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

from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_Hamlib')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_Hamlib')
    _Hamlib = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_Hamlib', [dirname(__file__)])
        except ImportError:
            import _Hamlib
            return _Hamlib
        try:
            _mod = imp.load_module('_Hamlib', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _Hamlib = swig_import_helper()
    del swig_import_helper
else:
    import _Hamlib
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0

RIG_MODEL_NONE = _Hamlib.RIG_MODEL_NONE
RIG_MODEL_DUMMY = _Hamlib.RIG_MODEL_DUMMY
RIG_MODEL_NETRIGCTL = _Hamlib.RIG_MODEL_NETRIGCTL
RIG_MODEL_ARMSTRONG = _Hamlib.RIG_MODEL_ARMSTRONG
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_FT450 = _Hamlib.RIG_MODEL_FT450
RIG_MODEL_FT950 = _Hamlib.RIG_MODEL_FT950
RIG_MODEL_FT2000 = _Hamlib.RIG_MODEL_FT2000
RIG_MODEL_FT9000 = _Hamlib.RIG_MODEL_FT9000
RIG_MODEL_FT980 = _Hamlib.RIG_MODEL_FT980
RIG_MODEL_FTDX5000 = _Hamlib.RIG_MODEL_FTDX5000
RIG_MODEL_VX1700 = _Hamlib.RIG_MODEL_VX1700
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_K3 = _Hamlib.RIG_MODEL_K3
RIG_MODEL_TRC80 = _Hamlib.RIG_MODEL_TRC80
RIG_MODEL_TS590S = _Hamlib.RIG_MODEL_TS590S
RIG_MODEL_TRANSFOX = _Hamlib.RIG_MODEL_TRANSFOX
RIG_MODEL_THD72A = _Hamlib.RIG_MODEL_THD72A
RIG_MODEL_TMD710 = _Hamlib.RIG_MODEL_TMD710
RIG_MODEL_TMV71 = _Hamlib.RIG_MODEL_TMV71
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_IC7200 = _Hamlib.RIG_MODEL_IC7200
RIG_MODEL_IC7700 = _Hamlib.RIG_MODEL_IC7700
RIG_MODEL_IC7600 = _Hamlib.RIG_MODEL_IC7600
RIG_MODEL_IC92D = _Hamlib.RIG_MODEL_IC92D
RIG_MODEL_ICR9500 = _Hamlib.RIG_MODEL_ICR9500
RIG_MODEL_IC7410 = _Hamlib.RIG_MODEL_IC7410
RIG_MODEL_IC9100 = _Hamlib.RIG_MODEL_IC9100
RIG_MODEL_ICRX7 = _Hamlib.RIG_MODEL_ICRX7
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_DELTAII = _Hamlib.RIG_MODEL_DELTAII
RIG_MODEL_PCR1000 = _Hamlib.RIG_MODEL_PCR1000
RIG_MODEL_PCR100 = _Hamlib.RIG_MODEL_PCR100
RIG_MODEL_PCR1500 = _Hamlib.RIG_MODEL_PCR1500
RIG_MODEL_PCR2500 = _Hamlib.RIG_MODEL_PCR2500
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_AR7030P = _Hamlib.RIG_MODEL_AR7030P
RIG_MODEL_SR2200 = _Hamlib.RIG_MODEL_SR2200
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_BC780 = _Hamlib.RIG_MODEL_BC780
RIG_MODEL_BC245 = _Hamlib.RIG_MODEL_BC245
RIG_MODEL_BC895 = _Hamlib.RIG_MODEL_BC895
RIG_MODEL_PRO2052 = _Hamlib.RIG_MODEL_PRO2052
RIG_MODEL_BC235 = _Hamlib.RIG_MODEL_BC235
RIG_MODEL_BC250 = _Hamlib.RIG_MODEL_BC250
RIG_MODEL_BC785 = _Hamlib.RIG_MODEL_BC785
RIG_MODEL_BC786 = _Hamlib.RIG_MODEL_BC786
RIG_MODEL_BCT8 = _Hamlib.RIG_MODEL_BCT8
RIG_MODEL_BCD396T = _Hamlib.RIG_MODEL_BCD396T
RIG_MODEL_BCD996T = _Hamlib.RIG_MODEL_BCD996T
RIG_MODEL_BC898 = _Hamlib.RIG_MODEL_BC898
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_RA3702 = _Hamlib.RIG_MODEL_RA3702
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_TRP8255 = _Hamlib.RIG_MODEL_TRP8255
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_G305 = _Hamlib.RIG_MODEL_G305
RIG_MODEL_G315 = _Hamlib.RIG_MODEL_G315
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_TT588 = _Hamlib.RIG_MODEL_TT588
RIG_MODEL_RX331 = _Hamlib.RIG_MODEL_RX331
RIG_MODEL_TT599 = _Hamlib.RIG_MODEL_TT599
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_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_MODEL_DSP10 = _Hamlib.RIG_MODEL_DSP10
RIG_MODEL_SDR1000 = _Hamlib.RIG_MODEL_SDR1000
RIG_MODEL_SDR1000RFE = _Hamlib.RIG_MODEL_SDR1000RFE
RIG_MODEL_DTTSP = _Hamlib.RIG_MODEL_DTTSP
RIG_MODEL_DTTSP_UDP = _Hamlib.RIG_MODEL_DTTSP_UDP
RIG_MODEL_EKD500 = _Hamlib.RIG_MODEL_EKD500
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_MODEL_DDS60 = _Hamlib.RIG_MODEL_DDS60
RIG_MODEL_ELEKTOR507 = _Hamlib.RIG_MODEL_ELEKTOR507
RIG_MODEL_MINIVNA = _Hamlib.RIG_MODEL_MINIVNA
RIG_MODEL_SI570AVRUSB = _Hamlib.RIG_MODEL_SI570AVRUSB
RIG_MODEL_PMSDR = _Hamlib.RIG_MODEL_PMSDR
RIG_MODEL_SI570PICUSB = _Hamlib.RIG_MODEL_SI570PICUSB
RIG_MODEL_FIFISDR = _Hamlib.RIG_MODEL_FIFISDR
RIG_MODEL_FUNCUBEDONGLE = _Hamlib.RIG_MODEL_FUNCUBEDONGLE
RIG_MODEL_HIQSDR = _Hamlib.RIG_MODEL_HIQSDR
RIG_MODEL_V4L = _Hamlib.RIG_MODEL_V4L
RIG_MODEL_V4L2 = _Hamlib.RIG_MODEL_V4L2
RIG_MODEL_ESMC = _Hamlib.RIG_MODEL_ESMC
RIG_MODEL_EB200 = _Hamlib.RIG_MODEL_EB200
RIG_MODEL_PRM8060 = _Hamlib.RIG_MODEL_PRM8060
RIG_MODEL_PRM8070 = _Hamlib.RIG_MODEL_PRM8070
RIG_MODEL_ADT_200A = _Hamlib.RIG_MODEL_ADT_200A
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
NETRIGCTL_RET = _Hamlib.NETRIGCTL_RET
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_PORT_UDP_NETWORK = _Hamlib.RIG_PORT_UDP_NETWORK
RIG_PORT_CM108 = _Hamlib.RIG_PORT_CM108
RIG_PARITY_NONE = _Hamlib.RIG_PARITY_NONE
RIG_PARITY_ODD = _Hamlib.RIG_PARITY_ODD
RIG_PARITY_EVEN = _Hamlib.RIG_PARITY_EVEN
RIG_PARITY_MARK = _Hamlib.RIG_PARITY_MARK
RIG_PARITY_SPACE = _Hamlib.RIG_PARITY_SPACE
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_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
RIG_VFO_NONE = _Hamlib.RIG_VFO_NONE
RIG_VFO_TX_FLAG = _Hamlib.RIG_VFO_TX_FLAG
RIG_VFO_CURR = _Hamlib.RIG_VFO_CURR
RIG_VFO_MEM = _Hamlib.RIG_VFO_MEM
RIG_VFO_VFO = _Hamlib.RIG_VFO_VFO
RIG_VFO_TX = _Hamlib.RIG_VFO_TX
RIG_VFO_RX = _Hamlib.RIG_VFO_RX
RIG_VFO_MAIN = _Hamlib.RIG_VFO_MAIN
RIG_VFO_SUB = _Hamlib.RIG_VFO_SUB
RIG_VFO_A = _Hamlib.RIG_VFO_A
RIG_VFO_B = _Hamlib.RIG_VFO_B
RIG_VFO_C = _Hamlib.RIG_VFO_C
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_TONE = _Hamlib.RIG_TARGETABLE_TONE
RIG_TARGETABLE_FUNC = _Hamlib.RIG_TARGETABLE_FUNC
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_DCD_CM108 = _Hamlib.RIG_DCD_CM108
RIG_PTT_OFF = _Hamlib.RIG_PTT_OFF
RIG_PTT_ON = _Hamlib.RIG_PTT_ON
RIG_PTT_ON_MIC = _Hamlib.RIG_PTT_ON_MIC
RIG_PTT_ON_DATA = _Hamlib.RIG_PTT_ON_DATA
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_PTT_RIG_MICDATA = _Hamlib.RIG_PTT_RIG_MICDATA
RIG_PTT_CM108 = _Hamlib.RIG_PTT_CM108
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_CONF_BUTTON = _Hamlib.RIG_CONF_BUTTON
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)
    __repr__ = _swig_repr
    __swig_setmethods__["token"] = _Hamlib.confparams_token_set
    __swig_getmethods__["token"] = _Hamlib.confparams_token_get
    if _newclass:
        token = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_property(_Hamlib.confparams_type_get, _Hamlib.confparams_type_set)
    __swig_getmethods__["u"] = _Hamlib.confparams_u_get
    if _newclass:
        u = _swig_property(_Hamlib.confparams_u_get)

    def __init__(self):
        this = _Hamlib.new_confparams()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_confparams
    __del__ = lambda self: None
confparams_swigregister = _Hamlib.confparams_swigregister
confparams_swigregister(confparams)
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)
    __repr__ = _swig_repr
    __swig_getmethods__["n"] = _Hamlib.confparams_u_n_get
    if _newclass:
        n = _swig_property(_Hamlib.confparams_u_n_get)
    __swig_getmethods__["c"] = _Hamlib.confparams_u_c_get
    if _newclass:
        c = _swig_property(_Hamlib.confparams_u_c_get)

    def __init__(self):
        this = _Hamlib.new_confparams_u()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_confparams_u
    __del__ = lambda self: None
confparams_u_swigregister = _Hamlib.confparams_u_swigregister
confparams_u_swigregister(confparams_u)

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)
    __repr__ = _swig_repr
    __swig_setmethods__["combostr"] = _Hamlib.confparams_u_c_combostr_set
    __swig_getmethods__["combostr"] = _Hamlib.confparams_u_c_combostr_get
    if _newclass:
        combostr = _swig_property(_Hamlib.confparams_u_c_combostr_get, _Hamlib.confparams_u_c_combostr_set)

    def __init__(self):
        this = _Hamlib.new_confparams_u_c()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_confparams_u_c
    __del__ = lambda self: None
confparams_u_c_swigregister = _Hamlib.confparams_u_c_swigregister
confparams_u_c_swigregister(confparams_u_c)

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)
    __repr__ = _swig_repr
    __swig_setmethods__["min"] = _Hamlib.confparams_u_n_min_set
    __swig_getmethods__["min"] = _Hamlib.confparams_u_n_min_get
    if _newclass:
        min = _swig_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 = _swig_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 = _swig_property(_Hamlib.confparams_u_n_step_get, _Hamlib.confparams_u_n_step_set)

    def __init__(self):
        this = _Hamlib.new_confparams_u_n()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_confparams_u_n
    __del__ = lambda self: None
confparams_u_n_swigregister = _Hamlib.confparams_u_n_swigregister
confparams_u_n_swigregister(confparams_u_n)

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_AGC_AUTO = _Hamlib.RIG_AGC_AUTO
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
RIG_METER_PO = _Hamlib.RIG_METER_PO
RIG_METER_VDD = _Hamlib.RIG_METER_VDD
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)
    __repr__ = _swig_repr
    __swig_setmethods__["i"] = _Hamlib.value_t_i_set
    __swig_getmethods__["i"] = _Hamlib.value_t_i_get
    if _newclass:
        i = _swig_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 = _swig_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 = _swig_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 = _swig_property(_Hamlib.value_t_cs_get, _Hamlib.value_t_cs_set)

    def __init__(self):
        this = _Hamlib.new_value_t()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_value_t
    __del__ = lambda self: None
value_t_swigregister = _Hamlib.value_t_swigregister
value_t_swigregister(value_t)

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_SLOPE_LOW = _Hamlib.RIG_LEVEL_SLOPE_LOW
RIG_LEVEL_SLOPE_HIGH = _Hamlib.RIG_LEVEL_SLOPE_HIGH
RIG_LEVEL_BKIN_DLYMS = _Hamlib.RIG_LEVEL_BKIN_DLYMS
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_MODE_DSB = _Hamlib.RIG_MODE_DSB
RIG_MODE_TESTS_MAX = _Hamlib.RIG_MODE_TESTS_MAX
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)
    __repr__ = _swig_repr
    __swig_setmethods__["start"] = _Hamlib.freq_range_t_start_set
    __swig_getmethods__["start"] = _Hamlib.freq_range_t_start_get
    if _newclass:
        start = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_property(_Hamlib.freq_range_t_ant_get, _Hamlib.freq_range_t_ant_set)

    def __init__(self):
        this = _Hamlib.new_freq_range_t()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_freq_range_t
    __del__ = lambda self: None
freq_range_t_swigregister = _Hamlib.freq_range_t_swigregister
freq_range_t_swigregister(freq_range_t)

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)
    __repr__ = _swig_repr
    __swig_setmethods__["modes"] = _Hamlib.tuning_step_list_modes_set
    __swig_getmethods__["modes"] = _Hamlib.tuning_step_list_modes_get
    if _newclass:
        modes = _swig_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 = _swig_property(_Hamlib.tuning_step_list_ts_get, _Hamlib.tuning_step_list_ts_set)

    def __init__(self):
        this = _Hamlib.new_tuning_step_list()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_tuning_step_list
    __del__ = lambda self: None
tuning_step_list_swigregister = _Hamlib.tuning_step_list_swigregister
tuning_step_list_swigregister(tuning_step_list)

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)
    __repr__ = _swig_repr
    __swig_setmethods__["modes"] = _Hamlib.filter_list_modes_set
    __swig_getmethods__["modes"] = _Hamlib.filter_list_modes_get
    if _newclass:
        modes = _swig_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 = _swig_property(_Hamlib.filter_list_width_get, _Hamlib.filter_list_width_set)

    def __init__(self):
        this = _Hamlib.new_filter_list()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_filter_list
    __del__ = lambda self: None
filter_list_swigregister = _Hamlib.filter_list_swigregister
filter_list_swigregister(filter_list)

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)
    __repr__ = _swig_repr
    __swig_setmethods__["token"] = _Hamlib.ext_list_token_set
    __swig_getmethods__["token"] = _Hamlib.ext_list_token_get
    if _newclass:
        token = _swig_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 = _swig_property(_Hamlib.ext_list_val_get, _Hamlib.ext_list_val_set)

    def __init__(self):
        this = _Hamlib.new_ext_list()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_ext_list
    __del__ = lambda self: None
ext_list_swigregister = _Hamlib.ext_list_swigregister
ext_list_swigregister(ext_list)

class channel(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, channel, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, channel, name)
    __repr__ = _swig_repr
    __swig_setmethods__["channel_num"] = _Hamlib.channel_channel_num_set
    __swig_getmethods__["channel_num"] = _Hamlib.channel_channel_num_get
    if _newclass:
        channel_num = _swig_property(_Hamlib.channel_channel_num_get, _Hamlib.channel_channel_num_set)
    __swig_setmethods__["bank_num"] = _Hamlib.channel_bank_num_set
    __swig_getmethods__["bank_num"] = _Hamlib.channel_bank_num_get
    if _newclass:
        bank_num = _swig_property(_Hamlib.channel_bank_num_get, _Hamlib.channel_bank_num_set)
    __swig_setmethods__["vfo"] = _Hamlib.channel_vfo_set
    __swig_getmethods__["vfo"] = _Hamlib.channel_vfo_get
    if _newclass:
        vfo = _swig_property(_Hamlib.channel_vfo_get, _Hamlib.channel_vfo_set)
    __swig_setmethods__["ant"] = _Hamlib.channel_ant_set
    __swig_getmethods__["ant"] = _Hamlib.channel_ant_get
    if _newclass:
        ant = _swig_property(_Hamlib.channel_ant_get, _Hamlib.channel_ant_set)
    __swig_setmethods__["freq"] = _Hamlib.channel_freq_set
    __swig_getmethods__["freq"] = _Hamlib.channel_freq_get
    if _newclass:
        freq = _swig_property(_Hamlib.channel_freq_get, _Hamlib.channel_freq_set)
    __swig_setmethods__["mode"] = _Hamlib.channel_mode_set
    __swig_getmethods__["mode"] = _Hamlib.channel_mode_get
    if _newclass:
        mode = _swig_property(_Hamlib.channel_mode_get, _Hamlib.channel_mode_set)
    __swig_setmethods__["width"] = _Hamlib.channel_width_set
    __swig_getmethods__["width"] = _Hamlib.channel_width_get
    if _newclass:
        width = _swig_property(_Hamlib.channel_width_get, _Hamlib.channel_width_set)
    __swig_setmethods__["tx_freq"] = _Hamlib.channel_tx_freq_set
    __swig_getmethods__["tx_freq"] = _Hamlib.channel_tx_freq_get
    if _newclass:
        tx_freq = _swig_property(_Hamlib.channel_tx_freq_get, _Hamlib.channel_tx_freq_set)
    __swig_setmethods__["tx_mode"] = _Hamlib.channel_tx_mode_set
    __swig_getmethods__["tx_mode"] = _Hamlib.channel_tx_mode_get
    if _newclass:
        tx_mode = _swig_property(_Hamlib.channel_tx_mode_get, _Hamlib.channel_tx_mode_set)
    __swig_setmethods__["tx_width"] = _Hamlib.channel_tx_width_set
    __swig_getmethods__["tx_width"] = _Hamlib.channel_tx_width_get
    if _newclass:
        tx_width = _swig_property(_Hamlib.channel_tx_width_get, _Hamlib.channel_tx_width_set)
    __swig_setmethods__["split"] = _Hamlib.channel_split_set
    __swig_getmethods__["split"] = _Hamlib.channel_split_get
    if _newclass:
        split = _swig_property(_Hamlib.channel_split_get, _Hamlib.channel_split_set)
    __swig_setmethods__["tx_vfo"] = _Hamlib.channel_tx_vfo_set
    __swig_getmethods__["tx_vfo"] = _Hamlib.channel_tx_vfo_get
    if _newclass:
        tx_vfo = _swig_property(_Hamlib.channel_tx_vfo_get, _Hamlib.channel_tx_vfo_set)
    __swig_setmethods__["rptr_shift"] = _Hamlib.channel_rptr_shift_set
    __swig_getmethods__["rptr_shift"] = _Hamlib.channel_rptr_shift_get
    if _newclass:
        rptr_shift = _swig_property(_Hamlib.channel_rptr_shift_get, _Hamlib.channel_rptr_shift_set)
    __swig_setmethods__["rptr_offs"] = _Hamlib.channel_rptr_offs_set
    __swig_getmethods__["rptr_offs"] = _Hamlib.channel_rptr_offs_get
    if _newclass:
        rptr_offs = _swig_property(_Hamlib.channel_rptr_offs_get, _Hamlib.channel_rptr_offs_set)
    __swig_setmethods__["tuning_step"] = _Hamlib.channel_tuning_step_set
    __swig_getmethods__["tuning_step"] = _Hamlib.channel_tuning_step_get
    if _newclass:
        tuning_step = _swig_property(_Hamlib.channel_tuning_step_get, _Hamlib.channel_tuning_step_set)
    __swig_setmethods__["rit"] = _Hamlib.channel_rit_set
    __swig_getmethods__["rit"] = _Hamlib.channel_rit_get
    if _newclass:
        rit = _swig_property(_Hamlib.channel_rit_get, _Hamlib.channel_rit_set)
    __swig_setmethods__["xit"] = _Hamlib.channel_xit_set
    __swig_getmethods__["xit"] = _Hamlib.channel_xit_get
    if _newclass:
        xit = _swig_property(_Hamlib.channel_xit_get, _Hamlib.channel_xit_set)
    __swig_setmethods__["funcs"] = _Hamlib.channel_funcs_set
    __swig_getmethods__["funcs"] = _Hamlib.channel_funcs_get
    if _newclass:
        funcs = _swig_property(_Hamlib.channel_funcs_get, _Hamlib.channel_funcs_set)
    __swig_setmethods__["levels"] = _Hamlib.channel_levels_set
    __swig_getmethods__["levels"] = _Hamlib.channel_levels_get
    if _newclass:
        levels = _swig_property(_Hamlib.channel_levels_get, _Hamlib.channel_levels_set)
    __swig_setmethods__["ctcss_tone"] = _Hamlib.channel_ctcss_tone_set
    __swig_getmethods__["ctcss_tone"] = _Hamlib.channel_ctcss_tone_get
    if _newclass:
        ctcss_tone = _swig_property(_Hamlib.channel_ctcss_tone_get, _Hamlib.channel_ctcss_tone_set)
    __swig_setmethods__["ctcss_sql"] = _Hamlib.channel_ctcss_sql_set
    __swig_getmethods__["ctcss_sql"] = _Hamlib.channel_ctcss_sql_get
    if _newclass:
        ctcss_sql = _swig_property(_Hamlib.channel_ctcss_sql_get, _Hamlib.channel_ctcss_sql_set)
    __swig_setmethods__["dcs_code"] = _Hamlib.channel_dcs_code_set
    __swig_getmethods__["dcs_code"] = _Hamlib.channel_dcs_code_get
    if _newclass:
        dcs_code = _swig_property(_Hamlib.channel_dcs_code_get, _Hamlib.channel_dcs_code_set)
    __swig_setmethods__["dcs_sql"] = _Hamlib.channel_dcs_sql_set
    __swig_getmethods__["dcs_sql"] = _Hamlib.channel_dcs_sql_get
    if _newclass:
        dcs_sql = _swig_property(_Hamlib.channel_dcs_sql_get, _Hamlib.channel_dcs_sql_set)
    __swig_setmethods__["scan_group"] = _Hamlib.channel_scan_group_set
    __swig_getmethods__["scan_group"] = _Hamlib.channel_scan_group_get
    if _newclass:
        scan_group = _swig_property(_Hamlib.channel_scan_group_get, _Hamlib.channel_scan_group_set)
    __swig_setmethods__["flags"] = _Hamlib.channel_flags_set
    __swig_getmethods__["flags"] = _Hamlib.channel_flags_get
    if _newclass:
        flags = _swig_property(_Hamlib.channel_flags_get, _Hamlib.channel_flags_set)
    __swig_setmethods__["channel_desc"] = _Hamlib.channel_channel_desc_set
    __swig_getmethods__["channel_desc"] = _Hamlib.channel_channel_desc_get
    if _newclass:
        channel_desc = _swig_property(_Hamlib.channel_channel_desc_get, _Hamlib.channel_channel_desc_set)
    __swig_setmethods__["ext_levels"] = _Hamlib.channel_ext_levels_set
    __swig_getmethods__["ext_levels"] = _Hamlib.channel_ext_levels_get
    if _newclass:
        ext_levels = _swig_property(_Hamlib.channel_ext_levels_get, _Hamlib.channel_ext_levels_set)

    def __init__(self, *args):
        this = _Hamlib.new_channel(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_channel
    __del__ = lambda self: None
channel_swigregister = _Hamlib.channel_swigregister
channel_swigregister(channel)

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)
    __repr__ = _swig_repr
    __swig_setmethods__["bank_num"] = _Hamlib.channel_cap_bank_num_set
    __swig_getmethods__["bank_num"] = _Hamlib.channel_cap_bank_num_get
    if _newclass:
        bank_num = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_property(_Hamlib.channel_cap_ext_levels_get, _Hamlib.channel_cap_ext_levels_set)

    def __init__(self):
        this = _Hamlib.new_channel_cap()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_channel_cap
    __del__ = lambda self: None
channel_cap_swigregister = _Hamlib.channel_cap_swigregister
channel_cap_swigregister(channel_cap)

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
RIG_MTYPE_BAND = _Hamlib.RIG_MTYPE_BAND
RIG_MTYPE_PRIO = _Hamlib.RIG_MTYPE_PRIO
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)
    __repr__ = _swig_repr
    __swig_setmethods__["start"] = _Hamlib.chan_list_start_set
    __swig_getmethods__["start"] = _Hamlib.chan_list_start_get
    if _newclass:
        start = _swig_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 = _swig_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 = _swig_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 = _swig_property(_Hamlib.chan_list_mem_caps_get, _Hamlib.chan_list_mem_caps_set)

    def __init__(self):
        this = _Hamlib.new_chan_list()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_chan_list
    __del__ = lambda self: None
chan_list_swigregister = _Hamlib.chan_list_swigregister
chan_list_swigregister(chan_list)

RIG_MEM_CAPS_ALL = _Hamlib.RIG_MEM_CAPS_ALL
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)
    __repr__ = _swig_repr
    __swig_setmethods__["min"] = _Hamlib.gran_min_set
    __swig_getmethods__["min"] = _Hamlib.gran_min_get
    if _newclass:
        min = _swig_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 = _swig_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 = _swig_property(_Hamlib.gran_step_get, _Hamlib.gran_step_set)

    def __init__(self):
        this = _Hamlib.new_gran()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_gran
    __del__ = lambda self: None
gran_swigregister = _Hamlib.gran_swigregister
gran_swigregister(gran)

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)
    __repr__ = _swig_repr
    __swig_setmethods__["size"] = _Hamlib.cal_table_size_set
    __swig_getmethods__["size"] = _Hamlib.cal_table_size_get
    if _newclass:
        size = _swig_property(_Hamlib.cal_table_size_get, _Hamlib.cal_table_size_set)
    __swig_getmethods__["table"] = _Hamlib.cal_table_table_get
    if _newclass:
        table = _swig_property(_Hamlib.cal_table_table_get)

    def __init__(self):
        this = _Hamlib.new_cal_table()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_cal_table
    __del__ = lambda self: None
cal_table_swigregister = _Hamlib.cal_table_swigregister
cal_table_swigregister(cal_table)

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)
    __repr__ = _swig_repr
    __swig_setmethods__["raw"] = _Hamlib.cal_table_table_raw_set
    __swig_getmethods__["raw"] = _Hamlib.cal_table_table_raw_get
    if _newclass:
        raw = _swig_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 = _swig_property(_Hamlib.cal_table_table_val_get, _Hamlib.cal_table_table_val_set)

    def __init__(self):
        this = _Hamlib.new_cal_table_table()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_cal_table_table
    __del__ = lambda self: None
cal_table_table_swigregister = _Hamlib.cal_table_table_swigregister
cal_table_table_swigregister(cal_table_table)

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)
    __repr__ = _swig_repr
    __swig_setmethods__["rig_model"] = _Hamlib.rig_caps_rig_model_set
    __swig_getmethods__["rig_model"] = _Hamlib.rig_caps_rig_model_get
    if _newclass:
        rig_model = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_property(_Hamlib.rig_caps_clone_combo_get_get, _Hamlib.rig_caps_clone_combo_get_set)

    def __init__(self):
        this = _Hamlib.new_rig_caps()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_rig_caps
    __del__ = lambda self: None
rig_caps_swigregister = _Hamlib.rig_caps_swigregister
rig_caps_swigregister(rig_caps)

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)
    __repr__ = _swig_repr
    __swig_getmethods__["type"] = _Hamlib.hamlib_port_t_type_get
    if _newclass:
        type = _swig_property(_Hamlib.hamlib_port_t_type_get)
    __swig_setmethods__["fd"] = _Hamlib.hamlib_port_t_fd_set
    __swig_getmethods__["fd"] = _Hamlib.hamlib_port_t_fd_get
    if _newclass:
        fd = _swig_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 = _swig_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 = _swig_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 = _swig_property(_Hamlib.hamlib_port_t_post_write_delay_get, _Hamlib.hamlib_port_t_post_write_delay_set)
    __swig_getmethods__["post_write_date"] = _Hamlib.hamlib_port_t_post_write_date_get
    if _newclass:
        post_write_date = _swig_property(_Hamlib.hamlib_port_t_post_write_date_get)
    __swig_setmethods__["timeout"] = _Hamlib.hamlib_port_t_timeout_set
    __swig_getmethods__["timeout"] = _Hamlib.hamlib_port_t_timeout_get
    if _newclass:
        timeout = _swig_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 = _swig_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 = _swig_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 = _swig_property(_Hamlib.hamlib_port_t_parm_get)

    def __init__(self):
        this = _Hamlib.new_hamlib_port_t()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_hamlib_port_t
    __del__ = lambda self: None
hamlib_port_t_swigregister = _Hamlib.hamlib_port_t_swigregister
hamlib_port_t_swigregister(hamlib_port_t)

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)
    __repr__ = _swig_repr
    __swig_getmethods__["serial"] = _Hamlib.hamlib_port_t_parm_serial_get
    if _newclass:
        serial = _swig_property(_Hamlib.hamlib_port_t_parm_serial_get)
    __swig_getmethods__["parallel"] = _Hamlib.hamlib_port_t_parm_parallel_get
    if _newclass:
        parallel = _swig_property(_Hamlib.hamlib_port_t_parm_parallel_get)
    __swig_getmethods__["cm108"] = _Hamlib.hamlib_port_t_parm_cm108_get
    if _newclass:
        cm108 = _swig_property(_Hamlib.hamlib_port_t_parm_cm108_get)
    __swig_getmethods__["usb"] = _Hamlib.hamlib_port_t_parm_usb_get
    if _newclass:
        usb = _swig_property(_Hamlib.hamlib_port_t_parm_usb_get)

    def __init__(self):
        this = _Hamlib.new_hamlib_port_t_parm()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_hamlib_port_t_parm
    __del__ = lambda self: None
hamlib_port_t_parm_swigregister = _Hamlib.hamlib_port_t_parm_swigregister
hamlib_port_t_parm_swigregister(hamlib_port_t_parm)

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)
    __repr__ = _swig_repr
    __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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_property(_Hamlib.hamlib_port_t_parm_usb_alt_get, _Hamlib.hamlib_port_t_parm_usb_alt_set)
    __swig_setmethods__["vendor_name"] = _Hamlib.hamlib_port_t_parm_usb_vendor_name_set
    __swig_getmethods__["vendor_name"] = _Hamlib.hamlib_port_t_parm_usb_vendor_name_get
    if _newclass:
        vendor_name = _swig_property(_Hamlib.hamlib_port_t_parm_usb_vendor_name_get, _Hamlib.hamlib_port_t_parm_usb_vendor_name_set)
    __swig_setmethods__["product"] = _Hamlib.hamlib_port_t_parm_usb_product_set
    __swig_getmethods__["product"] = _Hamlib.hamlib_port_t_parm_usb_product_get
    if _newclass:
        product = _swig_property(_Hamlib.hamlib_port_t_parm_usb_product_get, _Hamlib.hamlib_port_t_parm_usb_product_set)

    def __init__(self):
        this = _Hamlib.new_hamlib_port_t_parm_usb()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_hamlib_port_t_parm_usb
    __del__ = lambda self: None
hamlib_port_t_parm_usb_swigregister = _Hamlib.hamlib_port_t_parm_usb_swigregister
hamlib_port_t_parm_usb_swigregister(hamlib_port_t_parm_usb)

class hamlib_port_t_parm_cm108(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, hamlib_port_t_parm_cm108, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, hamlib_port_t_parm_cm108, name)
    __repr__ = _swig_repr
    __swig_setmethods__["ptt_bitnum"] = _Hamlib.hamlib_port_t_parm_cm108_ptt_bitnum_set
    __swig_getmethods__["ptt_bitnum"] = _Hamlib.hamlib_port_t_parm_cm108_ptt_bitnum_get
    if _newclass:
        ptt_bitnum = _swig_property(_Hamlib.hamlib_port_t_parm_cm108_ptt_bitnum_get, _Hamlib.hamlib_port_t_parm_cm108_ptt_bitnum_set)

    def __init__(self):
        this = _Hamlib.new_hamlib_port_t_parm_cm108()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_hamlib_port_t_parm_cm108
    __del__ = lambda self: None
hamlib_port_t_parm_cm108_swigregister = _Hamlib.hamlib_port_t_parm_cm108_swigregister
hamlib_port_t_parm_cm108_swigregister(hamlib_port_t_parm_cm108)

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)
    __repr__ = _swig_repr
    __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 = _swig_property(_Hamlib.hamlib_port_t_parm_parallel_pin_get, _Hamlib.hamlib_port_t_parm_parallel_pin_set)

    def __init__(self):
        this = _Hamlib.new_hamlib_port_t_parm_parallel()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_hamlib_port_t_parm_parallel
    __del__ = lambda self: None
hamlib_port_t_parm_parallel_swigregister = _Hamlib.hamlib_port_t_parm_parallel_swigregister
hamlib_port_t_parm_parallel_swigregister(hamlib_port_t_parm_parallel)

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)
    __repr__ = _swig_repr
    __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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_property(_Hamlib.hamlib_port_t_parm_serial_dtr_state_get, _Hamlib.hamlib_port_t_parm_serial_dtr_state_set)

    def __init__(self):
        this = _Hamlib.new_hamlib_port_t_parm_serial()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_hamlib_port_t_parm_serial
    __del__ = lambda self: None
hamlib_port_t_parm_serial_swigregister = _Hamlib.hamlib_port_t_parm_serial_swigregister
hamlib_port_t_parm_serial_swigregister(hamlib_port_t_parm_serial)

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)
    __repr__ = _swig_repr
    __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 = _swig_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 = _swig_property(_Hamlib.hamlib_port_t_post_write_date_tv_usec_get, _Hamlib.hamlib_port_t_post_write_date_tv_usec_set)

    def __init__(self):
        this = _Hamlib.new_hamlib_port_t_post_write_date()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_hamlib_port_t_post_write_date
    __del__ = lambda self: None
hamlib_port_t_post_write_date_swigregister = _Hamlib.hamlib_port_t_post_write_date_swigregister
hamlib_port_t_post_write_date_swigregister(hamlib_port_t_post_write_date)

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)
    __repr__ = _swig_repr
    __swig_setmethods__["rig"] = _Hamlib.hamlib_port_t_type_rig_set
    __swig_getmethods__["rig"] = _Hamlib.hamlib_port_t_type_rig_get
    if _newclass:
        rig = _swig_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 = _swig_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 = _swig_property(_Hamlib.hamlib_port_t_type_dcd_get, _Hamlib.hamlib_port_t_type_dcd_set)

    def __init__(self):
        this = _Hamlib.new_hamlib_port_t_type()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_hamlib_port_t_type
    __del__ = lambda self: None
hamlib_port_t_type_swigregister = _Hamlib.hamlib_port_t_type_swigregister
hamlib_port_t_type_swigregister(hamlib_port_t_type)

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)
    __repr__ = _swig_repr
    __swig_setmethods__["rigport"] = _Hamlib.rig_state_rigport_set
    __swig_getmethods__["rigport"] = _Hamlib.rig_state_rigport_get
    if _newclass:
        rigport = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_property(_Hamlib.rig_state_current_width_get, _Hamlib.rig_state_current_width_set)
    __swig_setmethods__["tx_vfo"] = _Hamlib.rig_state_tx_vfo_set
    __swig_getmethods__["tx_vfo"] = _Hamlib.rig_state_tx_vfo_get
    if _newclass:
        tx_vfo = _swig_property(_Hamlib.rig_state_tx_vfo_get, _Hamlib.rig_state_tx_vfo_set)
    __swig_setmethods__["mode_list"] = _Hamlib.rig_state_mode_list_set
    __swig_getmethods__["mode_list"] = _Hamlib.rig_state_mode_list_get
    if _newclass:
        mode_list = _swig_property(_Hamlib.rig_state_mode_list_get, _Hamlib.rig_state_mode_list_set)

    def __init__(self):
        this = _Hamlib.new_rig_state()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_rig_state
    __del__ = lambda self: None
rig_state_swigregister = _Hamlib.rig_state_swigregister
rig_state_swigregister(rig_state)

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)
    __repr__ = _swig_repr
    __swig_setmethods__["freq_event"] = _Hamlib.rig_callbacks_freq_event_set
    __swig_getmethods__["freq_event"] = _Hamlib.rig_callbacks_freq_event_get
    if _newclass:
        freq_event = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_property(_Hamlib.rig_callbacks_pltune_arg_get, _Hamlib.rig_callbacks_pltune_arg_set)

    def __init__(self):
        this = _Hamlib.new_rig_callbacks()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_rig_callbacks
    __del__ = lambda self: None
rig_callbacks_swigregister = _Hamlib.rig_callbacks_swigregister
rig_callbacks_swigregister(rig_callbacks)

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)
    __repr__ = _swig_repr
    __swig_setmethods__["caps"] = _Hamlib.rig_caps_set
    __swig_getmethods__["caps"] = _Hamlib.rig_caps_get
    if _newclass:
        caps = _swig_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 = _swig_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 = _swig_property(_Hamlib.rig_callbacks_get, _Hamlib.rig_callbacks_set)

    def __init__(self):
        this = _Hamlib.new_rig()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_rig
    __del__ = lambda self: None
rig_swigregister = _Hamlib.rig_swigregister
rig_swigregister(rig)


def rig_init(rig_model):
    return _Hamlib.rig_init(rig_model)
rig_init = _Hamlib.rig_init

def rig_set_split_vfo(arg1, rx_vfo, split, tx_vfo):
    return _Hamlib.rig_set_split_vfo(arg1, rx_vfo, split, tx_vfo)
rig_set_split_vfo = _Hamlib.rig_set_split_vfo

def rig_get_split_vfo(arg1, rx_vfo, split, tx_vfo):
    return _Hamlib.rig_get_split_vfo(arg1, rx_vfo, split, tx_vfo)
rig_get_split_vfo = _Hamlib.rig_get_split_vfo

def rig_ext_lookup(rig, name):
    return _Hamlib.rig_ext_lookup(rig, name)
rig_ext_lookup = _Hamlib.rig_ext_lookup

def rig_ext_lookup_tok(rig, token):
    return _Hamlib.rig_ext_lookup_tok(rig, token)
rig_ext_lookup_tok = _Hamlib.rig_ext_lookup_tok

def rig_ext_token_lookup(rig, name):
    return _Hamlib.rig_ext_token_lookup(rig, name)
rig_ext_token_lookup = _Hamlib.rig_ext_token_lookup

def rig_token_foreach(rig, cfunc, data):
    return _Hamlib.rig_token_foreach(rig, cfunc, data)
rig_token_foreach = _Hamlib.rig_token_foreach

def rig_confparam_lookup(rig, name):
    return _Hamlib.rig_confparam_lookup(rig, name)
rig_confparam_lookup = _Hamlib.rig_confparam_lookup

def rig_set_chan_all(rig, chans):
    return _Hamlib.rig_set_chan_all(rig, chans)
rig_set_chan_all = _Hamlib.rig_set_chan_all

def rig_get_chan_all(rig, chans):
    return _Hamlib.rig_get_chan_all(rig, chans)
rig_get_chan_all = _Hamlib.rig_get_chan_all

def rig_set_chan_all_cb(rig, chan_cb, arg3):
    return _Hamlib.rig_set_chan_all_cb(rig, chan_cb, arg3)
rig_set_chan_all_cb = _Hamlib.rig_set_chan_all_cb

def rig_get_chan_all_cb(rig, chan_cb, arg3):
    return _Hamlib.rig_get_chan_all_cb(rig, chan_cb, arg3)
rig_get_chan_all_cb = _Hamlib.rig_get_chan_all_cb

def rig_set_mem_all_cb(rig, chan_cb, parm_cb, arg4):
    return _Hamlib.rig_set_mem_all_cb(rig, chan_cb, parm_cb, arg4)
rig_set_mem_all_cb = _Hamlib.rig_set_mem_all_cb

def rig_get_mem_all_cb(rig, chan_cb, parm_cb, arg4):
    return _Hamlib.rig_get_mem_all_cb(rig, chan_cb, parm_cb, arg4)
rig_get_mem_all_cb = _Hamlib.rig_get_mem_all_cb

def rig_set_mem_all(rig, chan, arg3, arg4):
    return _Hamlib.rig_set_mem_all(rig, chan, arg3, arg4)
rig_set_mem_all = _Hamlib.rig_set_mem_all

def rig_get_mem_all(rig, chan, arg3, arg4):
    return _Hamlib.rig_get_mem_all(rig, chan, arg3, arg4)
rig_get_mem_all = _Hamlib.rig_get_mem_all

def rig_lookup_mem_caps(rig, ch):
    return _Hamlib.rig_lookup_mem_caps(rig, ch)
rig_lookup_mem_caps = _Hamlib.rig_lookup_mem_caps

def rig_mem_count(rig):
    return _Hamlib.rig_mem_count(rig)
rig_mem_count = _Hamlib.rig_mem_count

def rig_get_caps(rig_model):
    return _Hamlib.rig_get_caps(rig_model)
rig_get_caps = _Hamlib.rig_get_caps

def rig_get_range(range_list, freq, mode):
    return _Hamlib.rig_get_range(range_list, freq, mode)
rig_get_range = _Hamlib.rig_get_range

def rigerror(errnum):
    return _Hamlib.rigerror(errnum)
rigerror = _Hamlib.rigerror

def rig_setting2idx(s):
    return _Hamlib.rig_setting2idx(s)
rig_setting2idx = _Hamlib.rig_setting2idx

def rig_set_debug(debug_level):
    return _Hamlib.rig_set_debug(debug_level)
rig_set_debug = _Hamlib.rig_set_debug

def rig_need_debug(debug_level):
    return _Hamlib.rig_need_debug(debug_level)
rig_need_debug = _Hamlib.rig_need_debug

def rig_debug(debug_level, fmt):
    return _Hamlib.rig_debug(debug_level, fmt)
rig_debug = _Hamlib.rig_debug

def rig_set_debug_callback(cb, arg):
    return _Hamlib.rig_set_debug_callback(cb, arg)
rig_set_debug_callback = _Hamlib.rig_set_debug_callback

def rig_set_debug_file(stream):
    return _Hamlib.rig_set_debug_file(stream)
rig_set_debug_file = _Hamlib.rig_set_debug_file

def rig_register(caps):
    return _Hamlib.rig_register(caps)
rig_register = _Hamlib.rig_register

def rig_unregister(rig_model):
    return _Hamlib.rig_unregister(rig_model)
rig_unregister = _Hamlib.rig_unregister

def rig_list_foreach(cfunc, data):
    return _Hamlib.rig_list_foreach(cfunc, data)
rig_list_foreach = _Hamlib.rig_list_foreach

def rig_load_backend(be_name):
    return _Hamlib.rig_load_backend(be_name)
rig_load_backend = _Hamlib.rig_load_backend

def rig_check_backend(rig_model):
    return _Hamlib.rig_check_backend(rig_model)
rig_check_backend = _Hamlib.rig_check_backend

def rig_load_all_backends():
    return _Hamlib.rig_load_all_backends()
rig_load_all_backends = _Hamlib.rig_load_all_backends

def rig_probe_all(p, arg2, arg3):
    return _Hamlib.rig_probe_all(p, arg2, arg3)
rig_probe_all = _Hamlib.rig_probe_all

def rig_strrmode(mode):
    return _Hamlib.rig_strrmode(mode)
rig_strrmode = _Hamlib.rig_strrmode

def rig_strvfo(vfo):
    return _Hamlib.rig_strvfo(vfo)
rig_strvfo = _Hamlib.rig_strvfo

def rig_strfunc(arg1):
    return _Hamlib.rig_strfunc(arg1)
rig_strfunc = _Hamlib.rig_strfunc

def rig_strlevel(arg1):
    return _Hamlib.rig_strlevel(arg1)
rig_strlevel = _Hamlib.rig_strlevel

def rig_strparm(arg1):
    return _Hamlib.rig_strparm(arg1)
rig_strparm = _Hamlib.rig_strparm

def rig_strptrshift(arg1):
    return _Hamlib.rig_strptrshift(arg1)
rig_strptrshift = _Hamlib.rig_strptrshift

def rig_strvfop(op):
    return _Hamlib.rig_strvfop(op)
rig_strvfop = _Hamlib.rig_strvfop

def rig_strscan(scan):
    return _Hamlib.rig_strscan(scan)
rig_strscan = _Hamlib.rig_strscan

def rig_strstatus(status):
    return _Hamlib.rig_strstatus(status)
rig_strstatus = _Hamlib.rig_strstatus

def rig_strmtype(mtype):
    return _Hamlib.rig_strmtype(mtype)
rig_strmtype = _Hamlib.rig_strmtype

def rig_parse_mode(s):
    return _Hamlib.rig_parse_mode(s)
rig_parse_mode = _Hamlib.rig_parse_mode

def rig_parse_vfo(s):
    return _Hamlib.rig_parse_vfo(s)
rig_parse_vfo = _Hamlib.rig_parse_vfo

def rig_parse_func(s):
    return _Hamlib.rig_parse_func(s)
rig_parse_func = _Hamlib.rig_parse_func

def rig_parse_level(s):
    return _Hamlib.rig_parse_level(s)
rig_parse_level = _Hamlib.rig_parse_level

def rig_parse_parm(s):
    return _Hamlib.rig_parse_parm(s)
rig_parse_parm = _Hamlib.rig_parse_parm

def rig_parse_vfo_op(s):
    return _Hamlib.rig_parse_vfo_op(s)
rig_parse_vfo_op = _Hamlib.rig_parse_vfo_op

def rig_parse_scan(s):
    return _Hamlib.rig_parse_scan(s)
rig_parse_scan = _Hamlib.rig_parse_scan

def rig_parse_rptr_shift(s):
    return _Hamlib.rig_parse_rptr_shift(s)
rig_parse_rptr_shift = _Hamlib.rig_parse_rptr_shift

def rig_parse_mtype(s):
    return _Hamlib.rig_parse_mtype(s)
rig_parse_mtype = _Hamlib.rig_parse_mtype
ROT_MODEL_NONE = _Hamlib.ROT_MODEL_NONE
ROT_MODEL_DUMMY = _Hamlib.ROT_MODEL_DUMMY
ROT_MODEL_NETROTCTL = _Hamlib.ROT_MODEL_NETROTCTL
ROT_MODEL_RPC = _Hamlib.ROT_MODEL_RPC
ROT_MODEL_EASYCOMM1 = _Hamlib.ROT_MODEL_EASYCOMM1
ROT_MODEL_EASYCOMM2 = _Hamlib.ROT_MODEL_EASYCOMM2
ROT_MODEL_TRAKBOX = _Hamlib.ROT_MODEL_TRAKBOX
ROT_MODEL_FODTRACK = _Hamlib.ROT_MODEL_FODTRACK
ROT_MODEL_ROTOREZ = _Hamlib.ROT_MODEL_ROTOREZ
ROT_MODEL_ROTORCARD = _Hamlib.ROT_MODEL_ROTORCARD
ROT_MODEL_DCU = _Hamlib.ROT_MODEL_DCU
ROT_MODEL_ERC = _Hamlib.ROT_MODEL_ERC
ROT_MODEL_SARTEK1 = _Hamlib.ROT_MODEL_SARTEK1
ROT_MODEL_GS232A = _Hamlib.ROT_MODEL_GS232A
ROT_MODEL_GS232 = _Hamlib.ROT_MODEL_GS232
ROT_MODEL_GS232B = _Hamlib.ROT_MODEL_GS232B
ROT_MODEL_F1TETRACKER = _Hamlib.ROT_MODEL_F1TETRACKER
ROT_MODEL_PCROTOR = _Hamlib.ROT_MODEL_PCROTOR
ROT_MODEL_HD1780 = _Hamlib.ROT_MODEL_HD1780
ROT_MODEL_SPID_ROT2PROG = _Hamlib.ROT_MODEL_SPID_ROT2PROG
ROT_MODEL_SPID_ROT1PROG = _Hamlib.ROT_MODEL_SPID_ROT1PROG
ROT_MODEL_RC2800 = _Hamlib.ROT_MODEL_RC2800
ROT_MODEL_RCI_AZEL = _Hamlib.ROT_MODEL_RCI_AZEL
ROT_MODEL_RCI_AZ = _Hamlib.ROT_MODEL_RCI_AZ
ROT_MODEL_IF100 = _Hamlib.ROT_MODEL_IF100
ROT_MODEL_TS7400 = _Hamlib.ROT_MODEL_TS7400
ROT_MODEL_NEXSTAR = _Hamlib.ROT_MODEL_NEXSTAR
NETROTCTL_RET = _Hamlib.NETROTCTL_RET
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)
    __repr__ = _swig_repr
    __swig_setmethods__["rot_model"] = _Hamlib.rot_caps_rot_model_set
    __swig_getmethods__["rot_model"] = _Hamlib.rot_caps_rot_model_get
    if _newclass:
        rot_model = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_property(_Hamlib.rot_caps_get_info_get, _Hamlib.rot_caps_get_info_set)

    def __init__(self):
        this = _Hamlib.new_rot_caps()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_rot_caps
    __del__ = lambda self: None
rot_caps_swigregister = _Hamlib.rot_caps_swigregister
rot_caps_swigregister(rot_caps)

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)
    __repr__ = _swig_repr
    __swig_setmethods__["min_az"] = _Hamlib.rot_state_min_az_set
    __swig_getmethods__["min_az"] = _Hamlib.rot_state_min_az_get
    if _newclass:
        min_az = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_property(_Hamlib.rot_state_obj_get, _Hamlib.rot_state_obj_set)

    def __init__(self):
        this = _Hamlib.new_rot_state()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_rot_state
    __del__ = lambda self: None
rot_state_swigregister = _Hamlib.rot_state_swigregister
rot_state_swigregister(rot_state)

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)
    __repr__ = _swig_repr
    __swig_setmethods__["caps"] = _Hamlib.rot_caps_set
    __swig_getmethods__["caps"] = _Hamlib.rot_caps_get
    if _newclass:
        caps = _swig_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 = _swig_property(_Hamlib.rot_state_get, _Hamlib.rot_state_set)

    def __init__(self):
        this = _Hamlib.new_rot()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_rot
    __del__ = lambda self: None
rot_swigregister = _Hamlib.rot_swigregister
rot_swigregister(rot)


def rot_init(rot_model):
    return _Hamlib.rot_init(rot_model)
rot_init = _Hamlib.rot_init

def rot_register(caps):
    return _Hamlib.rot_register(caps)
rot_register = _Hamlib.rot_register

def rot_unregister(rot_model):
    return _Hamlib.rot_unregister(rot_model)
rot_unregister = _Hamlib.rot_unregister

def rot_list_foreach(cfunc, data):
    return _Hamlib.rot_list_foreach(cfunc, data)
rot_list_foreach = _Hamlib.rot_list_foreach

def rot_load_backend(be_name):
    return _Hamlib.rot_load_backend(be_name)
rot_load_backend = _Hamlib.rot_load_backend

def rot_check_backend(rot_model):
    return _Hamlib.rot_check_backend(rot_model)
rot_check_backend = _Hamlib.rot_check_backend

def rot_load_all_backends():
    return _Hamlib.rot_load_all_backends()
rot_load_all_backends = _Hamlib.rot_load_all_backends

def rot_probe_all(p):
    return _Hamlib.rot_probe_all(p)
rot_probe_all = _Hamlib.rot_probe_all

def rot_token_foreach(rot, cfunc, data):
    return _Hamlib.rot_token_foreach(rot, cfunc, data)
rot_token_foreach = _Hamlib.rot_token_foreach

def rot_confparam_lookup(rot, name):
    return _Hamlib.rot_confparam_lookup(rot, name)
rot_confparam_lookup = _Hamlib.rot_confparam_lookup

def rot_token_lookup(rot, name):
    return _Hamlib.rot_token_lookup(rot, name)
rot_token_lookup = _Hamlib.rot_token_lookup

def rot_get_caps(rot_model):
    return _Hamlib.rot_get_caps(rot_model)
rot_get_caps = _Hamlib.rot_get_caps

def qrb(lon1, lat1, lon2, lat2):
    return _Hamlib.qrb(lon1, lat1, lon2, lat2)
qrb = _Hamlib.qrb

def distance_long_path(distance):
    return _Hamlib.distance_long_path(distance)
distance_long_path = _Hamlib.distance_long_path

def azimuth_long_path(azimuth):
    return _Hamlib.azimuth_long_path(azimuth)
azimuth_long_path = _Hamlib.azimuth_long_path

def longlat2locator(longitude, latitude, pair_count):
    return _Hamlib.longlat2locator(longitude, latitude, pair_count)
longlat2locator = _Hamlib.longlat2locator

def locator2longlat(locator):
    return _Hamlib.locator2longlat(locator)
locator2longlat = _Hamlib.locator2longlat

def dms2dec(degrees, minutes, seconds, sw):
    return _Hamlib.dms2dec(degrees, minutes, seconds, sw)
dms2dec = _Hamlib.dms2dec

def dec2dms(dec):
    return _Hamlib.dec2dms(dec)
dec2dms = _Hamlib.dec2dms

def dec2dmmm(dec):
    return _Hamlib.dec2dmmm(dec)
dec2dmmm = _Hamlib.dec2dmmm

def dmmm2dec(degrees, minutes, sw):
    return _Hamlib.dmmm2dec(degrees, minutes, sw)
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)
    __repr__ = _swig_repr
    __swig_setmethods__["rig"] = _Hamlib.Rig_rig_set
    __swig_getmethods__["rig"] = _Hamlib.Rig_rig_get
    if _newclass:
        rig = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_property(_Hamlib.Rig_do_exception_get, _Hamlib.Rig_do_exception_set)

    def __init__(self, rig_model):
        this = _Hamlib.new_Rig(rig_model)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_Rig
    __del__ = lambda self: None

    def open(self):
        return _Hamlib.Rig_open(self)

    def close(self):
        return _Hamlib.Rig_close(self)

    def set_freq(self, *args):
        return _Hamlib.Rig_set_freq(self, *args)

    def set_mode(self, *args):
        return _Hamlib.Rig_set_mode(self, *args)

    def set_ptt(self, *args):
        return _Hamlib.Rig_set_ptt(self, *args)

    def set_rptr_shift(self, *args):
        return _Hamlib.Rig_set_rptr_shift(self, *args)

    def set_rptr_offs(self, *args):
        return _Hamlib.Rig_set_rptr_offs(self, *args)

    def set_ctcss_tone(self, *args):
        return _Hamlib.Rig_set_ctcss_tone(self, *args)

    def set_dcs_code(self, *args):
        return _Hamlib.Rig_set_dcs_code(self, *args)

    def set_ctcss_sql(self, *args):
        return _Hamlib.Rig_set_ctcss_sql(self, *args)

    def set_dcs_sql(self, *args):
        return _Hamlib.Rig_set_dcs_sql(self, *args)

    def set_split_freq(self, *args):
        return _Hamlib.Rig_set_split_freq(self, *args)

    def set_split_mode(self, *args):
        return _Hamlib.Rig_set_split_mode(self, *args)

    def set_split_vfo(self, *args):
        return _Hamlib.Rig_set_split_vfo(self, *args)

    def set_rit(self, *args):
        return _Hamlib.Rig_set_rit(self, *args)

    def set_xit(self, *args):
        return _Hamlib.Rig_set_xit(self, *args)

    def set_ts(self, *args):
        return _Hamlib.Rig_set_ts(self, *args)

    def set_ant(self, *args):
        return _Hamlib.Rig_set_ant(self, *args)

    def set_func(self, *args):
        return _Hamlib.Rig_set_func(self, *args)

    def set_bank(self, *args):
        return _Hamlib.Rig_set_bank(self, *args)

    def set_mem(self, *args):
        return _Hamlib.Rig_set_mem(self, *args)

    def send_dtmf(self, *args):
        return _Hamlib.Rig_send_dtmf(self, *args)

    def send_morse(self, *args):
        return _Hamlib.Rig_send_morse(self, *args)

    def vfo_op(self, *args):
        return _Hamlib.Rig_vfo_op(self, *args)

    def scan(self, *args):
        return _Hamlib.Rig_scan(self, *args)

    def set_level(self, *args):
        return _Hamlib.Rig_set_level(self, *args)

    def set_ext_level(self, *args):
        return _Hamlib.Rig_set_ext_level(self, *args)

    def get_level_i(self, *args):
        return _Hamlib.Rig_get_level_i(self, *args)

    def get_level_f(self, *args):
        return _Hamlib.Rig_get_level_f(self, *args)

    def set_vfo(self, _vfo_t):
        return _Hamlib.Rig_set_vfo(self, _vfo_t)

    def set_powerstat(self, _powerstat_t):
        return _Hamlib.Rig_set_powerstat(self, _powerstat_t)

    def set_trn(self, _int):
        return _Hamlib.Rig_set_trn(self, _int)

    def has_set_level(self, _setting_t):
        return _Hamlib.Rig_has_set_level(self, _setting_t)

    def has_set_parm(self, _setting_t):
        return _Hamlib.Rig_has_set_parm(self, _setting_t)

    def has_set_func(self, _setting_t):
        return _Hamlib.Rig_has_set_func(self, _setting_t)

    def reset(self, _reset_t):
        return _Hamlib.Rig_reset(self, _reset_t)

    def has_scan(self, _scan_t):
        return _Hamlib.Rig_has_scan(self, _scan_t)

    def has_vfo_op(self, _vfo_op_t):
        return _Hamlib.Rig_has_vfo_op(self, _vfo_op_t)

    def passband_normal(self, _rmode_t):
        return _Hamlib.Rig_passband_normal(self, _rmode_t)

    def passband_narrow(self, _rmode_t):
        return _Hamlib.Rig_passband_narrow(self, _rmode_t)

    def passband_wide(self, _rmode_t):
        return _Hamlib.Rig_passband_wide(self, _rmode_t)

    def ext_token_lookup(self, _const_char_string):
        return _Hamlib.Rig_ext_token_lookup(self, _const_char_string)

    def token_lookup(self, _const_char_string):
        return _Hamlib.Rig_token_lookup(self, _const_char_string)

    def set_ext_parm(self, _token_t_1, _value_t_2):
        return _Hamlib.Rig_set_ext_parm(self, _token_t_1, _value_t_2)

    def set_parm(self, *args):
        return _Hamlib.Rig_set_parm(self, *args)

    def get_parm_i(self, *args):
        return _Hamlib.Rig_get_parm_i(self, *args)

    def get_parm_f(self, *args):
        return _Hamlib.Rig_get_parm_f(self, *args)

    def get_parm(self, name):
        return _Hamlib.Rig_get_parm(self, name)

    def set_conf(self, *args):
        return _Hamlib.Rig_set_conf(self, *args)

    def get_freq(self, *args):
        return _Hamlib.Rig_get_freq(self, *args)

    def get_mode(self, *args):
        return _Hamlib.Rig_get_mode(self, *args)

    def get_split_mode(self, *args):
        return _Hamlib.Rig_get_split_mode(self, *args)

    def get_vfo(self):
        return _Hamlib.Rig_get_vfo(self)

    def get_ptt(self, *args):
        return _Hamlib.Rig_get_ptt(self, *args)

    def get_rptr_shift(self, *args):
        return _Hamlib.Rig_get_rptr_shift(self, *args)

    def get_rptr_offs(self, *args):
        return _Hamlib.Rig_get_rptr_offs(self, *args)

    def get_ctcss_tone(self, *args):
        return _Hamlib.Rig_get_ctcss_tone(self, *args)

    def get_dcs_code(self, *args):
        return _Hamlib.Rig_get_dcs_code(self, *args)

    def get_ctcss_sql(self, *args):
        return _Hamlib.Rig_get_ctcss_sql(self, *args)

    def get_dcs_sql(self, *args):
        return _Hamlib.Rig_get_dcs_sql(self, *args)

    def get_split_freq(self, *args):
        return _Hamlib.Rig_get_split_freq(self, *args)

    def get_split_vfo(self, *args):
        return _Hamlib.Rig_get_split_vfo(self, *args)

    def get_rit(self, *args):
        return _Hamlib.Rig_get_rit(self, *args)

    def get_xit(self, *args):
        return _Hamlib.Rig_get_xit(self, *args)

    def get_ts(self, *args):
        return _Hamlib.Rig_get_ts(self, *args)

    def get_ant(self, *args):
        return _Hamlib.Rig_get_ant(self, *args)

    def get_mem(self, *args):
        return _Hamlib.Rig_get_mem(self, *args)

    def get_powerstat(self):
        return _Hamlib.Rig_get_powerstat(self)

    def get_trn(self):
        return _Hamlib.Rig_get_trn(self)

    def mem_count(self):
        return _Hamlib.Rig_mem_count(self)

    def lookup_mem_caps(self, channel_num=-1):
        return _Hamlib.Rig_lookup_mem_caps(self, channel_num)

    def set_channel(self, chan):
        return _Hamlib.Rig_set_channel(self, chan)

    def chan_clear(self, chans, nb_chans=1):
        return _Hamlib.Rig_chan_clear(self, chans, nb_chans)

    def get_chan_all(self, *args):
        return _Hamlib.Rig_get_chan_all(self, *args)

    def get_channel(self, *args):
        return _Hamlib.Rig_get_channel(self, *args)

    def get_conf(self, *args):
        return _Hamlib.Rig_get_conf(self, *args)

    def recv_dtmf(self, *args):
        return _Hamlib.Rig_recv_dtmf(self, *args)

    def get_info(self):
        return _Hamlib.Rig_get_info(self)

    def get_func(self, *args):
        return _Hamlib.Rig_get_func(self, *args)

    def get_level(self, *args):
        return _Hamlib.Rig_get_level(self, *args)
Rig_swigregister = _Hamlib.Rig_swigregister
Rig_swigregister(Rig)

class channelArray(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, channelArray, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, channelArray, name)
    __repr__ = _swig_repr

    def __init__(self, nelements):
        this = _Hamlib.new_channelArray(nelements)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_channelArray
    __del__ = lambda self: None

    def __getitem__(self, index):
        return _Hamlib.channelArray___getitem__(self, index)

    def __setitem__(self, index, value):
        return _Hamlib.channelArray___setitem__(self, index, value)

    def cast(self):
        return _Hamlib.channelArray_cast(self)
    if _newclass:
        frompointer = staticmethod(_Hamlib.channelArray_frompointer)
    else:
        frompointer = _Hamlib.channelArray_frompointer
channelArray_swigregister = _Hamlib.channelArray_swigregister
channelArray_swigregister(channelArray)

def channelArray_frompointer(t):
    return _Hamlib.channelArray_frompointer(t)
channelArray_frompointer = _Hamlib.channelArray_frompointer

class toneArray(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, toneArray, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, toneArray, name)
    __repr__ = _swig_repr

    def __init__(self, nelements):
        this = _Hamlib.new_toneArray(nelements)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_toneArray
    __del__ = lambda self: None

    def __getitem__(self, index):
        return _Hamlib.toneArray___getitem__(self, index)

    def __setitem__(self, index, value):
        return _Hamlib.toneArray___setitem__(self, index, value)

    def cast(self):
        return _Hamlib.toneArray_cast(self)
    if _newclass:
        frompointer = staticmethod(_Hamlib.toneArray_frompointer)
    else:
        frompointer = _Hamlib.toneArray_frompointer
toneArray_swigregister = _Hamlib.toneArray_swigregister
toneArray_swigregister(toneArray)

def toneArray_frompointer(t):
    return _Hamlib.toneArray_frompointer(t)
toneArray_frompointer = _Hamlib.toneArray_frompointer

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)
    __repr__ = _swig_repr
    __swig_setmethods__["rot"] = _Hamlib.Rot_rot_set
    __swig_getmethods__["rot"] = _Hamlib.Rot_rot_get
    if _newclass:
        rot = _swig_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 = _swig_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 = _swig_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 = _swig_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 = _swig_property(_Hamlib.Rot_do_exception_get, _Hamlib.Rot_do_exception_set)

    def __init__(self, rot_model):
        this = _Hamlib.new_Rot(rot_model)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _Hamlib.delete_Rot
    __del__ = lambda self: None

    def open(self):
        return _Hamlib.Rot_open(self)

    def close(self):
        return _Hamlib.Rot_close(self)

    def set_position(self, _azimuth_t_1, _elevation_t_2):
        return _Hamlib.Rot_set_position(self, _azimuth_t_1, _elevation_t_2)

    def get_position(self):
        return _Hamlib.Rot_get_position(self)

    def stop(self):
        return _Hamlib.Rot_stop(self)

    def park(self):
        return _Hamlib.Rot_park(self)

    def reset(self, _rot_reset_t):
        return _Hamlib.Rot_reset(self, _rot_reset_t)

    def move(self, _int_1, _int_2):
        return _Hamlib.Rot_move(self, _int_1, _int_2)

    def token_lookup(self, _const_char_string):
        return _Hamlib.Rot_token_lookup(self, _const_char_string)

    def set_conf(self, *args):
        return _Hamlib.Rot_set_conf(self, *args)

    def get_conf(self, *args):
        return _Hamlib.Rot_get_conf(self, *args)

    def get_info(self):
        return _Hamlib.Rot_get_info(self)
Rot_swigregister = _Hamlib.Rot_swigregister
Rot_swigregister(Rot)

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


