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

    def __init__(self, defaultArgs, autoStart, autoRestart):
        typecheck.is_bool(autoStart, AssertionError)
        typecheck.is_bool(autoRestart, AssertionError)

        self.defaultArgs = defaultArgs
        self.autoStart = autoStart
        self.autoRestart = autoRestart

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

    def __init__(self, enabled, autocfg, ipaddr, netmask, gateway, hostname, dns_suffixes, override_dns, dns_ip_1, dns_ip_2, domain_name):
        typecheck.is_bool(enabled, AssertionError)
        typecheck.is_enum(autocfg, raritan.rpc.net.AutoConfigs, AssertionError)
        typecheck.is_string(ipaddr, AssertionError)
        typecheck.is_string(netmask, AssertionError)
        typecheck.is_string(gateway, AssertionError)
        typecheck.is_string(hostname, AssertionError)
        for x0 in dns_suffixes:
            typecheck.is_string(x0, AssertionError)
        typecheck.is_bool(override_dns, AssertionError)
        typecheck.is_string(dns_ip_1, AssertionError)
        typecheck.is_string(dns_ip_2, AssertionError)
        typecheck.is_string(domain_name, AssertionError)

        self.enabled = enabled
        self.autocfg = autocfg
        self.ipaddr = ipaddr
        self.netmask = netmask
        self.gateway = gateway
        self.hostname = hostname
        self.dns_suffixes = dns_suffixes
        self.override_dns = override_dns
        self.dns_ip_1 = dns_ip_1
        self.dns_ip_2 = dns_ip_2
        self.domain_name = domain_name

 def encode(portNum, hasPower):
     typecheck.is_int(portNum, AssertionError)
     typecheck.is_bool(hasPower, AssertionError)
     args = {}
     args['portNum'] = portNum
     args['hasPower'] = hasPower
     return args

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

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

            self.id = id
            self.name = name
            self.enableAutoDST = enableAutoDST

        def __init__(self, timestamp, available, value):
            typecheck.is_time(timestamp, AssertionError)
            typecheck.is_bool(available, AssertionError)
            typecheck.is_int(value, AssertionError)

            self.timestamp = timestamp
            self.available = available
            self.value = value

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

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

 def getImageInfo(self):
     agent = self.agent
     args = {}
     rsp = agent.json_rpc(self.target, 'getImageInfo', args)
     _ret_ = rsp['_ret_']
     info = raritan.rpc.firmware.ImageInfo.decode(rsp['info'], agent)
     typecheck.is_bool(_ret_, DecodeException)
     typecheck.is_struct(info, raritan.rpc.firmware.ImageInfo, DecodeException)
     return (_ret_, info)

 def decode(rsp, agent):
     zone = raritan.rpc.datetime.DateTime.ZoneInfo.decode(rsp['zone'], agent)
     dstEnabled = rsp['dstEnabled']
     utcOffset = rsp['utcOffset']
     currentTime = raritan.rpc.Time.decode(rsp['currentTime'])
     typecheck.is_struct(zone, raritan.rpc.datetime.DateTime.ZoneInfo, DecodeException)
     typecheck.is_bool(dstEnabled, DecodeException)
     typecheck.is_int(utcOffset, DecodeException)
     typecheck.is_time(currentTime, DecodeException)
     return (zone, dstEnabled, utcOffset, currentTime)

 def activate(self, on, reason, timeout):
     agent = self.agent
     typecheck.is_bool(on, AssertionError)
     typecheck.is_string(reason, AssertionError)
     typecheck.is_int(timeout, AssertionError)
     args = {}
     args['on'] = on
     args['reason'] = reason
     args['timeout'] = timeout
     rsp = agent.json_rpc(self.target, 'activate', args)

 def setRawValue(self, rawValue, validateRange):
     agent = self.agent
     typecheck.is_int(rawValue, AssertionError)
     typecheck.is_bool(validateRange, AssertionError)
     args = {}
     args['rawValue'] = rawValue
     args['validateRange'] = validateRange
     rsp = agent.json_rpc(self.target, 'setRawValue', args)
     _ret_ = rsp['_ret_']
     typecheck.is_int(_ret_, DecodeException)
     return _ret_

 def setSettings(self, isEnabled, samplesPerRecord):
     agent = self.agent
     typecheck.is_bool(isEnabled, AssertionError)
     typecheck.is_int(samplesPerRecord, AssertionError)
     args = {}
     args['isEnabled'] = isEnabled
     args['samplesPerRecord'] = samplesPerRecord
     rsp = agent.json_rpc(self.target, 'setSettings', args)
     _ret_ = rsp['_ret_']
     typecheck.is_int(_ret_, DecodeException)
     return _ret_