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

 def encode(startIndex, count):
     typecheck.is_int(startIndex, AssertionError)
     typecheck.is_int(count, AssertionError)
     args = {}
     args['startIndex'] = startIndex
     args['count'] = count
     return args

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

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

 def encode(reqInfo, days):
     typecheck.is_struct(reqInfo, raritan.rpc.cert.ServerSSLCert.ReqInfo, AssertionError)
     typecheck.is_int(days, AssertionError)
     args = {}
     args['reqInfo'] = raritan.rpc.cert.ServerSSLCert.ReqInfo.encode(reqInfo)
     args['days'] = days
     return args

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

 def decode(rsp, agent):
     _ret_ = rsp['_ret_']
     image = [raritan.rpc.webcam.StorageManager.StorageImage.decode(x0, agent) for x0 in rsp['image']]
     typecheck.is_int(_ret_, DecodeException)
     for x0 in image:
         typecheck.is_struct(x0, raritan.rpc.webcam.StorageManager.StorageImage, DecodeException)
     return (_ret_, image)

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

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

 def encode(sessionId, reason):
     typecheck.is_int(sessionId, AssertionError)
     typecheck.is_enum(reason, raritan.rpc.session.SessionManager.CloseReason, AssertionError)
     args = {}
     args['sessionId'] = sessionId
     args['reason'] = raritan.rpc.session.SessionManager.CloseReason.encode(reason)
     return args

 def getIndex(self):
     agent = self.agent
     args = {}
     rsp = agent.json_rpc(self.target, 'getIndex', args)
     idx = rsp['idx']
     typecheck.is_int(idx, DecodeException)
     return idx

    def __init__(self, width, height, pixelFormat):
        typecheck.is_int(width, AssertionError)
        typecheck.is_int(height, AssertionError)
        typecheck.is_enum(pixelFormat, raritan.rpc.webcam.PixelFormat, AssertionError)

        self.width = width
        self.height = height
        self.pixelFormat = pixelFormat

    def __init__(self, creationTime, idFirst, idNext):
        typecheck.is_long(creationTime, AssertionError)
        typecheck.is_int(idFirst, AssertionError)
        typecheck.is_int(idNext, AssertionError)

        self.creationTime = creationTime
        self.idFirst = idFirst
        self.idNext = idNext

        def __init__(self, id, name, info):
            typecheck.is_int(id, AssertionError)
            typecheck.is_string(name, AssertionError)
            typecheck.is_struct(info, raritan.rpc.usermgmt.Role.Info, AssertionError)

            self.id = id
            self.name = name
            self.info = info

        def __init__(self, id, name, hasDSTInfo):
            typecheck.is_int(id, AssertionError)
            typecheck.is_string(name, AssertionError)
            typecheck.is_bool(hasDSTInfo, AssertionError)

            self.id = id
            self.name = name
            self.hasDSTInfo = hasDSTInfo

 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)