# This file was created automatically by SWIG.
# Don't modify this file, modify the SWIG interface instead.
# This file is compatible with both classic and new-style classes.

import _core

def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "this"):
        if isinstance(value, class_type):
            self.__dict__[name] = value.this
            if hasattr(value,"thisown"): self.__dict__["thisown"] = value.thisown
            del value.thisown
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static) or hasattr(self,name) or (name == "thisown"):
        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):
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError,name

SWIG_SVN_INVALID_REVNUM = _core.SWIG_SVN_INVALID_REVNUM
SWIG_SVN_IGNORED_REVNUM = _core.SWIG_SVN_IGNORED_REVNUM

def apr_initialize(*args):
    """apr_initialize() -> apr_status_t"""
    return apply(_core.apr_initialize, args)

def apr_terminate(*args):
    """apr_terminate()"""
    return apply(_core.apr_terminate, args)

def apr_time_ansi_put(*args):
    """apr_time_ansi_put(apr_time_t result, time_t input) -> apr_status_t"""
    return apply(_core.apr_time_ansi_put, args)

def apr_pool_destroy(*args):
    """apr_pool_destroy(apr_pool_t p)"""
    return apply(_core.apr_pool_destroy, args)

def apr_pool_clear(*args):
    """apr_pool_clear(apr_pool_t p)"""
    return apply(_core.apr_pool_clear, args)

def apr_file_open_stdout(*args):
    """apr_file_open_stdout(apr_file_t out, apr_pool_t pool) -> apr_status_t"""
    return apply(_core.apr_file_open_stdout, args)

def apr_file_open_stderr(*args):
    """apr_file_open_stderr(apr_file_t out, apr_pool_t pool) -> apr_status_t"""
    return apply(_core.apr_file_open_stderr, args)
SVN_ERR_CATEGORY_SIZE = _core.SVN_ERR_CATEGORY_SIZE
SVN_WARNING = _core.SVN_WARNING
SVN_ERR_BAD_CONTAINING_POOL = _core.SVN_ERR_BAD_CONTAINING_POOL
SVN_ERR_BAD_FILENAME = _core.SVN_ERR_BAD_FILENAME
SVN_ERR_BAD_URL = _core.SVN_ERR_BAD_URL
SVN_ERR_BAD_DATE = _core.SVN_ERR_BAD_DATE
SVN_ERR_BAD_MIME_TYPE = _core.SVN_ERR_BAD_MIME_TYPE
SVN_ERR_BAD_PROPERTY_VALUE = _core.SVN_ERR_BAD_PROPERTY_VALUE
SVN_ERR_BAD_VERSION_FILE_FORMAT = _core.SVN_ERR_BAD_VERSION_FILE_FORMAT
SVN_ERR_BAD_RELATIVE_PATH = _core.SVN_ERR_BAD_RELATIVE_PATH
SVN_ERR_BAD_UUID = _core.SVN_ERR_BAD_UUID
SVN_ERR_BAD_CONFIG_VALUE = _core.SVN_ERR_BAD_CONFIG_VALUE
SVN_ERR_BAD_SERVER_SPECIFICATION = _core.SVN_ERR_BAD_SERVER_SPECIFICATION
SVN_ERR_BAD_CHECKSUM_KIND = _core.SVN_ERR_BAD_CHECKSUM_KIND
SVN_ERR_BAD_CHECKSUM_PARSE = _core.SVN_ERR_BAD_CHECKSUM_PARSE
SVN_ERR_XML_ATTRIB_NOT_FOUND = _core.SVN_ERR_XML_ATTRIB_NOT_FOUND
SVN_ERR_XML_MISSING_ANCESTRY = _core.SVN_ERR_XML_MISSING_ANCESTRY
SVN_ERR_XML_UNKNOWN_ENCODING = _core.SVN_ERR_XML_UNKNOWN_ENCODING
SVN_ERR_XML_MALFORMED = _core.SVN_ERR_XML_MALFORMED
SVN_ERR_XML_UNESCAPABLE_DATA = _core.SVN_ERR_XML_UNESCAPABLE_DATA
SVN_ERR_IO_INCONSISTENT_EOL = _core.SVN_ERR_IO_INCONSISTENT_EOL
SVN_ERR_IO_UNKNOWN_EOL = _core.SVN_ERR_IO_UNKNOWN_EOL
SVN_ERR_IO_CORRUPT_EOL = _core.SVN_ERR_IO_CORRUPT_EOL
SVN_ERR_IO_UNIQUE_NAMES_EXHAUSTED = _core.SVN_ERR_IO_UNIQUE_NAMES_EXHAUSTED
SVN_ERR_IO_PIPE_FRAME_ERROR = _core.SVN_ERR_IO_PIPE_FRAME_ERROR
SVN_ERR_IO_PIPE_READ_ERROR = _core.SVN_ERR_IO_PIPE_READ_ERROR
SVN_ERR_IO_WRITE_ERROR = _core.SVN_ERR_IO_WRITE_ERROR
SVN_ERR_STREAM_UNEXPECTED_EOF = _core.SVN_ERR_STREAM_UNEXPECTED_EOF
SVN_ERR_STREAM_MALFORMED_DATA = _core.SVN_ERR_STREAM_MALFORMED_DATA
SVN_ERR_STREAM_UNRECOGNIZED_DATA = _core.SVN_ERR_STREAM_UNRECOGNIZED_DATA
SVN_ERR_NODE_UNKNOWN_KIND = _core.SVN_ERR_NODE_UNKNOWN_KIND
SVN_ERR_NODE_UNEXPECTED_KIND = _core.SVN_ERR_NODE_UNEXPECTED_KIND
SVN_ERR_ENTRY_NOT_FOUND = _core.SVN_ERR_ENTRY_NOT_FOUND
SVN_ERR_ENTRY_EXISTS = _core.SVN_ERR_ENTRY_EXISTS
SVN_ERR_ENTRY_MISSING_REVISION = _core.SVN_ERR_ENTRY_MISSING_REVISION
SVN_ERR_ENTRY_MISSING_URL = _core.SVN_ERR_ENTRY_MISSING_URL
SVN_ERR_ENTRY_ATTRIBUTE_INVALID = _core.SVN_ERR_ENTRY_ATTRIBUTE_INVALID
SVN_ERR_ENTRY_FORBIDDEN = _core.SVN_ERR_ENTRY_FORBIDDEN
SVN_ERR_WC_OBSTRUCTED_UPDATE = _core.SVN_ERR_WC_OBSTRUCTED_UPDATE
SVN_ERR_WC_UNWIND_MISMATCH = _core.SVN_ERR_WC_UNWIND_MISMATCH
SVN_ERR_WC_UNWIND_EMPTY = _core.SVN_ERR_WC_UNWIND_EMPTY
SVN_ERR_WC_UNWIND_NOT_EMPTY = _core.SVN_ERR_WC_UNWIND_NOT_EMPTY
SVN_ERR_WC_LOCKED = _core.SVN_ERR_WC_LOCKED
SVN_ERR_WC_NOT_LOCKED = _core.SVN_ERR_WC_NOT_LOCKED
SVN_ERR_WC_INVALID_LOCK = _core.SVN_ERR_WC_INVALID_LOCK
SVN_ERR_WC_NOT_DIRECTORY = _core.SVN_ERR_WC_NOT_DIRECTORY
SVN_ERR_WC_NOT_FILE = _core.SVN_ERR_WC_NOT_FILE
SVN_ERR_WC_BAD_ADM_LOG = _core.SVN_ERR_WC_BAD_ADM_LOG
SVN_ERR_WC_PATH_NOT_FOUND = _core.SVN_ERR_WC_PATH_NOT_FOUND
SVN_ERR_WC_NOT_UP_TO_DATE = _core.SVN_ERR_WC_NOT_UP_TO_DATE
SVN_ERR_WC_LEFT_LOCAL_MOD = _core.SVN_ERR_WC_LEFT_LOCAL_MOD
SVN_ERR_WC_SCHEDULE_CONFLICT = _core.SVN_ERR_WC_SCHEDULE_CONFLICT
SVN_ERR_WC_PATH_FOUND = _core.SVN_ERR_WC_PATH_FOUND
SVN_ERR_WC_FOUND_CONFLICT = _core.SVN_ERR_WC_FOUND_CONFLICT
SVN_ERR_WC_CORRUPT = _core.SVN_ERR_WC_CORRUPT
SVN_ERR_WC_CORRUPT_TEXT_BASE = _core.SVN_ERR_WC_CORRUPT_TEXT_BASE
SVN_ERR_WC_NODE_KIND_CHANGE = _core.SVN_ERR_WC_NODE_KIND_CHANGE
SVN_ERR_WC_INVALID_OP_ON_CWD = _core.SVN_ERR_WC_INVALID_OP_ON_CWD
SVN_ERR_WC_BAD_ADM_LOG_START = _core.SVN_ERR_WC_BAD_ADM_LOG_START
SVN_ERR_WC_UNSUPPORTED_FORMAT = _core.SVN_ERR_WC_UNSUPPORTED_FORMAT
SVN_ERR_WC_BAD_PATH = _core.SVN_ERR_WC_BAD_PATH
SVN_ERR_WC_INVALID_SCHEDULE = _core.SVN_ERR_WC_INVALID_SCHEDULE
SVN_ERR_WC_INVALID_RELOCATION = _core.SVN_ERR_WC_INVALID_RELOCATION
SVN_ERR_WC_INVALID_SWITCH = _core.SVN_ERR_WC_INVALID_SWITCH
SVN_ERR_WC_MISMATCHED_CHANGELIST = _core.SVN_ERR_WC_MISMATCHED_CHANGELIST
SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE = _core.SVN_ERR_WC_CONFLICT_RESOLVER_FAILURE
SVN_ERR_WC_COPYFROM_PATH_NOT_FOUND = _core.SVN_ERR_WC_COPYFROM_PATH_NOT_FOUND
SVN_ERR_WC_CHANGELIST_MOVE = _core.SVN_ERR_WC_CHANGELIST_MOVE
SVN_ERR_WC_CANNOT_DELETE_FILE_EXTERNAL = _core.SVN_ERR_WC_CANNOT_DELETE_FILE_EXTERNAL
SVN_ERR_WC_CANNOT_MOVE_FILE_EXTERNAL = _core.SVN_ERR_WC_CANNOT_MOVE_FILE_EXTERNAL
SVN_ERR_FS_GENERAL = _core.SVN_ERR_FS_GENERAL
SVN_ERR_FS_CLEANUP = _core.SVN_ERR_FS_CLEANUP
SVN_ERR_FS_ALREADY_OPEN = _core.SVN_ERR_FS_ALREADY_OPEN
SVN_ERR_FS_NOT_OPEN = _core.SVN_ERR_FS_NOT_OPEN
SVN_ERR_FS_CORRUPT = _core.SVN_ERR_FS_CORRUPT
SVN_ERR_FS_PATH_SYNTAX = _core.SVN_ERR_FS_PATH_SYNTAX
SVN_ERR_FS_NO_SUCH_REVISION = _core.SVN_ERR_FS_NO_SUCH_REVISION
SVN_ERR_FS_NO_SUCH_TRANSACTION = _core.SVN_ERR_FS_NO_SUCH_TRANSACTION
SVN_ERR_FS_NO_SUCH_ENTRY = _core.SVN_ERR_FS_NO_SUCH_ENTRY
SVN_ERR_FS_NO_SUCH_REPRESENTATION = _core.SVN_ERR_FS_NO_SUCH_REPRESENTATION
SVN_ERR_FS_NO_SUCH_STRING = _core.SVN_ERR_FS_NO_SUCH_STRING
SVN_ERR_FS_NO_SUCH_COPY = _core.SVN_ERR_FS_NO_SUCH_COPY
SVN_ERR_FS_TRANSACTION_NOT_MUTABLE = _core.SVN_ERR_FS_TRANSACTION_NOT_MUTABLE
SVN_ERR_FS_NOT_FOUND = _core.SVN_ERR_FS_NOT_FOUND
SVN_ERR_FS_ID_NOT_FOUND = _core.SVN_ERR_FS_ID_NOT_FOUND
SVN_ERR_FS_NOT_ID = _core.SVN_ERR_FS_NOT_ID
SVN_ERR_FS_NOT_DIRECTORY = _core.SVN_ERR_FS_NOT_DIRECTORY
SVN_ERR_FS_NOT_FILE = _core.SVN_ERR_FS_NOT_FILE
SVN_ERR_FS_NOT_SINGLE_PATH_COMPONENT = _core.SVN_ERR_FS_NOT_SINGLE_PATH_COMPONENT
SVN_ERR_FS_NOT_MUTABLE = _core.SVN_ERR_FS_NOT_MUTABLE
SVN_ERR_FS_ALREADY_EXISTS = _core.SVN_ERR_FS_ALREADY_EXISTS
SVN_ERR_FS_ROOT_DIR = _core.SVN_ERR_FS_ROOT_DIR
SVN_ERR_FS_NOT_TXN_ROOT = _core.SVN_ERR_FS_NOT_TXN_ROOT
SVN_ERR_FS_NOT_REVISION_ROOT = _core.SVN_ERR_FS_NOT_REVISION_ROOT
SVN_ERR_FS_CONFLICT = _core.SVN_ERR_FS_CONFLICT
SVN_ERR_FS_REP_CHANGED = _core.SVN_ERR_FS_REP_CHANGED
SVN_ERR_FS_REP_NOT_MUTABLE = _core.SVN_ERR_FS_REP_NOT_MUTABLE
SVN_ERR_FS_MALFORMED_SKEL = _core.SVN_ERR_FS_MALFORMED_SKEL
SVN_ERR_FS_TXN_OUT_OF_DATE = _core.SVN_ERR_FS_TXN_OUT_OF_DATE
SVN_ERR_FS_BERKELEY_DB = _core.SVN_ERR_FS_BERKELEY_DB
SVN_ERR_FS_BERKELEY_DB_DEADLOCK = _core.SVN_ERR_FS_BERKELEY_DB_DEADLOCK
SVN_ERR_FS_TRANSACTION_DEAD = _core.SVN_ERR_FS_TRANSACTION_DEAD
SVN_ERR_FS_TRANSACTION_NOT_DEAD = _core.SVN_ERR_FS_TRANSACTION_NOT_DEAD
SVN_ERR_FS_UNKNOWN_FS_TYPE = _core.SVN_ERR_FS_UNKNOWN_FS_TYPE
SVN_ERR_FS_NO_USER = _core.SVN_ERR_FS_NO_USER
SVN_ERR_FS_PATH_ALREADY_LOCKED = _core.SVN_ERR_FS_PATH_ALREADY_LOCKED
SVN_ERR_FS_PATH_NOT_LOCKED = _core.SVN_ERR_FS_PATH_NOT_LOCKED
SVN_ERR_FS_BAD_LOCK_TOKEN = _core.SVN_ERR_FS_BAD_LOCK_TOKEN
SVN_ERR_FS_NO_LOCK_TOKEN = _core.SVN_ERR_FS_NO_LOCK_TOKEN
SVN_ERR_FS_LOCK_OWNER_MISMATCH = _core.SVN_ERR_FS_LOCK_OWNER_MISMATCH
SVN_ERR_FS_NO_SUCH_LOCK = _core.SVN_ERR_FS_NO_SUCH_LOCK
SVN_ERR_FS_LOCK_EXPIRED = _core.SVN_ERR_FS_LOCK_EXPIRED
SVN_ERR_FS_OUT_OF_DATE = _core.SVN_ERR_FS_OUT_OF_DATE
SVN_ERR_FS_UNSUPPORTED_FORMAT = _core.SVN_ERR_FS_UNSUPPORTED_FORMAT
SVN_ERR_FS_REP_BEING_WRITTEN = _core.SVN_ERR_FS_REP_BEING_WRITTEN
SVN_ERR_FS_TXN_NAME_TOO_LONG = _core.SVN_ERR_FS_TXN_NAME_TOO_LONG
SVN_ERR_FS_NO_SUCH_NODE_ORIGIN = _core.SVN_ERR_FS_NO_SUCH_NODE_ORIGIN
SVN_ERR_FS_UNSUPPORTED_UPGRADE = _core.SVN_ERR_FS_UNSUPPORTED_UPGRADE
SVN_ERR_FS_NO_SUCH_CHECKSUM_REP = _core.SVN_ERR_FS_NO_SUCH_CHECKSUM_REP
SVN_ERR_REPOS_LOCKED = _core.SVN_ERR_REPOS_LOCKED
SVN_ERR_REPOS_HOOK_FAILURE = _core.SVN_ERR_REPOS_HOOK_FAILURE
SVN_ERR_REPOS_BAD_ARGS = _core.SVN_ERR_REPOS_BAD_ARGS
SVN_ERR_REPOS_NO_DATA_FOR_REPORT = _core.SVN_ERR_REPOS_NO_DATA_FOR_REPORT
SVN_ERR_REPOS_BAD_REVISION_REPORT = _core.SVN_ERR_REPOS_BAD_REVISION_REPORT
SVN_ERR_REPOS_UNSUPPORTED_VERSION = _core.SVN_ERR_REPOS_UNSUPPORTED_VERSION
SVN_ERR_REPOS_DISABLED_FEATURE = _core.SVN_ERR_REPOS_DISABLED_FEATURE
SVN_ERR_REPOS_POST_COMMIT_HOOK_FAILED = _core.SVN_ERR_REPOS_POST_COMMIT_HOOK_FAILED
SVN_ERR_REPOS_POST_LOCK_HOOK_FAILED = _core.SVN_ERR_REPOS_POST_LOCK_HOOK_FAILED
SVN_ERR_REPOS_POST_UNLOCK_HOOK_FAILED = _core.SVN_ERR_REPOS_POST_UNLOCK_HOOK_FAILED
SVN_ERR_REPOS_UNSUPPORTED_UPGRADE = _core.SVN_ERR_REPOS_UNSUPPORTED_UPGRADE
SVN_ERR_RA_ILLEGAL_URL = _core.SVN_ERR_RA_ILLEGAL_URL
SVN_ERR_RA_NOT_AUTHORIZED = _core.SVN_ERR_RA_NOT_AUTHORIZED
SVN_ERR_RA_UNKNOWN_AUTH = _core.SVN_ERR_RA_UNKNOWN_AUTH
SVN_ERR_RA_NOT_IMPLEMENTED = _core.SVN_ERR_RA_NOT_IMPLEMENTED
SVN_ERR_RA_OUT_OF_DATE = _core.SVN_ERR_RA_OUT_OF_DATE
SVN_ERR_RA_NO_REPOS_UUID = _core.SVN_ERR_RA_NO_REPOS_UUID
SVN_ERR_RA_UNSUPPORTED_ABI_VERSION = _core.SVN_ERR_RA_UNSUPPORTED_ABI_VERSION
SVN_ERR_RA_NOT_LOCKED = _core.SVN_ERR_RA_NOT_LOCKED
SVN_ERR_RA_PARTIAL_REPLAY_NOT_SUPPORTED = _core.SVN_ERR_RA_PARTIAL_REPLAY_NOT_SUPPORTED
SVN_ERR_RA_UUID_MISMATCH = _core.SVN_ERR_RA_UUID_MISMATCH
SVN_ERR_RA_REPOS_ROOT_URL_MISMATCH = _core.SVN_ERR_RA_REPOS_ROOT_URL_MISMATCH
SVN_ERR_RA_DAV_SOCK_INIT = _core.SVN_ERR_RA_DAV_SOCK_INIT
SVN_ERR_RA_DAV_CREATING_REQUEST = _core.SVN_ERR_RA_DAV_CREATING_REQUEST
SVN_ERR_RA_DAV_REQUEST_FAILED = _core.SVN_ERR_RA_DAV_REQUEST_FAILED
SVN_ERR_RA_DAV_OPTIONS_REQ_FAILED = _core.SVN_ERR_RA_DAV_OPTIONS_REQ_FAILED
SVN_ERR_RA_DAV_PROPS_NOT_FOUND = _core.SVN_ERR_RA_DAV_PROPS_NOT_FOUND
SVN_ERR_RA_DAV_ALREADY_EXISTS = _core.SVN_ERR_RA_DAV_ALREADY_EXISTS
SVN_ERR_RA_DAV_INVALID_CONFIG_VALUE = _core.SVN_ERR_RA_DAV_INVALID_CONFIG_VALUE
SVN_ERR_RA_DAV_PATH_NOT_FOUND = _core.SVN_ERR_RA_DAV_PATH_NOT_FOUND
SVN_ERR_RA_DAV_PROPPATCH_FAILED = _core.SVN_ERR_RA_DAV_PROPPATCH_FAILED
SVN_ERR_RA_DAV_MALFORMED_DATA = _core.SVN_ERR_RA_DAV_MALFORMED_DATA
SVN_ERR_RA_DAV_RESPONSE_HEADER_BADNESS = _core.SVN_ERR_RA_DAV_RESPONSE_HEADER_BADNESS
SVN_ERR_RA_DAV_RELOCATED = _core.SVN_ERR_RA_DAV_RELOCATED
SVN_ERR_RA_DAV_FORBIDDEN = _core.SVN_ERR_RA_DAV_FORBIDDEN
SVN_ERR_RA_LOCAL_REPOS_NOT_FOUND = _core.SVN_ERR_RA_LOCAL_REPOS_NOT_FOUND
SVN_ERR_RA_LOCAL_REPOS_OPEN_FAILED = _core.SVN_ERR_RA_LOCAL_REPOS_OPEN_FAILED
SVN_ERR_RA_SVN_CMD_ERR = _core.SVN_ERR_RA_SVN_CMD_ERR
SVN_ERR_RA_SVN_UNKNOWN_CMD = _core.SVN_ERR_RA_SVN_UNKNOWN_CMD
SVN_ERR_RA_SVN_CONNECTION_CLOSED = _core.SVN_ERR_RA_SVN_CONNECTION_CLOSED
SVN_ERR_RA_SVN_IO_ERROR = _core.SVN_ERR_RA_SVN_IO_ERROR
SVN_ERR_RA_SVN_MALFORMED_DATA = _core.SVN_ERR_RA_SVN_MALFORMED_DATA
SVN_ERR_RA_SVN_REPOS_NOT_FOUND = _core.SVN_ERR_RA_SVN_REPOS_NOT_FOUND
SVN_ERR_RA_SVN_BAD_VERSION = _core.SVN_ERR_RA_SVN_BAD_VERSION
SVN_ERR_RA_SVN_NO_MECHANISMS = _core.SVN_ERR_RA_SVN_NO_MECHANISMS
SVN_ERR_RA_SERF_SSPI_INITIALISATION_FAILED = _core.SVN_ERR_RA_SERF_SSPI_INITIALISATION_FAILED
SVN_ERR_RA_SERF_SSL_CERT_UNTRUSTED = _core.SVN_ERR_RA_SERF_SSL_CERT_UNTRUSTED
SVN_ERR_AUTHN_CREDS_UNAVAILABLE = _core.SVN_ERR_AUTHN_CREDS_UNAVAILABLE
SVN_ERR_AUTHN_NO_PROVIDER = _core.SVN_ERR_AUTHN_NO_PROVIDER
SVN_ERR_AUTHN_PROVIDERS_EXHAUSTED = _core.SVN_ERR_AUTHN_PROVIDERS_EXHAUSTED
SVN_ERR_AUTHN_CREDS_NOT_SAVED = _core.SVN_ERR_AUTHN_CREDS_NOT_SAVED
SVN_ERR_AUTHN_FAILED = _core.SVN_ERR_AUTHN_FAILED
SVN_ERR_AUTHZ_ROOT_UNREADABLE = _core.SVN_ERR_AUTHZ_ROOT_UNREADABLE
SVN_ERR_AUTHZ_UNREADABLE = _core.SVN_ERR_AUTHZ_UNREADABLE
SVN_ERR_AUTHZ_PARTIALLY_READABLE = _core.SVN_ERR_AUTHZ_PARTIALLY_READABLE
SVN_ERR_AUTHZ_INVALID_CONFIG = _core.SVN_ERR_AUTHZ_INVALID_CONFIG
SVN_ERR_AUTHZ_UNWRITABLE = _core.SVN_ERR_AUTHZ_UNWRITABLE
SVN_ERR_SVNDIFF_INVALID_HEADER = _core.SVN_ERR_SVNDIFF_INVALID_HEADER
SVN_ERR_SVNDIFF_CORRUPT_WINDOW = _core.SVN_ERR_SVNDIFF_CORRUPT_WINDOW
SVN_ERR_SVNDIFF_BACKWARD_VIEW = _core.SVN_ERR_SVNDIFF_BACKWARD_VIEW
SVN_ERR_SVNDIFF_INVALID_OPS = _core.SVN_ERR_SVNDIFF_INVALID_OPS
SVN_ERR_SVNDIFF_UNEXPECTED_END = _core.SVN_ERR_SVNDIFF_UNEXPECTED_END
SVN_ERR_SVNDIFF_INVALID_COMPRESSED_DATA = _core.SVN_ERR_SVNDIFF_INVALID_COMPRESSED_DATA
SVN_ERR_DIFF_DATASOURCE_MODIFIED = _core.SVN_ERR_DIFF_DATASOURCE_MODIFIED
SVN_ERR_APMOD_MISSING_PATH_TO_FS = _core.SVN_ERR_APMOD_MISSING_PATH_TO_FS
SVN_ERR_APMOD_MALFORMED_URI = _core.SVN_ERR_APMOD_MALFORMED_URI
SVN_ERR_APMOD_ACTIVITY_NOT_FOUND = _core.SVN_ERR_APMOD_ACTIVITY_NOT_FOUND
SVN_ERR_APMOD_BAD_BASELINE = _core.SVN_ERR_APMOD_BAD_BASELINE
SVN_ERR_APMOD_CONNECTION_ABORTED = _core.SVN_ERR_APMOD_CONNECTION_ABORTED
SVN_ERR_CLIENT_VERSIONED_PATH_REQUIRED = _core.SVN_ERR_CLIENT_VERSIONED_PATH_REQUIRED
SVN_ERR_CLIENT_RA_ACCESS_REQUIRED = _core.SVN_ERR_CLIENT_RA_ACCESS_REQUIRED
SVN_ERR_CLIENT_BAD_REVISION = _core.SVN_ERR_CLIENT_BAD_REVISION
SVN_ERR_CLIENT_DUPLICATE_COMMIT_URL = _core.SVN_ERR_CLIENT_DUPLICATE_COMMIT_URL
SVN_ERR_CLIENT_IS_BINARY_FILE = _core.SVN_ERR_CLIENT_IS_BINARY_FILE
SVN_ERR_CLIENT_INVALID_EXTERNALS_DESCRIPTION = _core.SVN_ERR_CLIENT_INVALID_EXTERNALS_DESCRIPTION
SVN_ERR_CLIENT_MODIFIED = _core.SVN_ERR_CLIENT_MODIFIED
SVN_ERR_CLIENT_IS_DIRECTORY = _core.SVN_ERR_CLIENT_IS_DIRECTORY
SVN_ERR_CLIENT_REVISION_RANGE = _core.SVN_ERR_CLIENT_REVISION_RANGE
SVN_ERR_CLIENT_INVALID_RELOCATION = _core.SVN_ERR_CLIENT_INVALID_RELOCATION
SVN_ERR_CLIENT_REVISION_AUTHOR_CONTAINS_NEWLINE = _core.SVN_ERR_CLIENT_REVISION_AUTHOR_CONTAINS_NEWLINE
SVN_ERR_CLIENT_PROPERTY_NAME = _core.SVN_ERR_CLIENT_PROPERTY_NAME
SVN_ERR_CLIENT_UNRELATED_RESOURCES = _core.SVN_ERR_CLIENT_UNRELATED_RESOURCES
SVN_ERR_CLIENT_MISSING_LOCK_TOKEN = _core.SVN_ERR_CLIENT_MISSING_LOCK_TOKEN
SVN_ERR_CLIENT_MULTIPLE_SOURCES_DISALLOWED = _core.SVN_ERR_CLIENT_MULTIPLE_SOURCES_DISALLOWED
SVN_ERR_CLIENT_NO_VERSIONED_PARENT = _core.SVN_ERR_CLIENT_NO_VERSIONED_PARENT
SVN_ERR_CLIENT_NOT_READY_TO_MERGE = _core.SVN_ERR_CLIENT_NOT_READY_TO_MERGE
SVN_ERR_CLIENT_FILE_EXTERNAL_OVERWRITE_VERSIONED = _core.SVN_ERR_CLIENT_FILE_EXTERNAL_OVERWRITE_VERSIONED
SVN_ERR_BASE = _core.SVN_ERR_BASE
SVN_ERR_PLUGIN_LOAD_FAILURE = _core.SVN_ERR_PLUGIN_LOAD_FAILURE
SVN_ERR_MALFORMED_FILE = _core.SVN_ERR_MALFORMED_FILE
SVN_ERR_INCOMPLETE_DATA = _core.SVN_ERR_INCOMPLETE_DATA
SVN_ERR_INCORRECT_PARAMS = _core.SVN_ERR_INCORRECT_PARAMS
SVN_ERR_UNVERSIONED_RESOURCE = _core.SVN_ERR_UNVERSIONED_RESOURCE
SVN_ERR_TEST_FAILED = _core.SVN_ERR_TEST_FAILED
SVN_ERR_UNSUPPORTED_FEATURE = _core.SVN_ERR_UNSUPPORTED_FEATURE
SVN_ERR_BAD_PROP_KIND = _core.SVN_ERR_BAD_PROP_KIND
SVN_ERR_ILLEGAL_TARGET = _core.SVN_ERR_ILLEGAL_TARGET
SVN_ERR_DELTA_MD5_CHECKSUM_ABSENT = _core.SVN_ERR_DELTA_MD5_CHECKSUM_ABSENT
SVN_ERR_DIR_NOT_EMPTY = _core.SVN_ERR_DIR_NOT_EMPTY
SVN_ERR_EXTERNAL_PROGRAM = _core.SVN_ERR_EXTERNAL_PROGRAM
SVN_ERR_SWIG_PY_EXCEPTION_SET = _core.SVN_ERR_SWIG_PY_EXCEPTION_SET
SVN_ERR_CHECKSUM_MISMATCH = _core.SVN_ERR_CHECKSUM_MISMATCH
SVN_ERR_CANCELLED = _core.SVN_ERR_CANCELLED
SVN_ERR_INVALID_DIFF_OPTION = _core.SVN_ERR_INVALID_DIFF_OPTION
SVN_ERR_PROPERTY_NOT_FOUND = _core.SVN_ERR_PROPERTY_NOT_FOUND
SVN_ERR_NO_AUTH_FILE_PATH = _core.SVN_ERR_NO_AUTH_FILE_PATH
SVN_ERR_VERSION_MISMATCH = _core.SVN_ERR_VERSION_MISMATCH
SVN_ERR_MERGEINFO_PARSE_ERROR = _core.SVN_ERR_MERGEINFO_PARSE_ERROR
SVN_ERR_CEASE_INVOCATION = _core.SVN_ERR_CEASE_INVOCATION
SVN_ERR_REVNUM_PARSE_FAILURE = _core.SVN_ERR_REVNUM_PARSE_FAILURE
SVN_ERR_ITER_BREAK = _core.SVN_ERR_ITER_BREAK
SVN_ERR_UNKNOWN_CHANGELIST = _core.SVN_ERR_UNKNOWN_CHANGELIST
SVN_ERR_RESERVED_FILENAME_SPECIFIED = _core.SVN_ERR_RESERVED_FILENAME_SPECIFIED
SVN_ERR_UNKNOWN_CAPABILITY = _core.SVN_ERR_UNKNOWN_CAPABILITY
SVN_ERR_TEST_SKIPPED = _core.SVN_ERR_TEST_SKIPPED
SVN_ERR_NO_APR_MEMCACHE = _core.SVN_ERR_NO_APR_MEMCACHE
SVN_ERR_ATOMIC_INIT_FAILURE = _core.SVN_ERR_ATOMIC_INIT_FAILURE
SVN_ERR_SQLITE_ERROR = _core.SVN_ERR_SQLITE_ERROR
SVN_ERR_SQLITE_READONLY = _core.SVN_ERR_SQLITE_READONLY
SVN_ERR_SQLITE_UNSUPPORTED_SCHEMA = _core.SVN_ERR_SQLITE_UNSUPPORTED_SCHEMA
SVN_ERR_CL_ARG_PARSING_ERROR = _core.SVN_ERR_CL_ARG_PARSING_ERROR
SVN_ERR_CL_INSUFFICIENT_ARGS = _core.SVN_ERR_CL_INSUFFICIENT_ARGS
SVN_ERR_CL_MUTUALLY_EXCLUSIVE_ARGS = _core.SVN_ERR_CL_MUTUALLY_EXCLUSIVE_ARGS
SVN_ERR_CL_ADM_DIR_RESERVED = _core.SVN_ERR_CL_ADM_DIR_RESERVED
SVN_ERR_CL_LOG_MESSAGE_IS_VERSIONED_FILE = _core.SVN_ERR_CL_LOG_MESSAGE_IS_VERSIONED_FILE
SVN_ERR_CL_LOG_MESSAGE_IS_PATHNAME = _core.SVN_ERR_CL_LOG_MESSAGE_IS_PATHNAME
SVN_ERR_CL_COMMIT_IN_ADDED_DIR = _core.SVN_ERR_CL_COMMIT_IN_ADDED_DIR
SVN_ERR_CL_NO_EXTERNAL_EDITOR = _core.SVN_ERR_CL_NO_EXTERNAL_EDITOR
SVN_ERR_CL_BAD_LOG_MESSAGE = _core.SVN_ERR_CL_BAD_LOG_MESSAGE
SVN_ERR_CL_UNNECESSARY_LOG_MESSAGE = _core.SVN_ERR_CL_UNNECESSARY_LOG_MESSAGE
SVN_ERR_CL_NO_EXTERNAL_MERGE_TOOL = _core.SVN_ERR_CL_NO_EXTERNAL_MERGE_TOOL
SVN_ERR_ASSERTION_FAIL = _core.SVN_ERR_ASSERTION_FAIL
SVN_ERR_LAST = _core.SVN_ERR_LAST

def svn_time_to_cstring(*args):
    """svn_time_to_cstring(apr_time_t when, apr_pool_t pool) -> char"""
    return apply(_core.svn_time_to_cstring, args)

def svn_time_from_cstring(*args):
    """svn_time_from_cstring(apr_time_t when, char data, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_time_from_cstring, args)

def svn_time_to_human_cstring(*args):
    """svn_time_to_human_cstring(apr_time_t when, apr_pool_t pool) -> char"""
    return apply(_core.svn_time_to_human_cstring, args)

def svn_parse_date(*args):
    """
    svn_parse_date(svn_boolean_t matched, apr_time_t result, char text, 
        apr_time_t now, apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_parse_date, args)

def svn_sleep_for_timestamps(*args):
    """svn_sleep_for_timestamps()"""
    return apply(_core.svn_sleep_for_timestamps, args)
class svn_error_t:
    """Proxy of C svn_error_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_error_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_error_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C svn_error_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["apr_err"] = _core.svn_error_t_apr_err_set
    __swig_getmethods__["apr_err"] = _core.svn_error_t_apr_err_get
    __swig_getmethods__["message"] = _core.svn_error_t_message_get
    __swig_setmethods__["child"] = _core.svn_error_t_child_set
    __swig_getmethods__["child"] = _core.svn_error_t_child_get
    __swig_setmethods__["pool"] = _core.svn_error_t_pool_set
    __swig_getmethods__["pool"] = _core.svn_error_t_pool_get
    __swig_getmethods__["file"] = _core.svn_error_t_file_get
    __swig_setmethods__["line"] = _core.svn_error_t_line_set
    __swig_getmethods__["line"] = _core.svn_error_t_line_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_error_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

    def __init__(self, *args):
        """__init__(self) -> svn_error_t"""
        _swig_setattr(self, svn_error_t, 'this', apply(_core.new_svn_error_t, args))
        _swig_setattr(self, svn_error_t, 'thisown', 1)
    def __del__(self, destroy=_core.delete_svn_error_t):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class svn_error_tPtr(svn_error_t):
    def __init__(self, this):
        _swig_setattr(self, svn_error_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_error_t, 'thisown', 0)
        _swig_setattr(self, svn_error_t,self.__class__,svn_error_t)
_core.svn_error_t_swigregister(svn_error_tPtr)

svn_node_none = _core.svn_node_none
svn_node_file = _core.svn_node_file
svn_node_dir = _core.svn_node_dir
svn_node_unknown = _core.svn_node_unknown

def svn_node_kind_to_word(*args):
    """svn_node_kind_to_word(svn_node_kind_t kind) -> char"""
    return apply(_core.svn_node_kind_to_word, args)

def svn_node_kind_from_word(*args):
    """svn_node_kind_from_word(char word) -> int"""
    return apply(_core.svn_node_kind_from_word, args)

def svn_revnum_parse(*args):
    """svn_revnum_parse(svn_revnum_t rev, char str, char endptr) -> svn_error_t"""
    return apply(_core.svn_revnum_parse, args)
SVN_REVNUM_T_FMT = _core.SVN_REVNUM_T_FMT
TRUE = _core.TRUE
FALSE = _core.FALSE
svn_nonrecursive = _core.svn_nonrecursive
svn_recursive = _core.svn_recursive
svn_depth_unknown = _core.svn_depth_unknown
svn_depth_exclude = _core.svn_depth_exclude
svn_depth_empty = _core.svn_depth_empty
svn_depth_files = _core.svn_depth_files
svn_depth_immediates = _core.svn_depth_immediates
svn_depth_infinity = _core.svn_depth_infinity

def svn_depth_to_word(*args):
    """svn_depth_to_word(svn_depth_t depth) -> char"""
    return apply(_core.svn_depth_to_word, args)

def svn_depth_from_word(*args):
    """svn_depth_from_word(char word) -> int"""
    return apply(_core.svn_depth_from_word, args)
SVN_DIRENT_KIND = _core.SVN_DIRENT_KIND
SVN_DIRENT_SIZE = _core.SVN_DIRENT_SIZE
SVN_DIRENT_HAS_PROPS = _core.SVN_DIRENT_HAS_PROPS
SVN_DIRENT_CREATED_REV = _core.SVN_DIRENT_CREATED_REV
SVN_DIRENT_TIME = _core.SVN_DIRENT_TIME
SVN_DIRENT_LAST_AUTHOR = _core.SVN_DIRENT_LAST_AUTHOR
class svn_dirent_t:
    """Proxy of C svn_dirent_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_dirent_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_dirent_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C svn_dirent_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["kind"] = _core.svn_dirent_t_kind_set
    __swig_getmethods__["kind"] = _core.svn_dirent_t_kind_get
    __swig_setmethods__["size"] = _core.svn_dirent_t_size_set
    __swig_getmethods__["size"] = _core.svn_dirent_t_size_get
    __swig_setmethods__["has_props"] = _core.svn_dirent_t_has_props_set
    __swig_getmethods__["has_props"] = _core.svn_dirent_t_has_props_get
    __swig_setmethods__["created_rev"] = _core.svn_dirent_t_created_rev_set
    __swig_getmethods__["created_rev"] = _core.svn_dirent_t_created_rev_get
    __swig_setmethods__["time"] = _core.svn_dirent_t_time_set
    __swig_getmethods__["time"] = _core.svn_dirent_t_time_get
    __swig_getmethods__["last_author"] = _core.svn_dirent_t_last_author_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_dirent_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

    def __init__(self, *args):
        """__init__(self) -> svn_dirent_t"""
        _swig_setattr(self, svn_dirent_t, 'this', apply(_core.new_svn_dirent_t, args))
        _swig_setattr(self, svn_dirent_t, 'thisown', 1)
    def __del__(self, destroy=_core.delete_svn_dirent_t):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class svn_dirent_tPtr(svn_dirent_t):
    def __init__(self, this):
        _swig_setattr(self, svn_dirent_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_dirent_t, 'thisown', 0)
        _swig_setattr(self, svn_dirent_t,self.__class__,svn_dirent_t)
_core.svn_dirent_t_swigregister(svn_dirent_tPtr)


def svn_dirent_dup(*args):
    """svn_dirent_dup(svn_dirent_t dirent, apr_pool_t pool) -> svn_dirent_t"""
    return apply(_core.svn_dirent_dup, args)
SVN_KEYWORD_MAX_LEN = _core.SVN_KEYWORD_MAX_LEN
SVN_KEYWORD_REVISION_LONG = _core.SVN_KEYWORD_REVISION_LONG
SVN_KEYWORD_REVISION_SHORT = _core.SVN_KEYWORD_REVISION_SHORT
SVN_KEYWORD_REVISION_MEDIUM = _core.SVN_KEYWORD_REVISION_MEDIUM
SVN_KEYWORD_DATE_LONG = _core.SVN_KEYWORD_DATE_LONG
SVN_KEYWORD_DATE_SHORT = _core.SVN_KEYWORD_DATE_SHORT
SVN_KEYWORD_AUTHOR_LONG = _core.SVN_KEYWORD_AUTHOR_LONG
SVN_KEYWORD_AUTHOR_SHORT = _core.SVN_KEYWORD_AUTHOR_SHORT
SVN_KEYWORD_URL_LONG = _core.SVN_KEYWORD_URL_LONG
SVN_KEYWORD_URL_SHORT = _core.SVN_KEYWORD_URL_SHORT
SVN_KEYWORD_ID = _core.SVN_KEYWORD_ID
SVN_KEYWORD_HEADER = _core.SVN_KEYWORD_HEADER
class svn_commit_info_t:
    """Proxy of C svn_commit_info_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_commit_info_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_commit_info_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C svn_commit_info_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["revision"] = _core.svn_commit_info_t_revision_set
    __swig_getmethods__["revision"] = _core.svn_commit_info_t_revision_get
    __swig_setmethods__["date"] = _core.svn_commit_info_t_date_set
    __swig_getmethods__["date"] = _core.svn_commit_info_t_date_get
    __swig_setmethods__["author"] = _core.svn_commit_info_t_author_set
    __swig_getmethods__["author"] = _core.svn_commit_info_t_author_get
    __swig_setmethods__["post_commit_err"] = _core.svn_commit_info_t_post_commit_err_set
    __swig_getmethods__["post_commit_err"] = _core.svn_commit_info_t_post_commit_err_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_commit_info_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

    def __init__(self, *args):
        """__init__(self) -> svn_commit_info_t"""
        _swig_setattr(self, svn_commit_info_t, 'this', apply(_core.new_svn_commit_info_t, args))
        _swig_setattr(self, svn_commit_info_t, 'thisown', 1)
    def __del__(self, destroy=_core.delete_svn_commit_info_t):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class svn_commit_info_tPtr(svn_commit_info_t):
    def __init__(self, this):
        _swig_setattr(self, svn_commit_info_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_commit_info_t, 'thisown', 0)
        _swig_setattr(self, svn_commit_info_t,self.__class__,svn_commit_info_t)
_core.svn_commit_info_t_swigregister(svn_commit_info_tPtr)


def svn_create_commit_info(*args):
    """svn_create_commit_info(apr_pool_t pool) -> svn_commit_info_t"""
    return apply(_core.svn_create_commit_info, args)

def svn_commit_info_dup(*args):
    """svn_commit_info_dup(svn_commit_info_t src_commit_info, apr_pool_t pool) -> svn_commit_info_t"""
    return apply(_core.svn_commit_info_dup, args)
class svn_log_changed_path2_t:
    """Proxy of C svn_log_changed_path2_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_log_changed_path2_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_log_changed_path2_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C svn_log_changed_path2_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["action"] = _core.svn_log_changed_path2_t_action_set
    __swig_getmethods__["action"] = _core.svn_log_changed_path2_t_action_get
    __swig_setmethods__["copyfrom_path"] = _core.svn_log_changed_path2_t_copyfrom_path_set
    __swig_getmethods__["copyfrom_path"] = _core.svn_log_changed_path2_t_copyfrom_path_get
    __swig_setmethods__["copyfrom_rev"] = _core.svn_log_changed_path2_t_copyfrom_rev_set
    __swig_getmethods__["copyfrom_rev"] = _core.svn_log_changed_path2_t_copyfrom_rev_get
    __swig_setmethods__["node_kind"] = _core.svn_log_changed_path2_t_node_kind_set
    __swig_getmethods__["node_kind"] = _core.svn_log_changed_path2_t_node_kind_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_log_changed_path2_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

    def __init__(self, *args):
        """__init__(self) -> svn_log_changed_path2_t"""
        _swig_setattr(self, svn_log_changed_path2_t, 'this', apply(_core.new_svn_log_changed_path2_t, args))
        _swig_setattr(self, svn_log_changed_path2_t, 'thisown', 1)
    def __del__(self, destroy=_core.delete_svn_log_changed_path2_t):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class svn_log_changed_path2_tPtr(svn_log_changed_path2_t):
    def __init__(self, this):
        _swig_setattr(self, svn_log_changed_path2_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_log_changed_path2_t, 'thisown', 0)
        _swig_setattr(self, svn_log_changed_path2_t,self.__class__,svn_log_changed_path2_t)
_core.svn_log_changed_path2_t_swigregister(svn_log_changed_path2_tPtr)


def svn_log_changed_path2_create(*args):
    """svn_log_changed_path2_create(apr_pool_t pool) -> svn_log_changed_path2_t"""
    return apply(_core.svn_log_changed_path2_create, args)

def svn_log_changed_path2_dup(*args):
    """svn_log_changed_path2_dup(svn_log_changed_path2_t changed_path, apr_pool_t pool) -> svn_log_changed_path2_t"""
    return apply(_core.svn_log_changed_path2_dup, args)
class svn_log_changed_path_t:
    """Proxy of C svn_log_changed_path_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_log_changed_path_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_log_changed_path_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C svn_log_changed_path_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["action"] = _core.svn_log_changed_path_t_action_set
    __swig_getmethods__["action"] = _core.svn_log_changed_path_t_action_get
    __swig_getmethods__["copyfrom_path"] = _core.svn_log_changed_path_t_copyfrom_path_get
    __swig_setmethods__["copyfrom_rev"] = _core.svn_log_changed_path_t_copyfrom_rev_set
    __swig_getmethods__["copyfrom_rev"] = _core.svn_log_changed_path_t_copyfrom_rev_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_log_changed_path_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

    def __init__(self, *args):
        """__init__(self) -> svn_log_changed_path_t"""
        _swig_setattr(self, svn_log_changed_path_t, 'this', apply(_core.new_svn_log_changed_path_t, args))
        _swig_setattr(self, svn_log_changed_path_t, 'thisown', 1)
    def __del__(self, destroy=_core.delete_svn_log_changed_path_t):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class svn_log_changed_path_tPtr(svn_log_changed_path_t):
    def __init__(self, this):
        _swig_setattr(self, svn_log_changed_path_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_log_changed_path_t, 'thisown', 0)
        _swig_setattr(self, svn_log_changed_path_t,self.__class__,svn_log_changed_path_t)
_core.svn_log_changed_path_t_swigregister(svn_log_changed_path_tPtr)


def svn_log_changed_path_dup(*args):
    """svn_log_changed_path_dup(svn_log_changed_path_t changed_path, apr_pool_t pool) -> svn_log_changed_path_t"""
    return apply(_core.svn_log_changed_path_dup, args)
class svn_log_entry_t:
    """Proxy of C svn_log_entry_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_log_entry_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_log_entry_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C svn_log_entry_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["changed_paths"] = _core.svn_log_entry_t_changed_paths_set
    __swig_getmethods__["changed_paths"] = _core.svn_log_entry_t_changed_paths_get
    __swig_setmethods__["revision"] = _core.svn_log_entry_t_revision_set
    __swig_getmethods__["revision"] = _core.svn_log_entry_t_revision_get
    __swig_setmethods__["revprops"] = _core.svn_log_entry_t_revprops_set
    __swig_getmethods__["revprops"] = _core.svn_log_entry_t_revprops_get
    __swig_setmethods__["has_children"] = _core.svn_log_entry_t_has_children_set
    __swig_getmethods__["has_children"] = _core.svn_log_entry_t_has_children_get
    __swig_setmethods__["changed_paths2"] = _core.svn_log_entry_t_changed_paths2_set
    __swig_getmethods__["changed_paths2"] = _core.svn_log_entry_t_changed_paths2_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_log_entry_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

    def __init__(self, *args):
        """__init__(self) -> svn_log_entry_t"""
        _swig_setattr(self, svn_log_entry_t, 'this', apply(_core.new_svn_log_entry_t, args))
        _swig_setattr(self, svn_log_entry_t, 'thisown', 1)
    def __del__(self, destroy=_core.delete_svn_log_entry_t):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class svn_log_entry_tPtr(svn_log_entry_t):
    def __init__(self, this):
        _swig_setattr(self, svn_log_entry_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_log_entry_t, 'thisown', 0)
        _swig_setattr(self, svn_log_entry_t,self.__class__,svn_log_entry_t)
_core.svn_log_entry_t_swigregister(svn_log_entry_tPtr)


def svn_log_entry_create(*args):
    """svn_log_entry_create(apr_pool_t pool) -> svn_log_entry_t"""
    return apply(_core.svn_log_entry_create, args)

def svn_log_entry_dup(*args):
    """svn_log_entry_dup(svn_log_entry_t log_entry, apr_pool_t pool) -> svn_log_entry_t"""
    return apply(_core.svn_log_entry_dup, args)
SVN_STREAM_CHUNK_SIZE = _core.SVN_STREAM_CHUNK_SIZE
SVN__STREAM_CHUNK_SIZE = _core.SVN__STREAM_CHUNK_SIZE

def svn_mime_type_validate(*args):
    """svn_mime_type_validate(char mime_type, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_mime_type_validate, args)

def svn_mime_type_is_binary(*args):
    """svn_mime_type_is_binary(char mime_type) -> svn_boolean_t"""
    return apply(_core.svn_mime_type_is_binary, args)
class svn_lock_t:
    """Proxy of C svn_lock_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_lock_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_lock_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C svn_lock_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["path"] = _core.svn_lock_t_path_set
    __swig_getmethods__["path"] = _core.svn_lock_t_path_get
    __swig_setmethods__["token"] = _core.svn_lock_t_token_set
    __swig_getmethods__["token"] = _core.svn_lock_t_token_get
    __swig_setmethods__["owner"] = _core.svn_lock_t_owner_set
    __swig_getmethods__["owner"] = _core.svn_lock_t_owner_get
    __swig_setmethods__["comment"] = _core.svn_lock_t_comment_set
    __swig_getmethods__["comment"] = _core.svn_lock_t_comment_get
    __swig_setmethods__["is_dav_comment"] = _core.svn_lock_t_is_dav_comment_set
    __swig_getmethods__["is_dav_comment"] = _core.svn_lock_t_is_dav_comment_get
    __swig_setmethods__["creation_date"] = _core.svn_lock_t_creation_date_set
    __swig_getmethods__["creation_date"] = _core.svn_lock_t_creation_date_get
    __swig_setmethods__["expiration_date"] = _core.svn_lock_t_expiration_date_set
    __swig_getmethods__["expiration_date"] = _core.svn_lock_t_expiration_date_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_lock_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

    def __init__(self, *args):
        """__init__(self) -> svn_lock_t"""
        _swig_setattr(self, svn_lock_t, 'this', apply(_core.new_svn_lock_t, args))
        _swig_setattr(self, svn_lock_t, 'thisown', 1)
    def __del__(self, destroy=_core.delete_svn_lock_t):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class svn_lock_tPtr(svn_lock_t):
    def __init__(self, this):
        _swig_setattr(self, svn_lock_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_lock_t, 'thisown', 0)
        _swig_setattr(self, svn_lock_t,self.__class__,svn_lock_t)
_core.svn_lock_t_swigregister(svn_lock_tPtr)


def svn_lock_create(*args):
    """svn_lock_create(apr_pool_t pool) -> svn_lock_t"""
    return apply(_core.svn_lock_create, args)

def svn_lock_dup(*args):
    """svn_lock_dup(svn_lock_t lock, apr_pool_t pool) -> svn_lock_t"""
    return apply(_core.svn_lock_dup, args)

def svn_uuid_generate(*args):
    """svn_uuid_generate(apr_pool_t pool) -> char"""
    return apply(_core.svn_uuid_generate, args)
class svn_merge_range_t:
    """Proxy of C svn_merge_range_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_merge_range_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_merge_range_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C svn_merge_range_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["start"] = _core.svn_merge_range_t_start_set
    __swig_getmethods__["start"] = _core.svn_merge_range_t_start_get
    __swig_setmethods__["end"] = _core.svn_merge_range_t_end_set
    __swig_getmethods__["end"] = _core.svn_merge_range_t_end_get
    __swig_setmethods__["inheritable"] = _core.svn_merge_range_t_inheritable_set
    __swig_getmethods__["inheritable"] = _core.svn_merge_range_t_inheritable_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_merge_range_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

    def __init__(self, *args):
        """__init__(self) -> svn_merge_range_t"""
        _swig_setattr(self, svn_merge_range_t, 'this', apply(_core.new_svn_merge_range_t, args))
        _swig_setattr(self, svn_merge_range_t, 'thisown', 1)
    def __del__(self, destroy=_core.delete_svn_merge_range_t):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class svn_merge_range_tPtr(svn_merge_range_t):
    def __init__(self, this):
        _swig_setattr(self, svn_merge_range_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_merge_range_t, 'thisown', 0)
        _swig_setattr(self, svn_merge_range_t,self.__class__,svn_merge_range_t)
_core.svn_merge_range_t_swigregister(svn_merge_range_tPtr)


def svn_merge_range_dup(*args):
    """svn_merge_range_dup(svn_merge_range_t range, apr_pool_t pool) -> svn_merge_range_t"""
    return apply(_core.svn_merge_range_dup, args)

def svn_merge_range_contains_rev(*args):
    """svn_merge_range_contains_rev(svn_merge_range_t range, svn_revnum_t rev) -> svn_boolean_t"""
    return apply(_core.svn_merge_range_contains_rev, args)
class svn_location_segment_t:
    """Proxy of C svn_location_segment_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_location_segment_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_location_segment_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C svn_location_segment_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["range_start"] = _core.svn_location_segment_t_range_start_set
    __swig_getmethods__["range_start"] = _core.svn_location_segment_t_range_start_get
    __swig_setmethods__["range_end"] = _core.svn_location_segment_t_range_end_set
    __swig_getmethods__["range_end"] = _core.svn_location_segment_t_range_end_get
    __swig_setmethods__["path"] = _core.svn_location_segment_t_path_set
    __swig_getmethods__["path"] = _core.svn_location_segment_t_path_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_location_segment_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

    def __init__(self, *args):
        """__init__(self) -> svn_location_segment_t"""
        _swig_setattr(self, svn_location_segment_t, 'this', apply(_core.new_svn_location_segment_t, args))
        _swig_setattr(self, svn_location_segment_t, 'thisown', 1)
    def __del__(self, destroy=_core.delete_svn_location_segment_t):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class svn_location_segment_tPtr(svn_location_segment_t):
    def __init__(self, this):
        _swig_setattr(self, svn_location_segment_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_location_segment_t, 'thisown', 0)
        _swig_setattr(self, svn_location_segment_t,self.__class__,svn_location_segment_t)
_core.svn_location_segment_t_swigregister(svn_location_segment_tPtr)


def svn_location_segment_dup(*args):
    """svn_location_segment_dup(svn_location_segment_t segment, apr_pool_t pool) -> svn_location_segment_t"""
    return apply(_core.svn_location_segment_dup, args)

def svn_log_invoke_entry_receiver(*args):
    """
    svn_log_invoke_entry_receiver(svn_log_entry_receiver_t _obj, void baton, svn_log_entry_t log_entry, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_log_invoke_entry_receiver, args)

def svn_log_invoke_message_receiver(*args):
    """
    svn_log_invoke_message_receiver(svn_log_message_receiver_t _obj, void baton, apr_hash_t changed_paths, 
        svn_revnum_t revision, char author, 
        char date, char message, apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_log_invoke_message_receiver, args)

def svn_commit_invoke_callback2(*args):
    """
    svn_commit_invoke_callback2(svn_commit_callback2_t _obj, svn_commit_info_t commit_info, 
        void baton, apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_commit_invoke_callback2, args)

def svn_commit_invoke_callback(*args):
    """
    svn_commit_invoke_callback(svn_commit_callback_t _obj, svn_revnum_t new_revision, 
        char date, char author, void baton) -> svn_error_t
    """
    return apply(_core.svn_commit_invoke_callback, args)

def svn_cancel_invoke_func(*args):
    """svn_cancel_invoke_func(svn_cancel_func_t _obj, void cancel_baton) -> svn_error_t"""
    return apply(_core.svn_cancel_invoke_func, args)

def svn_location_invoke_segment_receiver(*args):
    """
    svn_location_invoke_segment_receiver(svn_location_segment_receiver_t _obj, svn_location_segment_t segment, 
        void baton, apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_location_invoke_segment_receiver, args)
class svn_log_entry_receiver_t:
    """Proxy of C svn_log_entry_receiver_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_log_entry_receiver_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_log_entry_receiver_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_log_entry_receiver_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_log_entry_receiver_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

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


class svn_log_entry_receiver_tPtr(svn_log_entry_receiver_t):
    def __init__(self, this):
        _swig_setattr(self, svn_log_entry_receiver_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_log_entry_receiver_t, 'thisown', 0)
        _swig_setattr(self, svn_log_entry_receiver_t,self.__class__,svn_log_entry_receiver_t)
_core.svn_log_entry_receiver_t_swigregister(svn_log_entry_receiver_tPtr)

class svn_log_message_receiver_t:
    """Proxy of C svn_log_message_receiver_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_log_message_receiver_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_log_message_receiver_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_log_message_receiver_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_log_message_receiver_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

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


class svn_log_message_receiver_tPtr(svn_log_message_receiver_t):
    def __init__(self, this):
        _swig_setattr(self, svn_log_message_receiver_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_log_message_receiver_t, 'thisown', 0)
        _swig_setattr(self, svn_log_message_receiver_t,self.__class__,svn_log_message_receiver_t)
_core.svn_log_message_receiver_t_swigregister(svn_log_message_receiver_tPtr)

class svn_commit_callback2_t:
    """Proxy of C svn_commit_callback2_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_commit_callback2_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_commit_callback2_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_commit_callback2_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_commit_callback2_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

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


class svn_commit_callback2_tPtr(svn_commit_callback2_t):
    def __init__(self, this):
        _swig_setattr(self, svn_commit_callback2_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_commit_callback2_t, 'thisown', 0)
        _swig_setattr(self, svn_commit_callback2_t,self.__class__,svn_commit_callback2_t)
_core.svn_commit_callback2_t_swigregister(svn_commit_callback2_tPtr)

class svn_commit_callback_t:
    """Proxy of C svn_commit_callback_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_commit_callback_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_commit_callback_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_commit_callback_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_commit_callback_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

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


class svn_commit_callback_tPtr(svn_commit_callback_t):
    def __init__(self, this):
        _swig_setattr(self, svn_commit_callback_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_commit_callback_t, 'thisown', 0)
        _swig_setattr(self, svn_commit_callback_t,self.__class__,svn_commit_callback_t)
_core.svn_commit_callback_t_swigregister(svn_commit_callback_tPtr)

class svn_cancel_func_t:
    """Proxy of C svn_cancel_func_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_cancel_func_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_cancel_func_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_cancel_func_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_cancel_func_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

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


class svn_cancel_func_tPtr(svn_cancel_func_t):
    def __init__(self, this):
        _swig_setattr(self, svn_cancel_func_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_cancel_func_t, 'thisown', 0)
        _swig_setattr(self, svn_cancel_func_t,self.__class__,svn_cancel_func_t)
_core.svn_cancel_func_t_swigregister(svn_cancel_func_tPtr)

class svn_location_segment_receiver_t:
    """Proxy of C svn_location_segment_receiver_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_location_segment_receiver_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_location_segment_receiver_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_location_segment_receiver_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_location_segment_receiver_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

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


class svn_location_segment_receiver_tPtr(svn_location_segment_receiver_t):
    def __init__(self, this):
        _swig_setattr(self, svn_location_segment_receiver_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_location_segment_receiver_t, 'thisown', 0)
        _swig_setattr(self, svn_location_segment_receiver_t,self.__class__,svn_location_segment_receiver_t)
_core.svn_location_segment_receiver_t_swigregister(svn_location_segment_receiver_tPtr)

SVN_ALLOCATOR_RECOMMENDED_MAX_FREE = _core.SVN_ALLOCATOR_RECOMMENDED_MAX_FREE

def svn_pool_create(*args):
    """svn_pool_create(apr_pool_t parent_pool, apr_allocator_t allocator) -> apr_pool_t"""
    return apply(_core.svn_pool_create, args)
SVN_VER_MAJOR = _core.SVN_VER_MAJOR
SVN_VER_MINOR = _core.SVN_VER_MINOR
SVN_VER_PATCH = _core.SVN_VER_PATCH
SVN_VER_MICRO = _core.SVN_VER_MICRO
SVN_VER_LIBRARY = _core.SVN_VER_LIBRARY
SVN_VER_TAG = _core.SVN_VER_TAG
SVN_VER_NUMTAG = _core.SVN_VER_NUMTAG
SVN_VER_REVISION = _core.SVN_VER_REVISION
class svn_version_t:
    """Proxy of C svn_version_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_version_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_version_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C svn_version_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["major"] = _core.svn_version_t_major_set
    __swig_getmethods__["major"] = _core.svn_version_t_major_get
    __swig_setmethods__["minor"] = _core.svn_version_t_minor_set
    __swig_getmethods__["minor"] = _core.svn_version_t_minor_get
    __swig_setmethods__["patch"] = _core.svn_version_t_patch_set
    __swig_getmethods__["patch"] = _core.svn_version_t_patch_get
    __swig_setmethods__["tag"] = _core.svn_version_t_tag_set
    __swig_getmethods__["tag"] = _core.svn_version_t_tag_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_version_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

    def __init__(self, *args):
        """__init__(self) -> svn_version_t"""
        _swig_setattr(self, svn_version_t, 'this', apply(_core.new_svn_version_t, args))
        _swig_setattr(self, svn_version_t, 'thisown', 1)
    def __del__(self, destroy=_core.delete_svn_version_t):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class svn_version_tPtr(svn_version_t):
    def __init__(self, this):
        _swig_setattr(self, svn_version_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_version_t, 'thisown', 0)
        _swig_setattr(self, svn_version_t,self.__class__,svn_version_t)
_core.svn_version_t_swigregister(svn_version_tPtr)


def svn_ver_compatible(*args):
    """svn_ver_compatible(svn_version_t my_version, svn_version_t lib_version) -> svn_boolean_t"""
    return apply(_core.svn_ver_compatible, args)

def svn_ver_equal(*args):
    """svn_ver_equal(svn_version_t my_version, svn_version_t lib_version) -> svn_boolean_t"""
    return apply(_core.svn_ver_equal, args)
class svn_version_checklist_t:
    """Proxy of C svn_version_checklist_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_version_checklist_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_version_checklist_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C svn_version_checklist_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["label"] = _core.svn_version_checklist_t_label_set
    __swig_getmethods__["label"] = _core.svn_version_checklist_t_label_get
    __swig_setmethods__["version_query"] = _core.svn_version_checklist_t_version_query_set
    __swig_getmethods__["version_query"] = _core.svn_version_checklist_t_version_query_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_version_checklist_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

    def version_query(self, *args):
      return svn_version_checklist_invoke_version_query(self, *args)

    def __init__(self, *args):
        """__init__(self) -> svn_version_checklist_t"""
        _swig_setattr(self, svn_version_checklist_t, 'this', apply(_core.new_svn_version_checklist_t, args))
        _swig_setattr(self, svn_version_checklist_t, 'thisown', 1)
    def __del__(self, destroy=_core.delete_svn_version_checklist_t):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class svn_version_checklist_tPtr(svn_version_checklist_t):
    def __init__(self, this):
        _swig_setattr(self, svn_version_checklist_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_version_checklist_t, 'thisown', 0)
        _swig_setattr(self, svn_version_checklist_t,self.__class__,svn_version_checklist_t)
_core.svn_version_checklist_t_swigregister(svn_version_checklist_tPtr)


def svn_ver_check_list(*args):
    """svn_ver_check_list(svn_version_t my_version, svn_version_checklist_t checklist) -> svn_error_t"""
    return apply(_core.svn_ver_check_list, args)

def svn_subr_version(*args):
    """svn_subr_version() -> svn_version_t"""
    return apply(_core.svn_subr_version, args)

def svn_version_checklist_invoke_version_query(*args):
    """svn_version_checklist_invoke_version_query(svn_version_checklist_t _obj) -> svn_version_t"""
    return apply(_core.svn_version_checklist_invoke_version_query, args)

def svn_version_invoke_func(*args):
    """svn_version_invoke_func(svn_version_func_t _obj) -> svn_version_t"""
    return apply(_core.svn_version_invoke_func, args)
class svn_version_func_t:
    """Proxy of C svn_version_func_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_version_func_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_version_func_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_version_func_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_version_func_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

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


class svn_version_func_tPtr(svn_version_func_t):
    def __init__(self, this):
        _swig_setattr(self, svn_version_func_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_version_func_t, 'thisown', 0)
        _swig_setattr(self, svn_version_func_t,self.__class__,svn_version_func_t)
_core.svn_version_func_t_swigregister(svn_version_func_tPtr)


def svn_prop_dup(*args):
    """svn_prop_dup( prop, apr_pool_t pool)"""
    return apply(_core.svn_prop_dup, args)

def svn_prop_array_dup(*args):
    """svn_prop_array_dup(apr_array_header_t array, apr_pool_t pool) -> apr_array_header_t"""
    return apply(_core.svn_prop_array_dup, args)

def svn_prop_hash_to_array(*args):
    """svn_prop_hash_to_array(apr_hash_t hash, apr_pool_t pool) -> apr_array_header_t"""
    return apply(_core.svn_prop_hash_to_array, args)

def svn_prop_hash_dup(*args):
    """svn_prop_hash_dup(apr_hash_t hash, apr_pool_t pool) -> apr_hash_t"""
    return apply(_core.svn_prop_hash_dup, args)
svn_prop_entry_kind = _core.svn_prop_entry_kind
svn_prop_wc_kind = _core.svn_prop_wc_kind
svn_prop_regular_kind = _core.svn_prop_regular_kind

def svn_property_kind(*args):
    """svn_property_kind(int prefix_len, char prop_name) -> int"""
    return apply(_core.svn_property_kind, args)

def svn_prop_is_svn_prop(*args):
    """svn_prop_is_svn_prop(char prop_name) -> svn_boolean_t"""
    return apply(_core.svn_prop_is_svn_prop, args)

def svn_prop_has_svn_prop(*args):
    """svn_prop_has_svn_prop(apr_hash_t props, apr_pool_t pool) -> svn_boolean_t"""
    return apply(_core.svn_prop_has_svn_prop, args)

def svn_prop_is_boolean(*args):
    """svn_prop_is_boolean(char prop_name) -> svn_boolean_t"""
    return apply(_core.svn_prop_is_boolean, args)

def svn_prop_needs_translation(*args):
    """svn_prop_needs_translation(char prop_name) -> svn_boolean_t"""
    return apply(_core.svn_prop_needs_translation, args)

def svn_categorize_props(*args):
    """
    svn_categorize_props(apr_array_header_t proplist, apr_array_header_t entry_props, 
        apr_array_header_t wc_props, apr_array_header_t regular_props, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_categorize_props, args)

def svn_prop_diffs(*args):
    """
    svn_prop_diffs(apr_array_header_t propdiffs, apr_hash_t target_props, 
        apr_hash_t source_props, apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_prop_diffs, args)

def svn_prop_name_is_valid(*args):
    """svn_prop_name_is_valid(char prop_name) -> svn_boolean_t"""
    return apply(_core.svn_prop_name_is_valid, args)
SVN_PROP_PREFIX = _core.SVN_PROP_PREFIX
SVN_PROP_BOOLEAN_TRUE = _core.SVN_PROP_BOOLEAN_TRUE
SVN_PROP_MIME_TYPE = _core.SVN_PROP_MIME_TYPE
SVN_PROP_IGNORE = _core.SVN_PROP_IGNORE
SVN_PROP_EOL_STYLE = _core.SVN_PROP_EOL_STYLE
SVN_PROP_KEYWORDS = _core.SVN_PROP_KEYWORDS
SVN_PROP_EXECUTABLE = _core.SVN_PROP_EXECUTABLE
SVN_PROP_EXECUTABLE_VALUE = _core.SVN_PROP_EXECUTABLE_VALUE
SVN_PROP_NEEDS_LOCK = _core.SVN_PROP_NEEDS_LOCK
SVN_PROP_NEEDS_LOCK_VALUE = _core.SVN_PROP_NEEDS_LOCK_VALUE
SVN_PROP_SPECIAL = _core.SVN_PROP_SPECIAL
SVN_PROP_SPECIAL_VALUE = _core.SVN_PROP_SPECIAL_VALUE
SVN_PROP_EXTERNALS = _core.SVN_PROP_EXTERNALS
SVN_PROP_MERGEINFO = _core.SVN_PROP_MERGEINFO
SVN_PROP_TEXT_TIME = _core.SVN_PROP_TEXT_TIME
SVN_PROP_OWNER = _core.SVN_PROP_OWNER
SVN_PROP_GROUP = _core.SVN_PROP_GROUP
SVN_PROP_UNIX_MODE = _core.SVN_PROP_UNIX_MODE
SVN_PROP_WC_PREFIX = _core.SVN_PROP_WC_PREFIX
SVN_PROP_ENTRY_PREFIX = _core.SVN_PROP_ENTRY_PREFIX
SVN_PROP_ENTRY_COMMITTED_REV = _core.SVN_PROP_ENTRY_COMMITTED_REV
SVN_PROP_ENTRY_COMMITTED_DATE = _core.SVN_PROP_ENTRY_COMMITTED_DATE
SVN_PROP_ENTRY_LAST_AUTHOR = _core.SVN_PROP_ENTRY_LAST_AUTHOR
SVN_PROP_ENTRY_UUID = _core.SVN_PROP_ENTRY_UUID
SVN_PROP_ENTRY_LOCK_TOKEN = _core.SVN_PROP_ENTRY_LOCK_TOKEN
SVN_PROP_CUSTOM_PREFIX = _core.SVN_PROP_CUSTOM_PREFIX
SVN_PROP_REVISION_AUTHOR = _core.SVN_PROP_REVISION_AUTHOR
SVN_PROP_REVISION_LOG = _core.SVN_PROP_REVISION_LOG
SVN_PROP_REVISION_DATE = _core.SVN_PROP_REVISION_DATE
SVN_PROP_REVISION_ORIG_DATE = _core.SVN_PROP_REVISION_ORIG_DATE
SVN_PROP_REVISION_AUTOVERSIONED = _core.SVN_PROP_REVISION_AUTOVERSIONED
SVNSYNC_PROP_PREFIX = _core.SVNSYNC_PROP_PREFIX
SVNSYNC_PROP_LOCK = _core.SVNSYNC_PROP_LOCK
SVNSYNC_PROP_FROM_URL = _core.SVNSYNC_PROP_FROM_URL
SVNSYNC_PROP_FROM_UUID = _core.SVNSYNC_PROP_FROM_UUID
SVNSYNC_PROP_LAST_MERGED_REV = _core.SVNSYNC_PROP_LAST_MERGED_REV
SVNSYNC_PROP_CURRENTLY_COPYING = _core.SVNSYNC_PROP_CURRENTLY_COPYING
SVN_OPT_MAX_ALIASES = _core.SVN_OPT_MAX_ALIASES
SVN_OPT_MAX_OPTIONS = _core.SVN_OPT_MAX_OPTIONS
SVN_OPT_FIRST_LONGOPT_ID = _core.SVN_OPT_FIRST_LONGOPT_ID
class svn_opt_subcommand_desc2_t:
    """Proxy of C svn_opt_subcommand_desc2_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_opt_subcommand_desc2_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_opt_subcommand_desc2_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C svn_opt_subcommand_desc2_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["name"] = _core.svn_opt_subcommand_desc2_t_name_set
    __swig_getmethods__["name"] = _core.svn_opt_subcommand_desc2_t_name_get
    __swig_setmethods__["cmd_func"] = _core.svn_opt_subcommand_desc2_t_cmd_func_set
    __swig_getmethods__["cmd_func"] = _core.svn_opt_subcommand_desc2_t_cmd_func_get
    __swig_setmethods__["aliases"] = _core.svn_opt_subcommand_desc2_t_aliases_set
    __swig_getmethods__["aliases"] = _core.svn_opt_subcommand_desc2_t_aliases_get
    __swig_setmethods__["help"] = _core.svn_opt_subcommand_desc2_t_help_set
    __swig_getmethods__["help"] = _core.svn_opt_subcommand_desc2_t_help_get
    __swig_setmethods__["valid_options"] = _core.svn_opt_subcommand_desc2_t_valid_options_set
    __swig_getmethods__["valid_options"] = _core.svn_opt_subcommand_desc2_t_valid_options_get
    __swig_getmethods__["desc_overrides"] = _core.svn_opt_subcommand_desc2_t_desc_overrides_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_opt_subcommand_desc2_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

    def __init__(self, *args):
        """__init__(self) -> svn_opt_subcommand_desc2_t"""
        _swig_setattr(self, svn_opt_subcommand_desc2_t, 'this', apply(_core.new_svn_opt_subcommand_desc2_t, args))
        _swig_setattr(self, svn_opt_subcommand_desc2_t, 'thisown', 1)
    def __del__(self, destroy=_core.delete_svn_opt_subcommand_desc2_t):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class svn_opt_subcommand_desc2_tPtr(svn_opt_subcommand_desc2_t):
    def __init__(self, this):
        _swig_setattr(self, svn_opt_subcommand_desc2_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_opt_subcommand_desc2_t, 'thisown', 0)
        _swig_setattr(self, svn_opt_subcommand_desc2_t,self.__class__,svn_opt_subcommand_desc2_t)
_core.svn_opt_subcommand_desc2_t_swigregister(svn_opt_subcommand_desc2_tPtr)

class svn_opt_subcommand_desc2_t_desc_overrides:
    """Proxy of C svn_opt_subcommand_desc2_t_desc_overrides struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_opt_subcommand_desc2_t_desc_overrides, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_opt_subcommand_desc2_t_desc_overrides, name)
    def __repr__(self):
        return "<%s.%s; proxy of C svn_opt_subcommand_desc2_t_desc_overrides instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["optch"] = _core.svn_opt_subcommand_desc2_t_desc_overrides_optch_set
    __swig_getmethods__["optch"] = _core.svn_opt_subcommand_desc2_t_desc_overrides_optch_get
    __swig_setmethods__["desc"] = _core.svn_opt_subcommand_desc2_t_desc_overrides_desc_set
    __swig_getmethods__["desc"] = _core.svn_opt_subcommand_desc2_t_desc_overrides_desc_get
    def __init__(self, *args):
        """__init__(self) -> svn_opt_subcommand_desc2_t_desc_overrides"""
        _swig_setattr(self, svn_opt_subcommand_desc2_t_desc_overrides, 'this', apply(_core.new_svn_opt_subcommand_desc2_t_desc_overrides, args))
        _swig_setattr(self, svn_opt_subcommand_desc2_t_desc_overrides, 'thisown', 1)
    def __del__(self, destroy=_core.delete_svn_opt_subcommand_desc2_t_desc_overrides):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class svn_opt_subcommand_desc2_t_desc_overridesPtr(svn_opt_subcommand_desc2_t_desc_overrides):
    def __init__(self, this):
        _swig_setattr(self, svn_opt_subcommand_desc2_t_desc_overrides, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_opt_subcommand_desc2_t_desc_overrides, 'thisown', 0)
        _swig_setattr(self, svn_opt_subcommand_desc2_t_desc_overrides,self.__class__,svn_opt_subcommand_desc2_t_desc_overrides)
_core.svn_opt_subcommand_desc2_t_desc_overrides_swigregister(svn_opt_subcommand_desc2_t_desc_overridesPtr)

class svn_opt_subcommand_desc_t:
    """Proxy of C svn_opt_subcommand_desc_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_opt_subcommand_desc_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_opt_subcommand_desc_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C svn_opt_subcommand_desc_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["name"] = _core.svn_opt_subcommand_desc_t_name_set
    __swig_getmethods__["name"] = _core.svn_opt_subcommand_desc_t_name_get
    __swig_setmethods__["cmd_func"] = _core.svn_opt_subcommand_desc_t_cmd_func_set
    __swig_getmethods__["cmd_func"] = _core.svn_opt_subcommand_desc_t_cmd_func_get
    __swig_setmethods__["aliases"] = _core.svn_opt_subcommand_desc_t_aliases_set
    __swig_getmethods__["aliases"] = _core.svn_opt_subcommand_desc_t_aliases_get
    __swig_setmethods__["help"] = _core.svn_opt_subcommand_desc_t_help_set
    __swig_getmethods__["help"] = _core.svn_opt_subcommand_desc_t_help_get
    __swig_setmethods__["valid_options"] = _core.svn_opt_subcommand_desc_t_valid_options_set
    __swig_getmethods__["valid_options"] = _core.svn_opt_subcommand_desc_t_valid_options_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_opt_subcommand_desc_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

    def __init__(self, *args):
        """__init__(self) -> svn_opt_subcommand_desc_t"""
        _swig_setattr(self, svn_opt_subcommand_desc_t, 'this', apply(_core.new_svn_opt_subcommand_desc_t, args))
        _swig_setattr(self, svn_opt_subcommand_desc_t, 'thisown', 1)
    def __del__(self, destroy=_core.delete_svn_opt_subcommand_desc_t):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class svn_opt_subcommand_desc_tPtr(svn_opt_subcommand_desc_t):
    def __init__(self, this):
        _swig_setattr(self, svn_opt_subcommand_desc_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_opt_subcommand_desc_t, 'thisown', 0)
        _swig_setattr(self, svn_opt_subcommand_desc_t,self.__class__,svn_opt_subcommand_desc_t)
_core.svn_opt_subcommand_desc_t_swigregister(svn_opt_subcommand_desc_tPtr)


def svn_opt_get_canonical_subcommand2(*args):
    """svn_opt_get_canonical_subcommand2(svn_opt_subcommand_desc2_t table, char cmd_name) -> svn_opt_subcommand_desc2_t"""
    return apply(_core.svn_opt_get_canonical_subcommand2, args)

def svn_opt_get_canonical_subcommand(*args):
    """svn_opt_get_canonical_subcommand(svn_opt_subcommand_desc_t table, char cmd_name) -> svn_opt_subcommand_desc_t"""
    return apply(_core.svn_opt_get_canonical_subcommand, args)

def svn_opt_get_option_from_code2(*args):
    """
    svn_opt_get_option_from_code2(int code, apr_getopt_option_t option_table, svn_opt_subcommand_desc2_t command, 
        apr_pool_t pool) -> apr_getopt_option_t
    """
    return apply(_core.svn_opt_get_option_from_code2, args)

def svn_opt_get_option_from_code(*args):
    """svn_opt_get_option_from_code(int code, apr_getopt_option_t option_table) -> apr_getopt_option_t"""
    return apply(_core.svn_opt_get_option_from_code, args)

def svn_opt_subcommand_takes_option3(*args):
    """
    svn_opt_subcommand_takes_option3(svn_opt_subcommand_desc2_t command, int option_code, 
        int global_options) -> svn_boolean_t
    """
    return apply(_core.svn_opt_subcommand_takes_option3, args)

def svn_opt_subcommand_takes_option2(*args):
    """svn_opt_subcommand_takes_option2(svn_opt_subcommand_desc2_t command, int option_code) -> svn_boolean_t"""
    return apply(_core.svn_opt_subcommand_takes_option2, args)

def svn_opt_subcommand_takes_option(*args):
    """svn_opt_subcommand_takes_option(svn_opt_subcommand_desc_t command, int option_code) -> svn_boolean_t"""
    return apply(_core.svn_opt_subcommand_takes_option, args)

def svn_opt_print_generic_help2(*args):
    """
    svn_opt_print_generic_help2(char header, svn_opt_subcommand_desc2_t cmd_table, 
        apr_getopt_option_t opt_table, char footer, apr_pool_t pool, 
        FILE stream)
    """
    return apply(_core.svn_opt_print_generic_help2, args)

def svn_opt_format_option(*args):
    """
    svn_opt_format_option(char string, apr_getopt_option_t opt, svn_boolean_t doc, 
        apr_pool_t pool)
    """
    return apply(_core.svn_opt_format_option, args)

def svn_opt_subcommand_help3(*args):
    """
    svn_opt_subcommand_help3(char subcommand, svn_opt_subcommand_desc2_t table, 
        apr_getopt_option_t options_table, int global_options, 
        apr_pool_t pool)
    """
    return apply(_core.svn_opt_subcommand_help3, args)

def svn_opt_subcommand_help2(*args):
    """
    svn_opt_subcommand_help2(char subcommand, svn_opt_subcommand_desc2_t table, 
        apr_getopt_option_t options_table, apr_pool_t pool)
    """
    return apply(_core.svn_opt_subcommand_help2, args)

def svn_opt_subcommand_help(*args):
    """
    svn_opt_subcommand_help(char subcommand, svn_opt_subcommand_desc_t table, apr_getopt_option_t options_table, 
        apr_pool_t pool)
    """
    return apply(_core.svn_opt_subcommand_help, args)
svn_opt_revision_unspecified = _core.svn_opt_revision_unspecified
svn_opt_revision_number = _core.svn_opt_revision_number
svn_opt_revision_date = _core.svn_opt_revision_date
svn_opt_revision_committed = _core.svn_opt_revision_committed
svn_opt_revision_previous = _core.svn_opt_revision_previous
svn_opt_revision_base = _core.svn_opt_revision_base
svn_opt_revision_working = _core.svn_opt_revision_working
svn_opt_revision_head = _core.svn_opt_revision_head
class svn_opt_revision_value_t:
    """Proxy of C svn_opt_revision_value_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_opt_revision_value_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_opt_revision_value_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C svn_opt_revision_value_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["number"] = _core.svn_opt_revision_value_t_number_set
    __swig_getmethods__["number"] = _core.svn_opt_revision_value_t_number_get
    __swig_setmethods__["date"] = _core.svn_opt_revision_value_t_date_set
    __swig_getmethods__["date"] = _core.svn_opt_revision_value_t_date_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_opt_revision_value_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

    def __init__(self, *args):
        """__init__(self) -> svn_opt_revision_value_t"""
        _swig_setattr(self, svn_opt_revision_value_t, 'this', apply(_core.new_svn_opt_revision_value_t, args))
        _swig_setattr(self, svn_opt_revision_value_t, 'thisown', 1)
    def __del__(self, destroy=_core.delete_svn_opt_revision_value_t):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class svn_opt_revision_value_tPtr(svn_opt_revision_value_t):
    def __init__(self, this):
        _swig_setattr(self, svn_opt_revision_value_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_opt_revision_value_t, 'thisown', 0)
        _swig_setattr(self, svn_opt_revision_value_t,self.__class__,svn_opt_revision_value_t)
_core.svn_opt_revision_value_t_swigregister(svn_opt_revision_value_tPtr)

class svn_opt_revision_t:
    """Proxy of C svn_opt_revision_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_opt_revision_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_opt_revision_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C svn_opt_revision_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["kind"] = _core.svn_opt_revision_t_kind_set
    __swig_getmethods__["kind"] = _core.svn_opt_revision_t_kind_get
    __swig_setmethods__["value"] = _core.svn_opt_revision_t_value_set
    __swig_getmethods__["value"] = _core.svn_opt_revision_t_value_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_opt_revision_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

    def __init__(self, *args):
        """__init__(self) -> svn_opt_revision_t"""
        _swig_setattr(self, svn_opt_revision_t, 'this', apply(_core.new_svn_opt_revision_t, args))
        _swig_setattr(self, svn_opt_revision_t, 'thisown', 1)
    def __del__(self, destroy=_core.delete_svn_opt_revision_t):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class svn_opt_revision_tPtr(svn_opt_revision_t):
    def __init__(self, this):
        _swig_setattr(self, svn_opt_revision_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_opt_revision_t, 'thisown', 0)
        _swig_setattr(self, svn_opt_revision_t,self.__class__,svn_opt_revision_t)
_core.svn_opt_revision_t_swigregister(svn_opt_revision_tPtr)

class svn_opt_revision_range_t:
    """Proxy of C svn_opt_revision_range_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_opt_revision_range_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_opt_revision_range_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C svn_opt_revision_range_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["start"] = _core.svn_opt_revision_range_t_start_set
    __swig_getmethods__["start"] = _core.svn_opt_revision_range_t_start_get
    __swig_setmethods__["end"] = _core.svn_opt_revision_range_t_end_set
    __swig_getmethods__["end"] = _core.svn_opt_revision_range_t_end_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_opt_revision_range_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

    def __init__(self, *args):
        """__init__(self) -> svn_opt_revision_range_t"""
        _swig_setattr(self, svn_opt_revision_range_t, 'this', apply(_core.new_svn_opt_revision_range_t, args))
        _swig_setattr(self, svn_opt_revision_range_t, 'thisown', 1)
    def __del__(self, destroy=_core.delete_svn_opt_revision_range_t):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class svn_opt_revision_range_tPtr(svn_opt_revision_range_t):
    def __init__(self, this):
        _swig_setattr(self, svn_opt_revision_range_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_opt_revision_range_t, 'thisown', 0)
        _swig_setattr(self, svn_opt_revision_range_t,self.__class__,svn_opt_revision_range_t)
_core.svn_opt_revision_range_t_swigregister(svn_opt_revision_range_tPtr)


def svn_opt_parse_revision(*args):
    """
    svn_opt_parse_revision(svn_opt_revision_t start_revision, svn_opt_revision_t end_revision, 
        char arg, apr_pool_t pool) -> int
    """
    return apply(_core.svn_opt_parse_revision, args)

def svn_opt_parse_revision_to_range(*args):
    """svn_opt_parse_revision_to_range(apr_array_header_t opt_ranges, char arg, apr_pool_t pool) -> int"""
    return apply(_core.svn_opt_parse_revision_to_range, args)

def svn_opt_resolve_revisions(*args):
    """
    svn_opt_resolve_revisions(svn_opt_revision_t peg_rev, svn_opt_revision_t op_rev, 
        svn_boolean_t is_url, svn_boolean_t notice_local_mods, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_opt_resolve_revisions, args)

def svn_opt_args_to_target_array3(*args):
    """
    svn_opt_args_to_target_array3(apr_array_header_t targets_p, apr_getopt_t os, apr_array_header_t known_targets, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_opt_args_to_target_array3, args)

def svn_opt_args_to_target_array2(*args):
    """
    svn_opt_args_to_target_array2(apr_array_header_t targets_p, apr_getopt_t os, apr_array_header_t known_targets, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_opt_args_to_target_array2, args)

def svn_opt_parse_revprop(*args):
    """svn_opt_parse_revprop(apr_hash_t revprops, char revprop_spec, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_opt_parse_revprop, args)

def svn_opt_push_implicit_dot_target(*args):
    """svn_opt_push_implicit_dot_target(apr_array_header_t targets, apr_pool_t pool)"""
    return apply(_core.svn_opt_push_implicit_dot_target, args)

def svn_opt_parse_num_args(*args):
    """
    svn_opt_parse_num_args(apr_array_header_t args_p, apr_getopt_t os, int num_args, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_opt_parse_num_args, args)

def svn_opt_parse_all_args(*args):
    """svn_opt_parse_all_args(apr_array_header_t args_p, apr_getopt_t os, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_opt_parse_all_args, args)

def svn_opt_parse_path(*args):
    """svn_opt_parse_path(svn_opt_revision_t rev, char truepath, char path, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_opt_parse_path, args)

def svn_opt_print_help3(*args):
    """
    svn_opt_print_help3(apr_getopt_t os, char pgm_name, svn_boolean_t print_version, 
        svn_boolean_t quiet, char version_footer, 
        char header, svn_opt_subcommand_desc2_t cmd_table, 
        apr_getopt_option_t option_table, 
        int global_options, char footer, apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_opt_print_help3, args)

def svn_opt_print_help2(*args):
    """
    svn_opt_print_help2(apr_getopt_t os, char pgm_name, svn_boolean_t print_version, 
        svn_boolean_t quiet, char version_footer, 
        char header, svn_opt_subcommand_desc2_t cmd_table, 
        apr_getopt_option_t option_table, 
        char footer, apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_opt_print_help2, args)

def svn_opt_print_help(*args):
    """
    svn_opt_print_help(apr_getopt_t os, char pgm_name, svn_boolean_t print_version, 
        svn_boolean_t quiet, char version_footer, 
        char header, svn_opt_subcommand_desc_t cmd_table, 
        apr_getopt_option_t option_table, 
        char footer, apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_opt_print_help, args)
class svn_auth_provider_t:
    """Proxy of C svn_auth_provider_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_auth_provider_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_auth_provider_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C svn_auth_provider_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["cred_kind"] = _core.svn_auth_provider_t_cred_kind_set
    __swig_getmethods__["cred_kind"] = _core.svn_auth_provider_t_cred_kind_get
    __swig_setmethods__["first_credentials"] = _core.svn_auth_provider_t_first_credentials_set
    __swig_getmethods__["first_credentials"] = _core.svn_auth_provider_t_first_credentials_get
    __swig_setmethods__["next_credentials"] = _core.svn_auth_provider_t_next_credentials_set
    __swig_getmethods__["next_credentials"] = _core.svn_auth_provider_t_next_credentials_get
    __swig_setmethods__["save_credentials"] = _core.svn_auth_provider_t_save_credentials_set
    __swig_getmethods__["save_credentials"] = _core.svn_auth_provider_t_save_credentials_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_auth_provider_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

    def first_credentials(self, *args):
      return svn_auth_provider_invoke_first_credentials(self, *args)

    def next_credentials(self, *args):
      return svn_auth_provider_invoke_next_credentials(self, *args)

    def save_credentials(self, *args):
      return svn_auth_provider_invoke_save_credentials(self, *args)

    def __init__(self, *args):
        """__init__(self) -> svn_auth_provider_t"""
        _swig_setattr(self, svn_auth_provider_t, 'this', apply(_core.new_svn_auth_provider_t, args))
        _swig_setattr(self, svn_auth_provider_t, 'thisown', 1)
    def __del__(self, destroy=_core.delete_svn_auth_provider_t):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class svn_auth_provider_tPtr(svn_auth_provider_t):
    def __init__(self, this):
        _swig_setattr(self, svn_auth_provider_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_auth_provider_t, 'thisown', 0)
        _swig_setattr(self, svn_auth_provider_t,self.__class__,svn_auth_provider_t)
_core.svn_auth_provider_t_swigregister(svn_auth_provider_tPtr)

class svn_auth_provider_object_t:
    """Proxy of C svn_auth_provider_object_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_auth_provider_object_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_auth_provider_object_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C svn_auth_provider_object_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["vtable"] = _core.svn_auth_provider_object_t_vtable_set
    __swig_getmethods__["vtable"] = _core.svn_auth_provider_object_t_vtable_get
    __swig_setmethods__["provider_baton"] = _core.svn_auth_provider_object_t_provider_baton_set
    __swig_getmethods__["provider_baton"] = _core.svn_auth_provider_object_t_provider_baton_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_auth_provider_object_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

    def __init__(self, *args):
        """__init__(self) -> svn_auth_provider_object_t"""
        _swig_setattr(self, svn_auth_provider_object_t, 'this', apply(_core.new_svn_auth_provider_object_t, args))
        _swig_setattr(self, svn_auth_provider_object_t, 'thisown', 1)
    def __del__(self, destroy=_core.delete_svn_auth_provider_object_t):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class svn_auth_provider_object_tPtr(svn_auth_provider_object_t):
    def __init__(self, this):
        _swig_setattr(self, svn_auth_provider_object_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_auth_provider_object_t, 'thisown', 0)
        _swig_setattr(self, svn_auth_provider_object_t,self.__class__,svn_auth_provider_object_t)
_core.svn_auth_provider_object_t_swigregister(svn_auth_provider_object_tPtr)

SVN_AUTH_CRED_SIMPLE = _core.SVN_AUTH_CRED_SIMPLE
class svn_auth_cred_simple_t:
    """Proxy of C svn_auth_cred_simple_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_auth_cred_simple_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_auth_cred_simple_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C svn_auth_cred_simple_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["username"] = _core.svn_auth_cred_simple_t_username_set
    __swig_getmethods__["username"] = _core.svn_auth_cred_simple_t_username_get
    __swig_setmethods__["password"] = _core.svn_auth_cred_simple_t_password_set
    __swig_getmethods__["password"] = _core.svn_auth_cred_simple_t_password_get
    __swig_setmethods__["may_save"] = _core.svn_auth_cred_simple_t_may_save_set
    __swig_getmethods__["may_save"] = _core.svn_auth_cred_simple_t_may_save_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_auth_cred_simple_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

    def __init__(self, *args):
        """__init__(self) -> svn_auth_cred_simple_t"""
        _swig_setattr(self, svn_auth_cred_simple_t, 'this', apply(_core.new_svn_auth_cred_simple_t, args))
        _swig_setattr(self, svn_auth_cred_simple_t, 'thisown', 1)
    def __del__(self, destroy=_core.delete_svn_auth_cred_simple_t):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class svn_auth_cred_simple_tPtr(svn_auth_cred_simple_t):
    def __init__(self, this):
        _swig_setattr(self, svn_auth_cred_simple_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_auth_cred_simple_t, 'thisown', 0)
        _swig_setattr(self, svn_auth_cred_simple_t,self.__class__,svn_auth_cred_simple_t)
_core.svn_auth_cred_simple_t_swigregister(svn_auth_cred_simple_tPtr)

SVN_AUTH_CRED_USERNAME = _core.SVN_AUTH_CRED_USERNAME
class svn_auth_cred_username_t:
    """Proxy of C svn_auth_cred_username_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_auth_cred_username_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_auth_cred_username_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C svn_auth_cred_username_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["username"] = _core.svn_auth_cred_username_t_username_set
    __swig_getmethods__["username"] = _core.svn_auth_cred_username_t_username_get
    __swig_setmethods__["may_save"] = _core.svn_auth_cred_username_t_may_save_set
    __swig_getmethods__["may_save"] = _core.svn_auth_cred_username_t_may_save_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_auth_cred_username_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

    def __init__(self, *args):
        """__init__(self) -> svn_auth_cred_username_t"""
        _swig_setattr(self, svn_auth_cred_username_t, 'this', apply(_core.new_svn_auth_cred_username_t, args))
        _swig_setattr(self, svn_auth_cred_username_t, 'thisown', 1)
    def __del__(self, destroy=_core.delete_svn_auth_cred_username_t):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class svn_auth_cred_username_tPtr(svn_auth_cred_username_t):
    def __init__(self, this):
        _swig_setattr(self, svn_auth_cred_username_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_auth_cred_username_t, 'thisown', 0)
        _swig_setattr(self, svn_auth_cred_username_t,self.__class__,svn_auth_cred_username_t)
_core.svn_auth_cred_username_t_swigregister(svn_auth_cred_username_tPtr)

SVN_AUTH_CRED_SSL_CLIENT_CERT = _core.SVN_AUTH_CRED_SSL_CLIENT_CERT
class svn_auth_cred_ssl_client_cert_t:
    """Proxy of C svn_auth_cred_ssl_client_cert_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_auth_cred_ssl_client_cert_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_auth_cred_ssl_client_cert_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C svn_auth_cred_ssl_client_cert_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["cert_file"] = _core.svn_auth_cred_ssl_client_cert_t_cert_file_set
    __swig_getmethods__["cert_file"] = _core.svn_auth_cred_ssl_client_cert_t_cert_file_get
    __swig_setmethods__["may_save"] = _core.svn_auth_cred_ssl_client_cert_t_may_save_set
    __swig_getmethods__["may_save"] = _core.svn_auth_cred_ssl_client_cert_t_may_save_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_auth_cred_ssl_client_cert_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

    def __init__(self, *args):
        """__init__(self) -> svn_auth_cred_ssl_client_cert_t"""
        _swig_setattr(self, svn_auth_cred_ssl_client_cert_t, 'this', apply(_core.new_svn_auth_cred_ssl_client_cert_t, args))
        _swig_setattr(self, svn_auth_cred_ssl_client_cert_t, 'thisown', 1)
    def __del__(self, destroy=_core.delete_svn_auth_cred_ssl_client_cert_t):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class svn_auth_cred_ssl_client_cert_tPtr(svn_auth_cred_ssl_client_cert_t):
    def __init__(self, this):
        _swig_setattr(self, svn_auth_cred_ssl_client_cert_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_auth_cred_ssl_client_cert_t, 'thisown', 0)
        _swig_setattr(self, svn_auth_cred_ssl_client_cert_t,self.__class__,svn_auth_cred_ssl_client_cert_t)
_core.svn_auth_cred_ssl_client_cert_t_swigregister(svn_auth_cred_ssl_client_cert_tPtr)

SVN_AUTH_CRED_SSL_CLIENT_CERT_PW = _core.SVN_AUTH_CRED_SSL_CLIENT_CERT_PW
class svn_auth_cred_ssl_client_cert_pw_t:
    """Proxy of C svn_auth_cred_ssl_client_cert_pw_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_auth_cred_ssl_client_cert_pw_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_auth_cred_ssl_client_cert_pw_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C svn_auth_cred_ssl_client_cert_pw_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["password"] = _core.svn_auth_cred_ssl_client_cert_pw_t_password_set
    __swig_getmethods__["password"] = _core.svn_auth_cred_ssl_client_cert_pw_t_password_get
    __swig_setmethods__["may_save"] = _core.svn_auth_cred_ssl_client_cert_pw_t_may_save_set
    __swig_getmethods__["may_save"] = _core.svn_auth_cred_ssl_client_cert_pw_t_may_save_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_auth_cred_ssl_client_cert_pw_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

    def __init__(self, *args):
        """__init__(self) -> svn_auth_cred_ssl_client_cert_pw_t"""
        _swig_setattr(self, svn_auth_cred_ssl_client_cert_pw_t, 'this', apply(_core.new_svn_auth_cred_ssl_client_cert_pw_t, args))
        _swig_setattr(self, svn_auth_cred_ssl_client_cert_pw_t, 'thisown', 1)
    def __del__(self, destroy=_core.delete_svn_auth_cred_ssl_client_cert_pw_t):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class svn_auth_cred_ssl_client_cert_pw_tPtr(svn_auth_cred_ssl_client_cert_pw_t):
    def __init__(self, this):
        _swig_setattr(self, svn_auth_cred_ssl_client_cert_pw_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_auth_cred_ssl_client_cert_pw_t, 'thisown', 0)
        _swig_setattr(self, svn_auth_cred_ssl_client_cert_pw_t,self.__class__,svn_auth_cred_ssl_client_cert_pw_t)
_core.svn_auth_cred_ssl_client_cert_pw_t_swigregister(svn_auth_cred_ssl_client_cert_pw_tPtr)

SVN_AUTH_CRED_SSL_SERVER_TRUST = _core.SVN_AUTH_CRED_SSL_SERVER_TRUST
class svn_auth_ssl_server_cert_info_t:
    """Proxy of C svn_auth_ssl_server_cert_info_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_auth_ssl_server_cert_info_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_auth_ssl_server_cert_info_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C svn_auth_ssl_server_cert_info_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["hostname"] = _core.svn_auth_ssl_server_cert_info_t_hostname_set
    __swig_getmethods__["hostname"] = _core.svn_auth_ssl_server_cert_info_t_hostname_get
    __swig_setmethods__["fingerprint"] = _core.svn_auth_ssl_server_cert_info_t_fingerprint_set
    __swig_getmethods__["fingerprint"] = _core.svn_auth_ssl_server_cert_info_t_fingerprint_get
    __swig_setmethods__["valid_from"] = _core.svn_auth_ssl_server_cert_info_t_valid_from_set
    __swig_getmethods__["valid_from"] = _core.svn_auth_ssl_server_cert_info_t_valid_from_get
    __swig_setmethods__["valid_until"] = _core.svn_auth_ssl_server_cert_info_t_valid_until_set
    __swig_getmethods__["valid_until"] = _core.svn_auth_ssl_server_cert_info_t_valid_until_get
    __swig_setmethods__["issuer_dname"] = _core.svn_auth_ssl_server_cert_info_t_issuer_dname_set
    __swig_getmethods__["issuer_dname"] = _core.svn_auth_ssl_server_cert_info_t_issuer_dname_get
    __swig_setmethods__["ascii_cert"] = _core.svn_auth_ssl_server_cert_info_t_ascii_cert_set
    __swig_getmethods__["ascii_cert"] = _core.svn_auth_ssl_server_cert_info_t_ascii_cert_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_auth_ssl_server_cert_info_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

    def __init__(self, *args):
        """__init__(self) -> svn_auth_ssl_server_cert_info_t"""
        _swig_setattr(self, svn_auth_ssl_server_cert_info_t, 'this', apply(_core.new_svn_auth_ssl_server_cert_info_t, args))
        _swig_setattr(self, svn_auth_ssl_server_cert_info_t, 'thisown', 1)
    def __del__(self, destroy=_core.delete_svn_auth_ssl_server_cert_info_t):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class svn_auth_ssl_server_cert_info_tPtr(svn_auth_ssl_server_cert_info_t):
    def __init__(self, this):
        _swig_setattr(self, svn_auth_ssl_server_cert_info_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_auth_ssl_server_cert_info_t, 'thisown', 0)
        _swig_setattr(self, svn_auth_ssl_server_cert_info_t,self.__class__,svn_auth_ssl_server_cert_info_t)
_core.svn_auth_ssl_server_cert_info_t_swigregister(svn_auth_ssl_server_cert_info_tPtr)


def svn_auth_ssl_server_cert_info_dup(*args):
    """svn_auth_ssl_server_cert_info_dup(svn_auth_ssl_server_cert_info_t info, apr_pool_t pool) -> svn_auth_ssl_server_cert_info_t"""
    return apply(_core.svn_auth_ssl_server_cert_info_dup, args)
class svn_auth_cred_ssl_server_trust_t:
    """Proxy of C svn_auth_cred_ssl_server_trust_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_auth_cred_ssl_server_trust_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_auth_cred_ssl_server_trust_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C svn_auth_cred_ssl_server_trust_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["may_save"] = _core.svn_auth_cred_ssl_server_trust_t_may_save_set
    __swig_getmethods__["may_save"] = _core.svn_auth_cred_ssl_server_trust_t_may_save_get
    __swig_setmethods__["accepted_failures"] = _core.svn_auth_cred_ssl_server_trust_t_accepted_failures_set
    __swig_getmethods__["accepted_failures"] = _core.svn_auth_cred_ssl_server_trust_t_accepted_failures_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_auth_cred_ssl_server_trust_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

    def __init__(self, *args):
        """__init__(self) -> svn_auth_cred_ssl_server_trust_t"""
        _swig_setattr(self, svn_auth_cred_ssl_server_trust_t, 'this', apply(_core.new_svn_auth_cred_ssl_server_trust_t, args))
        _swig_setattr(self, svn_auth_cred_ssl_server_trust_t, 'thisown', 1)
    def __del__(self, destroy=_core.delete_svn_auth_cred_ssl_server_trust_t):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class svn_auth_cred_ssl_server_trust_tPtr(svn_auth_cred_ssl_server_trust_t):
    def __init__(self, this):
        _swig_setattr(self, svn_auth_cred_ssl_server_trust_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_auth_cred_ssl_server_trust_t, 'thisown', 0)
        _swig_setattr(self, svn_auth_cred_ssl_server_trust_t,self.__class__,svn_auth_cred_ssl_server_trust_t)
_core.svn_auth_cred_ssl_server_trust_t_swigregister(svn_auth_cred_ssl_server_trust_tPtr)

SVN_AUTH_SSL_NOTYETVALID = _core.SVN_AUTH_SSL_NOTYETVALID
SVN_AUTH_SSL_EXPIRED = _core.SVN_AUTH_SSL_EXPIRED
SVN_AUTH_SSL_CNMISMATCH = _core.SVN_AUTH_SSL_CNMISMATCH
SVN_AUTH_SSL_UNKNOWNCA = _core.SVN_AUTH_SSL_UNKNOWNCA
SVN_AUTH_SSL_OTHER = _core.SVN_AUTH_SSL_OTHER

def svn_auth_open(*args):
    """
    svn_auth_open(svn_auth_baton_t auth_baton, apr_array_header_t providers, 
        apr_pool_t pool)
    """
    return apply(_core.svn_auth_open, args)

def svn_auth_set_parameter(*args):
    """svn_auth_set_parameter(svn_auth_baton_t auth_baton, char name, void value)"""
    return apply(_core.svn_auth_set_parameter, args)
SVN_AUTH_PARAM_PREFIX = _core.SVN_AUTH_PARAM_PREFIX
SVN_AUTH_PARAM_DEFAULT_USERNAME = _core.SVN_AUTH_PARAM_DEFAULT_USERNAME
SVN_AUTH_PARAM_DEFAULT_PASSWORD = _core.SVN_AUTH_PARAM_DEFAULT_PASSWORD
SVN_AUTH_PARAM_NON_INTERACTIVE = _core.SVN_AUTH_PARAM_NON_INTERACTIVE
SVN_AUTH_PARAM_DONT_STORE_PASSWORDS = _core.SVN_AUTH_PARAM_DONT_STORE_PASSWORDS
SVN_AUTH_PARAM_STORE_PLAINTEXT_PASSWORDS = _core.SVN_AUTH_PARAM_STORE_PLAINTEXT_PASSWORDS
SVN_AUTH_PARAM_DONT_STORE_SSL_CLIENT_CERT_PP = _core.SVN_AUTH_PARAM_DONT_STORE_SSL_CLIENT_CERT_PP
SVN_AUTH_PARAM_STORE_SSL_CLIENT_CERT_PP_PLAINTEXT = _core.SVN_AUTH_PARAM_STORE_SSL_CLIENT_CERT_PP_PLAINTEXT
SVN_AUTH_PARAM_NO_AUTH_CACHE = _core.SVN_AUTH_PARAM_NO_AUTH_CACHE
SVN_AUTH_PARAM_SSL_SERVER_FAILURES = _core.SVN_AUTH_PARAM_SSL_SERVER_FAILURES
SVN_AUTH_PARAM_SSL_SERVER_CERT_INFO = _core.SVN_AUTH_PARAM_SSL_SERVER_CERT_INFO
SVN_AUTH_PARAM_CONFIG_CATEGORY_CONFIG = _core.SVN_AUTH_PARAM_CONFIG_CATEGORY_CONFIG
SVN_AUTH_PARAM_CONFIG_CATEGORY_SERVERS = _core.SVN_AUTH_PARAM_CONFIG_CATEGORY_SERVERS
SVN_AUTH_PARAM_CONFIG = _core.SVN_AUTH_PARAM_CONFIG
SVN_AUTH_PARAM_SERVER_GROUP = _core.SVN_AUTH_PARAM_SERVER_GROUP
SVN_AUTH_PARAM_CONFIG_DIR = _core.SVN_AUTH_PARAM_CONFIG_DIR

def svn_auth_first_credentials(*args):
    """
    svn_auth_first_credentials(void credentials, svn_auth_iterstate_t state, char cred_kind, 
        char realmstring, svn_auth_baton_t auth_baton, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_auth_first_credentials, args)

def svn_auth_next_credentials(*args):
    """svn_auth_next_credentials(void credentials, svn_auth_iterstate_t state, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_auth_next_credentials, args)

def svn_auth_save_credentials(*args):
    """svn_auth_save_credentials(svn_auth_iterstate_t state, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_auth_save_credentials, args)

def svn_auth_get_simple_prompt_provider(*args):
    """
    svn_auth_get_simple_prompt_provider(svn_auth_provider_object_t provider, svn_auth_simple_prompt_func_t prompt_func, 
        int retry_limit, 
        apr_pool_t pool)
    """
    return apply(_core.svn_auth_get_simple_prompt_provider, args)

def svn_auth_get_username_prompt_provider(*args):
    """
    svn_auth_get_username_prompt_provider(svn_auth_provider_object_t provider, svn_auth_username_prompt_func_t prompt_func, 
        int retry_limit, 
        apr_pool_t pool)
    """
    return apply(_core.svn_auth_get_username_prompt_provider, args)

def svn_auth_get_simple_provider2(*args):
    """
    svn_auth_get_simple_provider2(svn_auth_provider_object_t provider, svn_auth_plaintext_prompt_func_t plaintext_prompt_func, 
        void prompt_baton, 
        apr_pool_t pool)
    """
    return apply(_core.svn_auth_get_simple_provider2, args)

def svn_auth_get_simple_provider(*args):
    """svn_auth_get_simple_provider(svn_auth_provider_object_t provider, apr_pool_t pool)"""
    return apply(_core.svn_auth_get_simple_provider, args)

def svn_auth_get_platform_specific_provider(*args):
    """
    svn_auth_get_platform_specific_provider(svn_auth_provider_object_t provider, char provider_name, 
        char provider_type, apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_auth_get_platform_specific_provider, args)

def svn_auth_get_platform_specific_client_providers(*args):
    """
    svn_auth_get_platform_specific_client_providers(apr_array_header_t providers, svn_config_t config, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_auth_get_platform_specific_client_providers, args)

def svn_auth_get_windows_ssl_client_cert_pw_provider(*args):
    """svn_auth_get_windows_ssl_client_cert_pw_provider(svn_auth_provider_object_t provider, apr_pool_t pool)"""
    return apply(_core.svn_auth_get_windows_ssl_client_cert_pw_provider, args)

def svn_auth_get_username_provider(*args):
    """svn_auth_get_username_provider(svn_auth_provider_object_t provider, apr_pool_t pool)"""
    return apply(_core.svn_auth_get_username_provider, args)

def svn_auth_get_ssl_server_trust_file_provider(*args):
    """svn_auth_get_ssl_server_trust_file_provider(svn_auth_provider_object_t provider, apr_pool_t pool)"""
    return apply(_core.svn_auth_get_ssl_server_trust_file_provider, args)

def svn_auth_get_ssl_client_cert_file_provider(*args):
    """svn_auth_get_ssl_client_cert_file_provider(svn_auth_provider_object_t provider, apr_pool_t pool)"""
    return apply(_core.svn_auth_get_ssl_client_cert_file_provider, args)

def svn_auth_get_ssl_client_cert_pw_file_provider2(*args):
    """
    svn_auth_get_ssl_client_cert_pw_file_provider2(svn_auth_provider_object_t provider, svn_auth_plaintext_passphrase_prompt_func_t plaintext_passphrase_prompt_func, 
        void prompt_baton, 
        apr_pool_t pool)
    """
    return apply(_core.svn_auth_get_ssl_client_cert_pw_file_provider2, args)

def svn_auth_get_ssl_client_cert_pw_file_provider(*args):
    """svn_auth_get_ssl_client_cert_pw_file_provider(svn_auth_provider_object_t provider, apr_pool_t pool)"""
    return apply(_core.svn_auth_get_ssl_client_cert_pw_file_provider, args)

def svn_auth_get_ssl_server_trust_prompt_provider(*args):
    """
    svn_auth_get_ssl_server_trust_prompt_provider(svn_auth_provider_object_t provider, svn_auth_ssl_server_trust_prompt_func_t prompt_func, 
        apr_pool_t pool)
    """
    return apply(_core.svn_auth_get_ssl_server_trust_prompt_provider, args)

def svn_auth_get_ssl_client_cert_prompt_provider(*args):
    """
    svn_auth_get_ssl_client_cert_prompt_provider(svn_auth_provider_object_t provider, svn_auth_ssl_client_cert_prompt_func_t prompt_func, 
        int retry_limit, 
        apr_pool_t pool)
    """
    return apply(_core.svn_auth_get_ssl_client_cert_prompt_provider, args)

def svn_auth_get_ssl_client_cert_pw_prompt_provider(*args):
    """
    svn_auth_get_ssl_client_cert_pw_prompt_provider(svn_auth_provider_object_t provider, svn_auth_ssl_client_cert_pw_prompt_func_t prompt_func, 
        int retry_limit, 
        apr_pool_t pool)
    """
    return apply(_core.svn_auth_get_ssl_client_cert_pw_prompt_provider, args)
class svn_auth_baton_t:
    """Proxy of C svn_auth_baton_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_auth_baton_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_auth_baton_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_auth_baton_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_auth_baton_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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


class svn_auth_baton_tPtr(svn_auth_baton_t):
    def __init__(self, this):
        _swig_setattr(self, svn_auth_baton_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_auth_baton_t, 'thisown', 0)
        _swig_setattr(self, svn_auth_baton_t,self.__class__,svn_auth_baton_t)
_core.svn_auth_baton_t_swigregister(svn_auth_baton_tPtr)

class svn_auth_iterstate_t:
    """Proxy of C svn_auth_iterstate_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_auth_iterstate_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_auth_iterstate_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_auth_iterstate_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_auth_iterstate_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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


class svn_auth_iterstate_tPtr(svn_auth_iterstate_t):
    def __init__(self, this):
        _swig_setattr(self, svn_auth_iterstate_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_auth_iterstate_t, 'thisown', 0)
        _swig_setattr(self, svn_auth_iterstate_t,self.__class__,svn_auth_iterstate_t)
_core.svn_auth_iterstate_t_swigregister(svn_auth_iterstate_tPtr)


def svn_auth_provider_invoke_first_credentials(*args):
    """
    svn_auth_provider_invoke_first_credentials(svn_auth_provider_t _obj, void credentials, void iter_baton, 
        void provider_baton, apr_hash_t parameters, 
        char realmstring, apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_auth_provider_invoke_first_credentials, args)

def svn_auth_provider_invoke_next_credentials(*args):
    """
    svn_auth_provider_invoke_next_credentials(svn_auth_provider_t _obj, void credentials, void iter_baton, 
        void provider_baton, apr_hash_t parameters, 
        char realmstring, apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_auth_provider_invoke_next_credentials, args)

def svn_auth_provider_invoke_save_credentials(*args):
    """
    svn_auth_provider_invoke_save_credentials(svn_auth_provider_t _obj, svn_boolean_t saved, void credentials, 
        void provider_baton, apr_hash_t parameters, 
        char realmstring, apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_auth_provider_invoke_save_credentials, args)

def svn_auth_invoke_simple_provider_func(*args):
    """
    svn_auth_invoke_simple_provider_func(svn_auth_simple_provider_func_t _obj, svn_auth_provider_object_t provider, 
        apr_pool_t pool)
    """
    return apply(_core.svn_auth_invoke_simple_provider_func, args)

def svn_auth_invoke_ssl_client_cert_pw_provider_func(*args):
    """
    svn_auth_invoke_ssl_client_cert_pw_provider_func(svn_auth_ssl_client_cert_pw_provider_func_t _obj, svn_auth_provider_object_t provider, 
        apr_pool_t pool)
    """
    return apply(_core.svn_auth_invoke_ssl_client_cert_pw_provider_func, args)

def svn_auth_invoke_simple_prompt_func(*args):
    """
    svn_auth_invoke_simple_prompt_func(svn_auth_simple_prompt_func_t _obj, svn_auth_cred_simple_t cred, 
        void baton, char realm, char username, 
        svn_boolean_t may_save, apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_auth_invoke_simple_prompt_func, args)

def svn_auth_invoke_username_prompt_func(*args):
    """
    svn_auth_invoke_username_prompt_func(svn_auth_username_prompt_func_t _obj, svn_auth_cred_username_t cred, 
        void baton, char realm, svn_boolean_t may_save, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_auth_invoke_username_prompt_func, args)

def svn_auth_invoke_ssl_server_trust_prompt_func(*args):
    """
    svn_auth_invoke_ssl_server_trust_prompt_func(svn_auth_ssl_server_trust_prompt_func_t _obj, svn_auth_cred_ssl_server_trust_t cred, 
        void baton, 
        char realm, apr_uint32_t failures, svn_auth_ssl_server_cert_info_t cert_info, 
        svn_boolean_t may_save, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_auth_invoke_ssl_server_trust_prompt_func, args)

def svn_auth_invoke_ssl_client_cert_prompt_func(*args):
    """
    svn_auth_invoke_ssl_client_cert_prompt_func(svn_auth_ssl_client_cert_prompt_func_t _obj, svn_auth_cred_ssl_client_cert_t cred, 
        void baton, char realm, 
        svn_boolean_t may_save, apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_auth_invoke_ssl_client_cert_prompt_func, args)

def svn_auth_invoke_ssl_client_cert_pw_prompt_func(*args):
    """
    svn_auth_invoke_ssl_client_cert_pw_prompt_func(svn_auth_ssl_client_cert_pw_prompt_func_t _obj, svn_auth_cred_ssl_client_cert_pw_t cred, 
        void baton, 
        char realm, svn_boolean_t may_save, apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_auth_invoke_ssl_client_cert_pw_prompt_func, args)

def svn_auth_invoke_plaintext_prompt_func(*args):
    """
    svn_auth_invoke_plaintext_prompt_func(svn_auth_plaintext_prompt_func_t _obj, svn_boolean_t may_save_plaintext, 
        char realmstring, void baton, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_auth_invoke_plaintext_prompt_func, args)

def svn_auth_invoke_plaintext_passphrase_prompt_func(*args):
    """
    svn_auth_invoke_plaintext_passphrase_prompt_func(svn_auth_plaintext_passphrase_prompt_func_t _obj, svn_boolean_t may_save_plaintext, 
        char realmstring, 
        void baton, apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_auth_invoke_plaintext_passphrase_prompt_func, args)
class svn_auth_simple_provider_func_t:
    """Proxy of C svn_auth_simple_provider_func_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_auth_simple_provider_func_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_auth_simple_provider_func_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_auth_simple_provider_func_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_auth_simple_provider_func_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

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


class svn_auth_simple_provider_func_tPtr(svn_auth_simple_provider_func_t):
    def __init__(self, this):
        _swig_setattr(self, svn_auth_simple_provider_func_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_auth_simple_provider_func_t, 'thisown', 0)
        _swig_setattr(self, svn_auth_simple_provider_func_t,self.__class__,svn_auth_simple_provider_func_t)
_core.svn_auth_simple_provider_func_t_swigregister(svn_auth_simple_provider_func_tPtr)

class svn_auth_ssl_client_cert_pw_provider_func_t:
    """Proxy of C svn_auth_ssl_client_cert_pw_provider_func_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_auth_ssl_client_cert_pw_provider_func_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_auth_ssl_client_cert_pw_provider_func_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_auth_ssl_client_cert_pw_provider_func_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_auth_ssl_client_cert_pw_provider_func_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

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


class svn_auth_ssl_client_cert_pw_provider_func_tPtr(svn_auth_ssl_client_cert_pw_provider_func_t):
    def __init__(self, this):
        _swig_setattr(self, svn_auth_ssl_client_cert_pw_provider_func_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_auth_ssl_client_cert_pw_provider_func_t, 'thisown', 0)
        _swig_setattr(self, svn_auth_ssl_client_cert_pw_provider_func_t,self.__class__,svn_auth_ssl_client_cert_pw_provider_func_t)
_core.svn_auth_ssl_client_cert_pw_provider_func_t_swigregister(svn_auth_ssl_client_cert_pw_provider_func_tPtr)

class svn_auth_simple_prompt_func_t:
    """Proxy of C svn_auth_simple_prompt_func_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_auth_simple_prompt_func_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_auth_simple_prompt_func_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_auth_simple_prompt_func_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_auth_simple_prompt_func_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

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


class svn_auth_simple_prompt_func_tPtr(svn_auth_simple_prompt_func_t):
    def __init__(self, this):
        _swig_setattr(self, svn_auth_simple_prompt_func_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_auth_simple_prompt_func_t, 'thisown', 0)
        _swig_setattr(self, svn_auth_simple_prompt_func_t,self.__class__,svn_auth_simple_prompt_func_t)
_core.svn_auth_simple_prompt_func_t_swigregister(svn_auth_simple_prompt_func_tPtr)

class svn_auth_username_prompt_func_t:
    """Proxy of C svn_auth_username_prompt_func_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_auth_username_prompt_func_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_auth_username_prompt_func_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_auth_username_prompt_func_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_auth_username_prompt_func_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

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


class svn_auth_username_prompt_func_tPtr(svn_auth_username_prompt_func_t):
    def __init__(self, this):
        _swig_setattr(self, svn_auth_username_prompt_func_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_auth_username_prompt_func_t, 'thisown', 0)
        _swig_setattr(self, svn_auth_username_prompt_func_t,self.__class__,svn_auth_username_prompt_func_t)
_core.svn_auth_username_prompt_func_t_swigregister(svn_auth_username_prompt_func_tPtr)

class svn_auth_ssl_server_trust_prompt_func_t:
    """Proxy of C svn_auth_ssl_server_trust_prompt_func_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_auth_ssl_server_trust_prompt_func_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_auth_ssl_server_trust_prompt_func_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_auth_ssl_server_trust_prompt_func_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_auth_ssl_server_trust_prompt_func_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

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


class svn_auth_ssl_server_trust_prompt_func_tPtr(svn_auth_ssl_server_trust_prompt_func_t):
    def __init__(self, this):
        _swig_setattr(self, svn_auth_ssl_server_trust_prompt_func_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_auth_ssl_server_trust_prompt_func_t, 'thisown', 0)
        _swig_setattr(self, svn_auth_ssl_server_trust_prompt_func_t,self.__class__,svn_auth_ssl_server_trust_prompt_func_t)
_core.svn_auth_ssl_server_trust_prompt_func_t_swigregister(svn_auth_ssl_server_trust_prompt_func_tPtr)

class svn_auth_ssl_client_cert_prompt_func_t:
    """Proxy of C svn_auth_ssl_client_cert_prompt_func_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_auth_ssl_client_cert_prompt_func_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_auth_ssl_client_cert_prompt_func_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_auth_ssl_client_cert_prompt_func_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_auth_ssl_client_cert_prompt_func_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

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


class svn_auth_ssl_client_cert_prompt_func_tPtr(svn_auth_ssl_client_cert_prompt_func_t):
    def __init__(self, this):
        _swig_setattr(self, svn_auth_ssl_client_cert_prompt_func_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_auth_ssl_client_cert_prompt_func_t, 'thisown', 0)
        _swig_setattr(self, svn_auth_ssl_client_cert_prompt_func_t,self.__class__,svn_auth_ssl_client_cert_prompt_func_t)
_core.svn_auth_ssl_client_cert_prompt_func_t_swigregister(svn_auth_ssl_client_cert_prompt_func_tPtr)

class svn_auth_ssl_client_cert_pw_prompt_func_t:
    """Proxy of C svn_auth_ssl_client_cert_pw_prompt_func_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_auth_ssl_client_cert_pw_prompt_func_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_auth_ssl_client_cert_pw_prompt_func_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_auth_ssl_client_cert_pw_prompt_func_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_auth_ssl_client_cert_pw_prompt_func_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

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


class svn_auth_ssl_client_cert_pw_prompt_func_tPtr(svn_auth_ssl_client_cert_pw_prompt_func_t):
    def __init__(self, this):
        _swig_setattr(self, svn_auth_ssl_client_cert_pw_prompt_func_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_auth_ssl_client_cert_pw_prompt_func_t, 'thisown', 0)
        _swig_setattr(self, svn_auth_ssl_client_cert_pw_prompt_func_t,self.__class__,svn_auth_ssl_client_cert_pw_prompt_func_t)
_core.svn_auth_ssl_client_cert_pw_prompt_func_t_swigregister(svn_auth_ssl_client_cert_pw_prompt_func_tPtr)

class svn_auth_plaintext_prompt_func_t:
    """Proxy of C svn_auth_plaintext_prompt_func_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_auth_plaintext_prompt_func_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_auth_plaintext_prompt_func_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_auth_plaintext_prompt_func_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_auth_plaintext_prompt_func_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

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


class svn_auth_plaintext_prompt_func_tPtr(svn_auth_plaintext_prompt_func_t):
    def __init__(self, this):
        _swig_setattr(self, svn_auth_plaintext_prompt_func_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_auth_plaintext_prompt_func_t, 'thisown', 0)
        _swig_setattr(self, svn_auth_plaintext_prompt_func_t,self.__class__,svn_auth_plaintext_prompt_func_t)
_core.svn_auth_plaintext_prompt_func_t_swigregister(svn_auth_plaintext_prompt_func_tPtr)

class svn_auth_plaintext_passphrase_prompt_func_t:
    """Proxy of C svn_auth_plaintext_passphrase_prompt_func_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_auth_plaintext_passphrase_prompt_func_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_auth_plaintext_passphrase_prompt_func_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_auth_plaintext_passphrase_prompt_func_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_auth_plaintext_passphrase_prompt_func_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

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


class svn_auth_plaintext_passphrase_prompt_func_tPtr(svn_auth_plaintext_passphrase_prompt_func_t):
    def __init__(self, this):
        _swig_setattr(self, svn_auth_plaintext_passphrase_prompt_func_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_auth_plaintext_passphrase_prompt_func_t, 'thisown', 0)
        _swig_setattr(self, svn_auth_plaintext_passphrase_prompt_func_t,self.__class__,svn_auth_plaintext_passphrase_prompt_func_t)
_core.svn_auth_plaintext_passphrase_prompt_func_t_swigregister(svn_auth_plaintext_passphrase_prompt_func_tPtr)

class svn_auth_gnome_keyring_unlock_prompt_func_t:
    """Proxy of C svn_auth_gnome_keyring_unlock_prompt_func_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_auth_gnome_keyring_unlock_prompt_func_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_auth_gnome_keyring_unlock_prompt_func_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_auth_gnome_keyring_unlock_prompt_func_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_auth_gnome_keyring_unlock_prompt_func_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

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


class svn_auth_gnome_keyring_unlock_prompt_func_tPtr(svn_auth_gnome_keyring_unlock_prompt_func_t):
    def __init__(self, this):
        _swig_setattr(self, svn_auth_gnome_keyring_unlock_prompt_func_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_auth_gnome_keyring_unlock_prompt_func_t, 'thisown', 0)
        _swig_setattr(self, svn_auth_gnome_keyring_unlock_prompt_func_t,self.__class__,svn_auth_gnome_keyring_unlock_prompt_func_t)
_core.svn_auth_gnome_keyring_unlock_prompt_func_t_swigregister(svn_auth_gnome_keyring_unlock_prompt_func_tPtr)

SVN_CONFIG_CATEGORY_SERVERS = _core.SVN_CONFIG_CATEGORY_SERVERS
SVN_CONFIG_SECTION_GROUPS = _core.SVN_CONFIG_SECTION_GROUPS
SVN_CONFIG_SECTION_GLOBAL = _core.SVN_CONFIG_SECTION_GLOBAL
SVN_CONFIG_OPTION_HTTP_PROXY_HOST = _core.SVN_CONFIG_OPTION_HTTP_PROXY_HOST
SVN_CONFIG_OPTION_HTTP_PROXY_PORT = _core.SVN_CONFIG_OPTION_HTTP_PROXY_PORT
SVN_CONFIG_OPTION_HTTP_PROXY_USERNAME = _core.SVN_CONFIG_OPTION_HTTP_PROXY_USERNAME
SVN_CONFIG_OPTION_HTTP_PROXY_PASSWORD = _core.SVN_CONFIG_OPTION_HTTP_PROXY_PASSWORD
SVN_CONFIG_OPTION_HTTP_PROXY_EXCEPTIONS = _core.SVN_CONFIG_OPTION_HTTP_PROXY_EXCEPTIONS
SVN_CONFIG_OPTION_HTTP_TIMEOUT = _core.SVN_CONFIG_OPTION_HTTP_TIMEOUT
SVN_CONFIG_OPTION_HTTP_COMPRESSION = _core.SVN_CONFIG_OPTION_HTTP_COMPRESSION
SVN_CONFIG_OPTION_NEON_DEBUG_MASK = _core.SVN_CONFIG_OPTION_NEON_DEBUG_MASK
SVN_CONFIG_OPTION_HTTP_AUTH_TYPES = _core.SVN_CONFIG_OPTION_HTTP_AUTH_TYPES
SVN_CONFIG_OPTION_SSL_AUTHORITY_FILES = _core.SVN_CONFIG_OPTION_SSL_AUTHORITY_FILES
SVN_CONFIG_OPTION_SSL_TRUST_DEFAULT_CA = _core.SVN_CONFIG_OPTION_SSL_TRUST_DEFAULT_CA
SVN_CONFIG_OPTION_SSL_CLIENT_CERT_FILE = _core.SVN_CONFIG_OPTION_SSL_CLIENT_CERT_FILE
SVN_CONFIG_OPTION_SSL_CLIENT_CERT_PASSWORD = _core.SVN_CONFIG_OPTION_SSL_CLIENT_CERT_PASSWORD
SVN_CONFIG_OPTION_SSL_PKCS11_PROVIDER = _core.SVN_CONFIG_OPTION_SSL_PKCS11_PROVIDER
SVN_CONFIG_OPTION_HTTP_LIBRARY = _core.SVN_CONFIG_OPTION_HTTP_LIBRARY
SVN_CONFIG_OPTION_STORE_PASSWORDS = _core.SVN_CONFIG_OPTION_STORE_PASSWORDS
SVN_CONFIG_OPTION_STORE_PLAINTEXT_PASSWORDS = _core.SVN_CONFIG_OPTION_STORE_PLAINTEXT_PASSWORDS
SVN_CONFIG_OPTION_STORE_AUTH_CREDS = _core.SVN_CONFIG_OPTION_STORE_AUTH_CREDS
SVN_CONFIG_OPTION_STORE_SSL_CLIENT_CERT_PP = _core.SVN_CONFIG_OPTION_STORE_SSL_CLIENT_CERT_PP
SVN_CONFIG_OPTION_STORE_SSL_CLIENT_CERT_PP_PLAINTEXT = _core.SVN_CONFIG_OPTION_STORE_SSL_CLIENT_CERT_PP_PLAINTEXT
SVN_CONFIG_OPTION_USERNAME = _core.SVN_CONFIG_OPTION_USERNAME
SVN_CONFIG_CATEGORY_CONFIG = _core.SVN_CONFIG_CATEGORY_CONFIG
SVN_CONFIG_SECTION_AUTH = _core.SVN_CONFIG_SECTION_AUTH
SVN_CONFIG_OPTION_PASSWORD_STORES = _core.SVN_CONFIG_OPTION_PASSWORD_STORES
SVN_CONFIG_OPTION_KWALLET_WALLET = _core.SVN_CONFIG_OPTION_KWALLET_WALLET
SVN_CONFIG_OPTION_KWALLET_SVN_APPLICATION_NAME_WITH_PID = _core.SVN_CONFIG_OPTION_KWALLET_SVN_APPLICATION_NAME_WITH_PID
SVN_CONFIG_SECTION_HELPERS = _core.SVN_CONFIG_SECTION_HELPERS
SVN_CONFIG_OPTION_EDITOR_CMD = _core.SVN_CONFIG_OPTION_EDITOR_CMD
SVN_CONFIG_OPTION_DIFF_CMD = _core.SVN_CONFIG_OPTION_DIFF_CMD
SVN_CONFIG_OPTION_DIFF3_CMD = _core.SVN_CONFIG_OPTION_DIFF3_CMD
SVN_CONFIG_OPTION_DIFF3_HAS_PROGRAM_ARG = _core.SVN_CONFIG_OPTION_DIFF3_HAS_PROGRAM_ARG
SVN_CONFIG_OPTION_MERGE_TOOL_CMD = _core.SVN_CONFIG_OPTION_MERGE_TOOL_CMD
SVN_CONFIG_SECTION_MISCELLANY = _core.SVN_CONFIG_SECTION_MISCELLANY
SVN_CONFIG_OPTION_GLOBAL_IGNORES = _core.SVN_CONFIG_OPTION_GLOBAL_IGNORES
SVN_CONFIG_OPTION_LOG_ENCODING = _core.SVN_CONFIG_OPTION_LOG_ENCODING
SVN_CONFIG_OPTION_USE_COMMIT_TIMES = _core.SVN_CONFIG_OPTION_USE_COMMIT_TIMES
SVN_CONFIG_OPTION_TEMPLATE_ROOT = _core.SVN_CONFIG_OPTION_TEMPLATE_ROOT
SVN_CONFIG_OPTION_ENABLE_AUTO_PROPS = _core.SVN_CONFIG_OPTION_ENABLE_AUTO_PROPS
SVN_CONFIG_OPTION_NO_UNLOCK = _core.SVN_CONFIG_OPTION_NO_UNLOCK
SVN_CONFIG_OPTION_MIMETYPES_FILE = _core.SVN_CONFIG_OPTION_MIMETYPES_FILE
SVN_CONFIG_OPTION_PRESERVED_CF_EXTS = _core.SVN_CONFIG_OPTION_PRESERVED_CF_EXTS
SVN_CONFIG_OPTION_INTERACTIVE_CONFLICTS = _core.SVN_CONFIG_OPTION_INTERACTIVE_CONFLICTS
SVN_CONFIG_SECTION_TUNNELS = _core.SVN_CONFIG_SECTION_TUNNELS
SVN_CONFIG_SECTION_AUTO_PROPS = _core.SVN_CONFIG_SECTION_AUTO_PROPS
SVN_CONFIG_SECTION_GENERAL = _core.SVN_CONFIG_SECTION_GENERAL
SVN_CONFIG_OPTION_ANON_ACCESS = _core.SVN_CONFIG_OPTION_ANON_ACCESS
SVN_CONFIG_OPTION_AUTH_ACCESS = _core.SVN_CONFIG_OPTION_AUTH_ACCESS
SVN_CONFIG_OPTION_PASSWORD_DB = _core.SVN_CONFIG_OPTION_PASSWORD_DB
SVN_CONFIG_OPTION_REALM = _core.SVN_CONFIG_OPTION_REALM
SVN_CONFIG_OPTION_AUTHZ_DB = _core.SVN_CONFIG_OPTION_AUTHZ_DB
SVN_CONFIG_SECTION_SASL = _core.SVN_CONFIG_SECTION_SASL
SVN_CONFIG_OPTION_USE_SASL = _core.SVN_CONFIG_OPTION_USE_SASL
SVN_CONFIG_OPTION_MIN_SSF = _core.SVN_CONFIG_OPTION_MIN_SSF
SVN_CONFIG_OPTION_MAX_SSF = _core.SVN_CONFIG_OPTION_MAX_SSF
SVN_CONFIG_SECTION_USERS = _core.SVN_CONFIG_SECTION_USERS
SVN_CONFIG__DEFAULT_GLOBAL_IGNORES_LINE_1 = _core.SVN_CONFIG__DEFAULT_GLOBAL_IGNORES_LINE_1
SVN_CONFIG__DEFAULT_GLOBAL_IGNORES_LINE_2 = _core.SVN_CONFIG__DEFAULT_GLOBAL_IGNORES_LINE_2
SVN_CONFIG_DEFAULT_GLOBAL_IGNORES = _core.SVN_CONFIG_DEFAULT_GLOBAL_IGNORES
SVN_CONFIG_TRUE = _core.SVN_CONFIG_TRUE
SVN_CONFIG_FALSE = _core.SVN_CONFIG_FALSE
SVN_CONFIG_ASK = _core.SVN_CONFIG_ASK
SVN_CONFIG_DEFAULT_OPTION_STORE_PASSWORDS = _core.SVN_CONFIG_DEFAULT_OPTION_STORE_PASSWORDS
SVN_CONFIG_DEFAULT_OPTION_STORE_PLAINTEXT_PASSWORDS = _core.SVN_CONFIG_DEFAULT_OPTION_STORE_PLAINTEXT_PASSWORDS
SVN_CONFIG_DEFAULT_OPTION_STORE_AUTH_CREDS = _core.SVN_CONFIG_DEFAULT_OPTION_STORE_AUTH_CREDS
SVN_CONFIG_DEFAULT_OPTION_STORE_SSL_CLIENT_CERT_PP = _core.SVN_CONFIG_DEFAULT_OPTION_STORE_SSL_CLIENT_CERT_PP
SVN_CONFIG_DEFAULT_OPTION_STORE_SSL_CLIENT_CERT_PP_PLAINTEXT = _core.SVN_CONFIG_DEFAULT_OPTION_STORE_SSL_CLIENT_CERT_PP_PLAINTEXT

def svn_config_get_config(*args):
    """svn_config_get_config(apr_hash_t cfg_hash, char config_dir, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_config_get_config, args)

def svn_config_read(*args):
    """
    svn_config_read(svn_config_t cfgp, char file, svn_boolean_t must_exist, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_config_read, args)

def svn_config_merge(*args):
    """svn_config_merge(svn_config_t cfg, char file, svn_boolean_t must_exist) -> svn_error_t"""
    return apply(_core.svn_config_merge, args)

def svn_config_get(*args):
    """
    svn_config_get(svn_config_t cfg, char valuep, char section, char option, 
        char default_value)
    """
    return apply(_core.svn_config_get, args)

def svn_config_set(*args):
    """svn_config_set(svn_config_t cfg, char section, char option, char value)"""
    return apply(_core.svn_config_set, args)

def svn_config_get_bool(*args):
    """
    svn_config_get_bool(svn_config_t cfg, svn_boolean_t valuep, char section, 
        char option, svn_boolean_t default_value) -> svn_error_t
    """
    return apply(_core.svn_config_get_bool, args)

def svn_config_set_bool(*args):
    """svn_config_set_bool(svn_config_t cfg, char section, char option, svn_boolean_t value)"""
    return apply(_core.svn_config_set_bool, args)

def svn_config_get_yes_no_ask(*args):
    """
    svn_config_get_yes_no_ask(svn_config_t cfg, char valuep, char section, char option, 
        char default_value) -> svn_error_t
    """
    return apply(_core.svn_config_get_yes_no_ask, args)

def svn_config_enumerate_sections(*args):
    """
    svn_config_enumerate_sections(svn_config_t cfg, svn_config_section_enumerator_t callback, 
        void baton) -> int
    """
    return apply(_core.svn_config_enumerate_sections, args)

def svn_config_enumerate_sections2(*args):
    """
    svn_config_enumerate_sections2(svn_config_t cfg, svn_config_section_enumerator2_t callback, 
        void baton, apr_pool_t pool) -> int
    """
    return apply(_core.svn_config_enumerate_sections2, args)

def svn_config_enumerate(*args):
    """
    svn_config_enumerate(svn_config_t cfg, char section, svn_config_enumerator_t callback, 
        void baton) -> int
    """
    return apply(_core.svn_config_enumerate, args)

def svn_config_enumerate2(*args):
    """
    svn_config_enumerate2(svn_config_t cfg, char section, svn_config_enumerator2_t callback, 
        void baton, apr_pool_t pool) -> int
    """
    return apply(_core.svn_config_enumerate2, args)

def svn_config_has_section(*args):
    """svn_config_has_section(svn_config_t cfg, char section) -> svn_boolean_t"""
    return apply(_core.svn_config_has_section, args)

def svn_config_find_group(*args):
    """svn_config_find_group(svn_config_t cfg, char key, char master_section, apr_pool_t pool) -> char"""
    return apply(_core.svn_config_find_group, args)

def svn_config_get_server_setting(*args):
    """
    svn_config_get_server_setting(svn_config_t cfg, char server_group, char option_name, 
        char default_value) -> char
    """
    return apply(_core.svn_config_get_server_setting, args)

def svn_config_get_server_setting_int(*args):
    """
    svn_config_get_server_setting_int(svn_config_t cfg, char server_group, char option_name, 
        apr_int64_t default_value, apr_int64_t result_value, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_config_get_server_setting_int, args)

def svn_config_get_server_setting_bool(*args):
    """
    svn_config_get_server_setting_bool(svn_config_t cfg, svn_boolean_t valuep, char server_group, 
        char option_name, svn_boolean_t default_value) -> svn_error_t
    """
    return apply(_core.svn_config_get_server_setting_bool, args)

def svn_config_ensure(*args):
    """svn_config_ensure(char config_dir, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_config_ensure, args)
SVN_CONFIG_REALMSTRING_KEY = _core.SVN_CONFIG_REALMSTRING_KEY

def svn_config_read_auth_data(*args):
    """
    svn_config_read_auth_data(apr_hash_t hash, char cred_kind, char realmstring, 
        char config_dir, apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_config_read_auth_data, args)

def svn_config_write_auth_data(*args):
    """
    svn_config_write_auth_data(apr_hash_t hash, char cred_kind, char realmstring, 
        char config_dir, apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_config_write_auth_data, args)

def svn_config_get_user_config_path(*args):
    """svn_config_get_user_config_path(char path, char config_dir, char fname, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_config_get_user_config_path, args)
class svn_config_t:
    """Proxy of C svn_config_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_config_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_config_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_config_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_config_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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


class svn_config_tPtr(svn_config_t):
    def __init__(self, this):
        _swig_setattr(self, svn_config_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_config_t, 'thisown', 0)
        _swig_setattr(self, svn_config_t,self.__class__,svn_config_t)
_core.svn_config_t_swigregister(svn_config_tPtr)


def svn_config_invoke_section_enumerator(*args):
    """svn_config_invoke_section_enumerator(svn_config_section_enumerator_t _obj, char name, void baton) -> svn_boolean_t"""
    return apply(_core.svn_config_invoke_section_enumerator, args)

def svn_config_invoke_section_enumerator2(*args):
    """
    svn_config_invoke_section_enumerator2(svn_config_section_enumerator2_t _obj, char name, void baton, 
        apr_pool_t pool) -> svn_boolean_t
    """
    return apply(_core.svn_config_invoke_section_enumerator2, args)

def svn_config_invoke_enumerator(*args):
    """
    svn_config_invoke_enumerator(svn_config_enumerator_t _obj, char name, char value, 
        void baton) -> svn_boolean_t
    """
    return apply(_core.svn_config_invoke_enumerator, args)

def svn_config_invoke_enumerator2(*args):
    """
    svn_config_invoke_enumerator2(svn_config_enumerator2_t _obj, char name, char value, 
        void baton, apr_pool_t pool) -> svn_boolean_t
    """
    return apply(_core.svn_config_invoke_enumerator2, args)
class svn_config_section_enumerator_t:
    """Proxy of C svn_config_section_enumerator_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_config_section_enumerator_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_config_section_enumerator_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_config_section_enumerator_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_config_section_enumerator_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

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


class svn_config_section_enumerator_tPtr(svn_config_section_enumerator_t):
    def __init__(self, this):
        _swig_setattr(self, svn_config_section_enumerator_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_config_section_enumerator_t, 'thisown', 0)
        _swig_setattr(self, svn_config_section_enumerator_t,self.__class__,svn_config_section_enumerator_t)
_core.svn_config_section_enumerator_t_swigregister(svn_config_section_enumerator_tPtr)

class svn_config_section_enumerator2_t:
    """Proxy of C svn_config_section_enumerator2_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_config_section_enumerator2_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_config_section_enumerator2_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_config_section_enumerator2_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_config_section_enumerator2_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

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


class svn_config_section_enumerator2_tPtr(svn_config_section_enumerator2_t):
    def __init__(self, this):
        _swig_setattr(self, svn_config_section_enumerator2_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_config_section_enumerator2_t, 'thisown', 0)
        _swig_setattr(self, svn_config_section_enumerator2_t,self.__class__,svn_config_section_enumerator2_t)
_core.svn_config_section_enumerator2_t_swigregister(svn_config_section_enumerator2_tPtr)

class svn_config_enumerator_t:
    """Proxy of C svn_config_enumerator_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_config_enumerator_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_config_enumerator_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_config_enumerator_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_config_enumerator_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

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


class svn_config_enumerator_tPtr(svn_config_enumerator_t):
    def __init__(self, this):
        _swig_setattr(self, svn_config_enumerator_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_config_enumerator_t, 'thisown', 0)
        _swig_setattr(self, svn_config_enumerator_t,self.__class__,svn_config_enumerator_t)
_core.svn_config_enumerator_t_swigregister(svn_config_enumerator_tPtr)

class svn_config_enumerator2_t:
    """Proxy of C svn_config_enumerator2_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_config_enumerator2_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_config_enumerator2_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_config_enumerator2_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_config_enumerator2_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

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


class svn_config_enumerator2_tPtr(svn_config_enumerator2_t):
    def __init__(self, this):
        _swig_setattr(self, svn_config_enumerator2_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_config_enumerator2_t, 'thisown', 0)
        _swig_setattr(self, svn_config_enumerator2_t,self.__class__,svn_config_enumerator2_t)
_core.svn_config_enumerator2_t_swigregister(svn_config_enumerator2_tPtr)


def svn_utf_initialize(*args):
    """svn_utf_initialize(apr_pool_t pool)"""
    return apply(_core.svn_utf_initialize, args)

def svn_utf_stringbuf_to_utf8(*args):
    """svn_utf_stringbuf_to_utf8(svn_stringbuf_t dest, svn_stringbuf_t src, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_utf_stringbuf_to_utf8, args)

def svn_utf_string_to_utf8(*args):
    """svn_utf_string_to_utf8(svn_string_t dest, svn_string_t src, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_utf_string_to_utf8, args)

def svn_utf_cstring_to_utf8(*args):
    """svn_utf_cstring_to_utf8(char dest, char src, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_utf_cstring_to_utf8, args)

def svn_utf_cstring_to_utf8_ex2(*args):
    """svn_utf_cstring_to_utf8_ex2(char dest, char src, char frompage, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_utf_cstring_to_utf8_ex2, args)

def svn_utf_cstring_to_utf8_ex(*args):
    """
    svn_utf_cstring_to_utf8_ex(char dest, char src, char frompage, char convset_key, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_utf_cstring_to_utf8_ex, args)

def svn_utf_stringbuf_from_utf8(*args):
    """svn_utf_stringbuf_from_utf8(svn_stringbuf_t dest, svn_stringbuf_t src, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_utf_stringbuf_from_utf8, args)

def svn_utf_string_from_utf8(*args):
    """svn_utf_string_from_utf8(svn_string_t dest, svn_string_t src, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_utf_string_from_utf8, args)

def svn_utf_cstring_from_utf8(*args):
    """svn_utf_cstring_from_utf8(char dest, char src, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_utf_cstring_from_utf8, args)

def svn_utf_cstring_from_utf8_ex2(*args):
    """svn_utf_cstring_from_utf8_ex2(char dest, char src, char topage, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_utf_cstring_from_utf8_ex2, args)

def svn_utf_cstring_from_utf8_ex(*args):
    """
    svn_utf_cstring_from_utf8_ex(char dest, char src, char topage, char convset_key, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_utf_cstring_from_utf8_ex, args)

def svn_utf_cstring_from_utf8_fuzzy(*args):
    """svn_utf_cstring_from_utf8_fuzzy(char src, apr_pool_t pool) -> char"""
    return apply(_core.svn_utf_cstring_from_utf8_fuzzy, args)

def svn_utf_cstring_from_utf8_stringbuf(*args):
    """svn_utf_cstring_from_utf8_stringbuf(char dest, svn_stringbuf_t src, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_utf_cstring_from_utf8_stringbuf, args)

def svn_utf_cstring_from_utf8_string(*args):
    """svn_utf_cstring_from_utf8_string(char dest, svn_string_t src, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_utf_cstring_from_utf8_string, args)

def svn_nls_init(*args):
    """svn_nls_init() -> svn_error_t"""
    return apply(_core.svn_nls_init, args)

def svn_path_internal_style(*args):
    """svn_path_internal_style(char path, apr_pool_t pool) -> char"""
    return apply(_core.svn_path_internal_style, args)

def svn_path_local_style(*args):
    """svn_path_local_style(char path, apr_pool_t pool) -> char"""
    return apply(_core.svn_path_local_style, args)

def svn_path_splitext(*args):
    """svn_path_splitext(char path_root, char path_ext, char path, apr_pool_t pool)"""
    return apply(_core.svn_path_splitext, args)

def svn_path_is_empty(*args):
    """svn_path_is_empty(char path) -> int"""
    return apply(_core.svn_path_is_empty, args)

def svn_dirent_is_root(*args):
    """svn_dirent_is_root(char dirent, apr_size_t len) -> svn_boolean_t"""
    return apply(_core.svn_dirent_is_root, args)

def svn_path_canonicalize(*args):
    """svn_path_canonicalize(char path, apr_pool_t pool) -> char"""
    return apply(_core.svn_path_canonicalize, args)

def svn_path_is_canonical(*args):
    """svn_path_is_canonical(char path, apr_pool_t pool) -> svn_boolean_t"""
    return apply(_core.svn_path_is_canonical, args)

def svn_path_compare_paths(*args):
    """svn_path_compare_paths(char path1, char path2) -> int"""
    return apply(_core.svn_path_compare_paths, args)

def svn_path_get_longest_ancestor(*args):
    """svn_path_get_longest_ancestor(char path1, char path2, apr_pool_t pool) -> char"""
    return apply(_core.svn_path_get_longest_ancestor, args)

def svn_path_is_dotpath_present(*args):
    """svn_path_is_dotpath_present(char path) -> svn_boolean_t"""
    return apply(_core.svn_path_is_dotpath_present, args)

def svn_path_is_url(*args):
    """svn_path_is_url(char path) -> svn_boolean_t"""
    return apply(_core.svn_path_is_url, args)

def svn_path_is_uri_safe(*args):
    """svn_path_is_uri_safe(char path) -> svn_boolean_t"""
    return apply(_core.svn_path_is_uri_safe, args)

def svn_path_url_add_component2(*args):
    """svn_path_url_add_component2(char url, char component, apr_pool_t pool) -> char"""
    return apply(_core.svn_path_url_add_component2, args)
SVN_MERGEINFO_NONINHERITABLE_STR = _core.SVN_MERGEINFO_NONINHERITABLE_STR

def svn_mergeinfo_parse(*args):
    """svn_mergeinfo_parse(svn_mergeinfo_t mergeinfo, char input, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_mergeinfo_parse, args)

def svn_mergeinfo_diff(*args):
    """
    svn_mergeinfo_diff(svn_mergeinfo_t deleted, svn_mergeinfo_t added, svn_mergeinfo_t mergefrom, 
        svn_mergeinfo_t mergeto, 
        svn_boolean_t consider_inheritance, apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_mergeinfo_diff, args)

def svn_mergeinfo_remove(*args):
    """
    svn_mergeinfo_remove(svn_mergeinfo_t mergeinfo, svn_mergeinfo_t eraser, 
        svn_mergeinfo_t whiteboard, apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_mergeinfo_remove, args)

def svn_rangelist_diff(*args):
    """
    svn_rangelist_diff(apr_array_header_t deleted, apr_array_header_t added, 
        apr_array_header_t from, apr_array_header_t to, 
        svn_boolean_t consider_inheritance, apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_rangelist_diff, args)

def svn_rangelist_remove(*args):
    """
    svn_rangelist_remove(apr_array_header_t output, apr_array_header_t eraser, 
        apr_array_header_t whiteboard, svn_boolean_t consider_inheritance, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_rangelist_remove, args)

def svn_mergeinfo_intersect(*args):
    """
    svn_mergeinfo_intersect(svn_mergeinfo_t mergeinfo, svn_mergeinfo_t mergeinfo1, 
        svn_mergeinfo_t mergeinfo2, apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_mergeinfo_intersect, args)

def svn_rangelist_intersect(*args):
    """
    svn_rangelist_intersect(apr_array_header_t rangelist, apr_array_header_t rangelist1, 
        apr_array_header_t rangelist2, svn_boolean_t consider_inheritance, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_rangelist_intersect, args)

def svn_rangelist_to_string(*args):
    """
    svn_rangelist_to_string(svn_string_t output, apr_array_header_t rangelist, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_rangelist_to_string, args)

def svn_rangelist_inheritable(*args):
    """
    svn_rangelist_inheritable(apr_array_header_t inheritable_rangelist, apr_array_header_t rangelist, 
        svn_revnum_t start, svn_revnum_t end, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_rangelist_inheritable, args)

def svn_mergeinfo_inheritable(*args):
    """
    svn_mergeinfo_inheritable(svn_mergeinfo_t inheritable_mergeinfo, svn_mergeinfo_t mergeinfo, 
        char path, svn_revnum_t start, 
        svn_revnum_t end, apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_mergeinfo_inheritable, args)

def svn_mergeinfo_to_string(*args):
    """svn_mergeinfo_to_string(svn_string_t output, svn_mergeinfo_t mergeinput, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_mergeinfo_to_string, args)

def svn_mergeinfo_catalog_dup(*args):
    """svn_mergeinfo_catalog_dup(svn_mergeinfo_catalog_t mergeinfo_catalog, apr_pool_t pool) -> svn_mergeinfo_catalog_t"""
    return apply(_core.svn_mergeinfo_catalog_dup, args)

def svn_mergeinfo_dup(*args):
    """svn_mergeinfo_dup(svn_mergeinfo_t mergeinfo, apr_pool_t pool) -> svn_mergeinfo_t"""
    return apply(_core.svn_mergeinfo_dup, args)

def svn_rangelist_dup(*args):
    """svn_rangelist_dup(apr_array_header_t rangelist, apr_pool_t pool) -> apr_array_header_t"""
    return apply(_core.svn_rangelist_dup, args)
svn_mergeinfo_explicit = _core.svn_mergeinfo_explicit
svn_mergeinfo_inherited = _core.svn_mergeinfo_inherited
svn_mergeinfo_nearest_ancestor = _core.svn_mergeinfo_nearest_ancestor

def svn_inheritance_to_word(*args):
    """svn_inheritance_to_word(svn_mergeinfo_inheritance_t inherit) -> char"""
    return apply(_core.svn_inheritance_to_word, args)

def svn_inheritance_from_word(*args):
    """svn_inheritance_from_word(char word) -> int"""
    return apply(_core.svn_inheritance_from_word, args)
svn_io_file_del_none = _core.svn_io_file_del_none
svn_io_file_del_on_close = _core.svn_io_file_del_on_close
svn_io_file_del_on_pool_cleanup = _core.svn_io_file_del_on_pool_cleanup
class svn_io_dirent_t:
    """Proxy of C svn_io_dirent_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_io_dirent_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_io_dirent_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C svn_io_dirent_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["kind"] = _core.svn_io_dirent_t_kind_set
    __swig_getmethods__["kind"] = _core.svn_io_dirent_t_kind_get
    __swig_setmethods__["special"] = _core.svn_io_dirent_t_special_set
    __swig_getmethods__["special"] = _core.svn_io_dirent_t_special_get
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_io_dirent_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

    def __init__(self, *args):
        """__init__(self) -> svn_io_dirent_t"""
        _swig_setattr(self, svn_io_dirent_t, 'this', apply(_core.new_svn_io_dirent_t, args))
        _swig_setattr(self, svn_io_dirent_t, 'thisown', 1)
    def __del__(self, destroy=_core.delete_svn_io_dirent_t):
        """__del__(self)"""
        try:
            if self.thisown: destroy(self)
        except: pass


class svn_io_dirent_tPtr(svn_io_dirent_t):
    def __init__(self, this):
        _swig_setattr(self, svn_io_dirent_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_io_dirent_t, 'thisown', 0)
        _swig_setattr(self, svn_io_dirent_t,self.__class__,svn_io_dirent_t)
_core.svn_io_dirent_t_swigregister(svn_io_dirent_tPtr)


def svn_io_open_uniquely_named(*args):
    """
    svn_io_open_uniquely_named(apr_file_t file, char unique_name, char dirpath, char filename, 
        char suffix, svn_io_file_del_t delete_when, 
        apr_pool_t result_pool, apr_pool_t scratch_pool) -> svn_error_t
    """
    return apply(_core.svn_io_open_uniquely_named, args)

def svn_io_open_unique_file3(*args):
    """
    svn_io_open_unique_file3(apr_file_t file, char temp_path, char dirpath, svn_io_file_del_t delete_when, 
        apr_pool_t result_pool, 
        apr_pool_t scratch_pool) -> svn_error_t
    """
    return apply(_core.svn_io_open_unique_file3, args)

def svn_io_open_unique_file2(*args):
    """
    svn_io_open_unique_file2(apr_file_t f, char unique_name_p, char path, char suffix, 
        svn_io_file_del_t delete_when, apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_io_open_unique_file2, args)

def svn_io_open_unique_file(*args):
    """
    svn_io_open_unique_file(apr_file_t f, char unique_name_p, char path, char suffix, 
        svn_boolean_t delete_on_close, apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_io_open_unique_file, args)

def svn_io_copy_perms(*args):
    """svn_io_copy_perms(char src, char dst, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_io_copy_perms, args)

def svn_io_sleep_for_timestamps(*args):
    """svn_io_sleep_for_timestamps(char path, apr_pool_t pool)"""
    return apply(_core.svn_io_sleep_for_timestamps, args)

def svn_io_file_checksum2(*args):
    """
    svn_io_file_checksum2(svn_checksum_t checksum, char file, svn_checksum_kind_t kind, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_io_file_checksum2, args)

def svn_io_file_checksum(*args):
    """svn_io_file_checksum(unsigned char digest, char file, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_io_file_checksum, args)

def svn_io_files_contents_same_p(*args):
    """svn_io_files_contents_same_p(svn_boolean_t same, char file1, char file2, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_io_files_contents_same_p, args)

def svn_stream_empty(*args):
    """svn_stream_empty(apr_pool_t pool) -> svn_stream_t"""
    return apply(_core.svn_stream_empty, args)

def svn_stream_disown(*args):
    """svn_stream_disown(svn_stream_t stream, apr_pool_t pool) -> svn_stream_t"""
    return apply(_core.svn_stream_disown, args)

def svn_stream_open_readonly(*args):
    """
    svn_stream_open_readonly(svn_stream_t stream, char path, apr_pool_t result_pool, 
        apr_pool_t scratch_pool) -> svn_error_t
    """
    return apply(_core.svn_stream_open_readonly, args)

def svn_stream_open_writable(*args):
    """
    svn_stream_open_writable(svn_stream_t stream, char path, apr_pool_t result_pool, 
        apr_pool_t scratch_pool) -> svn_error_t
    """
    return apply(_core.svn_stream_open_writable, args)

def svn_stream_open_unique(*args):
    """
    svn_stream_open_unique(svn_stream_t stream, char temp_path, char dirpath, 
        svn_io_file_del_t delete_when, apr_pool_t result_pool, 
        apr_pool_t scratch_pool) -> svn_error_t
    """
    return apply(_core.svn_stream_open_unique, args)

def svn_stream_from_aprfile2(*args):
    """svn_stream_from_aprfile2(apr_file_t file, svn_boolean_t disown, apr_pool_t pool) -> svn_stream_t"""
    return apply(_core.svn_stream_from_aprfile2, args)

def svn_stream_from_aprfile(*args):
    """svn_stream_from_aprfile(apr_file_t file, apr_pool_t pool) -> svn_stream_t"""
    return apply(_core.svn_stream_from_aprfile, args)

def svn_stream_for_stdout(*args):
    """svn_stream_for_stdout(svn_stream_t out, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_stream_for_stdout, args)

def svn_stream_from_stringbuf(*args):
    """svn_stream_from_stringbuf(svn_stringbuf_t str, apr_pool_t pool) -> svn_stream_t"""
    return apply(_core.svn_stream_from_stringbuf, args)

def svn_stream_from_string(*args):
    """svn_stream_from_string(svn_string_t str, apr_pool_t pool) -> svn_stream_t"""
    return apply(_core.svn_stream_from_string, args)

def svn_stream_compressed(*args):
    """svn_stream_compressed(svn_stream_t stream, apr_pool_t pool) -> svn_stream_t"""
    return apply(_core.svn_stream_compressed, args)

def svn_stream_checksummed2(*args):
    """
    svn_stream_checksummed2(svn_stream_t stream, svn_checksum_t read_checksum, 
        svn_checksum_t write_checksum, svn_checksum_kind_t checksum_kind, 
        svn_boolean_t read_all, 
        apr_pool_t pool) -> svn_stream_t
    """
    return apply(_core.svn_stream_checksummed2, args)

def svn_stream_read(*args):
    """svn_stream_read(svn_stream_t stream, char buffer) -> svn_error_t"""
    return apply(_core.svn_stream_read, args)

def svn_stream_write(*args):
    """svn_stream_write(svn_stream_t stream, char data) -> svn_error_t"""
    return apply(_core.svn_stream_write, args)

def svn_stream_close(*args):
    """svn_stream_close(svn_stream_t stream) -> svn_error_t"""
    return apply(_core.svn_stream_close, args)

def svn_stream_readline(*args):
    """
    svn_stream_readline(svn_stream_t stream, svn_stringbuf_t stringbuf, char eol, 
        svn_boolean_t eof, apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_stream_readline, args)

def svn_stream_copy3(*args):
    """
    svn_stream_copy3(svn_stream_t from, svn_stream_t to, svn_cancel_func_t cancel_func, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_stream_copy3, args)

def svn_stream_copy2(*args):
    """
    svn_stream_copy2(svn_stream_t from, svn_stream_t to, svn_cancel_func_t cancel_func, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_stream_copy2, args)

def svn_stream_copy(*args):
    """svn_stream_copy(svn_stream_t from, svn_stream_t to, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_stream_copy, args)

def svn_stream_contents_same(*args):
    """
    svn_stream_contents_same(svn_boolean_t same, svn_stream_t stream1, svn_stream_t stream2, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_stream_contents_same, args)

def svn_string_from_stream(*args):
    """
    svn_string_from_stream(svn_string_t result, svn_stream_t stream, apr_pool_t result_pool, 
        apr_pool_t scratch_pool) -> svn_error_t
    """
    return apply(_core.svn_string_from_stream, args)

def svn_stringbuf_from_file2(*args):
    """svn_stringbuf_from_file2(svn_stringbuf_t result, char filename, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_stringbuf_from_file2, args)

def svn_stringbuf_from_file(*args):
    """svn_stringbuf_from_file(svn_stringbuf_t result, char filename, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_stringbuf_from_file, args)

def svn_stringbuf_from_aprfile(*args):
    """svn_stringbuf_from_aprfile(svn_stringbuf_t result, apr_file_t file, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_stringbuf_from_aprfile, args)

def svn_io_remove_file(*args):
    """svn_io_remove_file(char path, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_io_remove_file, args)

def svn_io_remove_dir2(*args):
    """
    svn_io_remove_dir2(char path, svn_boolean_t ignore_enoent, svn_cancel_func_t cancel_func, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_io_remove_dir2, args)

def svn_io_remove_dir(*args):
    """svn_io_remove_dir(char path, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_io_remove_dir, args)

def svn_io_run_diff2(*args):
    """
    svn_io_run_diff2(char dir, char user_args, int num_user_args, char label1, 
        char label2, char from, char to, int exitcode, 
        apr_file_t outfile, apr_file_t errfile, 
        char diff_cmd, apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_io_run_diff2, args)

def svn_io_run_diff3_3(*args):
    """
    svn_io_run_diff3_3(int exitcode, char dir, char mine, char older, char yours, 
        char mine_label, char older_label, char yours_label, 
        apr_file_t merged, char diff3_cmd, 
        apr_array_header_t user_args, apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_io_run_diff3_3, args)

def svn_io_parse_mimetypes_file(*args):
    """svn_io_parse_mimetypes_file(apr_hash_t type_map, char mimetypes_file, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_io_parse_mimetypes_file, args)

def svn_io_detect_mimetype2(*args):
    """
    svn_io_detect_mimetype2(char mimetype, char file, apr_hash_t mimetype_map, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_io_detect_mimetype2, args)

def svn_io_detect_mimetype(*args):
    """svn_io_detect_mimetype(char mimetype, char file, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_io_detect_mimetype, args)

def svn_io_write_unique(*args):
    """
    svn_io_write_unique(char tmp_path, char dirpath, void buf, apr_size_t nbytes, 
        svn_io_file_del_t delete_when, apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_io_write_unique, args)

def svn_io_file_trunc(*args):
    """svn_io_file_trunc(apr_file_t file, apr_off_t offset, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_io_file_trunc, args)
class svn_stream_t:
    """Proxy of C svn_stream_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_stream_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_stream_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_stream_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_stream_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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


class svn_stream_tPtr(svn_stream_t):
    def __init__(self, this):
        _swig_setattr(self, svn_stream_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_stream_t, 'thisown', 0)
        _swig_setattr(self, svn_stream_t,self.__class__,svn_stream_t)
_core.svn_stream_t_swigregister(svn_stream_tPtr)


def svn_read_invoke_fn(*args):
    """svn_read_invoke_fn(svn_read_fn_t _obj, void baton, char buffer) -> svn_error_t"""
    return apply(_core.svn_read_invoke_fn, args)

def svn_write_invoke_fn(*args):
    """svn_write_invoke_fn(svn_write_fn_t _obj, void baton, char data) -> svn_error_t"""
    return apply(_core.svn_write_invoke_fn, args)

def svn_close_invoke_fn(*args):
    """svn_close_invoke_fn(svn_close_fn_t _obj, void baton) -> svn_error_t"""
    return apply(_core.svn_close_invoke_fn, args)

def svn_io_invoke_walk_func(*args):
    """
    svn_io_invoke_walk_func(svn_io_walk_func_t _obj, void baton, char path, apr_finfo_t finfo, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_io_invoke_walk_func, args)
class svn_read_fn_t:
    """Proxy of C svn_read_fn_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_read_fn_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_read_fn_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_read_fn_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_read_fn_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

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


class svn_read_fn_tPtr(svn_read_fn_t):
    def __init__(self, this):
        _swig_setattr(self, svn_read_fn_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_read_fn_t, 'thisown', 0)
        _swig_setattr(self, svn_read_fn_t,self.__class__,svn_read_fn_t)
_core.svn_read_fn_t_swigregister(svn_read_fn_tPtr)

class svn_write_fn_t:
    """Proxy of C svn_write_fn_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_write_fn_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_write_fn_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_write_fn_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_write_fn_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

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


class svn_write_fn_tPtr(svn_write_fn_t):
    def __init__(self, this):
        _swig_setattr(self, svn_write_fn_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_write_fn_t, 'thisown', 0)
        _swig_setattr(self, svn_write_fn_t,self.__class__,svn_write_fn_t)
_core.svn_write_fn_t_swigregister(svn_write_fn_tPtr)

class svn_close_fn_t:
    """Proxy of C svn_close_fn_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_close_fn_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_close_fn_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_close_fn_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_close_fn_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

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


class svn_close_fn_tPtr(svn_close_fn_t):
    def __init__(self, this):
        _swig_setattr(self, svn_close_fn_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_close_fn_t, 'thisown', 0)
        _swig_setattr(self, svn_close_fn_t,self.__class__,svn_close_fn_t)
_core.svn_close_fn_t_swigregister(svn_close_fn_tPtr)

class svn_io_walk_func_t:
    """Proxy of C svn_io_walk_func_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, svn_io_walk_func_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, svn_io_walk_func_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C svn_io_walk_func_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for svn_io_walk_func_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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

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


class svn_io_walk_func_tPtr(svn_io_walk_func_t):
    def __init__(self, this):
        _swig_setattr(self, svn_io_walk_func_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, svn_io_walk_func_t, 'thisown', 0)
        _swig_setattr(self, svn_io_walk_func_t,self.__class__,svn_io_walk_func_t)
_core.svn_io_walk_func_t_swigregister(svn_io_walk_func_tPtr)


def svn_swig_py_set_application_pool(*args):
    """svn_swig_py_set_application_pool(PyObject py_pool, apr_pool_t pool)"""
    return apply(_core.svn_swig_py_set_application_pool, args)

def svn_swig_py_clear_application_pool(*args):
    """svn_swig_py_clear_application_pool()"""
    return apply(_core.svn_swig_py_clear_application_pool, args)
class apr_array_header_t:
    """Proxy of C apr_array_header_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apr_array_header_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apr_array_header_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C apr_array_header_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for apr_array_header_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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


class apr_array_header_tPtr(apr_array_header_t):
    def __init__(self, this):
        _swig_setattr(self, apr_array_header_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, apr_array_header_t, 'thisown', 0)
        _swig_setattr(self, apr_array_header_t,self.__class__,apr_array_header_t)
_core.apr_array_header_t_swigregister(apr_array_header_tPtr)

class apr_file_t:
    """Proxy of C apr_file_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apr_file_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apr_file_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C apr_file_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for apr_file_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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


class apr_file_tPtr(apr_file_t):
    def __init__(self, this):
        _swig_setattr(self, apr_file_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, apr_file_t, 'thisown', 0)
        _swig_setattr(self, apr_file_t,self.__class__,apr_file_t)
_core.apr_file_t_swigregister(apr_file_tPtr)

class apr_hash_t:
    """Proxy of C apr_hash_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apr_hash_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apr_hash_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C apr_hash_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new proxy object for apr_hash_t"""
      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)



      members = self.__dict__.get("_members")
      if members is not None:
        old_value = members.get(name)
        if (old_value is not None and value is not None and
            value is not old_value):
          try:
            value.__dict__.update(old_value.__dict__)
          except AttributeError:
            pass


      if hasattr(value, "assert_valid"):
        value.assert_valid()

      return value

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




      self.__dict__.setdefault("_members",{})[name] = value

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


class apr_hash_tPtr(apr_hash_t):
    def __init__(self, this):
        _swig_setattr(self, apr_hash_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, apr_hash_t, 'thisown', 0)
        _swig_setattr(self, apr_hash_t,self.__class__,apr_hash_t)
_core.apr_hash_t_swigregister(apr_hash_tPtr)

import threading

application_pool = None
application_pool_lock = threading.Lock()
class GenericSWIGWrapper:
  def __init__(self, this, pool):
    """Create new Generic SWIG wrapper object"""
    import weakref
    self.this = this
    self._parent_pool = pool
    self._is_valid = weakref.ref(pool._is_valid)

  def set_parent_pool(self, pool):
    """Set the parent pool of this object"""
    self._parent_pool = pool

  def valid(self):
    """Is this object valid?"""
    return self._is_valid()

  def assert_valid(self):
    """Assert that this object is still valid"""
    assert self.valid(), "This object has already been destroyed"

  def _unwrap(self):
    """Return underlying SWIG object"""
    self.assert_valid()
    return self.this

def _mark_weakpool_invalid(weakpool):
  if weakpool and weakpool() and hasattr(weakpool(), "_is_valid"):
    del weakpool()._is_valid


class apr_pool_t:
    """Proxy of C apr_pool_t struct"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, apr_pool_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, apr_pool_t, name)
    def __init__(self): raise RuntimeError, "No constructor defined"
    def __repr__(self):
        return "<%s.%s; proxy of C apr_pool_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    def set_parent_pool(self, parent_pool=None):
      """Create a new memory pool"""
      global application_pool

      try:
        application_pool_lock.acquire()

        self._parent_pool = parent_pool or application_pool
        self._mark_valid()

        # Protect important functions from GC
        self._apr_pool_destroy = _core.apr_pool_destroy
        self._svn_swig_py_clear_application_pool = \
          _core.svn_swig_py_clear_application_pool

        # If we are an application-level pool,
        # then set this pool to be the application-level pool
        if not self._parent_pool:
          svn_swig_py_set_application_pool(self, self)
          application_pool = self
      finally:
        application_pool_lock.release()

    def valid(self):
      """Check whether this memory pool and its parents
      are still valid"""
      return hasattr(self,"_is_valid")

    def assert_valid(self):
      """Assert that this memory_pool is still valid."""
      assert self.valid(), "This pool has already been destroyed"

    def clear(self):
      """Clear embedded memory pool. Invalidate all subpools."""
      pool = self._parent_pool
      apr_pool_clear(self)
      self.set_parent_pool(pool)

    def destroy(self):
      """Destroy embedded memory pool. If you do not destroy
      the memory pool manually, Python will destroy it
      automatically."""
      global application_pool

      self.assert_valid()

      is_application_pool = not self._parent_pool

      # Destroy pool
      self._apr_pool_destroy(self)

      # Clear application pool if necessary
      if is_application_pool:
        application_pool = None
        self._svn_swig_py_clear_application_pool()

      # Mark self as invalid
      if hasattr(self, "_parent_pool"):
        del self._parent_pool
      if hasattr(self, "_is_valid"):
        del self._is_valid

    def __del__(self):
      """Automatically destroy memory pools, if necessary"""
      if self.valid():
        self.destroy()

    def _mark_valid(self):
      """Mark pool as valid"""

      self._weakparent = None

      if self._parent_pool:
        import weakref

        # Make sure that the parent object is valid
        self._parent_pool.assert_valid()

        # Refer to self using a weakrefrence so that we don't
        # create a reference cycle
        weakself = weakref.ref(self)

        # Set up callbacks to mark pool as invalid when parents
        # are destroyed
        self._weakparent = weakref.ref(self._parent_pool._is_valid,
          lambda x: _mark_weakpool_invalid(weakself))

      # Mark pool as valid
      self._is_valid = lambda: 1

    def _wrap(self, obj):
      """Mark a SWIG object as owned by this pool"""
      self.assert_valid()
      if hasattr(obj, "set_parent_pool"):
        obj.set_parent_pool(self)
        return obj
      elif obj is None:
        return None
      else:
        return GenericSWIGWrapper(obj, self)



class apr_pool_tPtr(apr_pool_t):
    def __init__(self, this):
        _swig_setattr(self, apr_pool_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, apr_pool_t, 'thisown', 0)
        _swig_setattr(self, apr_pool_t,self.__class__,apr_pool_t)
_core.apr_pool_t_swigregister(apr_pool_tPtr)

# Initialize a global pool
svn_pool_create()


def svn_swig_mergeinfo_merge(*args):
    """svn_swig_mergeinfo_merge(apr_hash_t mergeinfo_inout, apr_hash_t changes, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_swig_mergeinfo_merge, args)

def svn_swig_mergeinfo_sort(*args):
    """svn_swig_mergeinfo_sort(apr_hash_t mergeinfo_inout, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_swig_mergeinfo_sort, args)

def svn_swig_rangelist_merge(*args):
    """
    svn_swig_rangelist_merge(apr_array_header_t rangelist_inout, apr_array_header_t changes, 
        apr_pool_t pool) -> svn_error_t
    """
    return apply(_core.svn_swig_rangelist_merge, args)

def svn_swig_rangelist_reverse(*args):
    """svn_swig_rangelist_reverse(apr_array_header_t rangelist_inout, apr_pool_t pool) -> svn_error_t"""
    return apply(_core.svn_swig_rangelist_reverse, args)

