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


import ZSI
import ZSI.TCcompound
from ZSI.TC import ElementDeclaration,TypeDefinition
from ZSI.generate.pyclass import pyclass_type

##############################
# targetNamespace
# http://s.mappoint.net/mappoint-30/
##############################

class ns2:
    targetNamespace = "http://s.mappoint.net/mappoint-30/"

    class ArrayOfVersionInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ArrayOfVersionInfo")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.ArrayOfVersionInfo_Def.schema
            TClist = [ns2.VersionInfo_Def(pname=(ns,"VersionInfo"), aname="_VersionInfo", minOccurs=0, maxOccurs="unbounded", nillable=True, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._VersionInfo = []
                    return
            Holder.__name__ = "ArrayOfVersionInfo_Holder"
            self.pyclass = Holder

    class VersionInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "VersionInfo")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.VersionInfo_Def.schema
            TClist = [ZSI.TC.String(pname=(ns,"Component"), aname="_Component", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"Version"), aname="_Version", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Component = None
                    self._Version = None
                    return
            Holder.__name__ = "VersionInfo_Holder"
            self.pyclass = Holder

    class CustomerInfoHeader_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "CustomerInfoHeader")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.CustomerInfoHeader_Def.schema
            TClist = [ZSI.TCnumbers.Ishort(pname=(ns,"CustomLogEntry"), aname="_CustomLogEntry", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._CustomLogEntry = None
                    return
            Holder.__name__ = "CustomerInfoHeader_Holder"
            self.pyclass = Holder

    class UserInfoHeader_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "UserInfoHeader")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.UserInfoHeader_Def.schema
            TClist = [ns2.CultureInfo_Def(pname=(ns,"Culture"), aname="_Culture", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.DistanceUnit_Def(pname=(ns,"DefaultDistanceUnit"), aname="_DefaultDistanceUnit", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.CountryRegionContext_Def(pname=(ns,"Context"), aname="_Context", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Culture = None
                    self._DefaultDistanceUnit = None
                    self._Context = None
                    return
            Holder.__name__ = "UserInfoHeader_Holder"
            self.pyclass = Holder

    class CultureInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "CultureInfo")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.CultureInfo_Def.schema
            TClist = [ZSI.TC.String(pname=(ns,"Name"), aname="_Name", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"Lcid"), aname="_Lcid", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Name = None
                    self._Lcid = None
                    return
            Holder.__name__ = "CultureInfo_Holder"
            self.pyclass = Holder

    class DistanceUnit_Def(ZSI.TC.String, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "DistanceUnit")
        def __init__(self, pname, **kw):
            ZSI.TC.String.__init__(self, pname, pyclass=None, **kw)
            class Holder(str):
                typecode = self
            self.pyclass = Holder

    class CountryRegionContext_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "CountryRegionContext")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.CountryRegionContext_Def.schema
            TClist = [ZSI.TCnumbers.Iint(pname=(ns,"EntityID"), aname="_EntityID", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"Iso2"), aname="_Iso2", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._EntityID = None
                    self._Iso2 = None
                    return
            Holder.__name__ = "CountryRegionContext_Holder"
            self.pyclass = Holder

    class ArrayOfInt_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ArrayOfInt")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.ArrayOfInt_Def.schema
            TClist = [ZSI.TCnumbers.Iint(pname=(ns,"int"), aname="_int", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._int = []
                    return
            Holder.__name__ = "ArrayOfInt_Holder"
            self.pyclass = Holder

    class ArrayOfCountryRegionInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ArrayOfCountryRegionInfo")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.ArrayOfCountryRegionInfo_Def.schema
            TClist = [ns2.CountryRegionInfo_Def(pname=(ns,"CountryRegionInfo"), aname="_CountryRegionInfo", minOccurs=0, maxOccurs="unbounded", nillable=True, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._CountryRegionInfo = []
                    return
            Holder.__name__ = "ArrayOfCountryRegionInfo_Holder"
            self.pyclass = Holder

    class CountryRegionInfo_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "CountryRegionInfo")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.CountryRegionInfo_Def.schema
            TClist = [ZSI.TCnumbers.Iint(pname=(ns,"EntityID"), aname="_EntityID", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.LatLong_Def(pname=(ns,"LatLong"), aname="_LatLong", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"Iso2"), aname="_Iso2", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"Iso3"), aname="_Iso3", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"FriendlyName"), aname="_FriendlyName", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"OfficialName"), aname="_OfficialName", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._EntityID = None
                    self._LatLong = None
                    self._Iso2 = None
                    self._Iso3 = None
                    self._FriendlyName = None
                    self._OfficialName = None
                    return
            Holder.__name__ = "CountryRegionInfo_Holder"
            self.pyclass = Holder

    class LatLong_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "LatLong")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.LatLong_Def.schema
            TClist = [ZSI.TCnumbers.FPdouble(pname=(ns,"Latitude"), aname="_Latitude", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPdouble(pname=(ns,"Longitude"), aname="_Longitude", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Latitude = None
                    self._Longitude = None
                    return
            Holder.__name__ = "LatLong_Holder"
            self.pyclass = Holder

    class ArrayOfEntityType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ArrayOfEntityType")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.ArrayOfEntityType_Def.schema
            TClist = [ns2.EntityType_Def(pname=(ns,"EntityType"), aname="_EntityType", minOccurs=0, maxOccurs="unbounded", nillable=True, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._EntityType = []
                    return
            Holder.__name__ = "ArrayOfEntityType_Holder"
            self.pyclass = Holder

    class EntityType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "EntityType")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.EntityType_Def.schema
            TClist = [ZSI.TC.String(pname=(ns,"Name"), aname="_Name", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"DisplayName"), aname="_DisplayName", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ParentName"), aname="_ParentName", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"Definition"), aname="_Definition", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.ArrayOfEntityProperty_Def(pname=(ns,"Properties"), aname="_Properties", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Name = None
                    self._DisplayName = None
                    self._ParentName = None
                    self._Definition = None
                    self._Properties = None
                    return
            Holder.__name__ = "EntityType_Holder"
            self.pyclass = Holder

    class ArrayOfEntityProperty_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ArrayOfEntityProperty")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.ArrayOfEntityProperty_Def.schema
            TClist = [ns2.EntityProperty_Def(pname=(ns,"Property"), aname="_Property", minOccurs=0, maxOccurs="unbounded", nillable=True, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Property = []
                    return
            Holder.__name__ = "ArrayOfEntityProperty_Holder"
            self.pyclass = Holder

    class EntityProperty_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "EntityProperty")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.EntityProperty_Def.schema
            TClist = [ZSI.TC.String(pname=(ns,"Name"), aname="_Name", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"DisplayName"), aname="_DisplayName", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"DataType"), aname="_DataType", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Name = None
                    self._DisplayName = None
                    self._DataType = None
                    return
            Holder.__name__ = "EntityProperty_Holder"
            self.pyclass = Holder

    class ArrayOfString_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ArrayOfString")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.ArrayOfString_Def.schema
            TClist = [ZSI.TC.String(pname=(ns,"string"), aname="_string", minOccurs=0, maxOccurs="unbounded", nillable=True, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._string = []
                    return
            Holder.__name__ = "ArrayOfString_Holder"
            self.pyclass = Holder

    class ArrayOfDataSource_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ArrayOfDataSource")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.ArrayOfDataSource_Def.schema
            TClist = [ns2.DataSource_Def(pname=(ns,"DataSource"), aname="_DataSource", minOccurs=0, maxOccurs="unbounded", nillable=True, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._DataSource = []
                    return
            Holder.__name__ = "ArrayOfDataSource_Holder"
            self.pyclass = Holder

    class DataSource_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "DataSource")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.DataSource_Def.schema
            TClist = [ZSI.TC.String(pname=(ns,"Name"), aname="_Name", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"Version"), aname="_Version", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"Description"), aname="_Description", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.DataSourceCapability_Def(pname=(ns,"Capability"), aname="_Capability", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.ArrayOfInt_Def(pname=(ns,"EntityExtent"), aname="_EntityExtent", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Name = None
                    self._Version = None
                    self._Description = None
                    self._Capability = None
                    self._EntityExtent = None
                    return
            Holder.__name__ = "DataSource_Holder"
            self.pyclass = Holder

    class DataSourceCapability_Def(ZSI.TC.List, TypeDefinition):
        itemType = None
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "DataSourceCapability")
        def __init__(self, pname, **kw):
            ZSI.TC.List.__init__(self, pname, **kw)

    class ArrayOfLatLong_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ArrayOfLatLong")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.ArrayOfLatLong_Def.schema
            TClist = [ns2.LatLong_Def(pname=(ns,"LatLong"), aname="_LatLong", minOccurs=0, maxOccurs="unbounded", nillable=True, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._LatLong = []
                    return
            Holder.__name__ = "ArrayOfLatLong_Holder"
            self.pyclass = Holder

    class ArrayOfDouble_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ArrayOfDouble")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.ArrayOfDouble_Def.schema
            TClist = [ZSI.TCnumbers.FPdouble(pname=(ns,"double"), aname="_double", minOccurs=0, maxOccurs="unbounded", nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._double = []
                    return
            Holder.__name__ = "ArrayOfDouble_Holder"
            self.pyclass = Holder

    class FindSpecification_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "FindSpecification")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.FindSpecification_Def.schema
            TClist = [ZSI.TC.String(pname=(ns,"DataSourceName"), aname="_DataSourceName", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"InputPlace"), aname="_InputPlace", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.ArrayOfString_Def(pname=(ns,"EntityTypeNames"), aname="_EntityTypeNames", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.FindOptions_Def(pname=(ns,"Options"), aname="_Options", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._DataSourceName = None
                    self._InputPlace = None
                    self._EntityTypeNames = None
                    self._Options = None
                    return
            Holder.__name__ = "FindSpecification_Holder"
            self.pyclass = Holder

    class FindOptions_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "FindOptions")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.FindOptions_Def.schema
            TClist = [ns2.FindRange_Def(pname=(ns,"Range"), aname="_Range", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"SearchContext"), aname="_SearchContext", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.FindResultMask_Def(pname=(ns,"ResultMask"), aname="_ResultMask", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPdouble(pname=(ns,"ThresholdScore"), aname="_ThresholdScore", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Range = None
                    self._SearchContext = None
                    self._ResultMask = None
                    self._ThresholdScore = None
                    return
            Holder.__name__ = "FindOptions_Holder"
            self.pyclass = Holder

    class FindRange_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "FindRange")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.FindRange_Def.schema
            TClist = [ZSI.TCnumbers.Iint(pname=(ns,"StartIndex"), aname="_StartIndex", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"Count"), aname="_Count", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._StartIndex = None
                    self._Count = None
                    return
            Holder.__name__ = "FindRange_Holder"
            self.pyclass = Holder

    class FindResultMask_Def(ZSI.TC.List, TypeDefinition):
        itemType = None
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "FindResultMask")
        def __init__(self, pname, **kw):
            ZSI.TC.List.__init__(self, pname, **kw)

    class FindResults_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "FindResults")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.FindResults_Def.schema
            TClist = [ZSI.TCnumbers.Iint(pname=(ns,"NumberFound"), aname="_NumberFound", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"StartIndex"), aname="_StartIndex", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.ArrayOfFindResult_Def(pname=(ns,"Results"), aname="_Results", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPdouble(pname=(ns,"TopScore"), aname="_TopScore", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._NumberFound = None
                    self._StartIndex = None
                    self._Results = None
                    self._TopScore = None
                    return
            Holder.__name__ = "FindResults_Holder"
            self.pyclass = Holder

    class ArrayOfFindResult_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ArrayOfFindResult")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.ArrayOfFindResult_Def.schema
            TClist = [ns2.FindResult_Def(pname=(ns,"FindResult"), aname="_FindResult", minOccurs=0, maxOccurs="unbounded", nillable=True, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._FindResult = []
                    return
            Holder.__name__ = "ArrayOfFindResult_Holder"
            self.pyclass = Holder

    class FindResult_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "FindResult")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.FindResult_Def.schema
            TClist = [ZSI.TCnumbers.FPdouble(pname=(ns,"Score"), aname="_Score", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.Location_Def(pname=(ns,"FoundLocation"), aname="_FoundLocation", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Score = None
                    self._FoundLocation = None
                    return
            Holder.__name__ = "FindResult_Holder"
            self.pyclass = Holder

    class Location_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "Location")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.Location_Def.schema
            TClist = [ns2.LatLong_Def(pname=(ns,"LatLong"), aname="_LatLong", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.Entity_Def(pname=(ns,"Entity"), aname="_Entity", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.Address_Def(pname=(ns,"Address"), aname="_Address", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.MapViewRepresentations_Def(pname=(ns,"BestMapView"), aname="_BestMapView", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"DataSourceName"), aname="_DataSourceName", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._LatLong = None
                    self._Entity = None
                    self._Address = None
                    self._BestMapView = None
                    self._DataSourceName = None
                    return
            Holder.__name__ = "Location_Holder"
            self.pyclass = Holder

    class Entity_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "Entity")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.Entity_Def.schema
            TClist = [ZSI.TCnumbers.Iint(pname=(ns,"ID"), aname="_ID", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"Name"), aname="_Name", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"DisplayName"), aname="_DisplayName", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"TypeName"), aname="_TypeName", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.ArrayOfEntityPropertyValue_Def(pname=(ns,"Properties"), aname="_Properties", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._ID = None
                    self._Name = None
                    self._DisplayName = None
                    self._TypeName = None
                    self._Properties = None
                    return
            Holder.__name__ = "Entity_Holder"
            self.pyclass = Holder

    class ArrayOfEntityPropertyValue_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ArrayOfEntityPropertyValue")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.ArrayOfEntityPropertyValue_Def.schema
            TClist = [ns2.EntityPropertyValue_Def(pname=(ns,"Property"), aname="_Property", minOccurs=0, maxOccurs="unbounded", nillable=True, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Property = []
                    return
            Holder.__name__ = "ArrayOfEntityPropertyValue_Holder"
            self.pyclass = Holder

    class EntityPropertyValue_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "EntityPropertyValue")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.EntityPropertyValue_Def.schema
            TClist = [ZSI.TC.String(pname=(ns,"Name"), aname="_Name", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.AnyType(pname=(ns,"Value"), aname="_Value", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Name = None
                    self._Value = None
                    return
            Holder.__name__ = "EntityPropertyValue_Holder"
            self.pyclass = Holder

    class Address_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "Address")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.Address_Def.schema
            TClist = [ZSI.TC.String(pname=(ns,"AddressLine"), aname="_AddressLine", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"PrimaryCity"), aname="_PrimaryCity", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"SecondaryCity"), aname="_SecondaryCity", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"Subdivision"), aname="_Subdivision", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"PostalCode"), aname="_PostalCode", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"CountryRegion"), aname="_CountryRegion", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"FormattedAddress"), aname="_FormattedAddress", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._AddressLine = None
                    self._PrimaryCity = None
                    self._SecondaryCity = None
                    self._Subdivision = None
                    self._PostalCode = None
                    self._CountryRegion = None
                    self._FormattedAddress = None
                    return
            Holder.__name__ = "Address_Holder"
            self.pyclass = Holder

    class MapViewRepresentations_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "MapViewRepresentations")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.MapViewRepresentations_Def.schema
            TClist = [ns2.ViewByScale_Def(pname=(ns,"ByScale"), aname="_ByScale", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.ViewByHeightWidth_Def(pname=(ns,"ByHeightWidth"), aname="_ByHeightWidth", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.ViewByBoundingRectangle_Def(pname=(ns,"ByBoundingRectangle"), aname="_ByBoundingRectangle", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._ByScale = None
                    self._ByHeightWidth = None
                    self._ByBoundingRectangle = None
                    return
            Holder.__name__ = "MapViewRepresentations_Holder"
            self.pyclass = Holder

    class ViewByScale_Def(TypeDefinition):
        #complexType/complexContent extension
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ViewByScale")
        def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw):
            ns = ns2.ViewByScale_Def.schema
            TClist = [ZSI.TCnumbers.FPdouble(pname=(ns,"MapScale"), aname="_MapScale", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.LatLong_Def(pname=(ns,"CenterPoint"), aname="_CenterPoint", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if ns2.MapView_Def not in ns2.ViewByScale_Def.__bases__:
                bases = list(ns2.ViewByScale_Def.__bases__)
                bases.insert(0, ns2.MapView_Def)
                ns2.ViewByScale_Def.__bases__ = tuple(bases)

            ns2.MapView_Def.__init__(self, pname, ofwhat=TClist, extend=True, **kw)

    class MapView_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "MapView")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.MapView_Def.schema
            TClist = []
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    return
            Holder.__name__ = "MapView_Holder"
            self.pyclass = Holder

    class ViewByBoundingLocations_Def(TypeDefinition):
        #complexType/complexContent extension
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ViewByBoundingLocations")
        def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw):
            ns = ns2.ViewByBoundingLocations_Def.schema
            TClist = [ns2.ArrayOfLocation_Def(pname=(ns,"Locations"), aname="_Locations", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if ns2.MapView_Def not in ns2.ViewByBoundingLocations_Def.__bases__:
                bases = list(ns2.ViewByBoundingLocations_Def.__bases__)
                bases.insert(0, ns2.MapView_Def)
                ns2.ViewByBoundingLocations_Def.__bases__ = tuple(bases)

            ns2.MapView_Def.__init__(self, pname, ofwhat=TClist, extend=True, **kw)

    class ArrayOfLocation_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ArrayOfLocation")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.ArrayOfLocation_Def.schema
            TClist = [ns2.Location_Def(pname=(ns,"Location"), aname="_Location", minOccurs=0, maxOccurs="unbounded", nillable=True, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Location = []
                    return
            Holder.__name__ = "ArrayOfLocation_Holder"
            self.pyclass = Holder

    class ViewByHeightWidth_Def(TypeDefinition):
        #complexType/complexContent extension
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ViewByHeightWidth")
        def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw):
            ns = ns2.ViewByHeightWidth_Def.schema
            TClist = [ZSI.TCnumbers.FPdouble(pname=(ns,"Height"), aname="_Height", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPdouble(pname=(ns,"Width"), aname="_Width", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.LatLong_Def(pname=(ns,"CenterPoint"), aname="_CenterPoint", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if ns2.MapView_Def not in ns2.ViewByHeightWidth_Def.__bases__:
                bases = list(ns2.ViewByHeightWidth_Def.__bases__)
                bases.insert(0, ns2.MapView_Def)
                ns2.ViewByHeightWidth_Def.__bases__ = tuple(bases)

            ns2.MapView_Def.__init__(self, pname, ofwhat=TClist, extend=True, **kw)

    class ViewByBoundingRectangle_Def(TypeDefinition):
        #complexType/complexContent extension
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ViewByBoundingRectangle")
        def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw):
            ns = ns2.ViewByBoundingRectangle_Def.schema
            TClist = [ns2.LatLongRectangle_Def(pname=(ns,"BoundingRectangle"), aname="_BoundingRectangle", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if ns2.MapView_Def not in ns2.ViewByBoundingRectangle_Def.__bases__:
                bases = list(ns2.ViewByBoundingRectangle_Def.__bases__)
                bases.insert(0, ns2.MapView_Def)
                ns2.ViewByBoundingRectangle_Def.__bases__ = tuple(bases)

            ns2.MapView_Def.__init__(self, pname, ofwhat=TClist, extend=True, **kw)

    class LatLongRectangle_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "LatLongRectangle")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.LatLongRectangle_Def.schema
            TClist = [ns2.LatLong_Def(pname=(ns,"Southwest"), aname="_Southwest", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.LatLong_Def(pname=(ns,"Northeast"), aname="_Northeast", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Southwest = None
                    self._Northeast = None
                    return
            Holder.__name__ = "LatLongRectangle_Holder"
            self.pyclass = Holder

    class MapPointConstants_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "MapPointConstants")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.MapPointConstants_Def.schema
            TClist = [ZSI.TCnumbers.FPdouble(pname=(ns,"EarthRadiusInKilometers"), aname="_EarthRadiusInKilometers", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPdouble(pname=(ns,"Pi"), aname="_Pi", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPdouble(pname=(ns,"RadiansPerDegree"), aname="_RadiansPerDegree", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPdouble(pname=(ns,"DegreesPerRadian"), aname="_DegreesPerRadian", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPdouble(pname=(ns,"MilesPerKilometer"), aname="_MilesPerKilometer", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPdouble(pname=(ns,"KilometersPerMile"), aname="_KilometersPerMile", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPdouble(pname=(ns,"KilometersPerFoot"), aname="_KilometersPerFoot", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPdouble(pname=(ns,"FeetPerKilometer"), aname="_FeetPerKilometer", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPdouble(pname=(ns,"FindScoreThreshold"), aname="_FindScoreThreshold", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"AssumedDpi"), aname="_AssumedDpi", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPdouble(pname=(ns,"FeetPerMeter"), aname="_FeetPerMeter", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPdouble(pname=(ns,"MetersPerFoot"), aname="_MetersPerFoot", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._EarthRadiusInKilometers = None
                    self._Pi = None
                    self._RadiansPerDegree = None
                    self._DegreesPerRadian = None
                    self._MilesPerKilometer = None
                    self._KilometersPerMile = None
                    self._KilometersPerFoot = None
                    self._FeetPerKilometer = None
                    self._FindScoreThreshold = None
                    self._AssumedDpi = None
                    self._FeetPerMeter = None
                    self._MetersPerFoot = None
                    return
            Holder.__name__ = "MapPointConstants_Holder"
            self.pyclass = Holder

    class SpatialFilter_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "SpatialFilter")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.SpatialFilter_Def.schema
            TClist = []
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    return
            Holder.__name__ = "SpatialFilter_Holder"
            self.pyclass = Holder

    class LatLongSpatialFilter_Def(TypeDefinition):
        #complexType/complexContent extension
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "LatLongSpatialFilter")
        def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw):
            ns = ns2.LatLongSpatialFilter_Def.schema
            TClist = [ns2.LatLong_Def(pname=(ns,"LatLong"), aname="_LatLong", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if ns2.SpatialFilter_Def not in ns2.LatLongSpatialFilter_Def.__bases__:
                bases = list(ns2.LatLongSpatialFilter_Def.__bases__)
                bases.insert(0, ns2.SpatialFilter_Def)
                ns2.LatLongSpatialFilter_Def.__bases__ = tuple(bases)

            ns2.SpatialFilter_Def.__init__(self, pname, ofwhat=TClist, extend=True, **kw)

    class LatLongRectangleSpatialFilter_Def(TypeDefinition):
        #complexType/complexContent extension
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "LatLongRectangleSpatialFilter")
        def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw):
            ns = ns2.LatLongRectangleSpatialFilter_Def.schema
            TClist = [ns2.LatLongRectangle_Def(pname=(ns,"BoundingRectangle"), aname="_BoundingRectangle", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.SpatialRelation_Def(pname=(ns,"PolygonRectangleRelation"), aname="_PolygonRectangleRelation", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if ns2.SpatialFilter_Def not in ns2.LatLongRectangleSpatialFilter_Def.__bases__:
                bases = list(ns2.LatLongRectangleSpatialFilter_Def.__bases__)
                bases.insert(0, ns2.SpatialFilter_Def)
                ns2.LatLongRectangleSpatialFilter_Def.__bases__ = tuple(bases)

            ns2.SpatialFilter_Def.__init__(self, pname, ofwhat=TClist, extend=True, **kw)

    class SpatialRelation_Def(ZSI.TC.String, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "SpatialRelation")
        def __init__(self, pname, **kw):
            ZSI.TC.String.__init__(self, pname, pyclass=None, **kw)
            class Holder(str):
                typecode = self
            self.pyclass = Holder

    class CustomerInfoFindHeader_Def(TypeDefinition):
        #complexType/complexContent extension
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "CustomerInfoFindHeader")
        def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw):
            ns = ns2.CustomerInfoFindHeader_Def.schema
            TClist = []
            self.attribute_typecode_dict = attributes or {}
            if ns2.CustomerInfoHeader_Def not in ns2.CustomerInfoFindHeader_Def.__bases__:
                bases = list(ns2.CustomerInfoFindHeader_Def.__bases__)
                bases.insert(0, ns2.CustomerInfoHeader_Def)
                ns2.CustomerInfoFindHeader_Def.__bases__ = tuple(bases)

            ns2.CustomerInfoHeader_Def.__init__(self, pname, ofwhat=TClist, extend=True, **kw)

    class UserInfoFindHeader_Def(TypeDefinition):
        #complexType/complexContent extension
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "UserInfoFindHeader")
        def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw):
            ns = ns2.UserInfoFindHeader_Def.schema
            TClist = []
            self.attribute_typecode_dict = attributes or {}
            if ns2.UserInfoHeader_Def not in ns2.UserInfoFindHeader_Def.__bases__:
                bases = list(ns2.UserInfoFindHeader_Def.__bases__)
                bases.insert(0, ns2.UserInfoHeader_Def)
                ns2.UserInfoFindHeader_Def.__bases__ = tuple(bases)

            ns2.UserInfoHeader_Def.__init__(self, pname, ofwhat=TClist, extend=True, **kw)

    class FindAddressSpecification_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "FindAddressSpecification")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.FindAddressSpecification_Def.schema
            TClist = [ZSI.TC.String(pname=(ns,"DataSourceName"), aname="_DataSourceName", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.Address_Def(pname=(ns,"InputAddress"), aname="_InputAddress", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.FindOptions_Def(pname=(ns,"Options"), aname="_Options", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._DataSourceName = None
                    self._InputAddress = None
                    self._Options = None
                    return
            Holder.__name__ = "FindAddressSpecification_Holder"
            self.pyclass = Holder

    class GetInfoOptions_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "GetInfoOptions")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.GetInfoOptions_Def.schema
            TClist = [ZSI.TC.Boolean(pname=(ns,"IncludeAddresses"), aname="_IncludeAddresses", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"IncludeAllEntityTypes"), aname="_IncludeAllEntityTypes", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.ArrayOfString_Def(pname=(ns,"EntityTypesToReturn"), aname="_EntityTypesToReturn", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._IncludeAddresses = None
                    self._IncludeAllEntityTypes = None
                    self._EntityTypesToReturn = None
                    return
            Holder.__name__ = "GetInfoOptions_Holder"
            self.pyclass = Holder

    class FindNearbySpecification_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "FindNearbySpecification")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.FindNearbySpecification_Def.schema
            TClist = [ZSI.TC.String(pname=(ns,"DataSourceName"), aname="_DataSourceName", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.LatLong_Def(pname=(ns,"LatLong"), aname="_LatLong", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPdouble(pname=(ns,"Distance"), aname="_Distance", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.FindFilter_Def(pname=(ns,"Filter"), aname="_Filter", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.FindOptions_Def(pname=(ns,"Options"), aname="_Options", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._DataSourceName = None
                    self._LatLong = None
                    self._Distance = None
                    self._Filter = None
                    self._Options = None
                    return
            Holder.__name__ = "FindNearbySpecification_Holder"
            self.pyclass = Holder

    class FindFilter_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "FindFilter")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.FindFilter_Def.schema
            TClist = [ZSI.TC.String(pname=(ns,"EntityTypeName"), aname="_EntityTypeName", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.ArrayOfString_Def(pname=(ns,"PropertyNames"), aname="_PropertyNames", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.WhereClause_Def(pname=(ns,"WhereClause"), aname="_WhereClause", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.ArrayOfSortProperty_Def(pname=(ns,"SortProperties"), aname="_SortProperties", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.FilterExpression_Def(pname=(ns,"Expression"), aname="_Expression", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._EntityTypeName = None
                    self._PropertyNames = None
                    self._WhereClause = None
                    self._SortProperties = None
                    self._Expression = None
                    return
            Holder.__name__ = "FindFilter_Holder"
            self.pyclass = Holder

    class WhereClause_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "WhereClause")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.WhereClause_Def.schema
            TClist = [ns2.ArrayOfEntityPropertyValue_Def(pname=(ns,"SearchProperties"), aname="_SearchProperties", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.SearchOperatorFlag_Def(pname=(ns,"SearchOperator"), aname="_SearchOperator", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._SearchProperties = None
                    self._SearchOperator = None
                    return
            Holder.__name__ = "WhereClause_Holder"
            self.pyclass = Holder

    class SearchOperatorFlag_Def(ZSI.TC.String, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "SearchOperatorFlag")
        def __init__(self, pname, **kw):
            ZSI.TC.String.__init__(self, pname, pyclass=None, **kw)
            class Holder(str):
                typecode = self
            self.pyclass = Holder

    class ArrayOfSortProperty_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ArrayOfSortProperty")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.ArrayOfSortProperty_Def.schema
            TClist = [ns2.SortProperty_Def(pname=(ns,"SortProperty"), aname="_SortProperty", minOccurs=0, maxOccurs="unbounded", nillable=True, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._SortProperty = []
                    return
            Holder.__name__ = "ArrayOfSortProperty_Holder"
            self.pyclass = Holder

    class SortProperty_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "SortProperty")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.SortProperty_Def.schema
            TClist = [ZSI.TC.String(pname=(ns,"PropertyName"), aname="_PropertyName", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.SortDirection_Def(pname=(ns,"Direction"), aname="_Direction", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._PropertyName = None
                    self._Direction = None
                    return
            Holder.__name__ = "SortProperty_Holder"
            self.pyclass = Holder

    class SortDirection_Def(ZSI.TC.String, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "SortDirection")
        def __init__(self, pname, **kw):
            ZSI.TC.String.__init__(self, pname, pyclass=None, **kw)
            class Holder(str):
                typecode = self
            self.pyclass = Holder

    class FilterExpression_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "FilterExpression")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.FilterExpression_Def.schema
            TClist = [ZSI.TC.String(pname=(ns,"Text"), aname="_Text", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.ArrayOfAnyType_Def(pname=(ns,"Parameters"), aname="_Parameters", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Text = None
                    self._Parameters = None
                    return
            Holder.__name__ = "FilterExpression_Holder"
            self.pyclass = Holder

    class ArrayOfAnyType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ArrayOfAnyType")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.ArrayOfAnyType_Def.schema
            TClist = [ZSI.TC.AnyType(pname=(ns,"anyType"), aname="_anyType", minOccurs=0, maxOccurs="unbounded", nillable=True, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._anyType = []
                    return
            Holder.__name__ = "ArrayOfAnyType_Holder"
            self.pyclass = Holder

    class FindByPropertySpecification_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "FindByPropertySpecification")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.FindByPropertySpecification_Def.schema
            TClist = [ZSI.TC.String(pname=(ns,"DataSourceName"), aname="_DataSourceName", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.FindFilter_Def(pname=(ns,"Filter"), aname="_Filter", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.FindOptions_Def(pname=(ns,"Options"), aname="_Options", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._DataSourceName = None
                    self._Filter = None
                    self._Options = None
                    return
            Holder.__name__ = "FindByPropertySpecification_Holder"
            self.pyclass = Holder

    class FindByIDSpecification_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "FindByIDSpecification")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.FindByIDSpecification_Def.schema
            TClist = [ZSI.TC.String(pname=(ns,"DataSourceName"), aname="_DataSourceName", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.FindFilter_Def(pname=(ns,"Filter"), aname="_Filter", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.FindOptions_Def(pname=(ns,"Options"), aname="_Options", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.ArrayOfInt_Def(pname=(ns,"EntityIDs"), aname="_EntityIDs", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._DataSourceName = None
                    self._Filter = None
                    self._Options = None
                    self._EntityIDs = None
                    return
            Holder.__name__ = "FindByIDSpecification_Holder"
            self.pyclass = Holder

    class FindNearRouteSpecification_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "FindNearRouteSpecification")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.FindNearRouteSpecification_Def.schema
            TClist = [ZSI.TC.String(pname=(ns,"DataSourceName"), aname="_DataSourceName", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPdouble(pname=(ns,"Distance"), aname="_Distance", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.FindFilter_Def(pname=(ns,"Filter"), aname="_Filter", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.FindOptions_Def(pname=(ns,"Options"), aname="_Options", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.Route_Def(pname=(ns,"Route"), aname="_Route", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._DataSourceName = None
                    self._Distance = None
                    self._Filter = None
                    self._Options = None
                    self._Route = None
                    return
            Holder.__name__ = "FindNearRouteSpecification_Holder"
            self.pyclass = Holder

    class Route_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "Route")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.Route_Def.schema
            TClist = [ns2.RouteSpecification_Def(pname=(ns,"Specification"), aname="_Specification", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.RouteItinerary_Def(pname=(ns,"Itinerary"), aname="_Itinerary", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.CalculatedRouteRepresentation_Def(pname=(ns,"CalculatedRepresentation"), aname="_CalculatedRepresentation", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Specification = None
                    self._Itinerary = None
                    self._CalculatedRepresentation = None
                    return
            Holder.__name__ = "Route_Holder"
            self.pyclass = Holder

    class RouteSpecification_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "RouteSpecification")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.RouteSpecification_Def.schema
            TClist = [ns2.ArrayOfSegmentSpecification_Def(pname=(ns,"Segments"), aname="_Segments", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.RouteResultMask_Def(pname=(ns,"ResultMask"), aname="_ResultMask", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"DataSourceName"), aname="_DataSourceName", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.DriverProfile_Def(pname=(ns,"DriverProfile"), aname="_DriverProfile", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Segments = None
                    self._ResultMask = None
                    self._DataSourceName = None
                    self._DriverProfile = None
                    return
            Holder.__name__ = "RouteSpecification_Holder"
            self.pyclass = Holder

    class ArrayOfSegmentSpecification_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ArrayOfSegmentSpecification")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.ArrayOfSegmentSpecification_Def.schema
            TClist = [ns2.SegmentSpecification_Def(pname=(ns,"SegmentSpecification"), aname="_SegmentSpecification", minOccurs=0, maxOccurs="unbounded", nillable=True, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._SegmentSpecification = []
                    return
            Holder.__name__ = "ArrayOfSegmentSpecification_Holder"
            self.pyclass = Holder

    class SegmentSpecification_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "SegmentSpecification")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.SegmentSpecification_Def.schema
            TClist = [ns2.Waypoint_Def(pname=(ns,"Waypoint"), aname="_Waypoint", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.SegmentOptions_Def(pname=(ns,"Options"), aname="_Options", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Waypoint = None
                    self._Options = None
                    return
            Holder.__name__ = "SegmentSpecification_Holder"
            self.pyclass = Holder

    class Waypoint_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "Waypoint")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.Waypoint_Def.schema
            TClist = [ns2.Location_Def(pname=(ns,"Location"), aname="_Location", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.SnapType_Def(pname=(ns,"Snap"), aname="_Snap", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"Name"), aname="_Name", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.Location_Def(pname=(ns,"CalculatedLocation"), aname="_CalculatedLocation", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Location = None
                    self._Snap = None
                    self._Name = None
                    self._CalculatedLocation = None
                    return
            Holder.__name__ = "Waypoint_Holder"
            self.pyclass = Holder

    class SnapType_Def(ZSI.TC.String, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "SnapType")
        def __init__(self, pname, **kw):
            ZSI.TC.String.__init__(self, pname, pyclass=None, **kw)
            class Holder(str):
                typecode = self
            self.pyclass = Holder

    class SegmentOptions_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "SegmentOptions")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.SegmentOptions_Def.schema
            TClist = [ns2.SegmentPreference_Def(pname=(ns,"Preference"), aname="_Preference", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"CalculateSegmentMapView"), aname="_CalculateSegmentMapView", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"CalculateDirectionMapView"), aname="_CalculateDirectionMapView", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Preference = None
                    self._CalculateSegmentMapView = None
                    self._CalculateDirectionMapView = None
                    return
            Holder.__name__ = "SegmentOptions_Holder"
            self.pyclass = Holder

    class SegmentPreference_Def(ZSI.TC.String, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "SegmentPreference")
        def __init__(self, pname, **kw):
            ZSI.TC.String.__init__(self, pname, pyclass=None, **kw)
            class Holder(str):
                typecode = self
            self.pyclass = Holder

    class RouteResultMask_Def(ZSI.TC.List, TypeDefinition):
        itemType = None
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "RouteResultMask")
        def __init__(self, pname, **kw):
            ZSI.TC.List.__init__(self, pname, **kw)

    class DriverProfile_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "DriverProfile")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.DriverProfile_Def.schema
            TClist = [ZSI.TCnumbers.Iint(pname=(ns,"DayStartTime"), aname="_DayStartTime", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"DayEndTime"), aname="_DayEndTime", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._DayStartTime = None
                    self._DayEndTime = None
                    return
            Holder.__name__ = "DriverProfile_Holder"
            self.pyclass = Holder

    class RouteItinerary_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "RouteItinerary")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.RouteItinerary_Def.schema
            TClist = [ns2.ArrayOfSegment_Def(pname=(ns,"Segments"), aname="_Segments", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"TripTime"), aname="_TripTime", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"DrivingTime"), aname="_DrivingTime", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPdouble(pname=(ns,"Distance"), aname="_Distance", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.MapViewRepresentations_Def(pname=(ns,"View"), aname="_View", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Segments = None
                    self._TripTime = None
                    self._DrivingTime = None
                    self._Distance = None
                    self._View = None
                    return
            Holder.__name__ = "RouteItinerary_Holder"
            self.pyclass = Holder

    class ArrayOfSegment_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ArrayOfSegment")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.ArrayOfSegment_Def.schema
            TClist = [ns2.Segment_Def(pname=(ns,"Segment"), aname="_Segment", minOccurs=0, maxOccurs="unbounded", nillable=True, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Segment = []
                    return
            Holder.__name__ = "ArrayOfSegment_Holder"
            self.pyclass = Holder

    class Segment_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "Segment")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.Segment_Def.schema
            TClist = [ns2.Waypoint_Def(pname=(ns,"Waypoint"), aname="_Waypoint", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.ArrayOfDirection_Def(pname=(ns,"Directions"), aname="_Directions", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"TripTime"), aname="_TripTime", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"DrivingTime"), aname="_DrivingTime", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPdouble(pname=(ns,"Distance"), aname="_Distance", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.MapViewRepresentations_Def(pname=(ns,"View"), aname="_View", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Waypoint = None
                    self._Directions = None
                    self._TripTime = None
                    self._DrivingTime = None
                    self._Distance = None
                    self._View = None
                    return
            Holder.__name__ = "Segment_Holder"
            self.pyclass = Holder

    class ArrayOfDirection_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ArrayOfDirection")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.ArrayOfDirection_Def.schema
            TClist = [ns2.Direction_Def(pname=(ns,"Direction"), aname="_Direction", minOccurs=0, maxOccurs="unbounded", nillable=True, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Direction = []
                    return
            Holder.__name__ = "ArrayOfDirection_Holder"
            self.pyclass = Holder

    class Direction_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "Direction")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.Direction_Def.schema
            TClist = [ns2.LatLong_Def(pname=(ns,"LatLong"), aname="_LatLong", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.DirectionType_Def(pname=(ns,"DirectionType"), aname="_DirectionType", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.DirectionAction_Def(pname=(ns,"Action"), aname="_Action", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPfloat(pname=(ns,"BearingOutOfTurn"), aname="_BearingOutOfTurn", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPfloat(pname=(ns,"BearingIntoTurn"), aname="_BearingIntoTurn", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Ilong(pname=(ns,"Duration"), aname="_Duration", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPdouble(pname=(ns,"Distance"), aname="_Distance", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"Towards"), aname="_Towards", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"Instruction"), aname="_Instruction", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"FormattedInstruction"), aname="_FormattedInstruction", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"ID"), aname="_ID", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.MapViewRepresentations_Def(pname=(ns,"View"), aname="_View", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._LatLong = None
                    self._DirectionType = None
                    self._Action = None
                    self._BearingOutOfTurn = None
                    self._BearingIntoTurn = None
                    self._Duration = None
                    self._Distance = None
                    self._Towards = None
                    self._Instruction = None
                    self._FormattedInstruction = None
                    self._ID = None
                    self._View = None
                    return
            Holder.__name__ = "Direction_Holder"
            self.pyclass = Holder

    class DirectionType_Def(ZSI.TC.String, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "DirectionType")
        def __init__(self, pname, **kw):
            ZSI.TC.String.__init__(self, pname, pyclass=None, **kw)
            class Holder(str):
                typecode = self
            self.pyclass = Holder

    class DirectionAction_Def(ZSI.TC.String, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "DirectionAction")
        def __init__(self, pname, **kw):
            ZSI.TC.String.__init__(self, pname, pyclass=None, **kw)
            class Holder(str):
                typecode = self
            self.pyclass = Holder

    class CalculatedRouteRepresentation_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "CalculatedRouteRepresentation")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.CalculatedRouteRepresentation_Def.schema
            TClist = [ZSI.TC.Base64String(pname=(ns,"Bits"), aname="_Bits", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Bits = None
                    return
            Holder.__name__ = "CalculatedRouteRepresentation_Holder"
            self.pyclass = Holder

    class FindPolygonSpecification_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "FindPolygonSpecification")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.FindPolygonSpecification_Def.schema
            TClist = [ZSI.TC.String(pname=(ns,"DataSourceName"), aname="_DataSourceName", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.FindFilter_Def(pname=(ns,"Filter"), aname="_Filter", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.FindOptions_Def(pname=(ns,"Options"), aname="_Options", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.SpatialFilter_Def(pname=(ns,"SpatialFilter"), aname="_SpatialFilter", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._DataSourceName = None
                    self._Filter = None
                    self._Options = None
                    self._SpatialFilter = None
                    return
            Holder.__name__ = "FindPolygonSpecification_Holder"
            self.pyclass = Holder

    class CustomerInfoRouteHeader_Def(TypeDefinition):
        #complexType/complexContent extension
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "CustomerInfoRouteHeader")
        def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw):
            ns = ns2.CustomerInfoRouteHeader_Def.schema
            TClist = []
            self.attribute_typecode_dict = attributes or {}
            if ns2.CustomerInfoHeader_Def not in ns2.CustomerInfoRouteHeader_Def.__bases__:
                bases = list(ns2.CustomerInfoRouteHeader_Def.__bases__)
                bases.insert(0, ns2.CustomerInfoHeader_Def)
                ns2.CustomerInfoRouteHeader_Def.__bases__ = tuple(bases)

            ns2.CustomerInfoHeader_Def.__init__(self, pname, ofwhat=TClist, extend=True, **kw)

    class UserInfoRouteHeader_Def(TypeDefinition):
        #complexType/complexContent extension
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "UserInfoRouteHeader")
        def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw):
            ns = ns2.UserInfoRouteHeader_Def.schema
            TClist = []
            self.attribute_typecode_dict = attributes or {}
            if ns2.UserInfoHeader_Def not in ns2.UserInfoRouteHeader_Def.__bases__:
                bases = list(ns2.UserInfoRouteHeader_Def.__bases__)
                bases.insert(0, ns2.UserInfoHeader_Def)
                ns2.UserInfoRouteHeader_Def.__bases__ = tuple(bases)

            ns2.UserInfoHeader_Def.__init__(self, pname, ofwhat=TClist, extend=True, **kw)

    class MapSpecification_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "MapSpecification")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.MapSpecification_Def.schema
            TClist = [ns2.ArrayOfPolygon_Def(pname=(ns,"Polygons"), aname="_Polygons", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"DataSourceName"), aname="_DataSourceName", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.ArrayOfInt_Def(pname=(ns,"HighlightedEntityIDs"), aname="_HighlightedEntityIDs", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.ArrayOfString_Def(pname=(ns,"HideEntityTypes"), aname="_HideEntityTypes", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.MapOptions_Def(pname=(ns,"Options"), aname="_Options", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.ArrayOfPushpin_Def(pname=(ns,"Pushpins"), aname="_Pushpins", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.Route_Def(pname=(ns,"Route"), aname="_Route", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.ArrayOfMapView_Def(pname=(ns,"Views"), aname="_Views", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Polygons = None
                    self._DataSourceName = None
                    self._HighlightedEntityIDs = None
                    self._HideEntityTypes = None
                    self._Options = None
                    self._Pushpins = None
                    self._Route = None
                    self._Views = None
                    return
            Holder.__name__ = "MapSpecification_Holder"
            self.pyclass = Holder

    class ArrayOfPolygon_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ArrayOfPolygon")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.ArrayOfPolygon_Def.schema
            TClist = [ns2.Polygon_Def(pname=(ns,"Polygon"), aname="_Polygon", minOccurs=0, maxOccurs="unbounded", nillable=True, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Polygon = []
                    return
            Holder.__name__ = "ArrayOfPolygon_Holder"
            self.pyclass = Holder

    class Polygon_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "Polygon")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.Polygon_Def.schema
            TClist = [ZSI.TC.String(pname=(ns,"DataSourceName"), aname="_DataSourceName", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"EntityID"), aname="_EntityID", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.ElementColor_Def(pname=(ns,"BorderColor"), aname="_BorderColor", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.ElementColor_Def(pname=(ns,"FillColor"), aname="_FillColor", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"Label"), aname="_Label", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._DataSourceName = None
                    self._EntityID = None
                    self._BorderColor = None
                    self._FillColor = None
                    self._Label = None
                    return
            Holder.__name__ = "Polygon_Holder"
            self.pyclass = Holder

    class ElementColor_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ElementColor")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.ElementColor_Def.schema
            TClist = [ZSI.TCnumbers.IunsignedByte(pname=(ns,"A"), aname="_A", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.IunsignedByte(pname=(ns,"R"), aname="_R", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.IunsignedByte(pname=(ns,"G"), aname="_G", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.IunsignedByte(pname=(ns,"B"), aname="_B", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._A = None
                    self._R = None
                    self._G = None
                    self._B = None
                    return
            Holder.__name__ = "ElementColor_Holder"
            self.pyclass = Holder

    class MapOptions_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "MapOptions")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.MapOptions_Def.schema
            TClist = [ns2.RouteHighlightColor_Def(pname=(ns,"RouteHighlightColor"), aname="_RouteHighlightColor", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.RouteHighlightColor_Def(pname=(ns,"ConstructionDelayHighlightColor"), aname="_ConstructionDelayHighlightColor", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.RouteHighlightColor_Def(pname=(ns,"ConstructionClosureHighlightColor"), aname="_ConstructionClosureHighlightColor", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.MapFontSize_Def(pname=(ns,"FontSize"), aname="_FontSize", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.ImageFormat_Def(pname=(ns,"Format"), aname="_Format", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"IsOverviewMap"), aname="_IsOverviewMap", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.MapReturnType_Def(pname=(ns,"ReturnType"), aname="_ReturnType", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPdouble(pname=(ns,"PanHorizontal"), aname="_PanHorizontal", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPdouble(pname=(ns,"PanVertical"), aname="_PanVertical", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.MapStyle_Def(pname=(ns,"Style"), aname="_Style", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.FPdouble(pname=(ns,"Zoom"), aname="_Zoom", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"PreventIconCollisions"), aname="_PreventIconCollisions", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._RouteHighlightColor = None
                    self._ConstructionDelayHighlightColor = None
                    self._ConstructionClosureHighlightColor = None
                    self._FontSize = None
                    self._Format = None
                    self._IsOverviewMap = None
                    self._ReturnType = None
                    self._PanHorizontal = None
                    self._PanVertical = None
                    self._Style = None
                    self._Zoom = None
                    self._PreventIconCollisions = None
                    return
            Holder.__name__ = "MapOptions_Holder"
            self.pyclass = Holder

    class RouteHighlightColor_Def(ZSI.TC.String, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "RouteHighlightColor")
        def __init__(self, pname, **kw):
            ZSI.TC.String.__init__(self, pname, pyclass=None, **kw)
            class Holder(str):
                typecode = self
            self.pyclass = Holder

    class MapFontSize_Def(ZSI.TC.String, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "MapFontSize")
        def __init__(self, pname, **kw):
            ZSI.TC.String.__init__(self, pname, pyclass=None, **kw)
            class Holder(str):
                typecode = self
            self.pyclass = Holder

    class ImageFormat_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ImageFormat")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.ImageFormat_Def.schema
            TClist = [ZSI.TC.String(pname=(ns,"MimeType"), aname="_MimeType", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"Height"), aname="_Height", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"Width"), aname="_Width", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._MimeType = None
                    self._Height = None
                    self._Width = None
                    return
            Holder.__name__ = "ImageFormat_Holder"
            self.pyclass = Holder

    class MapReturnType_Def(ZSI.TC.String, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "MapReturnType")
        def __init__(self, pname, **kw):
            ZSI.TC.String.__init__(self, pname, pyclass=None, **kw)
            class Holder(str):
                typecode = self
            self.pyclass = Holder

    class MapStyle_Def(ZSI.TC.String, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "MapStyle")
        def __init__(self, pname, **kw):
            ZSI.TC.String.__init__(self, pname, pyclass=None, **kw)
            class Holder(str):
                typecode = self
            self.pyclass = Holder

    class ArrayOfPushpin_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ArrayOfPushpin")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.ArrayOfPushpin_Def.schema
            TClist = [ns2.Pushpin_Def(pname=(ns,"Pushpin"), aname="_Pushpin", minOccurs=0, maxOccurs="unbounded", nillable=True, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Pushpin = []
                    return
            Holder.__name__ = "ArrayOfPushpin_Holder"
            self.pyclass = Holder

    class Pushpin_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "Pushpin")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.Pushpin_Def.schema
            TClist = [ZSI.TC.String(pname=(ns,"IconDataSource"), aname="_IconDataSource", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"IconName"), aname="_IconName", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"Label"), aname="_Label", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.LatLong_Def(pname=(ns,"LatLong"), aname="_LatLong", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"PinID"), aname="_PinID", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.PixelCoord_Def(pname=(ns,"Pixel"), aname="_Pixel", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"ReturnsHotArea"), aname="_ReturnsHotArea", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.Boolean(pname=(ns,"LabelNearbyRoads"), aname="_LabelNearbyRoads", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._IconDataSource = None
                    self._IconName = None
                    self._Label = None
                    self._LatLong = None
                    self._PinID = None
                    self._Pixel = None
                    self._ReturnsHotArea = None
                    self._LabelNearbyRoads = None
                    return
            Holder.__name__ = "Pushpin_Holder"
            self.pyclass = Holder

    class PixelCoord_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "PixelCoord")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.PixelCoord_Def.schema
            TClist = [ZSI.TCnumbers.Iint(pname=(ns,"X"), aname="_X", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"Y"), aname="_Y", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._X = None
                    self._Y = None
                    return
            Holder.__name__ = "PixelCoord_Holder"
            self.pyclass = Holder

    class ArrayOfMapView_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ArrayOfMapView")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.ArrayOfMapView_Def.schema
            TClist = [ns2.MapView_Def(pname=(ns,"MapView"), aname="_MapView", minOccurs=0, maxOccurs="unbounded", nillable=True, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._MapView = []
                    return
            Holder.__name__ = "ArrayOfMapView_Holder"
            self.pyclass = Holder

    class MapImage_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "MapImage")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.MapImage_Def.schema
            TClist = [ns2.ArrayOfHotArea_Def(pname=(ns,"HotAreas"), aname="_HotAreas", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.MimeData_Def(pname=(ns,"MimeData"), aname="_MimeData", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.MapViewRepresentations_Def(pname=(ns,"View"), aname="_View", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"Url"), aname="_Url", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._HotAreas = None
                    self._MimeData = None
                    self._View = None
                    self._Url = None
                    return
            Holder.__name__ = "MapImage_Holder"
            self.pyclass = Holder

    class ArrayOfHotArea_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ArrayOfHotArea")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.ArrayOfHotArea_Def.schema
            TClist = [ns2.HotArea_Def(pname=(ns,"HotArea"), aname="_HotArea", minOccurs=0, maxOccurs="unbounded", nillable=True, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._HotArea = []
                    return
            Holder.__name__ = "ArrayOfHotArea_Holder"
            self.pyclass = Holder

    class HotArea_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "HotArea")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.HotArea_Def.schema
            TClist = [ns2.PixelRectangle_Def(pname=(ns,"IconRectangle"), aname="_IconRectangle", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.PixelRectangle_Def(pname=(ns,"LabelRectangle"), aname="_LabelRectangle", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"PinID"), aname="_PinID", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._IconRectangle = None
                    self._LabelRectangle = None
                    self._PinID = None
                    return
            Holder.__name__ = "HotArea_Holder"
            self.pyclass = Holder

    class PixelRectangle_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "PixelRectangle")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.PixelRectangle_Def.schema
            TClist = [ZSI.TCnumbers.Iint(pname=(ns,"Bottom"), aname="_Bottom", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"Left"), aname="_Left", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"Right"), aname="_Right", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"Top"), aname="_Top", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Bottom = None
                    self._Left = None
                    self._Right = None
                    self._Top = None
                    return
            Holder.__name__ = "PixelRectangle_Holder"
            self.pyclass = Holder

    class MimeData_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "MimeData")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.MimeData_Def.schema
            TClist = [ZSI.TC.Base64String(pname=(ns,"Bits"), aname="_Bits", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"ContentID"), aname="_ContentID", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"MimeType"), aname="_MimeType", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Bits = None
                    self._ContentID = None
                    self._MimeType = None
                    return
            Holder.__name__ = "MimeData_Holder"
            self.pyclass = Holder

    class ArrayOfMapImage_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ArrayOfMapImage")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.ArrayOfMapImage_Def.schema
            TClist = [ns2.MapImage_Def(pname=(ns,"MapImage"), aname="_MapImage", minOccurs=0, maxOccurs="unbounded", nillable=True, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._MapImage = []
                    return
            Holder.__name__ = "ArrayOfMapImage_Holder"
            self.pyclass = Holder

    class CustomerInfoRenderHeader_Def(TypeDefinition):
        #complexType/complexContent extension
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "CustomerInfoRenderHeader")
        def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw):
            ns = ns2.CustomerInfoRenderHeader_Def.schema
            TClist = []
            self.attribute_typecode_dict = attributes or {}
            if ns2.CustomerInfoHeader_Def not in ns2.CustomerInfoRenderHeader_Def.__bases__:
                bases = list(ns2.CustomerInfoRenderHeader_Def.__bases__)
                bases.insert(0, ns2.CustomerInfoHeader_Def)
                ns2.CustomerInfoRenderHeader_Def.__bases__ = tuple(bases)

            ns2.CustomerInfoHeader_Def.__init__(self, pname, ofwhat=TClist, extend=True, **kw)

    class UserInfoRenderHeader_Def(TypeDefinition):
        #complexType/complexContent extension
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "UserInfoRenderHeader")
        def __init__(self, pname, ofwhat=(), extend=False, restrict=False, attributes=None, **kw):
            ns = ns2.UserInfoRenderHeader_Def.schema
            TClist = []
            self.attribute_typecode_dict = attributes or {}
            if ns2.UserInfoHeader_Def not in ns2.UserInfoRenderHeader_Def.__bases__:
                bases = list(ns2.UserInfoRenderHeader_Def.__bases__)
                bases.insert(0, ns2.UserInfoHeader_Def)
                ns2.UserInfoRenderHeader_Def.__bases__ = tuple(bases)

            ns2.UserInfoHeader_Def.__init__(self, pname, ofwhat=TClist, extend=True, **kw)

    class ArrayOfPixelCoord_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ArrayOfPixelCoord")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.ArrayOfPixelCoord_Def.schema
            TClist = [ns2.PixelCoord_Def(pname=(ns,"PixelCoord"), aname="_PixelCoord", minOccurs=0, maxOccurs="unbounded", nillable=True, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._PixelCoord = []
                    return
            Holder.__name__ = "ArrayOfPixelCoord_Holder"
            self.pyclass = Holder

    class LineDriveMapSpecification_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "LineDriveMapSpecification")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.LineDriveMapSpecification_Def.schema
            TClist = [ns2.Route_Def(pname=(ns,"Route"), aname="_Route", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.LineDriveMapOptions_Def(pname=(ns,"Options"), aname="_Options", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Route = None
                    self._Options = None
                    return
            Holder.__name__ = "LineDriveMapSpecification_Holder"
            self.pyclass = Holder

    class LineDriveMapOptions_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "LineDriveMapOptions")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.LineDriveMapOptions_Def.schema
            TClist = [ns2.ImageFormat_Def(pname=(ns,"Format"), aname="_Format", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.MapReturnType_Def(pname=(ns,"ReturnType"), aname="_ReturnType", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.MapFontSize_Def(pname=(ns,"FontSize"), aname="_FontSize", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.PaletteType_Def(pname=(ns,"PaletteType"), aname="_PaletteType", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"DestinationIconDataSource"), aname="_DestinationIconDataSource", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"DestinationIconName"), aname="_DestinationIconName", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Format = None
                    self._ReturnType = None
                    self._FontSize = None
                    self._PaletteType = None
                    self._DestinationIconDataSource = None
                    self._DestinationIconName = None
                    return
            Holder.__name__ = "LineDriveMapOptions_Holder"
            self.pyclass = Holder

    class PaletteType_Def(ZSI.TC.String, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "PaletteType")
        def __init__(self, pname, **kw):
            ZSI.TC.String.__init__(self, pname, pyclass=None, **kw)
            class Holder(str):
                typecode = self
            self.pyclass = Holder

    class LineDriveMapImage_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "LineDriveMapImage")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.LineDriveMapImage_Def.schema
            TClist = [ns2.MimeData_Def(pname=(ns,"MimeData"), aname="_MimeData", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"Url"), aname="_Url", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.MapViewRepresentations_Def(pname=(ns,"View"), aname="_View", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"FirstDirectionID"), aname="_FirstDirectionID", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"LastDirectionID"), aname="_LastDirectionID", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._MimeData = None
                    self._Url = None
                    self._View = None
                    self._FirstDirectionID = None
                    self._LastDirectionID = None
                    return
            Holder.__name__ = "LineDriveMapImage_Holder"
            self.pyclass = Holder

    class ArrayOfLineDriveMapImage_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://s.mappoint.net/mappoint-30/"
        type = (schema, "ArrayOfLineDriveMapImage")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns2.ArrayOfLineDriveMapImage_Def.schema
            TClist = [ns2.LineDriveMapImage_Def(pname=(ns,"LineDriveMapImage"), aname="_LineDriveMapImage", minOccurs=0, maxOccurs="unbounded", nillable=True, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._LineDriveMapImage = []
                    return
            Holder.__name__ = "ArrayOfLineDriveMapImage_Holder"
            self.pyclass = Holder

    class GetVersionInfo_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "GetVersionInfo"
        def __init__(self, **kw):
            ns = ns2.GetVersionInfo_Dec.schema
            TClist = []
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","GetVersionInfo")
            kw["aname"] = "_GetVersionInfo"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    return
            Holder.__name__ = "GetVersionInfo_Holder"
            self.pyclass = Holder

    class GetVersionInfoResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "GetVersionInfoResponse"
        def __init__(self, **kw):
            ns = ns2.GetVersionInfoResponse_Dec.schema
            TClist = [ns2.ArrayOfVersionInfo_Def(pname=(ns,"GetVersionInfoResult"), aname="_GetVersionInfoResult", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","GetVersionInfoResponse")
            kw["aname"] = "_GetVersionInfoResponse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._GetVersionInfoResult = None
                    return
            Holder.__name__ = "GetVersionInfoResponse_Holder"
            self.pyclass = Holder

    class CustomerInfoHeader_Dec(ElementDeclaration):
        literal = "CustomerInfoHeader"
        schema = "http://s.mappoint.net/mappoint-30/"
        def __init__(self, **kw):
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","CustomerInfoHeader")
            kw["aname"] = "_CustomerInfoHeader"
            if ns2.CustomerInfoHeader_Def not in ns2.CustomerInfoHeader_Dec.__bases__:
                bases = list(ns2.CustomerInfoHeader_Dec.__bases__)
                bases.insert(0, ns2.CustomerInfoHeader_Def)
                ns2.CustomerInfoHeader_Dec.__bases__ = tuple(bases)

            ns2.CustomerInfoHeader_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "CustomerInfoHeader_Dec_Holder"

    class UserInfoHeader_Dec(ElementDeclaration):
        literal = "UserInfoHeader"
        schema = "http://s.mappoint.net/mappoint-30/"
        def __init__(self, **kw):
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","UserInfoHeader")
            kw["aname"] = "_UserInfoHeader"
            if ns2.UserInfoHeader_Def not in ns2.UserInfoHeader_Dec.__bases__:
                bases = list(ns2.UserInfoHeader_Dec.__bases__)
                bases.insert(0, ns2.UserInfoHeader_Def)
                ns2.UserInfoHeader_Dec.__bases__ = tuple(bases)

            ns2.UserInfoHeader_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "UserInfoHeader_Dec_Holder"

    class GetCountryRegionInfo_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "GetCountryRegionInfo"
        def __init__(self, **kw):
            ns = ns2.GetCountryRegionInfo_Dec.schema
            TClist = [ns2.ArrayOfInt_Def(pname=(ns,"entityIDs"), aname="_entityIDs", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","GetCountryRegionInfo")
            kw["aname"] = "_GetCountryRegionInfo"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._entityIDs = None
                    return
            Holder.__name__ = "GetCountryRegionInfo_Holder"
            self.pyclass = Holder

    class GetCountryRegionInfoResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "GetCountryRegionInfoResponse"
        def __init__(self, **kw):
            ns = ns2.GetCountryRegionInfoResponse_Dec.schema
            TClist = [ns2.ArrayOfCountryRegionInfo_Def(pname=(ns,"GetCountryRegionInfoResult"), aname="_GetCountryRegionInfoResult", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","GetCountryRegionInfoResponse")
            kw["aname"] = "_GetCountryRegionInfoResponse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._GetCountryRegionInfoResult = None
                    return
            Holder.__name__ = "GetCountryRegionInfoResponse_Holder"
            self.pyclass = Holder

    class GetEntityTypes_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "GetEntityTypes"
        def __init__(self, **kw):
            ns = ns2.GetEntityTypes_Dec.schema
            TClist = [ZSI.TC.String(pname=(ns,"dataSourceName"), aname="_dataSourceName", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","GetEntityTypes")
            kw["aname"] = "_GetEntityTypes"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._dataSourceName = None
                    return
            Holder.__name__ = "GetEntityTypes_Holder"
            self.pyclass = Holder

    class GetEntityTypesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "GetEntityTypesResponse"
        def __init__(self, **kw):
            ns = ns2.GetEntityTypesResponse_Dec.schema
            TClist = [ns2.ArrayOfEntityType_Def(pname=(ns,"GetEntityTypesResult"), aname="_GetEntityTypesResult", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","GetEntityTypesResponse")
            kw["aname"] = "_GetEntityTypesResponse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._GetEntityTypesResult = None
                    return
            Holder.__name__ = "GetEntityTypesResponse_Holder"
            self.pyclass = Holder

    class GetDataSourceInfo_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "GetDataSourceInfo"
        def __init__(self, **kw):
            ns = ns2.GetDataSourceInfo_Dec.schema
            TClist = [ns2.ArrayOfString_Def(pname=(ns,"dataSourceNames"), aname="_dataSourceNames", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","GetDataSourceInfo")
            kw["aname"] = "_GetDataSourceInfo"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._dataSourceNames = None
                    return
            Holder.__name__ = "GetDataSourceInfo_Holder"
            self.pyclass = Holder

    class GetDataSourceInfoResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "GetDataSourceInfoResponse"
        def __init__(self, **kw):
            ns = ns2.GetDataSourceInfoResponse_Dec.schema
            TClist = [ns2.ArrayOfDataSource_Def(pname=(ns,"GetDataSourceInfoResult"), aname="_GetDataSourceInfoResult", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","GetDataSourceInfoResponse")
            kw["aname"] = "_GetDataSourceInfoResponse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._GetDataSourceInfoResult = None
                    return
            Holder.__name__ = "GetDataSourceInfoResponse_Holder"
            self.pyclass = Holder

    class GetGreatCircleDistances_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "GetGreatCircleDistances"
        def __init__(self, **kw):
            ns = ns2.GetGreatCircleDistances_Dec.schema
            TClist = [ns2.ArrayOfLatLong_Def(pname=(ns,"latLongs"), aname="_latLongs", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","GetGreatCircleDistances")
            kw["aname"] = "_GetGreatCircleDistances"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._latLongs = None
                    return
            Holder.__name__ = "GetGreatCircleDistances_Holder"
            self.pyclass = Holder

    class GetGreatCircleDistancesResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "GetGreatCircleDistancesResponse"
        def __init__(self, **kw):
            ns = ns2.GetGreatCircleDistancesResponse_Dec.schema
            TClist = [ns2.ArrayOfDouble_Def(pname=(ns,"GetGreatCircleDistancesResult"), aname="_GetGreatCircleDistancesResult", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","GetGreatCircleDistancesResponse")
            kw["aname"] = "_GetGreatCircleDistancesResponse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._GetGreatCircleDistancesResult = None
                    return
            Holder.__name__ = "GetGreatCircleDistancesResponse_Holder"
            self.pyclass = Holder

    class Find_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "Find"
        def __init__(self, **kw):
            ns = ns2.Find_Dec.schema
            TClist = [ns2.FindSpecification_Def(pname=(ns,"specification"), aname="_specification", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","Find")
            kw["aname"] = "_Find"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._specification = None
                    return
            Holder.__name__ = "Find_Holder"
            self.pyclass = Holder

    class FindResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "FindResponse"
        def __init__(self, **kw):
            ns = ns2.FindResponse_Dec.schema
            TClist = [ns2.FindResults_Def(pname=(ns,"FindResult"), aname="_FindResult", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","FindResponse")
            kw["aname"] = "_FindResponse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._FindResult = None
                    return
            Holder.__name__ = "FindResponse_Holder"
            self.pyclass = Holder

    class CustomerInfoFindHeader_Dec(ElementDeclaration):
        literal = "CustomerInfoFindHeader"
        schema = "http://s.mappoint.net/mappoint-30/"
        def __init__(self, **kw):
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","CustomerInfoFindHeader")
            kw["aname"] = "_CustomerInfoFindHeader"
            if ns2.CustomerInfoFindHeader_Def not in ns2.CustomerInfoFindHeader_Dec.__bases__:
                bases = list(ns2.CustomerInfoFindHeader_Dec.__bases__)
                bases.insert(0, ns2.CustomerInfoFindHeader_Def)
                ns2.CustomerInfoFindHeader_Dec.__bases__ = tuple(bases)

            ns2.CustomerInfoFindHeader_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "CustomerInfoFindHeader_Dec_Holder"

    class UserInfoFindHeader_Dec(ElementDeclaration):
        literal = "UserInfoFindHeader"
        schema = "http://s.mappoint.net/mappoint-30/"
        def __init__(self, **kw):
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","UserInfoFindHeader")
            kw["aname"] = "_UserInfoFindHeader"
            if ns2.UserInfoFindHeader_Def not in ns2.UserInfoFindHeader_Dec.__bases__:
                bases = list(ns2.UserInfoFindHeader_Dec.__bases__)
                bases.insert(0, ns2.UserInfoFindHeader_Def)
                ns2.UserInfoFindHeader_Dec.__bases__ = tuple(bases)

            ns2.UserInfoFindHeader_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "UserInfoFindHeader_Dec_Holder"

    class FindAddress_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "FindAddress"
        def __init__(self, **kw):
            ns = ns2.FindAddress_Dec.schema
            TClist = [ns2.FindAddressSpecification_Def(pname=(ns,"specification"), aname="_specification", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","FindAddress")
            kw["aname"] = "_FindAddress"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._specification = None
                    return
            Holder.__name__ = "FindAddress_Holder"
            self.pyclass = Holder

    class FindAddressResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "FindAddressResponse"
        def __init__(self, **kw):
            ns = ns2.FindAddressResponse_Dec.schema
            TClist = [ns2.FindResults_Def(pname=(ns,"FindAddressResult"), aname="_FindAddressResult", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","FindAddressResponse")
            kw["aname"] = "_FindAddressResponse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._FindAddressResult = None
                    return
            Holder.__name__ = "FindAddressResponse_Holder"
            self.pyclass = Holder

    class ParseAddress_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "ParseAddress"
        def __init__(self, **kw):
            ns = ns2.ParseAddress_Dec.schema
            TClist = [ZSI.TC.String(pname=(ns,"inputAddress"), aname="_inputAddress", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"countryRegion"), aname="_countryRegion", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","ParseAddress")
            kw["aname"] = "_ParseAddress"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._inputAddress = None
                    self._countryRegion = None
                    return
            Holder.__name__ = "ParseAddress_Holder"
            self.pyclass = Holder

    class ParseAddressResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "ParseAddressResponse"
        def __init__(self, **kw):
            ns = ns2.ParseAddressResponse_Dec.schema
            TClist = [ns2.Address_Def(pname=(ns,"ParseAddressResult"), aname="_ParseAddressResult", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","ParseAddressResponse")
            kw["aname"] = "_ParseAddressResponse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._ParseAddressResult = None
                    return
            Holder.__name__ = "ParseAddressResponse_Holder"
            self.pyclass = Holder

    class GetLocationInfo_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "GetLocationInfo"
        def __init__(self, **kw):
            ns = ns2.GetLocationInfo_Dec.schema
            TClist = [ns2.LatLong_Def(pname=(ns,"location"), aname="_location", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dataSourceName"), aname="_dataSourceName", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.GetInfoOptions_Def(pname=(ns,"options"), aname="_options", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","GetLocationInfo")
            kw["aname"] = "_GetLocationInfo"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._location = None
                    self._dataSourceName = None
                    self._options = None
                    return
            Holder.__name__ = "GetLocationInfo_Holder"
            self.pyclass = Holder

    class GetLocationInfoResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "GetLocationInfoResponse"
        def __init__(self, **kw):
            ns = ns2.GetLocationInfoResponse_Dec.schema
            TClist = [ns2.ArrayOfLocation_Def(pname=(ns,"GetLocationInfoResult"), aname="_GetLocationInfoResult", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","GetLocationInfoResponse")
            kw["aname"] = "_GetLocationInfoResponse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._GetLocationInfoResult = None
                    return
            Holder.__name__ = "GetLocationInfoResponse_Holder"
            self.pyclass = Holder

    class FindNearby_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "FindNearby"
        def __init__(self, **kw):
            ns = ns2.FindNearby_Dec.schema
            TClist = [ns2.FindNearbySpecification_Def(pname=(ns,"specification"), aname="_specification", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","FindNearby")
            kw["aname"] = "_FindNearby"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._specification = None
                    return
            Holder.__name__ = "FindNearby_Holder"
            self.pyclass = Holder

    class FindNearbyResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "FindNearbyResponse"
        def __init__(self, **kw):
            ns = ns2.FindNearbyResponse_Dec.schema
            TClist = [ns2.FindResults_Def(pname=(ns,"FindNearbyResult"), aname="_FindNearbyResult", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","FindNearbyResponse")
            kw["aname"] = "_FindNearbyResponse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._FindNearbyResult = None
                    return
            Holder.__name__ = "FindNearbyResponse_Holder"
            self.pyclass = Holder

    class FindByProperty_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "FindByProperty"
        def __init__(self, **kw):
            ns = ns2.FindByProperty_Dec.schema
            TClist = [ns2.FindByPropertySpecification_Def(pname=(ns,"specification"), aname="_specification", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","FindByProperty")
            kw["aname"] = "_FindByProperty"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._specification = None
                    return
            Holder.__name__ = "FindByProperty_Holder"
            self.pyclass = Holder

    class FindByPropertyResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "FindByPropertyResponse"
        def __init__(self, **kw):
            ns = ns2.FindByPropertyResponse_Dec.schema
            TClist = [ns2.FindResults_Def(pname=(ns,"FindByPropertyResult"), aname="_FindByPropertyResult", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","FindByPropertyResponse")
            kw["aname"] = "_FindByPropertyResponse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._FindByPropertyResult = None
                    return
            Holder.__name__ = "FindByPropertyResponse_Holder"
            self.pyclass = Holder

    class FindByID_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "FindByID"
        def __init__(self, **kw):
            ns = ns2.FindByID_Dec.schema
            TClist = [ns2.FindByIDSpecification_Def(pname=(ns,"specification"), aname="_specification", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","FindByID")
            kw["aname"] = "_FindByID"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._specification = None
                    return
            Holder.__name__ = "FindByID_Holder"
            self.pyclass = Holder

    class FindByIDResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "FindByIDResponse"
        def __init__(self, **kw):
            ns = ns2.FindByIDResponse_Dec.schema
            TClist = [ns2.FindResults_Def(pname=(ns,"FindByIDResult"), aname="_FindByIDResult", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","FindByIDResponse")
            kw["aname"] = "_FindByIDResponse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._FindByIDResult = None
                    return
            Holder.__name__ = "FindByIDResponse_Holder"
            self.pyclass = Holder

    class FindNearRoute_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "FindNearRoute"
        def __init__(self, **kw):
            ns = ns2.FindNearRoute_Dec.schema
            TClist = [ns2.FindNearRouteSpecification_Def(pname=(ns,"specification"), aname="_specification", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","FindNearRoute")
            kw["aname"] = "_FindNearRoute"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._specification = None
                    return
            Holder.__name__ = "FindNearRoute_Holder"
            self.pyclass = Holder

    class FindNearRouteResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "FindNearRouteResponse"
        def __init__(self, **kw):
            ns = ns2.FindNearRouteResponse_Dec.schema
            TClist = [ns2.FindResults_Def(pname=(ns,"FindNearRouteResult"), aname="_FindNearRouteResult", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","FindNearRouteResponse")
            kw["aname"] = "_FindNearRouteResponse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._FindNearRouteResult = None
                    return
            Holder.__name__ = "FindNearRouteResponse_Holder"
            self.pyclass = Holder

    class FindPolygon_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "FindPolygon"
        def __init__(self, **kw):
            ns = ns2.FindPolygon_Dec.schema
            TClist = [ns2.FindPolygonSpecification_Def(pname=(ns,"specification"), aname="_specification", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","FindPolygon")
            kw["aname"] = "_FindPolygon"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._specification = None
                    return
            Holder.__name__ = "FindPolygon_Holder"
            self.pyclass = Holder

    class FindPolygonResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "FindPolygonResponse"
        def __init__(self, **kw):
            ns = ns2.FindPolygonResponse_Dec.schema
            TClist = [ns2.FindResults_Def(pname=(ns,"FindPolygonResult"), aname="_FindPolygonResult", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","FindPolygonResponse")
            kw["aname"] = "_FindPolygonResponse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._FindPolygonResult = None
                    return
            Holder.__name__ = "FindPolygonResponse_Holder"
            self.pyclass = Holder

    class CalculateSimpleRoute_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "CalculateSimpleRoute"
        def __init__(self, **kw):
            ns = ns2.CalculateSimpleRoute_Dec.schema
            TClist = [ns2.ArrayOfLatLong_Def(pname=(ns,"latLongs"), aname="_latLongs", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dataSourceName"), aname="_dataSourceName", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.SegmentPreference_Def(pname=(ns,"preference"), aname="_preference", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","CalculateSimpleRoute")
            kw["aname"] = "_CalculateSimpleRoute"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._latLongs = None
                    self._dataSourceName = None
                    self._preference = None
                    return
            Holder.__name__ = "CalculateSimpleRoute_Holder"
            self.pyclass = Holder

    class CalculateSimpleRouteResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "CalculateSimpleRouteResponse"
        def __init__(self, **kw):
            ns = ns2.CalculateSimpleRouteResponse_Dec.schema
            TClist = [ns2.Route_Def(pname=(ns,"CalculateSimpleRouteResult"), aname="_CalculateSimpleRouteResult", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","CalculateSimpleRouteResponse")
            kw["aname"] = "_CalculateSimpleRouteResponse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._CalculateSimpleRouteResult = None
                    return
            Holder.__name__ = "CalculateSimpleRouteResponse_Holder"
            self.pyclass = Holder

    class CustomerInfoRouteHeader_Dec(ElementDeclaration):
        literal = "CustomerInfoRouteHeader"
        schema = "http://s.mappoint.net/mappoint-30/"
        def __init__(self, **kw):
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","CustomerInfoRouteHeader")
            kw["aname"] = "_CustomerInfoRouteHeader"
            if ns2.CustomerInfoRouteHeader_Def not in ns2.CustomerInfoRouteHeader_Dec.__bases__:
                bases = list(ns2.CustomerInfoRouteHeader_Dec.__bases__)
                bases.insert(0, ns2.CustomerInfoRouteHeader_Def)
                ns2.CustomerInfoRouteHeader_Dec.__bases__ = tuple(bases)

            ns2.CustomerInfoRouteHeader_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "CustomerInfoRouteHeader_Dec_Holder"

    class UserInfoRouteHeader_Dec(ElementDeclaration):
        literal = "UserInfoRouteHeader"
        schema = "http://s.mappoint.net/mappoint-30/"
        def __init__(self, **kw):
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","UserInfoRouteHeader")
            kw["aname"] = "_UserInfoRouteHeader"
            if ns2.UserInfoRouteHeader_Def not in ns2.UserInfoRouteHeader_Dec.__bases__:
                bases = list(ns2.UserInfoRouteHeader_Dec.__bases__)
                bases.insert(0, ns2.UserInfoRouteHeader_Def)
                ns2.UserInfoRouteHeader_Dec.__bases__ = tuple(bases)

            ns2.UserInfoRouteHeader_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "UserInfoRouteHeader_Dec_Holder"

    class CalculateRoute_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "CalculateRoute"
        def __init__(self, **kw):
            ns = ns2.CalculateRoute_Dec.schema
            TClist = [ns2.RouteSpecification_Def(pname=(ns,"specification"), aname="_specification", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","CalculateRoute")
            kw["aname"] = "_CalculateRoute"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._specification = None
                    return
            Holder.__name__ = "CalculateRoute_Holder"
            self.pyclass = Holder

    class CalculateRouteResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "CalculateRouteResponse"
        def __init__(self, **kw):
            ns = ns2.CalculateRouteResponse_Dec.schema
            TClist = [ns2.Route_Def(pname=(ns,"CalculateRouteResult"), aname="_CalculateRouteResult", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","CalculateRouteResponse")
            kw["aname"] = "_CalculateRouteResponse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._CalculateRouteResult = None
                    return
            Holder.__name__ = "CalculateRouteResponse_Holder"
            self.pyclass = Holder

    class GetMap_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "GetMap"
        def __init__(self, **kw):
            ns = ns2.GetMap_Dec.schema
            TClist = [ns2.MapSpecification_Def(pname=(ns,"specification"), aname="_specification", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","GetMap")
            kw["aname"] = "_GetMap"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._specification = None
                    return
            Holder.__name__ = "GetMap_Holder"
            self.pyclass = Holder

    class GetMapResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "GetMapResponse"
        def __init__(self, **kw):
            ns = ns2.GetMapResponse_Dec.schema
            TClist = [ns2.ArrayOfMapImage_Def(pname=(ns,"GetMapResult"), aname="_GetMapResult", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","GetMapResponse")
            kw["aname"] = "_GetMapResponse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._GetMapResult = None
                    return
            Holder.__name__ = "GetMapResponse_Holder"
            self.pyclass = Holder

    class CustomerInfoRenderHeader_Dec(ElementDeclaration):
        literal = "CustomerInfoRenderHeader"
        schema = "http://s.mappoint.net/mappoint-30/"
        def __init__(self, **kw):
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","CustomerInfoRenderHeader")
            kw["aname"] = "_CustomerInfoRenderHeader"
            if ns2.CustomerInfoRenderHeader_Def not in ns2.CustomerInfoRenderHeader_Dec.__bases__:
                bases = list(ns2.CustomerInfoRenderHeader_Dec.__bases__)
                bases.insert(0, ns2.CustomerInfoRenderHeader_Def)
                ns2.CustomerInfoRenderHeader_Dec.__bases__ = tuple(bases)

            ns2.CustomerInfoRenderHeader_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "CustomerInfoRenderHeader_Dec_Holder"

    class UserInfoRenderHeader_Dec(ElementDeclaration):
        literal = "UserInfoRenderHeader"
        schema = "http://s.mappoint.net/mappoint-30/"
        def __init__(self, **kw):
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","UserInfoRenderHeader")
            kw["aname"] = "_UserInfoRenderHeader"
            if ns2.UserInfoRenderHeader_Def not in ns2.UserInfoRenderHeader_Dec.__bases__:
                bases = list(ns2.UserInfoRenderHeader_Dec.__bases__)
                bases.insert(0, ns2.UserInfoRenderHeader_Def)
                ns2.UserInfoRenderHeader_Dec.__bases__ = tuple(bases)

            ns2.UserInfoRenderHeader_Def.__init__(self, **kw)
            if self.pyclass is not None: self.pyclass.__name__ = "UserInfoRenderHeader_Dec_Holder"

    class ConvertToPoint_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "ConvertToPoint"
        def __init__(self, **kw):
            ns = ns2.ConvertToPoint_Dec.schema
            TClist = [ns2.ArrayOfLatLong_Def(pname=(ns,"latLong"), aname="_latLong", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.MapView_Def(pname=(ns,"view"), aname="_view", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"width"), aname="_width", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"height"), aname="_height", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","ConvertToPoint")
            kw["aname"] = "_ConvertToPoint"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._latLong = None
                    self._view = None
                    self._width = None
                    self._height = None
                    return
            Holder.__name__ = "ConvertToPoint_Holder"
            self.pyclass = Holder

    class ConvertToPointResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "ConvertToPointResponse"
        def __init__(self, **kw):
            ns = ns2.ConvertToPointResponse_Dec.schema
            TClist = [ns2.ArrayOfPixelCoord_Def(pname=(ns,"ConvertToPointResult"), aname="_ConvertToPointResult", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","ConvertToPointResponse")
            kw["aname"] = "_ConvertToPointResponse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._ConvertToPointResult = None
                    return
            Holder.__name__ = "ConvertToPointResponse_Holder"
            self.pyclass = Holder

    class ConvertToLatLong_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "ConvertToLatLong"
        def __init__(self, **kw):
            ns = ns2.ConvertToLatLong_Dec.schema
            TClist = [ns2.ArrayOfPixelCoord_Def(pname=(ns,"pixels"), aname="_pixels", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ns2.MapView_Def(pname=(ns,"view"), aname="_view", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"width"), aname="_width", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iint(pname=(ns,"height"), aname="_height", minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","ConvertToLatLong")
            kw["aname"] = "_ConvertToLatLong"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._pixels = None
                    self._view = None
                    self._width = None
                    self._height = None
                    return
            Holder.__name__ = "ConvertToLatLong_Holder"
            self.pyclass = Holder

    class ConvertToLatLongResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "ConvertToLatLongResponse"
        def __init__(self, **kw):
            ns = ns2.ConvertToLatLongResponse_Dec.schema
            TClist = [ns2.ArrayOfLatLong_Def(pname=(ns,"ConvertToLatLongResult"), aname="_ConvertToLatLongResult", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","ConvertToLatLongResponse")
            kw["aname"] = "_ConvertToLatLongResponse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._ConvertToLatLongResult = None
                    return
            Holder.__name__ = "ConvertToLatLongResponse_Holder"
            self.pyclass = Holder

    class GetBestMapView_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "GetBestMapView"
        def __init__(self, **kw):
            ns = ns2.GetBestMapView_Dec.schema
            TClist = [ns2.ArrayOfLocation_Def(pname=(ns,"locations"), aname="_locations", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"dataSourceName"), aname="_dataSourceName", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","GetBestMapView")
            kw["aname"] = "_GetBestMapView"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._locations = None
                    self._dataSourceName = None
                    return
            Holder.__name__ = "GetBestMapView_Holder"
            self.pyclass = Holder

    class GetBestMapViewResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "GetBestMapViewResponse"
        def __init__(self, **kw):
            ns = ns2.GetBestMapViewResponse_Dec.schema
            TClist = [ns2.MapViewRepresentations_Def(pname=(ns,"GetBestMapViewResult"), aname="_GetBestMapViewResult", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","GetBestMapViewResponse")
            kw["aname"] = "_GetBestMapViewResponse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._GetBestMapViewResult = None
                    return
            Holder.__name__ = "GetBestMapViewResponse_Holder"
            self.pyclass = Holder

    class GetLineDriveMap_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "GetLineDriveMap"
        def __init__(self, **kw):
            ns = ns2.GetLineDriveMap_Dec.schema
            TClist = [ns2.LineDriveMapSpecification_Def(pname=(ns,"specification"), aname="_specification", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","GetLineDriveMap")
            kw["aname"] = "_GetLineDriveMap"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._specification = None
                    return
            Holder.__name__ = "GetLineDriveMap_Holder"
            self.pyclass = Holder

    class GetLineDriveMapResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        schema = "http://s.mappoint.net/mappoint-30/"
        literal = "GetLineDriveMapResponse"
        def __init__(self, **kw):
            ns = ns2.GetLineDriveMapResponse_Dec.schema
            TClist = [ns2.ArrayOfLineDriveMapImage_Def(pname=(ns,"GetLineDriveMapResult"), aname="_GetLineDriveMapResult", minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://s.mappoint.net/mappoint-30/","GetLineDriveMapResponse")
            kw["aname"] = "_GetLineDriveMapResponse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, inorder=0, **kw)
            class Holder:
                __metaclass__ = pyclass_type
                typecode = self
                def __init__(self):
                    # pyclass
                    self._GetLineDriveMapResult = None
                    return
            Holder.__name__ = "GetLineDriveMapResponse_Holder"
            self.pyclass = Holder

# end class ns2 (tns: http://s.mappoint.net/mappoint-30/)
