def encode(name, iAddr):
     typecheck.is_string(name, AssertionError)
     typecheck.is_long(iAddr, AssertionError)
     args = {}
     args['name'] = name
     args['iAddr'] = iAddr
     return args

 def decode(rsp, agent):
     _ret_ = rsp['_ret_']
     values = [x0 for x0 in rsp['values']]
     typecheck.is_int(_ret_, DecodeException)
     for x0 in values:
         typecheck.is_string(x0, DecodeException)
     return (_ret_, values)

        def __init__(self, state, reason, source):
            super(raritan.rpc.hmi.InternalBeeper.StateChangedEvent, self).__init__(source)
            typecheck.is_enum(state, raritan.rpc.hmi.InternalBeeper.State, AssertionError)
            typecheck.is_string(reason, AssertionError)

            self.state = state
            self.reason = reason

 def encode(recipient, testSettings):
     typecheck.is_string(recipient, AssertionError)
     typecheck.is_struct(testSettings, raritan.rpc.serial.GsmModem.Settings, AssertionError)
     args = {}
     args['recipient'] = recipient
     args['testSettings'] = raritan.rpc.serial.GsmModem.Settings.encode(testSettings)
     return args

 def getMasterIpV6Address(self):
     agent = self.agent
     args = {}
     rsp = agent.json_rpc(self.target, 'getMasterIpV6Address', args)
     masterIpV6Address = rsp['masterIpV6Address']
     typecheck.is_string(masterIpV6Address, DecodeException)
     return masterIpV6Address

 def encode(ctxName, logLevel):
     typecheck.is_string(ctxName, AssertionError)
     typecheck.is_enum(logLevel, raritan.rpc.diag.DiagLogSettings.LogLevel, AssertionError)
     args = {}
     args['ctxName'] = ctxName
     args['logLevel'] = raritan.rpc.diag.DiagLogSettings.LogLevel.encode(logLevel)
     return args

 def getVersion(self):
     agent = self.agent
     args = {}
     rsp = agent.json_rpc(self.target, 'getVersion', args)
     _ret_ = rsp['_ret_']
     typecheck.is_string(_ret_, DecodeException)
     return _ret_

        def __init__(self, oldName, newName, actUserName, actIpAddr, source):
            super(raritan.rpc.lhxmodel.Config.PortNameChangedEvent, self).__init__(actUserName, actIpAddr, source)
            typecheck.is_string(oldName, AssertionError)
            typecheck.is_string(newName, AssertionError)

            self.oldName = oldName
            self.newName = newName

    def __init__(self, id, supportedFormats):
        typecheck.is_string(id, AssertionError)
        for x0 in supportedFormats:
            typecheck.is_struct(x0, raritan.rpc.webcam.Format, AssertionError)

        self.id = id
        self.supportedFormats = supportedFormats

    def __init__(self, creationTime, remoteIp, clientType):
        typecheck.is_time(creationTime, AssertionError)
        typecheck.is_string(remoteIp, AssertionError)
        typecheck.is_string(clientType, AssertionError)

        self.creationTime = creationTime
        self.remoteIp = remoteIp
        self.clientType = clientType

 def getDetectableDevices(self):
     agent = self.agent
     args = {}
     rsp = agent.json_rpc(self.target, 'getDetectableDevices', args)
     _ret_ = [x0 for x0 in rsp['_ret_']]
     for x0 in _ret_:
         typecheck.is_string(x0, DecodeException)
     return _ret_

 def closeSession(self, token, reason):
     agent = self.agent
     typecheck.is_string(token, AssertionError)
     typecheck.is_enum(reason, raritan.rpc.session.SessionManager.CloseReason, AssertionError)
     args = {}
     args['token'] = token
     args['reason'] = raritan.rpc.session.SessionManager.CloseReason.encode(reason)
     rsp = agent.json_rpc(self.target, 'closeSession', args)

 def decode(rsp, agent):
     _ret_ = rsp['_ret_']
     session = raritan.rpc.session.Session.decode(rsp['session'], agent)
     token = rsp['token']
     typecheck.is_int(_ret_, DecodeException)
     typecheck.is_struct(session, raritan.rpc.session.Session, DecodeException)
     typecheck.is_string(token, DecodeException)
     return (_ret_, session, token)