# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.4.1
#
# Do not make changes to this file unless you know what you are doing - modify
# the SWIG interface file instead.

from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if getattr(globals().get("__spec__"), "parent", None) or __package__ or "." in __name__:
    from . import _pisock
else:
    import _pisock

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)



from pisockextras import *


error = _pisock.error 

PI_ERR_PROT_ABORTED = _pisock.PI_ERR_PROT_ABORTED
PI_ERR_PROT_INCOMPATIBLE = _pisock.PI_ERR_PROT_INCOMPATIBLE
PI_ERR_PROT_BADPACKET = _pisock.PI_ERR_PROT_BADPACKET
PI_ERR_SOCK_DISCONNECTED = _pisock.PI_ERR_SOCK_DISCONNECTED
PI_ERR_SOCK_INVALID = _pisock.PI_ERR_SOCK_INVALID
PI_ERR_SOCK_TIMEOUT = _pisock.PI_ERR_SOCK_TIMEOUT
PI_ERR_SOCK_CANCELED = _pisock.PI_ERR_SOCK_CANCELED
PI_ERR_SOCK_IO = _pisock.PI_ERR_SOCK_IO
PI_ERR_SOCK_LISTENER = _pisock.PI_ERR_SOCK_LISTENER
PI_ERR_DLP_BUFSIZE = _pisock.PI_ERR_DLP_BUFSIZE
PI_ERR_DLP_PALMOS = _pisock.PI_ERR_DLP_PALMOS
PI_ERR_DLP_UNSUPPORTED = _pisock.PI_ERR_DLP_UNSUPPORTED
PI_ERR_DLP_SOCKET = _pisock.PI_ERR_DLP_SOCKET
PI_ERR_DLP_DATASIZE = _pisock.PI_ERR_DLP_DATASIZE
PI_ERR_DLP_COMMAND = _pisock.PI_ERR_DLP_COMMAND
PI_ERR_FILE_INVALID = _pisock.PI_ERR_FILE_INVALID
PI_ERR_FILE_ERROR = _pisock.PI_ERR_FILE_ERROR
PI_ERR_FILE_ABORTED = _pisock.PI_ERR_FILE_ABORTED
PI_ERR_FILE_NOT_FOUND = _pisock.PI_ERR_FILE_NOT_FOUND
PI_ERR_FILE_ALREADY_EXISTS = _pisock.PI_ERR_FILE_ALREADY_EXISTS
PI_ERR_GENERIC_MEMORY = _pisock.PI_ERR_GENERIC_MEMORY
PI_ERR_GENERIC_ARGUMENT = _pisock.PI_ERR_GENERIC_ARGUMENT
PI_ERR_GENERIC_SYSTEM = _pisock.PI_ERR_GENERIC_SYSTEM
PI_AF_PILOT = _pisock.PI_AF_PILOT
PI_SOCK_STREAM = _pisock.PI_SOCK_STREAM
PI_SOCK_RAW = _pisock.PI_SOCK_RAW
PI_CMD_CMP = _pisock.PI_CMD_CMP
PI_CMD_NET = _pisock.PI_CMD_NET
PI_CMD_SYS = _pisock.PI_CMD_SYS
PI_MSG_PEEK = _pisock.PI_MSG_PEEK
PI_PF_DEV = _pisock.PI_PF_DEV
PI_PF_SLP = _pisock.PI_PF_SLP
PI_PF_SYS = _pisock.PI_PF_SYS
PI_PF_PADP = _pisock.PI_PF_PADP
PI_PF_NET = _pisock.PI_PF_NET
PI_PF_DLP = _pisock.PI_PF_DLP
PI_LEVEL_DEV = _pisock.PI_LEVEL_DEV
PI_LEVEL_SLP = _pisock.PI_LEVEL_SLP
PI_LEVEL_PADP = _pisock.PI_LEVEL_PADP
PI_LEVEL_NET = _pisock.PI_LEVEL_NET
PI_LEVEL_SYS = _pisock.PI_LEVEL_SYS
PI_LEVEL_CMP = _pisock.PI_LEVEL_CMP
PI_LEVEL_DLP = _pisock.PI_LEVEL_DLP
PI_LEVEL_SOCK = _pisock.PI_LEVEL_SOCK
PI_DEV_RATE = _pisock.PI_DEV_RATE
PI_DEV_ESTRATE = _pisock.PI_DEV_ESTRATE
PI_DEV_HIGHRATE = _pisock.PI_DEV_HIGHRATE
PI_DEV_TIMEOUT = _pisock.PI_DEV_TIMEOUT
PI_SLP_DEST = _pisock.PI_SLP_DEST
PI_SLP_LASTDEST = _pisock.PI_SLP_LASTDEST
PI_SLP_SRC = _pisock.PI_SLP_SRC
PI_SLP_LASTSRC = _pisock.PI_SLP_LASTSRC
PI_SLP_TYPE = _pisock.PI_SLP_TYPE
PI_SLP_LASTTYPE = _pisock.PI_SLP_LASTTYPE
PI_SLP_TXID = _pisock.PI_SLP_TXID
PI_SLP_LASTTXID = _pisock.PI_SLP_LASTTXID
PI_PADP_TYPE = _pisock.PI_PADP_TYPE
PI_PADP_LASTTYPE = _pisock.PI_PADP_LASTTYPE
PI_PADP_FREEZE_TXID = _pisock.PI_PADP_FREEZE_TXID
PI_PADP_USE_LONG_FORMAT = _pisock.PI_PADP_USE_LONG_FORMAT
PI_CMP_TYPE = _pisock.PI_CMP_TYPE
PI_CMP_FLAGS = _pisock.PI_CMP_FLAGS
PI_CMP_VERS = _pisock.PI_CMP_VERS
PI_CMP_BAUD = _pisock.PI_CMP_BAUD
PI_NET_TYPE = _pisock.PI_NET_TYPE
PI_NET_SPLIT_WRITES = _pisock.PI_NET_SPLIT_WRITES
PI_NET_WRITE_CHUNKSIZE = _pisock.PI_NET_WRITE_CHUNKSIZE
PI_SOCK_STATE = _pisock.PI_SOCK_STATE
PI_SOCK_HONOR_RX_TIMEOUT = _pisock.PI_SOCK_HONOR_RX_TIMEOUT
class pi_socket_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    sd = property(_pisock.pi_socket_t_sd_get, _pisock.pi_socket_t_sd_set)
    type = property(_pisock.pi_socket_t_type_get, _pisock.pi_socket_t_type_set)
    protocol = property(_pisock.pi_socket_t_protocol_get, _pisock.pi_socket_t_protocol_set)
    cmd = property(_pisock.pi_socket_t_cmd_get, _pisock.pi_socket_t_cmd_set)
    laddr = property(_pisock.pi_socket_t_laddr_get, _pisock.pi_socket_t_laddr_set)
    laddrlen = property(_pisock.pi_socket_t_laddrlen_get, _pisock.pi_socket_t_laddrlen_set)
    raddr = property(_pisock.pi_socket_t_raddr_get, _pisock.pi_socket_t_raddr_set)
    raddrlen = property(_pisock.pi_socket_t_raddrlen_get, _pisock.pi_socket_t_raddrlen_set)
    protocol_queue = property(_pisock.pi_socket_t_protocol_queue_get, _pisock.pi_socket_t_protocol_queue_set)
    queue_len = property(_pisock.pi_socket_t_queue_len_get, _pisock.pi_socket_t_queue_len_set)
    cmd_queue = property(_pisock.pi_socket_t_cmd_queue_get, _pisock.pi_socket_t_cmd_queue_set)
    cmd_len = property(_pisock.pi_socket_t_cmd_len_get, _pisock.pi_socket_t_cmd_len_set)
    device = property(_pisock.pi_socket_t_device_get, _pisock.pi_socket_t_device_set)
    state = property(_pisock.pi_socket_t_state_get, _pisock.pi_socket_t_state_set)
    honor_rx_to = property(_pisock.pi_socket_t_honor_rx_to_get, _pisock.pi_socket_t_honor_rx_to_set)
    command = property(_pisock.pi_socket_t_command_get, _pisock.pi_socket_t_command_set)
    accept_to = property(_pisock.pi_socket_t_accept_to_get, _pisock.pi_socket_t_accept_to_set)
    dlprecord = property(_pisock.pi_socket_t_dlprecord_get, _pisock.pi_socket_t_dlprecord_set)
    dlpversion = property(_pisock.pi_socket_t_dlpversion_get, _pisock.pi_socket_t_dlpversion_set)
    maxrecsize = property(_pisock.pi_socket_t_maxrecsize_get, _pisock.pi_socket_t_maxrecsize_set)
    last_error = property(_pisock.pi_socket_t_last_error_get, _pisock.pi_socket_t_last_error_set)
    palmos_error = property(_pisock.pi_socket_t_palmos_error_get, _pisock.pi_socket_t_palmos_error_set)

    def __init__(self):
        _pisock.pi_socket_t_swiginit(self, _pisock.new_pi_socket_t())
    __swig_destroy__ = _pisock.delete_pi_socket_t

# Register pi_socket_t in _pisock:
_pisock.pi_socket_t_swigregister(pi_socket_t)
dlp_ReadRecordIDList = _pisock.dlp_ReadRecordIDList
pi_file_install = _pisock.pi_file_install
pi_file_retrieve = _pisock.pi_file_retrieve

class pi_socket_list_t(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    ps = property(_pisock.pi_socket_list_t_ps_get, _pisock.pi_socket_list_t_ps_set)
    next = property(_pisock.pi_socket_list_t_next_get, _pisock.pi_socket_list_t_next_set)

    def __init__(self):
        _pisock.pi_socket_list_t_swiginit(self, _pisock.new_pi_socket_list_t())
    __swig_destroy__ = _pisock.delete_pi_socket_list_t

# Register pi_socket_list_t in _pisock:
_pisock.pi_socket_list_t_swigregister(pi_socket_list_t)

def pi_socket(domain, type, protocol):
    return _pisock.pi_socket(domain, type, protocol)

def pi_socket_setsd(ps, pi_sd):
    return _pisock.pi_socket_setsd(ps, pi_sd)

def pi_getsockname(pi_sd):
    return _pisock.pi_getsockname(pi_sd)

def pi_getsockpeer(pi_sd):
    return _pisock.pi_getsockpeer(pi_sd)

def pi_getsockopt(pi_sd, level, option_name, option_value, option_len):
    return _pisock.pi_getsockopt(pi_sd, level, option_name, option_value, option_len)

def pi_setsockopt(pi_sd, level, option_name, option_value, option_len):
    return _pisock.pi_setsockopt(pi_sd, level, option_name, option_value, option_len)

def pi_protocol(pi_sd, level):
    return _pisock.pi_protocol(pi_sd, level)

def pi_protocol_next(pi_sd, level):
    return _pisock.pi_protocol_next(pi_sd, level)

def pi_socket_connected(pi_sd):
    return _pisock.pi_socket_connected(pi_sd)

def pi_connect(pi_sd, port):
    return _pisock.pi_connect(pi_sd, port)

def pi_bind(pi_sd, port):
    return _pisock.pi_bind(pi_sd, port)

def pi_listen(pi_sd, backlog):
    return _pisock.pi_listen(pi_sd, backlog)

def pi_accept(pi_sd):
    return _pisock.pi_accept(pi_sd)

def pi_accept_to(pi_sd, timeout):
    return _pisock.pi_accept_to(pi_sd, timeout)

def pi_close(pi_sd):
    return _pisock.pi_close(pi_sd)

def pi_send(pi_sd, msg, len, flags):
    return _pisock.pi_send(pi_sd, msg, len, flags)

def pi_recv(pi_sd, len, flags):
    return _pisock.pi_recv(pi_sd, len, flags)

def pi_read(pi_sd, len):
    return _pisock.pi_read(pi_sd, len)

def pi_write(pi_sd, databuf):
    return _pisock.pi_write(pi_sd, databuf)

def pi_flush(pi_sd, flags):
    return _pisock.pi_flush(pi_sd, flags)

def pi_error(pi_sd):
    return _pisock.pi_error(pi_sd)

def pi_set_error(pi_sd, error_code):
    return _pisock.pi_set_error(pi_sd, error_code)

def pi_palmos_error(pi_sd):
    return _pisock.pi_palmos_error(pi_sd)

def pi_set_palmos_error(pi_sd, error_code):
    return _pisock.pi_set_palmos_error(pi_sd, error_code)

def pi_reset_errors(sd):
    return _pisock.pi_reset_errors(sd)

def pi_version(pi_sd):
    return _pisock.pi_version(pi_sd)

def pi_maxrecsize(pi_sd):
    return _pisock.pi_maxrecsize(pi_sd)

def pi_tickle(pi_sd):
    return _pisock.pi_tickle(pi_sd)

def pi_watchdog(pi_sd, interval):
    return _pisock.pi_watchdog(pi_sd, interval)
PI_DLP_VERSION_MAJOR = _pisock.PI_DLP_VERSION_MAJOR
PI_DLP_VERSION_MINOR = _pisock.PI_DLP_VERSION_MINOR
vfsMountFlagsUseThisFileSystem = _pisock.vfsMountFlagsUseThisFileSystem
vfsMAXFILENAME = _pisock.vfsMAXFILENAME
vfsInvalidVolRef = _pisock.vfsInvalidVolRef
vfsInvalidFileRef = _pisock.vfsInvalidFileRef
class VFSDirInfo(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    attr = property(_pisock.VFSDirInfo_attr_get, _pisock.VFSDirInfo_attr_set)
    name = property(_pisock.VFSDirInfo_name_get, _pisock.VFSDirInfo_name_set)

    def __init__(self):
        _pisock.VFSDirInfo_swiginit(self, _pisock.new_VFSDirInfo())
    __swig_destroy__ = _pisock.delete_VFSDirInfo

# Register VFSDirInfo in _pisock:
_pisock.VFSDirInfo_swigregister(VFSDirInfo)
class VFSAnyMountParam(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    volRefNum = property(_pisock.VFSAnyMountParam_volRefNum_get, _pisock.VFSAnyMountParam_volRefNum_set)
    reserved = property(_pisock.VFSAnyMountParam_reserved_get, _pisock.VFSAnyMountParam_reserved_set)
    mountClass = property(_pisock.VFSAnyMountParam_mountClass_get, _pisock.VFSAnyMountParam_mountClass_set)

    def __init__(self):
        _pisock.VFSAnyMountParam_swiginit(self, _pisock.new_VFSAnyMountParam())
    __swig_destroy__ = _pisock.delete_VFSAnyMountParam

# Register VFSAnyMountParam in _pisock:
_pisock.VFSAnyMountParam_swigregister(VFSAnyMountParam)
class VFSSlotMountParam(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    vfsMountParam = property(_pisock.VFSSlotMountParam_vfsMountParam_get, _pisock.VFSSlotMountParam_vfsMountParam_set)
    slotLibRefNum = property(_pisock.VFSSlotMountParam_slotLibRefNum_get, _pisock.VFSSlotMountParam_slotLibRefNum_set)
    slotRefNum = property(_pisock.VFSSlotMountParam_slotRefNum_get, _pisock.VFSSlotMountParam_slotRefNum_set)

    def __init__(self):
        _pisock.VFSSlotMountParam_swiginit(self, _pisock.new_VFSSlotMountParam())
    __swig_destroy__ = _pisock.delete_VFSSlotMountParam

# Register VFSSlotMountParam in _pisock:
_pisock.VFSSlotMountParam_swigregister(VFSSlotMountParam)
class VFSInfo(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    attributes = property(_pisock.VFSInfo_attributes_get, _pisock.VFSInfo_attributes_set)
    fsType = property(_pisock.VFSInfo_fsType_get, _pisock.VFSInfo_fsType_set)
    fsCreator = property(_pisock.VFSInfo_fsCreator_get, _pisock.VFSInfo_fsCreator_set)
    mountClass = property(_pisock.VFSInfo_mountClass_get, _pisock.VFSInfo_mountClass_set)
    slotLibRefNum = property(_pisock.VFSInfo_slotLibRefNum_get, _pisock.VFSInfo_slotLibRefNum_set)
    slotRefNum = property(_pisock.VFSInfo_slotRefNum_get, _pisock.VFSInfo_slotRefNum_set)
    mediaType = property(_pisock.VFSInfo_mediaType_get, _pisock.VFSInfo_mediaType_set)
    reserved = property(_pisock.VFSInfo_reserved_get, _pisock.VFSInfo_reserved_set)

    def __init__(self):
        _pisock.VFSInfo_swiginit(self, _pisock.new_VFSInfo())
    __swig_destroy__ = _pisock.delete_VFSInfo

# Register VFSInfo in _pisock:
_pisock.VFSInfo_swigregister(VFSInfo)
class PilotUser(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    passwordLength = property(_pisock.PilotUser_passwordLength_get, _pisock.PilotUser_passwordLength_set)
    username = property(_pisock.PilotUser_username_get, _pisock.PilotUser_username_set)
    password = property(_pisock.PilotUser_password_get, _pisock.PilotUser_password_set)
    userID = property(_pisock.PilotUser_userID_get, _pisock.PilotUser_userID_set)
    viewerID = property(_pisock.PilotUser_viewerID_get, _pisock.PilotUser_viewerID_set)
    lastSyncPC = property(_pisock.PilotUser_lastSyncPC_get, _pisock.PilotUser_lastSyncPC_set)
    successfulSyncDate = property(_pisock.PilotUser_successfulSyncDate_get, _pisock.PilotUser_successfulSyncDate_set)
    lastSyncDate = property(_pisock.PilotUser_lastSyncDate_get, _pisock.PilotUser_lastSyncDate_set)

    def __init__(self):
        _pisock.PilotUser_swiginit(self, _pisock.new_PilotUser())
    __swig_destroy__ = _pisock.delete_PilotUser

# Register PilotUser in _pisock:
_pisock.PilotUser_swigregister(PilotUser)
class SysInfo(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    romVersion = property(_pisock.SysInfo_romVersion_get, _pisock.SysInfo_romVersion_set)
    locale = property(_pisock.SysInfo_locale_get, _pisock.SysInfo_locale_set)
    prodIDLength = property(_pisock.SysInfo_prodIDLength_get, _pisock.SysInfo_prodIDLength_set)
    prodID = property(_pisock.SysInfo_prodID_get, _pisock.SysInfo_prodID_set)
    dlpMajorVersion = property(_pisock.SysInfo_dlpMajorVersion_get, _pisock.SysInfo_dlpMajorVersion_set)
    dlpMinorVersion = property(_pisock.SysInfo_dlpMinorVersion_get, _pisock.SysInfo_dlpMinorVersion_set)
    compatMajorVersion = property(_pisock.SysInfo_compatMajorVersion_get, _pisock.SysInfo_compatMajorVersion_set)
    compatMinorVersion = property(_pisock.SysInfo_compatMinorVersion_get, _pisock.SysInfo_compatMinorVersion_set)
    maxRecSize = property(_pisock.SysInfo_maxRecSize_get, _pisock.SysInfo_maxRecSize_set)

    def __init__(self):
        _pisock.SysInfo_swiginit(self, _pisock.new_SysInfo())
    __swig_destroy__ = _pisock.delete_SysInfo

# Register SysInfo in _pisock:
_pisock.SysInfo_swigregister(SysInfo)
class DBInfo(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    more = property(_pisock.DBInfo_more_get, _pisock.DBInfo_more_set)
    name = property(_pisock.DBInfo_name_get, _pisock.DBInfo_name_set)
    flags = property(_pisock.DBInfo_flags_get, _pisock.DBInfo_flags_set)
    miscFlags = property(_pisock.DBInfo_miscFlags_get, _pisock.DBInfo_miscFlags_set)
    version = property(_pisock.DBInfo_version_get, _pisock.DBInfo_version_set)
    type = property(_pisock.DBInfo_type_get, _pisock.DBInfo_type_set)
    creator = property(_pisock.DBInfo_creator_get, _pisock.DBInfo_creator_set)
    modnum = property(_pisock.DBInfo_modnum_get, _pisock.DBInfo_modnum_set)
    index = property(_pisock.DBInfo_index_get, _pisock.DBInfo_index_set)
    createDate = property(_pisock.DBInfo_createDate_get, _pisock.DBInfo_createDate_set)
    modifyDate = property(_pisock.DBInfo_modifyDate_get, _pisock.DBInfo_modifyDate_set)
    backupDate = property(_pisock.DBInfo_backupDate_get, _pisock.DBInfo_backupDate_set)

    def __init__(self):
        _pisock.DBInfo_swiginit(self, _pisock.new_DBInfo())
    __swig_destroy__ = _pisock.delete_DBInfo

# Register DBInfo in _pisock:
_pisock.DBInfo_swigregister(DBInfo)
class DBSizeInfo(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    numRecords = property(_pisock.DBSizeInfo_numRecords_get, _pisock.DBSizeInfo_numRecords_set)
    totalBytes = property(_pisock.DBSizeInfo_totalBytes_get, _pisock.DBSizeInfo_totalBytes_set)
    dataBytes = property(_pisock.DBSizeInfo_dataBytes_get, _pisock.DBSizeInfo_dataBytes_set)
    appBlockSize = property(_pisock.DBSizeInfo_appBlockSize_get, _pisock.DBSizeInfo_appBlockSize_set)
    sortBlockSize = property(_pisock.DBSizeInfo_sortBlockSize_get, _pisock.DBSizeInfo_sortBlockSize_set)
    maxRecSize = property(_pisock.DBSizeInfo_maxRecSize_get, _pisock.DBSizeInfo_maxRecSize_set)

    def __init__(self):
        _pisock.DBSizeInfo_swiginit(self, _pisock.new_DBSizeInfo())
    __swig_destroy__ = _pisock.delete_DBSizeInfo

# Register DBSizeInfo in _pisock:
_pisock.DBSizeInfo_swigregister(DBSizeInfo)
class CardInfo(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    card = property(_pisock.CardInfo_card_get, _pisock.CardInfo_card_set)
    version = property(_pisock.CardInfo_version_get, _pisock.CardInfo_version_set)
    more = property(_pisock.CardInfo_more_get, _pisock.CardInfo_more_set)
    creation = property(_pisock.CardInfo_creation_get, _pisock.CardInfo_creation_set)
    romSize = property(_pisock.CardInfo_romSize_get, _pisock.CardInfo_romSize_set)
    ramSize = property(_pisock.CardInfo_ramSize_get, _pisock.CardInfo_ramSize_set)
    ramFree = property(_pisock.CardInfo_ramFree_get, _pisock.CardInfo_ramFree_set)
    name = property(_pisock.CardInfo_name_get, _pisock.CardInfo_name_set)
    manufacturer = property(_pisock.CardInfo_manufacturer_get, _pisock.CardInfo_manufacturer_set)

    def __init__(self):
        _pisock.CardInfo_swiginit(self, _pisock.new_CardInfo())
    __swig_destroy__ = _pisock.delete_CardInfo

# Register CardInfo in _pisock:
_pisock.CardInfo_swigregister(CardInfo)
class NetSyncInfo(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    lanSync = property(_pisock.NetSyncInfo_lanSync_get, _pisock.NetSyncInfo_lanSync_set)
    hostName = property(_pisock.NetSyncInfo_hostName_get, _pisock.NetSyncInfo_hostName_set)
    hostAddress = property(_pisock.NetSyncInfo_hostAddress_get, _pisock.NetSyncInfo_hostAddress_set)
    hostSubnetMask = property(_pisock.NetSyncInfo_hostSubnetMask_get, _pisock.NetSyncInfo_hostSubnetMask_set)

    def __init__(self):
        _pisock.NetSyncInfo_swiginit(self, _pisock.new_NetSyncInfo())
    __swig_destroy__ = _pisock.delete_NetSyncInfo

# Register NetSyncInfo in _pisock:
_pisock.NetSyncInfo_swigregister(NetSyncInfo)
dlpDBFlagResource = _pisock.dlpDBFlagResource
dlpDBFlagReadOnly = _pisock.dlpDBFlagReadOnly
dlpDBFlagAppInfoDirty = _pisock.dlpDBFlagAppInfoDirty
dlpDBFlagBackup = _pisock.dlpDBFlagBackup
dlpDBFlagHidden = _pisock.dlpDBFlagHidden
dlpDBFlagLaunchable = _pisock.dlpDBFlagLaunchable
dlpDBFlagRecyclable = _pisock.dlpDBFlagRecyclable
dlpDBFlagBundle = _pisock.dlpDBFlagBundle
dlpDBFlagOpen = _pisock.dlpDBFlagOpen
dlpDBFlagNewer = _pisock.dlpDBFlagNewer
dlpDBFlagReset = _pisock.dlpDBFlagReset
dlpDBFlagCopyPrevention = _pisock.dlpDBFlagCopyPrevention
dlpDBFlagStream = _pisock.dlpDBFlagStream
dlpDBFlagSchema = _pisock.dlpDBFlagSchema
dlpDBFlagSecure = _pisock.dlpDBFlagSecure
dlpDBFlagExtended = _pisock.dlpDBFlagExtended
dlpDBFlagFixedUp = _pisock.dlpDBFlagFixedUp
dlpDBMiscFlagExcludeFromSync = _pisock.dlpDBMiscFlagExcludeFromSync
dlpDBMiscFlagRamBased = _pisock.dlpDBMiscFlagRamBased
dlpRecAttrDeleted = _pisock.dlpRecAttrDeleted
dlpRecAttrDirty = _pisock.dlpRecAttrDirty
dlpRecAttrBusy = _pisock.dlpRecAttrBusy
dlpRecAttrSecret = _pisock.dlpRecAttrSecret
dlpRecAttrArchived = _pisock.dlpRecAttrArchived
dlpOpenRead = _pisock.dlpOpenRead
dlpOpenWrite = _pisock.dlpOpenWrite
dlpOpenExclusive = _pisock.dlpOpenExclusive
dlpOpenSecret = _pisock.dlpOpenSecret
dlpOpenReadWrite = _pisock.dlpOpenReadWrite
dlpDBListRAM = _pisock.dlpDBListRAM
dlpDBListROM = _pisock.dlpDBListROM
dlpDBListMultiple = _pisock.dlpDBListMultiple
dlpFindDBOptFlagGetAttributes = _pisock.dlpFindDBOptFlagGetAttributes
dlpFindDBOptFlagGetSize = _pisock.dlpFindDBOptFlagGetSize
dlpFindDBOptFlagMaxRecSize = _pisock.dlpFindDBOptFlagMaxRecSize
dlpFindDBSrchFlagNewSearch = _pisock.dlpFindDBSrchFlagNewSearch
dlpFindDBSrchFlagOnlyLatest = _pisock.dlpFindDBSrchFlagOnlyLatest
dlpEndCodeNormal = _pisock.dlpEndCodeNormal
dlpEndCodeOutOfMemory = _pisock.dlpEndCodeOutOfMemory
dlpEndCodeUserCan = _pisock.dlpEndCodeUserCan
dlpEndCodeOther = _pisock.dlpEndCodeOther
dlpExpCapabilityHasStorage = _pisock.dlpExpCapabilityHasStorage
dlpExpCapabilityReadOnly = _pisock.dlpExpCapabilityReadOnly
dlpExpCapabilitySerial = _pisock.dlpExpCapabilitySerial
vfsVolAttrSlotBased = _pisock.vfsVolAttrSlotBased
vfsVolAttrReadOnly = _pisock.vfsVolAttrReadOnly
vfsVolAttrHidden = _pisock.vfsVolAttrHidden
vfsOriginBeginning = _pisock.vfsOriginBeginning
vfsOriginCurrent = _pisock.vfsOriginCurrent
vfsOriginEnd = _pisock.vfsOriginEnd
dlpVFSOpenExclusive = _pisock.dlpVFSOpenExclusive
dlpVFSOpenRead = _pisock.dlpVFSOpenRead
dlpVFSOpenWrite = _pisock.dlpVFSOpenWrite
dlpVFSOpenReadWrite = _pisock.dlpVFSOpenReadWrite
vfsModeExclusive = _pisock.vfsModeExclusive
vfsModeRead = _pisock.vfsModeRead
vfsModeWrite = _pisock.vfsModeWrite
vfsModeReadWrite = _pisock.vfsModeReadWrite
vfsModeCreate = _pisock.vfsModeCreate
vfsModeTruncate = _pisock.vfsModeTruncate
vfsModeLeaveOpen = _pisock.vfsModeLeaveOpen
vfsFileAttrReadOnly = _pisock.vfsFileAttrReadOnly
vfsFileAttrHidden = _pisock.vfsFileAttrHidden
vfsFileAttrSystem = _pisock.vfsFileAttrSystem
vfsFileAttrVolumeLabel = _pisock.vfsFileAttrVolumeLabel
vfsFileAttrDirectory = _pisock.vfsFileAttrDirectory
vfsFileAttrArchive = _pisock.vfsFileAttrArchive
vfsFileAttrLink = _pisock.vfsFileAttrLink
vfsFileDateCreated = _pisock.vfsFileDateCreated
vfsFileDateModified = _pisock.vfsFileDateModified
vfsFileDateAccessed = _pisock.vfsFileDateAccessed
vfsIteratorStart = _pisock.vfsIteratorStart
vfsIteratorStop = _pisock.vfsIteratorStop
dlpErrNoError = _pisock.dlpErrNoError
dlpErrSystem = _pisock.dlpErrSystem
dlpErrIllegalReq = _pisock.dlpErrIllegalReq
dlpErrMemory = _pisock.dlpErrMemory
dlpErrParam = _pisock.dlpErrParam
dlpErrNotFound = _pisock.dlpErrNotFound
dlpErrNoneOpen = _pisock.dlpErrNoneOpen
dlpErrAlreadyOpen = _pisock.dlpErrAlreadyOpen
dlpErrTooManyOpen = _pisock.dlpErrTooManyOpen
dlpErrExists = _pisock.dlpErrExists
dlpErrOpen = _pisock.dlpErrOpen
dlpErrDeleted = _pisock.dlpErrDeleted
dlpErrBusy = _pisock.dlpErrBusy
dlpErrNotSupp = _pisock.dlpErrNotSupp
dlpErrUnused1 = _pisock.dlpErrUnused1
dlpErrReadOnly = _pisock.dlpErrReadOnly
dlpErrSpace = _pisock.dlpErrSpace
dlpErrLimit = _pisock.dlpErrLimit
dlpErrSync = _pisock.dlpErrSync
dlpErrWrapper = _pisock.dlpErrWrapper
dlpErrArgument = _pisock.dlpErrArgument
dlpErrSize = _pisock.dlpErrSize
dlpErrUnknown = _pisock.dlpErrUnknown

def dlp_set_protocol_version(major, minor):
    return _pisock.dlp_set_protocol_version(major, minor)

def dlp_ptohdate(timeDateData):
    return _pisock.dlp_ptohdate(timeDateData)

def dlp_htopdate(palm_time, timeDateData):
    return _pisock.dlp_htopdate(palm_time, timeDateData)

def dlp_GetSysDateTime_(sd, palm_time):
    return _pisock.dlp_GetSysDateTime_(sd, palm_time)

def dlp_SetSysDateTime(sd, palm_time):
    return _pisock.dlp_SetSysDateTime(sd, palm_time)

def dlp_ReadSysInfo(sd):
    return _pisock.dlp_ReadSysInfo(sd)

def dlp_ReadStorageInfo(sd, cardno):
    return _pisock.dlp_ReadStorageInfo(sd, cardno)

def dlp_ReadUserInfo(sd):
    return _pisock.dlp_ReadUserInfo(sd)

def dlp_WriteUserInfo(sd, INPUT):
    return _pisock.dlp_WriteUserInfo(sd, INPUT)

def dlp_ResetLastSyncPC(sd):
    return _pisock.dlp_ResetLastSyncPC(sd)

def dlp_ReadNetSyncInfo(sd):
    return _pisock.dlp_ReadNetSyncInfo(sd)

def dlp_WriteNetSyncInfo(sd, INPUT):
    return _pisock.dlp_WriteNetSyncInfo(sd, INPUT)

def dlp_OpenConduit(sd):
    return _pisock.dlp_OpenConduit(sd)

def dlp_EndOfSync(sd, status):
    return _pisock.dlp_EndOfSync(sd, status)

def dlp_AbortSync(sd):
    return _pisock.dlp_AbortSync(sd)

def dlp_ReadFeature(sd, creator, num):
    return _pisock.dlp_ReadFeature(sd, creator, num)

def dlp_GetROMToken(sd, token, databuf, datasize):
    return _pisock.dlp_GetROMToken(sd, token, databuf, datasize)

def dlp_AddSyncLogEntry(sd, string):
    return _pisock.dlp_AddSyncLogEntry(sd, string)

def dlp_CallApplication(sd, creator, type, action, datasize):
    return _pisock.dlp_CallApplication(sd, creator, type, action, datasize)

def dlp_ReadAppPreference(sd, creator, prefid, backup, maxsize, databuf, datasize, version):
    return _pisock.dlp_ReadAppPreference(sd, creator, prefid, backup, maxsize, databuf, datasize, version)

def dlp_WriteAppPreference(sd, creator, prefid, backup, version, databuf):
    return _pisock.dlp_WriteAppPreference(sd, creator, prefid, backup, version, databuf)

def dlp_ResetSystem(sd):
    return _pisock.dlp_ResetSystem(sd)

def dlp_ReadDBList_(sd, cardno, flags, start):
    return _pisock.dlp_ReadDBList_(sd, cardno, flags, start)

def dlp_FindDBByName(sd, cardno, dbname):
    return _pisock.dlp_FindDBByName(sd, cardno, dbname)

def dlp_FindDBByOpenHandle(sd, dbhandle):
    return _pisock.dlp_FindDBByOpenHandle(sd, dbhandle)

def dlp_FindDBByTypeCreator(sd, type, creator, start, latest):
    return _pisock.dlp_FindDBByTypeCreator(sd, type, creator, start, latest)

def dlp_FindDBInfo(sd, cardno, start, dbname, type, creator):
    return _pisock.dlp_FindDBInfo(sd, cardno, start, dbname, type, creator)

def dlp_OpenDB(sd, cardno, mode, dbname):
    return _pisock.dlp_OpenDB(sd, cardno, mode, dbname)

def dlp_CloseDB(sd, dbhandle):
    return _pisock.dlp_CloseDB(sd, dbhandle)

def dlp_CloseDB_All(sd):
    return _pisock.dlp_CloseDB_All(sd)

def dlp_DeleteDB(sd, cardno, dbname):
    return _pisock.dlp_DeleteDB(sd, cardno, dbname)

def dlp_CreateDB(sd, creator, type, cardno, flags, version, dbname):
    return _pisock.dlp_CreateDB(sd, creator, type, cardno, flags, version, dbname)

def dlp_ReadOpenDBInfo(sd, dbhandle):
    return _pisock.dlp_ReadOpenDBInfo(sd, dbhandle)

def dlp_SetDBInfo(sd, dbhandle, flags, clearFlags, version, createDate, modifyDate, backupDate, type, creator):
    return _pisock.dlp_SetDBInfo(sd, dbhandle, flags, clearFlags, version, createDate, modifyDate, backupDate, type, creator)

def dlp_DeleteCategory(sd, dbhandle, category):
    return _pisock.dlp_DeleteCategory(sd, dbhandle, category)

def dlp_MoveCategory(sd, dbhandle, fromcat, tocat):
    return _pisock.dlp_MoveCategory(sd, dbhandle, fromcat, tocat)

def dlp_ReadAppBlock(sd, dbhandle, offset, reqbytes):
    return _pisock.dlp_ReadAppBlock(sd, dbhandle, offset, reqbytes)

def dlp_WriteAppBlock(sd, dbhandle, databuf):
    return _pisock.dlp_WriteAppBlock(sd, dbhandle, databuf)

def dlp_ReadSortBlock(sd, dbhandle, offset, reqbytes):
    return _pisock.dlp_ReadSortBlock(sd, dbhandle, offset, reqbytes)

def dlp_WriteSortBlock(sd, dbhandle, databuf):
    return _pisock.dlp_WriteSortBlock(sd, dbhandle, databuf)

def dlp_CleanUpDatabase(sd, dbhandle):
    return _pisock.dlp_CleanUpDatabase(sd, dbhandle)

def dlp_ResetSyncFlags(sd, dbhandle):
    return _pisock.dlp_ResetSyncFlags(sd, dbhandle)

def dlp_ResetDBIndex(sd, dbhandle):
    return _pisock.dlp_ResetDBIndex(sd, dbhandle)

def dlp_ReadRecordById(sd, dbhandle, recuid):
    return _pisock.dlp_ReadRecordById(sd, dbhandle, recuid)

def dlp_ReadRecordByIndex(sd, dbhandle, recindex):
    return _pisock.dlp_ReadRecordByIndex(sd, dbhandle, recindex)

def dlp_ReadNextModifiedRec(sd, dbhandle):
    return _pisock.dlp_ReadNextModifiedRec(sd, dbhandle)

def dlp_ReadNextModifiedRecInCategory(sd, dbhandle, category):
    return _pisock.dlp_ReadNextModifiedRecInCategory(sd, dbhandle, category)

def dlp_ReadNextRecInCategory(sd, dbhandle, category):
    return _pisock.dlp_ReadNextRecInCategory(sd, dbhandle, category)

def dlp_WriteRecord(sd, dbhandle, flags, recuid, catid, databuf):
    return _pisock.dlp_WriteRecord(sd, dbhandle, flags, recuid, catid, databuf)

def dlp_DeleteRecord(sd, dbhandle, all, recuid):
    return _pisock.dlp_DeleteRecord(sd, dbhandle, all, recuid)

def dlp_ReadResourceByType(sd, dbhandle, type, resid):
    return _pisock.dlp_ReadResourceByType(sd, dbhandle, type, resid)

def dlp_ReadResourceByIndex(sd, dbhandle, resindex, restype):
    return _pisock.dlp_ReadResourceByIndex(sd, dbhandle, resindex, restype)

def dlp_WriteResource(sd, dbhandle, restype, resid, databuf):
    return _pisock.dlp_WriteResource(sd, dbhandle, restype, resid, databuf)

def dlp_DeleteResource(sd, dbhandle, all, restype, resid):
    return _pisock.dlp_DeleteResource(sd, dbhandle, all, restype, resid)

def dlp_ExpSlotEnumerate(sd):
    return _pisock.dlp_ExpSlotEnumerate(sd)

def dlp_ExpCardPresent(sd, slotref):
    return _pisock.dlp_ExpCardPresent(sd, slotref)

def dlp_ExpCardInfo(sd, slotref, expflags, numstrings, strings):
    return _pisock.dlp_ExpCardInfo(sd, slotref, expflags, numstrings, strings)

def dlp_ExpSlotMediaType(sd, slotref, mediatype):
    return _pisock.dlp_ExpSlotMediaType(sd, slotref, mediatype)

def dlp_VFSVolumeEnumerate(sd, numvols, volrefs):
    return _pisock.dlp_VFSVolumeEnumerate(sd, numvols, volrefs)

def dlp_VFSVolumeInfo(sd, volref, volinfo):
    return _pisock.dlp_VFSVolumeInfo(sd, volref, volinfo)

def dlp_VFSVolumeGetLabel(sd, volref, len, name):
    return _pisock.dlp_VFSVolumeGetLabel(sd, volref, len, name)

def dlp_VFSVolumeSetLabel(sd, volref, name):
    return _pisock.dlp_VFSVolumeSetLabel(sd, volref, name)

def dlp_VFSVolumeSize(sd, volref):
    return _pisock.dlp_VFSVolumeSize(sd, volref)

def dlp_VFSVolumeFormat(sd, fmtflags, fsLibRef, param):
    return _pisock.dlp_VFSVolumeFormat(sd, fmtflags, fsLibRef, param)

def dlp_VFSGetDefaultDir(sd, volref, name, dir, len):
    return _pisock.dlp_VFSGetDefaultDir(sd, volref, name, dir, len)

def dlp_VFSDirEntryEnumerate(sd, dirref, diriterator, maxitems, diritems):
    return _pisock.dlp_VFSDirEntryEnumerate(sd, dirref, diriterator, maxitems, diritems)

def dlp_VFSDirCreate(sd, volref, path):
    return _pisock.dlp_VFSDirCreate(sd, volref, path)

def dlp_VFSImportDatabaseFromFile(sd, volref, pathname):
    return _pisock.dlp_VFSImportDatabaseFromFile(sd, volref, pathname)

def dlp_VFSExportDatabaseToFile(sd, volref, pathname, cardno, localid):
    return _pisock.dlp_VFSExportDatabaseToFile(sd, volref, pathname, cardno, localid)

def dlp_VFSFileCreate(sd, volref, pathname):
    return _pisock.dlp_VFSFileCreate(sd, volref, pathname)

def dlp_VFSFileOpen(sd, volref, path, mode, fileref):
    return _pisock.dlp_VFSFileOpen(sd, volref, path, mode, fileref)

def dlp_VFSFileClose(sd, fileref):
    return _pisock.dlp_VFSFileClose(sd, fileref)

def dlp_VFSFileWrite(sd, fileref, databuf):
    return _pisock.dlp_VFSFileWrite(sd, fileref, databuf)

def dlp_VFSFileRead(sd, fileref, reqbytes):
    return _pisock.dlp_VFSFileRead(sd, fileref, reqbytes)

def dlp_VFSFileDelete(sd, volref, pathname):
    return _pisock.dlp_VFSFileDelete(sd, volref, pathname)

def dlp_VFSFileRename(sd, volref, pathname, newname):
    return _pisock.dlp_VFSFileRename(sd, volref, pathname, newname)

def dlp_VFSFileEOF(sd, fileref):
    return _pisock.dlp_VFSFileEOF(sd, fileref)

def dlp_VFSFileTell(sd, fileref, position):
    return _pisock.dlp_VFSFileTell(sd, fileref, position)

def dlp_VFSFileGetAttributes(sd, fileref, fileattrs):
    return _pisock.dlp_VFSFileGetAttributes(sd, fileref, fileattrs)

def dlp_VFSFileSetAttributes(sd, fileref, fileattrs):
    return _pisock.dlp_VFSFileSetAttributes(sd, fileref, fileattrs)

def dlp_VFSFileGetDate(sd, fileref, which, date):
    return _pisock.dlp_VFSFileGetDate(sd, fileref, which, date)

def dlp_VFSFileSetDate(sd, fileref, which, date):
    return _pisock.dlp_VFSFileSetDate(sd, fileref, which, date)

def dlp_VFSFileSeek(sd, fileref, origin, offset):
    return _pisock.dlp_VFSFileSeek(sd, fileref, origin, offset)

def dlp_VFSFileResize(sd, fileref, newsize):
    return _pisock.dlp_VFSFileResize(sd, fileref, newsize)

def dlp_VFSFileSize(sd, fileref, size):
    return _pisock.dlp_VFSFileSize(sd, fileref, size)

