# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.12
#
# 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
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_ra', [dirname(__file__)])
        except ImportError:
            import _ra
            return _ra
        if fp is not None:
            try:
                _mod = imp.load_module('_ra', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _ra = swig_import_helper()
    del swig_import_helper
else:
    import _ra
del version_info
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):
        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,)

def _copy_metadata_deep(value, old_value):
  """Copy all attributes of old_value into value, recursively traversing
  lists and dicts if needed."""
  if value is None or old_value is None or value is old_value: return
  
  if isinstance(value, dict):
    for k, v in value.iteritems():
      _copy_metadata_deep(v, old_value[k])
  elif isinstance(value, list):
    for v, old_v in zip(value, old_value):
      _copy_metadata_deep(v, old_v)
  else:
    try:
      value.__dict__.update(old_value.__dict__)
    except AttributeError:
      pass
      
def _assert_valid_deep(value):
  """Assert value's validity, recursively traversing lists and dicts."""
  if isinstance(value, dict):
    for v in value.itervalues():
      _assert_valid_deep(v)
  elif isinstance(value, list):
    for v in value:
      _assert_valid_deep(v)
  else:
    if hasattr(value, "assert_valid"):
      value.assert_valid()

import libsvn.core
import libsvn.delta

def svn_ra_version():
  """svn_ra_version() -> svn_version_t const *"""
  return _ra.svn_ra_version()
class svn_ra_reporter3_t:
    """Proxy of C svn_ra_reporter3_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_ra_reporter3_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_ra_reporter3_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["set_path"] = _ra.svn_ra_reporter3_t_set_path_set
    __swig_getmethods__["set_path"] = _ra.svn_ra_reporter3_t_set_path_get
    __swig_setmethods__["delete_path"] = _ra.svn_ra_reporter3_t_delete_path_set
    __swig_getmethods__["delete_path"] = _ra.svn_ra_reporter3_t_delete_path_get
    __swig_setmethods__["link_path"] = _ra.svn_ra_reporter3_t_link_path_set
    __swig_getmethods__["link_path"] = _ra.svn_ra_reporter3_t_link_path_get
    __swig_setmethods__["finish_report"] = _ra.svn_ra_reporter3_t_finish_report_set
    __swig_getmethods__["finish_report"] = _ra.svn_ra_reporter3_t_finish_report_get
    __swig_setmethods__["abort_report"] = _ra.svn_ra_reporter3_t_abort_report_set
    __swig_getmethods__["abort_report"] = _ra.svn_ra_reporter3_t_abort_report_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for TYPE"""
      import libsvn.core, weakref
      self.__dict__["_parent_pool"] = \
        parent_pool or libsvn.core.application_pool;
      if self.__dict__["_parent_pool"]:
        self.__dict__["_is_valid"] = weakref.ref(
          self.__dict__["_parent_pool"]._is_valid)

    def assert_valid(self):
      """Assert that this object is using valid pool memory"""
      if "_is_valid" in self.__dict__:
        assert self.__dict__["_is_valid"](), "Variable has already been deleted"

    def __getattr__(self, name):
      """Get an attribute from this object"""
      self.assert_valid()

      value = _swig_getattr(self, self.__class__, name)

      # If we got back a different object than we have, we need to copy all our
      # metadata into it, so that it looks identical
      members = self.__dict__.get("_members")
      if members is not None:
        _copy_metadata_deep(value, members.get(name))

      # Verify that the new object is good
      _assert_valid_deep(value)

      return value

    def __setattr__(self, name, value):
      """Set an attribute on this object"""
      self.assert_valid()

      # Save a copy of the object, so that the garbage
      # collector won't kill the object while it's in
      # SWIG-land
      self.__dict__.setdefault("_members",{})[name] = value

      return _swig_setattr(self, self.__class__, name, value)

    def set_path(self, *args):
      return svn_ra_reporter3_invoke_set_path(self, *args)

    def delete_path(self, *args):
      return svn_ra_reporter3_invoke_delete_path(self, *args)

    def link_path(self, *args):
      return svn_ra_reporter3_invoke_link_path(self, *args)

    def finish_report(self, *args):
      return svn_ra_reporter3_invoke_finish_report(self, *args)

    def abort_report(self, *args):
      return svn_ra_reporter3_invoke_abort_report(self, *args)

    def __init__(self): 
        """__init__(svn_ra_reporter3_t self) -> svn_ra_reporter3_t"""
        this = _ra.new_svn_ra_reporter3_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ra.delete_svn_ra_reporter3_t
    __del__ = lambda self : None;
svn_ra_reporter3_t_swigregister = _ra.svn_ra_reporter3_t_swigregister
svn_ra_reporter3_t_swigregister(svn_ra_reporter3_t)

class svn_ra_reporter2_t:
    """Proxy of C svn_ra_reporter2_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_ra_reporter2_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_ra_reporter2_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["set_path"] = _ra.svn_ra_reporter2_t_set_path_set
    __swig_getmethods__["set_path"] = _ra.svn_ra_reporter2_t_set_path_get
    __swig_setmethods__["delete_path"] = _ra.svn_ra_reporter2_t_delete_path_set
    __swig_getmethods__["delete_path"] = _ra.svn_ra_reporter2_t_delete_path_get
    __swig_setmethods__["link_path"] = _ra.svn_ra_reporter2_t_link_path_set
    __swig_getmethods__["link_path"] = _ra.svn_ra_reporter2_t_link_path_get
    __swig_setmethods__["finish_report"] = _ra.svn_ra_reporter2_t_finish_report_set
    __swig_getmethods__["finish_report"] = _ra.svn_ra_reporter2_t_finish_report_get
    __swig_setmethods__["abort_report"] = _ra.svn_ra_reporter2_t_abort_report_set
    __swig_getmethods__["abort_report"] = _ra.svn_ra_reporter2_t_abort_report_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for TYPE"""
      import libsvn.core, weakref
      self.__dict__["_parent_pool"] = \
        parent_pool or libsvn.core.application_pool;
      if self.__dict__["_parent_pool"]:
        self.__dict__["_is_valid"] = weakref.ref(
          self.__dict__["_parent_pool"]._is_valid)

    def assert_valid(self):
      """Assert that this object is using valid pool memory"""
      if "_is_valid" in self.__dict__:
        assert self.__dict__["_is_valid"](), "Variable has already been deleted"

    def __getattr__(self, name):
      """Get an attribute from this object"""
      self.assert_valid()

      value = _swig_getattr(self, self.__class__, name)

      # If we got back a different object than we have, we need to copy all our
      # metadata into it, so that it looks identical
      members = self.__dict__.get("_members")
      if members is not None:
        _copy_metadata_deep(value, members.get(name))

      # Verify that the new object is good
      _assert_valid_deep(value)

      return value

    def __setattr__(self, name, value):
      """Set an attribute on this object"""
      self.assert_valid()

      # Save a copy of the object, so that the garbage
      # collector won't kill the object while it's in
      # SWIG-land
      self.__dict__.setdefault("_members",{})[name] = value

      return _swig_setattr(self, self.__class__, name, value)

    def set_path(self, *args):
      return svn_ra_reporter2_invoke_set_path(self, *args)

    def delete_path(self, *args):
      return svn_ra_reporter2_invoke_delete_path(self, *args)

    def link_path(self, *args):
      return svn_ra_reporter2_invoke_link_path(self, *args)

    def finish_report(self, *args):
      return svn_ra_reporter2_invoke_finish_report(self, *args)

    def abort_report(self, *args):
      return svn_ra_reporter2_invoke_abort_report(self, *args)

    def __init__(self): 
        """__init__(svn_ra_reporter2_t self) -> svn_ra_reporter2_t"""
        this = _ra.new_svn_ra_reporter2_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ra.delete_svn_ra_reporter2_t
    __del__ = lambda self : None;
svn_ra_reporter2_t_swigregister = _ra.svn_ra_reporter2_t_swigregister
svn_ra_reporter2_t_swigregister(svn_ra_reporter2_t)

class svn_ra_reporter_t:
    """Proxy of C svn_ra_reporter_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_ra_reporter_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_ra_reporter_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["set_path"] = _ra.svn_ra_reporter_t_set_path_set
    __swig_getmethods__["set_path"] = _ra.svn_ra_reporter_t_set_path_get
    __swig_setmethods__["delete_path"] = _ra.svn_ra_reporter_t_delete_path_set
    __swig_getmethods__["delete_path"] = _ra.svn_ra_reporter_t_delete_path_get
    __swig_setmethods__["link_path"] = _ra.svn_ra_reporter_t_link_path_set
    __swig_getmethods__["link_path"] = _ra.svn_ra_reporter_t_link_path_get
    __swig_setmethods__["finish_report"] = _ra.svn_ra_reporter_t_finish_report_set
    __swig_getmethods__["finish_report"] = _ra.svn_ra_reporter_t_finish_report_get
    __swig_setmethods__["abort_report"] = _ra.svn_ra_reporter_t_abort_report_set
    __swig_getmethods__["abort_report"] = _ra.svn_ra_reporter_t_abort_report_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for TYPE"""
      import libsvn.core, weakref
      self.__dict__["_parent_pool"] = \
        parent_pool or libsvn.core.application_pool;
      if self.__dict__["_parent_pool"]:
        self.__dict__["_is_valid"] = weakref.ref(
          self.__dict__["_parent_pool"]._is_valid)

    def assert_valid(self):
      """Assert that this object is using valid pool memory"""
      if "_is_valid" in self.__dict__:
        assert self.__dict__["_is_valid"](), "Variable has already been deleted"

    def __getattr__(self, name):
      """Get an attribute from this object"""
      self.assert_valid()

      value = _swig_getattr(self, self.__class__, name)

      # If we got back a different object than we have, we need to copy all our
      # metadata into it, so that it looks identical
      members = self.__dict__.get("_members")
      if members is not None:
        _copy_metadata_deep(value, members.get(name))

      # Verify that the new object is good
      _assert_valid_deep(value)

      return value

    def __setattr__(self, name, value):
      """Set an attribute on this object"""
      self.assert_valid()

      # Save a copy of the object, so that the garbage
      # collector won't kill the object while it's in
      # SWIG-land
      self.__dict__.setdefault("_members",{})[name] = value

      return _swig_setattr(self, self.__class__, name, value)

    def set_path(self, *args):
      return svn_ra_reporter_invoke_set_path(self, *args)

    def delete_path(self, *args):
      return svn_ra_reporter_invoke_delete_path(self, *args)

    def link_path(self, *args):
      return svn_ra_reporter_invoke_link_path(self, *args)

    def finish_report(self, *args):
      return svn_ra_reporter_invoke_finish_report(self, *args)

    def abort_report(self, *args):
      return svn_ra_reporter_invoke_abort_report(self, *args)

    def __init__(self): 
        """__init__(svn_ra_reporter_t self) -> svn_ra_reporter_t"""
        this = _ra.new_svn_ra_reporter_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ra.delete_svn_ra_reporter_t
    __del__ = lambda self : None;
svn_ra_reporter_t_swigregister = _ra.svn_ra_reporter_t_swigregister
svn_ra_reporter_t_swigregister(svn_ra_reporter_t)

class svn_ra_callbacks2_t:
    """Proxy of C svn_ra_callbacks2_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_ra_callbacks2_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_ra_callbacks2_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["open_tmp_file"] = _ra.svn_ra_callbacks2_t_open_tmp_file_set
    __swig_getmethods__["open_tmp_file"] = _ra.svn_ra_callbacks2_t_open_tmp_file_get
    __swig_setmethods__["auth_baton"] = _ra.svn_ra_callbacks2_t_auth_baton_set
    __swig_getmethods__["auth_baton"] = _ra.svn_ra_callbacks2_t_auth_baton_get
    __swig_setmethods__["get_wc_prop"] = _ra.svn_ra_callbacks2_t_get_wc_prop_set
    __swig_getmethods__["get_wc_prop"] = _ra.svn_ra_callbacks2_t_get_wc_prop_get
    __swig_setmethods__["set_wc_prop"] = _ra.svn_ra_callbacks2_t_set_wc_prop_set
    __swig_getmethods__["set_wc_prop"] = _ra.svn_ra_callbacks2_t_set_wc_prop_get
    __swig_setmethods__["push_wc_prop"] = _ra.svn_ra_callbacks2_t_push_wc_prop_set
    __swig_getmethods__["push_wc_prop"] = _ra.svn_ra_callbacks2_t_push_wc_prop_get
    __swig_setmethods__["invalidate_wc_props"] = _ra.svn_ra_callbacks2_t_invalidate_wc_props_set
    __swig_getmethods__["invalidate_wc_props"] = _ra.svn_ra_callbacks2_t_invalidate_wc_props_get
    __swig_setmethods__["progress_func"] = _ra.svn_ra_callbacks2_t_progress_func_set
    __swig_getmethods__["progress_func"] = _ra.svn_ra_callbacks2_t_progress_func_get
    __swig_setmethods__["progress_baton"] = _ra.svn_ra_callbacks2_t_progress_baton_set
    __swig_getmethods__["progress_baton"] = _ra.svn_ra_callbacks2_t_progress_baton_get
    __swig_setmethods__["cancel_func"] = _ra.svn_ra_callbacks2_t_cancel_func_set
    __swig_getmethods__["cancel_func"] = _ra.svn_ra_callbacks2_t_cancel_func_get
    __swig_setmethods__["get_client_string"] = _ra.svn_ra_callbacks2_t_get_client_string_set
    __swig_getmethods__["get_client_string"] = _ra.svn_ra_callbacks2_t_get_client_string_get
    __swig_setmethods__["get_wc_contents"] = _ra.svn_ra_callbacks2_t_get_wc_contents_set
    __swig_getmethods__["get_wc_contents"] = _ra.svn_ra_callbacks2_t_get_wc_contents_get
    __swig_setmethods__["check_tunnel_func"] = _ra.svn_ra_callbacks2_t_check_tunnel_func_set
    __swig_getmethods__["check_tunnel_func"] = _ra.svn_ra_callbacks2_t_check_tunnel_func_get
    __swig_setmethods__["open_tunnel_func"] = _ra.svn_ra_callbacks2_t_open_tunnel_func_set
    __swig_getmethods__["open_tunnel_func"] = _ra.svn_ra_callbacks2_t_open_tunnel_func_get
    __swig_setmethods__["tunnel_baton"] = _ra.svn_ra_callbacks2_t_tunnel_baton_set
    __swig_getmethods__["tunnel_baton"] = _ra.svn_ra_callbacks2_t_tunnel_baton_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for TYPE"""
      import libsvn.core, weakref
      self.__dict__["_parent_pool"] = \
        parent_pool or libsvn.core.application_pool;
      if self.__dict__["_parent_pool"]:
        self.__dict__["_is_valid"] = weakref.ref(
          self.__dict__["_parent_pool"]._is_valid)

    def assert_valid(self):
      """Assert that this object is using valid pool memory"""
      if "_is_valid" in self.__dict__:
        assert self.__dict__["_is_valid"](), "Variable has already been deleted"

    def __getattr__(self, name):
      """Get an attribute from this object"""
      self.assert_valid()

      value = _swig_getattr(self, self.__class__, name)

      # If we got back a different object than we have, we need to copy all our
      # metadata into it, so that it looks identical
      members = self.__dict__.get("_members")
      if members is not None:
        _copy_metadata_deep(value, members.get(name))

      # Verify that the new object is good
      _assert_valid_deep(value)

      return value

    def __setattr__(self, name, value):
      """Set an attribute on this object"""
      self.assert_valid()

      # Save a copy of the object, so that the garbage
      # collector won't kill the object while it's in
      # SWIG-land
      self.__dict__.setdefault("_members",{})[name] = value

      return _swig_setattr(self, self.__class__, name, value)

    def open_tmp_file(self, *args):
      return svn_ra_callbacks2_invoke_open_tmp_file(self, *args)

    def __init__(self): 
        """__init__(svn_ra_callbacks2_t self) -> svn_ra_callbacks2_t"""
        this = _ra.new_svn_ra_callbacks2_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ra.delete_svn_ra_callbacks2_t
    __del__ = lambda self : None;
svn_ra_callbacks2_t_swigregister = _ra.svn_ra_callbacks2_t_swigregister
svn_ra_callbacks2_t_swigregister(svn_ra_callbacks2_t)

class svn_ra_callbacks_t:
    """Proxy of C svn_ra_callbacks_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_ra_callbacks_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_ra_callbacks_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["open_tmp_file"] = _ra.svn_ra_callbacks_t_open_tmp_file_set
    __swig_getmethods__["open_tmp_file"] = _ra.svn_ra_callbacks_t_open_tmp_file_get
    __swig_setmethods__["auth_baton"] = _ra.svn_ra_callbacks_t_auth_baton_set
    __swig_getmethods__["auth_baton"] = _ra.svn_ra_callbacks_t_auth_baton_get
    __swig_setmethods__["get_wc_prop"] = _ra.svn_ra_callbacks_t_get_wc_prop_set
    __swig_getmethods__["get_wc_prop"] = _ra.svn_ra_callbacks_t_get_wc_prop_get
    __swig_setmethods__["set_wc_prop"] = _ra.svn_ra_callbacks_t_set_wc_prop_set
    __swig_getmethods__["set_wc_prop"] = _ra.svn_ra_callbacks_t_set_wc_prop_get
    __swig_setmethods__["push_wc_prop"] = _ra.svn_ra_callbacks_t_push_wc_prop_set
    __swig_getmethods__["push_wc_prop"] = _ra.svn_ra_callbacks_t_push_wc_prop_get
    __swig_setmethods__["invalidate_wc_props"] = _ra.svn_ra_callbacks_t_invalidate_wc_props_set
    __swig_getmethods__["invalidate_wc_props"] = _ra.svn_ra_callbacks_t_invalidate_wc_props_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for TYPE"""
      import libsvn.core, weakref
      self.__dict__["_parent_pool"] = \
        parent_pool or libsvn.core.application_pool;
      if self.__dict__["_parent_pool"]:
        self.__dict__["_is_valid"] = weakref.ref(
          self.__dict__["_parent_pool"]._is_valid)

    def assert_valid(self):
      """Assert that this object is using valid pool memory"""
      if "_is_valid" in self.__dict__:
        assert self.__dict__["_is_valid"](), "Variable has already been deleted"

    def __getattr__(self, name):
      """Get an attribute from this object"""
      self.assert_valid()

      value = _swig_getattr(self, self.__class__, name)

      # If we got back a different object than we have, we need to copy all our
      # metadata into it, so that it looks identical
      members = self.__dict__.get("_members")
      if members is not None:
        _copy_metadata_deep(value, members.get(name))

      # Verify that the new object is good
      _assert_valid_deep(value)

      return value

    def __setattr__(self, name, value):
      """Set an attribute on this object"""
      self.assert_valid()

      # Save a copy of the object, so that the garbage
      # collector won't kill the object while it's in
      # SWIG-land
      self.__dict__.setdefault("_members",{})[name] = value

      return _swig_setattr(self, self.__class__, name, value)

    def open_tmp_file(self, *args):
      return svn_ra_callbacks_invoke_open_tmp_file(self, *args)

    def __init__(self): 
        """__init__(svn_ra_callbacks_t self) -> svn_ra_callbacks_t"""
        this = _ra.new_svn_ra_callbacks_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ra.delete_svn_ra_callbacks_t
    __del__ = lambda self : None;
svn_ra_callbacks_t_swigregister = _ra.svn_ra_callbacks_t_swigregister
svn_ra_callbacks_t_swigregister(svn_ra_callbacks_t)


def svn_ra_initialize(*args):
  """svn_ra_initialize(apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_initialize(*args)

def svn_ra_create_callbacks(*args):
  """svn_ra_create_callbacks(apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_create_callbacks(*args)

def svn_ra_open4(*args):
  """
    svn_ra_open4(char const * repos_URL, char const * uuid, svn_ra_callbacks2_t callbacks, apr_hash_t config, 
        apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_open4(*args)

def svn_ra_open3(*args):
  """
    svn_ra_open3(char const * repos_URL, char const * uuid, svn_ra_callbacks2_t callbacks, apr_hash_t config, 
        apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_open3(*args)

def svn_ra_open2(*args):
  """svn_ra_open2(char const * repos_URL, svn_ra_callbacks2_t callbacks, apr_hash_t config, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_open2(*args)

def svn_ra_open(*args):
  """
    svn_ra_open(char const * repos_URL, svn_ra_callbacks_t callbacks, void * callback_baton, apr_hash_t config, 
        apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_open(*args)

def svn_ra_reparent(*args):
  """svn_ra_reparent(svn_ra_session_t * ra_session, char const * url, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_reparent(*args)

def svn_ra_get_session_url(*args):
  """svn_ra_get_session_url(svn_ra_session_t * ra_session, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_get_session_url(*args)

def svn_ra_get_path_relative_to_session(*args):
  """svn_ra_get_path_relative_to_session(svn_ra_session_t * ra_session, char const * url, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_get_path_relative_to_session(*args)

def svn_ra_get_path_relative_to_root(*args):
  """svn_ra_get_path_relative_to_root(svn_ra_session_t * ra_session, char const * url, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_get_path_relative_to_root(*args)

def svn_ra_get_latest_revnum(*args):
  """svn_ra_get_latest_revnum(svn_ra_session_t * session, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_get_latest_revnum(*args)

def svn_ra_get_dated_revision(*args):
  """svn_ra_get_dated_revision(svn_ra_session_t * session, apr_time_t tm, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_get_dated_revision(*args)

def svn_ra_change_rev_prop2(*args):
  """
    svn_ra_change_rev_prop2(svn_ra_session_t * session, svn_revnum_t rev, char const * name, svn_string_t const *const * old_value_p, 
        svn_string_t const * value, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_change_rev_prop2(*args)

def svn_ra_change_rev_prop(*args):
  """
    svn_ra_change_rev_prop(svn_ra_session_t * session, svn_revnum_t rev, char const * name, svn_string_t const * value, 
        apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_change_rev_prop(*args)

def svn_ra_rev_proplist(*args):
  """svn_ra_rev_proplist(svn_ra_session_t * session, svn_revnum_t rev, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_rev_proplist(*args)

def svn_ra_rev_prop(*args):
  """svn_ra_rev_prop(svn_ra_session_t * session, svn_revnum_t rev, char const * name, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_rev_prop(*args)

def svn_ra_get_commit_editor3(*args):
  """
    svn_ra_get_commit_editor3(svn_ra_session_t * session, apr_hash_t revprop_table, svn_commit_callback2_t commit_callback, 
        apr_hash_t lock_tokens, svn_boolean_t keep_locks, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_get_commit_editor3(*args)

def svn_ra_get_commit_editor2(*args):
  """
    svn_ra_get_commit_editor2(svn_ra_session_t * session, char const * log_msg, svn_commit_callback2_t commit_callback, 
        apr_hash_t lock_tokens, svn_boolean_t keep_locks, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_get_commit_editor2(*args)

def svn_ra_get_commit_editor(*args):
  """
    svn_ra_get_commit_editor(svn_ra_session_t * session, char const * log_msg, svn_commit_callback_t callback, 
        apr_hash_t lock_tokens, svn_boolean_t keep_locks, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_get_commit_editor(*args)

def svn_ra_get_file(*args):
  """
    svn_ra_get_file(svn_ra_session_t * session, char const * path, svn_revnum_t revision, svn_stream_t * stream, 
        apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_get_file(*args)

def svn_ra_get_dir2(*args):
  """
    svn_ra_get_dir2(svn_ra_session_t * session, char const * path, svn_revnum_t revision, apr_uint32_t dirent_fields, 
        apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_get_dir2(*args)

def svn_ra_get_dir(*args):
  """svn_ra_get_dir(svn_ra_session_t * session, char const * path, svn_revnum_t revision, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_get_dir(*args)

def svn_ra_get_mergeinfo(*args):
  """
    svn_ra_get_mergeinfo(svn_ra_session_t * session, apr_array_header_t paths, svn_revnum_t revision, svn_mergeinfo_inheritance_t inherit, 
        svn_boolean_t include_descendants, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_get_mergeinfo(*args)

def svn_ra_do_update3(*args):
  """
    svn_ra_do_update3(svn_ra_session_t * session, svn_revnum_t revision_to_update_to, char const * update_target, 
        svn_depth_t depth, svn_boolean_t send_copyfrom_args, svn_boolean_t ignore_ancestry, 
        svn_delta_editor_t update_editor, void * update_baton, 
        apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t
    """
  return _ra.svn_ra_do_update3(*args)

def svn_ra_do_update2(*args):
  """
    svn_ra_do_update2(svn_ra_session_t * session, svn_revnum_t revision_to_update_to, char const * update_target, 
        svn_depth_t depth, svn_boolean_t send_copyfrom_args, svn_delta_editor_t update_editor, 
        void * update_baton, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_do_update2(*args)

def svn_ra_do_update(*args):
  """
    svn_ra_do_update(svn_ra_session_t * session, svn_revnum_t revision_to_update_to, char const * update_target, 
        svn_boolean_t recurse, svn_delta_editor_t update_editor, void * update_baton, 
        apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_do_update(*args)

def svn_ra_do_switch3(*args):
  """
    svn_ra_do_switch3(svn_ra_session_t * session, svn_revnum_t revision_to_switch_to, char const * switch_target, 
        svn_depth_t depth, char const * switch_url, svn_boolean_t send_copyfrom_args, 
        svn_boolean_t ignore_ancestry, svn_delta_editor_t switch_editor, 
        void * switch_baton, apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t
    """
  return _ra.svn_ra_do_switch3(*args)

def svn_ra_do_switch2(*args):
  """
    svn_ra_do_switch2(svn_ra_session_t * session, svn_revnum_t revision_to_switch_to, char const * switch_target, 
        svn_depth_t depth, char const * switch_url, svn_delta_editor_t switch_editor, 
        void * switch_baton, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_do_switch2(*args)

def svn_ra_do_switch(*args):
  """
    svn_ra_do_switch(svn_ra_session_t * session, svn_revnum_t revision_to_switch_to, char const * switch_target, 
        svn_boolean_t recurse, char const * switch_url, svn_delta_editor_t switch_editor, 
        void * switch_baton, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_do_switch(*args)

def svn_ra_do_status2(*args):
  """
    svn_ra_do_status2(svn_ra_session_t * session, char const * status_target, svn_revnum_t revision, svn_depth_t depth, 
        svn_delta_editor_t status_editor, void * status_baton, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_do_status2(*args)

def svn_ra_do_status(*args):
  """
    svn_ra_do_status(svn_ra_session_t * session, char const * status_target, svn_revnum_t revision, svn_boolean_t recurse, 
        svn_delta_editor_t status_editor, void * status_baton, 
        apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_do_status(*args)

def svn_ra_do_diff3(*args):
  """
    svn_ra_do_diff3(svn_ra_session_t * session, svn_revnum_t revision, char const * diff_target, svn_depth_t depth, 
        svn_boolean_t ignore_ancestry, svn_boolean_t text_deltas, char const * versus_url, 
        svn_delta_editor_t diff_editor, void * diff_baton, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_do_diff3(*args)

def svn_ra_do_diff2(*args):
  """
    svn_ra_do_diff2(svn_ra_session_t * session, svn_revnum_t revision, char const * diff_target, svn_boolean_t recurse, 
        svn_boolean_t ignore_ancestry, svn_boolean_t text_deltas, 
        char const * versus_url, svn_delta_editor_t diff_editor, void * diff_baton, 
        apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_do_diff2(*args)

def svn_ra_do_diff(*args):
  """
    svn_ra_do_diff(svn_ra_session_t * session, svn_revnum_t revision, char const * diff_target, svn_boolean_t recurse, 
        svn_boolean_t ignore_ancestry, char const * versus_url, 
        svn_delta_editor_t diff_editor, void * diff_baton, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_do_diff(*args)

def svn_ra_get_log2(*args):
  """
    svn_ra_get_log2(svn_ra_session_t * session, apr_array_header_t paths, svn_revnum_t start, svn_revnum_t end, 
        int limit, svn_boolean_t discover_changed_paths, svn_boolean_t strict_node_history, 
        svn_boolean_t include_merged_revisions, apr_array_header_t revprops, 
        svn_log_entry_receiver_t receiver, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_get_log2(*args)

def svn_ra_get_log(*args):
  """
    svn_ra_get_log(svn_ra_session_t * session, apr_array_header_t paths, svn_revnum_t start, svn_revnum_t end, 
        int limit, svn_boolean_t discover_changed_paths, svn_boolean_t strict_node_history, 
        svn_log_message_receiver_t receiver, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_get_log(*args)

def svn_ra_check_path(*args):
  """svn_ra_check_path(svn_ra_session_t * session, char const * path, svn_revnum_t revision, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_check_path(*args)

def svn_ra_stat(*args):
  """svn_ra_stat(svn_ra_session_t * session, char const * path, svn_revnum_t revision, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_stat(*args)

def svn_ra_get_uuid2(*args):
  """svn_ra_get_uuid2(svn_ra_session_t * session, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_get_uuid2(*args)

def svn_ra_get_uuid(*args):
  """svn_ra_get_uuid(svn_ra_session_t * session, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_get_uuid(*args)

def svn_ra_get_repos_root2(*args):
  """svn_ra_get_repos_root2(svn_ra_session_t * session, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_get_repos_root2(*args)

def svn_ra_get_repos_root(*args):
  """svn_ra_get_repos_root(svn_ra_session_t * session, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_get_repos_root(*args)

def svn_ra_get_locations(*args):
  """
    svn_ra_get_locations(svn_ra_session_t * session, char const * path, svn_revnum_t peg_revision, apr_array_header_t location_revisions, 
        apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_get_locations(*args)

def svn_ra_get_location_segments(*args):
  """
    svn_ra_get_location_segments(svn_ra_session_t * session, char const * path, svn_revnum_t peg_revision, svn_revnum_t start_rev, 
        svn_revnum_t end_rev, svn_location_segment_receiver_t receiver, 
        apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_get_location_segments(*args)

def svn_ra_get_file_revs2(*args):
  """
    svn_ra_get_file_revs2(svn_ra_session_t * session, char const * path, svn_revnum_t start, svn_revnum_t end, 
        svn_boolean_t include_merged_revisions, svn_file_rev_handler_t handler, 
        void * handler_baton, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_get_file_revs2(*args)

def svn_ra_get_file_revs(*args):
  """
    svn_ra_get_file_revs(svn_ra_session_t * session, char const * path, svn_revnum_t start, svn_revnum_t end, 
        svn_ra_file_rev_handler_t handler, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_get_file_revs(*args)

def svn_ra_lock(*args):
  """
    svn_ra_lock(svn_ra_session_t * session, apr_hash_t path_revs, char const * comment, svn_boolean_t steal_lock, 
        svn_ra_lock_callback_t lock_func, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_lock(*args)

def svn_ra_unlock(*args):
  """
    svn_ra_unlock(svn_ra_session_t * session, apr_hash_t path_tokens, svn_boolean_t break_lock, svn_ra_lock_callback_t lock_func, 
        apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_unlock(*args)

def svn_ra_get_lock(*args):
  """svn_ra_get_lock(svn_ra_session_t * session, char const * path, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_get_lock(*args)

def svn_ra_get_locks2(*args):
  """svn_ra_get_locks2(svn_ra_session_t * session, char const * path, svn_depth_t depth, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_get_locks2(*args)

def svn_ra_get_locks(*args):
  """svn_ra_get_locks(svn_ra_session_t * session, char const * path, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_get_locks(*args)

def svn_ra_replay_range(*args):
  """
    svn_ra_replay_range(svn_ra_session_t * session, svn_revnum_t start_revision, svn_revnum_t end_revision, 
        svn_revnum_t low_water_mark, svn_boolean_t send_deltas, svn_ra_replay_revstart_callback_t revstart_func, 
        svn_ra_replay_revfinish_callback_t revfinish_func, 
        void * replay_baton, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_replay_range(*args)

def svn_ra_replay(*args):
  """
    svn_ra_replay(svn_ra_session_t * session, svn_revnum_t revision, svn_revnum_t low_water_mark, svn_boolean_t send_deltas, 
        svn_delta_editor_t editor, void * edit_baton, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_replay(*args)

def svn_ra_get_deleted_rev(*args):
  """
    svn_ra_get_deleted_rev(svn_ra_session_t * session, char const * path, svn_revnum_t peg_revision, svn_revnum_t end_revision, 
        apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_get_deleted_rev(*args)

def svn_ra_get_inherited_props(*args):
  """
    svn_ra_get_inherited_props(svn_ra_session_t * session, char const * path, svn_revnum_t revision, apr_pool_t result_pool, 
        apr_pool_t scratch_pool) -> svn_error_t
    """
  return _ra.svn_ra_get_inherited_props(*args)

def svn_ra_has_capability(*args):
  """svn_ra_has_capability(svn_ra_session_t * session, char const * capability, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_has_capability(*args)
SVN_RA_CAPABILITY_DEPTH = _ra.SVN_RA_CAPABILITY_DEPTH
SVN_RA_CAPABILITY_MERGEINFO = _ra.SVN_RA_CAPABILITY_MERGEINFO
SVN_RA_CAPABILITY_LOG_REVPROPS = _ra.SVN_RA_CAPABILITY_LOG_REVPROPS
SVN_RA_CAPABILITY_PARTIAL_REPLAY = _ra.SVN_RA_CAPABILITY_PARTIAL_REPLAY
SVN_RA_CAPABILITY_COMMIT_REVPROPS = _ra.SVN_RA_CAPABILITY_COMMIT_REVPROPS
SVN_RA_CAPABILITY_ATOMIC_REVPROPS = _ra.SVN_RA_CAPABILITY_ATOMIC_REVPROPS
SVN_RA_CAPABILITY_INHERITED_PROPS = _ra.SVN_RA_CAPABILITY_INHERITED_PROPS
SVN_RA_CAPABILITY_EPHEMERAL_TXNPROPS = _ra.SVN_RA_CAPABILITY_EPHEMERAL_TXNPROPS
SVN_RA_CAPABILITY_GET_FILE_REVS_REVERSE = _ra.SVN_RA_CAPABILITY_GET_FILE_REVS_REVERSE

def svn_ra_print_modules(*args):
  """svn_ra_print_modules(svn_stringbuf_t * output, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_print_modules(*args)

def svn_ra_print_ra_libraries(*args):
  """svn_ra_print_ra_libraries(void * ra_baton, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_print_ra_libraries(*args)
class svn_ra_plugin_t:
    """Proxy of C svn_ra_plugin_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_ra_plugin_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_ra_plugin_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["name"] = _ra.svn_ra_plugin_t_name_set
    __swig_getmethods__["name"] = _ra.svn_ra_plugin_t_name_get
    __swig_setmethods__["description"] = _ra.svn_ra_plugin_t_description_set
    __swig_getmethods__["description"] = _ra.svn_ra_plugin_t_description_get
    __swig_setmethods__["open"] = _ra.svn_ra_plugin_t_open_set
    __swig_getmethods__["open"] = _ra.svn_ra_plugin_t_open_get
    __swig_setmethods__["get_latest_revnum"] = _ra.svn_ra_plugin_t_get_latest_revnum_set
    __swig_getmethods__["get_latest_revnum"] = _ra.svn_ra_plugin_t_get_latest_revnum_get
    __swig_setmethods__["get_dated_revision"] = _ra.svn_ra_plugin_t_get_dated_revision_set
    __swig_getmethods__["get_dated_revision"] = _ra.svn_ra_plugin_t_get_dated_revision_get
    __swig_setmethods__["change_rev_prop"] = _ra.svn_ra_plugin_t_change_rev_prop_set
    __swig_getmethods__["change_rev_prop"] = _ra.svn_ra_plugin_t_change_rev_prop_get
    __swig_setmethods__["rev_proplist"] = _ra.svn_ra_plugin_t_rev_proplist_set
    __swig_getmethods__["rev_proplist"] = _ra.svn_ra_plugin_t_rev_proplist_get
    __swig_setmethods__["rev_prop"] = _ra.svn_ra_plugin_t_rev_prop_set
    __swig_getmethods__["rev_prop"] = _ra.svn_ra_plugin_t_rev_prop_get
    __swig_setmethods__["get_commit_editor"] = _ra.svn_ra_plugin_t_get_commit_editor_set
    __swig_getmethods__["get_commit_editor"] = _ra.svn_ra_plugin_t_get_commit_editor_get
    __swig_setmethods__["get_file"] = _ra.svn_ra_plugin_t_get_file_set
    __swig_getmethods__["get_file"] = _ra.svn_ra_plugin_t_get_file_get
    __swig_setmethods__["get_dir"] = _ra.svn_ra_plugin_t_get_dir_set
    __swig_getmethods__["get_dir"] = _ra.svn_ra_plugin_t_get_dir_get
    __swig_setmethods__["do_update"] = _ra.svn_ra_plugin_t_do_update_set
    __swig_getmethods__["do_update"] = _ra.svn_ra_plugin_t_do_update_get
    __swig_setmethods__["do_switch"] = _ra.svn_ra_plugin_t_do_switch_set
    __swig_getmethods__["do_switch"] = _ra.svn_ra_plugin_t_do_switch_get
    __swig_setmethods__["do_status"] = _ra.svn_ra_plugin_t_do_status_set
    __swig_getmethods__["do_status"] = _ra.svn_ra_plugin_t_do_status_get
    __swig_setmethods__["do_diff"] = _ra.svn_ra_plugin_t_do_diff_set
    __swig_getmethods__["do_diff"] = _ra.svn_ra_plugin_t_do_diff_get
    __swig_setmethods__["get_log"] = _ra.svn_ra_plugin_t_get_log_set
    __swig_getmethods__["get_log"] = _ra.svn_ra_plugin_t_get_log_get
    __swig_setmethods__["check_path"] = _ra.svn_ra_plugin_t_check_path_set
    __swig_getmethods__["check_path"] = _ra.svn_ra_plugin_t_check_path_get
    __swig_setmethods__["get_uuid"] = _ra.svn_ra_plugin_t_get_uuid_set
    __swig_getmethods__["get_uuid"] = _ra.svn_ra_plugin_t_get_uuid_get
    __swig_setmethods__["get_repos_root"] = _ra.svn_ra_plugin_t_get_repos_root_set
    __swig_getmethods__["get_repos_root"] = _ra.svn_ra_plugin_t_get_repos_root_get
    __swig_setmethods__["get_locations"] = _ra.svn_ra_plugin_t_get_locations_set
    __swig_getmethods__["get_locations"] = _ra.svn_ra_plugin_t_get_locations_get
    __swig_setmethods__["get_file_revs"] = _ra.svn_ra_plugin_t_get_file_revs_set
    __swig_getmethods__["get_file_revs"] = _ra.svn_ra_plugin_t_get_file_revs_get
    __swig_setmethods__["get_version"] = _ra.svn_ra_plugin_t_get_version_set
    __swig_getmethods__["get_version"] = _ra.svn_ra_plugin_t_get_version_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for TYPE"""
      import libsvn.core, weakref
      self.__dict__["_parent_pool"] = \
        parent_pool or libsvn.core.application_pool;
      if self.__dict__["_parent_pool"]:
        self.__dict__["_is_valid"] = weakref.ref(
          self.__dict__["_parent_pool"]._is_valid)

    def assert_valid(self):
      """Assert that this object is using valid pool memory"""
      if "_is_valid" in self.__dict__:
        assert self.__dict__["_is_valid"](), "Variable has already been deleted"

    def __getattr__(self, name):
      """Get an attribute from this object"""
      self.assert_valid()

      value = _swig_getattr(self, self.__class__, name)

      # If we got back a different object than we have, we need to copy all our
      # metadata into it, so that it looks identical
      members = self.__dict__.get("_members")
      if members is not None:
        _copy_metadata_deep(value, members.get(name))

      # Verify that the new object is good
      _assert_valid_deep(value)

      return value

    def __setattr__(self, name, value):
      """Set an attribute on this object"""
      self.assert_valid()

      # Save a copy of the object, so that the garbage
      # collector won't kill the object while it's in
      # SWIG-land
      self.__dict__.setdefault("_members",{})[name] = value

      return _swig_setattr(self, self.__class__, name, value)

    def open(self, *args):
      return svn_ra_plugin_invoke_open(self, *args)

    def get_latest_revnum(self, *args):
      return svn_ra_plugin_invoke_get_latest_revnum(self, *args)

    def get_dated_revision(self, *args):
      return svn_ra_plugin_invoke_get_dated_revision(self, *args)

    def change_rev_prop(self, *args):
      return svn_ra_plugin_invoke_change_rev_prop(self, *args)

    def rev_proplist(self, *args):
      return svn_ra_plugin_invoke_rev_proplist(self, *args)

    def rev_prop(self, *args):
      return svn_ra_plugin_invoke_rev_prop(self, *args)

    def get_commit_editor(self, *args):
      return svn_ra_plugin_invoke_get_commit_editor(self, *args)

    def get_file(self, *args):
      return svn_ra_plugin_invoke_get_file(self, *args)

    def get_dir(self, *args):
      return svn_ra_plugin_invoke_get_dir(self, *args)

    def do_update(self, *args):
      return svn_ra_plugin_invoke_do_update(self, *args)

    def do_switch(self, *args):
      return svn_ra_plugin_invoke_do_switch(self, *args)

    def do_status(self, *args):
      return svn_ra_plugin_invoke_do_status(self, *args)

    def do_diff(self, *args):
      return svn_ra_plugin_invoke_do_diff(self, *args)

    def get_log(self, *args):
      return svn_ra_plugin_invoke_get_log(self, *args)

    def check_path(self, *args):
      return svn_ra_plugin_invoke_check_path(self, *args)

    def get_uuid(self, *args):
      return svn_ra_plugin_invoke_get_uuid(self, *args)

    def get_repos_root(self, *args):
      return svn_ra_plugin_invoke_get_repos_root(self, *args)

    def get_locations(self, *args):
      return svn_ra_plugin_invoke_get_locations(self, *args)

    def get_file_revs(self, *args):
      return svn_ra_plugin_invoke_get_file_revs(self, *args)

    def get_version(self, *args):
      return svn_ra_plugin_invoke_get_version(self, *args)

    def __init__(self): 
        """__init__(svn_ra_plugin_t self) -> svn_ra_plugin_t"""
        this = _ra.new_svn_ra_plugin_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ra.delete_svn_ra_plugin_t
    __del__ = lambda self : None;
svn_ra_plugin_t_swigregister = _ra.svn_ra_plugin_t_swigregister
svn_ra_plugin_t_swigregister(svn_ra_plugin_t)

SVN_RA_ABI_VERSION = _ra.SVN_RA_ABI_VERSION

def svn_ra_init_ra_libs(*args):
  """svn_ra_init_ra_libs(apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_init_ra_libs(*args)

def svn_ra_get_ra_library(*args):
  """svn_ra_get_ra_library(void * ra_baton, char const * url, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_get_ra_library(*args)
class svn_ra_session_t:
    """Proxy of C svn_ra_session_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_ra_session_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_ra_session_t, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for TYPE"""
      import libsvn.core, weakref
      self.__dict__["_parent_pool"] = \
        parent_pool or libsvn.core.application_pool;
      if self.__dict__["_parent_pool"]:
        self.__dict__["_is_valid"] = weakref.ref(
          self.__dict__["_parent_pool"]._is_valid)

    def assert_valid(self):
      """Assert that this object is using valid pool memory"""
      if "_is_valid" in self.__dict__:
        assert self.__dict__["_is_valid"](), "Variable has already been deleted"

    def __getattr__(self, name):
      """Get an attribute from this object"""
      self.assert_valid()

      value = _swig_getattr(self, self.__class__, name)

      # If we got back a different object than we have, we need to copy all our
      # metadata into it, so that it looks identical
      members = self.__dict__.get("_members")
      if members is not None:
        _copy_metadata_deep(value, members.get(name))

      # Verify that the new object is good
      _assert_valid_deep(value)

      return value

    def __setattr__(self, name, value):
      """Set an attribute on this object"""
      self.assert_valid()

      # Save a copy of the object, so that the garbage
      # collector won't kill the object while it's in
      # SWIG-land
      self.__dict__.setdefault("_members",{})[name] = value

      return _swig_setattr(self, self.__class__, name, value)

svn_ra_session_t_swigregister = _ra.svn_ra_session_t_swigregister
svn_ra_session_t_swigregister(svn_ra_session_t)


def svn_ra_reporter3_invoke_set_path(*args):
  """
    svn_ra_reporter3_invoke_set_path(svn_ra_reporter3_t _obj, void * report_baton, char const * path, svn_revnum_t revision, 
        svn_depth_t depth, svn_boolean_t start_empty, char const * lock_token, 
        apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_reporter3_invoke_set_path(*args)

def svn_ra_reporter3_invoke_delete_path(*args):
  """svn_ra_reporter3_invoke_delete_path(svn_ra_reporter3_t _obj, void * report_baton, char const * path, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_reporter3_invoke_delete_path(*args)

def svn_ra_reporter3_invoke_link_path(*args):
  """
    svn_ra_reporter3_invoke_link_path(svn_ra_reporter3_t _obj, void * report_baton, char const * path, char const * url, 
        svn_revnum_t revision, svn_depth_t depth, svn_boolean_t start_empty, char const * lock_token, 
        apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_reporter3_invoke_link_path(*args)

def svn_ra_reporter3_invoke_finish_report(*args):
  """svn_ra_reporter3_invoke_finish_report(svn_ra_reporter3_t _obj, void * report_baton, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_reporter3_invoke_finish_report(*args)

def svn_ra_reporter3_invoke_abort_report(*args):
  """svn_ra_reporter3_invoke_abort_report(svn_ra_reporter3_t _obj, void * report_baton, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_reporter3_invoke_abort_report(*args)

def svn_ra_reporter2_invoke_set_path(*args):
  """
    svn_ra_reporter2_invoke_set_path(svn_ra_reporter2_t _obj, void * report_baton, char const * path, svn_revnum_t revision, 
        svn_boolean_t start_empty, char const * lock_token, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_reporter2_invoke_set_path(*args)

def svn_ra_reporter2_invoke_delete_path(*args):
  """svn_ra_reporter2_invoke_delete_path(svn_ra_reporter2_t _obj, void * report_baton, char const * path, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_reporter2_invoke_delete_path(*args)

def svn_ra_reporter2_invoke_link_path(*args):
  """
    svn_ra_reporter2_invoke_link_path(svn_ra_reporter2_t _obj, void * report_baton, char const * path, char const * url, 
        svn_revnum_t revision, svn_boolean_t start_empty, char const * lock_token, 
        apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_reporter2_invoke_link_path(*args)

def svn_ra_reporter2_invoke_finish_report(*args):
  """svn_ra_reporter2_invoke_finish_report(svn_ra_reporter2_t _obj, void * report_baton, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_reporter2_invoke_finish_report(*args)

def svn_ra_reporter2_invoke_abort_report(*args):
  """svn_ra_reporter2_invoke_abort_report(svn_ra_reporter2_t _obj, void * report_baton, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_reporter2_invoke_abort_report(*args)

def svn_ra_reporter_invoke_set_path(*args):
  """
    svn_ra_reporter_invoke_set_path(svn_ra_reporter_t _obj, void * report_baton, char const * path, svn_revnum_t revision, 
        svn_boolean_t start_empty, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_reporter_invoke_set_path(*args)

def svn_ra_reporter_invoke_delete_path(*args):
  """svn_ra_reporter_invoke_delete_path(svn_ra_reporter_t _obj, void * report_baton, char const * path, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_reporter_invoke_delete_path(*args)

def svn_ra_reporter_invoke_link_path(*args):
  """
    svn_ra_reporter_invoke_link_path(svn_ra_reporter_t _obj, void * report_baton, char const * path, char const * url, 
        svn_revnum_t revision, svn_boolean_t start_empty, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_reporter_invoke_link_path(*args)

def svn_ra_reporter_invoke_finish_report(*args):
  """svn_ra_reporter_invoke_finish_report(svn_ra_reporter_t _obj, void * report_baton, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_reporter_invoke_finish_report(*args)

def svn_ra_reporter_invoke_abort_report(*args):
  """svn_ra_reporter_invoke_abort_report(svn_ra_reporter_t _obj, void * report_baton, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_reporter_invoke_abort_report(*args)

def svn_ra_callbacks2_invoke_open_tmp_file(*args):
  """svn_ra_callbacks2_invoke_open_tmp_file(svn_ra_callbacks2_t _obj, void * callback_baton, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_callbacks2_invoke_open_tmp_file(*args)

def svn_ra_callbacks_invoke_open_tmp_file(*args):
  """svn_ra_callbacks_invoke_open_tmp_file(svn_ra_callbacks_t _obj, void * callback_baton, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_callbacks_invoke_open_tmp_file(*args)

def svn_ra_plugin_invoke_open(*args):
  """
    svn_ra_plugin_invoke_open(svn_ra_plugin_t _obj, char const * repos_URL, svn_ra_callbacks_t callbacks, void * callback_baton, 
        apr_hash_t config, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_plugin_invoke_open(*args)

def svn_ra_plugin_invoke_get_latest_revnum(*args):
  """svn_ra_plugin_invoke_get_latest_revnum(svn_ra_plugin_t _obj, void * session_baton, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_plugin_invoke_get_latest_revnum(*args)

def svn_ra_plugin_invoke_get_dated_revision(*args):
  """svn_ra_plugin_invoke_get_dated_revision(svn_ra_plugin_t _obj, void * session_baton, apr_time_t tm, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_plugin_invoke_get_dated_revision(*args)

def svn_ra_plugin_invoke_change_rev_prop(*args):
  """
    svn_ra_plugin_invoke_change_rev_prop(svn_ra_plugin_t _obj, void * session_baton, svn_revnum_t rev, char const * name, 
        svn_string_t const * value, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_plugin_invoke_change_rev_prop(*args)

def svn_ra_plugin_invoke_rev_proplist(*args):
  """svn_ra_plugin_invoke_rev_proplist(svn_ra_plugin_t _obj, void * session_baton, svn_revnum_t rev, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_plugin_invoke_rev_proplist(*args)

def svn_ra_plugin_invoke_rev_prop(*args):
  """
    svn_ra_plugin_invoke_rev_prop(svn_ra_plugin_t _obj, void * session_baton, svn_revnum_t rev, char const * name, 
        apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_plugin_invoke_rev_prop(*args)

def svn_ra_plugin_invoke_get_commit_editor(*args):
  """
    svn_ra_plugin_invoke_get_commit_editor(svn_ra_plugin_t _obj, void * session_baton, char const * log_msg, svn_commit_callback_t callback, 
        apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_plugin_invoke_get_commit_editor(*args)

def svn_ra_plugin_invoke_get_file(*args):
  """
    svn_ra_plugin_invoke_get_file(svn_ra_plugin_t _obj, void * session_baton, char const * path, svn_revnum_t revision, 
        svn_stream_t * stream, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_plugin_invoke_get_file(*args)

def svn_ra_plugin_invoke_get_dir(*args):
  """
    svn_ra_plugin_invoke_get_dir(svn_ra_plugin_t _obj, void * session_baton, char const * path, svn_revnum_t revision, 
        apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_plugin_invoke_get_dir(*args)

def svn_ra_plugin_invoke_do_update(*args):
  """
    svn_ra_plugin_invoke_do_update(svn_ra_plugin_t _obj, void * session_baton, svn_revnum_t revision_to_update_to, char const * update_target, 
        svn_boolean_t recurse, svn_delta_editor_t update_editor, 
        void * update_baton, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_plugin_invoke_do_update(*args)

def svn_ra_plugin_invoke_do_switch(*args):
  """
    svn_ra_plugin_invoke_do_switch(svn_ra_plugin_t _obj, void * session_baton, svn_revnum_t revision_to_switch_to, char const * switch_target, 
        svn_boolean_t recurse, char const * switch_url, 
        svn_delta_editor_t switch_editor, void * switch_baton, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_plugin_invoke_do_switch(*args)

def svn_ra_plugin_invoke_do_status(*args):
  """
    svn_ra_plugin_invoke_do_status(svn_ra_plugin_t _obj, void * session_baton, char const * status_target, svn_revnum_t revision, 
        svn_boolean_t recurse, svn_delta_editor_t status_editor, void * status_baton, 
        apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_plugin_invoke_do_status(*args)

def svn_ra_plugin_invoke_do_diff(*args):
  """
    svn_ra_plugin_invoke_do_diff(svn_ra_plugin_t _obj, void * session_baton, svn_revnum_t revision, char const * diff_target, 
        svn_boolean_t recurse, svn_boolean_t ignore_ancestry, char const * versus_url, 
        svn_delta_editor_t diff_editor, void * diff_baton, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_plugin_invoke_do_diff(*args)

def svn_ra_plugin_invoke_get_log(*args):
  """
    svn_ra_plugin_invoke_get_log(svn_ra_plugin_t _obj, void * session_baton, apr_array_header_t paths, svn_revnum_t start, 
        svn_revnum_t end, svn_boolean_t discover_changed_paths, svn_boolean_t strict_node_history, 
        svn_log_message_receiver_t receiver, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_plugin_invoke_get_log(*args)

def svn_ra_plugin_invoke_check_path(*args):
  """
    svn_ra_plugin_invoke_check_path(svn_ra_plugin_t _obj, void * session_baton, char const * path, svn_revnum_t revision, 
        apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_plugin_invoke_check_path(*args)

def svn_ra_plugin_invoke_get_uuid(*args):
  """svn_ra_plugin_invoke_get_uuid(svn_ra_plugin_t _obj, void * session_baton, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_plugin_invoke_get_uuid(*args)

def svn_ra_plugin_invoke_get_repos_root(*args):
  """svn_ra_plugin_invoke_get_repos_root(svn_ra_plugin_t _obj, void * session_baton, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_plugin_invoke_get_repos_root(*args)

def svn_ra_plugin_invoke_get_locations(*args):
  """
    svn_ra_plugin_invoke_get_locations(svn_ra_plugin_t _obj, void * session_baton, char const * path, svn_revnum_t peg_revision, 
        apr_array_header_t location_revisions, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_plugin_invoke_get_locations(*args)

def svn_ra_plugin_invoke_get_file_revs(*args):
  """
    svn_ra_plugin_invoke_get_file_revs(svn_ra_plugin_t _obj, void * session_baton, char const * path, svn_revnum_t start, 
        svn_revnum_t end, svn_ra_file_rev_handler_t handler, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_plugin_invoke_get_file_revs(*args)

def svn_ra_plugin_invoke_get_version(*args):
  """svn_ra_plugin_invoke_get_version(svn_ra_plugin_t _obj) -> svn_version_t const *"""
  return _ra.svn_ra_plugin_invoke_get_version(*args)

def svn_ra_invoke_get_wc_prop_func(*args):
  """
    svn_ra_invoke_get_wc_prop_func(svn_ra_get_wc_prop_func_t _obj, void * baton, char const * path, char const * name, 
        apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_invoke_get_wc_prop_func(*args)

def svn_ra_invoke_set_wc_prop_func(*args):
  """
    svn_ra_invoke_set_wc_prop_func(svn_ra_set_wc_prop_func_t _obj, void * baton, char const * path, char const * name, 
        svn_string_t const * value, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_invoke_set_wc_prop_func(*args)

def svn_ra_invoke_push_wc_prop_func(*args):
  """
    svn_ra_invoke_push_wc_prop_func(svn_ra_push_wc_prop_func_t _obj, void * baton, char const * path, char const * name, 
        svn_string_t const * value, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_invoke_push_wc_prop_func(*args)

def svn_ra_invoke_invalidate_wc_props_func(*args):
  """
    svn_ra_invoke_invalidate_wc_props_func(svn_ra_invalidate_wc_props_func_t _obj, void * baton, char const * path, char const * name, 
        apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_invoke_invalidate_wc_props_func(*args)

def svn_ra_invoke_get_wc_contents_func(*args):
  """svn_ra_invoke_get_wc_contents_func(svn_ra_get_wc_contents_func_t _obj, void * baton, svn_checksum_t checksum, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_invoke_get_wc_contents_func(*args)

def svn_ra_invoke_get_latest_revnum_func(*args):
  """svn_ra_invoke_get_latest_revnum_func(svn_ra_get_latest_revnum_func_t _obj, void * session_baton) -> svn_error_t"""
  return _ra.svn_ra_invoke_get_latest_revnum_func(*args)

def svn_ra_invoke_get_client_string_func(*args):
  """svn_ra_invoke_get_client_string_func(svn_ra_get_client_string_func_t _obj, void * baton, apr_pool_t pool) -> svn_error_t"""
  return _ra.svn_ra_invoke_get_client_string_func(*args)

def svn_ra_invoke_file_rev_handler(*args):
  """
    svn_ra_invoke_file_rev_handler(svn_ra_file_rev_handler_t _obj, void * baton, char const * path, svn_revnum_t rev, 
        apr_hash_t rev_props, apr_array_header_t prop_diffs, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_invoke_file_rev_handler(*args)

def svn_ra_invoke_lock_callback(*args):
  """
    svn_ra_invoke_lock_callback(svn_ra_lock_callback_t _obj, void * baton, char const * path, svn_boolean_t do_lock, 
        svn_lock_t lock, svn_error_t ra_err, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_invoke_lock_callback(*args)

def svn_ra_invoke_progress_notify_func(*args):
  """
    svn_ra_invoke_progress_notify_func(svn_ra_progress_notify_func_t _obj, apr_off_t progress, apr_off_t total, void * baton, 
        apr_pool_t pool)
    """
  return _ra.svn_ra_invoke_progress_notify_func(*args)

def svn_ra_invoke_replay_revstart_callback(*args):
  """
    svn_ra_invoke_replay_revstart_callback(svn_ra_replay_revstart_callback_t _obj, svn_revnum_t revision, void * replay_baton, 
        apr_hash_t rev_props, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_invoke_replay_revstart_callback(*args)

def svn_ra_invoke_replay_revfinish_callback(*args):
  """
    svn_ra_invoke_replay_revfinish_callback(svn_ra_replay_revfinish_callback_t _obj, svn_revnum_t revision, void * replay_baton, 
        svn_delta_editor_t editor, void * edit_baton, apr_hash_t rev_props, apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_invoke_replay_revfinish_callback(*args)

def svn_ra_invoke_check_tunnel_func(*args):
  """svn_ra_invoke_check_tunnel_func(svn_ra_check_tunnel_func_t _obj, void * tunnel_baton, char const * tunnel_name) -> svn_boolean_t"""
  return _ra.svn_ra_invoke_check_tunnel_func(*args)

def svn_ra_invoke_close_tunnel_func(*args):
  """svn_ra_invoke_close_tunnel_func(svn_ra_close_tunnel_func_t _obj, void * close_baton, void * tunnel_baton)"""
  return _ra.svn_ra_invoke_close_tunnel_func(*args)

def svn_ra_invoke_open_tunnel_func(*args):
  """
    svn_ra_invoke_open_tunnel_func(svn_ra_open_tunnel_func_t _obj, void * tunnel_baton, char const * tunnel_name, char const * user, 
        char const * hostname, int port, svn_cancel_func_t cancel_func, 
        apr_pool_t pool) -> svn_error_t
    """
  return _ra.svn_ra_invoke_open_tunnel_func(*args)

def svn_ra_invoke_init_func(*args):
  """svn_ra_invoke_init_func(svn_ra_init_func_t _obj, int abi_version, apr_pool_t pool, apr_hash_t hash) -> svn_error_t"""
  return _ra.svn_ra_invoke_init_func(*args)
class svn_ra_get_wc_prop_func_t:
    """Proxy of C svn_ra_get_wc_prop_func_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_ra_get_wc_prop_func_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_ra_get_wc_prop_func_t, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for TYPE"""
      import libsvn.core, weakref
      self.__dict__["_parent_pool"] = \
        parent_pool or libsvn.core.application_pool;
      if self.__dict__["_parent_pool"]:
        self.__dict__["_is_valid"] = weakref.ref(
          self.__dict__["_parent_pool"]._is_valid)

    def assert_valid(self):
      """Assert that this object is using valid pool memory"""
      if "_is_valid" in self.__dict__:
        assert self.__dict__["_is_valid"](), "Variable has already been deleted"

    def __getattr__(self, name):
      """Get an attribute from this object"""
      self.assert_valid()

      value = _swig_getattr(self, self.__class__, name)

      # If we got back a different object than we have, we need to copy all our
      # metadata into it, so that it looks identical
      members = self.__dict__.get("_members")
      if members is not None:
        _copy_metadata_deep(value, members.get(name))

      # Verify that the new object is good
      _assert_valid_deep(value)

      return value

    def __setattr__(self, name, value):
      """Set an attribute on this object"""
      self.assert_valid()

      # Save a copy of the object, so that the garbage
      # collector won't kill the object while it's in
      # SWIG-land
      self.__dict__.setdefault("_members",{})[name] = value

      return _swig_setattr(self, self.__class__, name, value)

    def __call__(self, *args):
      return svn_ra_invoke_get_wc_prop_func(self, *args)

svn_ra_get_wc_prop_func_t_swigregister = _ra.svn_ra_get_wc_prop_func_t_swigregister
svn_ra_get_wc_prop_func_t_swigregister(svn_ra_get_wc_prop_func_t)

class svn_ra_set_wc_prop_func_t:
    """Proxy of C svn_ra_set_wc_prop_func_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_ra_set_wc_prop_func_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_ra_set_wc_prop_func_t, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for TYPE"""
      import libsvn.core, weakref
      self.__dict__["_parent_pool"] = \
        parent_pool or libsvn.core.application_pool;
      if self.__dict__["_parent_pool"]:
        self.__dict__["_is_valid"] = weakref.ref(
          self.__dict__["_parent_pool"]._is_valid)

    def assert_valid(self):
      """Assert that this object is using valid pool memory"""
      if "_is_valid" in self.__dict__:
        assert self.__dict__["_is_valid"](), "Variable has already been deleted"

    def __getattr__(self, name):
      """Get an attribute from this object"""
      self.assert_valid()

      value = _swig_getattr(self, self.__class__, name)

      # If we got back a different object than we have, we need to copy all our
      # metadata into it, so that it looks identical
      members = self.__dict__.get("_members")
      if members is not None:
        _copy_metadata_deep(value, members.get(name))

      # Verify that the new object is good
      _assert_valid_deep(value)

      return value

    def __setattr__(self, name, value):
      """Set an attribute on this object"""
      self.assert_valid()

      # Save a copy of the object, so that the garbage
      # collector won't kill the object while it's in
      # SWIG-land
      self.__dict__.setdefault("_members",{})[name] = value

      return _swig_setattr(self, self.__class__, name, value)

    def __call__(self, *args):
      return svn_ra_invoke_set_wc_prop_func(self, *args)

svn_ra_set_wc_prop_func_t_swigregister = _ra.svn_ra_set_wc_prop_func_t_swigregister
svn_ra_set_wc_prop_func_t_swigregister(svn_ra_set_wc_prop_func_t)

class svn_ra_push_wc_prop_func_t:
    """Proxy of C svn_ra_push_wc_prop_func_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_ra_push_wc_prop_func_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_ra_push_wc_prop_func_t, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for TYPE"""
      import libsvn.core, weakref
      self.__dict__["_parent_pool"] = \
        parent_pool or libsvn.core.application_pool;
      if self.__dict__["_parent_pool"]:
        self.__dict__["_is_valid"] = weakref.ref(
          self.__dict__["_parent_pool"]._is_valid)

    def assert_valid(self):
      """Assert that this object is using valid pool memory"""
      if "_is_valid" in self.__dict__:
        assert self.__dict__["_is_valid"](), "Variable has already been deleted"

    def __getattr__(self, name):
      """Get an attribute from this object"""
      self.assert_valid()

      value = _swig_getattr(self, self.__class__, name)

      # If we got back a different object than we have, we need to copy all our
      # metadata into it, so that it looks identical
      members = self.__dict__.get("_members")
      if members is not None:
        _copy_metadata_deep(value, members.get(name))

      # Verify that the new object is good
      _assert_valid_deep(value)

      return value

    def __setattr__(self, name, value):
      """Set an attribute on this object"""
      self.assert_valid()

      # Save a copy of the object, so that the garbage
      # collector won't kill the object while it's in
      # SWIG-land
      self.__dict__.setdefault("_members",{})[name] = value

      return _swig_setattr(self, self.__class__, name, value)

    def __call__(self, *args):
      return svn_ra_invoke_push_wc_prop_func(self, *args)

svn_ra_push_wc_prop_func_t_swigregister = _ra.svn_ra_push_wc_prop_func_t_swigregister
svn_ra_push_wc_prop_func_t_swigregister(svn_ra_push_wc_prop_func_t)

class svn_ra_invalidate_wc_props_func_t:
    """Proxy of C svn_ra_invalidate_wc_props_func_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_ra_invalidate_wc_props_func_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_ra_invalidate_wc_props_func_t, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for TYPE"""
      import libsvn.core, weakref
      self.__dict__["_parent_pool"] = \
        parent_pool or libsvn.core.application_pool;
      if self.__dict__["_parent_pool"]:
        self.__dict__["_is_valid"] = weakref.ref(
          self.__dict__["_parent_pool"]._is_valid)

    def assert_valid(self):
      """Assert that this object is using valid pool memory"""
      if "_is_valid" in self.__dict__:
        assert self.__dict__["_is_valid"](), "Variable has already been deleted"

    def __getattr__(self, name):
      """Get an attribute from this object"""
      self.assert_valid()

      value = _swig_getattr(self, self.__class__, name)

      # If we got back a different object than we have, we need to copy all our
      # metadata into it, so that it looks identical
      members = self.__dict__.get("_members")
      if members is not None:
        _copy_metadata_deep(value, members.get(name))

      # Verify that the new object is good
      _assert_valid_deep(value)

      return value

    def __setattr__(self, name, value):
      """Set an attribute on this object"""
      self.assert_valid()

      # Save a copy of the object, so that the garbage
      # collector won't kill the object while it's in
      # SWIG-land
      self.__dict__.setdefault("_members",{})[name] = value

      return _swig_setattr(self, self.__class__, name, value)

    def __call__(self, *args):
      return svn_ra_invoke_invalidate_wc_props_func(self, *args)

svn_ra_invalidate_wc_props_func_t_swigregister = _ra.svn_ra_invalidate_wc_props_func_t_swigregister
svn_ra_invalidate_wc_props_func_t_swigregister(svn_ra_invalidate_wc_props_func_t)

class svn_ra_get_wc_contents_func_t:
    """Proxy of C svn_ra_get_wc_contents_func_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_ra_get_wc_contents_func_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_ra_get_wc_contents_func_t, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for TYPE"""
      import libsvn.core, weakref
      self.__dict__["_parent_pool"] = \
        parent_pool or libsvn.core.application_pool;
      if self.__dict__["_parent_pool"]:
        self.__dict__["_is_valid"] = weakref.ref(
          self.__dict__["_parent_pool"]._is_valid)

    def assert_valid(self):
      """Assert that this object is using valid pool memory"""
      if "_is_valid" in self.__dict__:
        assert self.__dict__["_is_valid"](), "Variable has already been deleted"

    def __getattr__(self, name):
      """Get an attribute from this object"""
      self.assert_valid()

      value = _swig_getattr(self, self.__class__, name)

      # If we got back a different object than we have, we need to copy all our
      # metadata into it, so that it looks identical
      members = self.__dict__.get("_members")
      if members is not None:
        _copy_metadata_deep(value, members.get(name))

      # Verify that the new object is good
      _assert_valid_deep(value)

      return value

    def __setattr__(self, name, value):
      """Set an attribute on this object"""
      self.assert_valid()

      # Save a copy of the object, so that the garbage
      # collector won't kill the object while it's in
      # SWIG-land
      self.__dict__.setdefault("_members",{})[name] = value

      return _swig_setattr(self, self.__class__, name, value)

    def __call__(self, *args):
      return svn_ra_invoke_get_wc_contents_func(self, *args)

svn_ra_get_wc_contents_func_t_swigregister = _ra.svn_ra_get_wc_contents_func_t_swigregister
svn_ra_get_wc_contents_func_t_swigregister(svn_ra_get_wc_contents_func_t)

class svn_ra_get_latest_revnum_func_t:
    """Proxy of C svn_ra_get_latest_revnum_func_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_ra_get_latest_revnum_func_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_ra_get_latest_revnum_func_t, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for TYPE"""
      import libsvn.core, weakref
      self.__dict__["_parent_pool"] = \
        parent_pool or libsvn.core.application_pool;
      if self.__dict__["_parent_pool"]:
        self.__dict__["_is_valid"] = weakref.ref(
          self.__dict__["_parent_pool"]._is_valid)

    def assert_valid(self):
      """Assert that this object is using valid pool memory"""
      if "_is_valid" in self.__dict__:
        assert self.__dict__["_is_valid"](), "Variable has already been deleted"

    def __getattr__(self, name):
      """Get an attribute from this object"""
      self.assert_valid()

      value = _swig_getattr(self, self.__class__, name)

      # If we got back a different object than we have, we need to copy all our
      # metadata into it, so that it looks identical
      members = self.__dict__.get("_members")
      if members is not None:
        _copy_metadata_deep(value, members.get(name))

      # Verify that the new object is good
      _assert_valid_deep(value)

      return value

    def __setattr__(self, name, value):
      """Set an attribute on this object"""
      self.assert_valid()

      # Save a copy of the object, so that the garbage
      # collector won't kill the object while it's in
      # SWIG-land
      self.__dict__.setdefault("_members",{})[name] = value

      return _swig_setattr(self, self.__class__, name, value)

    def __call__(self, *args):
      return svn_ra_invoke_get_latest_revnum_func(self, *args)

svn_ra_get_latest_revnum_func_t_swigregister = _ra.svn_ra_get_latest_revnum_func_t_swigregister
svn_ra_get_latest_revnum_func_t_swigregister(svn_ra_get_latest_revnum_func_t)

class svn_ra_get_client_string_func_t:
    """Proxy of C svn_ra_get_client_string_func_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_ra_get_client_string_func_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_ra_get_client_string_func_t, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for TYPE"""
      import libsvn.core, weakref
      self.__dict__["_parent_pool"] = \
        parent_pool or libsvn.core.application_pool;
      if self.__dict__["_parent_pool"]:
        self.__dict__["_is_valid"] = weakref.ref(
          self.__dict__["_parent_pool"]._is_valid)

    def assert_valid(self):
      """Assert that this object is using valid pool memory"""
      if "_is_valid" in self.__dict__:
        assert self.__dict__["_is_valid"](), "Variable has already been deleted"

    def __getattr__(self, name):
      """Get an attribute from this object"""
      self.assert_valid()

      value = _swig_getattr(self, self.__class__, name)

      # If we got back a different object than we have, we need to copy all our
      # metadata into it, so that it looks identical
      members = self.__dict__.get("_members")
      if members is not None:
        _copy_metadata_deep(value, members.get(name))

      # Verify that the new object is good
      _assert_valid_deep(value)

      return value

    def __setattr__(self, name, value):
      """Set an attribute on this object"""
      self.assert_valid()

      # Save a copy of the object, so that the garbage
      # collector won't kill the object while it's in
      # SWIG-land
      self.__dict__.setdefault("_members",{})[name] = value

      return _swig_setattr(self, self.__class__, name, value)

    def __call__(self, *args):
      return svn_ra_invoke_get_client_string_func(self, *args)

svn_ra_get_client_string_func_t_swigregister = _ra.svn_ra_get_client_string_func_t_swigregister
svn_ra_get_client_string_func_t_swigregister(svn_ra_get_client_string_func_t)

class svn_ra_file_rev_handler_t:
    """Proxy of C svn_ra_file_rev_handler_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_ra_file_rev_handler_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_ra_file_rev_handler_t, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for TYPE"""
      import libsvn.core, weakref
      self.__dict__["_parent_pool"] = \
        parent_pool or libsvn.core.application_pool;
      if self.__dict__["_parent_pool"]:
        self.__dict__["_is_valid"] = weakref.ref(
          self.__dict__["_parent_pool"]._is_valid)

    def assert_valid(self):
      """Assert that this object is using valid pool memory"""
      if "_is_valid" in self.__dict__:
        assert self.__dict__["_is_valid"](), "Variable has already been deleted"

    def __getattr__(self, name):
      """Get an attribute from this object"""
      self.assert_valid()

      value = _swig_getattr(self, self.__class__, name)

      # If we got back a different object than we have, we need to copy all our
      # metadata into it, so that it looks identical
      members = self.__dict__.get("_members")
      if members is not None:
        _copy_metadata_deep(value, members.get(name))

      # Verify that the new object is good
      _assert_valid_deep(value)

      return value

    def __setattr__(self, name, value):
      """Set an attribute on this object"""
      self.assert_valid()

      # Save a copy of the object, so that the garbage
      # collector won't kill the object while it's in
      # SWIG-land
      self.__dict__.setdefault("_members",{})[name] = value

      return _swig_setattr(self, self.__class__, name, value)

    def __call__(self, *args):
      return svn_ra_invoke_file_rev_handler(self, *args)

svn_ra_file_rev_handler_t_swigregister = _ra.svn_ra_file_rev_handler_t_swigregister
svn_ra_file_rev_handler_t_swigregister(svn_ra_file_rev_handler_t)

class svn_ra_lock_callback_t:
    """Proxy of C svn_ra_lock_callback_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_ra_lock_callback_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_ra_lock_callback_t, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for TYPE"""
      import libsvn.core, weakref
      self.__dict__["_parent_pool"] = \
        parent_pool or libsvn.core.application_pool;
      if self.__dict__["_parent_pool"]:
        self.__dict__["_is_valid"] = weakref.ref(
          self.__dict__["_parent_pool"]._is_valid)

    def assert_valid(self):
      """Assert that this object is using valid pool memory"""
      if "_is_valid" in self.__dict__:
        assert self.__dict__["_is_valid"](), "Variable has already been deleted"

    def __getattr__(self, name):
      """Get an attribute from this object"""
      self.assert_valid()

      value = _swig_getattr(self, self.__class__, name)

      # If we got back a different object than we have, we need to copy all our
      # metadata into it, so that it looks identical
      members = self.__dict__.get("_members")
      if members is not None:
        _copy_metadata_deep(value, members.get(name))

      # Verify that the new object is good
      _assert_valid_deep(value)

      return value

    def __setattr__(self, name, value):
      """Set an attribute on this object"""
      self.assert_valid()

      # Save a copy of the object, so that the garbage
      # collector won't kill the object while it's in
      # SWIG-land
      self.__dict__.setdefault("_members",{})[name] = value

      return _swig_setattr(self, self.__class__, name, value)

    def __call__(self, *args):
      return svn_ra_invoke_lock_callback(self, *args)

svn_ra_lock_callback_t_swigregister = _ra.svn_ra_lock_callback_t_swigregister
svn_ra_lock_callback_t_swigregister(svn_ra_lock_callback_t)

class svn_ra_progress_notify_func_t:
    """Proxy of C svn_ra_progress_notify_func_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_ra_progress_notify_func_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_ra_progress_notify_func_t, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for TYPE"""
      import libsvn.core, weakref
      self.__dict__["_parent_pool"] = \
        parent_pool or libsvn.core.application_pool;
      if self.__dict__["_parent_pool"]:
        self.__dict__["_is_valid"] = weakref.ref(
          self.__dict__["_parent_pool"]._is_valid)

    def assert_valid(self):
      """Assert that this object is using valid pool memory"""
      if "_is_valid" in self.__dict__:
        assert self.__dict__["_is_valid"](), "Variable has already been deleted"

    def __getattr__(self, name):
      """Get an attribute from this object"""
      self.assert_valid()

      value = _swig_getattr(self, self.__class__, name)

      # If we got back a different object than we have, we need to copy all our
      # metadata into it, so that it looks identical
      members = self.__dict__.get("_members")
      if members is not None:
        _copy_metadata_deep(value, members.get(name))

      # Verify that the new object is good
      _assert_valid_deep(value)

      return value

    def __setattr__(self, name, value):
      """Set an attribute on this object"""
      self.assert_valid()

      # Save a copy of the object, so that the garbage
      # collector won't kill the object while it's in
      # SWIG-land
      self.__dict__.setdefault("_members",{})[name] = value

      return _swig_setattr(self, self.__class__, name, value)

    def __call__(self, *args):
      return svn_ra_invoke_progress_notify_func(self, *args)

svn_ra_progress_notify_func_t_swigregister = _ra.svn_ra_progress_notify_func_t_swigregister
svn_ra_progress_notify_func_t_swigregister(svn_ra_progress_notify_func_t)

class svn_ra_replay_revstart_callback_t:
    """Proxy of C svn_ra_replay_revstart_callback_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_ra_replay_revstart_callback_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_ra_replay_revstart_callback_t, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for TYPE"""
      import libsvn.core, weakref
      self.__dict__["_parent_pool"] = \
        parent_pool or libsvn.core.application_pool;
      if self.__dict__["_parent_pool"]:
        self.__dict__["_is_valid"] = weakref.ref(
          self.__dict__["_parent_pool"]._is_valid)

    def assert_valid(self):
      """Assert that this object is using valid pool memory"""
      if "_is_valid" in self.__dict__:
        assert self.__dict__["_is_valid"](), "Variable has already been deleted"

    def __getattr__(self, name):
      """Get an attribute from this object"""
      self.assert_valid()

      value = _swig_getattr(self, self.__class__, name)

      # If we got back a different object than we have, we need to copy all our
      # metadata into it, so that it looks identical
      members = self.__dict__.get("_members")
      if members is not None:
        _copy_metadata_deep(value, members.get(name))

      # Verify that the new object is good
      _assert_valid_deep(value)

      return value

    def __setattr__(self, name, value):
      """Set an attribute on this object"""
      self.assert_valid()

      # Save a copy of the object, so that the garbage
      # collector won't kill the object while it's in
      # SWIG-land
      self.__dict__.setdefault("_members",{})[name] = value

      return _swig_setattr(self, self.__class__, name, value)

    def __call__(self, *args):
      return svn_ra_invoke_replay_revstart_callback(self, *args)

svn_ra_replay_revstart_callback_t_swigregister = _ra.svn_ra_replay_revstart_callback_t_swigregister
svn_ra_replay_revstart_callback_t_swigregister(svn_ra_replay_revstart_callback_t)

class svn_ra_replay_revfinish_callback_t:
    """Proxy of C svn_ra_replay_revfinish_callback_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_ra_replay_revfinish_callback_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_ra_replay_revfinish_callback_t, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for TYPE"""
      import libsvn.core, weakref
      self.__dict__["_parent_pool"] = \
        parent_pool or libsvn.core.application_pool;
      if self.__dict__["_parent_pool"]:
        self.__dict__["_is_valid"] = weakref.ref(
          self.__dict__["_parent_pool"]._is_valid)

    def assert_valid(self):
      """Assert that this object is using valid pool memory"""
      if "_is_valid" in self.__dict__:
        assert self.__dict__["_is_valid"](), "Variable has already been deleted"

    def __getattr__(self, name):
      """Get an attribute from this object"""
      self.assert_valid()

      value = _swig_getattr(self, self.__class__, name)

      # If we got back a different object than we have, we need to copy all our
      # metadata into it, so that it looks identical
      members = self.__dict__.get("_members")
      if members is not None:
        _copy_metadata_deep(value, members.get(name))

      # Verify that the new object is good
      _assert_valid_deep(value)

      return value

    def __setattr__(self, name, value):
      """Set an attribute on this object"""
      self.assert_valid()

      # Save a copy of the object, so that the garbage
      # collector won't kill the object while it's in
      # SWIG-land
      self.__dict__.setdefault("_members",{})[name] = value

      return _swig_setattr(self, self.__class__, name, value)

    def __call__(self, *args):
      return svn_ra_invoke_replay_revfinish_callback(self, *args)

svn_ra_replay_revfinish_callback_t_swigregister = _ra.svn_ra_replay_revfinish_callback_t_swigregister
svn_ra_replay_revfinish_callback_t_swigregister(svn_ra_replay_revfinish_callback_t)

class svn_ra_check_tunnel_func_t:
    """Proxy of C svn_ra_check_tunnel_func_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_ra_check_tunnel_func_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_ra_check_tunnel_func_t, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for TYPE"""
      import libsvn.core, weakref
      self.__dict__["_parent_pool"] = \
        parent_pool or libsvn.core.application_pool;
      if self.__dict__["_parent_pool"]:
        self.__dict__["_is_valid"] = weakref.ref(
          self.__dict__["_parent_pool"]._is_valid)

    def assert_valid(self):
      """Assert that this object is using valid pool memory"""
      if "_is_valid" in self.__dict__:
        assert self.__dict__["_is_valid"](), "Variable has already been deleted"

    def __getattr__(self, name):
      """Get an attribute from this object"""
      self.assert_valid()

      value = _swig_getattr(self, self.__class__, name)

      # If we got back a different object than we have, we need to copy all our
      # metadata into it, so that it looks identical
      members = self.__dict__.get("_members")
      if members is not None:
        _copy_metadata_deep(value, members.get(name))

      # Verify that the new object is good
      _assert_valid_deep(value)

      return value

    def __setattr__(self, name, value):
      """Set an attribute on this object"""
      self.assert_valid()

      # Save a copy of the object, so that the garbage
      # collector won't kill the object while it's in
      # SWIG-land
      self.__dict__.setdefault("_members",{})[name] = value

      return _swig_setattr(self, self.__class__, name, value)

    def __call__(self, *args):
      return svn_ra_invoke_check_tunnel_func(self, *args)

svn_ra_check_tunnel_func_t_swigregister = _ra.svn_ra_check_tunnel_func_t_swigregister
svn_ra_check_tunnel_func_t_swigregister(svn_ra_check_tunnel_func_t)

class svn_ra_close_tunnel_func_t:
    """Proxy of C svn_ra_close_tunnel_func_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_ra_close_tunnel_func_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_ra_close_tunnel_func_t, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for TYPE"""
      import libsvn.core, weakref
      self.__dict__["_parent_pool"] = \
        parent_pool or libsvn.core.application_pool;
      if self.__dict__["_parent_pool"]:
        self.__dict__["_is_valid"] = weakref.ref(
          self.__dict__["_parent_pool"]._is_valid)

    def assert_valid(self):
      """Assert that this object is using valid pool memory"""
      if "_is_valid" in self.__dict__:
        assert self.__dict__["_is_valid"](), "Variable has already been deleted"

    def __getattr__(self, name):
      """Get an attribute from this object"""
      self.assert_valid()

      value = _swig_getattr(self, self.__class__, name)

      # If we got back a different object than we have, we need to copy all our
      # metadata into it, so that it looks identical
      members = self.__dict__.get("_members")
      if members is not None:
        _copy_metadata_deep(value, members.get(name))

      # Verify that the new object is good
      _assert_valid_deep(value)

      return value

    def __setattr__(self, name, value):
      """Set an attribute on this object"""
      self.assert_valid()

      # Save a copy of the object, so that the garbage
      # collector won't kill the object while it's in
      # SWIG-land
      self.__dict__.setdefault("_members",{})[name] = value

      return _swig_setattr(self, self.__class__, name, value)

    def __call__(self, *args):
      return svn_ra_invoke_close_tunnel_func(self, *args)

svn_ra_close_tunnel_func_t_swigregister = _ra.svn_ra_close_tunnel_func_t_swigregister
svn_ra_close_tunnel_func_t_swigregister(svn_ra_close_tunnel_func_t)

class svn_ra_open_tunnel_func_t:
    """Proxy of C svn_ra_open_tunnel_func_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_ra_open_tunnel_func_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_ra_open_tunnel_func_t, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for TYPE"""
      import libsvn.core, weakref
      self.__dict__["_parent_pool"] = \
        parent_pool or libsvn.core.application_pool;
      if self.__dict__["_parent_pool"]:
        self.__dict__["_is_valid"] = weakref.ref(
          self.__dict__["_parent_pool"]._is_valid)

    def assert_valid(self):
      """Assert that this object is using valid pool memory"""
      if "_is_valid" in self.__dict__:
        assert self.__dict__["_is_valid"](), "Variable has already been deleted"

    def __getattr__(self, name):
      """Get an attribute from this object"""
      self.assert_valid()

      value = _swig_getattr(self, self.__class__, name)

      # If we got back a different object than we have, we need to copy all our
      # metadata into it, so that it looks identical
      members = self.__dict__.get("_members")
      if members is not None:
        _copy_metadata_deep(value, members.get(name))

      # Verify that the new object is good
      _assert_valid_deep(value)

      return value

    def __setattr__(self, name, value):
      """Set an attribute on this object"""
      self.assert_valid()

      # Save a copy of the object, so that the garbage
      # collector won't kill the object while it's in
      # SWIG-land
      self.__dict__.setdefault("_members",{})[name] = value

      return _swig_setattr(self, self.__class__, name, value)

    def __call__(self, *args):
      return svn_ra_invoke_open_tunnel_func(self, *args)

svn_ra_open_tunnel_func_t_swigregister = _ra.svn_ra_open_tunnel_func_t_swigregister
svn_ra_open_tunnel_func_t_swigregister(svn_ra_open_tunnel_func_t)

class svn_ra_init_func_t:
    """Proxy of C svn_ra_init_func_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_ra_init_func_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_ra_init_func_t, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for TYPE"""
      import libsvn.core, weakref
      self.__dict__["_parent_pool"] = \
        parent_pool or libsvn.core.application_pool;
      if self.__dict__["_parent_pool"]:
        self.__dict__["_is_valid"] = weakref.ref(
          self.__dict__["_parent_pool"]._is_valid)

    def assert_valid(self):
      """Assert that this object is using valid pool memory"""
      if "_is_valid" in self.__dict__:
        assert self.__dict__["_is_valid"](), "Variable has already been deleted"

    def __getattr__(self, name):
      """Get an attribute from this object"""
      self.assert_valid()

      value = _swig_getattr(self, self.__class__, name)

      # If we got back a different object than we have, we need to copy all our
      # metadata into it, so that it looks identical
      members = self.__dict__.get("_members")
      if members is not None:
        _copy_metadata_deep(value, members.get(name))

      # Verify that the new object is good
      _assert_valid_deep(value)

      return value

    def __setattr__(self, name, value):
      """Set an attribute on this object"""
      self.assert_valid()

      # Save a copy of the object, so that the garbage
      # collector won't kill the object while it's in
      # SWIG-land
      self.__dict__.setdefault("_members",{})[name] = value

      return _swig_setattr(self, self.__class__, name, value)

    def __call__(self, *args):
      return svn_ra_invoke_init_func(self, *args)

svn_ra_init_func_t_swigregister = _ra.svn_ra_init_func_t_swigregister
svn_ra_init_func_t_swigregister(svn_ra_init_func_t)

# This file is compatible with both classic and new-style classes.


