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


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

# Locator
class MetaEditAPILocator:
    MetaEditAPIPortType_address = "http://localhost:6390/MetaEditAPI"
    def getMetaEditAPIPortTypeAddress(self):
        return MetaEditAPILocator.MetaEditAPIPortType_address
    def getMetaEditAPIPortType(self, url=None, **kw):
        return MetaEditAPISoapBindingSOAP(url or MetaEditAPILocator.MetaEditAPIPortType_address, **kw)

# Methods
class MetaEditAPISoapBindingSOAP:
    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: allGoodInstances
    def allGoodInstances(self, request):
        if isinstance(request, allGoodInstancesRequest) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="http://metacase.com/MetaEditAPI.allGoodInstances", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=allGoodInstancesResponse.typecode.ofwhat, pyclass=allGoodInstancesResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    # op: login
    def login(self, request):
        if isinstance(request, loginRequest) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="http://metacase.com/MetaEditAPI.login", 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: loginDB
    def loginDB(self, request):
        if isinstance(request, loginDBRequest) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="http://metacase.com/MetaEditAPI.loginDB", encodingStyle="http://schemas.xmlsoap.org/soap/encoding/", **kw)
        # no output wsaction
        typecode = Struct(pname=None, ofwhat=loginDBResponse.typecode.ofwhat, pyclass=loginDBResponse.typecode.pyclass)
        response = self.binding.Receive(typecode)
        return response

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

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

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

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

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

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

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

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

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

class allGoodInstancesRequest:
    def __init__(self):
        self._receiver = None
        return
allGoodInstancesRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","allGoodInstances"), ofwhat=[ns0.METype_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=allGoodInstancesRequest, encoded="http://metacase.com/wsdl/")

class allGoodInstancesResponse:
    def __init__(self):
        self._result = None
        return
allGoodInstancesResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","allGoodInstancesResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=allGoodInstancesResponse, encoded="http://metacase.com/wsdl/")

class allSimilarInstancesRequest:
    def __init__(self):
        self._receiver = None
        return
allSimilarInstancesRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","allSimilarInstances"), ofwhat=[ns0.METype_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=allSimilarInstancesRequest, encoded="http://metacase.com/wsdl/")

class allSimilarInstancesResponse:
    def __init__(self):
        self._result = None
        return
allSimilarInstancesResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","allSimilarInstancesResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=allSimilarInstancesResponse, encoded="http://metacase.com/wsdl/")

class subTypeNamedRequest:
    def __init__(self):
        self._receiver = None
        self._subTypeNamed = None
        return
subTypeNamedRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","subTypeNamed"), ofwhat=[ns0.METype_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="subTypeNamed", aname="_subTypeNamed", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=subTypeNamedRequest, encoded="http://metacase.com/wsdl/")

class subTypeNamedResponse:
    def __init__(self):
        self._result = None
        return
subTypeNamedResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","subTypeNamedResponse"), ofwhat=[ns0.METype_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=subTypeNamedResponse, encoded="http://metacase.com/wsdl/")

class findStringRequest:
    def __init__(self):
        self._receiver = None
        self._findString = None
        return
findStringRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","findString"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="findString", aname="_findString", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=findStringRequest, encoded="http://metacase.com/wsdl/")

class findStringResponse:
    def __init__(self):
        self._result = None
        return
findStringResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","findStringResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=findStringResponse, encoded="http://metacase.com/wsdl/")

class instancesNamedRequest:
    def __init__(self):
        self._receiver = None
        self._instancesNamed = None
        self._ofSubTypesNamed = None
        return
instancesNamedRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","instancesNamed"), ofwhat=[ns0.METype_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="instancesNamed", aname="_instancesNamed", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="ofSubTypesNamed", aname="_ofSubTypesNamed", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=instancesNamedRequest, encoded="http://metacase.com/wsdl/")

class instancesNamedResponse:
    def __init__(self):
        self._result = None
        return
instancesNamedResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","instancesNamedResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=instancesNamedResponse, encoded="http://metacase.com/wsdl/")

class typeNameRequest:
    def __init__(self):
        self._receiver = None
        return
typeNameRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","typeName"), ofwhat=[ns0.METype_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=typeNameRequest, encoded="http://metacase.com/wsdl/")

class typeNameResponse:
    def __init__(self):
        self._result = None
        return
typeNameResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","typeNameResponse"), ofwhat=[ZSI.TC.String(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=typeNameResponse, encoded="http://metacase.com/wsdl/")

class typeRequest:
    def __init__(self):
        self._receiver = None
        return
typeRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","type"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=typeRequest, encoded="http://metacase.com/wsdl/")

class typeResponse:
    def __init__(self):
        self._result = None
        return
typeResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","typeResponse"), ofwhat=[ns0.METype_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=typeResponse, encoded="http://metacase.com/wsdl/")

class userPrintStringRequest:
    def __init__(self):
        self._receiver = None
        return
userPrintStringRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","userPrintString"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=userPrintStringRequest, encoded="http://metacase.com/wsdl/")

class userPrintStringResponse:
    def __init__(self):
        self._result = None
        return
userPrintStringResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","userPrintStringResponse"), ofwhat=[ZSI.TC.String(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=userPrintStringResponse, encoded="http://metacase.com/wsdl/")

class valueAtRequest:
    def __init__(self):
        self._receiver = None
        self._valueAt = None
        return
valueAtRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","valueAt"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TCnumbers.Iint(pname="valueAt", aname="_valueAt", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=valueAtRequest, encoded="http://metacase.com/wsdl/")

class valueAtResponse:
    def __init__(self):
        self._result = None
        return
valueAtResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","valueAtResponse"), ofwhat=[ns0.MEAny_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=valueAtResponse, encoded="http://metacase.com/wsdl/")

class setValueAtRequest:
    def __init__(self):
        self._receiver = None
        self._valueAt = None
        self._put = None
        return
setValueAtRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","setValueAt"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TCnumbers.Iint(pname="valueAt", aname="_valueAt", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEAny_Def(pname="put", aname="_put", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setValueAtRequest, encoded="http://metacase.com/wsdl/")

class setValueAtResponse:
    def __init__(self):
        self._result = None
        return
setValueAtResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","setValueAtResponse"), ofwhat=[ns0.MEAny_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setValueAtResponse, encoded="http://metacase.com/wsdl/")

class allPropertiesValuesRequest:
    def __init__(self):
        self._receiver = None
        return
allPropertiesValuesRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","allPropertiesValues"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=allPropertiesValuesRequest, encoded="http://metacase.com/wsdl/")

class allPropertiesValuesResponse:
    def __init__(self):
        self._result = None
        return
allPropertiesValuesResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","allPropertiesValuesResponse"), ofwhat=[ns0.MEAnyArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=allPropertiesValuesResponse, encoded="http://metacase.com/wsdl/")

class allPropertiesRequest:
    def __init__(self):
        self._receiver = None
        return
allPropertiesRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","allProperties"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=allPropertiesRequest, encoded="http://metacase.com/wsdl/")

class allPropertiesResponse:
    def __init__(self):
        self._result = None
        return
allPropertiesResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","allPropertiesResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=allPropertiesResponse, encoded="http://metacase.com/wsdl/")

class allPropertiesWrappedRequest:
    def __init__(self):
        self._receiver = None
        return
allPropertiesWrappedRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","allPropertiesWrapped"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=allPropertiesWrappedRequest, encoded="http://metacase.com/wsdl/")

class allPropertiesWrappedResponse:
    def __init__(self):
        self._result = None
        return
allPropertiesWrappedResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","allPropertiesWrappedResponse"), ofwhat=[ns0.MEAnyArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=allPropertiesWrappedResponse, encoded="http://metacase.com/wsdl/")

class instPropsRequest:
    def __init__(self):
        self._receiver = None
        self._propColl = None
        self._valueColl = None
        self._np = None
        self._inArea = None
        return
instPropsRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","instProps"), ofwhat=[ns0.METype_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEAnyArray_Def(pname="propColl", aname="_propColl", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEAnyArray_Def(pname="valueColl", aname="_valueColl", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEAny_Def(pname="np", aname="_np", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEAny_Def(pname="inArea", aname="_inArea", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=instPropsRequest, encoded="http://metacase.com/wsdl/")

class instPropsResponse:
    def __init__(self):
        self._result = None
        return
instPropsResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","instPropsResponse"), ofwhat=[ns0.MEAny_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=instPropsResponse, encoded="http://metacase.com/wsdl/")

class unsafeNewRequest:
    def __init__(self):
        self._receiver = None
        return
unsafeNewRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","unsafeNew"), ofwhat=[ns0.METype_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=unsafeNewRequest, encoded="http://metacase.com/wsdl/")

class unsafeNewResponse:
    def __init__(self):
        self._result = None
        return
unsafeNewResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","unsafeNewResponse"), ofwhat=[ns0.MEOop_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=unsafeNewResponse, encoded="http://metacase.com/wsdl/")

class objectSetRequest:
    def __init__(self):
        self._receiver = None
        return
objectSetRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","objectSet"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=objectSetRequest, encoded="http://metacase.com/wsdl/")

class objectSetResponse:
    def __init__(self):
        self._result = None
        return
objectSetResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","objectSetResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=objectSetResponse, encoded="http://metacase.com/wsdl/")

class relationshipSetRequest:
    def __init__(self):
        self._receiver = None
        return
relationshipSetRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","relationshipSet"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=relationshipSetRequest, encoded="http://metacase.com/wsdl/")

class relationshipSetResponse:
    def __init__(self):
        self._result = None
        return
relationshipSetResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","relationshipSetResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=relationshipSetResponse, encoded="http://metacase.com/wsdl/")

class roleSetRequest:
    def __init__(self):
        self._receiver = None
        return
roleSetRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","roleSet"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=roleSetRequest, encoded="http://metacase.com/wsdl/")

class roleSetResponse:
    def __init__(self):
        self._result = None
        return
roleSetResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","roleSetResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=roleSetResponse, encoded="http://metacase.com/wsdl/")

class bindingSetRequest:
    def __init__(self):
        self._receiver = None
        return
bindingSetRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","bindingSet"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=bindingSetRequest, encoded="http://metacase.com/wsdl/")

class bindingSetResponse:
    def __init__(self):
        self._result = None
        return
bindingSetResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","bindingSetResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=bindingSetResponse, encoded="http://metacase.com/wsdl/")

class explodeGraphsRequest:
    def __init__(self):
        self._receiver = None
        return
explodeGraphsRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","explodeGraphs"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=explodeGraphsRequest, encoded="http://metacase.com/wsdl/")

class explodeGraphsResponse:
    def __init__(self):
        self._result = None
        return
explodeGraphsResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","explodeGraphsResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=explodeGraphsResponse, encoded="http://metacase.com/wsdl/")

class decompGraphsRequest:
    def __init__(self):
        self._receiver = None
        return
decompGraphsRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","decompGraphs"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=decompGraphsRequest, encoded="http://metacase.com/wsdl/")

class decompGraphsResponse:
    def __init__(self):
        self._result = None
        return
decompGraphsResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","decompGraphsResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=decompGraphsResponse, encoded="http://metacase.com/wsdl/")

class subgraphsRequest:
    def __init__(self):
        self._receiver = None
        return
subgraphsRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","subgraphs"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=subgraphsRequest, encoded="http://metacase.com/wsdl/")

class subgraphsResponse:
    def __init__(self):
        self._result = None
        return
subgraphsResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","subgraphsResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=subgraphsResponse, encoded="http://metacase.com/wsdl/")

class addExplodeRequest:
    def __init__(self):
        self._receiver = None
        self._addExplode = None
        self._for = None
        return
addExplodeRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","addExplode"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEOop_Def(pname="addExplode", aname="_addExplode", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEOop_Def(pname="for", aname="_for", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=addExplodeRequest, encoded="http://metacase.com/wsdl/")

class addExplodeResponse:
    def __init__(self):
        self._result = None
        return
addExplodeResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","addExplodeResponse"), ofwhat=[ns0.MEOop_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=addExplodeResponse, encoded="http://metacase.com/wsdl/")

class getExplodeGraphsForNPRequest:
    def __init__(self):
        self._receiver = None
        self._getExplodeGraphsForNP = None
        return
getExplodeGraphsForNPRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","getExplodeGraphsForNP"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEOop_Def(pname="getExplodeGraphsForNP", aname="_getExplodeGraphsForNP", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=getExplodeGraphsForNPRequest, encoded="http://metacase.com/wsdl/")

class getExplodeGraphsForNPResponse:
    def __init__(self):
        self._result = None
        return
getExplodeGraphsForNPResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","getExplodeGraphsForNPResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=getExplodeGraphsForNPResponse, encoded="http://metacase.com/wsdl/")

class removeExplodeRequest:
    def __init__(self):
        self._receiver = None
        self._removeExplode = None
        self._for = None
        return
removeExplodeRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","removeExplode"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEOop_Def(pname="removeExplode", aname="_removeExplode", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEOop_Def(pname="for", aname="_for", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=removeExplodeRequest, encoded="http://metacase.com/wsdl/")

class removeExplodeResponse:
    def __init__(self):
        self._result = None
        return
removeExplodeResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","removeExplodeResponse"), ofwhat=[ns0.MEOop_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=removeExplodeResponse, encoded="http://metacase.com/wsdl/")

class decompGraphRequest:
    def __init__(self):
        self._receiver = None
        return
decompGraphRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","decompGraph"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=decompGraphRequest, encoded="http://metacase.com/wsdl/")

class decompGraphResponse:
    def __init__(self):
        self._result = None
        return
decompGraphResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","decompGraphResponse"), ofwhat=[ns0.MEAny_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=decompGraphResponse, encoded="http://metacase.com/wsdl/")

class setDecompGraphRequest:
    def __init__(self):
        self._receiver = None
        self._decompGraph = None
        return
setDecompGraphRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","setDecompGraph"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEAny_Def(pname="decompGraph", aname="_decompGraph", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setDecompGraphRequest, encoded="http://metacase.com/wsdl/")

class setDecompGraphResponse:
    def __init__(self):
        self._result = None
        return
setDecompGraphResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","setDecompGraphResponse"), ofwhat=[ns0.MEAny_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setDecompGraphResponse, encoded="http://metacase.com/wsdl/")

class objsForObjRequest:
    def __init__(self):
        self._receiver = None
        self._objsForObj = None
        self._ofClass = None
        return
objsForObjRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","objsForObj"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEOop_Def(pname="objsForObj", aname="_objsForObj", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.METype_Def(pname="ofClass", aname="_ofClass", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=objsForObjRequest, encoded="http://metacase.com/wsdl/")

class objsForObjResponse:
    def __init__(self):
        self._result = None
        return
objsForObjResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","objsForObjResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=objsForObjResponse, encoded="http://metacase.com/wsdl/")

class objsForRelRequest:
    def __init__(self):
        self._receiver = None
        self._objsForRel = None
        self._ofClass = None
        return
objsForRelRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","objsForRel"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEOop_Def(pname="objsForRel", aname="_objsForRel", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.METype_Def(pname="ofClass", aname="_ofClass", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=objsForRelRequest, encoded="http://metacase.com/wsdl/")

class objsForRelResponse:
    def __init__(self):
        self._result = None
        return
objsForRelResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","objsForRelResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=objsForRelResponse, encoded="http://metacase.com/wsdl/")

class objsForRoleRequest:
    def __init__(self):
        self._receiver = None
        self._objsForRole = None
        self._ofClass = None
        return
objsForRoleRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","objsForRole"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEOop_Def(pname="objsForRole", aname="_objsForRole", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.METype_Def(pname="ofClass", aname="_ofClass", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=objsForRoleRequest, encoded="http://metacase.com/wsdl/")

class objsForRoleResponse:
    def __init__(self):
        self._result = None
        return
objsForRoleResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","objsForRoleResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=objsForRoleResponse, encoded="http://metacase.com/wsdl/")

class relsForObjRequest:
    def __init__(self):
        self._receiver = None
        self._relsForObj = None
        self._ofClass = None
        return
relsForObjRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","relsForObj"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEOop_Def(pname="relsForObj", aname="_relsForObj", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.METype_Def(pname="ofClass", aname="_ofClass", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=relsForObjRequest, encoded="http://metacase.com/wsdl/")

class relsForObjResponse:
    def __init__(self):
        self._result = None
        return
relsForObjResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","relsForObjResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=relsForObjResponse, encoded="http://metacase.com/wsdl/")

class relsForRoleRequest:
    def __init__(self):
        self._receiver = None
        self._relsForRole = None
        self._ofClass = None
        return
relsForRoleRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","relsForRole"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEOop_Def(pname="relsForRole", aname="_relsForRole", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.METype_Def(pname="ofClass", aname="_ofClass", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=relsForRoleRequest, encoded="http://metacase.com/wsdl/")

class relsForRoleResponse:
    def __init__(self):
        self._result = None
        return
relsForRoleResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","relsForRoleResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=relsForRoleResponse, encoded="http://metacase.com/wsdl/")

class rolesForObjRequest:
    def __init__(self):
        self._receiver = None
        self._rolesForObj = None
        self._ofClass = None
        return
rolesForObjRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","rolesForObj"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEOop_Def(pname="rolesForObj", aname="_rolesForObj", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.METype_Def(pname="ofClass", aname="_ofClass", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=rolesForObjRequest, encoded="http://metacase.com/wsdl/")

class rolesForObjResponse:
    def __init__(self):
        self._result = None
        return
rolesForObjResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","rolesForObjResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=rolesForObjResponse, encoded="http://metacase.com/wsdl/")

class rolesForRelRequest:
    def __init__(self):
        self._receiver = None
        self._rolesForRel = None
        self._ofClass = None
        return
rolesForRelRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","rolesForRel"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEOop_Def(pname="rolesForRel", aname="_rolesForRel", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.METype_Def(pname="ofClass", aname="_ofClass", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=rolesForRelRequest, encoded="http://metacase.com/wsdl/")

class rolesForRelResponse:
    def __init__(self):
        self._result = None
        return
rolesForRelResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","rolesForRelResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=rolesForRelResponse, encoded="http://metacase.com/wsdl/")

class rolesForRoleRequest:
    def __init__(self):
        self._receiver = None
        self._rolesForRole = None
        self._ofClass = None
        return
rolesForRoleRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","rolesForRole"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEOop_Def(pname="rolesForRole", aname="_rolesForRole", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.METype_Def(pname="ofClass", aname="_ofClass", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=rolesForRoleRequest, encoded="http://metacase.com/wsdl/")

class rolesForRoleResponse:
    def __init__(self):
        self._result = None
        return
rolesForRoleResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","rolesForRoleResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=rolesForRoleResponse, encoded="http://metacase.com/wsdl/")

class openRequest:
    def __init__(self):
        self._receiver = None
        return
openRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","open"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=openRequest, encoded="http://metacase.com/wsdl/")

class openResponse:
    def __init__(self):
        self._result = None
        return
openResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","openResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=openResponse, encoded="http://metacase.com/wsdl/")

class animateRequest:
    def __init__(self):
        self._receiver = None
        self._animate = None
        return
animateRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","animate"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEOop_Def(pname="animate", aname="_animate", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=animateRequest, encoded="http://metacase.com/wsdl/")

class animateResponse:
    def __init__(self):
        self._result = None
        return
animateResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","animateResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=animateResponse, encoded="http://metacase.com/wsdl/")

class refreshRequest:
    def __init__(self):
        self._receiver = None
        return
refreshRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","refresh"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=refreshRequest, encoded="http://metacase.com/wsdl/")

class refreshResponse:
    def __init__(self):
        self._result = None
        return
refreshResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","refreshResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=refreshResponse, encoded="http://metacase.com/wsdl/")

class copiedObjectsRequest:
    def __init__(self):
        self._receiver = None
        return
copiedObjectsRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","copiedObjects"), ofwhat=[ns0.MENull_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=copiedObjectsRequest, encoded="http://metacase.com/wsdl/")

class copiedObjectsResponse:
    def __init__(self):
        self._result = None
        return
copiedObjectsResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","copiedObjectsResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=copiedObjectsResponse, encoded="http://metacase.com/wsdl/")

class deleteRequest:
    def __init__(self):
        self._receiver = None
        return
deleteRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","delete"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=deleteRequest, encoded="http://metacase.com/wsdl/")

class deleteResponse:
    def __init__(self):
        self._result = None
        return
deleteResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","deleteResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=deleteResponse, encoded="http://metacase.com/wsdl/")

class addToGraphRequest:
    def __init__(self):
        self._receiver = None
        self._addToGraph = None
        return
addToGraphRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","addToGraph"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEOop_Def(pname="addToGraph", aname="_addToGraph", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=addToGraphRequest, encoded="http://metacase.com/wsdl/")

class addToGraphResponse:
    def __init__(self):
        self._result = None
        return
addToGraphResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","addToGraphResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=addToGraphResponse, encoded="http://metacase.com/wsdl/")

class createBindingRequest:
    def __init__(self):
        self._receiver = None
        self._relType = None
        self._roleTypes = None
        self._objects = None
        return
createBindingRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","createBinding"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.METype_Def(pname="relType", aname="_relType", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.METypeArray_Def(pname="roleTypes", aname="_roleTypes", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEOopArray_Def(pname="objects", aname="_objects", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=createBindingRequest, encoded="http://metacase.com/wsdl/")

class createBindingResponse:
    def __init__(self):
        self._result = None
        return
createBindingResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","createBindingResponse"), ofwhat=[ns0.MEOop_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=createBindingResponse, encoded="http://metacase.com/wsdl/")

class relationshipRequest:
    def __init__(self):
        self._receiver = None
        return
relationshipRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","relationship"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=relationshipRequest, encoded="http://metacase.com/wsdl/")

class relationshipResponse:
    def __init__(self):
        self._result = None
        return
relationshipResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","relationshipResponse"), ofwhat=[ns0.MEOop_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=relationshipResponse, encoded="http://metacase.com/wsdl/")

class rolesRequest:
    def __init__(self):
        self._receiver = None
        return
rolesRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","roles"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=rolesRequest, encoded="http://metacase.com/wsdl/")

class rolesResponse:
    def __init__(self):
        self._result = None
        return
rolesResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","rolesResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=rolesResponse, encoded="http://metacase.com/wsdl/")

class objectsRequest:
    def __init__(self):
        self._receiver = None
        return
objectsRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","objects"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=objectsRequest, encoded="http://metacase.com/wsdl/")

class objectsResponse:
    def __init__(self):
        self._result = None
        return
objectsResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","objectsResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=objectsResponse, encoded="http://metacase.com/wsdl/")

class diagramsRequest:
    def __init__(self):
        self._receiver = None
        return
diagramsRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","diagrams"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=diagramsRequest, encoded="http://metacase.com/wsdl/")

class diagramsResponse:
    def __init__(self):
        self._result = None
        return
diagramsResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","diagramsResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=diagramsResponse, encoded="http://metacase.com/wsdl/")

class matricesRequest:
    def __init__(self):
        self._receiver = None
        return
matricesRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","matrices"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=matricesRequest, encoded="http://metacase.com/wsdl/")

class matricesResponse:
    def __init__(self):
        self._result = None
        return
matricesResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","matricesResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=matricesResponse, encoded="http://metacase.com/wsdl/")

class tablesRequest:
    def __init__(self):
        self._receiver = None
        return
tablesRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","tables"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=tablesRequest, encoded="http://metacase.com/wsdl/")

class tablesResponse:
    def __init__(self):
        self._result = None
        return
tablesResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","tablesResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=tablesResponse, encoded="http://metacase.com/wsdl/")

class newDiagramRequest:
    def __init__(self):
        self._receiver = None
        return
newDiagramRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","newDiagram"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=newDiagramRequest, encoded="http://metacase.com/wsdl/")

class newDiagramResponse:
    def __init__(self):
        self._result = None
        return
newDiagramResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","newDiagramResponse"), ofwhat=[ns0.MEOop_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=newDiagramResponse, encoded="http://metacase.com/wsdl/")

class newMatrixRequest:
    def __init__(self):
        self._receiver = None
        return
newMatrixRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","newMatrix"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=newMatrixRequest, encoded="http://metacase.com/wsdl/")

class newMatrixResponse:
    def __init__(self):
        self._result = None
        return
newMatrixResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","newMatrixResponse"), ofwhat=[ns0.MEOop_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=newMatrixResponse, encoded="http://metacase.com/wsdl/")

class newTableRequest:
    def __init__(self):
        self._receiver = None
        return
newTableRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","newTable"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=newTableRequest, encoded="http://metacase.com/wsdl/")

class newTableResponse:
    def __init__(self):
        self._result = None
        return
newTableResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","newTableResponse"), ofwhat=[ns0.MEOop_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=newTableResponse, encoded="http://metacase.com/wsdl/")

class instRequest:
    def __init__(self):
        self._receiver = None
        return
instRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","inst"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=instRequest, encoded="http://metacase.com/wsdl/")

class instResponse:
    def __init__(self):
        self._result = None
        return
instResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","instResponse"), ofwhat=[ns0.MEOop_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=instResponse, encoded="http://metacase.com/wsdl/")

class repSetRequest:
    def __init__(self):
        self._receiver = None
        return
repSetRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","repSet"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=repSetRequest, encoded="http://metacase.com/wsdl/")

class repSetResponse:
    def __init__(self):
        self._result = None
        return
repSetResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","repSetResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=repSetResponse, encoded="http://metacase.com/wsdl/")

class reprGraphRequest:
    def __init__(self):
        self._receiver = None
        return
reprGraphRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","reprGraph"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=reprGraphRequest, encoded="http://metacase.com/wsdl/")

class reprGraphResponse:
    def __init__(self):
        self._result = None
        return
reprGraphResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","reprGraphResponse"), ofwhat=[ns0.MEOop_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=reprGraphResponse, encoded="http://metacase.com/wsdl/")

class removeRequest:
    def __init__(self):
        self._receiver = None
        return
removeRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","remove"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=removeRequest, encoded="http://metacase.com/wsdl/")

class removeResponse:
    def __init__(self):
        self._result = None
        return
removeResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","removeResponse"), ofwhat=[ns0.MEOop_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=removeResponse, encoded="http://metacase.com/wsdl/")

class timeStampRequest:
    def __init__(self):
        self._receiver = None
        return
timeStampRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","timeStamp"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=timeStampRequest, encoded="http://metacase.com/wsdl/")

class timeStampResponse:
    def __init__(self):
        self._result = None
        return
timeStampResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","timeStampResponse"), ofwhat=[ZSI.TCtimes.gDateTime(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=timeStampResponse, encoded="http://metacase.com/wsdl/")

class setTimeStampRequest:
    def __init__(self):
        self._receiver = None
        self._timeStamp = None
        return
setTimeStampRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","setTimeStamp"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TCtimes.gDateTime(pname="timeStamp", aname="_timeStamp", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setTimeStampRequest, encoded="http://metacase.com/wsdl/")

class setTimeStampResponse:
    def __init__(self):
        self._result = None
        return
setTimeStampResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","setTimeStampResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setTimeStampResponse, encoded="http://metacase.com/wsdl/")

class objectReprsRequest:
    def __init__(self):
        self._receiver = None
        return
objectReprsRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","objectReprs"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=objectReprsRequest, encoded="http://metacase.com/wsdl/")

class objectReprsResponse:
    def __init__(self):
        self._result = None
        return
objectReprsResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","objectReprsResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=objectReprsResponse, encoded="http://metacase.com/wsdl/")

class bindingReprsRequest:
    def __init__(self):
        self._receiver = None
        return
bindingReprsRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","bindingReprs"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=bindingReprsRequest, encoded="http://metacase.com/wsdl/")

class bindingReprsResponse:
    def __init__(self):
        self._result = None
        return
bindingReprsResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","bindingReprsResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=bindingReprsResponse, encoded="http://metacase.com/wsdl/")

class gridRequest:
    def __init__(self):
        self._receiver = None
        return
gridRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","grid"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=gridRequest, encoded="http://metacase.com/wsdl/")

class gridResponse:
    def __init__(self):
        self._result = None
        return
gridResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","gridResponse"), ofwhat=[ns0.MEAny_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=gridResponse, encoded="http://metacase.com/wsdl/")

class setGridRequest:
    def __init__(self):
        self._receiver = None
        self._grid = None
        return
setGridRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","setGrid"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEAny_Def(pname="grid", aname="_grid", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setGridRequest, encoded="http://metacase.com/wsdl/")

class setGridResponse:
    def __init__(self):
        self._result = None
        return
setGridResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","setGridResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setGridResponse, encoded="http://metacase.com/wsdl/")

class displayGridRequest:
    def __init__(self):
        self._receiver = None
        return
displayGridRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","displayGrid"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=displayGridRequest, encoded="http://metacase.com/wsdl/")

class displayGridResponse:
    def __init__(self):
        self._result = None
        return
displayGridResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","displayGridResponse"), ofwhat=[ZSI.TC.Boolean(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=displayGridResponse, encoded="http://metacase.com/wsdl/")

class setDisplayGridRequest:
    def __init__(self):
        self._receiver = None
        self._displayGrid = None
        return
setDisplayGridRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","setDisplayGrid"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.Boolean(pname="displayGrid", aname="_displayGrid", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setDisplayGridRequest, encoded="http://metacase.com/wsdl/")

class setDisplayGridResponse:
    def __init__(self):
        self._result = None
        return
setDisplayGridResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","setDisplayGridResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setDisplayGridResponse, encoded="http://metacase.com/wsdl/")

class useGridRequest:
    def __init__(self):
        self._receiver = None
        return
useGridRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","useGrid"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=useGridRequest, encoded="http://metacase.com/wsdl/")

class useGridResponse:
    def __init__(self):
        self._result = None
        return
useGridResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","useGridResponse"), ofwhat=[ZSI.TC.Boolean(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=useGridResponse, encoded="http://metacase.com/wsdl/")

class setUseGridRequest:
    def __init__(self):
        self._receiver = None
        self._useGrid = None
        return
setUseGridRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","setUseGrid"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.Boolean(pname="useGrid", aname="_useGrid", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setUseGridRequest, encoded="http://metacase.com/wsdl/")

class setUseGridResponse:
    def __init__(self):
        self._result = None
        return
setUseGridResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","setUseGridResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setUseGridResponse, encoded="http://metacase.com/wsdl/")

class placeRequest:
    def __init__(self):
        self._receiver = None
        return
placeRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","place"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=placeRequest, encoded="http://metacase.com/wsdl/")

class placeResponse:
    def __init__(self):
        self._result = None
        return
placeResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","placeResponse"), ofwhat=[ns0.MEAny_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=placeResponse, encoded="http://metacase.com/wsdl/")

class setPlaceRequest:
    def __init__(self):
        self._receiver = None
        self._place = None
        return
setPlaceRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","setPlace"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEAny_Def(pname="place", aname="_place", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setPlaceRequest, encoded="http://metacase.com/wsdl/")

class setPlaceResponse:
    def __init__(self):
        self._result = None
        return
setPlaceResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","setPlaceResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setPlaceResponse, encoded="http://metacase.com/wsdl/")

class scaleRequest:
    def __init__(self):
        self._receiver = None
        return
scaleRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","scale"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=scaleRequest, encoded="http://metacase.com/wsdl/")

class scaleResponse:
    def __init__(self):
        self._result = None
        return
scaleResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","scaleResponse"), ofwhat=[ns0.MEAny_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=scaleResponse, encoded="http://metacase.com/wsdl/")

class setScaleRequest:
    def __init__(self):
        self._receiver = None
        self._scale = None
        return
setScaleRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","setScale"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEAny_Def(pname="scale", aname="_scale", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setScaleRequest, encoded="http://metacase.com/wsdl/")

class setScaleResponse:
    def __init__(self):
        self._result = None
        return
setScaleResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","setScaleResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setScaleResponse, encoded="http://metacase.com/wsdl/")

class isStraightRequest:
    def __init__(self):
        self._receiver = None
        return
isStraightRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","isStraight"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=isStraightRequest, encoded="http://metacase.com/wsdl/")

class isStraightResponse:
    def __init__(self):
        self._result = None
        return
isStraightResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","isStraightResponse"), ofwhat=[ZSI.TC.Boolean(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=isStraightResponse, encoded="http://metacase.com/wsdl/")

class straightenRequest:
    def __init__(self):
        self._receiver = None
        return
straightenRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","straighten"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=straightenRequest, encoded="http://metacase.com/wsdl/")

class straightenResponse:
    def __init__(self):
        self._result = None
        return
straightenResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","straightenResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=straightenResponse, encoded="http://metacase.com/wsdl/")

class layoutRequest:
    def __init__(self):
        self._receiver = None
        self._layoutRelationship = None
        self._fromRole = None
        self._toRole = None
        self._direction = None
        self._manhattan = None
        return
layoutRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","layout"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.METype_Def(pname="layoutRelationship", aname="_layoutRelationship", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.METype_Def(pname="fromRole", aname="_fromRole", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.METype_Def(pname="toRole", aname="_toRole", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="direction", aname="_direction", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.Boolean(pname="manhattan", aname="_manhattan", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=layoutRequest, encoded="http://metacase.com/wsdl/")

class layoutResponse:
    def __init__(self):
        self._result = None
        return
layoutResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","layoutResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=layoutResponse, encoded="http://metacase.com/wsdl/")

class addNewObjectRepForRequest:
    def __init__(self):
        self._receiver = None
        self._addNewObjectRepFor = None
        self._beforeIndex = None
        self._place = None
        return
addNewObjectRepForRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","addNewObjectRepFor"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEOop_Def(pname="addNewObjectRepFor", aname="_addNewObjectRepFor", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TCnumbers.Iint(pname="beforeIndex", aname="_beforeIndex", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEAny_Def(pname="place", aname="_place", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=addNewObjectRepForRequest, encoded="http://metacase.com/wsdl/")

class addNewObjectRepForResponse:
    def __init__(self):
        self._result = None
        return
addNewObjectRepForResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","addNewObjectRepForResponse"), ofwhat=[ns0.MEOop_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=addNewObjectRepForResponse, encoded="http://metacase.com/wsdl/")

class addNewBindingRepForRequest:
    def __init__(self):
        self._receiver = None
        self._addNewBindingRepFor = None
        self._beforeIndex = None
        self._place = None
        return
addNewBindingRepForRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","addNewBindingRepFor"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEOop_Def(pname="addNewBindingRepFor", aname="_addNewBindingRepFor", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TCnumbers.Iint(pname="beforeIndex", aname="_beforeIndex", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEAny_Def(pname="place", aname="_place", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=addNewBindingRepForRequest, encoded="http://metacase.com/wsdl/")

class addNewBindingRepForResponse:
    def __init__(self):
        self._result = None
        return
addNewBindingRepForResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","addNewBindingRepForResponse"), ofwhat=[ns0.MEOop_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=addNewBindingRepForResponse, encoded="http://metacase.com/wsdl/")

class connectionReprIdsRequest:
    def __init__(self):
        self._receiver = None
        return
connectionReprIdsRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","connectionReprIds"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=connectionReprIdsRequest, encoded="http://metacase.com/wsdl/")

class connectionReprIdsResponse:
    def __init__(self):
        self._result = None
        return
connectionReprIdsResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","connectionReprIdsResponse"), ofwhat=[ns0.MEAnyArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=connectionReprIdsResponse, encoded="http://metacase.com/wsdl/")

class addPointRequest:
    def __init__(self):
        self._receiver = None
        self._addPoint = None
        self._index = None
        self._id = None
        return
addPointRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","addPoint"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEAny_Def(pname="addPoint", aname="_addPoint", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TCnumbers.Iint(pname="index", aname="_index", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TCnumbers.Iint(pname="id", aname="_id", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=addPointRequest, encoded="http://metacase.com/wsdl/")

class addPointResponse:
    def __init__(self):
        self._result = None
        return
addPointResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","addPointResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=addPointResponse, encoded="http://metacase.com/wsdl/")

class putPointAtIndexRequest:
    def __init__(self):
        self._receiver = None
        self._at = None
        self._putPoint = None
        self._id = None
        return
putPointAtIndexRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","putPointAtIndex"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TCnumbers.Iint(pname="at", aname="_at", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEAny_Def(pname="putPoint", aname="_putPoint", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TCnumbers.Iint(pname="id", aname="_id", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=putPointAtIndexRequest, encoded="http://metacase.com/wsdl/")

class putPointAtIndexResponse:
    def __init__(self):
        self._result = None
        return
putPointAtIndexResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","putPointAtIndexResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=putPointAtIndexResponse, encoded="http://metacase.com/wsdl/")

class breakpointsRequest:
    def __init__(self):
        self._receiver = None
        self._breakpoints = None
        self._id = None
        return
breakpointsRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","breakpoints"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEAnyArray_Def(pname="breakpoints", aname="_breakpoints", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TCnumbers.Iint(pname="id", aname="_id", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=breakpointsRequest, encoded="http://metacase.com/wsdl/")

class breakpointsResponse:
    def __init__(self):
        self._result = None
        return
breakpointsResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","breakpointsResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=breakpointsResponse, encoded="http://metacase.com/wsdl/")

class objTargetOffsetRequest:
    def __init__(self):
        self._receiver = None
        self._objTargetOffset = None
        self._id = None
        return
objTargetOffsetRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","objTargetOffset"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEAny_Def(pname="objTargetOffset", aname="_objTargetOffset", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TCnumbers.Iint(pname="id", aname="_id", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=objTargetOffsetRequest, encoded="http://metacase.com/wsdl/")

class objTargetOffsetResponse:
    def __init__(self):
        self._result = None
        return
objTargetOffsetResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","objTargetOffsetResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=objTargetOffsetResponse, encoded="http://metacase.com/wsdl/")

class removePointRequest:
    def __init__(self):
        self._receiver = None
        self._removePoint = None
        self._id = None
        return
removePointRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","removePoint"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEAny_Def(pname="removePoint", aname="_removePoint", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TCnumbers.Iint(pname="id", aname="_id", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=removePointRequest, encoded="http://metacase.com/wsdl/")

class removePointResponse:
    def __init__(self):
        self._result = None
        return
removePointResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","removePointResponse"), ofwhat=[ns0.MEAny_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=removePointResponse, encoded="http://metacase.com/wsdl/")

class hAxisRequest:
    def __init__(self):
        self._receiver = None
        return
hAxisRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","hAxis"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=hAxisRequest, encoded="http://metacase.com/wsdl/")

class hAxisResponse:
    def __init__(self):
        self._result = None
        return
hAxisResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","hAxisResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=hAxisResponse, encoded="http://metacase.com/wsdl/")

class vAxisRequest:
    def __init__(self):
        self._receiver = None
        return
vAxisRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","vAxis"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=vAxisRequest, encoded="http://metacase.com/wsdl/")

class vAxisResponse:
    def __init__(self):
        self._result = None
        return
vAxisResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","vAxisResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=vAxisResponse, encoded="http://metacase.com/wsdl/")

class bindSelectRequest:
    def __init__(self):
        self._receiver = None
        return
bindSelectRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","bindSelect"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=bindSelectRequest, encoded="http://metacase.com/wsdl/")

class bindSelectResponse:
    def __init__(self):
        self._result = None
        return
bindSelectResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","bindSelectResponse"), ofwhat=[ZSI.TC.String(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=bindSelectResponse, encoded="http://metacase.com/wsdl/")

class setBindSelectRequest:
    def __init__(self):
        self._receiver = None
        self._bindSelect = None
        return
setBindSelectRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","setBindSelect"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="bindSelect", aname="_bindSelect", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setBindSelectRequest, encoded="http://metacase.com/wsdl/")

class setBindSelectResponse:
    def __init__(self):
        self._result = None
        return
setBindSelectResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","setBindSelectResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setBindSelectResponse, encoded="http://metacase.com/wsdl/")

class cellDisplayModeRequest:
    def __init__(self):
        self._receiver = None
        return
cellDisplayModeRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","cellDisplayMode"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=cellDisplayModeRequest, encoded="http://metacase.com/wsdl/")

class cellDisplayModeResponse:
    def __init__(self):
        self._result = None
        return
cellDisplayModeResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","cellDisplayModeResponse"), ofwhat=[ZSI.TC.String(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=cellDisplayModeResponse, encoded="http://metacase.com/wsdl/")

class setCellDisplayModeRequest:
    def __init__(self):
        self._receiver = None
        self._cellDisplayMode = None
        return
setCellDisplayModeRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","setCellDisplayMode"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="cellDisplayMode", aname="_cellDisplayMode", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setCellDisplayModeRequest, encoded="http://metacase.com/wsdl/")

class setCellDisplayModeResponse:
    def __init__(self):
        self._result = None
        return
setCellDisplayModeResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","setCellDisplayModeResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setCellDisplayModeResponse, encoded="http://metacase.com/wsdl/")

class displayStringSelectorRequest:
    def __init__(self):
        self._receiver = None
        return
displayStringSelectorRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","displayStringSelector"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=displayStringSelectorRequest, encoded="http://metacase.com/wsdl/")

class displayStringSelectorResponse:
    def __init__(self):
        self._result = None
        return
displayStringSelectorResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","displayStringSelectorResponse"), ofwhat=[ZSI.TC.String(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=displayStringSelectorResponse, encoded="http://metacase.com/wsdl/")

class setDisplayStringSelectorRequest:
    def __init__(self):
        self._receiver = None
        self._displayStringSelector = None
        return
setDisplayStringSelectorRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","setDisplayStringSelector"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="displayStringSelector", aname="_displayStringSelector", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setDisplayStringSelectorRequest, encoded="http://metacase.com/wsdl/")

class setDisplayStringSelectorResponse:
    def __init__(self):
        self._result = None
        return
setDisplayStringSelectorResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","setDisplayStringSelectorResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setDisplayStringSelectorResponse, encoded="http://metacase.com/wsdl/")

class axisDisplayModeRequest:
    def __init__(self):
        self._receiver = None
        return
axisDisplayModeRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","axisDisplayMode"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=axisDisplayModeRequest, encoded="http://metacase.com/wsdl/")

class axisDisplayModeResponse:
    def __init__(self):
        self._result = None
        return
axisDisplayModeResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","axisDisplayModeResponse"), ofwhat=[ZSI.TC.String(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=axisDisplayModeResponse, encoded="http://metacase.com/wsdl/")

class setAxisDisplayModeRequest:
    def __init__(self):
        self._receiver = None
        self._axisDisplayMode = None
        return
setAxisDisplayModeRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","setAxisDisplayMode"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="axisDisplayMode", aname="_axisDisplayMode", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setAxisDisplayModeRequest, encoded="http://metacase.com/wsdl/")

class setAxisDisplayModeResponse:
    def __init__(self):
        self._result = None
        return
setAxisDisplayModeResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","setAxisDisplayModeResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setAxisDisplayModeResponse, encoded="http://metacase.com/wsdl/")

class showFirstRequest:
    def __init__(self):
        self._receiver = None
        return
showFirstRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","showFirst"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=showFirstRequest, encoded="http://metacase.com/wsdl/")

class showFirstResponse:
    def __init__(self):
        self._result = None
        return
showFirstResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","showFirstResponse"), ofwhat=[ZSI.TC.Boolean(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=showFirstResponse, encoded="http://metacase.com/wsdl/")

class setShowFirstRequest:
    def __init__(self):
        self._receiver = None
        self._showFirst = None
        return
setShowFirstRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","setShowFirst"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.Boolean(pname="showFirst", aname="_showFirst", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setShowFirstRequest, encoded="http://metacase.com/wsdl/")

class setShowFirstResponse:
    def __init__(self):
        self._result = None
        return
setShowFirstResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","setShowFirstResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setShowFirstResponse, encoded="http://metacase.com/wsdl/")

class rowLabelsWidthRequest:
    def __init__(self):
        self._receiver = None
        return
rowLabelsWidthRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","rowLabelsWidth"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=rowLabelsWidthRequest, encoded="http://metacase.com/wsdl/")

class rowLabelsWidthResponse:
    def __init__(self):
        self._result = None
        return
rowLabelsWidthResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","rowLabelsWidthResponse"), ofwhat=[ZSI.TCnumbers.Iint(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=rowLabelsWidthResponse, encoded="http://metacase.com/wsdl/")

class setRowLabelsWidthRequest:
    def __init__(self):
        self._receiver = None
        self._rowLabelsWidth = None
        return
setRowLabelsWidthRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","setRowLabelsWidth"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TCnumbers.Iint(pname="rowLabelsWidth", aname="_rowLabelsWidth", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setRowLabelsWidthRequest, encoded="http://metacase.com/wsdl/")

class setRowLabelsWidthResponse:
    def __init__(self):
        self._result = None
        return
setRowLabelsWidthResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","setRowLabelsWidthResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setRowLabelsWidthResponse, encoded="http://metacase.com/wsdl/")

class textStyleSymbolRequest:
    def __init__(self):
        self._receiver = None
        return
textStyleSymbolRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","textStyleSymbol"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=textStyleSymbolRequest, encoded="http://metacase.com/wsdl/")

class textStyleSymbolResponse:
    def __init__(self):
        self._result = None
        return
textStyleSymbolResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","textStyleSymbolResponse"), ofwhat=[ZSI.TC.String(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=textStyleSymbolResponse, encoded="http://metacase.com/wsdl/")

class setTextStyleSymbolRequest:
    def __init__(self):
        self._receiver = None
        self._textStyleSymbol = None
        return
setTextStyleSymbolRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","setTextStyleSymbol"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="textStyleSymbol", aname="_textStyleSymbol", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setTextStyleSymbolRequest, encoded="http://metacase.com/wsdl/")

class setTextStyleSymbolResponse:
    def __init__(self):
        self._result = None
        return
setTextStyleSymbolResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","setTextStyleSymbolResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setTextStyleSymbolResponse, encoded="http://metacase.com/wsdl/")

class addNewAxisEltForRequest:
    def __init__(self):
        self._receiver = None
        self._addNewRepFor = None
        self._toAxis = None
        self._beforeIndex = None
        return
addNewAxisEltForRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","addNewAxisEltFor"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEOop_Def(pname="addNewRepFor", aname="_addNewRepFor", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="toAxis", aname="_toAxis", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TCnumbers.Iint(pname="beforeIndex", aname="_beforeIndex", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=addNewAxisEltForRequest, encoded="http://metacase.com/wsdl/")

class addNewAxisEltForResponse:
    def __init__(self):
        self._result = None
        return
addNewAxisEltForResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","addNewAxisEltForResponse"), ofwhat=[ns0.MEOop_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=addNewAxisEltForResponse, encoded="http://metacase.com/wsdl/")

class getWidthRequest:
    def __init__(self):
        self._receiver = None
        return
getWidthRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","getWidth"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=getWidthRequest, encoded="http://metacase.com/wsdl/")

class getWidthResponse:
    def __init__(self):
        self._result = None
        return
getWidthResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","getWidthResponse"), ofwhat=[ZSI.TCnumbers.Iint(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=getWidthResponse, encoded="http://metacase.com/wsdl/")

class setWidthRequest:
    def __init__(self):
        self._receiver = None
        self._setWidth = None
        return
setWidthRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","setWidth"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TCnumbers.Iint(pname="setWidth", aname="_setWidth", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setWidthRequest, encoded="http://metacase.com/wsdl/")

class setWidthResponse:
    def __init__(self):
        self._result = None
        return
setWidthResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","setWidthResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setWidthResponse, encoded="http://metacase.com/wsdl/")

class oTRequest:
    def __init__(self):
        self._receiver = None
        return
oTRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","oT"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=oTRequest, encoded="http://metacase.com/wsdl/")

class oTResponse:
    def __init__(self):
        self._result = None
        return
oTResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","oTResponse"), ofwhat=[ns0.METype_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=oTResponse, encoded="http://metacase.com/wsdl/")

class baseCollectionRequest:
    def __init__(self):
        self._receiver = None
        return
baseCollectionRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","baseCollection"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=baseCollectionRequest, encoded="http://metacase.com/wsdl/")

class baseCollectionResponse:
    def __init__(self):
        self._result = None
        return
baseCollectionResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","baseCollectionResponse"), ofwhat=[ns0.MEOopArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=baseCollectionResponse, encoded="http://metacase.com/wsdl/")

class fontRequest:
    def __init__(self):
        self._receiver = None
        return
fontRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","font"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=fontRequest, encoded="http://metacase.com/wsdl/")

class fontResponse:
    def __init__(self):
        self._result = None
        return
fontResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","fontResponse"), ofwhat=[ZSI.TC.String(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=fontResponse, encoded="http://metacase.com/wsdl/")

class setFontRequest:
    def __init__(self):
        self._receiver = None
        self._font = None
        return
setFontRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","setFont"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="font", aname="_font", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setFontRequest, encoded="http://metacase.com/wsdl/")

class setFontResponse:
    def __init__(self):
        self._result = None
        return
setFontResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","setFontResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setFontResponse, encoded="http://metacase.com/wsdl/")

class gxlWidthsRequest:
    def __init__(self):
        self._receiver = None
        return
gxlWidthsRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","gxlWidths"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=gxlWidthsRequest, encoded="http://metacase.com/wsdl/")

class gxlWidthsResponse:
    def __init__(self):
        self._result = None
        return
gxlWidthsResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","gxlWidthsResponse"), ofwhat=[ns0.MEAnyArray_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=gxlWidthsResponse, encoded="http://metacase.com/wsdl/")

class setGxlWidthsRequest:
    def __init__(self):
        self._receiver = None
        self._gxlWidths = None
        return
setGxlWidthsRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","setGxlWidths"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEAnyArray_Def(pname="gxlWidths", aname="_gxlWidths", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setGxlWidthsRequest, encoded="http://metacase.com/wsdl/")

class setGxlWidthsResponse:
    def __init__(self):
        self._result = None
        return
setGxlWidthsResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","setGxlWidthsResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setGxlWidthsResponse, encoded="http://metacase.com/wsdl/")

class addNewTableEltForRequest:
    def __init__(self):
        self._receiver = None
        self._addNewRepFor = None
        self._beforeIndex = None
        return
addNewTableEltForRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","addNewTableEltFor"), ofwhat=[ns0.MEOop_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ns0.MEOop_Def(pname="addNewRepFor", aname="_addNewRepFor", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TCnumbers.Iint(pname="beforeIndex", aname="_beforeIndex", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=addNewTableEltForRequest, encoded="http://metacase.com/wsdl/")

class addNewTableEltForResponse:
    def __init__(self):
        self._result = None
        return
addNewTableEltForResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","addNewTableEltForResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=addNewTableEltForResponse, encoded="http://metacase.com/wsdl/")

class currentDirRequest:
    def __init__(self):
        self._receiver = None
        self._currentDir = None
        return
currentDirRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","currentDir"), ofwhat=[ns0.MENull_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="currentDir", aname="_currentDir", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=currentDirRequest, encoded="http://metacase.com/wsdl/")

class currentDirResponse:
    def __init__(self):
        self._result = None
        return
currentDirResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","currentDirResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=currentDirResponse, encoded="http://metacase.com/wsdl/")

class fileInPatchRequest:
    def __init__(self):
        self._receiver = None
        self._fileInPatch = None
        return
fileInPatchRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","fileInPatch"), ofwhat=[ns0.MENull_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="fileInPatch", aname="_fileInPatch", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=fileInPatchRequest, encoded="http://metacase.com/wsdl/")

class fileInPatchResponse:
    def __init__(self):
        self._result = None
        return
fileInPatchResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","fileInPatchResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=fileInPatchResponse, encoded="http://metacase.com/wsdl/")

class fileInPatchesRequest:
    def __init__(self):
        self._receiver = None
        return
fileInPatchesRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","fileInPatches"), ofwhat=[ns0.MENull_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=fileInPatchesRequest, encoded="http://metacase.com/wsdl/")

class fileInPatchesResponse:
    def __init__(self):
        self._result = None
        return
fileInPatchesResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","fileInPatchesResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=fileInPatchesResponse, encoded="http://metacase.com/wsdl/")

class abandonRequest:
    def __init__(self):
        self._receiver = None
        return
abandonRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","abandon"), ofwhat=[ns0.MENull_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=abandonRequest, encoded="http://metacase.com/wsdl/")

class abandonResponse:
    def __init__(self):
        self._result = None
        return
abandonResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","abandonResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=abandonResponse, encoded="http://metacase.com/wsdl/")

class commitRequest:
    def __init__(self):
        self._receiver = None
        return
commitRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","commit"), ofwhat=[ns0.MENull_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=commitRequest, encoded="http://metacase.com/wsdl/")

class commitResponse:
    def __init__(self):
        self._result = None
        return
commitResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","commitResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=commitResponse, encoded="http://metacase.com/wsdl/")

class condenseDatabaseRequest:
    def __init__(self):
        self._receiver = None
        return
condenseDatabaseRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","condenseDatabase"), ofwhat=[ns0.MENull_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=condenseDatabaseRequest, encoded="http://metacase.com/wsdl/")

class condenseDatabaseResponse:
    def __init__(self):
        self._result = None
        return
condenseDatabaseResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","condenseDatabaseResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=condenseDatabaseResponse, encoded="http://metacase.com/wsdl/")

class createProjectRequest:
    def __init__(self):
        self._receiver = None
        self._createProject = None
        return
createProjectRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","createProject"), ofwhat=[ns0.MENull_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="createProject", aname="_createProject", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=createProjectRequest, encoded="http://metacase.com/wsdl/")

class createProjectResponse:
    def __init__(self):
        self._result = None
        return
createProjectResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","createProjectResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=createProjectResponse, encoded="http://metacase.com/wsdl/")

class documentRequest:
    def __init__(self):
        self._receiver = None
        self._document = None
        self._into = None
        return
documentRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","document"), ofwhat=[ns0.MENull_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="document", aname="_document", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="into", aname="_into", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=documentRequest, encoded="http://metacase.com/wsdl/")

class documentResponse:
    def __init__(self):
        self._result = None
        return
documentResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","documentResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=documentResponse, encoded="http://metacase.com/wsdl/")

class forAllRequest:
    def __init__(self):
        self._receiver = None
        self._forAll = None
        self._run = None
        return
forAllRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","forAll"), ofwhat=[ns0.MENull_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="forAll", aname="_forAll", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="run", aname="_run", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=forAllRequest, encoded="http://metacase.com/wsdl/")

class forAllResponse:
    def __init__(self):
        self._result = None
        return
forAllResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","forAllResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=forAllResponse, encoded="http://metacase.com/wsdl/")

class forNameRequest:
    def __init__(self):
        self._receiver = None
        self._forName = None
        self._type = None
        self._run = None
        return
forNameRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","forName"), ofwhat=[ns0.MENull_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="forName", aname="_forName", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="type", aname="_type", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="run", aname="_run", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=forNameRequest, encoded="http://metacase.com/wsdl/")

class forNameResponse:
    def __init__(self):
        self._result = None
        return
forNameResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","forNameResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=forNameResponse, encoded="http://metacase.com/wsdl/")

class loginRequest:
    def __init__(self):
        self._receiver = None
        return
loginRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","login"), ofwhat=[ns0.MENull_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=loginRequest, encoded="http://metacase.com/wsdl/")

class loginResponse:
    def __init__(self):
        self._result = None
        return
loginResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","loginResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=loginResponse, encoded="http://metacase.com/wsdl/")

class loginDBRequest:
    def __init__(self):
        self._receiver = None
        self._loginDB = None
        self._user = None
        self._password = None
        return
loginDBRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","loginDB"), ofwhat=[ns0.MENull_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="loginDB", aname="_loginDB", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="user", aname="_user", 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=loginDBRequest, encoded="http://metacase.com/wsdl/")

class loginDBResponse:
    def __init__(self):
        self._result = None
        return
loginDBResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","loginDBResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=loginDBResponse, encoded="http://metacase.com/wsdl/")

class loginNewDBRequest:
    def __init__(self):
        self._receiver = None
        self._loginNewDB = None
        self._dir = None
        self._user = None
        self._password = None
        return
loginNewDBRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","loginNewDB"), ofwhat=[ns0.MENull_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="loginNewDB", aname="_loginNewDB", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="dir", aname="_dir", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="user", aname="_user", 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=loginNewDBRequest, encoded="http://metacase.com/wsdl/")

class loginNewDBResponse:
    def __init__(self):
        self._result = None
        return
loginNewDBResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","loginNewDBResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=loginNewDBResponse, encoded="http://metacase.com/wsdl/")

class logoutAndExitRequest:
    def __init__(self):
        self._receiver = None
        return
logoutAndExitRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","logoutAndExit"), ofwhat=[ns0.MENull_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=logoutAndExitRequest, encoded="http://metacase.com/wsdl/")

class logoutAndExitResponse:
    def __init__(self):
        self._result = None
        return
logoutAndExitResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","logoutAndExitResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=logoutAndExitResponse, encoded="http://metacase.com/wsdl/")

class maintainDatabaseRequest:
    def __init__(self):
        self._receiver = None
        return
maintainDatabaseRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","maintainDatabase"), ofwhat=[ns0.MENull_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=maintainDatabaseRequest, encoded="http://metacase.com/wsdl/")

class maintainDatabaseResponse:
    def __init__(self):
        self._result = None
        return
maintainDatabaseResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","maintainDatabaseResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=maintainDatabaseResponse, encoded="http://metacase.com/wsdl/")

class openAllProjectsRequest:
    def __init__(self):
        self._receiver = None
        return
openAllProjectsRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","openAllProjects"), ofwhat=[ns0.MENull_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=openAllProjectsRequest, encoded="http://metacase.com/wsdl/")

class openAllProjectsResponse:
    def __init__(self):
        self._result = None
        return
openAllProjectsResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","openAllProjectsResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=openAllProjectsResponse, encoded="http://metacase.com/wsdl/")

class quitRequest:
    def __init__(self):
        self._receiver = None
        return
quitRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","quit"), ofwhat=[ns0.MENull_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=quitRequest, encoded="http://metacase.com/wsdl/")

class quitResponse:
    def __init__(self):
        self._result = None
        return
quitResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","quitResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=quitResponse, encoded="http://metacase.com/wsdl/")

class setProjectRequest:
    def __init__(self):
        self._receiver = None
        self._setProject = None
        return
setProjectRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","setProject"), ofwhat=[ns0.MENull_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="setProject", aname="_setProject", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setProjectRequest, encoded="http://metacase.com/wsdl/")

class setProjectResponse:
    def __init__(self):
        self._result = None
        return
setProjectResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","setProjectResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=setProjectResponse, encoded="http://metacase.com/wsdl/")

class startAPIRequest:
    def __init__(self):
        self._receiver = None
        return
startAPIRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","startAPI"), ofwhat=[ns0.MENull_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=startAPIRequest, encoded="http://metacase.com/wsdl/")

class startAPIResponse:
    def __init__(self):
        self._result = None
        return
startAPIResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","startAPIResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=startAPIResponse, encoded="http://metacase.com/wsdl/")

class startAPIHostnameRequest:
    def __init__(self):
        self._receiver = None
        self._startAPIHostname = None
        self._port = None
        self._logEvents = None
        return
startAPIHostnameRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","startAPIHostname"), ofwhat=[ns0.MENull_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="startAPIHostname", aname="_startAPIHostname", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="port", aname="_port", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True), ZSI.TC.String(pname="logEvents", aname="_logEvents", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=startAPIHostnameRequest, encoded="http://metacase.com/wsdl/")

class startAPIHostnameResponse:
    def __init__(self):
        self._result = None
        return
startAPIHostnameResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","startAPIHostnameResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=startAPIHostnameResponse, encoded="http://metacase.com/wsdl/")

class stopAPIRequest:
    def __init__(self):
        self._receiver = None
        return
stopAPIRequest.typecode = Struct(pname=("http://metacase.com/wsdl/","stopAPI"), ofwhat=[ns0.MENull_Def(pname="receiver", aname="_receiver", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=stopAPIRequest, encoded="http://metacase.com/wsdl/")

class stopAPIResponse:
    def __init__(self):
        self._result = None
        return
stopAPIResponse.typecode = Struct(pname=("http://metacase.com/wsdl/","stopAPIResponse"), ofwhat=[ns0.MENull_Def(pname="result", aname="_result", typed=False, encoded=None, minOccurs=1, maxOccurs=1, nillable=True)], pyclass=stopAPIResponse, encoded="http://metacase.com/wsdl/")
