# 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('_diff', [dirname(__file__)])
        except ImportError:
            import _diff
            return _diff
        if fp is not None:
            try:
                _mod = imp.load_module('_diff', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _diff = swig_import_helper()
    del swig_import_helper
else:
    import _diff
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

def svn_diff_version():
  """svn_diff_version() -> svn_version_t const *"""
  return _diff.svn_diff_version()
svn_diff_datasource_original = _diff.svn_diff_datasource_original
svn_diff_datasource_modified = _diff.svn_diff_datasource_modified
svn_diff_datasource_latest = _diff.svn_diff_datasource_latest
svn_diff_datasource_ancestor = _diff.svn_diff_datasource_ancestor
class svn_diff_fns2_t:
    """Proxy of C svn_diff_fns2_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_diff_fns2_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_diff_fns2_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["datasources_open"] = _diff.svn_diff_fns2_t_datasources_open_set
    __swig_getmethods__["datasources_open"] = _diff.svn_diff_fns2_t_datasources_open_get
    __swig_setmethods__["datasource_close"] = _diff.svn_diff_fns2_t_datasource_close_set
    __swig_getmethods__["datasource_close"] = _diff.svn_diff_fns2_t_datasource_close_get
    __swig_setmethods__["datasource_get_next_token"] = _diff.svn_diff_fns2_t_datasource_get_next_token_set
    __swig_getmethods__["datasource_get_next_token"] = _diff.svn_diff_fns2_t_datasource_get_next_token_get
    __swig_setmethods__["token_compare"] = _diff.svn_diff_fns2_t_token_compare_set
    __swig_getmethods__["token_compare"] = _diff.svn_diff_fns2_t_token_compare_get
    __swig_setmethods__["token_discard"] = _diff.svn_diff_fns2_t_token_discard_set
    __swig_getmethods__["token_discard"] = _diff.svn_diff_fns2_t_token_discard_get
    __swig_setmethods__["token_discard_all"] = _diff.svn_diff_fns2_t_token_discard_all_set
    __swig_getmethods__["token_discard_all"] = _diff.svn_diff_fns2_t_token_discard_all_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 datasources_open(self, *args):
      return svn_diff_fns2_invoke_datasources_open(self, *args)

    def datasource_close(self, *args):
      return svn_diff_fns2_invoke_datasource_close(self, *args)

    def datasource_get_next_token(self, *args):
      return svn_diff_fns2_invoke_datasource_get_next_token(self, *args)

    def token_compare(self, *args):
      return svn_diff_fns2_invoke_token_compare(self, *args)

    def token_discard(self, *args):
      return svn_diff_fns2_invoke_token_discard(self, *args)

    def token_discard_all(self, *args):
      return svn_diff_fns2_invoke_token_discard_all(self, *args)

    def __init__(self): 
        """__init__(svn_diff_fns2_t self) -> svn_diff_fns2_t"""
        this = _diff.new_svn_diff_fns2_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _diff.delete_svn_diff_fns2_t
    __del__ = lambda self : None;
svn_diff_fns2_t_swigregister = _diff.svn_diff_fns2_t_swigregister
svn_diff_fns2_t_swigregister(svn_diff_fns2_t)

class svn_diff_fns_t:
    """Proxy of C svn_diff_fns_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_diff_fns_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_diff_fns_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["datasource_open"] = _diff.svn_diff_fns_t_datasource_open_set
    __swig_getmethods__["datasource_open"] = _diff.svn_diff_fns_t_datasource_open_get
    __swig_setmethods__["datasource_close"] = _diff.svn_diff_fns_t_datasource_close_set
    __swig_getmethods__["datasource_close"] = _diff.svn_diff_fns_t_datasource_close_get
    __swig_setmethods__["datasource_get_next_token"] = _diff.svn_diff_fns_t_datasource_get_next_token_set
    __swig_getmethods__["datasource_get_next_token"] = _diff.svn_diff_fns_t_datasource_get_next_token_get
    __swig_setmethods__["token_compare"] = _diff.svn_diff_fns_t_token_compare_set
    __swig_getmethods__["token_compare"] = _diff.svn_diff_fns_t_token_compare_get
    __swig_setmethods__["token_discard"] = _diff.svn_diff_fns_t_token_discard_set
    __swig_getmethods__["token_discard"] = _diff.svn_diff_fns_t_token_discard_get
    __swig_setmethods__["token_discard_all"] = _diff.svn_diff_fns_t_token_discard_all_set
    __swig_getmethods__["token_discard_all"] = _diff.svn_diff_fns_t_token_discard_all_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 datasource_open(self, *args):
      return svn_diff_fns_invoke_datasource_open(self, *args)

    def datasource_close(self, *args):
      return svn_diff_fns_invoke_datasource_close(self, *args)

    def datasource_get_next_token(self, *args):
      return svn_diff_fns_invoke_datasource_get_next_token(self, *args)

    def token_compare(self, *args):
      return svn_diff_fns_invoke_token_compare(self, *args)

    def token_discard(self, *args):
      return svn_diff_fns_invoke_token_discard(self, *args)

    def token_discard_all(self, *args):
      return svn_diff_fns_invoke_token_discard_all(self, *args)

    def __init__(self): 
        """__init__(svn_diff_fns_t self) -> svn_diff_fns_t"""
        this = _diff.new_svn_diff_fns_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _diff.delete_svn_diff_fns_t
    __del__ = lambda self : None;
svn_diff_fns_t_swigregister = _diff.svn_diff_fns_t_swigregister
svn_diff_fns_t_swigregister(svn_diff_fns_t)


def svn_diff_diff_2(*args):
  """svn_diff_diff_2(void * diff_baton, svn_diff_fns2_t diff_fns, apr_pool_t pool) -> svn_error_t"""
  return _diff.svn_diff_diff_2(*args)

def svn_diff_diff(*args):
  """svn_diff_diff(void * diff_baton, svn_diff_fns_t diff_fns, apr_pool_t pool) -> svn_error_t"""
  return _diff.svn_diff_diff(*args)

def svn_diff_diff3_2(*args):
  """svn_diff_diff3_2(void * diff_baton, svn_diff_fns2_t diff_fns, apr_pool_t pool) -> svn_error_t"""
  return _diff.svn_diff_diff3_2(*args)

def svn_diff_diff3(*args):
  """svn_diff_diff3(void * diff_baton, svn_diff_fns_t diff_fns, apr_pool_t pool) -> svn_error_t"""
  return _diff.svn_diff_diff3(*args)

def svn_diff_diff4_2(*args):
  """svn_diff_diff4_2(void * diff_baton, svn_diff_fns2_t diff_fns, apr_pool_t pool) -> svn_error_t"""
  return _diff.svn_diff_diff4_2(*args)

def svn_diff_diff4(*args):
  """svn_diff_diff4(void * diff_baton, svn_diff_fns_t diff_fns, apr_pool_t pool) -> svn_error_t"""
  return _diff.svn_diff_diff4(*args)

def svn_diff_contains_conflicts(*args):
  """svn_diff_contains_conflicts(svn_diff_t * diff) -> svn_boolean_t"""
  return _diff.svn_diff_contains_conflicts(*args)

def svn_diff_contains_diffs(*args):
  """svn_diff_contains_diffs(svn_diff_t * diff) -> svn_boolean_t"""
  return _diff.svn_diff_contains_diffs(*args)
class svn_diff_output_fns_t:
    """Proxy of C svn_diff_output_fns_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_diff_output_fns_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_diff_output_fns_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["output_common"] = _diff.svn_diff_output_fns_t_output_common_set
    __swig_getmethods__["output_common"] = _diff.svn_diff_output_fns_t_output_common_get
    __swig_setmethods__["output_diff_modified"] = _diff.svn_diff_output_fns_t_output_diff_modified_set
    __swig_getmethods__["output_diff_modified"] = _diff.svn_diff_output_fns_t_output_diff_modified_get
    __swig_setmethods__["output_diff_latest"] = _diff.svn_diff_output_fns_t_output_diff_latest_set
    __swig_getmethods__["output_diff_latest"] = _diff.svn_diff_output_fns_t_output_diff_latest_get
    __swig_setmethods__["output_diff_common"] = _diff.svn_diff_output_fns_t_output_diff_common_set
    __swig_getmethods__["output_diff_common"] = _diff.svn_diff_output_fns_t_output_diff_common_get
    __swig_setmethods__["output_conflict"] = _diff.svn_diff_output_fns_t_output_conflict_set
    __swig_getmethods__["output_conflict"] = _diff.svn_diff_output_fns_t_output_conflict_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 output_common(self, *args):
      return svn_diff_output_fns_invoke_output_common(self, *args)

    def output_diff_modified(self, *args):
      return svn_diff_output_fns_invoke_output_diff_modified(self, *args)

    def output_diff_latest(self, *args):
      return svn_diff_output_fns_invoke_output_diff_latest(self, *args)

    def output_diff_common(self, *args):
      return svn_diff_output_fns_invoke_output_diff_common(self, *args)

    def output_conflict(self, *args):
      return svn_diff_output_fns_invoke_output_conflict(self, *args)

    def __init__(self): 
        """__init__(svn_diff_output_fns_t self) -> svn_diff_output_fns_t"""
        this = _diff.new_svn_diff_output_fns_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _diff.delete_svn_diff_output_fns_t
    __del__ = lambda self : None;
svn_diff_output_fns_t_swigregister = _diff.svn_diff_output_fns_t_swigregister
svn_diff_output_fns_t_swigregister(svn_diff_output_fns_t)

svn_diff_conflict_display_modified_latest = _diff.svn_diff_conflict_display_modified_latest
svn_diff_conflict_display_resolved_modified_latest = _diff.svn_diff_conflict_display_resolved_modified_latest
svn_diff_conflict_display_modified_original_latest = _diff.svn_diff_conflict_display_modified_original_latest
svn_diff_conflict_display_modified = _diff.svn_diff_conflict_display_modified
svn_diff_conflict_display_latest = _diff.svn_diff_conflict_display_latest
svn_diff_conflict_display_only_conflicts = _diff.svn_diff_conflict_display_only_conflicts

def svn_diff_output2(*args):
  """svn_diff_output2(svn_diff_t * diff, void * output_baton, svn_diff_output_fns_t output_fns, svn_cancel_func_t cancel_func) -> svn_error_t"""
  return _diff.svn_diff_output2(*args)

def svn_diff_output(*args):
  """svn_diff_output(svn_diff_t * diff, void * output_baton, svn_diff_output_fns_t output_fns) -> svn_error_t"""
  return _diff.svn_diff_output(*args)
svn_diff_file_ignore_space_none = _diff.svn_diff_file_ignore_space_none
svn_diff_file_ignore_space_change = _diff.svn_diff_file_ignore_space_change
svn_diff_file_ignore_space_all = _diff.svn_diff_file_ignore_space_all
class svn_diff_file_options_t:
    """Proxy of C svn_diff_file_options_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_diff_file_options_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_diff_file_options_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["ignore_space"] = _diff.svn_diff_file_options_t_ignore_space_set
    __swig_getmethods__["ignore_space"] = _diff.svn_diff_file_options_t_ignore_space_get
    __swig_setmethods__["ignore_eol_style"] = _diff.svn_diff_file_options_t_ignore_eol_style_set
    __swig_getmethods__["ignore_eol_style"] = _diff.svn_diff_file_options_t_ignore_eol_style_get
    __swig_setmethods__["show_c_function"] = _diff.svn_diff_file_options_t_show_c_function_set
    __swig_getmethods__["show_c_function"] = _diff.svn_diff_file_options_t_show_c_function_get
    __swig_setmethods__["context_size"] = _diff.svn_diff_file_options_t_context_size_set
    __swig_getmethods__["context_size"] = _diff.svn_diff_file_options_t_context_size_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 __init__(self): 
        """__init__(svn_diff_file_options_t self) -> svn_diff_file_options_t"""
        this = _diff.new_svn_diff_file_options_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _diff.delete_svn_diff_file_options_t
    __del__ = lambda self : None;
svn_diff_file_options_t_swigregister = _diff.svn_diff_file_options_t_swigregister
svn_diff_file_options_t_swigregister(svn_diff_file_options_t)


def svn_diff_file_options_create(*args):
  """svn_diff_file_options_create(apr_pool_t pool) -> svn_diff_file_options_t"""
  return _diff.svn_diff_file_options_create(*args)

def svn_diff_file_options_parse(*args):
  """svn_diff_file_options_parse(svn_diff_file_options_t options, apr_array_header_t args, apr_pool_t pool) -> svn_error_t"""
  return _diff.svn_diff_file_options_parse(*args)

def svn_diff_file_diff_2(*args):
  """svn_diff_file_diff_2(char const * original, char const * modified, svn_diff_file_options_t options, apr_pool_t pool) -> svn_error_t"""
  return _diff.svn_diff_file_diff_2(*args)

def svn_diff_file_diff(*args):
  """svn_diff_file_diff(char const * original, char const * modified, apr_pool_t pool) -> svn_error_t"""
  return _diff.svn_diff_file_diff(*args)

def svn_diff_file_diff3_2(*args):
  """
    svn_diff_file_diff3_2(char const * original, char const * modified, char const * latest, svn_diff_file_options_t options, 
        apr_pool_t pool) -> svn_error_t
    """
  return _diff.svn_diff_file_diff3_2(*args)

def svn_diff_file_diff3(*args):
  """svn_diff_file_diff3(char const * original, char const * modified, char const * latest, apr_pool_t pool) -> svn_error_t"""
  return _diff.svn_diff_file_diff3(*args)

def svn_diff_file_diff4_2(*args):
  """
    svn_diff_file_diff4_2(char const * original, char const * modified, char const * latest, char const * ancestor, 
        svn_diff_file_options_t options, apr_pool_t pool) -> svn_error_t
    """
  return _diff.svn_diff_file_diff4_2(*args)

def svn_diff_file_diff4(*args):
  """
    svn_diff_file_diff4(char const * original, char const * modified, char const * latest, char const * ancestor, 
        apr_pool_t pool) -> svn_error_t
    """
  return _diff.svn_diff_file_diff4(*args)

def svn_diff_file_output_unified4(*args):
  """
    svn_diff_file_output_unified4(svn_stream_t * output_stream, svn_diff_t * diff, char const * original_path, char const * modified_path, 
        char const * original_header, char const * modified_header, 
        char const * header_encoding, char const * relative_to_dir, svn_boolean_t show_c_function, 
        int context_size, svn_cancel_func_t cancel_func, apr_pool_t scratch_pool) -> svn_error_t
    """
  return _diff.svn_diff_file_output_unified4(*args)

def svn_diff_file_output_unified3(*args):
  """
    svn_diff_file_output_unified3(svn_stream_t * output_stream, svn_diff_t * diff, char const * original_path, char const * modified_path, 
        char const * original_header, char const * modified_header, 
        char const * header_encoding, char const * relative_to_dir, svn_boolean_t show_c_function, 
        apr_pool_t pool) -> svn_error_t
    """
  return _diff.svn_diff_file_output_unified3(*args)

def svn_diff_file_output_unified2(*args):
  """
    svn_diff_file_output_unified2(svn_stream_t * output_stream, svn_diff_t * diff, char const * original_path, char const * modified_path, 
        char const * original_header, char const * modified_header, 
        char const * header_encoding, apr_pool_t pool) -> svn_error_t
    """
  return _diff.svn_diff_file_output_unified2(*args)

def svn_diff_file_output_unified(*args):
  """
    svn_diff_file_output_unified(svn_stream_t * output_stream, svn_diff_t * diff, char const * original_path, char const * modified_path, 
        char const * original_header, char const * modified_header, 
        apr_pool_t pool) -> svn_error_t
    """
  return _diff.svn_diff_file_output_unified(*args)

def svn_diff_file_output_merge3(*args):
  """
    svn_diff_file_output_merge3(svn_stream_t * output_stream, svn_diff_t * diff, char const * original_path, char const * modified_path, 
        char const * latest_path, char const * conflict_original, 
        char const * conflict_modified, char const * conflict_latest, char const * conflict_separator, 
        svn_diff_conflict_display_style_t conflict_style, 
        svn_cancel_func_t cancel_func, apr_pool_t scratch_pool) -> svn_error_t
    """
  return _diff.svn_diff_file_output_merge3(*args)

def svn_diff_file_output_merge2(*args):
  """
    svn_diff_file_output_merge2(svn_stream_t * output_stream, svn_diff_t * diff, char const * original_path, char const * modified_path, 
        char const * latest_path, char const * conflict_original, 
        char const * conflict_modified, char const * conflict_latest, char const * conflict_separator, 
        svn_diff_conflict_display_style_t conflict_style, 
        apr_pool_t pool) -> svn_error_t
    """
  return _diff.svn_diff_file_output_merge2(*args)

def svn_diff_file_output_merge(*args):
  """
    svn_diff_file_output_merge(svn_stream_t * output_stream, svn_diff_t * diff, char const * original_path, char const * modified_path, 
        char const * latest_path, char const * conflict_original, 
        char const * conflict_modified, char const * conflict_latest, char const * conflict_separator, 
        svn_boolean_t display_original_in_conflict, svn_boolean_t display_resolved_conflicts, 
        apr_pool_t pool) -> svn_error_t
    """
  return _diff.svn_diff_file_output_merge(*args)

def svn_diff_output_binary(*args):
  """
    svn_diff_output_binary(svn_stream_t * output_stream, svn_stream_t * original, svn_stream_t * latest, svn_cancel_func_t cancel_func, 
        apr_pool_t scratch_pool) -> svn_error_t
    """
  return _diff.svn_diff_output_binary(*args)

def svn_diff_mem_string_diff(*args):
  """
    svn_diff_mem_string_diff(svn_string_t const * original, svn_string_t const * modified, svn_diff_file_options_t options, 
        apr_pool_t pool) -> svn_error_t
    """
  return _diff.svn_diff_mem_string_diff(*args)

def svn_diff_mem_string_diff3(*args):
  """
    svn_diff_mem_string_diff3(svn_string_t const * original, svn_string_t const * modified, svn_string_t const * latest, 
        svn_diff_file_options_t options, apr_pool_t pool) -> svn_error_t
    """
  return _diff.svn_diff_mem_string_diff3(*args)

def svn_diff_mem_string_diff4(*args):
  """
    svn_diff_mem_string_diff4(svn_string_t const * original, svn_string_t const * modified, svn_string_t const * latest, 
        svn_string_t const * ancestor, svn_diff_file_options_t options, apr_pool_t pool) -> svn_error_t
    """
  return _diff.svn_diff_mem_string_diff4(*args)

def svn_diff_mem_string_output_unified3(*args):
  """
    svn_diff_mem_string_output_unified3(svn_stream_t * output_stream, svn_diff_t * diff, svn_boolean_t with_diff_header, 
        char const * hunk_delimiter, char const * original_header, char const * modified_header, 
        char const * header_encoding, svn_string_t const * original, 
        svn_string_t const * modified, int context_size, svn_cancel_func_t cancel_func, 
        apr_pool_t scratch_pool) -> svn_error_t
    """
  return _diff.svn_diff_mem_string_output_unified3(*args)

def svn_diff_mem_string_output_unified2(*args):
  """
    svn_diff_mem_string_output_unified2(svn_stream_t * output_stream, svn_diff_t * diff, svn_boolean_t with_diff_header, 
        char const * hunk_delimiter, char const * original_header, char const * modified_header, 
        char const * header_encoding, svn_string_t const * original, 
        svn_string_t const * modified, apr_pool_t pool) -> svn_error_t
    """
  return _diff.svn_diff_mem_string_output_unified2(*args)

def svn_diff_mem_string_output_unified(*args):
  """
    svn_diff_mem_string_output_unified(svn_stream_t * output_stream, svn_diff_t * diff, char const * original_header, char const * modified_header, 
        char const * header_encoding, svn_string_t const * original, 
        svn_string_t const * modified, apr_pool_t pool) -> svn_error_t
    """
  return _diff.svn_diff_mem_string_output_unified(*args)

def svn_diff_mem_string_output_merge3(*args):
  """
    svn_diff_mem_string_output_merge3(svn_stream_t * output_stream, svn_diff_t * diff, svn_string_t const * original, svn_string_t const * modified, 
        svn_string_t const * latest, char const * conflict_original, 
        char const * conflict_modified, char const * conflict_latest, 
        char const * conflict_separator, svn_diff_conflict_display_style_t style, 
        svn_cancel_func_t cancel_func, apr_pool_t scratch_pool) -> svn_error_t
    """
  return _diff.svn_diff_mem_string_output_merge3(*args)

def svn_diff_mem_string_output_merge2(*args):
  """
    svn_diff_mem_string_output_merge2(svn_stream_t * output_stream, svn_diff_t * diff, svn_string_t const * original, svn_string_t const * modified, 
        svn_string_t const * latest, char const * conflict_original, 
        char const * conflict_modified, char const * conflict_latest, 
        char const * conflict_separator, svn_diff_conflict_display_style_t style, 
        apr_pool_t pool) -> svn_error_t
    """
  return _diff.svn_diff_mem_string_output_merge2(*args)

def svn_diff_mem_string_output_merge(*args):
  """
    svn_diff_mem_string_output_merge(svn_stream_t * output_stream, svn_diff_t * diff, svn_string_t const * original, svn_string_t const * modified, 
        svn_string_t const * latest, char const * conflict_original, 
        char const * conflict_modified, char const * conflict_latest, 
        char const * conflict_separator, svn_boolean_t display_original_in_conflict, 
        svn_boolean_t display_resolved_conflicts, apr_pool_t pool) -> svn_error_t
    """
  return _diff.svn_diff_mem_string_output_merge(*args)
svn_diff_op_unchanged = _diff.svn_diff_op_unchanged
svn_diff_op_added = _diff.svn_diff_op_added
svn_diff_op_deleted = _diff.svn_diff_op_deleted
svn_diff_op_copied = _diff.svn_diff_op_copied
svn_diff_op_moved = _diff.svn_diff_op_moved
svn_diff_op_modified = _diff.svn_diff_op_modified

def svn_diff_hunk_readline_diff_text(*args):
  """svn_diff_hunk_readline_diff_text(svn_diff_hunk_t * hunk, apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t"""
  return _diff.svn_diff_hunk_readline_diff_text(*args)

def svn_diff_hunk_readline_original_text(*args):
  """svn_diff_hunk_readline_original_text(svn_diff_hunk_t * hunk, apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t"""
  return _diff.svn_diff_hunk_readline_original_text(*args)

def svn_diff_hunk_readline_modified_text(*args):
  """svn_diff_hunk_readline_modified_text(svn_diff_hunk_t * hunk, apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t"""
  return _diff.svn_diff_hunk_readline_modified_text(*args)

def svn_diff_hunk_reset_diff_text(*args):
  """svn_diff_hunk_reset_diff_text(svn_diff_hunk_t * hunk)"""
  return _diff.svn_diff_hunk_reset_diff_text(*args)

def svn_diff_hunk_reset_original_text(*args):
  """svn_diff_hunk_reset_original_text(svn_diff_hunk_t * hunk)"""
  return _diff.svn_diff_hunk_reset_original_text(*args)

def svn_diff_hunk_reset_modified_text(*args):
  """svn_diff_hunk_reset_modified_text(svn_diff_hunk_t * hunk)"""
  return _diff.svn_diff_hunk_reset_modified_text(*args)

def svn_diff_hunk_get_original_start(*args):
  """svn_diff_hunk_get_original_start(svn_diff_hunk_t const * hunk) -> svn_linenum_t"""
  return _diff.svn_diff_hunk_get_original_start(*args)

def svn_diff_hunk_get_original_length(*args):
  """svn_diff_hunk_get_original_length(svn_diff_hunk_t const * hunk) -> svn_linenum_t"""
  return _diff.svn_diff_hunk_get_original_length(*args)

def svn_diff_hunk_get_modified_start(*args):
  """svn_diff_hunk_get_modified_start(svn_diff_hunk_t const * hunk) -> svn_linenum_t"""
  return _diff.svn_diff_hunk_get_modified_start(*args)

def svn_diff_hunk_get_modified_length(*args):
  """svn_diff_hunk_get_modified_length(svn_diff_hunk_t const * hunk) -> svn_linenum_t"""
  return _diff.svn_diff_hunk_get_modified_length(*args)

def svn_diff_hunk_get_leading_context(*args):
  """svn_diff_hunk_get_leading_context(svn_diff_hunk_t const * hunk) -> svn_linenum_t"""
  return _diff.svn_diff_hunk_get_leading_context(*args)

def svn_diff_hunk_get_trailing_context(*args):
  """svn_diff_hunk_get_trailing_context(svn_diff_hunk_t const * hunk) -> svn_linenum_t"""
  return _diff.svn_diff_hunk_get_trailing_context(*args)
class svn_prop_patch_t:
    """Proxy of C svn_prop_patch_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_prop_patch_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_prop_patch_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["name"] = _diff.svn_prop_patch_t_name_set
    __swig_getmethods__["name"] = _diff.svn_prop_patch_t_name_get
    __swig_setmethods__["operation"] = _diff.svn_prop_patch_t_operation_set
    __swig_getmethods__["operation"] = _diff.svn_prop_patch_t_operation_get
    __swig_setmethods__["hunks"] = _diff.svn_prop_patch_t_hunks_set
    __swig_getmethods__["hunks"] = _diff.svn_prop_patch_t_hunks_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 __init__(self): 
        """__init__(svn_prop_patch_t self) -> svn_prop_patch_t"""
        this = _diff.new_svn_prop_patch_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _diff.delete_svn_prop_patch_t
    __del__ = lambda self : None;
svn_prop_patch_t_swigregister = _diff.svn_prop_patch_t_swigregister
svn_prop_patch_t_swigregister(svn_prop_patch_t)

class svn_patch_t:
    """Proxy of C svn_patch_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_patch_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_patch_t, name)
    __repr__ = _swig_repr
    __swig_setmethods__["old_filename"] = _diff.svn_patch_t_old_filename_set
    __swig_getmethods__["old_filename"] = _diff.svn_patch_t_old_filename_get
    __swig_setmethods__["new_filename"] = _diff.svn_patch_t_new_filename_set
    __swig_getmethods__["new_filename"] = _diff.svn_patch_t_new_filename_get
    __swig_setmethods__["hunks"] = _diff.svn_patch_t_hunks_set
    __swig_getmethods__["hunks"] = _diff.svn_patch_t_hunks_get
    __swig_setmethods__["prop_patches"] = _diff.svn_patch_t_prop_patches_set
    __swig_getmethods__["prop_patches"] = _diff.svn_patch_t_prop_patches_get
    __swig_setmethods__["operation"] = _diff.svn_patch_t_operation_set
    __swig_getmethods__["operation"] = _diff.svn_patch_t_operation_get
    __swig_setmethods__["reverse"] = _diff.svn_patch_t_reverse_set
    __swig_getmethods__["reverse"] = _diff.svn_patch_t_reverse_get
    __swig_setmethods__["mergeinfo"] = _diff.svn_patch_t_mergeinfo_set
    __swig_getmethods__["mergeinfo"] = _diff.svn_patch_t_mergeinfo_get
    __swig_setmethods__["reverse_mergeinfo"] = _diff.svn_patch_t_reverse_mergeinfo_set
    __swig_getmethods__["reverse_mergeinfo"] = _diff.svn_patch_t_reverse_mergeinfo_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 __init__(self): 
        """__init__(svn_patch_t self) -> svn_patch_t"""
        this = _diff.new_svn_patch_t()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _diff.delete_svn_patch_t
    __del__ = lambda self : None;
svn_patch_t_swigregister = _diff.svn_patch_t_swigregister
svn_patch_t_swigregister(svn_patch_t)


def svn_diff_open_patch_file(*args):
  """svn_diff_open_patch_file(char const * local_abspath, apr_pool_t result_pool) -> svn_error_t"""
  return _diff.svn_diff_open_patch_file(*args)

def svn_diff_parse_next_patch(*args):
  """
    svn_diff_parse_next_patch(svn_patch_file_t * patch_file, svn_boolean_t reverse, svn_boolean_t ignore_whitespace, 
        apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t
    """
  return _diff.svn_diff_parse_next_patch(*args)

def svn_diff_close_patch_file(*args):
  """svn_diff_close_patch_file(svn_patch_file_t * patch_file, apr_pool_t scratch_pool) -> svn_error_t"""
  return _diff.svn_diff_close_patch_file(*args)
class svn_diff_t:
    """Proxy of C svn_diff_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_diff_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_diff_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_diff_t_swigregister = _diff.svn_diff_t_swigregister
svn_diff_t_swigregister(svn_diff_t)

class svn_diff_hunk_t:
    """Proxy of C svn_diff_hunk_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_diff_hunk_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_diff_hunk_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_diff_hunk_t_swigregister = _diff.svn_diff_hunk_t_swigregister
svn_diff_hunk_t_swigregister(svn_diff_hunk_t)

class svn_patch_file_t:
    """Proxy of C svn_patch_file_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_patch_file_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_patch_file_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_patch_file_t_swigregister = _diff.svn_patch_file_t_swigregister
svn_patch_file_t_swigregister(svn_patch_file_t)


def svn_diff_fns2_invoke_datasources_open(*args):
  """
    svn_diff_fns2_invoke_datasources_open(svn_diff_fns2_t _obj, void * diff_baton, apr_off_t * prefix_lines, apr_off_t * suffix_lines, 
        svn_diff_datasource_e const * datasources, apr_size_t datasources_len) -> svn_error_t
    """
  return _diff.svn_diff_fns2_invoke_datasources_open(*args)

def svn_diff_fns2_invoke_datasource_close(*args):
  """svn_diff_fns2_invoke_datasource_close(svn_diff_fns2_t _obj, void * diff_baton, svn_diff_datasource_e datasource) -> svn_error_t"""
  return _diff.svn_diff_fns2_invoke_datasource_close(*args)

def svn_diff_fns2_invoke_datasource_get_next_token(*args):
  """svn_diff_fns2_invoke_datasource_get_next_token(svn_diff_fns2_t _obj, void * diff_baton, svn_diff_datasource_e datasource) -> svn_error_t"""
  return _diff.svn_diff_fns2_invoke_datasource_get_next_token(*args)

def svn_diff_fns2_invoke_token_compare(*args):
  """svn_diff_fns2_invoke_token_compare(svn_diff_fns2_t _obj, void * diff_baton, void * ltoken, void * rtoken) -> svn_error_t"""
  return _diff.svn_diff_fns2_invoke_token_compare(*args)

def svn_diff_fns2_invoke_token_discard(*args):
  """svn_diff_fns2_invoke_token_discard(svn_diff_fns2_t _obj, void * diff_baton, void * token)"""
  return _diff.svn_diff_fns2_invoke_token_discard(*args)

def svn_diff_fns2_invoke_token_discard_all(*args):
  """svn_diff_fns2_invoke_token_discard_all(svn_diff_fns2_t _obj, void * diff_baton)"""
  return _diff.svn_diff_fns2_invoke_token_discard_all(*args)

def svn_diff_fns_invoke_datasource_open(*args):
  """svn_diff_fns_invoke_datasource_open(svn_diff_fns_t _obj, void * diff_baton, svn_diff_datasource_e datasource) -> svn_error_t"""
  return _diff.svn_diff_fns_invoke_datasource_open(*args)

def svn_diff_fns_invoke_datasource_close(*args):
  """svn_diff_fns_invoke_datasource_close(svn_diff_fns_t _obj, void * diff_baton, svn_diff_datasource_e datasource) -> svn_error_t"""
  return _diff.svn_diff_fns_invoke_datasource_close(*args)

def svn_diff_fns_invoke_datasource_get_next_token(*args):
  """svn_diff_fns_invoke_datasource_get_next_token(svn_diff_fns_t _obj, void * diff_baton, svn_diff_datasource_e datasource) -> svn_error_t"""
  return _diff.svn_diff_fns_invoke_datasource_get_next_token(*args)

def svn_diff_fns_invoke_token_compare(*args):
  """svn_diff_fns_invoke_token_compare(svn_diff_fns_t _obj, void * diff_baton, void * ltoken, void * rtoken) -> svn_error_t"""
  return _diff.svn_diff_fns_invoke_token_compare(*args)

def svn_diff_fns_invoke_token_discard(*args):
  """svn_diff_fns_invoke_token_discard(svn_diff_fns_t _obj, void * diff_baton, void * token)"""
  return _diff.svn_diff_fns_invoke_token_discard(*args)

def svn_diff_fns_invoke_token_discard_all(*args):
  """svn_diff_fns_invoke_token_discard_all(svn_diff_fns_t _obj, void * diff_baton)"""
  return _diff.svn_diff_fns_invoke_token_discard_all(*args)

def svn_diff_output_fns_invoke_output_common(*args):
  """
    svn_diff_output_fns_invoke_output_common(svn_diff_output_fns_t _obj, void * output_baton, apr_off_t original_start, apr_off_t original_length, 
        apr_off_t modified_start, apr_off_t modified_length, apr_off_t latest_start, 
        apr_off_t latest_length) -> svn_error_t
    """
  return _diff.svn_diff_output_fns_invoke_output_common(*args)

def svn_diff_output_fns_invoke_output_diff_modified(*args):
  """
    svn_diff_output_fns_invoke_output_diff_modified(svn_diff_output_fns_t _obj, void * output_baton, apr_off_t original_start, apr_off_t original_length, 
        apr_off_t modified_start, apr_off_t modified_length, apr_off_t latest_start, 
        apr_off_t latest_length) -> svn_error_t
    """
  return _diff.svn_diff_output_fns_invoke_output_diff_modified(*args)

def svn_diff_output_fns_invoke_output_diff_latest(*args):
  """
    svn_diff_output_fns_invoke_output_diff_latest(svn_diff_output_fns_t _obj, void * output_baton, apr_off_t original_start, apr_off_t original_length, 
        apr_off_t modified_start, apr_off_t modified_length, apr_off_t latest_start, 
        apr_off_t latest_length) -> svn_error_t
    """
  return _diff.svn_diff_output_fns_invoke_output_diff_latest(*args)

def svn_diff_output_fns_invoke_output_diff_common(*args):
  """
    svn_diff_output_fns_invoke_output_diff_common(svn_diff_output_fns_t _obj, void * output_baton, apr_off_t original_start, apr_off_t original_length, 
        apr_off_t modified_start, apr_off_t modified_length, apr_off_t latest_start, 
        apr_off_t latest_length) -> svn_error_t
    """
  return _diff.svn_diff_output_fns_invoke_output_diff_common(*args)

def svn_diff_output_fns_invoke_output_conflict(*args):
  """
    svn_diff_output_fns_invoke_output_conflict(svn_diff_output_fns_t _obj, void * output_baton, apr_off_t original_start, apr_off_t original_length, 
        apr_off_t modified_start, apr_off_t modified_length, apr_off_t latest_start, 
        apr_off_t latest_length, svn_diff_t * resolved_diff) -> svn_error_t
    """
  return _diff.svn_diff_output_fns_invoke_output_conflict(*args)
# This file is compatible with both classic and new-style classes.


