NSStat_services.py

################################################## 
# NSStat_services.py 
# generated by ZSI.generate.wsdl2python
##################################################


from NSStat_services_types import *
import urlparse, types
from ZSI.TCcompound import ComplexType, Struct
from ZSI import client
import ZSI

# Locator
class NSStatServiceLocator:
    NSStatPort_address = "http://netscaler_ip/soap/"
    def getNSStatPortAddress(self):
        return NSStatServiceLocator.NSStatPort_address
    def getNSStatPort(self, url=None, **kw):
        return NSStatBindingSOAP(url or NSStatServiceLocator.NSStatPort_address, **kw)

# Methods
class NSStatBindingSOAP:
    def __init__(self, url, **kw):
        kw.setdefault("readerclass", None)
        kw.setdefault("writerclass", None)
        # no resource properties
        self.binding = client.Binding(url=url, **kw)
        # no ws-addressing

    # op: statservice
    def statservice(self, request):
        if isinstance(request, statservice) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statserviceResponse.typecode.ofwhat, pyclass=statserviceResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statservicegroup
    def statservicegroup(self, request):
        if isinstance(request, statservicegroup) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statservicegroupResponse.typecode.ofwhat, pyclass=statservicegroupResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: stataaa
    def stataaa(self, request):
        if isinstance(request, stataaa) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=stataaaResponse.typecode.ofwhat, pyclass=stataaaResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statappfw
    def statappfw(self, request):
        if isinstance(request, statappfw) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statappfwResponse.typecode.ofwhat, pyclass=statappfwResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: stataudit
    def stataudit(self, request):
        if isinstance(request, stataudit) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statauditResponse.typecode.ofwhat, pyclass=statauditResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statcache
    def statcache(self, request):
        if isinstance(request, statcache) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statcacheResponse.typecode.ofwhat, pyclass=statcacheResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: getclioutput
    def getclioutput(self, request):
        if isinstance(request, getclioutput) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=getclioutputResponse.typecode.ofwhat, pyclass=getclioutputResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statcmp
    def statcmp(self, request):
        if isinstance(request, statcmp) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statcmpResponse.typecode.ofwhat, pyclass=statcmpResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statcsvserver
    def statcsvserver(self, request):
        if isinstance(request, statcsvserver) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statcsvserverResponse.typecode.ofwhat, pyclass=statcsvserverResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statdns
    def statdns(self, request):
        if isinstance(request, statdns) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statdnsResponse.typecode.ofwhat, pyclass=statdnsResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statdos
    def statdos(self, request):
        if isinstance(request, statdos) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statdosResponse.typecode.ofwhat, pyclass=statdosResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statdospolicy
    def statdospolicy(self, request):
        if isinstance(request, statdospolicy) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statdospolicyResponse.typecode.ofwhat, pyclass=statdospolicyResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statgslbdomain
    def statgslbdomain(self, request):
        if isinstance(request, statgslbdomain) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statgslbdomainResponse.typecode.ofwhat, pyclass=statgslbdomainResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statgslbsite
    def statgslbsite(self, request):
        if isinstance(request, statgslbsite) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statgslbsiteResponse.typecode.ofwhat, pyclass=statgslbsiteResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statgslbservice
    def statgslbservice(self, request):
        if isinstance(request, statgslbservice) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statgslbserviceResponse.typecode.ofwhat, pyclass=statgslbserviceResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statgslbvserver
    def statgslbvserver(self, request):
        if isinstance(request, statgslbvserver) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statgslbvserverResponse.typecode.ofwhat, pyclass=statgslbvserverResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: stathanode
    def stathanode(self, request):
        if isinstance(request, stathanode) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=stathanodeResponse.typecode.ofwhat, pyclass=stathanodeResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statlbvserver
    def statlbvserver(self, request):
        if isinstance(request, statlbvserver) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statlbvserverResponse.typecode.ofwhat, pyclass=statlbvserverResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statbridge
    def statbridge(self, request):
        if isinstance(request, statbridge) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statbridgeResponse.typecode.ofwhat, pyclass=statbridgeResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statinterface
    def statinterface(self, request):
        if isinstance(request, statinterface) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statinterfaceResponse.typecode.ofwhat, pyclass=statinterfaceResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statrnat
    def statrnat(self, request):
        if isinstance(request, statrnat) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statrnatResponse.typecode.ofwhat, pyclass=statrnatResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statrnatip
    def statrnatip(self, request):
        if isinstance(request, statrnatip) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statrnatipResponse.typecode.ofwhat, pyclass=statrnatipResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statvlan
    def statvlan(self, request):
        if isinstance(request, statvlan) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statvlanResponse.typecode.ofwhat, pyclass=statvlanResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: login
    def login(self, request):
        if isinstance(request, login) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=loginResponse.typecode.ofwhat, pyclass=loginResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: loginchallengeresponse
    def loginchallengeresponse(self, request):
        if isinstance(request, loginchallengeresponse) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=loginchallengeresponseResponse.typecode.ofwhat, pyclass=loginchallengeresponseResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: logout
    def logout(self, request):
        if isinstance(request, logout) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=logoutResponse.typecode.ofwhat, pyclass=logoutResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statnsacl
    def statnsacl(self, request):
        if isinstance(request, statnsacl) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statnsaclResponse.typecode.ofwhat, pyclass=statnsaclResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statnssimpleacl
    def statnssimpleacl(self, request):
        if isinstance(request, statnssimpleacl) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statnssimpleaclResponse.typecode.ofwhat, pyclass=statnssimpleaclResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statpq
    def statpq(self, request):
        if isinstance(request, statpq) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statpqResponse.typecode.ofwhat, pyclass=statpqResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statpqpolicy
    def statpqpolicy(self, request):
        if isinstance(request, statpqpolicy) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statpqpolicyResponse.typecode.ofwhat, pyclass=statpqpolicyResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statprotocoltcp
    def statprotocoltcp(self, request):
        if isinstance(request, statprotocoltcp) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statprotocoltcpResponse.typecode.ofwhat, pyclass=statprotocoltcpResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statprotocolhttp
    def statprotocolhttp(self, request):
        if isinstance(request, statprotocolhttp) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statprotocolhttpResponse.typecode.ofwhat, pyclass=statprotocolhttpResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statprotocolicmp
    def statprotocolicmp(self, request):
        if isinstance(request, statprotocolicmp) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statprotocolicmpResponse.typecode.ofwhat, pyclass=statprotocolicmpResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statprotocolipv6
    def statprotocolipv6(self, request):
        if isinstance(request, statprotocolipv6) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statprotocolipv6Response.typecode.ofwhat, pyclass=statprotocolipv6Response.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statprotocolip
    def statprotocolip(self, request):
        if isinstance(request, statprotocolip) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statprotocolipResponse.typecode.ofwhat, pyclass=statprotocolipResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statprotocoludp
    def statprotocoludp(self, request):
        if isinstance(request, statprotocoludp) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statprotocoludpResponse.typecode.ofwhat, pyclass=statprotocoludpResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statsnmp
    def statsnmp(self, request):
        if isinstance(request, statsnmp) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statsnmpResponse.typecode.ofwhat, pyclass=statsnmpResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statsc
    def statsc(self, request):
        if isinstance(request, statsc) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statscResponse.typecode.ofwhat, pyclass=statscResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statscpolicy
    def statscpolicy(self, request):
        if isinstance(request, statscpolicy) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statscpolicyResponse.typecode.ofwhat, pyclass=statscpolicyResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statssl
    def statssl(self, request):
        if isinstance(request, statssl) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statsslResponse.typecode.ofwhat, pyclass=statsslResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statsystem
    def statsystem(self, request):
        if isinstance(request, statsystem) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statsystemResponse.typecode.ofwhat, pyclass=statsystemResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statsystemcpu
    def statsystemcpu(self, request):
        if isinstance(request, statsystemcpu) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statsystemcpuResponse.typecode.ofwhat, pyclass=statsystemcpuResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statvpn
    def statvpn(self, request):
        if isinstance(request, statvpn) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statvpnResponse.typecode.ofwhat, pyclass=statvpnResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

    # op: statvpnvserver
    def statvpnvserver(self, request):
        if isinstance(request, statvpnvserver) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="urn:NSConfigAction", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=statvpnvserverResponse.typecode.ofwhat, pyclass=statvpnvserverResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

class statservice:
    def __init__(self):
        self._name = None
        return
statservice.typecode = Struct(pname=("urn:NSConfig","statservice"), ofwhat=[ZSI.TC.String(pname="name", aname="_name", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statservice, encoded="urn:NSConfig")

class statserviceResponse:
    def __init__(self):
        self._return = None
        return
statserviceResponse.typecode = Struct(pname=("urn:NSConfig","statserviceResponse"), ofwhat=[ns0.statserviceResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statserviceResponse, encoded="urn:NSConfig")

class statservicegroup:
    def __init__(self):
        self._servicegroupname = None
        return
statservicegroup.typecode = Struct(pname=("urn:NSConfig","statservicegroup"), ofwhat=[ZSI.TC.String(pname="servicegroupname", aname="_servicegroupname", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statservicegroup, encoded="urn:NSConfig")

class statservicegroupResponse:
    def __init__(self):
        self._return = None
        return
statservicegroupResponse.typecode = Struct(pname=("urn:NSConfig","statservicegroupResponse"), ofwhat=[ns0.statservicegroupResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statservicegroupResponse, encoded="urn:NSConfig")

class stataaa:
    def __init__(self):
        return
stataaa.typecode = Struct(pname=("urn:NSConfig","stataaa"), ofwhat=[], pyclass=stataaa, encoded="urn:NSConfig")

class stataaaResponse:
    def __init__(self):
        self._return = None
        return
stataaaResponse.typecode = Struct(pname=("urn:NSConfig","stataaaResponse"), ofwhat=[ns0.stataaaResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=stataaaResponse, encoded="urn:NSConfig")

class statappfw:
    def __init__(self):
        return
statappfw.typecode = Struct(pname=("urn:NSConfig","statappfw"), ofwhat=[], pyclass=statappfw, encoded="urn:NSConfig")

class statappfwResponse:
    def __init__(self):
        self._return = None
        return
statappfwResponse.typecode = Struct(pname=("urn:NSConfig","statappfwResponse"), ofwhat=[ns0.statappfwResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statappfwResponse, encoded="urn:NSConfig")

class stataudit:
    def __init__(self):
        return
stataudit.typecode = Struct(pname=("urn:NSConfig","stataudit"), ofwhat=[], pyclass=stataudit, encoded="urn:NSConfig")

class statauditResponse:
    def __init__(self):
        self._return = None
        return
statauditResponse.typecode = Struct(pname=("urn:NSConfig","statauditResponse"), ofwhat=[ns0.statauditResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statauditResponse, encoded="urn:NSConfig")

class statcache:
    def __init__(self):
        return
statcache.typecode = Struct(pname=("urn:NSConfig","statcache"), ofwhat=[], pyclass=statcache, encoded="urn:NSConfig")

class statcacheResponse:
    def __init__(self):
        self._return = None
        return
statcacheResponse.typecode = Struct(pname=("urn:NSConfig","statcacheResponse"), ofwhat=[ns0.statcacheResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statcacheResponse, encoded="urn:NSConfig")

class getclioutput:
    def __init__(self):
        self._command = None
        return
getclioutput.typecode = Struct(pname=("urn:NSConfig","getclioutput"), ofwhat=[ZSI.TC.String(pname="command", aname="_command", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=getclioutput, encoded="urn:NSConfig")

class getclioutputResponse:
    def __init__(self):
        self._return = None
        return
getclioutputResponse.typecode = Struct(pname=("urn:NSConfig","getclioutputResponse"), ofwhat=[ns0.getclioutputResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=getclioutputResponse, encoded="urn:NSConfig")

class statcmp:
    def __init__(self):
        return
statcmp.typecode = Struct(pname=("urn:NSConfig","statcmp"), ofwhat=[], pyclass=statcmp, encoded="urn:NSConfig")

class statcmpResponse:
    def __init__(self):
        self._return = None
        return
statcmpResponse.typecode = Struct(pname=("urn:NSConfig","statcmpResponse"), ofwhat=[ns0.statcmpResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statcmpResponse, encoded="urn:NSConfig")

class statcsvserver:
    def __init__(self):
        self._name = None
        return
statcsvserver.typecode = Struct(pname=("urn:NSConfig","statcsvserver"), ofwhat=[ZSI.TC.String(pname="name", aname="_name", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statcsvserver, encoded="urn:NSConfig")

class statcsvserverResponse:
    def __init__(self):
        self._return = None
        return
statcsvserverResponse.typecode = Struct(pname=("urn:NSConfig","statcsvserverResponse"), ofwhat=[ns0.statcsvserverResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statcsvserverResponse, encoded="urn:NSConfig")

class statdns:
    def __init__(self):
        return
statdns.typecode = Struct(pname=("urn:NSConfig","statdns"), ofwhat=[], pyclass=statdns, encoded="urn:NSConfig")

class statdnsResponse:
    def __init__(self):
        self._return = None
        return
statdnsResponse.typecode = Struct(pname=("urn:NSConfig","statdnsResponse"), ofwhat=[ns0.statdnsResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statdnsResponse, encoded="urn:NSConfig")

class statdos:
    def __init__(self):
        return
statdos.typecode = Struct(pname=("urn:NSConfig","statdos"), ofwhat=[], pyclass=statdos, encoded="urn:NSConfig")

class statdosResponse:
    def __init__(self):
        self._return = None
        return
statdosResponse.typecode = Struct(pname=("urn:NSConfig","statdosResponse"), ofwhat=[ns0.statdosResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statdosResponse, encoded="urn:NSConfig")

class statdospolicy:
    def __init__(self):
        self._name = None
        return
statdospolicy.typecode = Struct(pname=("urn:NSConfig","statdospolicy"), ofwhat=[ZSI.TC.String(pname="name", aname="_name", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statdospolicy, encoded="urn:NSConfig")

class statdospolicyResponse:
    def __init__(self):
        self._return = None
        return
statdospolicyResponse.typecode = Struct(pname=("urn:NSConfig","statdospolicyResponse"), ofwhat=[ns0.statdospolicyResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statdospolicyResponse, encoded="urn:NSConfig")

class statgslbdomain:
    def __init__(self):
        self._name = None
        return
statgslbdomain.typecode = Struct(pname=("urn:NSConfig","statgslbdomain"), ofwhat=[ZSI.TC.String(pname="name", aname="_name", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statgslbdomain, encoded="urn:NSConfig")

class statgslbdomainResponse:
    def __init__(self):
        self._return = None
        return
statgslbdomainResponse.typecode = Struct(pname=("urn:NSConfig","statgslbdomainResponse"), ofwhat=[ns0.statgslbdomainResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statgslbdomainResponse, encoded="urn:NSConfig")

class statgslbsite:
    def __init__(self):
        self._sitename = None
        return
statgslbsite.typecode = Struct(pname=("urn:NSConfig","statgslbsite"), ofwhat=[ZSI.TC.String(pname="sitename", aname="_sitename", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statgslbsite, encoded="urn:NSConfig")

class statgslbsiteResponse:
    def __init__(self):
        self._return = None
        return
statgslbsiteResponse.typecode = Struct(pname=("urn:NSConfig","statgslbsiteResponse"), ofwhat=[ns0.statgslbsiteResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statgslbsiteResponse, encoded="urn:NSConfig")

class statgslbservice:
    def __init__(self):
        self._servicename = None
        return
statgslbservice.typecode = Struct(pname=("urn:NSConfig","statgslbservice"), ofwhat=[ZSI.TC.String(pname="servicename", aname="_servicename", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statgslbservice, encoded="urn:NSConfig")

class statgslbserviceResponse:
    def __init__(self):
        self._return = None
        return
statgslbserviceResponse.typecode = Struct(pname=("urn:NSConfig","statgslbserviceResponse"), ofwhat=[ns0.statgslbserviceResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statgslbserviceResponse, encoded="urn:NSConfig")

class statgslbvserver:
    def __init__(self):
        self._name = None
        return
statgslbvserver.typecode = Struct(pname=("urn:NSConfig","statgslbvserver"), ofwhat=[ZSI.TC.String(pname="name", aname="_name", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statgslbvserver, encoded="urn:NSConfig")

class statgslbvserverResponse:
    def __init__(self):
        self._return = None
        return
statgslbvserverResponse.typecode = Struct(pname=("urn:NSConfig","statgslbvserverResponse"), ofwhat=[ns0.statgslbvserverResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statgslbvserverResponse, encoded="urn:NSConfig")

class stathanode:
    def __init__(self):
        return
stathanode.typecode = Struct(pname=("urn:NSConfig","stathanode"), ofwhat=[], pyclass=stathanode, encoded="urn:NSConfig")

class stathanodeResponse:
    def __init__(self):
        self._return = None
        return
stathanodeResponse.typecode = Struct(pname=("urn:NSConfig","stathanodeResponse"), ofwhat=[ns0.stathanodeResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=stathanodeResponse, encoded="urn:NSConfig")

class statlbvserver:
    def __init__(self):
        self._name = None
        return
statlbvserver.typecode = Struct(pname=("urn:NSConfig","statlbvserver"), ofwhat=[ZSI.TC.String(pname="name", aname="_name", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statlbvserver, encoded="urn:NSConfig")

class statlbvserverResponse:
    def __init__(self):
        self._return = None
        return
statlbvserverResponse.typecode = Struct(pname=("urn:NSConfig","statlbvserverResponse"), ofwhat=[ns0.statlbvserverResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statlbvserverResponse, encoded="urn:NSConfig")

class statbridge:
    def __init__(self):
        return
statbridge.typecode = Struct(pname=("urn:NSConfig","statbridge"), ofwhat=[], pyclass=statbridge, encoded="urn:NSConfig")

class statbridgeResponse:
    def __init__(self):
        self._return = None
        return
statbridgeResponse.typecode = Struct(pname=("urn:NSConfig","statbridgeResponse"), ofwhat=[ns0.statbridgeResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statbridgeResponse, encoded="urn:NSConfig")

class statinterface:
    def __init__(self):
        self._id = None
        return
statinterface.typecode = Struct(pname=("urn:NSConfig","statinterface"), ofwhat=[ZSI.TC.String(pname="id", aname="_id", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statinterface, encoded="urn:NSConfig")

class statinterfaceResponse:
    def __init__(self):
        self._return = None
        return
statinterfaceResponse.typecode = Struct(pname=("urn:NSConfig","statinterfaceResponse"), ofwhat=[ns0.statinterfaceResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statinterfaceResponse, encoded="urn:NSConfig")

class statrnat:
    def __init__(self):
        return
statrnat.typecode = Struct(pname=("urn:NSConfig","statrnat"), ofwhat=[], pyclass=statrnat, encoded="urn:NSConfig")

class statrnatResponse:
    def __init__(self):
        self._return = None
        return
statrnatResponse.typecode = Struct(pname=("urn:NSConfig","statrnatResponse"), ofwhat=[ns0.statrnatResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statrnatResponse, encoded="urn:NSConfig")

class statrnatip:
    def __init__(self):
        self._rnatip = None
        return
statrnatip.typecode = Struct(pname=("urn:NSConfig","statrnatip"), ofwhat=[ZSI.TC.String(pname="rnatip", aname="_rnatip", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statrnatip, encoded="urn:NSConfig")

class statrnatipResponse:
    def __init__(self):
        self._return = None
        return
statrnatipResponse.typecode = Struct(pname=("urn:NSConfig","statrnatipResponse"), ofwhat=[ns0.statrnatipResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statrnatipResponse, encoded="urn:NSConfig")

class statvlan:
    def __init__(self):
        self._id = None
        return
statvlan.typecode = Struct(pname=("urn:NSConfig","statvlan"), ofwhat=[ZSI.TCnumbers.IunsignedInt(pname="id", aname="_id", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statvlan, encoded="urn:NSConfig")

class statvlanResponse:
    def __init__(self):
        self._return = None
        return
statvlanResponse.typecode = Struct(pname=("urn:NSConfig","statvlanResponse"), ofwhat=[ns0.statvlanResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statvlanResponse, encoded="urn:NSConfig")

class login:
    def __init__(self):
        self._username = None
        self._password = None
        return
login.typecode = Struct(pname=("urn:NSConfig","login"), ofwhat=[ZSI.TC.String(pname="username", aname="_username", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="password", aname="_password", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=login, encoded="urn:NSConfig")

class loginResponse:
    def __init__(self):
        self._return = None
        return
loginResponse.typecode = Struct(pname=("urn:NSConfig","loginResponse"), ofwhat=[ns0.simpleResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=loginResponse, encoded="urn:NSConfig")

class loginchallengeresponse:
    def __init__(self):
        self._response = None
        return
loginchallengeresponse.typecode = Struct(pname=("urn:NSConfig","loginchallengeresponse"), ofwhat=[ZSI.TC.String(pname="response", aname="_response", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=loginchallengeresponse, encoded="urn:NSConfig")

class loginchallengeresponseResponse:
    def __init__(self):
        self._return = None
        return
loginchallengeresponseResponse.typecode = Struct(pname=("urn:NSConfig","loginchallengeresponseResponse"), ofwhat=[ns0.simpleResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=loginchallengeresponseResponse, encoded="urn:NSConfig")

class logout:
    def __init__(self):
        return
logout.typecode = Struct(pname=("urn:NSConfig","logout"), ofwhat=[], pyclass=logout, encoded="urn:NSConfig")

class logoutResponse:
    def __init__(self):
        self._return = None
        return
logoutResponse.typecode = Struct(pname=("urn:NSConfig","logoutResponse"), ofwhat=[ns0.simpleResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=logoutResponse, encoded="urn:NSConfig")

class statnsacl:
    def __init__(self):
        self._aclname = None
        return
statnsacl.typecode = Struct(pname=("urn:NSConfig","statnsacl"), ofwhat=[ZSI.TC.String(pname="aclname", aname="_aclname", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statnsacl, encoded="urn:NSConfig")

class statnsaclResponse:
    def __init__(self):
        self._return = None
        return
statnsaclResponse.typecode = Struct(pname=("urn:NSConfig","statnsaclResponse"), ofwhat=[ns0.statnsaclResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statnsaclResponse, encoded="urn:NSConfig")

class statnssimpleacl:
    def __init__(self):
        return
statnssimpleacl.typecode = Struct(pname=("urn:NSConfig","statnssimpleacl"), ofwhat=[], pyclass=statnssimpleacl, encoded="urn:NSConfig")

class statnssimpleaclResponse:
    def __init__(self):
        self._return = None
        return
statnssimpleaclResponse.typecode = Struct(pname=("urn:NSConfig","statnssimpleaclResponse"), ofwhat=[ns0.statnssimpleaclResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statnssimpleaclResponse, encoded="urn:NSConfig")

class statpq:
    def __init__(self):
        return
statpq.typecode = Struct(pname=("urn:NSConfig","statpq"), ofwhat=[], pyclass=statpq, encoded="urn:NSConfig")

class statpqResponse:
    def __init__(self):
        self._return = None
        return
statpqResponse.typecode = Struct(pname=("urn:NSConfig","statpqResponse"), ofwhat=[ns0.statpqResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statpqResponse, encoded="urn:NSConfig")

class statpqpolicy:
    def __init__(self):
        self._policyname = None
        return
statpqpolicy.typecode = Struct(pname=("urn:NSConfig","statpqpolicy"), ofwhat=[ZSI.TC.String(pname="policyname", aname="_policyname", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statpqpolicy, encoded="urn:NSConfig")

class statpqpolicyResponse:
    def __init__(self):
        self._return = None
        return
statpqpolicyResponse.typecode = Struct(pname=("urn:NSConfig","statpqpolicyResponse"), ofwhat=[ns0.statpqpolicyResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statpqpolicyResponse, encoded="urn:NSConfig")

class statprotocoltcp:
    def __init__(self):
        return
statprotocoltcp.typecode = Struct(pname=("urn:NSConfig","statprotocoltcp"), ofwhat=[], pyclass=statprotocoltcp, encoded="urn:NSConfig")

class statprotocoltcpResponse:
    def __init__(self):
        self._return = None
        return
statprotocoltcpResponse.typecode = Struct(pname=("urn:NSConfig","statprotocoltcpResponse"), ofwhat=[ns0.statprotocoltcpResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statprotocoltcpResponse, encoded="urn:NSConfig")

class statprotocolhttp:
    def __init__(self):
        return
statprotocolhttp.typecode = Struct(pname=("urn:NSConfig","statprotocolhttp"), ofwhat=[], pyclass=statprotocolhttp, encoded="urn:NSConfig")

class statprotocolhttpResponse:
    def __init__(self):
        self._return = None
        return
statprotocolhttpResponse.typecode = Struct(pname=("urn:NSConfig","statprotocolhttpResponse"), ofwhat=[ns0.statprotocolhttpResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statprotocolhttpResponse, encoded="urn:NSConfig")

class statprotocolicmp:
    def __init__(self):
        return
statprotocolicmp.typecode = Struct(pname=("urn:NSConfig","statprotocolicmp"), ofwhat=[], pyclass=statprotocolicmp, encoded="urn:NSConfig")

class statprotocolicmpResponse:
    def __init__(self):
        self._return = None
        return
statprotocolicmpResponse.typecode = Struct(pname=("urn:NSConfig","statprotocolicmpResponse"), ofwhat=[ns0.statprotocolicmpResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statprotocolicmpResponse, encoded="urn:NSConfig")

class statprotocolipv6:
    def __init__(self):
        return
statprotocolipv6.typecode = Struct(pname=("urn:NSConfig","statprotocolipv6"), ofwhat=[], pyclass=statprotocolipv6, encoded="urn:NSConfig")

class statprotocolipv6Response:
    def __init__(self):
        self._return = None
        return
statprotocolipv6Response.typecode = Struct(pname=("urn:NSConfig","statprotocolipv6Response"), ofwhat=[ns0.statprotocolipv6Result_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statprotocolipv6Response, encoded="urn:NSConfig")

class statprotocolip:
    def __init__(self):
        return
statprotocolip.typecode = Struct(pname=("urn:NSConfig","statprotocolip"), ofwhat=[], pyclass=statprotocolip, encoded="urn:NSConfig")

class statprotocolipResponse:
    def __init__(self):
        self._return = None
        return
statprotocolipResponse.typecode = Struct(pname=("urn:NSConfig","statprotocolipResponse"), ofwhat=[ns0.statprotocolipResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statprotocolipResponse, encoded="urn:NSConfig")

class statprotocoludp:
    def __init__(self):
        return
statprotocoludp.typecode = Struct(pname=("urn:NSConfig","statprotocoludp"), ofwhat=[], pyclass=statprotocoludp, encoded="urn:NSConfig")

class statprotocoludpResponse:
    def __init__(self):
        self._return = None
        return
statprotocoludpResponse.typecode = Struct(pname=("urn:NSConfig","statprotocoludpResponse"), ofwhat=[ns0.statprotocoludpResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statprotocoludpResponse, encoded="urn:NSConfig")

class statsnmp:
    def __init__(self):
        return
statsnmp.typecode = Struct(pname=("urn:NSConfig","statsnmp"), ofwhat=[], pyclass=statsnmp, encoded="urn:NSConfig")

class statsnmpResponse:
    def __init__(self):
        self._return = None
        return
statsnmpResponse.typecode = Struct(pname=("urn:NSConfig","statsnmpResponse"), ofwhat=[ns0.statsnmpResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statsnmpResponse, encoded="urn:NSConfig")

class statsc:
    def __init__(self):
        return
statsc.typecode = Struct(pname=("urn:NSConfig","statsc"), ofwhat=[], pyclass=statsc, encoded="urn:NSConfig")

class statscResponse:
    def __init__(self):
        self._return = None
        return
statscResponse.typecode = Struct(pname=("urn:NSConfig","statscResponse"), ofwhat=[ns0.statscResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statscResponse, encoded="urn:NSConfig")

class statscpolicy:
    def __init__(self):
        self._name = None
        return
statscpolicy.typecode = Struct(pname=("urn:NSConfig","statscpolicy"), ofwhat=[ZSI.TC.String(pname="name", aname="_name", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statscpolicy, encoded="urn:NSConfig")

class statscpolicyResponse:
    def __init__(self):
        self._return = None
        return
statscpolicyResponse.typecode = Struct(pname=("urn:NSConfig","statscpolicyResponse"), ofwhat=[ns0.statscpolicyResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statscpolicyResponse, encoded="urn:NSConfig")

class statssl:
    def __init__(self):
        return
statssl.typecode = Struct(pname=("urn:NSConfig","statssl"), ofwhat=[], pyclass=statssl, encoded="urn:NSConfig")

class statsslResponse:
    def __init__(self):
        self._return = None
        return
statsslResponse.typecode = Struct(pname=("urn:NSConfig","statsslResponse"), ofwhat=[ns0.statsslResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statsslResponse, encoded="urn:NSConfig")

class statsystem:
    def __init__(self):
        return
statsystem.typecode = Struct(pname=("urn:NSConfig","statsystem"), ofwhat=[], pyclass=statsystem, encoded="urn:NSConfig")

class statsystemResponse:
    def __init__(self):
        self._return = None
        return
statsystemResponse.typecode = Struct(pname=("urn:NSConfig","statsystemResponse"), ofwhat=[ns0.statsystemResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statsystemResponse, encoded="urn:NSConfig")

class statsystemcpu:
    def __init__(self):
        self._id = None
        return
statsystemcpu.typecode = Struct(pname=("urn:NSConfig","statsystemcpu"), ofwhat=[ZSI.TCnumbers.IunsignedInt(pname="id", aname="_id", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statsystemcpu, encoded="urn:NSConfig")

class statsystemcpuResponse:
    def __init__(self):
        self._return = None
        return
statsystemcpuResponse.typecode = Struct(pname=("urn:NSConfig","statsystemcpuResponse"), ofwhat=[ns0.statsystemcpuResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statsystemcpuResponse, encoded="urn:NSConfig")

class statvpn:
    def __init__(self):
        return
statvpn.typecode = Struct(pname=("urn:NSConfig","statvpn"), ofwhat=[], pyclass=statvpn, encoded="urn:NSConfig")

class statvpnResponse:
    def __init__(self):
        self._return = None
        return
statvpnResponse.typecode = Struct(pname=("urn:NSConfig","statvpnResponse"), ofwhat=[ns0.statvpnResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statvpnResponse, encoded="urn:NSConfig")

class statvpnvserver:
    def __init__(self):
        self._name = None
        return
statvpnvserver.typecode = Struct(pname=("urn:NSConfig","statvpnvserver"), ofwhat=[ZSI.TC.String(pname="name", aname="_name", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statvpnvserver, encoded="urn:NSConfig")

class statvpnvserverResponse:
    def __init__(self):
        self._return = None
        return
statvpnvserverResponse.typecode = Struct(pname=("urn:NSConfig","statvpnvserverResponse"), ofwhat=[ns0.statvpnvserverResult_Def(pname="return", aname="_return", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=statvpnvserverResponse, encoded="urn:NSConfig")