# 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 _Hamlib

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

import types
try:
    _object = types.ObjectType
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0
del types


RIG_MODEL_NONE = _Hamlib.RIG_MODEL_NONE
RIG_MODEL_DUMMY = _Hamlib.RIG_MODEL_DUMMY
RIG_MODEL_FT847 = _Hamlib.RIG_MODEL_FT847
RIG_MODEL_FT1000 = _Hamlib.RIG_MODEL_FT1000
RIG_MODEL_FT1000D = _Hamlib.RIG_MODEL_FT1000D
RIG_MODEL_FT1000MPMKV = _Hamlib.RIG_MODEL_FT1000MPMKV
RIG_MODEL_FT747 = _Hamlib.RIG_MODEL_FT747
RIG_MODEL_FT757 = _Hamlib.RIG_MODEL_FT757
RIG_MODEL_FT757GXII = _Hamlib.RIG_MODEL_FT757GXII
RIG_MODEL_FT575 = _Hamlib.RIG_MODEL_FT575
RIG_MODEL_FT767 = _Hamlib.RIG_MODEL_FT767
RIG_MODEL_FT736R = _Hamlib.RIG_MODEL_FT736R
RIG_MODEL_FT840 = _Hamlib.RIG_MODEL_FT840
RIG_MODEL_FT820 = _Hamlib.RIG_MODEL_FT820
RIG_MODEL_FT900 = _Hamlib.RIG_MODEL_FT900
RIG_MODEL_FT920 = _Hamlib.RIG_MODEL_FT920
RIG_MODEL_FT890 = _Hamlib.RIG_MODEL_FT890
RIG_MODEL_FT990 = _Hamlib.RIG_MODEL_FT990
RIG_MODEL_FRG100 = _Hamlib.RIG_MODEL_FRG100
RIG_MODEL_FRG9600 = _Hamlib.RIG_MODEL_FRG9600
RIG_MODEL_FRG8800 = _Hamlib.RIG_MODEL_FRG8800
RIG_MODEL_FT817 = _Hamlib.RIG_MODEL_FT817
RIG_MODEL_FT100 = _Hamlib.RIG_MODEL_FT100
RIG_MODEL_FT857 = _Hamlib.RIG_MODEL_FT857
RIG_MODEL_FT897 = _Hamlib.RIG_MODEL_FT897
RIG_MODEL_FT1000MP = _Hamlib.RIG_MODEL_FT1000MP
RIG_MODEL_FT1000MPMKVFLD = _Hamlib.RIG_MODEL_FT1000MPMKVFLD
RIG_MODEL_VR5000 = _Hamlib.RIG_MODEL_VR5000
RIG_MODEL_TS50 = _Hamlib.RIG_MODEL_TS50
RIG_MODEL_TS440 = _Hamlib.RIG_MODEL_TS440
RIG_MODEL_TS450S = _Hamlib.RIG_MODEL_TS450S
RIG_MODEL_TS570D = _Hamlib.RIG_MODEL_TS570D
RIG_MODEL_TS690S = _Hamlib.RIG_MODEL_TS690S
RIG_MODEL_TS711 = _Hamlib.RIG_MODEL_TS711
RIG_MODEL_TS790 = _Hamlib.RIG_MODEL_TS790
RIG_MODEL_TS811 = _Hamlib.RIG_MODEL_TS811
RIG_MODEL_TS850 = _Hamlib.RIG_MODEL_TS850
RIG_MODEL_TS870S = _Hamlib.RIG_MODEL_TS870S
RIG_MODEL_TS940 = _Hamlib.RIG_MODEL_TS940
RIG_MODEL_TS950 = _Hamlib.RIG_MODEL_TS950
RIG_MODEL_TS950SDX = _Hamlib.RIG_MODEL_TS950SDX
RIG_MODEL_TS2000 = _Hamlib.RIG_MODEL_TS2000
RIG_MODEL_R5000 = _Hamlib.RIG_MODEL_R5000
RIG_MODEL_TS570S = _Hamlib.RIG_MODEL_TS570S
RIG_MODEL_THD7A = _Hamlib.RIG_MODEL_THD7A
RIG_MODEL_THD7AG = _Hamlib.RIG_MODEL_THD7AG
RIG_MODEL_THF6A = _Hamlib.RIG_MODEL_THF6A
RIG_MODEL_THF7E = _Hamlib.RIG_MODEL_THF7E
RIG_MODEL_K2 = _Hamlib.RIG_MODEL_K2
RIG_MODEL_TS930 = _Hamlib.RIG_MODEL_TS930
RIG_MODEL_THG71 = _Hamlib.RIG_MODEL_THG71
RIG_MODEL_TS680S = _Hamlib.RIG_MODEL_TS680S
RIG_MODEL_TS140S = _Hamlib.RIG_MODEL_TS140S
RIG_MODEL_TMD700 = _Hamlib.RIG_MODEL_TMD700
RIG_MODEL_TMV7 = _Hamlib.RIG_MODEL_TMV7
RIG_MODEL_TS480 = _Hamlib.RIG_MODEL_TS480
RIG_MODEL_IC1271 = _Hamlib.RIG_MODEL_IC1271
RIG_MODEL_IC1275 = _Hamlib.RIG_MODEL_IC1275
RIG_MODEL_IC271 = _Hamlib.RIG_MODEL_IC271
RIG_MODEL_IC275 = _Hamlib.RIG_MODEL_IC275
RIG_MODEL_IC375 = _Hamlib.RIG_MODEL_IC375
RIG_MODEL_IC471 = _Hamlib.RIG_MODEL_IC471
RIG_MODEL_IC475 = _Hamlib.RIG_MODEL_IC475
RIG_MODEL_IC575 = _Hamlib.RIG_MODEL_IC575
RIG_MODEL_IC706 = _Hamlib.RIG_MODEL_IC706
RIG_MODEL_IC706MKII = _Hamlib.RIG_MODEL_IC706MKII
RIG_MODEL_IC706MKIIG = _Hamlib.RIG_MODEL_IC706MKIIG
RIG_MODEL_IC707 = _Hamlib.RIG_MODEL_IC707
RIG_MODEL_IC718 = _Hamlib.RIG_MODEL_IC718
RIG_MODEL_IC725 = _Hamlib.RIG_MODEL_IC725
RIG_MODEL_IC726 = _Hamlib.RIG_MODEL_IC726
RIG_MODEL_IC728 = _Hamlib.RIG_MODEL_IC728
RIG_MODEL_IC729 = _Hamlib.RIG_MODEL_IC729
RIG_MODEL_IC731 = _Hamlib.RIG_MODEL_IC731
RIG_MODEL_IC735 = _Hamlib.RIG_MODEL_IC735
RIG_MODEL_IC736 = _Hamlib.RIG_MODEL_IC736
RIG_MODEL_IC737 = _Hamlib.RIG_MODEL_IC737
RIG_MODEL_IC738 = _Hamlib.RIG_MODEL_IC738
RIG_MODEL_IC746 = _Hamlib.RIG_MODEL_IC746
RIG_MODEL_IC751 = _Hamlib.RIG_MODEL_IC751
RIG_MODEL_IC751A = _Hamlib.RIG_MODEL_IC751A
RIG_MODEL_IC756 = _Hamlib.RIG_MODEL_IC756
RIG_MODEL_IC756PRO = _Hamlib.RIG_MODEL_IC756PRO
RIG_MODEL_IC761 = _Hamlib.RIG_MODEL_IC761
RIG_MODEL_IC765 = _Hamlib.RIG_MODEL_IC765
RIG_MODEL_IC775 = _Hamlib.RIG_MODEL_IC775
RIG_MODEL_IC781 = _Hamlib.RIG_MODEL_IC781
RIG_MODEL_IC820 = _Hamlib.RIG_MODEL_IC820
RIG_MODEL_IC821 = _Hamlib.RIG_MODEL_IC821
RIG_MODEL_IC821H = _Hamlib.RIG_MODEL_IC821H
RIG_MODEL_IC970 = _Hamlib.RIG_MODEL_IC970
RIG_MODEL_ICR10 = _Hamlib.RIG_MODEL_ICR10
RIG_MODEL_ICR71 = _Hamlib.RIG_MODEL_ICR71
RIG_MODEL_ICR72 = _Hamlib.RIG_MODEL_ICR72
RIG_MODEL_ICR75 = _Hamlib.RIG_MODEL_ICR75
RIG_MODEL_ICR7000 = _Hamlib.RIG_MODEL_ICR7000
RIG_MODEL_ICR7100 = _Hamlib.RIG_MODEL_ICR7100
RIG_MODEL_ICR8500 = _Hamlib.RIG_MODEL_ICR8500
RIG_MODEL_ICR9000 = _Hamlib.RIG_MODEL_ICR9000
RIG_MODEL_IC910 = _Hamlib.RIG_MODEL_IC910
RIG_MODEL_IC78 = _Hamlib.RIG_MODEL_IC78
RIG_MODEL_IC746PRO = _Hamlib.RIG_MODEL_IC746PRO
RIG_MODEL_IC756PROII = _Hamlib.RIG_MODEL_IC756PROII
RIG_MODEL_ICID1 = _Hamlib.RIG_MODEL_ICID1
RIG_MODEL_IC703 = _Hamlib.RIG_MODEL_IC703
RIG_MODEL_IC7800 = _Hamlib.RIG_MODEL_IC7800
RIG_MODEL_IC756PROIII = _Hamlib.RIG_MODEL_IC756PROIII
RIG_MODEL_ICR20 = _Hamlib.RIG_MODEL_ICR20
RIG_MODEL_IC7000 = _Hamlib.RIG_MODEL_IC7000
RIG_MODEL_MINISCOUT = _Hamlib.RIG_MODEL_MINISCOUT
RIG_MODEL_XPLORER = _Hamlib.RIG_MODEL_XPLORER
RIG_MODEL_OS535 = _Hamlib.RIG_MODEL_OS535
RIG_MODEL_OS456 = _Hamlib.RIG_MODEL_OS456
RIG_MODEL_OMNIVI = _Hamlib.RIG_MODEL_OMNIVI
RIG_MODEL_OMNIVIP = _Hamlib.RIG_MODEL_OMNIVIP
RIG_MODEL_PARAGON2 = _Hamlib.RIG_MODEL_PARAGON2
RIG_MODEL_PCR1000 = _Hamlib.RIG_MODEL_PCR1000
RIG_MODEL_PCR100 = _Hamlib.RIG_MODEL_PCR100
RIG_MODEL_AR8200 = _Hamlib.RIG_MODEL_AR8200
RIG_MODEL_AR8000 = _Hamlib.RIG_MODEL_AR8000
RIG_MODEL_AR7030 = _Hamlib.RIG_MODEL_AR7030
RIG_MODEL_AR5000 = _Hamlib.RIG_MODEL_AR5000
RIG_MODEL_AR3030 = _Hamlib.RIG_MODEL_AR3030
RIG_MODEL_AR3000A = _Hamlib.RIG_MODEL_AR3000A
RIG_MODEL_AR3000 = _Hamlib.RIG_MODEL_AR3000
RIG_MODEL_AR2700 = _Hamlib.RIG_MODEL_AR2700
RIG_MODEL_AR2500 = _Hamlib.RIG_MODEL_AR2500
RIG_MODEL_AR16 = _Hamlib.RIG_MODEL_AR16
RIG_MODEL_SDU5500 = _Hamlib.RIG_MODEL_SDU5500
RIG_MODEL_SDU5000 = _Hamlib.RIG_MODEL_SDU5000
RIG_MODEL_AR8600 = _Hamlib.RIG_MODEL_AR8600
RIG_MODEL_AR5000A = _Hamlib.RIG_MODEL_AR5000A
RIG_MODEL_JST145 = _Hamlib.RIG_MODEL_JST145
RIG_MODEL_JST245 = _Hamlib.RIG_MODEL_JST245
RIG_MODEL_CMH530 = _Hamlib.RIG_MODEL_CMH530
RIG_MODEL_NRD345 = _Hamlib.RIG_MODEL_NRD345
RIG_MODEL_NRD525 = _Hamlib.RIG_MODEL_NRD525
RIG_MODEL_NRD535 = _Hamlib.RIG_MODEL_NRD535
RIG_MODEL_NRD545 = _Hamlib.RIG_MODEL_NRD545
RIG_MODEL_RS64 = _Hamlib.RIG_MODEL_RS64
RIG_MODEL_RS2005 = _Hamlib.RIG_MODEL_RS2005
RIG_MODEL_RS2006 = _Hamlib.RIG_MODEL_RS2006
RIG_MODEL_RS2035 = _Hamlib.RIG_MODEL_RS2035
RIG_MODEL_RS2042 = _Hamlib.RIG_MODEL_RS2042
RIG_MODEL_RS2041 = _Hamlib.RIG_MODEL_RS2041
RIG_MODEL_RS2052 = _Hamlib.RIG_MODEL_RS2052
RIG_MODEL_BC780 = _Hamlib.RIG_MODEL_BC780
RIG_MODEL_BC245 = _Hamlib.RIG_MODEL_BC245
RIG_MODEL_BC895 = _Hamlib.RIG_MODEL_BC895
RIG_MODEL_DKR8 = _Hamlib.RIG_MODEL_DKR8
RIG_MODEL_DKR8A = _Hamlib.RIG_MODEL_DKR8A
RIG_MODEL_DKR8B = _Hamlib.RIG_MODEL_DKR8B
RIG_MODEL_HF150 = _Hamlib.RIG_MODEL_HF150
RIG_MODEL_HF225 = _Hamlib.RIG_MODEL_HF225
RIG_MODEL_HF250 = _Hamlib.RIG_MODEL_HF250
RIG_MODEL_HF235 = _Hamlib.RIG_MODEL_HF235
RIG_MODEL_RA3790 = _Hamlib.RIG_MODEL_RA3790
RIG_MODEL_RA3720 = _Hamlib.RIG_MODEL_RA3720
RIG_MODEL_RA6790 = _Hamlib.RIG_MODEL_RA6790
RIG_MODEL_RA3710 = _Hamlib.RIG_MODEL_RA3710
RIG_MODEL_HF1000 = _Hamlib.RIG_MODEL_HF1000
RIG_MODEL_HF1000A = _Hamlib.RIG_MODEL_HF1000A
RIG_MODEL_WJ8711 = _Hamlib.RIG_MODEL_WJ8711
RIG_MODEL_WJ8888 = _Hamlib.RIG_MODEL_WJ8888
RIG_MODEL_ESM500 = _Hamlib.RIG_MODEL_ESM500
RIG_MODEL_EK890 = _Hamlib.RIG_MODEL_EK890
RIG_MODEL_EK891 = _Hamlib.RIG_MODEL_EK891
RIG_MODEL_EK895 = _Hamlib.RIG_MODEL_EK895
RIG_MODEL_EK070 = _Hamlib.RIG_MODEL_EK070
RIG_MODEL_TRP7000 = _Hamlib.RIG_MODEL_TRP7000
RIG_MODEL_TRP8000 = _Hamlib.RIG_MODEL_TRP8000
RIG_MODEL_TRP9000 = _Hamlib.RIG_MODEL_TRP9000
RIG_MODEL_WR1000 = _Hamlib.RIG_MODEL_WR1000
RIG_MODEL_WR1500 = _Hamlib.RIG_MODEL_WR1500
RIG_MODEL_WR1550 = _Hamlib.RIG_MODEL_WR1550
RIG_MODEL_WR3100 = _Hamlib.RIG_MODEL_WR3100
RIG_MODEL_WR3150 = _Hamlib.RIG_MODEL_WR3150
RIG_MODEL_WR3500 = _Hamlib.RIG_MODEL_WR3500
RIG_MODEL_WR3700 = _Hamlib.RIG_MODEL_WR3700
RIG_MODEL_G303 = _Hamlib.RIG_MODEL_G303
RIG_MODEL_G313 = _Hamlib.RIG_MODEL_G313
RIG_MODEL_TT550 = _Hamlib.RIG_MODEL_TT550
RIG_MODEL_TT538 = _Hamlib.RIG_MODEL_TT538
RIG_MODEL_RX320 = _Hamlib.RIG_MODEL_RX320
RIG_MODEL_RX340 = _Hamlib.RIG_MODEL_RX340
RIG_MODEL_RX350 = _Hamlib.RIG_MODEL_RX350
RIG_MODEL_TT526 = _Hamlib.RIG_MODEL_TT526
RIG_MODEL_TT516 = _Hamlib.RIG_MODEL_TT516
RIG_MODEL_TT565 = _Hamlib.RIG_MODEL_TT565
RIG_MODEL_TT585 = _Hamlib.RIG_MODEL_TT585
RIG_MODEL_DX77 = _Hamlib.RIG_MODEL_DX77
RIG_MODEL_505DSP = _Hamlib.RIG_MODEL_505DSP
RIG_MODEL_RPC = _Hamlib.RIG_MODEL_RPC
RIG_MODEL_GNURADIO = _Hamlib.RIG_MODEL_GNURADIO
RIG_MODEL_MC4020 = _Hamlib.RIG_MODEL_MC4020
RIG_MODEL_GRAUDIO = _Hamlib.RIG_MODEL_GRAUDIO
RIG_MODEL_GRAUDIOIQ = _Hamlib.RIG_MODEL_GRAUDIOIQ
RIG_MODEL_USRP_G = _Hamlib.RIG_MODEL_USRP_G
RIG_MICROTUNE = _Hamlib.RIG_MICROTUNE
RIG_BACKEND_MICROTUNE = _Hamlib.RIG_BACKEND_MICROTUNE
RIG_MODEL_MICROTUNE_4937 = _Hamlib.RIG_MODEL_MICROTUNE_4937
RIG_MODEL_MICROTUNE_4702 = _Hamlib.RIG_MODEL_MICROTUNE_4702
RIG_MODEL_MICROTUNE_4707 = _Hamlib.RIG_MODEL_MICROTUNE_4707
RIG_TAPR = _Hamlib.RIG_TAPR
RIG_BACKEND_TAPR = _Hamlib.RIG_BACKEND_TAPR
RIG_MODEL_DSP10 = _Hamlib.RIG_MODEL_DSP10
RIG_FLEXRADIO = _Hamlib.RIG_FLEXRADIO
RIG_BACKEND_FLEXRADIO = _Hamlib.RIG_BACKEND_FLEXRADIO
RIG_MODEL_SDR1000 = _Hamlib.RIG_MODEL_SDR1000
RIG_MODEL_SDR1000RFE = _Hamlib.RIG_MODEL_SDR1000RFE
RIG_RFT = _Hamlib.RIG_RFT
RIG_BACKEND_RFT = _Hamlib.RIG_BACKEND_RFT
RIG_MODEL_EKD500 = _Hamlib.RIG_MODEL_EKD500
RIG_KIT = _Hamlib.RIG_KIT
RIG_BACKEND_KIT = _Hamlib.RIG_BACKEND_KIT
RIG_MODEL_ELEKTOR304 = _Hamlib.RIG_MODEL_ELEKTOR304
RIG_MODEL_DRT1 = _Hamlib.RIG_MODEL_DRT1
RIG_MODEL_DWT = _Hamlib.RIG_MODEL_DWT
RIG_MODEL_USRP0 = _Hamlib.RIG_MODEL_USRP0
RIG_MODEL_USRP = _Hamlib.RIG_MODEL_USRP
RIG_TUNER = _Hamlib.RIG_TUNER
RIG_BACKEND_TUNER = _Hamlib.RIG_BACKEND_TUNER
RIG_MODEL_V4L = _Hamlib.RIG_MODEL_V4L
RIG_OK = _Hamlib.RIG_OK
RIG_EINVAL = _Hamlib.RIG_EINVAL
RIG_ECONF = _Hamlib.RIG_ECONF
RIG_ENOMEM = _Hamlib.RIG_ENOMEM
RIG_ENIMPL = _Hamlib.RIG_ENIMPL
RIG_ETIMEOUT = _Hamlib.RIG_ETIMEOUT
RIG_EIO = _Hamlib.RIG_EIO
RIG_EINTERNAL = _Hamlib.RIG_EINTERNAL
RIG_EPROTO = _Hamlib.RIG_EPROTO
RIG_ERJCTED = _Hamlib.RIG_ERJCTED
RIG_ETRUNC = _Hamlib.RIG_ETRUNC
RIG_ENAVAIL = _Hamlib.RIG_ENAVAIL
RIG_ENTARGET = _Hamlib.RIG_ENTARGET
RIG_BUSERROR = _Hamlib.RIG_BUSERROR
RIG_BUSBUSY = _Hamlib.RIG_BUSBUSY
RIG_EARG = _Hamlib.RIG_EARG
RIG_EVFO = _Hamlib.RIG_EVFO
RIG_EDOM = _Hamlib.RIG_EDOM
RIG_DEBUG_NONE = _Hamlib.RIG_DEBUG_NONE
RIG_DEBUG_BUG = _Hamlib.RIG_DEBUG_BUG
RIG_DEBUG_ERR = _Hamlib.RIG_DEBUG_ERR
RIG_DEBUG_WARN = _Hamlib.RIG_DEBUG_WARN
RIG_DEBUG_VERBOSE = _Hamlib.RIG_DEBUG_VERBOSE
RIG_DEBUG_TRACE = _Hamlib.RIG_DEBUG_TRACE
RIGNAMSIZ = _Hamlib.RIGNAMSIZ
RIGVERSIZ = _Hamlib.RIGVERSIZ
FILPATHLEN = _Hamlib.FILPATHLEN
FRQRANGESIZ = _Hamlib.FRQRANGESIZ
MAXCHANDESC = _Hamlib.MAXCHANDESC
TSLSTSIZ = _Hamlib.TSLSTSIZ
FLTLSTSIZ = _Hamlib.FLTLSTSIZ
MAXDBLSTSIZ = _Hamlib.MAXDBLSTSIZ
CHANLSTSIZ = _Hamlib.CHANLSTSIZ
MAX_CAL_LENGTH = _Hamlib.MAX_CAL_LENGTH
RIG_PORT_NONE = _Hamlib.RIG_PORT_NONE
RIG_PORT_SERIAL = _Hamlib.RIG_PORT_SERIAL
RIG_PORT_NETWORK = _Hamlib.RIG_PORT_NETWORK
RIG_PORT_DEVICE = _Hamlib.RIG_PORT_DEVICE
RIG_PORT_PACKET = _Hamlib.RIG_PORT_PACKET
RIG_PORT_DTMF = _Hamlib.RIG_PORT_DTMF
RIG_PORT_ULTRA = _Hamlib.RIG_PORT_ULTRA
RIG_PORT_RPC = _Hamlib.RIG_PORT_RPC
RIG_PORT_PARALLEL = _Hamlib.RIG_PORT_PARALLEL
RIG_PORT_USB = _Hamlib.RIG_PORT_USB
RIG_PARITY_NONE = _Hamlib.RIG_PARITY_NONE
RIG_PARITY_ODD = _Hamlib.RIG_PARITY_ODD
RIG_PARITY_EVEN = _Hamlib.RIG_PARITY_EVEN
RIG_HANDSHAKE_NONE = _Hamlib.RIG_HANDSHAKE_NONE
RIG_HANDSHAKE_XONXOFF = _Hamlib.RIG_HANDSHAKE_XONXOFF
RIG_HANDSHAKE_HARDWARE = _Hamlib.RIG_HANDSHAKE_HARDWARE
RIG_SIGNAL_UNSET = _Hamlib.RIG_SIGNAL_UNSET
RIG_SIGNAL_ON = _Hamlib.RIG_SIGNAL_ON
RIG_SIGNAL_OFF = _Hamlib.RIG_SIGNAL_OFF
RIG_FLAG_RECEIVER = _Hamlib.RIG_FLAG_RECEIVER
RIG_FLAG_TRANSMITTER = _Hamlib.RIG_FLAG_TRANSMITTER
RIG_FLAG_SCANNER = _Hamlib.RIG_FLAG_SCANNER
RIG_FLAG_MOBILE = _Hamlib.RIG_FLAG_MOBILE
RIG_FLAG_HANDHELD = _Hamlib.RIG_FLAG_HANDHELD
RIG_FLAG_COMPUTER = _Hamlib.RIG_FLAG_COMPUTER
RIG_FLAG_TRUNKING = _Hamlib.RIG_FLAG_TRUNKING
RIG_FLAG_APRS = _Hamlib.RIG_FLAG_APRS
RIG_FLAG_TNC = _Hamlib.RIG_FLAG_TNC
RIG_FLAG_DXCLUSTER = _Hamlib.RIG_FLAG_DXCLUSTER
RIG_FLAG_TUNER = _Hamlib.RIG_FLAG_TUNER
RIG_TYPE_OTHER = _Hamlib.RIG_TYPE_OTHER
RIG_STATUS_ALPHA = _Hamlib.RIG_STATUS_ALPHA
RIG_STATUS_UNTESTED = _Hamlib.RIG_STATUS_UNTESTED
RIG_STATUS_BETA = _Hamlib.RIG_STATUS_BETA
RIG_STATUS_STABLE = _Hamlib.RIG_STATUS_STABLE
RIG_STATUS_BUGGY = _Hamlib.RIG_STATUS_BUGGY
RIG_STATUS_NEW = _Hamlib.RIG_STATUS_NEW
RIG_RPT_SHIFT_NONE = _Hamlib.RIG_RPT_SHIFT_NONE
RIG_RPT_SHIFT_MINUS = _Hamlib.RIG_RPT_SHIFT_MINUS
RIG_RPT_SHIFT_PLUS = _Hamlib.RIG_RPT_SHIFT_PLUS
RIG_SPLIT_OFF = _Hamlib.RIG_SPLIT_OFF
RIG_SPLIT_ON = _Hamlib.RIG_SPLIT_ON
PRIfreq = _Hamlib.PRIfreq
SCNfreq = _Hamlib.SCNfreq
FREQFMT = _Hamlib.FREQFMT
RIG_VFO_NONE = _Hamlib.RIG_VFO_NONE
RIG_TARGETABLE_NONE = _Hamlib.RIG_TARGETABLE_NONE
RIG_TARGETABLE_FREQ = _Hamlib.RIG_TARGETABLE_FREQ
RIG_TARGETABLE_MODE = _Hamlib.RIG_TARGETABLE_MODE
RIG_TARGETABLE_PURE = _Hamlib.RIG_TARGETABLE_PURE
RIG_TARGETABLE_ALL = _Hamlib.RIG_TARGETABLE_ALL
RIG_DCD_OFF = _Hamlib.RIG_DCD_OFF
RIG_DCD_ON = _Hamlib.RIG_DCD_ON
RIG_DCD_NONE = _Hamlib.RIG_DCD_NONE
RIG_DCD_RIG = _Hamlib.RIG_DCD_RIG
RIG_DCD_SERIAL_DSR = _Hamlib.RIG_DCD_SERIAL_DSR
RIG_DCD_SERIAL_CTS = _Hamlib.RIG_DCD_SERIAL_CTS
RIG_DCD_SERIAL_CAR = _Hamlib.RIG_DCD_SERIAL_CAR
RIG_DCD_PARALLEL = _Hamlib.RIG_DCD_PARALLEL
RIG_PTT_OFF = _Hamlib.RIG_PTT_OFF
RIG_PTT_ON = _Hamlib.RIG_PTT_ON
RIG_PTT_NONE = _Hamlib.RIG_PTT_NONE
RIG_PTT_RIG = _Hamlib.RIG_PTT_RIG
RIG_PTT_SERIAL_DTR = _Hamlib.RIG_PTT_SERIAL_DTR
RIG_PTT_SERIAL_RTS = _Hamlib.RIG_PTT_SERIAL_RTS
RIG_PTT_PARALLEL = _Hamlib.RIG_PTT_PARALLEL
RIG_POWER_OFF = _Hamlib.RIG_POWER_OFF
RIG_POWER_ON = _Hamlib.RIG_POWER_ON
RIG_POWER_STANDBY = _Hamlib.RIG_POWER_STANDBY
RIG_RESET_NONE = _Hamlib.RIG_RESET_NONE
RIG_RESET_SOFT = _Hamlib.RIG_RESET_SOFT
RIG_RESET_VFO = _Hamlib.RIG_RESET_VFO
RIG_RESET_MCALL = _Hamlib.RIG_RESET_MCALL
RIG_RESET_MASTER = _Hamlib.RIG_RESET_MASTER
RIG_OP_NONE = _Hamlib.RIG_OP_NONE
RIG_OP_CPY = _Hamlib.RIG_OP_CPY
RIG_OP_XCHG = _Hamlib.RIG_OP_XCHG
RIG_OP_FROM_VFO = _Hamlib.RIG_OP_FROM_VFO
RIG_OP_TO_VFO = _Hamlib.RIG_OP_TO_VFO
RIG_OP_MCL = _Hamlib.RIG_OP_MCL
RIG_OP_UP = _Hamlib.RIG_OP_UP
RIG_OP_DOWN = _Hamlib.RIG_OP_DOWN
RIG_OP_BAND_UP = _Hamlib.RIG_OP_BAND_UP
RIG_OP_BAND_DOWN = _Hamlib.RIG_OP_BAND_DOWN
RIG_OP_LEFT = _Hamlib.RIG_OP_LEFT
RIG_OP_RIGHT = _Hamlib.RIG_OP_RIGHT
RIG_OP_TUNE = _Hamlib.RIG_OP_TUNE
RIG_OP_TOGGLE = _Hamlib.RIG_OP_TOGGLE
RIG_SCAN_NONE = _Hamlib.RIG_SCAN_NONE
RIG_SCAN_STOP = _Hamlib.RIG_SCAN_STOP
RIG_SCAN_MEM = _Hamlib.RIG_SCAN_MEM
RIG_SCAN_SLCT = _Hamlib.RIG_SCAN_SLCT
RIG_SCAN_PRIO = _Hamlib.RIG_SCAN_PRIO
RIG_SCAN_PROG = _Hamlib.RIG_SCAN_PROG
RIG_SCAN_DELTA = _Hamlib.RIG_SCAN_DELTA
RIG_SCAN_VFO = _Hamlib.RIG_SCAN_VFO
RIG_SCAN_PLT = _Hamlib.RIG_SCAN_PLT
RIG_CONF_END = _Hamlib.RIG_CONF_END
RIG_CONF_STRING = _Hamlib.RIG_CONF_STRING
RIG_CONF_COMBO = _Hamlib.RIG_CONF_COMBO
RIG_CONF_NUMERIC = _Hamlib.RIG_CONF_NUMERIC
RIG_CONF_CHECKBUTTON = _Hamlib.RIG_CONF_CHECKBUTTON
RIG_COMBO_MAX = _Hamlib.RIG_COMBO_MAX
class confparams(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, confparams, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, confparams, name)
    def __repr__(self):
        return "<%s.%s; proxy of C confparams instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["token"] = _Hamlib.confparams_token_set
    __swig_getmethods__["token"] = _Hamlib.confparams_token_get
    if _newclass:token = property(_Hamlib.confparams_token_get, _Hamlib.confparams_token_set)
    __swig_setmethods__["name"] = _Hamlib.confparams_name_set
    __swig_getmethods__["name"] = _Hamlib.confparams_name_get
    if _newclass:name = property(_Hamlib.confparams_name_get, _Hamlib.confparams_name_set)
    __swig_setmethods__["label"] = _Hamlib.confparams_label_set
    __swig_getmethods__["label"] = _Hamlib.confparams_label_get
    if _newclass:label = property(_Hamlib.confparams_label_get, _Hamlib.confparams_label_set)
    __swig_setmethods__["tooltip"] = _Hamlib.confparams_tooltip_set
    __swig_getmethods__["tooltip"] = _Hamlib.confparams_tooltip_get
    if _newclass:tooltip = property(_Hamlib.confparams_tooltip_get, _Hamlib.confparams_tooltip_set)
    __swig_setmethods__["dflt"] = _Hamlib.confparams_dflt_set
    __swig_getmethods__["dflt"] = _Hamlib.confparams_dflt_get
    if _newclass:dflt = property(_Hamlib.confparams_dflt_get, _Hamlib.confparams_dflt_set)
    __swig_setmethods__["type"] = _Hamlib.confparams_type_set
    __swig_getmethods__["type"] = _Hamlib.confparams_type_get
    if _newclass:type = property(_Hamlib.confparams_type_get, _Hamlib.confparams_type_set)
    __swig_getmethods__["u"] = _Hamlib.confparams_u_get
    if _newclass:u = property(_Hamlib.confparams_u_get)
    def __init__(self, *args):
        _swig_setattr(self, confparams, 'this', _Hamlib.new_confparams(*args))
        _swig_setattr(self, confparams, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_confparams):
        try:
            if self.thisown: destroy(self)
        except: pass


class confparamsPtr(confparams):
    def __init__(self, this):
        _swig_setattr(self, confparams, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, confparams, 'thisown', 0)
        _swig_setattr(self, confparams,self.__class__,confparams)
_Hamlib.confparams_swigregister(confparamsPtr)
cvar = _Hamlib.cvar
hamlib_version = cvar.hamlib_version
hamlib_copyright = cvar.hamlib_copyright

class confparams_u(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, confparams_u, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, confparams_u, name)
    def __repr__(self):
        return "<%s.%s; proxy of C confparams_u instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_getmethods__["c"] = _Hamlib.confparams_u_c_get
    if _newclass:c = property(_Hamlib.confparams_u_c_get)
    __swig_getmethods__["n"] = _Hamlib.confparams_u_n_get
    if _newclass:n = property(_Hamlib.confparams_u_n_get)
    def __init__(self, *args):
        _swig_setattr(self, confparams_u, 'this', _Hamlib.new_confparams_u(*args))
        _swig_setattr(self, confparams_u, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_confparams_u):
        try:
            if self.thisown: destroy(self)
        except: pass


class confparams_uPtr(confparams_u):
    def __init__(self, this):
        _swig_setattr(self, confparams_u, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, confparams_u, 'thisown', 0)
        _swig_setattr(self, confparams_u,self.__class__,confparams_u)
_Hamlib.confparams_u_swigregister(confparams_uPtr)

class confparams_u_c(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, confparams_u_c, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, confparams_u_c, name)
    def __repr__(self):
        return "<%s.%s; proxy of C confparams_u_c instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["combostr"] = _Hamlib.confparams_u_c_combostr_set
    __swig_getmethods__["combostr"] = _Hamlib.confparams_u_c_combostr_get
    if _newclass:combostr = property(_Hamlib.confparams_u_c_combostr_get, _Hamlib.confparams_u_c_combostr_set)
    def __init__(self, *args):
        _swig_setattr(self, confparams_u_c, 'this', _Hamlib.new_confparams_u_c(*args))
        _swig_setattr(self, confparams_u_c, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_confparams_u_c):
        try:
            if self.thisown: destroy(self)
        except: pass


class confparams_u_cPtr(confparams_u_c):
    def __init__(self, this):
        _swig_setattr(self, confparams_u_c, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, confparams_u_c, 'thisown', 0)
        _swig_setattr(self, confparams_u_c,self.__class__,confparams_u_c)
_Hamlib.confparams_u_c_swigregister(confparams_u_cPtr)

class confparams_u_n(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, confparams_u_n, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, confparams_u_n, name)
    def __repr__(self):
        return "<%s.%s; proxy of C confparams_u_n instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["min"] = _Hamlib.confparams_u_n_min_set
    __swig_getmethods__["min"] = _Hamlib.confparams_u_n_min_get
    if _newclass:min = property(_Hamlib.confparams_u_n_min_get, _Hamlib.confparams_u_n_min_set)
    __swig_setmethods__["max"] = _Hamlib.confparams_u_n_max_set
    __swig_getmethods__["max"] = _Hamlib.confparams_u_n_max_get
    if _newclass:max = property(_Hamlib.confparams_u_n_max_get, _Hamlib.confparams_u_n_max_set)
    __swig_setmethods__["step"] = _Hamlib.confparams_u_n_step_set
    __swig_getmethods__["step"] = _Hamlib.confparams_u_n_step_get
    if _newclass:step = property(_Hamlib.confparams_u_n_step_get, _Hamlib.confparams_u_n_step_set)
    def __init__(self, *args):
        _swig_setattr(self, confparams_u_n, 'this', _Hamlib.new_confparams_u_n(*args))
        _swig_setattr(self, confparams_u_n, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_confparams_u_n):
        try:
            if self.thisown: destroy(self)
        except: pass


class confparams_u_nPtr(confparams_u_n):
    def __init__(self, this):
        _swig_setattr(self, confparams_u_n, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, confparams_u_n, 'thisown', 0)
        _swig_setattr(self, confparams_u_n,self.__class__,confparams_u_n)
_Hamlib.confparams_u_n_swigregister(confparams_u_nPtr)

RIG_ANN_NONE = _Hamlib.RIG_ANN_NONE
RIG_ANN_OFF = _Hamlib.RIG_ANN_OFF
RIG_ANN_FREQ = _Hamlib.RIG_ANN_FREQ
RIG_ANN_RXMODE = _Hamlib.RIG_ANN_RXMODE
RIG_ANN_CW = _Hamlib.RIG_ANN_CW
RIG_ANN_ENG = _Hamlib.RIG_ANN_ENG
RIG_ANN_JAP = _Hamlib.RIG_ANN_JAP
RIG_ANT_NONE = _Hamlib.RIG_ANT_NONE
RIG_AGC_OFF = _Hamlib.RIG_AGC_OFF
RIG_AGC_SUPERFAST = _Hamlib.RIG_AGC_SUPERFAST
RIG_AGC_FAST = _Hamlib.RIG_AGC_FAST
RIG_AGC_SLOW = _Hamlib.RIG_AGC_SLOW
RIG_AGC_USER = _Hamlib.RIG_AGC_USER
RIG_AGC_MEDIUM = _Hamlib.RIG_AGC_MEDIUM
RIG_METER_NONE = _Hamlib.RIG_METER_NONE
RIG_METER_SWR = _Hamlib.RIG_METER_SWR
RIG_METER_COMP = _Hamlib.RIG_METER_COMP
RIG_METER_ALC = _Hamlib.RIG_METER_ALC
RIG_METER_IC = _Hamlib.RIG_METER_IC
RIG_METER_DB = _Hamlib.RIG_METER_DB
class value_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, value_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, value_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C value_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["i"] = _Hamlib.value_t_i_set
    __swig_getmethods__["i"] = _Hamlib.value_t_i_get
    if _newclass:i = property(_Hamlib.value_t_i_get, _Hamlib.value_t_i_set)
    __swig_setmethods__["f"] = _Hamlib.value_t_f_set
    __swig_getmethods__["f"] = _Hamlib.value_t_f_get
    if _newclass:f = property(_Hamlib.value_t_f_get, _Hamlib.value_t_f_set)
    __swig_setmethods__["s"] = _Hamlib.value_t_s_set
    __swig_getmethods__["s"] = _Hamlib.value_t_s_get
    if _newclass:s = property(_Hamlib.value_t_s_get, _Hamlib.value_t_s_set)
    __swig_setmethods__["cs"] = _Hamlib.value_t_cs_set
    __swig_getmethods__["cs"] = _Hamlib.value_t_cs_get
    if _newclass:cs = property(_Hamlib.value_t_cs_get, _Hamlib.value_t_cs_set)
    def __init__(self, *args):
        _swig_setattr(self, value_t, 'this', _Hamlib.new_value_t(*args))
        _swig_setattr(self, value_t, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_value_t):
        try:
            if self.thisown: destroy(self)
        except: pass


class value_tPtr(value_t):
    def __init__(self, this):
        _swig_setattr(self, value_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, value_t, 'thisown', 0)
        _swig_setattr(self, value_t,self.__class__,value_t)
_Hamlib.value_t_swigregister(value_tPtr)

RIG_LEVEL_NONE = _Hamlib.RIG_LEVEL_NONE
RIG_LEVEL_PREAMP = _Hamlib.RIG_LEVEL_PREAMP
RIG_LEVEL_ATT = _Hamlib.RIG_LEVEL_ATT
RIG_LEVEL_VOX = _Hamlib.RIG_LEVEL_VOX
RIG_LEVEL_AF = _Hamlib.RIG_LEVEL_AF
RIG_LEVEL_RF = _Hamlib.RIG_LEVEL_RF
RIG_LEVEL_SQL = _Hamlib.RIG_LEVEL_SQL
RIG_LEVEL_IF = _Hamlib.RIG_LEVEL_IF
RIG_LEVEL_APF = _Hamlib.RIG_LEVEL_APF
RIG_LEVEL_NR = _Hamlib.RIG_LEVEL_NR
RIG_LEVEL_PBT_IN = _Hamlib.RIG_LEVEL_PBT_IN
RIG_LEVEL_PBT_OUT = _Hamlib.RIG_LEVEL_PBT_OUT
RIG_LEVEL_CWPITCH = _Hamlib.RIG_LEVEL_CWPITCH
RIG_LEVEL_RFPOWER = _Hamlib.RIG_LEVEL_RFPOWER
RIG_LEVEL_MICGAIN = _Hamlib.RIG_LEVEL_MICGAIN
RIG_LEVEL_KEYSPD = _Hamlib.RIG_LEVEL_KEYSPD
RIG_LEVEL_NOTCHF = _Hamlib.RIG_LEVEL_NOTCHF
RIG_LEVEL_COMP = _Hamlib.RIG_LEVEL_COMP
RIG_LEVEL_AGC = _Hamlib.RIG_LEVEL_AGC
RIG_LEVEL_BKINDL = _Hamlib.RIG_LEVEL_BKINDL
RIG_LEVEL_BALANCE = _Hamlib.RIG_LEVEL_BALANCE
RIG_LEVEL_METER = _Hamlib.RIG_LEVEL_METER
RIG_LEVEL_VOXGAIN = _Hamlib.RIG_LEVEL_VOXGAIN
RIG_LEVEL_VOXDELAY = _Hamlib.RIG_LEVEL_VOXDELAY
RIG_LEVEL_ANTIVOX = _Hamlib.RIG_LEVEL_ANTIVOX
RIG_LEVEL_RAWSTR = _Hamlib.RIG_LEVEL_RAWSTR
RIG_LEVEL_SQLSTAT = _Hamlib.RIG_LEVEL_SQLSTAT
RIG_LEVEL_SWR = _Hamlib.RIG_LEVEL_SWR
RIG_LEVEL_ALC = _Hamlib.RIG_LEVEL_ALC
RIG_LEVEL_STRENGTH = _Hamlib.RIG_LEVEL_STRENGTH
RIG_PARM_NONE = _Hamlib.RIG_PARM_NONE
RIG_PARM_ANN = _Hamlib.RIG_PARM_ANN
RIG_PARM_APO = _Hamlib.RIG_PARM_APO
RIG_PARM_BACKLIGHT = _Hamlib.RIG_PARM_BACKLIGHT
RIG_PARM_BEEP = _Hamlib.RIG_PARM_BEEP
RIG_PARM_TIME = _Hamlib.RIG_PARM_TIME
RIG_PARM_BAT = _Hamlib.RIG_PARM_BAT
RIG_PARM_KEYLIGHT = _Hamlib.RIG_PARM_KEYLIGHT
RIG_SETTING_MAX = _Hamlib.RIG_SETTING_MAX
RIG_TRN_OFF = _Hamlib.RIG_TRN_OFF
RIG_TRN_RIG = _Hamlib.RIG_TRN_RIG
RIG_TRN_POLL = _Hamlib.RIG_TRN_POLL
RIG_FUNC_NONE = _Hamlib.RIG_FUNC_NONE
RIG_FUNC_FAGC = _Hamlib.RIG_FUNC_FAGC
RIG_FUNC_NB = _Hamlib.RIG_FUNC_NB
RIG_FUNC_COMP = _Hamlib.RIG_FUNC_COMP
RIG_FUNC_VOX = _Hamlib.RIG_FUNC_VOX
RIG_FUNC_TONE = _Hamlib.RIG_FUNC_TONE
RIG_FUNC_TSQL = _Hamlib.RIG_FUNC_TSQL
RIG_FUNC_SBKIN = _Hamlib.RIG_FUNC_SBKIN
RIG_FUNC_FBKIN = _Hamlib.RIG_FUNC_FBKIN
RIG_FUNC_ANF = _Hamlib.RIG_FUNC_ANF
RIG_FUNC_NR = _Hamlib.RIG_FUNC_NR
RIG_FUNC_AIP = _Hamlib.RIG_FUNC_AIP
RIG_FUNC_APF = _Hamlib.RIG_FUNC_APF
RIG_FUNC_MON = _Hamlib.RIG_FUNC_MON
RIG_FUNC_MN = _Hamlib.RIG_FUNC_MN
RIG_FUNC_RF = _Hamlib.RIG_FUNC_RF
RIG_FUNC_ARO = _Hamlib.RIG_FUNC_ARO
RIG_FUNC_LOCK = _Hamlib.RIG_FUNC_LOCK
RIG_FUNC_MUTE = _Hamlib.RIG_FUNC_MUTE
RIG_FUNC_VSC = _Hamlib.RIG_FUNC_VSC
RIG_FUNC_REV = _Hamlib.RIG_FUNC_REV
RIG_FUNC_SQL = _Hamlib.RIG_FUNC_SQL
RIG_FUNC_ABM = _Hamlib.RIG_FUNC_ABM
RIG_FUNC_BC = _Hamlib.RIG_FUNC_BC
RIG_FUNC_MBC = _Hamlib.RIG_FUNC_MBC
RIG_FUNC_AFC = _Hamlib.RIG_FUNC_AFC
RIG_FUNC_SATMODE = _Hamlib.RIG_FUNC_SATMODE
RIG_FUNC_SCOPE = _Hamlib.RIG_FUNC_SCOPE
RIG_FUNC_RESUME = _Hamlib.RIG_FUNC_RESUME
RIG_FUNC_TBURST = _Hamlib.RIG_FUNC_TBURST
RIG_FUNC_TUNER = _Hamlib.RIG_FUNC_TUNER
RIG_MODE_NONE = _Hamlib.RIG_MODE_NONE
RIG_MODE_AM = _Hamlib.RIG_MODE_AM
RIG_MODE_CW = _Hamlib.RIG_MODE_CW
RIG_MODE_USB = _Hamlib.RIG_MODE_USB
RIG_MODE_LSB = _Hamlib.RIG_MODE_LSB
RIG_MODE_RTTY = _Hamlib.RIG_MODE_RTTY
RIG_MODE_FM = _Hamlib.RIG_MODE_FM
RIG_MODE_WFM = _Hamlib.RIG_MODE_WFM
RIG_MODE_CWR = _Hamlib.RIG_MODE_CWR
RIG_MODE_RTTYR = _Hamlib.RIG_MODE_RTTYR
RIG_MODE_AMS = _Hamlib.RIG_MODE_AMS
RIG_MODE_PKTLSB = _Hamlib.RIG_MODE_PKTLSB
RIG_MODE_PKTUSB = _Hamlib.RIG_MODE_PKTUSB
RIG_MODE_PKTFM = _Hamlib.RIG_MODE_PKTFM
RIG_MODE_ECSSUSB = _Hamlib.RIG_MODE_ECSSUSB
RIG_MODE_ECSSLSB = _Hamlib.RIG_MODE_ECSSLSB
RIG_MODE_FAX = _Hamlib.RIG_MODE_FAX
RIG_MODE_SAM = _Hamlib.RIG_MODE_SAM
RIG_MODE_SAL = _Hamlib.RIG_MODE_SAL
RIG_MODE_SAH = _Hamlib.RIG_MODE_SAH
RIG_DBLST_END = _Hamlib.RIG_DBLST_END
class freq_range_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, freq_range_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, freq_range_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C freq_range_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["start"] = _Hamlib.freq_range_t_start_set
    __swig_getmethods__["start"] = _Hamlib.freq_range_t_start_get
    if _newclass:start = property(_Hamlib.freq_range_t_start_get, _Hamlib.freq_range_t_start_set)
    __swig_setmethods__["end"] = _Hamlib.freq_range_t_end_set
    __swig_getmethods__["end"] = _Hamlib.freq_range_t_end_get
    if _newclass:end = property(_Hamlib.freq_range_t_end_get, _Hamlib.freq_range_t_end_set)
    __swig_setmethods__["modes"] = _Hamlib.freq_range_t_modes_set
    __swig_getmethods__["modes"] = _Hamlib.freq_range_t_modes_get
    if _newclass:modes = property(_Hamlib.freq_range_t_modes_get, _Hamlib.freq_range_t_modes_set)
    __swig_setmethods__["low_power"] = _Hamlib.freq_range_t_low_power_set
    __swig_getmethods__["low_power"] = _Hamlib.freq_range_t_low_power_get
    if _newclass:low_power = property(_Hamlib.freq_range_t_low_power_get, _Hamlib.freq_range_t_low_power_set)
    __swig_setmethods__["high_power"] = _Hamlib.freq_range_t_high_power_set
    __swig_getmethods__["high_power"] = _Hamlib.freq_range_t_high_power_get
    if _newclass:high_power = property(_Hamlib.freq_range_t_high_power_get, _Hamlib.freq_range_t_high_power_set)
    __swig_setmethods__["vfo"] = _Hamlib.freq_range_t_vfo_set
    __swig_getmethods__["vfo"] = _Hamlib.freq_range_t_vfo_get
    if _newclass:vfo = property(_Hamlib.freq_range_t_vfo_get, _Hamlib.freq_range_t_vfo_set)
    __swig_setmethods__["ant"] = _Hamlib.freq_range_t_ant_set
    __swig_getmethods__["ant"] = _Hamlib.freq_range_t_ant_get
    if _newclass:ant = property(_Hamlib.freq_range_t_ant_get, _Hamlib.freq_range_t_ant_set)
    def __init__(self, *args):
        _swig_setattr(self, freq_range_t, 'this', _Hamlib.new_freq_range_t(*args))
        _swig_setattr(self, freq_range_t, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_freq_range_t):
        try:
            if self.thisown: destroy(self)
        except: pass


class freq_range_tPtr(freq_range_t):
    def __init__(self, this):
        _swig_setattr(self, freq_range_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, freq_range_t, 'thisown', 0)
        _swig_setattr(self, freq_range_t,self.__class__,freq_range_t)
_Hamlib.freq_range_t_swigregister(freq_range_tPtr)

RIG_ITU_REGION1 = _Hamlib.RIG_ITU_REGION1
RIG_ITU_REGION2 = _Hamlib.RIG_ITU_REGION2
RIG_ITU_REGION3 = _Hamlib.RIG_ITU_REGION3
class tuning_step_list(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, tuning_step_list, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, tuning_step_list, name)
    def __repr__(self):
        return "<%s.%s; proxy of C tuning_step_list instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["modes"] = _Hamlib.tuning_step_list_modes_set
    __swig_getmethods__["modes"] = _Hamlib.tuning_step_list_modes_get
    if _newclass:modes = property(_Hamlib.tuning_step_list_modes_get, _Hamlib.tuning_step_list_modes_set)
    __swig_setmethods__["ts"] = _Hamlib.tuning_step_list_ts_set
    __swig_getmethods__["ts"] = _Hamlib.tuning_step_list_ts_get
    if _newclass:ts = property(_Hamlib.tuning_step_list_ts_get, _Hamlib.tuning_step_list_ts_set)
    def __init__(self, *args):
        _swig_setattr(self, tuning_step_list, 'this', _Hamlib.new_tuning_step_list(*args))
        _swig_setattr(self, tuning_step_list, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_tuning_step_list):
        try:
            if self.thisown: destroy(self)
        except: pass


class tuning_step_listPtr(tuning_step_list):
    def __init__(self, this):
        _swig_setattr(self, tuning_step_list, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, tuning_step_list, 'thisown', 0)
        _swig_setattr(self, tuning_step_list,self.__class__,tuning_step_list)
_Hamlib.tuning_step_list_swigregister(tuning_step_listPtr)

RIG_TS_ANY = _Hamlib.RIG_TS_ANY
class filter_list(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, filter_list, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, filter_list, name)
    def __repr__(self):
        return "<%s.%s; proxy of C filter_list instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["modes"] = _Hamlib.filter_list_modes_set
    __swig_getmethods__["modes"] = _Hamlib.filter_list_modes_get
    if _newclass:modes = property(_Hamlib.filter_list_modes_get, _Hamlib.filter_list_modes_set)
    __swig_setmethods__["width"] = _Hamlib.filter_list_width_set
    __swig_getmethods__["width"] = _Hamlib.filter_list_width_get
    if _newclass:width = property(_Hamlib.filter_list_width_get, _Hamlib.filter_list_width_set)
    def __init__(self, *args):
        _swig_setattr(self, filter_list, 'this', _Hamlib.new_filter_list(*args))
        _swig_setattr(self, filter_list, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_filter_list):
        try:
            if self.thisown: destroy(self)
        except: pass


class filter_listPtr(filter_list):
    def __init__(self, this):
        _swig_setattr(self, filter_list, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, filter_list, 'thisown', 0)
        _swig_setattr(self, filter_list,self.__class__,filter_list)
_Hamlib.filter_list_swigregister(filter_listPtr)

RIG_FLT_ANY = _Hamlib.RIG_FLT_ANY
RIG_CHFLAG_NONE = _Hamlib.RIG_CHFLAG_NONE
RIG_CHFLAG_SKIP = _Hamlib.RIG_CHFLAG_SKIP
RIG_CHFLAG_DATA = _Hamlib.RIG_CHFLAG_DATA
class ext_list(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ext_list, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ext_list, name)
    def __repr__(self):
        return "<%s.%s; proxy of C ext_list instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["token"] = _Hamlib.ext_list_token_set
    __swig_getmethods__["token"] = _Hamlib.ext_list_token_get
    if _newclass:token = property(_Hamlib.ext_list_token_get, _Hamlib.ext_list_token_set)
    __swig_setmethods__["val"] = _Hamlib.ext_list_val_set
    __swig_getmethods__["val"] = _Hamlib.ext_list_val_get
    if _newclass:val = property(_Hamlib.ext_list_val_get, _Hamlib.ext_list_val_set)
    def __init__(self, *args):
        _swig_setattr(self, ext_list, 'this', _Hamlib.new_ext_list(*args))
        _swig_setattr(self, ext_list, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_ext_list):
        try:
            if self.thisown: destroy(self)
        except: pass


class ext_listPtr(ext_list):
    def __init__(self, this):
        _swig_setattr(self, ext_list, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, ext_list, 'thisown', 0)
        _swig_setattr(self, ext_list,self.__class__,ext_list)
_Hamlib.ext_list_swigregister(ext_listPtr)

class Chan(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Chan, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Chan, name)
    def __repr__(self):
        return "<%s.%s; proxy of C channel instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["channel_num"] = _Hamlib.Chan_channel_num_set
    __swig_getmethods__["channel_num"] = _Hamlib.Chan_channel_num_get
    if _newclass:channel_num = property(_Hamlib.Chan_channel_num_get, _Hamlib.Chan_channel_num_set)
    __swig_setmethods__["bank_num"] = _Hamlib.Chan_bank_num_set
    __swig_getmethods__["bank_num"] = _Hamlib.Chan_bank_num_get
    if _newclass:bank_num = property(_Hamlib.Chan_bank_num_get, _Hamlib.Chan_bank_num_set)
    __swig_setmethods__["vfo"] = _Hamlib.Chan_vfo_set
    __swig_getmethods__["vfo"] = _Hamlib.Chan_vfo_get
    if _newclass:vfo = property(_Hamlib.Chan_vfo_get, _Hamlib.Chan_vfo_set)
    __swig_setmethods__["ant"] = _Hamlib.Chan_ant_set
    __swig_getmethods__["ant"] = _Hamlib.Chan_ant_get
    if _newclass:ant = property(_Hamlib.Chan_ant_get, _Hamlib.Chan_ant_set)
    __swig_setmethods__["freq"] = _Hamlib.Chan_freq_set
    __swig_getmethods__["freq"] = _Hamlib.Chan_freq_get
    if _newclass:freq = property(_Hamlib.Chan_freq_get, _Hamlib.Chan_freq_set)
    __swig_setmethods__["mode"] = _Hamlib.Chan_mode_set
    __swig_getmethods__["mode"] = _Hamlib.Chan_mode_get
    if _newclass:mode = property(_Hamlib.Chan_mode_get, _Hamlib.Chan_mode_set)
    __swig_setmethods__["width"] = _Hamlib.Chan_width_set
    __swig_getmethods__["width"] = _Hamlib.Chan_width_get
    if _newclass:width = property(_Hamlib.Chan_width_get, _Hamlib.Chan_width_set)
    __swig_setmethods__["tx_freq"] = _Hamlib.Chan_tx_freq_set
    __swig_getmethods__["tx_freq"] = _Hamlib.Chan_tx_freq_get
    if _newclass:tx_freq = property(_Hamlib.Chan_tx_freq_get, _Hamlib.Chan_tx_freq_set)
    __swig_setmethods__["tx_mode"] = _Hamlib.Chan_tx_mode_set
    __swig_getmethods__["tx_mode"] = _Hamlib.Chan_tx_mode_get
    if _newclass:tx_mode = property(_Hamlib.Chan_tx_mode_get, _Hamlib.Chan_tx_mode_set)
    __swig_setmethods__["tx_width"] = _Hamlib.Chan_tx_width_set
    __swig_getmethods__["tx_width"] = _Hamlib.Chan_tx_width_get
    if _newclass:tx_width = property(_Hamlib.Chan_tx_width_get, _Hamlib.Chan_tx_width_set)
    __swig_setmethods__["split"] = _Hamlib.Chan_split_set
    __swig_getmethods__["split"] = _Hamlib.Chan_split_get
    if _newclass:split = property(_Hamlib.Chan_split_get, _Hamlib.Chan_split_set)
    __swig_setmethods__["tx_vfo"] = _Hamlib.Chan_tx_vfo_set
    __swig_getmethods__["tx_vfo"] = _Hamlib.Chan_tx_vfo_get
    if _newclass:tx_vfo = property(_Hamlib.Chan_tx_vfo_get, _Hamlib.Chan_tx_vfo_set)
    __swig_setmethods__["rptr_shift"] = _Hamlib.Chan_rptr_shift_set
    __swig_getmethods__["rptr_shift"] = _Hamlib.Chan_rptr_shift_get
    if _newclass:rptr_shift = property(_Hamlib.Chan_rptr_shift_get, _Hamlib.Chan_rptr_shift_set)
    __swig_setmethods__["rptr_offs"] = _Hamlib.Chan_rptr_offs_set
    __swig_getmethods__["rptr_offs"] = _Hamlib.Chan_rptr_offs_get
    if _newclass:rptr_offs = property(_Hamlib.Chan_rptr_offs_get, _Hamlib.Chan_rptr_offs_set)
    __swig_setmethods__["tuning_step"] = _Hamlib.Chan_tuning_step_set
    __swig_getmethods__["tuning_step"] = _Hamlib.Chan_tuning_step_get
    if _newclass:tuning_step = property(_Hamlib.Chan_tuning_step_get, _Hamlib.Chan_tuning_step_set)
    __swig_setmethods__["rit"] = _Hamlib.Chan_rit_set
    __swig_getmethods__["rit"] = _Hamlib.Chan_rit_get
    if _newclass:rit = property(_Hamlib.Chan_rit_get, _Hamlib.Chan_rit_set)
    __swig_setmethods__["xit"] = _Hamlib.Chan_xit_set
    __swig_getmethods__["xit"] = _Hamlib.Chan_xit_get
    if _newclass:xit = property(_Hamlib.Chan_xit_get, _Hamlib.Chan_xit_set)
    __swig_setmethods__["funcs"] = _Hamlib.Chan_funcs_set
    __swig_getmethods__["funcs"] = _Hamlib.Chan_funcs_get
    if _newclass:funcs = property(_Hamlib.Chan_funcs_get, _Hamlib.Chan_funcs_set)
    __swig_setmethods__["levels"] = _Hamlib.Chan_levels_set
    __swig_getmethods__["levels"] = _Hamlib.Chan_levels_get
    if _newclass:levels = property(_Hamlib.Chan_levels_get, _Hamlib.Chan_levels_set)
    __swig_setmethods__["ctcss_tone"] = _Hamlib.Chan_ctcss_tone_set
    __swig_getmethods__["ctcss_tone"] = _Hamlib.Chan_ctcss_tone_get
    if _newclass:ctcss_tone = property(_Hamlib.Chan_ctcss_tone_get, _Hamlib.Chan_ctcss_tone_set)
    __swig_setmethods__["ctcss_sql"] = _Hamlib.Chan_ctcss_sql_set
    __swig_getmethods__["ctcss_sql"] = _Hamlib.Chan_ctcss_sql_get
    if _newclass:ctcss_sql = property(_Hamlib.Chan_ctcss_sql_get, _Hamlib.Chan_ctcss_sql_set)
    __swig_setmethods__["dcs_code"] = _Hamlib.Chan_dcs_code_set
    __swig_getmethods__["dcs_code"] = _Hamlib.Chan_dcs_code_get
    if _newclass:dcs_code = property(_Hamlib.Chan_dcs_code_get, _Hamlib.Chan_dcs_code_set)
    __swig_setmethods__["dcs_sql"] = _Hamlib.Chan_dcs_sql_set
    __swig_getmethods__["dcs_sql"] = _Hamlib.Chan_dcs_sql_get
    if _newclass:dcs_sql = property(_Hamlib.Chan_dcs_sql_get, _Hamlib.Chan_dcs_sql_set)
    __swig_setmethods__["scan_group"] = _Hamlib.Chan_scan_group_set
    __swig_getmethods__["scan_group"] = _Hamlib.Chan_scan_group_get
    if _newclass:scan_group = property(_Hamlib.Chan_scan_group_get, _Hamlib.Chan_scan_group_set)
    __swig_setmethods__["flags"] = _Hamlib.Chan_flags_set
    __swig_getmethods__["flags"] = _Hamlib.Chan_flags_get
    if _newclass:flags = property(_Hamlib.Chan_flags_get, _Hamlib.Chan_flags_set)
    __swig_setmethods__["channel_desc"] = _Hamlib.Chan_channel_desc_set
    __swig_getmethods__["channel_desc"] = _Hamlib.Chan_channel_desc_get
    if _newclass:channel_desc = property(_Hamlib.Chan_channel_desc_get, _Hamlib.Chan_channel_desc_set)
    __swig_setmethods__["ext_levels"] = _Hamlib.Chan_ext_levels_set
    __swig_getmethods__["ext_levels"] = _Hamlib.Chan_ext_levels_get
    if _newclass:ext_levels = property(_Hamlib.Chan_ext_levels_get, _Hamlib.Chan_ext_levels_set)
    def __init__(self, *args):
        _swig_setattr(self, Chan, 'this', _Hamlib.new_Chan(*args))
        _swig_setattr(self, Chan, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_Chan):
        try:
            if self.thisown: destroy(self)
        except: pass


class ChanPtr(Chan):
    def __init__(self, this):
        _swig_setattr(self, Chan, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Chan, 'thisown', 0)
        _swig_setattr(self, Chan,self.__class__,Chan)
_Hamlib.Chan_swigregister(ChanPtr)

class channel_cap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, channel_cap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, channel_cap, name)
    def __repr__(self):
        return "<%s.%s; proxy of C channel_cap instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["bank_num"] = _Hamlib.channel_cap_bank_num_set
    __swig_getmethods__["bank_num"] = _Hamlib.channel_cap_bank_num_get
    if _newclass:bank_num = property(_Hamlib.channel_cap_bank_num_get, _Hamlib.channel_cap_bank_num_set)
    __swig_setmethods__["vfo"] = _Hamlib.channel_cap_vfo_set
    __swig_getmethods__["vfo"] = _Hamlib.channel_cap_vfo_get
    if _newclass:vfo = property(_Hamlib.channel_cap_vfo_get, _Hamlib.channel_cap_vfo_set)
    __swig_setmethods__["ant"] = _Hamlib.channel_cap_ant_set
    __swig_getmethods__["ant"] = _Hamlib.channel_cap_ant_get
    if _newclass:ant = property(_Hamlib.channel_cap_ant_get, _Hamlib.channel_cap_ant_set)
    __swig_setmethods__["freq"] = _Hamlib.channel_cap_freq_set
    __swig_getmethods__["freq"] = _Hamlib.channel_cap_freq_get
    if _newclass:freq = property(_Hamlib.channel_cap_freq_get, _Hamlib.channel_cap_freq_set)
    __swig_setmethods__["mode"] = _Hamlib.channel_cap_mode_set
    __swig_getmethods__["mode"] = _Hamlib.channel_cap_mode_get
    if _newclass:mode = property(_Hamlib.channel_cap_mode_get, _Hamlib.channel_cap_mode_set)
    __swig_setmethods__["width"] = _Hamlib.channel_cap_width_set
    __swig_getmethods__["width"] = _Hamlib.channel_cap_width_get
    if _newclass:width = property(_Hamlib.channel_cap_width_get, _Hamlib.channel_cap_width_set)
    __swig_setmethods__["tx_freq"] = _Hamlib.channel_cap_tx_freq_set
    __swig_getmethods__["tx_freq"] = _Hamlib.channel_cap_tx_freq_get
    if _newclass:tx_freq = property(_Hamlib.channel_cap_tx_freq_get, _Hamlib.channel_cap_tx_freq_set)
    __swig_setmethods__["tx_mode"] = _Hamlib.channel_cap_tx_mode_set
    __swig_getmethods__["tx_mode"] = _Hamlib.channel_cap_tx_mode_get
    if _newclass:tx_mode = property(_Hamlib.channel_cap_tx_mode_get, _Hamlib.channel_cap_tx_mode_set)
    __swig_setmethods__["tx_width"] = _Hamlib.channel_cap_tx_width_set
    __swig_getmethods__["tx_width"] = _Hamlib.channel_cap_tx_width_get
    if _newclass:tx_width = property(_Hamlib.channel_cap_tx_width_get, _Hamlib.channel_cap_tx_width_set)
    __swig_setmethods__["split"] = _Hamlib.channel_cap_split_set
    __swig_getmethods__["split"] = _Hamlib.channel_cap_split_get
    if _newclass:split = property(_Hamlib.channel_cap_split_get, _Hamlib.channel_cap_split_set)
    __swig_setmethods__["tx_vfo"] = _Hamlib.channel_cap_tx_vfo_set
    __swig_getmethods__["tx_vfo"] = _Hamlib.channel_cap_tx_vfo_get
    if _newclass:tx_vfo = property(_Hamlib.channel_cap_tx_vfo_get, _Hamlib.channel_cap_tx_vfo_set)
    __swig_setmethods__["rptr_shift"] = _Hamlib.channel_cap_rptr_shift_set
    __swig_getmethods__["rptr_shift"] = _Hamlib.channel_cap_rptr_shift_get
    if _newclass:rptr_shift = property(_Hamlib.channel_cap_rptr_shift_get, _Hamlib.channel_cap_rptr_shift_set)
    __swig_setmethods__["rptr_offs"] = _Hamlib.channel_cap_rptr_offs_set
    __swig_getmethods__["rptr_offs"] = _Hamlib.channel_cap_rptr_offs_get
    if _newclass:rptr_offs = property(_Hamlib.channel_cap_rptr_offs_get, _Hamlib.channel_cap_rptr_offs_set)
    __swig_setmethods__["tuning_step"] = _Hamlib.channel_cap_tuning_step_set
    __swig_getmethods__["tuning_step"] = _Hamlib.channel_cap_tuning_step_get
    if _newclass:tuning_step = property(_Hamlib.channel_cap_tuning_step_get, _Hamlib.channel_cap_tuning_step_set)
    __swig_setmethods__["rit"] = _Hamlib.channel_cap_rit_set
    __swig_getmethods__["rit"] = _Hamlib.channel_cap_rit_get
    if _newclass:rit = property(_Hamlib.channel_cap_rit_get, _Hamlib.channel_cap_rit_set)
    __swig_setmethods__["xit"] = _Hamlib.channel_cap_xit_set
    __swig_getmethods__["xit"] = _Hamlib.channel_cap_xit_get
    if _newclass:xit = property(_Hamlib.channel_cap_xit_get, _Hamlib.channel_cap_xit_set)
    __swig_setmethods__["funcs"] = _Hamlib.channel_cap_funcs_set
    __swig_getmethods__["funcs"] = _Hamlib.channel_cap_funcs_get
    if _newclass:funcs = property(_Hamlib.channel_cap_funcs_get, _Hamlib.channel_cap_funcs_set)
    __swig_setmethods__["levels"] = _Hamlib.channel_cap_levels_set
    __swig_getmethods__["levels"] = _Hamlib.channel_cap_levels_get
    if _newclass:levels = property(_Hamlib.channel_cap_levels_get, _Hamlib.channel_cap_levels_set)
    __swig_setmethods__["ctcss_tone"] = _Hamlib.channel_cap_ctcss_tone_set
    __swig_getmethods__["ctcss_tone"] = _Hamlib.channel_cap_ctcss_tone_get
    if _newclass:ctcss_tone = property(_Hamlib.channel_cap_ctcss_tone_get, _Hamlib.channel_cap_ctcss_tone_set)
    __swig_setmethods__["ctcss_sql"] = _Hamlib.channel_cap_ctcss_sql_set
    __swig_getmethods__["ctcss_sql"] = _Hamlib.channel_cap_ctcss_sql_get
    if _newclass:ctcss_sql = property(_Hamlib.channel_cap_ctcss_sql_get, _Hamlib.channel_cap_ctcss_sql_set)
    __swig_setmethods__["dcs_code"] = _Hamlib.channel_cap_dcs_code_set
    __swig_getmethods__["dcs_code"] = _Hamlib.channel_cap_dcs_code_get
    if _newclass:dcs_code = property(_Hamlib.channel_cap_dcs_code_get, _Hamlib.channel_cap_dcs_code_set)
    __swig_setmethods__["dcs_sql"] = _Hamlib.channel_cap_dcs_sql_set
    __swig_getmethods__["dcs_sql"] = _Hamlib.channel_cap_dcs_sql_get
    if _newclass:dcs_sql = property(_Hamlib.channel_cap_dcs_sql_get, _Hamlib.channel_cap_dcs_sql_set)
    __swig_setmethods__["scan_group"] = _Hamlib.channel_cap_scan_group_set
    __swig_getmethods__["scan_group"] = _Hamlib.channel_cap_scan_group_get
    if _newclass:scan_group = property(_Hamlib.channel_cap_scan_group_get, _Hamlib.channel_cap_scan_group_set)
    __swig_setmethods__["flags"] = _Hamlib.channel_cap_flags_set
    __swig_getmethods__["flags"] = _Hamlib.channel_cap_flags_get
    if _newclass:flags = property(_Hamlib.channel_cap_flags_get, _Hamlib.channel_cap_flags_set)
    __swig_setmethods__["channel_desc"] = _Hamlib.channel_cap_channel_desc_set
    __swig_getmethods__["channel_desc"] = _Hamlib.channel_cap_channel_desc_get
    if _newclass:channel_desc = property(_Hamlib.channel_cap_channel_desc_get, _Hamlib.channel_cap_channel_desc_set)
    __swig_setmethods__["ext_levels"] = _Hamlib.channel_cap_ext_levels_set
    __swig_getmethods__["ext_levels"] = _Hamlib.channel_cap_ext_levels_get
    if _newclass:ext_levels = property(_Hamlib.channel_cap_ext_levels_get, _Hamlib.channel_cap_ext_levels_set)
    def __init__(self, *args):
        _swig_setattr(self, channel_cap, 'this', _Hamlib.new_channel_cap(*args))
        _swig_setattr(self, channel_cap, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_channel_cap):
        try:
            if self.thisown: destroy(self)
        except: pass


class channel_capPtr(channel_cap):
    def __init__(self, this):
        _swig_setattr(self, channel_cap, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, channel_cap, 'thisown', 0)
        _swig_setattr(self, channel_cap,self.__class__,channel_cap)
_Hamlib.channel_cap_swigregister(channel_capPtr)

RIG_MTYPE_NONE = _Hamlib.RIG_MTYPE_NONE
RIG_MTYPE_MEM = _Hamlib.RIG_MTYPE_MEM
RIG_MTYPE_EDGE = _Hamlib.RIG_MTYPE_EDGE
RIG_MTYPE_CALL = _Hamlib.RIG_MTYPE_CALL
RIG_MTYPE_MEMOPAD = _Hamlib.RIG_MTYPE_MEMOPAD
RIG_MTYPE_SAT = _Hamlib.RIG_MTYPE_SAT
class chan_list(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, chan_list, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, chan_list, name)
    def __repr__(self):
        return "<%s.%s; proxy of C chan_list instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["start"] = _Hamlib.chan_list_start_set
    __swig_getmethods__["start"] = _Hamlib.chan_list_start_get
    if _newclass:start = property(_Hamlib.chan_list_start_get, _Hamlib.chan_list_start_set)
    __swig_setmethods__["end"] = _Hamlib.chan_list_end_set
    __swig_getmethods__["end"] = _Hamlib.chan_list_end_get
    if _newclass:end = property(_Hamlib.chan_list_end_get, _Hamlib.chan_list_end_set)
    __swig_setmethods__["type"] = _Hamlib.chan_list_type_set
    __swig_getmethods__["type"] = _Hamlib.chan_list_type_get
    if _newclass:type = property(_Hamlib.chan_list_type_get, _Hamlib.chan_list_type_set)
    __swig_setmethods__["mem_caps"] = _Hamlib.chan_list_mem_caps_set
    __swig_getmethods__["mem_caps"] = _Hamlib.chan_list_mem_caps_get
    if _newclass:mem_caps = property(_Hamlib.chan_list_mem_caps_get, _Hamlib.chan_list_mem_caps_set)
    def __init__(self, *args):
        _swig_setattr(self, chan_list, 'this', _Hamlib.new_chan_list(*args))
        _swig_setattr(self, chan_list, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_chan_list):
        try:
            if self.thisown: destroy(self)
        except: pass


class chan_listPtr(chan_list):
    def __init__(self, this):
        _swig_setattr(self, chan_list, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, chan_list, 'thisown', 0)
        _swig_setattr(self, chan_list,self.__class__,chan_list)
_Hamlib.chan_list_swigregister(chan_listPtr)

class gran(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, gran, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, gran, name)
    def __repr__(self):
        return "<%s.%s; proxy of C gran instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["min"] = _Hamlib.gran_min_set
    __swig_getmethods__["min"] = _Hamlib.gran_min_get
    if _newclass:min = property(_Hamlib.gran_min_get, _Hamlib.gran_min_set)
    __swig_setmethods__["max"] = _Hamlib.gran_max_set
    __swig_getmethods__["max"] = _Hamlib.gran_max_get
    if _newclass:max = property(_Hamlib.gran_max_get, _Hamlib.gran_max_set)
    __swig_setmethods__["step"] = _Hamlib.gran_step_set
    __swig_getmethods__["step"] = _Hamlib.gran_step_get
    if _newclass:step = property(_Hamlib.gran_step_get, _Hamlib.gran_step_set)
    def __init__(self, *args):
        _swig_setattr(self, gran, 'this', _Hamlib.new_gran(*args))
        _swig_setattr(self, gran, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_gran):
        try:
            if self.thisown: destroy(self)
        except: pass


class granPtr(gran):
    def __init__(self, this):
        _swig_setattr(self, gran, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, gran, 'thisown', 0)
        _swig_setattr(self, gran,self.__class__,gran)
_Hamlib.gran_swigregister(granPtr)

class cal_table(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, cal_table, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, cal_table, name)
    def __repr__(self):
        return "<%s.%s; proxy of C cal_table instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["size"] = _Hamlib.cal_table_size_set
    __swig_getmethods__["size"] = _Hamlib.cal_table_size_get
    if _newclass:size = property(_Hamlib.cal_table_size_get, _Hamlib.cal_table_size_set)
    __swig_getmethods__["table"] = _Hamlib.cal_table_table_get
    if _newclass:table = property(_Hamlib.cal_table_table_get)
    def __init__(self, *args):
        _swig_setattr(self, cal_table, 'this', _Hamlib.new_cal_table(*args))
        _swig_setattr(self, cal_table, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_cal_table):
        try:
            if self.thisown: destroy(self)
        except: pass


class cal_tablePtr(cal_table):
    def __init__(self, this):
        _swig_setattr(self, cal_table, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, cal_table, 'thisown', 0)
        _swig_setattr(self, cal_table,self.__class__,cal_table)
_Hamlib.cal_table_swigregister(cal_tablePtr)

class cal_table_table(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, cal_table_table, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, cal_table_table, name)
    def __repr__(self):
        return "<%s.%s; proxy of C cal_table_table instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["raw"] = _Hamlib.cal_table_table_raw_set
    __swig_getmethods__["raw"] = _Hamlib.cal_table_table_raw_get
    if _newclass:raw = property(_Hamlib.cal_table_table_raw_get, _Hamlib.cal_table_table_raw_set)
    __swig_setmethods__["val"] = _Hamlib.cal_table_table_val_set
    __swig_getmethods__["val"] = _Hamlib.cal_table_table_val_get
    if _newclass:val = property(_Hamlib.cal_table_table_val_get, _Hamlib.cal_table_table_val_set)
    def __init__(self, *args):
        _swig_setattr(self, cal_table_table, 'this', _Hamlib.new_cal_table_table(*args))
        _swig_setattr(self, cal_table_table, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_cal_table_table):
        try:
            if self.thisown: destroy(self)
        except: pass


class cal_table_tablePtr(cal_table_table):
    def __init__(self, this):
        _swig_setattr(self, cal_table_table, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, cal_table_table, 'thisown', 0)
        _swig_setattr(self, cal_table_table,self.__class__,cal_table_table)
_Hamlib.cal_table_table_swigregister(cal_table_tablePtr)

class rig_caps(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, rig_caps, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, rig_caps, name)
    def __repr__(self):
        return "<%s.%s; proxy of C rig_caps instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["rig_model"] = _Hamlib.rig_caps_rig_model_set
    __swig_getmethods__["rig_model"] = _Hamlib.rig_caps_rig_model_get
    if _newclass:rig_model = property(_Hamlib.rig_caps_rig_model_get, _Hamlib.rig_caps_rig_model_set)
    __swig_setmethods__["model_name"] = _Hamlib.rig_caps_model_name_set
    __swig_getmethods__["model_name"] = _Hamlib.rig_caps_model_name_get
    if _newclass:model_name = property(_Hamlib.rig_caps_model_name_get, _Hamlib.rig_caps_model_name_set)
    __swig_setmethods__["mfg_name"] = _Hamlib.rig_caps_mfg_name_set
    __swig_getmethods__["mfg_name"] = _Hamlib.rig_caps_mfg_name_get
    if _newclass:mfg_name = property(_Hamlib.rig_caps_mfg_name_get, _Hamlib.rig_caps_mfg_name_set)
    __swig_setmethods__["version"] = _Hamlib.rig_caps_version_set
    __swig_getmethods__["version"] = _Hamlib.rig_caps_version_get
    if _newclass:version = property(_Hamlib.rig_caps_version_get, _Hamlib.rig_caps_version_set)
    __swig_setmethods__["copyright"] = _Hamlib.rig_caps_copyright_set
    __swig_getmethods__["copyright"] = _Hamlib.rig_caps_copyright_get
    if _newclass:copyright = property(_Hamlib.rig_caps_copyright_get, _Hamlib.rig_caps_copyright_set)
    __swig_setmethods__["status"] = _Hamlib.rig_caps_status_set
    __swig_getmethods__["status"] = _Hamlib.rig_caps_status_get
    if _newclass:status = property(_Hamlib.rig_caps_status_get, _Hamlib.rig_caps_status_set)
    __swig_setmethods__["rig_type"] = _Hamlib.rig_caps_rig_type_set
    __swig_getmethods__["rig_type"] = _Hamlib.rig_caps_rig_type_get
    if _newclass:rig_type = property(_Hamlib.rig_caps_rig_type_get, _Hamlib.rig_caps_rig_type_set)
    __swig_setmethods__["ptt_type"] = _Hamlib.rig_caps_ptt_type_set
    __swig_getmethods__["ptt_type"] = _Hamlib.rig_caps_ptt_type_get
    if _newclass:ptt_type = property(_Hamlib.rig_caps_ptt_type_get, _Hamlib.rig_caps_ptt_type_set)
    __swig_setmethods__["dcd_type"] = _Hamlib.rig_caps_dcd_type_set
    __swig_getmethods__["dcd_type"] = _Hamlib.rig_caps_dcd_type_get
    if _newclass:dcd_type = property(_Hamlib.rig_caps_dcd_type_get, _Hamlib.rig_caps_dcd_type_set)
    __swig_setmethods__["port_type"] = _Hamlib.rig_caps_port_type_set
    __swig_getmethods__["port_type"] = _Hamlib.rig_caps_port_type_get
    if _newclass:port_type = property(_Hamlib.rig_caps_port_type_get, _Hamlib.rig_caps_port_type_set)
    __swig_setmethods__["serial_rate_min"] = _Hamlib.rig_caps_serial_rate_min_set
    __swig_getmethods__["serial_rate_min"] = _Hamlib.rig_caps_serial_rate_min_get
    if _newclass:serial_rate_min = property(_Hamlib.rig_caps_serial_rate_min_get, _Hamlib.rig_caps_serial_rate_min_set)
    __swig_setmethods__["serial_rate_max"] = _Hamlib.rig_caps_serial_rate_max_set
    __swig_getmethods__["serial_rate_max"] = _Hamlib.rig_caps_serial_rate_max_get
    if _newclass:serial_rate_max = property(_Hamlib.rig_caps_serial_rate_max_get, _Hamlib.rig_caps_serial_rate_max_set)
    __swig_setmethods__["serial_data_bits"] = _Hamlib.rig_caps_serial_data_bits_set
    __swig_getmethods__["serial_data_bits"] = _Hamlib.rig_caps_serial_data_bits_get
    if _newclass:serial_data_bits = property(_Hamlib.rig_caps_serial_data_bits_get, _Hamlib.rig_caps_serial_data_bits_set)
    __swig_setmethods__["serial_stop_bits"] = _Hamlib.rig_caps_serial_stop_bits_set
    __swig_getmethods__["serial_stop_bits"] = _Hamlib.rig_caps_serial_stop_bits_get
    if _newclass:serial_stop_bits = property(_Hamlib.rig_caps_serial_stop_bits_get, _Hamlib.rig_caps_serial_stop_bits_set)
    __swig_setmethods__["serial_parity"] = _Hamlib.rig_caps_serial_parity_set
    __swig_getmethods__["serial_parity"] = _Hamlib.rig_caps_serial_parity_get
    if _newclass:serial_parity = property(_Hamlib.rig_caps_serial_parity_get, _Hamlib.rig_caps_serial_parity_set)
    __swig_setmethods__["serial_handshake"] = _Hamlib.rig_caps_serial_handshake_set
    __swig_getmethods__["serial_handshake"] = _Hamlib.rig_caps_serial_handshake_get
    if _newclass:serial_handshake = property(_Hamlib.rig_caps_serial_handshake_get, _Hamlib.rig_caps_serial_handshake_set)
    __swig_setmethods__["write_delay"] = _Hamlib.rig_caps_write_delay_set
    __swig_getmethods__["write_delay"] = _Hamlib.rig_caps_write_delay_get
    if _newclass:write_delay = property(_Hamlib.rig_caps_write_delay_get, _Hamlib.rig_caps_write_delay_set)
    __swig_setmethods__["post_write_delay"] = _Hamlib.rig_caps_post_write_delay_set
    __swig_getmethods__["post_write_delay"] = _Hamlib.rig_caps_post_write_delay_get
    if _newclass:post_write_delay = property(_Hamlib.rig_caps_post_write_delay_get, _Hamlib.rig_caps_post_write_delay_set)
    __swig_setmethods__["timeout"] = _Hamlib.rig_caps_timeout_set
    __swig_getmethods__["timeout"] = _Hamlib.rig_caps_timeout_get
    if _newclass:timeout = property(_Hamlib.rig_caps_timeout_get, _Hamlib.rig_caps_timeout_set)
    __swig_setmethods__["retry"] = _Hamlib.rig_caps_retry_set
    __swig_getmethods__["retry"] = _Hamlib.rig_caps_retry_get
    if _newclass:retry = property(_Hamlib.rig_caps_retry_get, _Hamlib.rig_caps_retry_set)
    __swig_setmethods__["has_get_func"] = _Hamlib.rig_caps_has_get_func_set
    __swig_getmethods__["has_get_func"] = _Hamlib.rig_caps_has_get_func_get
    if _newclass:has_get_func = property(_Hamlib.rig_caps_has_get_func_get, _Hamlib.rig_caps_has_get_func_set)
    __swig_setmethods__["has_set_func"] = _Hamlib.rig_caps_has_set_func_set
    __swig_getmethods__["has_set_func"] = _Hamlib.rig_caps_has_set_func_get
    if _newclass:has_set_func = property(_Hamlib.rig_caps_has_set_func_get, _Hamlib.rig_caps_has_set_func_set)
    __swig_setmethods__["has_get_level"] = _Hamlib.rig_caps_has_get_level_set
    __swig_getmethods__["has_get_level"] = _Hamlib.rig_caps_has_get_level_get
    if _newclass:has_get_level = property(_Hamlib.rig_caps_has_get_level_get, _Hamlib.rig_caps_has_get_level_set)
    __swig_setmethods__["has_set_level"] = _Hamlib.rig_caps_has_set_level_set
    __swig_getmethods__["has_set_level"] = _Hamlib.rig_caps_has_set_level_get
    if _newclass:has_set_level = property(_Hamlib.rig_caps_has_set_level_get, _Hamlib.rig_caps_has_set_level_set)
    __swig_setmethods__["has_get_parm"] = _Hamlib.rig_caps_has_get_parm_set
    __swig_getmethods__["has_get_parm"] = _Hamlib.rig_caps_has_get_parm_get
    if _newclass:has_get_parm = property(_Hamlib.rig_caps_has_get_parm_get, _Hamlib.rig_caps_has_get_parm_set)
    __swig_setmethods__["has_set_parm"] = _Hamlib.rig_caps_has_set_parm_set
    __swig_getmethods__["has_set_parm"] = _Hamlib.rig_caps_has_set_parm_get
    if _newclass:has_set_parm = property(_Hamlib.rig_caps_has_set_parm_get, _Hamlib.rig_caps_has_set_parm_set)
    __swig_setmethods__["level_gran"] = _Hamlib.rig_caps_level_gran_set
    __swig_getmethods__["level_gran"] = _Hamlib.rig_caps_level_gran_get
    if _newclass:level_gran = property(_Hamlib.rig_caps_level_gran_get, _Hamlib.rig_caps_level_gran_set)
    __swig_setmethods__["parm_gran"] = _Hamlib.rig_caps_parm_gran_set
    __swig_getmethods__["parm_gran"] = _Hamlib.rig_caps_parm_gran_get
    if _newclass:parm_gran = property(_Hamlib.rig_caps_parm_gran_get, _Hamlib.rig_caps_parm_gran_set)
    __swig_setmethods__["extparms"] = _Hamlib.rig_caps_extparms_set
    __swig_getmethods__["extparms"] = _Hamlib.rig_caps_extparms_get
    if _newclass:extparms = property(_Hamlib.rig_caps_extparms_get, _Hamlib.rig_caps_extparms_set)
    __swig_setmethods__["extlevels"] = _Hamlib.rig_caps_extlevels_set
    __swig_getmethods__["extlevels"] = _Hamlib.rig_caps_extlevels_get
    if _newclass:extlevels = property(_Hamlib.rig_caps_extlevels_get, _Hamlib.rig_caps_extlevels_set)
    __swig_setmethods__["ctcss_list"] = _Hamlib.rig_caps_ctcss_list_set
    __swig_getmethods__["ctcss_list"] = _Hamlib.rig_caps_ctcss_list_get
    if _newclass:ctcss_list = property(_Hamlib.rig_caps_ctcss_list_get, _Hamlib.rig_caps_ctcss_list_set)
    __swig_setmethods__["dcs_list"] = _Hamlib.rig_caps_dcs_list_set
    __swig_getmethods__["dcs_list"] = _Hamlib.rig_caps_dcs_list_get
    if _newclass:dcs_list = property(_Hamlib.rig_caps_dcs_list_get, _Hamlib.rig_caps_dcs_list_set)
    __swig_setmethods__["preamp"] = _Hamlib.rig_caps_preamp_set
    __swig_getmethods__["preamp"] = _Hamlib.rig_caps_preamp_get
    if _newclass:preamp = property(_Hamlib.rig_caps_preamp_get, _Hamlib.rig_caps_preamp_set)
    __swig_setmethods__["attenuator"] = _Hamlib.rig_caps_attenuator_set
    __swig_getmethods__["attenuator"] = _Hamlib.rig_caps_attenuator_get
    if _newclass:attenuator = property(_Hamlib.rig_caps_attenuator_get, _Hamlib.rig_caps_attenuator_set)
    __swig_setmethods__["max_rit"] = _Hamlib.rig_caps_max_rit_set
    __swig_getmethods__["max_rit"] = _Hamlib.rig_caps_max_rit_get
    if _newclass:max_rit = property(_Hamlib.rig_caps_max_rit_get, _Hamlib.rig_caps_max_rit_set)
    __swig_setmethods__["max_xit"] = _Hamlib.rig_caps_max_xit_set
    __swig_getmethods__["max_xit"] = _Hamlib.rig_caps_max_xit_get
    if _newclass:max_xit = property(_Hamlib.rig_caps_max_xit_get, _Hamlib.rig_caps_max_xit_set)
    __swig_setmethods__["max_ifshift"] = _Hamlib.rig_caps_max_ifshift_set
    __swig_getmethods__["max_ifshift"] = _Hamlib.rig_caps_max_ifshift_get
    if _newclass:max_ifshift = property(_Hamlib.rig_caps_max_ifshift_get, _Hamlib.rig_caps_max_ifshift_set)
    __swig_setmethods__["announces"] = _Hamlib.rig_caps_announces_set
    __swig_getmethods__["announces"] = _Hamlib.rig_caps_announces_get
    if _newclass:announces = property(_Hamlib.rig_caps_announces_get, _Hamlib.rig_caps_announces_set)
    __swig_setmethods__["vfo_ops"] = _Hamlib.rig_caps_vfo_ops_set
    __swig_getmethods__["vfo_ops"] = _Hamlib.rig_caps_vfo_ops_get
    if _newclass:vfo_ops = property(_Hamlib.rig_caps_vfo_ops_get, _Hamlib.rig_caps_vfo_ops_set)
    __swig_setmethods__["scan_ops"] = _Hamlib.rig_caps_scan_ops_set
    __swig_getmethods__["scan_ops"] = _Hamlib.rig_caps_scan_ops_get
    if _newclass:scan_ops = property(_Hamlib.rig_caps_scan_ops_get, _Hamlib.rig_caps_scan_ops_set)
    __swig_setmethods__["targetable_vfo"] = _Hamlib.rig_caps_targetable_vfo_set
    __swig_getmethods__["targetable_vfo"] = _Hamlib.rig_caps_targetable_vfo_get
    if _newclass:targetable_vfo = property(_Hamlib.rig_caps_targetable_vfo_get, _Hamlib.rig_caps_targetable_vfo_set)
    __swig_setmethods__["transceive"] = _Hamlib.rig_caps_transceive_set
    __swig_getmethods__["transceive"] = _Hamlib.rig_caps_transceive_get
    if _newclass:transceive = property(_Hamlib.rig_caps_transceive_get, _Hamlib.rig_caps_transceive_set)
    __swig_setmethods__["bank_qty"] = _Hamlib.rig_caps_bank_qty_set
    __swig_getmethods__["bank_qty"] = _Hamlib.rig_caps_bank_qty_get
    if _newclass:bank_qty = property(_Hamlib.rig_caps_bank_qty_get, _Hamlib.rig_caps_bank_qty_set)
    __swig_setmethods__["chan_desc_sz"] = _Hamlib.rig_caps_chan_desc_sz_set
    __swig_getmethods__["chan_desc_sz"] = _Hamlib.rig_caps_chan_desc_sz_get
    if _newclass:chan_desc_sz = property(_Hamlib.rig_caps_chan_desc_sz_get, _Hamlib.rig_caps_chan_desc_sz_set)
    __swig_setmethods__["chan_list"] = _Hamlib.rig_caps_chan_list_set
    __swig_getmethods__["chan_list"] = _Hamlib.rig_caps_chan_list_get
    if _newclass:chan_list = property(_Hamlib.rig_caps_chan_list_get, _Hamlib.rig_caps_chan_list_set)
    __swig_setmethods__["rx_range_list1"] = _Hamlib.rig_caps_rx_range_list1_set
    __swig_getmethods__["rx_range_list1"] = _Hamlib.rig_caps_rx_range_list1_get
    if _newclass:rx_range_list1 = property(_Hamlib.rig_caps_rx_range_list1_get, _Hamlib.rig_caps_rx_range_list1_set)
    __swig_setmethods__["tx_range_list1"] = _Hamlib.rig_caps_tx_range_list1_set
    __swig_getmethods__["tx_range_list1"] = _Hamlib.rig_caps_tx_range_list1_get
    if _newclass:tx_range_list1 = property(_Hamlib.rig_caps_tx_range_list1_get, _Hamlib.rig_caps_tx_range_list1_set)
    __swig_setmethods__["rx_range_list2"] = _Hamlib.rig_caps_rx_range_list2_set
    __swig_getmethods__["rx_range_list2"] = _Hamlib.rig_caps_rx_range_list2_get
    if _newclass:rx_range_list2 = property(_Hamlib.rig_caps_rx_range_list2_get, _Hamlib.rig_caps_rx_range_list2_set)
    __swig_setmethods__["tx_range_list2"] = _Hamlib.rig_caps_tx_range_list2_set
    __swig_getmethods__["tx_range_list2"] = _Hamlib.rig_caps_tx_range_list2_get
    if _newclass:tx_range_list2 = property(_Hamlib.rig_caps_tx_range_list2_get, _Hamlib.rig_caps_tx_range_list2_set)
    __swig_setmethods__["tuning_steps"] = _Hamlib.rig_caps_tuning_steps_set
    __swig_getmethods__["tuning_steps"] = _Hamlib.rig_caps_tuning_steps_get
    if _newclass:tuning_steps = property(_Hamlib.rig_caps_tuning_steps_get, _Hamlib.rig_caps_tuning_steps_set)
    __swig_setmethods__["filters"] = _Hamlib.rig_caps_filters_set
    __swig_getmethods__["filters"] = _Hamlib.rig_caps_filters_get
    if _newclass:filters = property(_Hamlib.rig_caps_filters_get, _Hamlib.rig_caps_filters_set)
    __swig_setmethods__["str_cal"] = _Hamlib.rig_caps_str_cal_set
    __swig_getmethods__["str_cal"] = _Hamlib.rig_caps_str_cal_get
    if _newclass:str_cal = property(_Hamlib.rig_caps_str_cal_get, _Hamlib.rig_caps_str_cal_set)
    __swig_setmethods__["cfgparams"] = _Hamlib.rig_caps_cfgparams_set
    __swig_getmethods__["cfgparams"] = _Hamlib.rig_caps_cfgparams_get
    if _newclass:cfgparams = property(_Hamlib.rig_caps_cfgparams_get, _Hamlib.rig_caps_cfgparams_set)
    __swig_setmethods__["priv"] = _Hamlib.rig_caps_priv_set
    __swig_getmethods__["priv"] = _Hamlib.rig_caps_priv_get
    if _newclass:priv = property(_Hamlib.rig_caps_priv_get, _Hamlib.rig_caps_priv_set)
    __swig_setmethods__["rig_init"] = _Hamlib.rig_caps_rig_init_set
    __swig_getmethods__["rig_init"] = _Hamlib.rig_caps_rig_init_get
    if _newclass:rig_init = property(_Hamlib.rig_caps_rig_init_get, _Hamlib.rig_caps_rig_init_set)
    __swig_setmethods__["set_freq"] = _Hamlib.rig_caps_set_freq_set
    __swig_getmethods__["set_freq"] = _Hamlib.rig_caps_set_freq_get
    if _newclass:set_freq = property(_Hamlib.rig_caps_set_freq_get, _Hamlib.rig_caps_set_freq_set)
    __swig_setmethods__["get_freq"] = _Hamlib.rig_caps_get_freq_set
    __swig_getmethods__["get_freq"] = _Hamlib.rig_caps_get_freq_get
    if _newclass:get_freq = property(_Hamlib.rig_caps_get_freq_get, _Hamlib.rig_caps_get_freq_set)
    __swig_setmethods__["set_mode"] = _Hamlib.rig_caps_set_mode_set
    __swig_getmethods__["set_mode"] = _Hamlib.rig_caps_set_mode_get
    if _newclass:set_mode = property(_Hamlib.rig_caps_set_mode_get, _Hamlib.rig_caps_set_mode_set)
    __swig_setmethods__["get_mode"] = _Hamlib.rig_caps_get_mode_set
    __swig_getmethods__["get_mode"] = _Hamlib.rig_caps_get_mode_get
    if _newclass:get_mode = property(_Hamlib.rig_caps_get_mode_get, _Hamlib.rig_caps_get_mode_set)
    __swig_setmethods__["set_vfo"] = _Hamlib.rig_caps_set_vfo_set
    __swig_getmethods__["set_vfo"] = _Hamlib.rig_caps_set_vfo_get
    if _newclass:set_vfo = property(_Hamlib.rig_caps_set_vfo_get, _Hamlib.rig_caps_set_vfo_set)
    __swig_setmethods__["get_vfo"] = _Hamlib.rig_caps_get_vfo_set
    __swig_getmethods__["get_vfo"] = _Hamlib.rig_caps_get_vfo_get
    if _newclass:get_vfo = property(_Hamlib.rig_caps_get_vfo_get, _Hamlib.rig_caps_get_vfo_set)
    __swig_setmethods__["set_ptt"] = _Hamlib.rig_caps_set_ptt_set
    __swig_getmethods__["set_ptt"] = _Hamlib.rig_caps_set_ptt_get
    if _newclass:set_ptt = property(_Hamlib.rig_caps_set_ptt_get, _Hamlib.rig_caps_set_ptt_set)
    __swig_setmethods__["get_ptt"] = _Hamlib.rig_caps_get_ptt_set
    __swig_getmethods__["get_ptt"] = _Hamlib.rig_caps_get_ptt_get
    if _newclass:get_ptt = property(_Hamlib.rig_caps_get_ptt_get, _Hamlib.rig_caps_get_ptt_set)
    __swig_setmethods__["get_dcd"] = _Hamlib.rig_caps_get_dcd_set
    __swig_getmethods__["get_dcd"] = _Hamlib.rig_caps_get_dcd_get
    if _newclass:get_dcd = property(_Hamlib.rig_caps_get_dcd_get, _Hamlib.rig_caps_get_dcd_set)
    __swig_setmethods__["set_rptr_shift"] = _Hamlib.rig_caps_set_rptr_shift_set
    __swig_getmethods__["set_rptr_shift"] = _Hamlib.rig_caps_set_rptr_shift_get
    if _newclass:set_rptr_shift = property(_Hamlib.rig_caps_set_rptr_shift_get, _Hamlib.rig_caps_set_rptr_shift_set)
    __swig_setmethods__["get_rptr_shift"] = _Hamlib.rig_caps_get_rptr_shift_set
    __swig_getmethods__["get_rptr_shift"] = _Hamlib.rig_caps_get_rptr_shift_get
    if _newclass:get_rptr_shift = property(_Hamlib.rig_caps_get_rptr_shift_get, _Hamlib.rig_caps_get_rptr_shift_set)
    __swig_setmethods__["set_rptr_offs"] = _Hamlib.rig_caps_set_rptr_offs_set
    __swig_getmethods__["set_rptr_offs"] = _Hamlib.rig_caps_set_rptr_offs_get
    if _newclass:set_rptr_offs = property(_Hamlib.rig_caps_set_rptr_offs_get, _Hamlib.rig_caps_set_rptr_offs_set)
    __swig_setmethods__["get_rptr_offs"] = _Hamlib.rig_caps_get_rptr_offs_set
    __swig_getmethods__["get_rptr_offs"] = _Hamlib.rig_caps_get_rptr_offs_get
    if _newclass:get_rptr_offs = property(_Hamlib.rig_caps_get_rptr_offs_get, _Hamlib.rig_caps_get_rptr_offs_set)
    __swig_setmethods__["set_split_freq"] = _Hamlib.rig_caps_set_split_freq_set
    __swig_getmethods__["set_split_freq"] = _Hamlib.rig_caps_set_split_freq_get
    if _newclass:set_split_freq = property(_Hamlib.rig_caps_set_split_freq_get, _Hamlib.rig_caps_set_split_freq_set)
    __swig_setmethods__["get_split_freq"] = _Hamlib.rig_caps_get_split_freq_set
    __swig_getmethods__["get_split_freq"] = _Hamlib.rig_caps_get_split_freq_get
    if _newclass:get_split_freq = property(_Hamlib.rig_caps_get_split_freq_get, _Hamlib.rig_caps_get_split_freq_set)
    __swig_setmethods__["set_split_mode"] = _Hamlib.rig_caps_set_split_mode_set
    __swig_getmethods__["set_split_mode"] = _Hamlib.rig_caps_set_split_mode_get
    if _newclass:set_split_mode = property(_Hamlib.rig_caps_set_split_mode_get, _Hamlib.rig_caps_set_split_mode_set)
    __swig_setmethods__["get_split_mode"] = _Hamlib.rig_caps_get_split_mode_set
    __swig_getmethods__["get_split_mode"] = _Hamlib.rig_caps_get_split_mode_get
    if _newclass:get_split_mode = property(_Hamlib.rig_caps_get_split_mode_get, _Hamlib.rig_caps_get_split_mode_set)
    __swig_setmethods__["set_split_vfo"] = _Hamlib.rig_caps_set_split_vfo_set
    __swig_getmethods__["set_split_vfo"] = _Hamlib.rig_caps_set_split_vfo_get
    if _newclass:set_split_vfo = property(_Hamlib.rig_caps_set_split_vfo_get, _Hamlib.rig_caps_set_split_vfo_set)
    __swig_setmethods__["get_split_vfo"] = _Hamlib.rig_caps_get_split_vfo_set
    __swig_getmethods__["get_split_vfo"] = _Hamlib.rig_caps_get_split_vfo_get
    if _newclass:get_split_vfo = property(_Hamlib.rig_caps_get_split_vfo_get, _Hamlib.rig_caps_get_split_vfo_set)
    __swig_setmethods__["set_rit"] = _Hamlib.rig_caps_set_rit_set
    __swig_getmethods__["set_rit"] = _Hamlib.rig_caps_set_rit_get
    if _newclass:set_rit = property(_Hamlib.rig_caps_set_rit_get, _Hamlib.rig_caps_set_rit_set)
    __swig_setmethods__["get_rit"] = _Hamlib.rig_caps_get_rit_set
    __swig_getmethods__["get_rit"] = _Hamlib.rig_caps_get_rit_get
    if _newclass:get_rit = property(_Hamlib.rig_caps_get_rit_get, _Hamlib.rig_caps_get_rit_set)
    __swig_setmethods__["set_xit"] = _Hamlib.rig_caps_set_xit_set
    __swig_getmethods__["set_xit"] = _Hamlib.rig_caps_set_xit_get
    if _newclass:set_xit = property(_Hamlib.rig_caps_set_xit_get, _Hamlib.rig_caps_set_xit_set)
    __swig_setmethods__["get_xit"] = _Hamlib.rig_caps_get_xit_set
    __swig_getmethods__["get_xit"] = _Hamlib.rig_caps_get_xit_get
    if _newclass:get_xit = property(_Hamlib.rig_caps_get_xit_get, _Hamlib.rig_caps_get_xit_set)
    __swig_setmethods__["set_ts"] = _Hamlib.rig_caps_set_ts_set
    __swig_getmethods__["set_ts"] = _Hamlib.rig_caps_set_ts_get
    if _newclass:set_ts = property(_Hamlib.rig_caps_set_ts_get, _Hamlib.rig_caps_set_ts_set)
    __swig_setmethods__["get_ts"] = _Hamlib.rig_caps_get_ts_set
    __swig_getmethods__["get_ts"] = _Hamlib.rig_caps_get_ts_get
    if _newclass:get_ts = property(_Hamlib.rig_caps_get_ts_get, _Hamlib.rig_caps_get_ts_set)
    __swig_setmethods__["set_dcs_code"] = _Hamlib.rig_caps_set_dcs_code_set
    __swig_getmethods__["set_dcs_code"] = _Hamlib.rig_caps_set_dcs_code_get
    if _newclass:set_dcs_code = property(_Hamlib.rig_caps_set_dcs_code_get, _Hamlib.rig_caps_set_dcs_code_set)
    __swig_setmethods__["get_dcs_code"] = _Hamlib.rig_caps_get_dcs_code_set
    __swig_getmethods__["get_dcs_code"] = _Hamlib.rig_caps_get_dcs_code_get
    if _newclass:get_dcs_code = property(_Hamlib.rig_caps_get_dcs_code_get, _Hamlib.rig_caps_get_dcs_code_set)
    __swig_setmethods__["set_tone"] = _Hamlib.rig_caps_set_tone_set
    __swig_getmethods__["set_tone"] = _Hamlib.rig_caps_set_tone_get
    if _newclass:set_tone = property(_Hamlib.rig_caps_set_tone_get, _Hamlib.rig_caps_set_tone_set)
    __swig_setmethods__["get_tone"] = _Hamlib.rig_caps_get_tone_set
    __swig_getmethods__["get_tone"] = _Hamlib.rig_caps_get_tone_get
    if _newclass:get_tone = property(_Hamlib.rig_caps_get_tone_get, _Hamlib.rig_caps_get_tone_set)
    __swig_setmethods__["set_ctcss_tone"] = _Hamlib.rig_caps_set_ctcss_tone_set
    __swig_getmethods__["set_ctcss_tone"] = _Hamlib.rig_caps_set_ctcss_tone_get
    if _newclass:set_ctcss_tone = property(_Hamlib.rig_caps_set_ctcss_tone_get, _Hamlib.rig_caps_set_ctcss_tone_set)
    __swig_setmethods__["get_ctcss_tone"] = _Hamlib.rig_caps_get_ctcss_tone_set
    __swig_getmethods__["get_ctcss_tone"] = _Hamlib.rig_caps_get_ctcss_tone_get
    if _newclass:get_ctcss_tone = property(_Hamlib.rig_caps_get_ctcss_tone_get, _Hamlib.rig_caps_get_ctcss_tone_set)
    __swig_setmethods__["set_dcs_sql"] = _Hamlib.rig_caps_set_dcs_sql_set
    __swig_getmethods__["set_dcs_sql"] = _Hamlib.rig_caps_set_dcs_sql_get
    if _newclass:set_dcs_sql = property(_Hamlib.rig_caps_set_dcs_sql_get, _Hamlib.rig_caps_set_dcs_sql_set)
    __swig_setmethods__["get_dcs_sql"] = _Hamlib.rig_caps_get_dcs_sql_set
    __swig_getmethods__["get_dcs_sql"] = _Hamlib.rig_caps_get_dcs_sql_get
    if _newclass:get_dcs_sql = property(_Hamlib.rig_caps_get_dcs_sql_get, _Hamlib.rig_caps_get_dcs_sql_set)
    __swig_setmethods__["set_tone_sql"] = _Hamlib.rig_caps_set_tone_sql_set
    __swig_getmethods__["set_tone_sql"] = _Hamlib.rig_caps_set_tone_sql_get
    if _newclass:set_tone_sql = property(_Hamlib.rig_caps_set_tone_sql_get, _Hamlib.rig_caps_set_tone_sql_set)
    __swig_setmethods__["get_tone_sql"] = _Hamlib.rig_caps_get_tone_sql_set
    __swig_getmethods__["get_tone_sql"] = _Hamlib.rig_caps_get_tone_sql_get
    if _newclass:get_tone_sql = property(_Hamlib.rig_caps_get_tone_sql_get, _Hamlib.rig_caps_get_tone_sql_set)
    __swig_setmethods__["set_ctcss_sql"] = _Hamlib.rig_caps_set_ctcss_sql_set
    __swig_getmethods__["set_ctcss_sql"] = _Hamlib.rig_caps_set_ctcss_sql_get
    if _newclass:set_ctcss_sql = property(_Hamlib.rig_caps_set_ctcss_sql_get, _Hamlib.rig_caps_set_ctcss_sql_set)
    __swig_setmethods__["get_ctcss_sql"] = _Hamlib.rig_caps_get_ctcss_sql_set
    __swig_getmethods__["get_ctcss_sql"] = _Hamlib.rig_caps_get_ctcss_sql_get
    if _newclass:get_ctcss_sql = property(_Hamlib.rig_caps_get_ctcss_sql_get, _Hamlib.rig_caps_get_ctcss_sql_set)
    __swig_setmethods__["power2mW"] = _Hamlib.rig_caps_power2mW_set
    __swig_getmethods__["power2mW"] = _Hamlib.rig_caps_power2mW_get
    if _newclass:power2mW = property(_Hamlib.rig_caps_power2mW_get, _Hamlib.rig_caps_power2mW_set)
    __swig_setmethods__["mW2power"] = _Hamlib.rig_caps_mW2power_set
    __swig_getmethods__["mW2power"] = _Hamlib.rig_caps_mW2power_get
    if _newclass:mW2power = property(_Hamlib.rig_caps_mW2power_get, _Hamlib.rig_caps_mW2power_set)
    __swig_setmethods__["set_powerstat"] = _Hamlib.rig_caps_set_powerstat_set
    __swig_getmethods__["set_powerstat"] = _Hamlib.rig_caps_set_powerstat_get
    if _newclass:set_powerstat = property(_Hamlib.rig_caps_set_powerstat_get, _Hamlib.rig_caps_set_powerstat_set)
    __swig_setmethods__["get_powerstat"] = _Hamlib.rig_caps_get_powerstat_set
    __swig_getmethods__["get_powerstat"] = _Hamlib.rig_caps_get_powerstat_get
    if _newclass:get_powerstat = property(_Hamlib.rig_caps_get_powerstat_get, _Hamlib.rig_caps_get_powerstat_set)
    __swig_setmethods__["reset"] = _Hamlib.rig_caps_reset_set
    __swig_getmethods__["reset"] = _Hamlib.rig_caps_reset_get
    if _newclass:reset = property(_Hamlib.rig_caps_reset_get, _Hamlib.rig_caps_reset_set)
    __swig_setmethods__["set_ant"] = _Hamlib.rig_caps_set_ant_set
    __swig_getmethods__["set_ant"] = _Hamlib.rig_caps_set_ant_get
    if _newclass:set_ant = property(_Hamlib.rig_caps_set_ant_get, _Hamlib.rig_caps_set_ant_set)
    __swig_setmethods__["get_ant"] = _Hamlib.rig_caps_get_ant_set
    __swig_getmethods__["get_ant"] = _Hamlib.rig_caps_get_ant_get
    if _newclass:get_ant = property(_Hamlib.rig_caps_get_ant_get, _Hamlib.rig_caps_get_ant_set)
    __swig_setmethods__["set_level"] = _Hamlib.rig_caps_set_level_set
    __swig_getmethods__["set_level"] = _Hamlib.rig_caps_set_level_get
    if _newclass:set_level = property(_Hamlib.rig_caps_set_level_get, _Hamlib.rig_caps_set_level_set)
    __swig_setmethods__["get_level"] = _Hamlib.rig_caps_get_level_set
    __swig_getmethods__["get_level"] = _Hamlib.rig_caps_get_level_get
    if _newclass:get_level = property(_Hamlib.rig_caps_get_level_get, _Hamlib.rig_caps_get_level_set)
    __swig_setmethods__["set_func"] = _Hamlib.rig_caps_set_func_set
    __swig_getmethods__["set_func"] = _Hamlib.rig_caps_set_func_get
    if _newclass:set_func = property(_Hamlib.rig_caps_set_func_get, _Hamlib.rig_caps_set_func_set)
    __swig_setmethods__["get_func"] = _Hamlib.rig_caps_get_func_set
    __swig_getmethods__["get_func"] = _Hamlib.rig_caps_get_func_get
    if _newclass:get_func = property(_Hamlib.rig_caps_get_func_get, _Hamlib.rig_caps_get_func_set)
    __swig_setmethods__["set_parm"] = _Hamlib.rig_caps_set_parm_set
    __swig_getmethods__["set_parm"] = _Hamlib.rig_caps_set_parm_get
    if _newclass:set_parm = property(_Hamlib.rig_caps_set_parm_get, _Hamlib.rig_caps_set_parm_set)
    __swig_setmethods__["get_parm"] = _Hamlib.rig_caps_get_parm_set
    __swig_getmethods__["get_parm"] = _Hamlib.rig_caps_get_parm_get
    if _newclass:get_parm = property(_Hamlib.rig_caps_get_parm_get, _Hamlib.rig_caps_get_parm_set)
    __swig_setmethods__["set_ext_level"] = _Hamlib.rig_caps_set_ext_level_set
    __swig_getmethods__["set_ext_level"] = _Hamlib.rig_caps_set_ext_level_get
    if _newclass:set_ext_level = property(_Hamlib.rig_caps_set_ext_level_get, _Hamlib.rig_caps_set_ext_level_set)
    __swig_setmethods__["get_ext_level"] = _Hamlib.rig_caps_get_ext_level_set
    __swig_getmethods__["get_ext_level"] = _Hamlib.rig_caps_get_ext_level_get
    if _newclass:get_ext_level = property(_Hamlib.rig_caps_get_ext_level_get, _Hamlib.rig_caps_get_ext_level_set)
    __swig_setmethods__["set_ext_parm"] = _Hamlib.rig_caps_set_ext_parm_set
    __swig_getmethods__["set_ext_parm"] = _Hamlib.rig_caps_set_ext_parm_get
    if _newclass:set_ext_parm = property(_Hamlib.rig_caps_set_ext_parm_get, _Hamlib.rig_caps_set_ext_parm_set)
    __swig_setmethods__["get_ext_parm"] = _Hamlib.rig_caps_get_ext_parm_set
    __swig_getmethods__["get_ext_parm"] = _Hamlib.rig_caps_get_ext_parm_get
    if _newclass:get_ext_parm = property(_Hamlib.rig_caps_get_ext_parm_get, _Hamlib.rig_caps_get_ext_parm_set)
    __swig_setmethods__["set_conf"] = _Hamlib.rig_caps_set_conf_set
    __swig_getmethods__["set_conf"] = _Hamlib.rig_caps_set_conf_get
    if _newclass:set_conf = property(_Hamlib.rig_caps_set_conf_get, _Hamlib.rig_caps_set_conf_set)
    __swig_setmethods__["get_conf"] = _Hamlib.rig_caps_get_conf_set
    __swig_getmethods__["get_conf"] = _Hamlib.rig_caps_get_conf_get
    if _newclass:get_conf = property(_Hamlib.rig_caps_get_conf_get, _Hamlib.rig_caps_get_conf_set)
    __swig_setmethods__["send_dtmf"] = _Hamlib.rig_caps_send_dtmf_set
    __swig_getmethods__["send_dtmf"] = _Hamlib.rig_caps_send_dtmf_get
    if _newclass:send_dtmf = property(_Hamlib.rig_caps_send_dtmf_get, _Hamlib.rig_caps_send_dtmf_set)
    __swig_setmethods__["recv_dtmf"] = _Hamlib.rig_caps_recv_dtmf_set
    __swig_getmethods__["recv_dtmf"] = _Hamlib.rig_caps_recv_dtmf_get
    if _newclass:recv_dtmf = property(_Hamlib.rig_caps_recv_dtmf_get, _Hamlib.rig_caps_recv_dtmf_set)
    __swig_setmethods__["send_morse"] = _Hamlib.rig_caps_send_morse_set
    __swig_getmethods__["send_morse"] = _Hamlib.rig_caps_send_morse_get
    if _newclass:send_morse = property(_Hamlib.rig_caps_send_morse_get, _Hamlib.rig_caps_send_morse_set)
    __swig_setmethods__["set_bank"] = _Hamlib.rig_caps_set_bank_set
    __swig_getmethods__["set_bank"] = _Hamlib.rig_caps_set_bank_get
    if _newclass:set_bank = property(_Hamlib.rig_caps_set_bank_get, _Hamlib.rig_caps_set_bank_set)
    __swig_setmethods__["set_mem"] = _Hamlib.rig_caps_set_mem_set
    __swig_getmethods__["set_mem"] = _Hamlib.rig_caps_set_mem_get
    if _newclass:set_mem = property(_Hamlib.rig_caps_set_mem_get, _Hamlib.rig_caps_set_mem_set)
    __swig_setmethods__["get_mem"] = _Hamlib.rig_caps_get_mem_set
    __swig_getmethods__["get_mem"] = _Hamlib.rig_caps_get_mem_get
    if _newclass:get_mem = property(_Hamlib.rig_caps_get_mem_get, _Hamlib.rig_caps_get_mem_set)
    __swig_setmethods__["vfo_op"] = _Hamlib.rig_caps_vfo_op_set
    __swig_getmethods__["vfo_op"] = _Hamlib.rig_caps_vfo_op_get
    if _newclass:vfo_op = property(_Hamlib.rig_caps_vfo_op_get, _Hamlib.rig_caps_vfo_op_set)
    __swig_setmethods__["scan"] = _Hamlib.rig_caps_scan_set
    __swig_getmethods__["scan"] = _Hamlib.rig_caps_scan_get
    if _newclass:scan = property(_Hamlib.rig_caps_scan_get, _Hamlib.rig_caps_scan_set)
    __swig_setmethods__["set_trn"] = _Hamlib.rig_caps_set_trn_set
    __swig_getmethods__["set_trn"] = _Hamlib.rig_caps_set_trn_get
    if _newclass:set_trn = property(_Hamlib.rig_caps_set_trn_get, _Hamlib.rig_caps_set_trn_set)
    __swig_setmethods__["get_trn"] = _Hamlib.rig_caps_get_trn_set
    __swig_getmethods__["get_trn"] = _Hamlib.rig_caps_get_trn_get
    if _newclass:get_trn = property(_Hamlib.rig_caps_get_trn_get, _Hamlib.rig_caps_get_trn_set)
    __swig_setmethods__["decode_event"] = _Hamlib.rig_caps_decode_event_set
    __swig_getmethods__["decode_event"] = _Hamlib.rig_caps_decode_event_get
    if _newclass:decode_event = property(_Hamlib.rig_caps_decode_event_get, _Hamlib.rig_caps_decode_event_set)
    __swig_setmethods__["set_channel"] = _Hamlib.rig_caps_set_channel_set
    __swig_getmethods__["set_channel"] = _Hamlib.rig_caps_set_channel_get
    if _newclass:set_channel = property(_Hamlib.rig_caps_set_channel_get, _Hamlib.rig_caps_set_channel_set)
    __swig_setmethods__["get_channel"] = _Hamlib.rig_caps_get_channel_set
    __swig_getmethods__["get_channel"] = _Hamlib.rig_caps_get_channel_get
    if _newclass:get_channel = property(_Hamlib.rig_caps_get_channel_get, _Hamlib.rig_caps_get_channel_set)
    __swig_setmethods__["get_info"] = _Hamlib.rig_caps_get_info_set
    __swig_getmethods__["get_info"] = _Hamlib.rig_caps_get_info_get
    if _newclass:get_info = property(_Hamlib.rig_caps_get_info_get, _Hamlib.rig_caps_get_info_set)
    __swig_setmethods__["set_chan_all_cb"] = _Hamlib.rig_caps_set_chan_all_cb_set
    __swig_getmethods__["set_chan_all_cb"] = _Hamlib.rig_caps_set_chan_all_cb_get
    if _newclass:set_chan_all_cb = property(_Hamlib.rig_caps_set_chan_all_cb_get, _Hamlib.rig_caps_set_chan_all_cb_set)
    __swig_setmethods__["get_chan_all_cb"] = _Hamlib.rig_caps_get_chan_all_cb_set
    __swig_getmethods__["get_chan_all_cb"] = _Hamlib.rig_caps_get_chan_all_cb_get
    if _newclass:get_chan_all_cb = property(_Hamlib.rig_caps_get_chan_all_cb_get, _Hamlib.rig_caps_get_chan_all_cb_set)
    __swig_setmethods__["set_mem_all_cb"] = _Hamlib.rig_caps_set_mem_all_cb_set
    __swig_getmethods__["set_mem_all_cb"] = _Hamlib.rig_caps_set_mem_all_cb_get
    if _newclass:set_mem_all_cb = property(_Hamlib.rig_caps_set_mem_all_cb_get, _Hamlib.rig_caps_set_mem_all_cb_set)
    __swig_setmethods__["get_mem_all_cb"] = _Hamlib.rig_caps_get_mem_all_cb_set
    __swig_getmethods__["get_mem_all_cb"] = _Hamlib.rig_caps_get_mem_all_cb_get
    if _newclass:get_mem_all_cb = property(_Hamlib.rig_caps_get_mem_all_cb_get, _Hamlib.rig_caps_get_mem_all_cb_set)
    __swig_setmethods__["clone_combo_set"] = _Hamlib.rig_caps_clone_combo_set_set
    __swig_getmethods__["clone_combo_set"] = _Hamlib.rig_caps_clone_combo_set_get
    if _newclass:clone_combo_set = property(_Hamlib.rig_caps_clone_combo_set_get, _Hamlib.rig_caps_clone_combo_set_set)
    __swig_setmethods__["clone_combo_get"] = _Hamlib.rig_caps_clone_combo_get_set
    __swig_getmethods__["clone_combo_get"] = _Hamlib.rig_caps_clone_combo_get_get
    if _newclass:clone_combo_get = property(_Hamlib.rig_caps_clone_combo_get_get, _Hamlib.rig_caps_clone_combo_get_set)
    def __init__(self, *args):
        _swig_setattr(self, rig_caps, 'this', _Hamlib.new_rig_caps(*args))
        _swig_setattr(self, rig_caps, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_rig_caps):
        try:
            if self.thisown: destroy(self)
        except: pass


class rig_capsPtr(rig_caps):
    def __init__(self, this):
        _swig_setattr(self, rig_caps, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, rig_caps, 'thisown', 0)
        _swig_setattr(self, rig_caps,self.__class__,rig_caps)
_Hamlib.rig_caps_swigregister(rig_capsPtr)

class hamlib_port_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, hamlib_port_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, hamlib_port_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C hamlib_port_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["fd"] = _Hamlib.hamlib_port_t_fd_set
    __swig_getmethods__["fd"] = _Hamlib.hamlib_port_t_fd_get
    if _newclass:fd = property(_Hamlib.hamlib_port_t_fd_get, _Hamlib.hamlib_port_t_fd_set)
    __swig_setmethods__["handle"] = _Hamlib.hamlib_port_t_handle_set
    __swig_getmethods__["handle"] = _Hamlib.hamlib_port_t_handle_get
    if _newclass:handle = property(_Hamlib.hamlib_port_t_handle_get, _Hamlib.hamlib_port_t_handle_set)
    __swig_setmethods__["write_delay"] = _Hamlib.hamlib_port_t_write_delay_set
    __swig_getmethods__["write_delay"] = _Hamlib.hamlib_port_t_write_delay_get
    if _newclass:write_delay = property(_Hamlib.hamlib_port_t_write_delay_get, _Hamlib.hamlib_port_t_write_delay_set)
    __swig_setmethods__["post_write_delay"] = _Hamlib.hamlib_port_t_post_write_delay_set
    __swig_getmethods__["post_write_delay"] = _Hamlib.hamlib_port_t_post_write_delay_get
    if _newclass:post_write_delay = property(_Hamlib.hamlib_port_t_post_write_delay_get, _Hamlib.hamlib_port_t_post_write_delay_set)
    __swig_setmethods__["timeout"] = _Hamlib.hamlib_port_t_timeout_set
    __swig_getmethods__["timeout"] = _Hamlib.hamlib_port_t_timeout_get
    if _newclass:timeout = property(_Hamlib.hamlib_port_t_timeout_get, _Hamlib.hamlib_port_t_timeout_set)
    __swig_setmethods__["retry"] = _Hamlib.hamlib_port_t_retry_set
    __swig_getmethods__["retry"] = _Hamlib.hamlib_port_t_retry_get
    if _newclass:retry = property(_Hamlib.hamlib_port_t_retry_get, _Hamlib.hamlib_port_t_retry_set)
    __swig_setmethods__["pathname"] = _Hamlib.hamlib_port_t_pathname_set
    __swig_getmethods__["pathname"] = _Hamlib.hamlib_port_t_pathname_get
    if _newclass:pathname = property(_Hamlib.hamlib_port_t_pathname_get, _Hamlib.hamlib_port_t_pathname_set)
    __swig_getmethods__["parm"] = _Hamlib.hamlib_port_t_parm_get
    if _newclass:parm = property(_Hamlib.hamlib_port_t_parm_get)
    __swig_getmethods__["post_write_date"] = _Hamlib.hamlib_port_t_post_write_date_get
    if _newclass:post_write_date = property(_Hamlib.hamlib_port_t_post_write_date_get)
    __swig_getmethods__["type"] = _Hamlib.hamlib_port_t_type_get
    if _newclass:type = property(_Hamlib.hamlib_port_t_type_get)
    def __init__(self, *args):
        _swig_setattr(self, hamlib_port_t, 'this', _Hamlib.new_hamlib_port_t(*args))
        _swig_setattr(self, hamlib_port_t, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_hamlib_port_t):
        try:
            if self.thisown: destroy(self)
        except: pass


class hamlib_port_tPtr(hamlib_port_t):
    def __init__(self, this):
        _swig_setattr(self, hamlib_port_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hamlib_port_t, 'thisown', 0)
        _swig_setattr(self, hamlib_port_t,self.__class__,hamlib_port_t)
_Hamlib.hamlib_port_t_swigregister(hamlib_port_tPtr)

class hamlib_port_t_parm(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, hamlib_port_t_parm, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, hamlib_port_t_parm, name)
    def __repr__(self):
        return "<%s.%s; proxy of C hamlib_port_t_parm instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_getmethods__["usb"] = _Hamlib.hamlib_port_t_parm_usb_get
    if _newclass:usb = property(_Hamlib.hamlib_port_t_parm_usb_get)
    __swig_getmethods__["parallel"] = _Hamlib.hamlib_port_t_parm_parallel_get
    if _newclass:parallel = property(_Hamlib.hamlib_port_t_parm_parallel_get)
    __swig_getmethods__["serial"] = _Hamlib.hamlib_port_t_parm_serial_get
    if _newclass:serial = property(_Hamlib.hamlib_port_t_parm_serial_get)
    def __init__(self, *args):
        _swig_setattr(self, hamlib_port_t_parm, 'this', _Hamlib.new_hamlib_port_t_parm(*args))
        _swig_setattr(self, hamlib_port_t_parm, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_hamlib_port_t_parm):
        try:
            if self.thisown: destroy(self)
        except: pass


class hamlib_port_t_parmPtr(hamlib_port_t_parm):
    def __init__(self, this):
        _swig_setattr(self, hamlib_port_t_parm, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hamlib_port_t_parm, 'thisown', 0)
        _swig_setattr(self, hamlib_port_t_parm,self.__class__,hamlib_port_t_parm)
_Hamlib.hamlib_port_t_parm_swigregister(hamlib_port_t_parmPtr)

class hamlib_port_t_parm_usb(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, hamlib_port_t_parm_usb, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, hamlib_port_t_parm_usb, name)
    def __repr__(self):
        return "<%s.%s; proxy of C hamlib_port_t_parm_usb instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["vid"] = _Hamlib.hamlib_port_t_parm_usb_vid_set
    __swig_getmethods__["vid"] = _Hamlib.hamlib_port_t_parm_usb_vid_get
    if _newclass:vid = property(_Hamlib.hamlib_port_t_parm_usb_vid_get, _Hamlib.hamlib_port_t_parm_usb_vid_set)
    __swig_setmethods__["pid"] = _Hamlib.hamlib_port_t_parm_usb_pid_set
    __swig_getmethods__["pid"] = _Hamlib.hamlib_port_t_parm_usb_pid_get
    if _newclass:pid = property(_Hamlib.hamlib_port_t_parm_usb_pid_get, _Hamlib.hamlib_port_t_parm_usb_pid_set)
    __swig_setmethods__["conf"] = _Hamlib.hamlib_port_t_parm_usb_conf_set
    __swig_getmethods__["conf"] = _Hamlib.hamlib_port_t_parm_usb_conf_get
    if _newclass:conf = property(_Hamlib.hamlib_port_t_parm_usb_conf_get, _Hamlib.hamlib_port_t_parm_usb_conf_set)
    __swig_setmethods__["iface"] = _Hamlib.hamlib_port_t_parm_usb_iface_set
    __swig_getmethods__["iface"] = _Hamlib.hamlib_port_t_parm_usb_iface_get
    if _newclass:iface = property(_Hamlib.hamlib_port_t_parm_usb_iface_get, _Hamlib.hamlib_port_t_parm_usb_iface_set)
    __swig_setmethods__["alt"] = _Hamlib.hamlib_port_t_parm_usb_alt_set
    __swig_getmethods__["alt"] = _Hamlib.hamlib_port_t_parm_usb_alt_get
    if _newclass:alt = property(_Hamlib.hamlib_port_t_parm_usb_alt_get, _Hamlib.hamlib_port_t_parm_usb_alt_set)
    def __init__(self, *args):
        _swig_setattr(self, hamlib_port_t_parm_usb, 'this', _Hamlib.new_hamlib_port_t_parm_usb(*args))
        _swig_setattr(self, hamlib_port_t_parm_usb, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_hamlib_port_t_parm_usb):
        try:
            if self.thisown: destroy(self)
        except: pass


class hamlib_port_t_parm_usbPtr(hamlib_port_t_parm_usb):
    def __init__(self, this):
        _swig_setattr(self, hamlib_port_t_parm_usb, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hamlib_port_t_parm_usb, 'thisown', 0)
        _swig_setattr(self, hamlib_port_t_parm_usb,self.__class__,hamlib_port_t_parm_usb)
_Hamlib.hamlib_port_t_parm_usb_swigregister(hamlib_port_t_parm_usbPtr)

class hamlib_port_t_parm_parallel(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, hamlib_port_t_parm_parallel, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, hamlib_port_t_parm_parallel, name)
    def __repr__(self):
        return "<%s.%s; proxy of C hamlib_port_t_parm_parallel instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["pin"] = _Hamlib.hamlib_port_t_parm_parallel_pin_set
    __swig_getmethods__["pin"] = _Hamlib.hamlib_port_t_parm_parallel_pin_get
    if _newclass:pin = property(_Hamlib.hamlib_port_t_parm_parallel_pin_get, _Hamlib.hamlib_port_t_parm_parallel_pin_set)
    def __init__(self, *args):
        _swig_setattr(self, hamlib_port_t_parm_parallel, 'this', _Hamlib.new_hamlib_port_t_parm_parallel(*args))
        _swig_setattr(self, hamlib_port_t_parm_parallel, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_hamlib_port_t_parm_parallel):
        try:
            if self.thisown: destroy(self)
        except: pass


class hamlib_port_t_parm_parallelPtr(hamlib_port_t_parm_parallel):
    def __init__(self, this):
        _swig_setattr(self, hamlib_port_t_parm_parallel, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hamlib_port_t_parm_parallel, 'thisown', 0)
        _swig_setattr(self, hamlib_port_t_parm_parallel,self.__class__,hamlib_port_t_parm_parallel)
_Hamlib.hamlib_port_t_parm_parallel_swigregister(hamlib_port_t_parm_parallelPtr)

class hamlib_port_t_parm_serial(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, hamlib_port_t_parm_serial, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, hamlib_port_t_parm_serial, name)
    def __repr__(self):
        return "<%s.%s; proxy of C hamlib_port_t_parm_serial instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["rate"] = _Hamlib.hamlib_port_t_parm_serial_rate_set
    __swig_getmethods__["rate"] = _Hamlib.hamlib_port_t_parm_serial_rate_get
    if _newclass:rate = property(_Hamlib.hamlib_port_t_parm_serial_rate_get, _Hamlib.hamlib_port_t_parm_serial_rate_set)
    __swig_setmethods__["data_bits"] = _Hamlib.hamlib_port_t_parm_serial_data_bits_set
    __swig_getmethods__["data_bits"] = _Hamlib.hamlib_port_t_parm_serial_data_bits_get
    if _newclass:data_bits = property(_Hamlib.hamlib_port_t_parm_serial_data_bits_get, _Hamlib.hamlib_port_t_parm_serial_data_bits_set)
    __swig_setmethods__["stop_bits"] = _Hamlib.hamlib_port_t_parm_serial_stop_bits_set
    __swig_getmethods__["stop_bits"] = _Hamlib.hamlib_port_t_parm_serial_stop_bits_get
    if _newclass:stop_bits = property(_Hamlib.hamlib_port_t_parm_serial_stop_bits_get, _Hamlib.hamlib_port_t_parm_serial_stop_bits_set)
    __swig_setmethods__["parity"] = _Hamlib.hamlib_port_t_parm_serial_parity_set
    __swig_getmethods__["parity"] = _Hamlib.hamlib_port_t_parm_serial_parity_get
    if _newclass:parity = property(_Hamlib.hamlib_port_t_parm_serial_parity_get, _Hamlib.hamlib_port_t_parm_serial_parity_set)
    __swig_setmethods__["handshake"] = _Hamlib.hamlib_port_t_parm_serial_handshake_set
    __swig_getmethods__["handshake"] = _Hamlib.hamlib_port_t_parm_serial_handshake_get
    if _newclass:handshake = property(_Hamlib.hamlib_port_t_parm_serial_handshake_get, _Hamlib.hamlib_port_t_parm_serial_handshake_set)
    __swig_setmethods__["rts_state"] = _Hamlib.hamlib_port_t_parm_serial_rts_state_set
    __swig_getmethods__["rts_state"] = _Hamlib.hamlib_port_t_parm_serial_rts_state_get
    if _newclass:rts_state = property(_Hamlib.hamlib_port_t_parm_serial_rts_state_get, _Hamlib.hamlib_port_t_parm_serial_rts_state_set)
    __swig_setmethods__["dtr_state"] = _Hamlib.hamlib_port_t_parm_serial_dtr_state_set
    __swig_getmethods__["dtr_state"] = _Hamlib.hamlib_port_t_parm_serial_dtr_state_get
    if _newclass:dtr_state = property(_Hamlib.hamlib_port_t_parm_serial_dtr_state_get, _Hamlib.hamlib_port_t_parm_serial_dtr_state_set)
    def __init__(self, *args):
        _swig_setattr(self, hamlib_port_t_parm_serial, 'this', _Hamlib.new_hamlib_port_t_parm_serial(*args))
        _swig_setattr(self, hamlib_port_t_parm_serial, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_hamlib_port_t_parm_serial):
        try:
            if self.thisown: destroy(self)
        except: pass


class hamlib_port_t_parm_serialPtr(hamlib_port_t_parm_serial):
    def __init__(self, this):
        _swig_setattr(self, hamlib_port_t_parm_serial, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hamlib_port_t_parm_serial, 'thisown', 0)
        _swig_setattr(self, hamlib_port_t_parm_serial,self.__class__,hamlib_port_t_parm_serial)
_Hamlib.hamlib_port_t_parm_serial_swigregister(hamlib_port_t_parm_serialPtr)

class hamlib_port_t_post_write_date(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, hamlib_port_t_post_write_date, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, hamlib_port_t_post_write_date, name)
    def __repr__(self):
        return "<%s.%s; proxy of C hamlib_port_t_post_write_date instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["tv_sec"] = _Hamlib.hamlib_port_t_post_write_date_tv_sec_set
    __swig_getmethods__["tv_sec"] = _Hamlib.hamlib_port_t_post_write_date_tv_sec_get
    if _newclass:tv_sec = property(_Hamlib.hamlib_port_t_post_write_date_tv_sec_get, _Hamlib.hamlib_port_t_post_write_date_tv_sec_set)
    __swig_setmethods__["tv_usec"] = _Hamlib.hamlib_port_t_post_write_date_tv_usec_set
    __swig_getmethods__["tv_usec"] = _Hamlib.hamlib_port_t_post_write_date_tv_usec_get
    if _newclass:tv_usec = property(_Hamlib.hamlib_port_t_post_write_date_tv_usec_get, _Hamlib.hamlib_port_t_post_write_date_tv_usec_set)
    def __init__(self, *args):
        _swig_setattr(self, hamlib_port_t_post_write_date, 'this', _Hamlib.new_hamlib_port_t_post_write_date(*args))
        _swig_setattr(self, hamlib_port_t_post_write_date, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_hamlib_port_t_post_write_date):
        try:
            if self.thisown: destroy(self)
        except: pass


class hamlib_port_t_post_write_datePtr(hamlib_port_t_post_write_date):
    def __init__(self, this):
        _swig_setattr(self, hamlib_port_t_post_write_date, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hamlib_port_t_post_write_date, 'thisown', 0)
        _swig_setattr(self, hamlib_port_t_post_write_date,self.__class__,hamlib_port_t_post_write_date)
_Hamlib.hamlib_port_t_post_write_date_swigregister(hamlib_port_t_post_write_datePtr)

class hamlib_port_t_type(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, hamlib_port_t_type, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, hamlib_port_t_type, name)
    def __repr__(self):
        return "<%s.%s; proxy of C hamlib_port_t_type instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["rig"] = _Hamlib.hamlib_port_t_type_rig_set
    __swig_getmethods__["rig"] = _Hamlib.hamlib_port_t_type_rig_get
    if _newclass:rig = property(_Hamlib.hamlib_port_t_type_rig_get, _Hamlib.hamlib_port_t_type_rig_set)
    __swig_setmethods__["ptt"] = _Hamlib.hamlib_port_t_type_ptt_set
    __swig_getmethods__["ptt"] = _Hamlib.hamlib_port_t_type_ptt_get
    if _newclass:ptt = property(_Hamlib.hamlib_port_t_type_ptt_get, _Hamlib.hamlib_port_t_type_ptt_set)
    __swig_setmethods__["dcd"] = _Hamlib.hamlib_port_t_type_dcd_set
    __swig_getmethods__["dcd"] = _Hamlib.hamlib_port_t_type_dcd_get
    if _newclass:dcd = property(_Hamlib.hamlib_port_t_type_dcd_get, _Hamlib.hamlib_port_t_type_dcd_set)
    def __init__(self, *args):
        _swig_setattr(self, hamlib_port_t_type, 'this', _Hamlib.new_hamlib_port_t_type(*args))
        _swig_setattr(self, hamlib_port_t_type, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_hamlib_port_t_type):
        try:
            if self.thisown: destroy(self)
        except: pass


class hamlib_port_t_typePtr(hamlib_port_t_type):
    def __init__(self, this):
        _swig_setattr(self, hamlib_port_t_type, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, hamlib_port_t_type, 'thisown', 0)
        _swig_setattr(self, hamlib_port_t_type,self.__class__,hamlib_port_t_type)
_Hamlib.hamlib_port_t_type_swigregister(hamlib_port_t_typePtr)

class rig_state(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, rig_state, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, rig_state, name)
    def __repr__(self):
        return "<%s.%s; proxy of C rig_state instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["rigport"] = _Hamlib.rig_state_rigport_set
    __swig_getmethods__["rigport"] = _Hamlib.rig_state_rigport_get
    if _newclass:rigport = property(_Hamlib.rig_state_rigport_get, _Hamlib.rig_state_rigport_set)
    __swig_setmethods__["pttport"] = _Hamlib.rig_state_pttport_set
    __swig_getmethods__["pttport"] = _Hamlib.rig_state_pttport_get
    if _newclass:pttport = property(_Hamlib.rig_state_pttport_get, _Hamlib.rig_state_pttport_set)
    __swig_setmethods__["dcdport"] = _Hamlib.rig_state_dcdport_set
    __swig_getmethods__["dcdport"] = _Hamlib.rig_state_dcdport_get
    if _newclass:dcdport = property(_Hamlib.rig_state_dcdport_get, _Hamlib.rig_state_dcdport_set)
    __swig_setmethods__["vfo_comp"] = _Hamlib.rig_state_vfo_comp_set
    __swig_getmethods__["vfo_comp"] = _Hamlib.rig_state_vfo_comp_get
    if _newclass:vfo_comp = property(_Hamlib.rig_state_vfo_comp_get, _Hamlib.rig_state_vfo_comp_set)
    __swig_setmethods__["itu_region"] = _Hamlib.rig_state_itu_region_set
    __swig_getmethods__["itu_region"] = _Hamlib.rig_state_itu_region_get
    if _newclass:itu_region = property(_Hamlib.rig_state_itu_region_get, _Hamlib.rig_state_itu_region_set)
    __swig_setmethods__["rx_range_list"] = _Hamlib.rig_state_rx_range_list_set
    __swig_getmethods__["rx_range_list"] = _Hamlib.rig_state_rx_range_list_get
    if _newclass:rx_range_list = property(_Hamlib.rig_state_rx_range_list_get, _Hamlib.rig_state_rx_range_list_set)
    __swig_setmethods__["tx_range_list"] = _Hamlib.rig_state_tx_range_list_set
    __swig_getmethods__["tx_range_list"] = _Hamlib.rig_state_tx_range_list_get
    if _newclass:tx_range_list = property(_Hamlib.rig_state_tx_range_list_get, _Hamlib.rig_state_tx_range_list_set)
    __swig_setmethods__["tuning_steps"] = _Hamlib.rig_state_tuning_steps_set
    __swig_getmethods__["tuning_steps"] = _Hamlib.rig_state_tuning_steps_get
    if _newclass:tuning_steps = property(_Hamlib.rig_state_tuning_steps_get, _Hamlib.rig_state_tuning_steps_set)
    __swig_setmethods__["filters"] = _Hamlib.rig_state_filters_set
    __swig_getmethods__["filters"] = _Hamlib.rig_state_filters_get
    if _newclass:filters = property(_Hamlib.rig_state_filters_get, _Hamlib.rig_state_filters_set)
    __swig_setmethods__["str_cal"] = _Hamlib.rig_state_str_cal_set
    __swig_getmethods__["str_cal"] = _Hamlib.rig_state_str_cal_get
    if _newclass:str_cal = property(_Hamlib.rig_state_str_cal_get, _Hamlib.rig_state_str_cal_set)
    __swig_setmethods__["chan_list"] = _Hamlib.rig_state_chan_list_set
    __swig_getmethods__["chan_list"] = _Hamlib.rig_state_chan_list_get
    if _newclass:chan_list = property(_Hamlib.rig_state_chan_list_get, _Hamlib.rig_state_chan_list_set)
    __swig_setmethods__["max_rit"] = _Hamlib.rig_state_max_rit_set
    __swig_getmethods__["max_rit"] = _Hamlib.rig_state_max_rit_get
    if _newclass:max_rit = property(_Hamlib.rig_state_max_rit_get, _Hamlib.rig_state_max_rit_set)
    __swig_setmethods__["max_xit"] = _Hamlib.rig_state_max_xit_set
    __swig_getmethods__["max_xit"] = _Hamlib.rig_state_max_xit_get
    if _newclass:max_xit = property(_Hamlib.rig_state_max_xit_get, _Hamlib.rig_state_max_xit_set)
    __swig_setmethods__["max_ifshift"] = _Hamlib.rig_state_max_ifshift_set
    __swig_getmethods__["max_ifshift"] = _Hamlib.rig_state_max_ifshift_get
    if _newclass:max_ifshift = property(_Hamlib.rig_state_max_ifshift_get, _Hamlib.rig_state_max_ifshift_set)
    __swig_setmethods__["announces"] = _Hamlib.rig_state_announces_set
    __swig_getmethods__["announces"] = _Hamlib.rig_state_announces_get
    if _newclass:announces = property(_Hamlib.rig_state_announces_get, _Hamlib.rig_state_announces_set)
    __swig_setmethods__["preamp"] = _Hamlib.rig_state_preamp_set
    __swig_getmethods__["preamp"] = _Hamlib.rig_state_preamp_get
    if _newclass:preamp = property(_Hamlib.rig_state_preamp_get, _Hamlib.rig_state_preamp_set)
    __swig_setmethods__["attenuator"] = _Hamlib.rig_state_attenuator_set
    __swig_getmethods__["attenuator"] = _Hamlib.rig_state_attenuator_get
    if _newclass:attenuator = property(_Hamlib.rig_state_attenuator_get, _Hamlib.rig_state_attenuator_set)
    __swig_setmethods__["has_get_func"] = _Hamlib.rig_state_has_get_func_set
    __swig_getmethods__["has_get_func"] = _Hamlib.rig_state_has_get_func_get
    if _newclass:has_get_func = property(_Hamlib.rig_state_has_get_func_get, _Hamlib.rig_state_has_get_func_set)
    __swig_setmethods__["has_set_func"] = _Hamlib.rig_state_has_set_func_set
    __swig_getmethods__["has_set_func"] = _Hamlib.rig_state_has_set_func_get
    if _newclass:has_set_func = property(_Hamlib.rig_state_has_set_func_get, _Hamlib.rig_state_has_set_func_set)
    __swig_setmethods__["has_get_level"] = _Hamlib.rig_state_has_get_level_set
    __swig_getmethods__["has_get_level"] = _Hamlib.rig_state_has_get_level_get
    if _newclass:has_get_level = property(_Hamlib.rig_state_has_get_level_get, _Hamlib.rig_state_has_get_level_set)
    __swig_setmethods__["has_set_level"] = _Hamlib.rig_state_has_set_level_set
    __swig_getmethods__["has_set_level"] = _Hamlib.rig_state_has_set_level_get
    if _newclass:has_set_level = property(_Hamlib.rig_state_has_set_level_get, _Hamlib.rig_state_has_set_level_set)
    __swig_setmethods__["has_get_parm"] = _Hamlib.rig_state_has_get_parm_set
    __swig_getmethods__["has_get_parm"] = _Hamlib.rig_state_has_get_parm_get
    if _newclass:has_get_parm = property(_Hamlib.rig_state_has_get_parm_get, _Hamlib.rig_state_has_get_parm_set)
    __swig_setmethods__["has_set_parm"] = _Hamlib.rig_state_has_set_parm_set
    __swig_getmethods__["has_set_parm"] = _Hamlib.rig_state_has_set_parm_get
    if _newclass:has_set_parm = property(_Hamlib.rig_state_has_set_parm_get, _Hamlib.rig_state_has_set_parm_set)
    __swig_setmethods__["level_gran"] = _Hamlib.rig_state_level_gran_set
    __swig_getmethods__["level_gran"] = _Hamlib.rig_state_level_gran_get
    if _newclass:level_gran = property(_Hamlib.rig_state_level_gran_get, _Hamlib.rig_state_level_gran_set)
    __swig_setmethods__["parm_gran"] = _Hamlib.rig_state_parm_gran_set
    __swig_getmethods__["parm_gran"] = _Hamlib.rig_state_parm_gran_get
    if _newclass:parm_gran = property(_Hamlib.rig_state_parm_gran_get, _Hamlib.rig_state_parm_gran_set)
    __swig_setmethods__["hold_decode"] = _Hamlib.rig_state_hold_decode_set
    __swig_getmethods__["hold_decode"] = _Hamlib.rig_state_hold_decode_get
    if _newclass:hold_decode = property(_Hamlib.rig_state_hold_decode_get, _Hamlib.rig_state_hold_decode_set)
    __swig_setmethods__["current_vfo"] = _Hamlib.rig_state_current_vfo_set
    __swig_getmethods__["current_vfo"] = _Hamlib.rig_state_current_vfo_get
    if _newclass:current_vfo = property(_Hamlib.rig_state_current_vfo_get, _Hamlib.rig_state_current_vfo_set)
    __swig_setmethods__["vfo_list"] = _Hamlib.rig_state_vfo_list_set
    __swig_getmethods__["vfo_list"] = _Hamlib.rig_state_vfo_list_get
    if _newclass:vfo_list = property(_Hamlib.rig_state_vfo_list_get, _Hamlib.rig_state_vfo_list_set)
    __swig_setmethods__["comm_state"] = _Hamlib.rig_state_comm_state_set
    __swig_getmethods__["comm_state"] = _Hamlib.rig_state_comm_state_get
    if _newclass:comm_state = property(_Hamlib.rig_state_comm_state_get, _Hamlib.rig_state_comm_state_set)
    __swig_setmethods__["priv"] = _Hamlib.rig_state_priv_set
    __swig_getmethods__["priv"] = _Hamlib.rig_state_priv_get
    if _newclass:priv = property(_Hamlib.rig_state_priv_get, _Hamlib.rig_state_priv_set)
    __swig_setmethods__["obj"] = _Hamlib.rig_state_obj_set
    __swig_getmethods__["obj"] = _Hamlib.rig_state_obj_get
    if _newclass:obj = property(_Hamlib.rig_state_obj_get, _Hamlib.rig_state_obj_set)
    __swig_setmethods__["transceive"] = _Hamlib.rig_state_transceive_set
    __swig_getmethods__["transceive"] = _Hamlib.rig_state_transceive_get
    if _newclass:transceive = property(_Hamlib.rig_state_transceive_get, _Hamlib.rig_state_transceive_set)
    __swig_setmethods__["poll_interval"] = _Hamlib.rig_state_poll_interval_set
    __swig_getmethods__["poll_interval"] = _Hamlib.rig_state_poll_interval_get
    if _newclass:poll_interval = property(_Hamlib.rig_state_poll_interval_get, _Hamlib.rig_state_poll_interval_set)
    __swig_setmethods__["current_freq"] = _Hamlib.rig_state_current_freq_set
    __swig_getmethods__["current_freq"] = _Hamlib.rig_state_current_freq_get
    if _newclass:current_freq = property(_Hamlib.rig_state_current_freq_get, _Hamlib.rig_state_current_freq_set)
    __swig_setmethods__["current_mode"] = _Hamlib.rig_state_current_mode_set
    __swig_getmethods__["current_mode"] = _Hamlib.rig_state_current_mode_get
    if _newclass:current_mode = property(_Hamlib.rig_state_current_mode_get, _Hamlib.rig_state_current_mode_set)
    __swig_setmethods__["current_width"] = _Hamlib.rig_state_current_width_set
    __swig_getmethods__["current_width"] = _Hamlib.rig_state_current_width_get
    if _newclass:current_width = property(_Hamlib.rig_state_current_width_get, _Hamlib.rig_state_current_width_set)
    def __init__(self, *args):
        _swig_setattr(self, rig_state, 'this', _Hamlib.new_rig_state(*args))
        _swig_setattr(self, rig_state, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_rig_state):
        try:
            if self.thisown: destroy(self)
        except: pass


class rig_statePtr(rig_state):
    def __init__(self, this):
        _swig_setattr(self, rig_state, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, rig_state, 'thisown', 0)
        _swig_setattr(self, rig_state,self.__class__,rig_state)
_Hamlib.rig_state_swigregister(rig_statePtr)

class rig_callbacks(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, rig_callbacks, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, rig_callbacks, name)
    def __repr__(self):
        return "<%s.%s; proxy of C rig_callbacks instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["freq_event"] = _Hamlib.rig_callbacks_freq_event_set
    __swig_getmethods__["freq_event"] = _Hamlib.rig_callbacks_freq_event_get
    if _newclass:freq_event = property(_Hamlib.rig_callbacks_freq_event_get, _Hamlib.rig_callbacks_freq_event_set)
    __swig_setmethods__["freq_arg"] = _Hamlib.rig_callbacks_freq_arg_set
    __swig_getmethods__["freq_arg"] = _Hamlib.rig_callbacks_freq_arg_get
    if _newclass:freq_arg = property(_Hamlib.rig_callbacks_freq_arg_get, _Hamlib.rig_callbacks_freq_arg_set)
    __swig_setmethods__["mode_event"] = _Hamlib.rig_callbacks_mode_event_set
    __swig_getmethods__["mode_event"] = _Hamlib.rig_callbacks_mode_event_get
    if _newclass:mode_event = property(_Hamlib.rig_callbacks_mode_event_get, _Hamlib.rig_callbacks_mode_event_set)
    __swig_setmethods__["mode_arg"] = _Hamlib.rig_callbacks_mode_arg_set
    __swig_getmethods__["mode_arg"] = _Hamlib.rig_callbacks_mode_arg_get
    if _newclass:mode_arg = property(_Hamlib.rig_callbacks_mode_arg_get, _Hamlib.rig_callbacks_mode_arg_set)
    __swig_setmethods__["vfo_event"] = _Hamlib.rig_callbacks_vfo_event_set
    __swig_getmethods__["vfo_event"] = _Hamlib.rig_callbacks_vfo_event_get
    if _newclass:vfo_event = property(_Hamlib.rig_callbacks_vfo_event_get, _Hamlib.rig_callbacks_vfo_event_set)
    __swig_setmethods__["vfo_arg"] = _Hamlib.rig_callbacks_vfo_arg_set
    __swig_getmethods__["vfo_arg"] = _Hamlib.rig_callbacks_vfo_arg_get
    if _newclass:vfo_arg = property(_Hamlib.rig_callbacks_vfo_arg_get, _Hamlib.rig_callbacks_vfo_arg_set)
    __swig_setmethods__["ptt_event"] = _Hamlib.rig_callbacks_ptt_event_set
    __swig_getmethods__["ptt_event"] = _Hamlib.rig_callbacks_ptt_event_get
    if _newclass:ptt_event = property(_Hamlib.rig_callbacks_ptt_event_get, _Hamlib.rig_callbacks_ptt_event_set)
    __swig_setmethods__["ptt_arg"] = _Hamlib.rig_callbacks_ptt_arg_set
    __swig_getmethods__["ptt_arg"] = _Hamlib.rig_callbacks_ptt_arg_get
    if _newclass:ptt_arg = property(_Hamlib.rig_callbacks_ptt_arg_get, _Hamlib.rig_callbacks_ptt_arg_set)
    __swig_setmethods__["dcd_event"] = _Hamlib.rig_callbacks_dcd_event_set
    __swig_getmethods__["dcd_event"] = _Hamlib.rig_callbacks_dcd_event_get
    if _newclass:dcd_event = property(_Hamlib.rig_callbacks_dcd_event_get, _Hamlib.rig_callbacks_dcd_event_set)
    __swig_setmethods__["dcd_arg"] = _Hamlib.rig_callbacks_dcd_arg_set
    __swig_getmethods__["dcd_arg"] = _Hamlib.rig_callbacks_dcd_arg_get
    if _newclass:dcd_arg = property(_Hamlib.rig_callbacks_dcd_arg_get, _Hamlib.rig_callbacks_dcd_arg_set)
    __swig_setmethods__["pltune"] = _Hamlib.rig_callbacks_pltune_set
    __swig_getmethods__["pltune"] = _Hamlib.rig_callbacks_pltune_get
    if _newclass:pltune = property(_Hamlib.rig_callbacks_pltune_get, _Hamlib.rig_callbacks_pltune_set)
    __swig_setmethods__["pltune_arg"] = _Hamlib.rig_callbacks_pltune_arg_set
    __swig_getmethods__["pltune_arg"] = _Hamlib.rig_callbacks_pltune_arg_get
    if _newclass:pltune_arg = property(_Hamlib.rig_callbacks_pltune_arg_get, _Hamlib.rig_callbacks_pltune_arg_set)
    def __init__(self, *args):
        _swig_setattr(self, rig_callbacks, 'this', _Hamlib.new_rig_callbacks(*args))
        _swig_setattr(self, rig_callbacks, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_rig_callbacks):
        try:
            if self.thisown: destroy(self)
        except: pass


class rig_callbacksPtr(rig_callbacks):
    def __init__(self, this):
        _swig_setattr(self, rig_callbacks, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, rig_callbacks, 'thisown', 0)
        _swig_setattr(self, rig_callbacks,self.__class__,rig_callbacks)
_Hamlib.rig_callbacks_swigregister(rig_callbacksPtr)

class rig(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, rig, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, rig, name)
    def __repr__(self):
        return "<%s.%s; proxy of C rig instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["caps"] = _Hamlib.rig_caps_set
    __swig_getmethods__["caps"] = _Hamlib.rig_caps_get
    if _newclass:caps = property(_Hamlib.rig_caps_get, _Hamlib.rig_caps_set)
    __swig_setmethods__["state"] = _Hamlib.rig_state_set
    __swig_getmethods__["state"] = _Hamlib.rig_state_get
    if _newclass:state = property(_Hamlib.rig_state_get, _Hamlib.rig_state_set)
    __swig_setmethods__["callbacks"] = _Hamlib.rig_callbacks_set
    __swig_getmethods__["callbacks"] = _Hamlib.rig_callbacks_get
    if _newclass:callbacks = property(_Hamlib.rig_callbacks_get, _Hamlib.rig_callbacks_set)
    def __init__(self, *args):
        _swig_setattr(self, rig, 'this', _Hamlib.new_rig(*args))
        _swig_setattr(self, rig, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_rig):
        try:
            if self.thisown: destroy(self)
        except: pass


class rigPtr(rig):
    def __init__(self, this):
        _swig_setattr(self, rig, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, rig, 'thisown', 0)
        _swig_setattr(self, rig,self.__class__,rig)
_Hamlib.rig_swigregister(rigPtr)


rig_init = _Hamlib.rig_init

rig_set_split_vfo = _Hamlib.rig_set_split_vfo

rig_get_split_vfo = _Hamlib.rig_get_split_vfo

rig_ext_lookup = _Hamlib.rig_ext_lookup

rig_ext_lookup_tok = _Hamlib.rig_ext_lookup_tok

rig_ext_token_lookup = _Hamlib.rig_ext_token_lookup

rig_token_foreach = _Hamlib.rig_token_foreach

rig_confparam_lookup = _Hamlib.rig_confparam_lookup

rig_set_chan_all = _Hamlib.rig_set_chan_all

rig_get_chan_all = _Hamlib.rig_get_chan_all

rig_set_chan_all_cb = _Hamlib.rig_set_chan_all_cb

rig_get_chan_all_cb = _Hamlib.rig_get_chan_all_cb

rig_set_mem_all_cb = _Hamlib.rig_set_mem_all_cb

rig_get_mem_all_cb = _Hamlib.rig_get_mem_all_cb

rig_set_mem_all = _Hamlib.rig_set_mem_all

rig_get_mem_all = _Hamlib.rig_get_mem_all

rig_get_caps = _Hamlib.rig_get_caps

rig_get_range = _Hamlib.rig_get_range

rigerror = _Hamlib.rigerror

rig_setting2idx = _Hamlib.rig_setting2idx

rig_set_debug = _Hamlib.rig_set_debug

rig_need_debug = _Hamlib.rig_need_debug

rig_set_debug_callback = _Hamlib.rig_set_debug_callback

rig_set_debug_file = _Hamlib.rig_set_debug_file

rig_register = _Hamlib.rig_register

rig_unregister = _Hamlib.rig_unregister

rig_list_foreach = _Hamlib.rig_list_foreach

rig_load_backend = _Hamlib.rig_load_backend

rig_check_backend = _Hamlib.rig_check_backend

rig_load_all_backends = _Hamlib.rig_load_all_backends

rig_probe_all = _Hamlib.rig_probe_all

rig_strrmode = _Hamlib.rig_strrmode

rig_strvfo = _Hamlib.rig_strvfo

rig_strfunc = _Hamlib.rig_strfunc

rig_strlevel = _Hamlib.rig_strlevel

rig_strparm = _Hamlib.rig_strparm

rig_strptrshift = _Hamlib.rig_strptrshift

rig_strvfop = _Hamlib.rig_strvfop

rig_strscan = _Hamlib.rig_strscan

rig_strstatus = _Hamlib.rig_strstatus

rig_parse_mode = _Hamlib.rig_parse_mode

rig_parse_vfo = _Hamlib.rig_parse_vfo

rig_parse_func = _Hamlib.rig_parse_func

rig_parse_level = _Hamlib.rig_parse_level

rig_parse_parm = _Hamlib.rig_parse_parm

rig_parse_vfo_op = _Hamlib.rig_parse_vfo_op

rig_parse_scan = _Hamlib.rig_parse_scan

rig_parse_rptr_shift = _Hamlib.rig_parse_rptr_shift
_ROTLIST_H = _Hamlib._ROTLIST_H
ROT_MODEL_NONE = _Hamlib.ROT_MODEL_NONE
ROT_DUMMY = _Hamlib.ROT_DUMMY
ROT_BACKEND_DUMMY = _Hamlib.ROT_BACKEND_DUMMY
ROT_MODEL_DUMMY = _Hamlib.ROT_MODEL_DUMMY
ROT_RPC = _Hamlib.ROT_RPC
ROT_BACKEND_RPC = _Hamlib.ROT_BACKEND_RPC
ROT_MODEL_RPC = _Hamlib.ROT_MODEL_RPC
ROT_EASYCOMM = _Hamlib.ROT_EASYCOMM
ROT_BACKEND_EASYCOMM = _Hamlib.ROT_BACKEND_EASYCOMM
ROT_MODEL_EASYCOMM1 = _Hamlib.ROT_MODEL_EASYCOMM1
ROT_MODEL_EASYCOMM2 = _Hamlib.ROT_MODEL_EASYCOMM2
ROT_FODTRACK = _Hamlib.ROT_FODTRACK
ROT_BACKEND_FODTRACK = _Hamlib.ROT_BACKEND_FODTRACK
ROT_MODEL_FODTRACK = _Hamlib.ROT_MODEL_FODTRACK
ROT_ROTOREZ = _Hamlib.ROT_ROTOREZ
ROT_BACKEND_ROTOREZ = _Hamlib.ROT_BACKEND_ROTOREZ
ROT_MODEL_ROTOREZ = _Hamlib.ROT_MODEL_ROTOREZ
ROT_MODEL_ROTORCARD = _Hamlib.ROT_MODEL_ROTORCARD
ROT_MODEL_DCU = _Hamlib.ROT_MODEL_DCU
ROT_SARTEK = _Hamlib.ROT_SARTEK
ROT_BACKEND_SARTEK = _Hamlib.ROT_BACKEND_SARTEK
ROT_MODEL_SARTEK1 = _Hamlib.ROT_MODEL_SARTEK1
_ROTATOR_H = _Hamlib._ROTATOR_H
ROT_RESET_ALL = _Hamlib.ROT_RESET_ALL
ROT_FLAG_AZIMUTH = _Hamlib.ROT_FLAG_AZIMUTH
ROT_FLAG_ELEVATION = _Hamlib.ROT_FLAG_ELEVATION
ROT_TYPE_OTHER = _Hamlib.ROT_TYPE_OTHER
ROT_MOVE_UP = _Hamlib.ROT_MOVE_UP
ROT_MOVE_DOWN = _Hamlib.ROT_MOVE_DOWN
ROT_MOVE_LEFT = _Hamlib.ROT_MOVE_LEFT
ROT_MOVE_CCW = _Hamlib.ROT_MOVE_CCW
ROT_MOVE_RIGHT = _Hamlib.ROT_MOVE_RIGHT
ROT_MOVE_CW = _Hamlib.ROT_MOVE_CW
class rot_caps(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, rot_caps, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, rot_caps, name)
    def __repr__(self):
        return "<%s.%s; proxy of C rot_caps instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["rot_model"] = _Hamlib.rot_caps_rot_model_set
    __swig_getmethods__["rot_model"] = _Hamlib.rot_caps_rot_model_get
    if _newclass:rot_model = property(_Hamlib.rot_caps_rot_model_get, _Hamlib.rot_caps_rot_model_set)
    __swig_setmethods__["model_name"] = _Hamlib.rot_caps_model_name_set
    __swig_getmethods__["model_name"] = _Hamlib.rot_caps_model_name_get
    if _newclass:model_name = property(_Hamlib.rot_caps_model_name_get, _Hamlib.rot_caps_model_name_set)
    __swig_setmethods__["mfg_name"] = _Hamlib.rot_caps_mfg_name_set
    __swig_getmethods__["mfg_name"] = _Hamlib.rot_caps_mfg_name_get
    if _newclass:mfg_name = property(_Hamlib.rot_caps_mfg_name_get, _Hamlib.rot_caps_mfg_name_set)
    __swig_setmethods__["version"] = _Hamlib.rot_caps_version_set
    __swig_getmethods__["version"] = _Hamlib.rot_caps_version_get
    if _newclass:version = property(_Hamlib.rot_caps_version_get, _Hamlib.rot_caps_version_set)
    __swig_setmethods__["copyright"] = _Hamlib.rot_caps_copyright_set
    __swig_getmethods__["copyright"] = _Hamlib.rot_caps_copyright_get
    if _newclass:copyright = property(_Hamlib.rot_caps_copyright_get, _Hamlib.rot_caps_copyright_set)
    __swig_setmethods__["status"] = _Hamlib.rot_caps_status_set
    __swig_getmethods__["status"] = _Hamlib.rot_caps_status_get
    if _newclass:status = property(_Hamlib.rot_caps_status_get, _Hamlib.rot_caps_status_set)
    __swig_setmethods__["rot_type"] = _Hamlib.rot_caps_rot_type_set
    __swig_getmethods__["rot_type"] = _Hamlib.rot_caps_rot_type_get
    if _newclass:rot_type = property(_Hamlib.rot_caps_rot_type_get, _Hamlib.rot_caps_rot_type_set)
    __swig_setmethods__["port_type"] = _Hamlib.rot_caps_port_type_set
    __swig_getmethods__["port_type"] = _Hamlib.rot_caps_port_type_get
    if _newclass:port_type = property(_Hamlib.rot_caps_port_type_get, _Hamlib.rot_caps_port_type_set)
    __swig_setmethods__["serial_rate_min"] = _Hamlib.rot_caps_serial_rate_min_set
    __swig_getmethods__["serial_rate_min"] = _Hamlib.rot_caps_serial_rate_min_get
    if _newclass:serial_rate_min = property(_Hamlib.rot_caps_serial_rate_min_get, _Hamlib.rot_caps_serial_rate_min_set)
    __swig_setmethods__["serial_rate_max"] = _Hamlib.rot_caps_serial_rate_max_set
    __swig_getmethods__["serial_rate_max"] = _Hamlib.rot_caps_serial_rate_max_get
    if _newclass:serial_rate_max = property(_Hamlib.rot_caps_serial_rate_max_get, _Hamlib.rot_caps_serial_rate_max_set)
    __swig_setmethods__["serial_data_bits"] = _Hamlib.rot_caps_serial_data_bits_set
    __swig_getmethods__["serial_data_bits"] = _Hamlib.rot_caps_serial_data_bits_get
    if _newclass:serial_data_bits = property(_Hamlib.rot_caps_serial_data_bits_get, _Hamlib.rot_caps_serial_data_bits_set)
    __swig_setmethods__["serial_stop_bits"] = _Hamlib.rot_caps_serial_stop_bits_set
    __swig_getmethods__["serial_stop_bits"] = _Hamlib.rot_caps_serial_stop_bits_get
    if _newclass:serial_stop_bits = property(_Hamlib.rot_caps_serial_stop_bits_get, _Hamlib.rot_caps_serial_stop_bits_set)
    __swig_setmethods__["serial_parity"] = _Hamlib.rot_caps_serial_parity_set
    __swig_getmethods__["serial_parity"] = _Hamlib.rot_caps_serial_parity_get
    if _newclass:serial_parity = property(_Hamlib.rot_caps_serial_parity_get, _Hamlib.rot_caps_serial_parity_set)
    __swig_setmethods__["serial_handshake"] = _Hamlib.rot_caps_serial_handshake_set
    __swig_getmethods__["serial_handshake"] = _Hamlib.rot_caps_serial_handshake_get
    if _newclass:serial_handshake = property(_Hamlib.rot_caps_serial_handshake_get, _Hamlib.rot_caps_serial_handshake_set)
    __swig_setmethods__["write_delay"] = _Hamlib.rot_caps_write_delay_set
    __swig_getmethods__["write_delay"] = _Hamlib.rot_caps_write_delay_get
    if _newclass:write_delay = property(_Hamlib.rot_caps_write_delay_get, _Hamlib.rot_caps_write_delay_set)
    __swig_setmethods__["post_write_delay"] = _Hamlib.rot_caps_post_write_delay_set
    __swig_getmethods__["post_write_delay"] = _Hamlib.rot_caps_post_write_delay_get
    if _newclass:post_write_delay = property(_Hamlib.rot_caps_post_write_delay_get, _Hamlib.rot_caps_post_write_delay_set)
    __swig_setmethods__["timeout"] = _Hamlib.rot_caps_timeout_set
    __swig_getmethods__["timeout"] = _Hamlib.rot_caps_timeout_get
    if _newclass:timeout = property(_Hamlib.rot_caps_timeout_get, _Hamlib.rot_caps_timeout_set)
    __swig_setmethods__["retry"] = _Hamlib.rot_caps_retry_set
    __swig_getmethods__["retry"] = _Hamlib.rot_caps_retry_get
    if _newclass:retry = property(_Hamlib.rot_caps_retry_get, _Hamlib.rot_caps_retry_set)
    __swig_setmethods__["min_az"] = _Hamlib.rot_caps_min_az_set
    __swig_getmethods__["min_az"] = _Hamlib.rot_caps_min_az_get
    if _newclass:min_az = property(_Hamlib.rot_caps_min_az_get, _Hamlib.rot_caps_min_az_set)
    __swig_setmethods__["max_az"] = _Hamlib.rot_caps_max_az_set
    __swig_getmethods__["max_az"] = _Hamlib.rot_caps_max_az_get
    if _newclass:max_az = property(_Hamlib.rot_caps_max_az_get, _Hamlib.rot_caps_max_az_set)
    __swig_setmethods__["min_el"] = _Hamlib.rot_caps_min_el_set
    __swig_getmethods__["min_el"] = _Hamlib.rot_caps_min_el_get
    if _newclass:min_el = property(_Hamlib.rot_caps_min_el_get, _Hamlib.rot_caps_min_el_set)
    __swig_setmethods__["max_el"] = _Hamlib.rot_caps_max_el_set
    __swig_getmethods__["max_el"] = _Hamlib.rot_caps_max_el_get
    if _newclass:max_el = property(_Hamlib.rot_caps_max_el_get, _Hamlib.rot_caps_max_el_set)
    __swig_setmethods__["cfgparams"] = _Hamlib.rot_caps_cfgparams_set
    __swig_getmethods__["cfgparams"] = _Hamlib.rot_caps_cfgparams_get
    if _newclass:cfgparams = property(_Hamlib.rot_caps_cfgparams_get, _Hamlib.rot_caps_cfgparams_set)
    __swig_setmethods__["priv"] = _Hamlib.rot_caps_priv_set
    __swig_getmethods__["priv"] = _Hamlib.rot_caps_priv_get
    if _newclass:priv = property(_Hamlib.rot_caps_priv_get, _Hamlib.rot_caps_priv_set)
    __swig_setmethods__["rot_init"] = _Hamlib.rot_caps_rot_init_set
    __swig_getmethods__["rot_init"] = _Hamlib.rot_caps_rot_init_get
    if _newclass:rot_init = property(_Hamlib.rot_caps_rot_init_get, _Hamlib.rot_caps_rot_init_set)
    __swig_setmethods__["set_conf"] = _Hamlib.rot_caps_set_conf_set
    __swig_getmethods__["set_conf"] = _Hamlib.rot_caps_set_conf_get
    if _newclass:set_conf = property(_Hamlib.rot_caps_set_conf_get, _Hamlib.rot_caps_set_conf_set)
    __swig_setmethods__["get_conf"] = _Hamlib.rot_caps_get_conf_set
    __swig_getmethods__["get_conf"] = _Hamlib.rot_caps_get_conf_get
    if _newclass:get_conf = property(_Hamlib.rot_caps_get_conf_get, _Hamlib.rot_caps_get_conf_set)
    __swig_setmethods__["set_position"] = _Hamlib.rot_caps_set_position_set
    __swig_getmethods__["set_position"] = _Hamlib.rot_caps_set_position_get
    if _newclass:set_position = property(_Hamlib.rot_caps_set_position_get, _Hamlib.rot_caps_set_position_set)
    __swig_setmethods__["get_position"] = _Hamlib.rot_caps_get_position_set
    __swig_getmethods__["get_position"] = _Hamlib.rot_caps_get_position_get
    if _newclass:get_position = property(_Hamlib.rot_caps_get_position_get, _Hamlib.rot_caps_get_position_set)
    __swig_setmethods__["stop"] = _Hamlib.rot_caps_stop_set
    __swig_getmethods__["stop"] = _Hamlib.rot_caps_stop_get
    if _newclass:stop = property(_Hamlib.rot_caps_stop_get, _Hamlib.rot_caps_stop_set)
    __swig_setmethods__["park"] = _Hamlib.rot_caps_park_set
    __swig_getmethods__["park"] = _Hamlib.rot_caps_park_get
    if _newclass:park = property(_Hamlib.rot_caps_park_get, _Hamlib.rot_caps_park_set)
    __swig_setmethods__["reset"] = _Hamlib.rot_caps_reset_set
    __swig_getmethods__["reset"] = _Hamlib.rot_caps_reset_get
    if _newclass:reset = property(_Hamlib.rot_caps_reset_get, _Hamlib.rot_caps_reset_set)
    __swig_setmethods__["move"] = _Hamlib.rot_caps_move_set
    __swig_getmethods__["move"] = _Hamlib.rot_caps_move_get
    if _newclass:move = property(_Hamlib.rot_caps_move_get, _Hamlib.rot_caps_move_set)
    __swig_setmethods__["get_info"] = _Hamlib.rot_caps_get_info_set
    __swig_getmethods__["get_info"] = _Hamlib.rot_caps_get_info_get
    if _newclass:get_info = property(_Hamlib.rot_caps_get_info_get, _Hamlib.rot_caps_get_info_set)
    def __init__(self, *args):
        _swig_setattr(self, rot_caps, 'this', _Hamlib.new_rot_caps(*args))
        _swig_setattr(self, rot_caps, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_rot_caps):
        try:
            if self.thisown: destroy(self)
        except: pass


class rot_capsPtr(rot_caps):
    def __init__(self, this):
        _swig_setattr(self, rot_caps, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, rot_caps, 'thisown', 0)
        _swig_setattr(self, rot_caps,self.__class__,rot_caps)
_Hamlib.rot_caps_swigregister(rot_capsPtr)

class rot_state(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, rot_state, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, rot_state, name)
    def __repr__(self):
        return "<%s.%s; proxy of C rot_state instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["min_az"] = _Hamlib.rot_state_min_az_set
    __swig_getmethods__["min_az"] = _Hamlib.rot_state_min_az_get
    if _newclass:min_az = property(_Hamlib.rot_state_min_az_get, _Hamlib.rot_state_min_az_set)
    __swig_setmethods__["max_az"] = _Hamlib.rot_state_max_az_set
    __swig_getmethods__["max_az"] = _Hamlib.rot_state_max_az_get
    if _newclass:max_az = property(_Hamlib.rot_state_max_az_get, _Hamlib.rot_state_max_az_set)
    __swig_setmethods__["min_el"] = _Hamlib.rot_state_min_el_set
    __swig_getmethods__["min_el"] = _Hamlib.rot_state_min_el_get
    if _newclass:min_el = property(_Hamlib.rot_state_min_el_get, _Hamlib.rot_state_min_el_set)
    __swig_setmethods__["max_el"] = _Hamlib.rot_state_max_el_set
    __swig_getmethods__["max_el"] = _Hamlib.rot_state_max_el_get
    if _newclass:max_el = property(_Hamlib.rot_state_max_el_get, _Hamlib.rot_state_max_el_set)
    __swig_setmethods__["rotport"] = _Hamlib.rot_state_rotport_set
    __swig_getmethods__["rotport"] = _Hamlib.rot_state_rotport_get
    if _newclass:rotport = property(_Hamlib.rot_state_rotport_get, _Hamlib.rot_state_rotport_set)
    __swig_setmethods__["comm_state"] = _Hamlib.rot_state_comm_state_set
    __swig_getmethods__["comm_state"] = _Hamlib.rot_state_comm_state_get
    if _newclass:comm_state = property(_Hamlib.rot_state_comm_state_get, _Hamlib.rot_state_comm_state_set)
    __swig_setmethods__["priv"] = _Hamlib.rot_state_priv_set
    __swig_getmethods__["priv"] = _Hamlib.rot_state_priv_get
    if _newclass:priv = property(_Hamlib.rot_state_priv_get, _Hamlib.rot_state_priv_set)
    __swig_setmethods__["obj"] = _Hamlib.rot_state_obj_set
    __swig_getmethods__["obj"] = _Hamlib.rot_state_obj_get
    if _newclass:obj = property(_Hamlib.rot_state_obj_get, _Hamlib.rot_state_obj_set)
    def __init__(self, *args):
        _swig_setattr(self, rot_state, 'this', _Hamlib.new_rot_state(*args))
        _swig_setattr(self, rot_state, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_rot_state):
        try:
            if self.thisown: destroy(self)
        except: pass


class rot_statePtr(rot_state):
    def __init__(self, this):
        _swig_setattr(self, rot_state, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, rot_state, 'thisown', 0)
        _swig_setattr(self, rot_state,self.__class__,rot_state)
_Hamlib.rot_state_swigregister(rot_statePtr)

class rot(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, rot, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, rot, name)
    def __repr__(self):
        return "<%s.%s; proxy of C rot instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["caps"] = _Hamlib.rot_caps_set
    __swig_getmethods__["caps"] = _Hamlib.rot_caps_get
    if _newclass:caps = property(_Hamlib.rot_caps_get, _Hamlib.rot_caps_set)
    __swig_setmethods__["state"] = _Hamlib.rot_state_set
    __swig_getmethods__["state"] = _Hamlib.rot_state_get
    if _newclass:state = property(_Hamlib.rot_state_get, _Hamlib.rot_state_set)
    def __init__(self, *args):
        _swig_setattr(self, rot, 'this', _Hamlib.new_rot(*args))
        _swig_setattr(self, rot, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_rot):
        try:
            if self.thisown: destroy(self)
        except: pass


class rotPtr(rot):
    def __init__(self, this):
        _swig_setattr(self, rot, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, rot, 'thisown', 0)
        _swig_setattr(self, rot,self.__class__,rot)
_Hamlib.rot_swigregister(rotPtr)


rot_init = _Hamlib.rot_init

rot_register = _Hamlib.rot_register

rot_unregister = _Hamlib.rot_unregister

rot_list_foreach = _Hamlib.rot_list_foreach

rot_load_backend = _Hamlib.rot_load_backend

rot_check_backend = _Hamlib.rot_check_backend

rot_load_all_backends = _Hamlib.rot_load_all_backends

rot_probe_all = _Hamlib.rot_probe_all

rot_token_foreach = _Hamlib.rot_token_foreach

rot_confparam_lookup = _Hamlib.rot_confparam_lookup

rot_token_lookup = _Hamlib.rot_token_lookup

rot_get_caps = _Hamlib.rot_get_caps

qrb = _Hamlib.qrb

distance_long_path = _Hamlib.distance_long_path

azimuth_long_path = _Hamlib.azimuth_long_path

longlat2locator = _Hamlib.longlat2locator

locator2longlat = _Hamlib.locator2longlat

dms2dec = _Hamlib.dms2dec

dec2dms = _Hamlib.dec2dms

dec2dmmm = _Hamlib.dec2dmmm

dmmm2dec = _Hamlib.dmmm2dec
class Rig(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Rig, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Rig, name)
    def __repr__(self):
        return "<%s.%s; proxy of C Rig instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["rig"] = _Hamlib.Rig_rig_set
    __swig_getmethods__["rig"] = _Hamlib.Rig_rig_get
    if _newclass:rig = property(_Hamlib.Rig_rig_get, _Hamlib.Rig_rig_set)
    __swig_setmethods__["caps"] = _Hamlib.Rig_caps_set
    __swig_getmethods__["caps"] = _Hamlib.Rig_caps_get
    if _newclass:caps = property(_Hamlib.Rig_caps_get, _Hamlib.Rig_caps_set)
    __swig_setmethods__["state"] = _Hamlib.Rig_state_set
    __swig_getmethods__["state"] = _Hamlib.Rig_state_get
    if _newclass:state = property(_Hamlib.Rig_state_get, _Hamlib.Rig_state_set)
    __swig_setmethods__["error_status"] = _Hamlib.Rig_error_status_set
    __swig_getmethods__["error_status"] = _Hamlib.Rig_error_status_get
    if _newclass:error_status = property(_Hamlib.Rig_error_status_get, _Hamlib.Rig_error_status_set)
    __swig_setmethods__["do_exception"] = _Hamlib.Rig_do_exception_set
    __swig_getmethods__["do_exception"] = _Hamlib.Rig_do_exception_get
    if _newclass:do_exception = property(_Hamlib.Rig_do_exception_get, _Hamlib.Rig_do_exception_set)
    def __init__(self, *args):
        _swig_setattr(self, Rig, 'this', _Hamlib.new_Rig(*args))
        _swig_setattr(self, Rig, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_Rig):
        try:
            if self.thisown: destroy(self)
        except: pass

    def open(*args): return _Hamlib.Rig_open(*args)
    def close(*args): return _Hamlib.Rig_close(*args)
    def set_freq(*args): return _Hamlib.Rig_set_freq(*args)
    def set_mode(*args): return _Hamlib.Rig_set_mode(*args)
    def set_ptt(*args): return _Hamlib.Rig_set_ptt(*args)
    def set_rptr_shift(*args): return _Hamlib.Rig_set_rptr_shift(*args)
    def set_rptr_offs(*args): return _Hamlib.Rig_set_rptr_offs(*args)
    def set_ctcss_tone(*args): return _Hamlib.Rig_set_ctcss_tone(*args)
    def set_dcs_code(*args): return _Hamlib.Rig_set_dcs_code(*args)
    def set_ctcss_sql(*args): return _Hamlib.Rig_set_ctcss_sql(*args)
    def set_dcs_sql(*args): return _Hamlib.Rig_set_dcs_sql(*args)
    def set_split_freq(*args): return _Hamlib.Rig_set_split_freq(*args)
    def set_split_mode(*args): return _Hamlib.Rig_set_split_mode(*args)
    def set_split_vfo(*args): return _Hamlib.Rig_set_split_vfo(*args)
    def set_rit(*args): return _Hamlib.Rig_set_rit(*args)
    def set_xit(*args): return _Hamlib.Rig_set_xit(*args)
    def set_ts(*args): return _Hamlib.Rig_set_ts(*args)
    def set_ant(*args): return _Hamlib.Rig_set_ant(*args)
    def set_func(*args): return _Hamlib.Rig_set_func(*args)
    def set_bank(*args): return _Hamlib.Rig_set_bank(*args)
    def set_mem(*args): return _Hamlib.Rig_set_mem(*args)
    def send_dtmf(*args): return _Hamlib.Rig_send_dtmf(*args)
    def send_morse(*args): return _Hamlib.Rig_send_morse(*args)
    def vfo_op(*args): return _Hamlib.Rig_vfo_op(*args)
    def scan(*args): return _Hamlib.Rig_scan(*args)
    def set_level(*args): return _Hamlib.Rig_set_level(*args)
    def set_ext_level(*args): return _Hamlib.Rig_set_ext_level(*args)
    def get_level_i(*args): return _Hamlib.Rig_get_level_i(*args)
    def get_level_f(*args): return _Hamlib.Rig_get_level_f(*args)
    def set_vfo(*args): return _Hamlib.Rig_set_vfo(*args)
    def set_powerstat(*args): return _Hamlib.Rig_set_powerstat(*args)
    def set_trn(*args): return _Hamlib.Rig_set_trn(*args)
    def has_set_level(*args): return _Hamlib.Rig_has_set_level(*args)
    def has_set_parm(*args): return _Hamlib.Rig_has_set_parm(*args)
    def has_set_func(*args): return _Hamlib.Rig_has_set_func(*args)
    def reset(*args): return _Hamlib.Rig_reset(*args)
    def has_scan(*args): return _Hamlib.Rig_has_scan(*args)
    def has_vfo_op(*args): return _Hamlib.Rig_has_vfo_op(*args)
    def passband_normal(*args): return _Hamlib.Rig_passband_normal(*args)
    def passband_narrow(*args): return _Hamlib.Rig_passband_narrow(*args)
    def passband_wide(*args): return _Hamlib.Rig_passband_wide(*args)
    def ext_token_lookup(*args): return _Hamlib.Rig_ext_token_lookup(*args)
    def token_lookup(*args): return _Hamlib.Rig_token_lookup(*args)
    def set_ext_parm(*args): return _Hamlib.Rig_set_ext_parm(*args)
    def set_parm(*args): return _Hamlib.Rig_set_parm(*args)
    def get_parm_i(*args): return _Hamlib.Rig_get_parm_i(*args)
    def get_parm_f(*args): return _Hamlib.Rig_get_parm_f(*args)
    def get_parm(*args): return _Hamlib.Rig_get_parm(*args)
    def set_conf(*args): return _Hamlib.Rig_set_conf(*args)
    def get_freq(*args): return _Hamlib.Rig_get_freq(*args)
    def get_mode(*args): return _Hamlib.Rig_get_mode(*args)
    def get_split_mode(*args): return _Hamlib.Rig_get_split_mode(*args)
    def get_vfo(*args): return _Hamlib.Rig_get_vfo(*args)
    def get_ptt(*args): return _Hamlib.Rig_get_ptt(*args)
    def get_rptr_shift(*args): return _Hamlib.Rig_get_rptr_shift(*args)
    def get_rptr_offs(*args): return _Hamlib.Rig_get_rptr_offs(*args)
    def get_ctcss_tone(*args): return _Hamlib.Rig_get_ctcss_tone(*args)
    def get_dcs_code(*args): return _Hamlib.Rig_get_dcs_code(*args)
    def get_ctcss_sql(*args): return _Hamlib.Rig_get_ctcss_sql(*args)
    def get_dcs_sql(*args): return _Hamlib.Rig_get_dcs_sql(*args)
    def get_split_freq(*args): return _Hamlib.Rig_get_split_freq(*args)
    def get_split_vfo(*args): return _Hamlib.Rig_get_split_vfo(*args)
    def get_rit(*args): return _Hamlib.Rig_get_rit(*args)
    def get_xit(*args): return _Hamlib.Rig_get_xit(*args)
    def get_ts(*args): return _Hamlib.Rig_get_ts(*args)
    def get_ant(*args): return _Hamlib.Rig_get_ant(*args)
    def get_mem(*args): return _Hamlib.Rig_get_mem(*args)
    def get_powerstat(*args): return _Hamlib.Rig_get_powerstat(*args)
    def get_trn(*args): return _Hamlib.Rig_get_trn(*args)
    def set_channel(*args): return _Hamlib.Rig_set_channel(*args)
    def get_channel(*args): return _Hamlib.Rig_get_channel(*args)
    def get_conf(*args): return _Hamlib.Rig_get_conf(*args)
    def recv_dtmf(*args): return _Hamlib.Rig_recv_dtmf(*args)
    def get_info(*args): return _Hamlib.Rig_get_info(*args)
    def get_func(*args): return _Hamlib.Rig_get_func(*args)
    def get_level(*args): return _Hamlib.Rig_get_level(*args)

class RigPtr(Rig):
    def __init__(self, this):
        _swig_setattr(self, Rig, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Rig, 'thisown', 0)
        _swig_setattr(self, Rig,self.__class__,Rig)
_Hamlib.Rig_swigregister(RigPtr)

MAX_STATIC = _Hamlib.MAX_STATIC
class Rot(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Rot, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Rot, name)
    def __repr__(self):
        return "<%s.%s; proxy of C Rot instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["rot"] = _Hamlib.Rot_rot_set
    __swig_getmethods__["rot"] = _Hamlib.Rot_rot_get
    if _newclass:rot = property(_Hamlib.Rot_rot_get, _Hamlib.Rot_rot_set)
    __swig_setmethods__["caps"] = _Hamlib.Rot_caps_set
    __swig_getmethods__["caps"] = _Hamlib.Rot_caps_get
    if _newclass:caps = property(_Hamlib.Rot_caps_get, _Hamlib.Rot_caps_set)
    __swig_setmethods__["state"] = _Hamlib.Rot_state_set
    __swig_getmethods__["state"] = _Hamlib.Rot_state_get
    if _newclass:state = property(_Hamlib.Rot_state_get, _Hamlib.Rot_state_set)
    __swig_setmethods__["error_status"] = _Hamlib.Rot_error_status_set
    __swig_getmethods__["error_status"] = _Hamlib.Rot_error_status_get
    if _newclass:error_status = property(_Hamlib.Rot_error_status_get, _Hamlib.Rot_error_status_set)
    __swig_setmethods__["do_exception"] = _Hamlib.Rot_do_exception_set
    __swig_getmethods__["do_exception"] = _Hamlib.Rot_do_exception_get
    if _newclass:do_exception = property(_Hamlib.Rot_do_exception_get, _Hamlib.Rot_do_exception_set)
    def __init__(self, *args):
        _swig_setattr(self, Rot, 'this', _Hamlib.new_Rot(*args))
        _swig_setattr(self, Rot, 'thisown', 1)
    def __del__(self, destroy=_Hamlib.delete_Rot):
        try:
            if self.thisown: destroy(self)
        except: pass

    def open(*args): return _Hamlib.Rot_open(*args)
    def close(*args): return _Hamlib.Rot_close(*args)
    def set_position(*args): return _Hamlib.Rot_set_position(*args)
    def get_position(*args): return _Hamlib.Rot_get_position(*args)
    def stop(*args): return _Hamlib.Rot_stop(*args)
    def park(*args): return _Hamlib.Rot_park(*args)
    def reset(*args): return _Hamlib.Rot_reset(*args)
    def move(*args): return _Hamlib.Rot_move(*args)
    def token_lookup(*args): return _Hamlib.Rot_token_lookup(*args)
    def set_conf(*args): return _Hamlib.Rot_set_conf(*args)
    def get_conf(*args): return _Hamlib.Rot_get_conf(*args)
    def get_info(*args): return _Hamlib.Rot_get_info(*args)

class RotPtr(Rot):
    def __init__(self, this):
        _swig_setattr(self, Rot, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, Rot, 'thisown', 0)
        _swig_setattr(self, Rot,self.__class__,Rot)
_Hamlib.Rot_swigregister(RotPtr)


