diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..3129a9a --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +*.pyc +build +dist diff --git a/MANIFEST.in b/MANIFEST.in new file mode 100644 index 0000000..0598ea9 --- /dev/null +++ b/MANIFEST.in @@ -0,0 +1,2 @@ +include README.md +recursive-include sample * diff --git a/README.md b/README.md index b8d9bc7..4d063cb 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,16 @@ -pyvomomi -======== +pyVmomi is a Python SDK for the VMware vSphere API that allows you to +manipulate ESX, ESXi, and vCenter using scripts. + +To get started, check out the examples in `sample/poweronvm.py` and +`sample/getallvms.py`. + +You can install this as a package. Just run `python setup.py bdist_egg` +and then use `pip` or `easy_install` to deploy it on your system. + +There are other bindings of this API in other languages. See: + +* **vijava** (Java): http://vijava.sourceforge.net/ +* **rbvmomi** (Ruby): https://github.com/vmware/rbvmomi +* **vSphere SDK for Perl** (non-free): https://my.vmware.com/group/vmware/details?downloadGroup=VSP510-SDKPERL-510&productId=285 + +Have fun! diff --git a/pyVim/__init__.py b/pyVim/__init__.py new file mode 100644 index 0000000..0688759 --- /dev/null +++ b/pyVim/__init__.py @@ -0,0 +1,12 @@ +## @file pyVim/__init__.py +## @brief A client-side Python API that wraps pyVmomi. +## +## + +## +## @mainpage +## +## A client-side Python API that wraps pyVmomi. +## +## + diff --git a/pyVim/connect.py b/pyVim/connect.py new file mode 100644 index 0000000..c6b3499 --- /dev/null +++ b/pyVim/connect.py @@ -0,0 +1,626 @@ +# VMware vSphere Python SDK +# Copyright (c) 2008-2013 VMware, Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +## @file connect.py +## @brief Connect to a VMOMI ServiceInstance. +## +## Detailed description (for Doxygen goes here) + +""" +Connect to a VMOMI ServiceInstance. + +Detailed description (for [e]pydoc goes here). +""" + +import sys +import threading +import thread +import types +import httplib +import socket +import time +import itertools +import re +from pyVmomi import vim, vmodl, SoapStubAdapter, SessionOrientedStub +from pyVmomi.VmomiSupport import nsMap, versionIdMap, versionMap, IsChildVersion +from pyVmomi.VmomiSupport import GetServiceVersions +try: + from xml.etree.ElementTree import ElementTree +except ImportError: + from elementtree.ElementTree import ElementTree +from xml.parsers.expat import ExpatError +import urllib + + +""" +Global regular expression for parsing host and port connection +See http://www.ietf.org/rfc/rfc3986.txt sec 3.2.2 +""" +_rx = re.compile(r"(^\[.+\]|[^:]+)(:\d+)?$") + +_si = None +""" +Global (thread-shared) ServiceInstance + +@todo: Get rid of me? +""" + + +class closing(object): + """ + Helper class for using closable objects in a 'with' statement, + similar to the one provided by contextlib. + """ + def __init__(self, obj): + self.obj = obj + def __enter__(self): + return self.obj + def __exit__(self, *exc_info): + self.obj.close() + + +class VimSessionOrientedStub(SessionOrientedStub): + '''A vim-specific SessionOrientedStub. See the SessionOrientedStub class + in pyVmomi/SoapAdapter.py for more information.''' + + # The set of exceptions that should trigger a relogin by the session stub. + SESSION_EXCEPTIONS = ( + vim.fault.NotAuthenticated, + ) + + @staticmethod + def makeUserLoginMethod(username, password, locale=None): + '''Return a function that will call the vim.SessionManager.Login() method + with the given parameters. The result of this function can be passed as + the "loginMethod" to a SessionOrientedStub constructor.''' + def _doLogin(soapStub): + si = vim.ServiceInstance("ServiceInstance", soapStub) + sm = si.content.sessionManager + if not sm.currentSession: + si.content.sessionManager.Login(username, password, locale) + + return _doLogin + + @staticmethod + def makeExtensionLoginMethod(extensionKey): + '''Return a function that will call the vim.SessionManager.Login() method + with the given parameters. The result of this function can be passed as + the "loginMethod" to a SessionOrientedStub constructor.''' + def _doLogin(soapStub): + si = vim.ServiceInstance("ServiceInstance", soapStub) + sm = si.content.sessionManager + if not sm.currentSession: + si.content.sessionManager.LoginExtensionByCertificate(extensionKey) + + return _doLogin + + @staticmethod + def makeCertHokTokenLoginMethod(stsUrl, stsCert=None): + '''Return a function that will call the vim.SessionManager.LoginByToken() + after obtaining a HoK SAML token from the STS. The result of this function + can be passed as the "loginMethod" to a SessionOrientedStub constructor. + + @param stsUrl: URL of the SAML Token issuing service. (i.e. SSO server). + @param stsCert: public key of the STS service. + ''' + assert(stsUrl) + + def _doLogin(soapStub): + import sso + cert = soapStub.schemeArgs['cert_file'] + key = soapStub.schemeArgs['key_file'] + authenticator = sso.SsoAuthenticator(sts_url=stsUrl, + sts_cert=stsCert) + + samlAssertion = authenticator.get_hok_saml_assertion(cert,key) + + + def _requestModifier(request): + return sso.add_saml_context(request, samlAssertion, key) + + si = vim.ServiceInstance("ServiceInstance", soapStub) + sm = si.content.sessionManager + if not sm.currentSession: + with soapStub.requestModifier(_requestModifier): + try: + soapStub.samlToken = samlAssertion + si.content.sessionManager.LoginByToken() + finally: + soapStub.samlToken = None + + return _doLogin + + @staticmethod + def makeCredBearerTokenLoginMethod(username, + password, + stsUrl, + stsCert=None): + '''Return a function that will call the vim.SessionManager.LoginByToken() + after obtaining a Bearer token from the STS. The result of this function + can be passed as the "loginMethod" to a SessionOrientedStub constructor. + + @param username: username of the user/service registered with STS. + @param password: password of the user/service registered with STS. + @param stsUrl: URL of the SAML Token issueing service. (i.e. SSO server). + @param stsCert: public key of the STS service. + ''' + assert(username) + assert(password) + assert(stsUrl) + + def _doLogin(soapStub): + import sso + cert = soapStub.schemeArgs['cert_file'] + key = soapStub.schemeArgs['key_file'] + authenticator = sso.SsoAuthenticator(sts_url=stsUrl, + sts_cert=stsCert) + samlAssertion = authenticator.get_bearer_saml_assertion(username, + password, + cert, + key) + si = vim.ServiceInstance("ServiceInstance", soapStub) + sm = si.content.sessionManager + if not sm.currentSession: + try: + soapStub.samlToken = samlAssertion + si.content.sessionManager.LoginByToken() + finally: + soapStub.samlToken = None + + return _doLogin + + +def Connect(host='localhost', port=443, user='root', pwd='', + service="hostd", adapter="SOAP", namespace=None, path="/sdk", + version=None, keyFile=None, certFile=None): + """ + Connect to the specified server, login and return the service + instance object. + + Throws any exception back to caller. The service instance object is + also saved in the library for easy access. + + Clients should modify the service parameter only when connecting to + a VMOMI server other than hostd/vpxd. For both of the latter, the + default value is fine. + + @param host: Which host to connect to. + @type host: string + @param port: Port + @type port: int + @param user: User + @type user: string + @param pwd: Password + @type pwd: string + @param service: Service + @type service: string + @param adapter: Adapter + @type adapter: string + @param namespace: Namespace *** Deprecated: Use version instead *** + @type namespace: string + @param path: Path + @type path: string + @param version: Version + @type version: string + @param keyFile: ssl key file path + @type keyFile: string + @param certFile: ssl cert file path + @type certFile: string + """ + try: + info = re.match(_rx, host) + if info is not None: + host = info.group(1) + if host[0] == '[': + host = info.group(1)[1:-1] + if info.group(2) is not None: + port = int(info.group(2)[1:]) + except ValueError, ve: + pass + + if namespace: + assert(version is None) + version = versionMap[namespace] + elif not version: + version="vim.version.version6" + si, stub = __Login(host, port, user, pwd, service, adapter, version, path, + keyFile, certFile) + SetSi(si) + + return si + + +def Disconnect(si): + """ + Disconnect (logout) service instance + @param si: Service instance (returned from Connect) + """ + # Logout + __Logout(si) + SetSi(None) + + +## Method that gets a local ticket for the specified user +def GetLocalTicket(si, user): + try: + sessionManager = si.content.sessionManager + except Exception, e: + if type(e).__name__ == 'ExpatError': + msg = 'Malformed response while querying for local ticket: "%s"' % e + raise vim.fault.HostConnectFault(msg=msg) + else: + msg = 'Failed to query for local ticket: "%s"' % e + raise vim.fault.HostConnectFault(msg=msg) + localTicket = sessionManager.AcquireLocalTicket(userName=user) + return (localTicket.userName, file(localTicket.passwordFilePath).read()) + + +## Private method that performs the actual Connect and returns a +## connected service instance object. + +def __Login(host, port, user, pwd, service, adapter, version, path, + keyFile, certFile): + """ + Private method that performs the actual Connect and returns a + connected service instance object. + + @param host: Which host to connect to. + @type host: string + @param port: Port + @type port: int + @param user: User + @type user: string + @param pwd: Password + @type pwd: string + @param service: Service + @type service: string + @param adapter: Adapter + @type adapter: string + @param version: Version + @type version: string + @param path: Path + @type path: string + @param keyFile: ssl key file path + @type keyFile: string + @param certFile: ssl cert file path + @type certFile: string + """ + + # XXX remove the adapter and service arguments once dependent code is fixed + if adapter != "SOAP": + raise ValueError(adapter) + + # Create the SOAP stub adapter + stub = SoapStubAdapter(host, port, version=version, path=path, + certKeyFile=keyFile, certFile=certFile) + + # Get Service instance + si = vim.ServiceInstance("ServiceInstance", stub) + try: + content = si.RetrieveContent() + except vmodl.MethodFault: + raise + except Exception, e: + raise vim.fault.HostConnectFault(msg=str(e)) + + # Get a ticket if we're connecting to localhost and password is not specified + if host == 'localhost' and not pwd: + try: + (user, pwd) = GetLocalTicket(si, user) + except: + pass # This is not supported against vCenter, and connecting + # with an empty password is fine in debug builds + + # Login + try: + x = content.sessionManager.Login(user, pwd, None) + except vim.fault.InvalidLogin: + raise + except Exception, e: + raise + return si, stub + + +## Private method that performs the actual Disonnect + +def __Logout(si): + """ + Disconnect (logout) service instance + @param si: Service instance (returned from Connect) + """ + try: + if si: + content = si.RetrieveContent() + content.sessionManager.Logout() + except Exception, e: + pass + + +## Get the saved service instance. + +def GetSi(): + """ Get the saved service instance. """ + return _si + + +## Set the saved service instance. + +def SetSi(si): + """ Set the saved service instance. """ + + global _si + _si = si + + +## Get the global saved stub + +def GetStub(): + """ Get the global saved stub. """ + si = GetSi() + if si: + return si._GetStub() + return None; + +## RAII-style class for managing connections + +class Connection(object): + def __init__(self, *args, **kwargs): + self.args = args + self.kwargs = kwargs + self.si = None + + def __enter__(self): + self.si = Connect(*self.args, **self.kwargs) + return self.si + + def __exit__(self, *exc_info): + if self.si: + Disconnect(self.si) + self.si = None + +class SmartConnection(object): + def __init__(self, *args, **kwargs): + self.args = args + self.kwargs = kwargs + self.si = None + + def __enter__(self): + self.si = SmartConnect(*self.args, **self.kwargs) + return self.si + + def __exit__(self, *exc_info): + if self.si: + Disconnect(self.si) + self.si = None + +## Private method that returns an ElementTree describing the API versions +## supported by the specified server. The result will be vimServiceVersions.xml +## if it exists, otherwise vimService.wsdl if it exists, otherwise None. + +def __GetServiceVersionDescription(protocol, server, port, path): + """ + Private method that returns an ElementTree describing the API versions + supported by the specified server. The result will be vimServiceVersions.xml + if it exists, otherwise vimService.wsdl if it exists, otherwise None. + + @param protocol: What protocol to use for the connection (e.g. https or http). + @type protocol: string + @param server: Which server to connect to. + @type server: string + @param port: Port + @type port: int + @param path: Path + @type path: string + """ + + tree = ElementTree() + + url = "%s://%s:%s/%s/vimServiceVersions.xml" % (protocol, server, port, path) + try: + with closing(urllib.urlopen(url)) as sock: + if sock.getcode() == 200: + tree.parse(sock) + return tree + except ExpatError: + pass + + url = "%s://%s:%s/%s/vimService.wsdl" % (protocol, server, port, path) + try: + with closing(urllib.urlopen(url)) as sock: + if sock.getcode() == 200: + tree.parse(sock) + return tree + except ExpatError: + pass + + return None + + +## Private method that returns true if the service version description document +## indicates that the desired version is supported + +def __VersionIsSupported(desiredVersion, serviceVersionDescription): + """ + Private method that returns true if the service version description document + indicates that the desired version is supported + + @param desiredVersion: The version we want to see if the server supports + (eg. vim.version.version2. + @type desiredVersion: string + @param serviceVersionDescription: An ElementTree for vimServiceVersions.xml + or vimService.wsdl. + @type serviceVersionDescription: ElementTree + """ + + root = serviceVersionDescription.getroot() + if root.tag == 'namespaces': + # serviceVersionDescription appears to be a vimServiceVersions.xml document + if root.get('version') <> '1.0': + raise RuntimeError('vimServiceVersions.xml has version %s,' \ + ' which is not understood' % (root.get('version'))) + desiredVersionId = versionIdMap[desiredVersion] + supportedVersion = None + for namespace in root.findall('namespace'): + versionId = namespace.findtext('version') + if versionId == desiredVersionId: + return True + else: + for versionId in namespace.findall('priorVersions/version'): + if versionId.text == desiredVersionId: + return True + else: + # serviceVersionDescription must be a vimService.wsdl document + wsdlNS = 'http://schemas.xmlsoap.org/wsdl/' + importElement = serviceVersionDescription.find('.//{%s}import' % wsdlNS) + supportedVersion = versionMap[importElement.get('namespace')[4:]] + if IsChildVersion(supportedVersion, desiredVersion): + return True + return False + + +## Private method that returns the most preferred API version supported by the +## specified server, + +def __FindSupportedVersion(protocol, server, port, path, preferredApiVersions): + """ + Private method that returns the most preferred API version supported by the + specified server, + + @param protocol: What protocol to use for the connection (e.g. https or http). + @type protocol: string + @param server: Which server to connect to. + @type server: string + @param port: Port + @type port: int + @param path: Path + @type path: string + @param preferredApiVersions: Acceptable API version(s) (e.g. vim.version.version3) + If a list of versions is specified the versions should + be ordered from most to least preferred. + @type preferredApiVersions: string or string list + """ + + serviceVersionDescription = __GetServiceVersionDescription(protocol, + server, + port, + path) + if serviceVersionDescription is None: + return None + + if not isinstance(preferredApiVersions, list): + preferredApiVersions = [ preferredApiVersions ] + + for desiredVersion in preferredApiVersions: + if __VersionIsSupported(desiredVersion, serviceVersionDescription): + return desiredVersion + return None + + +def SmartConnect(protocol='https', host='localhost', port=443, user='root', pwd='', + service="hostd", path="/sdk", + preferredApiVersions=None): + """ + Determine the most preferred API version supported by the specified server, + then connect to the specified server using that API version, login and return + the service instance object. + + Throws any exception back to caller. The service instance object is + also saved in the library for easy access. + + Clients should modify the service parameter only when connecting to + a VMOMI server other than hostd/vpxd. For both of the latter, the + default value is fine. + + @param protocol: What protocol to use for the connection (e.g. https or http). + @type protocol: string + @param host: Which host to connect to. + @type host: string + @param port: Port + @type port: int + @param user: User + @type user: string + @param pwd: Password + @type pwd: string + @param service: Service + @type service: string + @param path: Path + @type path: string + @param preferredApiVersions: Acceptable API version(s) (e.g. vim.version.version3) + If a list of versions is specified the versions should + be ordered from most to least preferred. If None is + specified, the list of versions support by pyVmomi will + be used. + @type preferredApiVersions: string or string list + """ + + if preferredApiVersions is None: + preferredApiVersions = GetServiceVersions('vim25') + + supportedVersion = __FindSupportedVersion(protocol, + host, + port, + path, + preferredApiVersions) + if supportedVersion is None: + raise Exception("%s:%s is not a VIM server" % (host, port)) + + portNumber = protocol == "http" and -int(port) or int(port) + + return Connect(host=host, + port=portNumber, + user=user, + pwd=pwd, + service=service, + adapter='SOAP', + version=supportedVersion, + path=path) + +def OpenUrlWithBasicAuth(url, user='root', pwd=''): + """ + Open the specified URL, using HTTP basic authentication to provide + the specified credentials to the server as part of the request. + Returns the response as a file-like object. + """ + import urllib2 + pwMgr = urllib2.HTTPPasswordMgrWithDefaultRealm() + pwMgr.add_password(None, url, user, pwd) + handler = urllib2.HTTPBasicAuthHandler(pwMgr) + opener = urllib2.build_opener(handler) + return opener.open(url) + +def OpenPathWithStub(path, stub): + """ + Open the specified path using HTTP, using the host/port/protocol + associated with the specified stub. If the stub has a session cookie, + it is included with the HTTP request. Returns the response as a + file-like object. + """ + import httplib + import urllib2 + if not hasattr(stub, 'scheme'): + raise vmodl.fault.NotSupported() + elif stub.scheme == httplib.HTTPConnection: + protocol = 'http' + elif stub.scheme == httplib.HTTPSConnection: + protocol = 'https' + else: + raise vmodl.fault.NotSupported() + hostPort = stub.host + url = '%s://%s%s' % (protocol, hostPort, path) + request = urllib2.Request(url) + if stub.cookie: + request.add_header('Cookie', stub.cookie) + return urllib2.urlopen(request) + diff --git a/pyVmomi/Cache.py b/pyVmomi/Cache.py new file mode 100644 index 0000000..592cce5 --- /dev/null +++ b/pyVmomi/Cache.py @@ -0,0 +1,42 @@ +# VMware vSphere Python SDK +# Copyright (c) 2008-2013 VMware, Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +This module implements the cache decorator +""" +__author__ = "VMware, Inc." + +def Cache(fn): + """ Function cache decorator """ + def fnCache(*args, **kwargs): + """ Cache function """ + key = (args and tuple(args) or None, + kwargs and frozenset(kwargs.items()) or None) + if key not in fn.__cached__: + fn.__cached__[key] = cache = fn(*args, **kwargs) + else: + cache = fn.__cached__[key] + return cache + + def ResetCache(): + """ Reset cache """ + fn.__cached__ = {} + + setattr(fn, "__cached__", {}) + setattr(fn, "__resetcache__", ResetCache) + fnCache.__name__ = fn.__name__ + fnCache.__doc__ = fn.__doc__ + fnCache.__dict__.update(fn.__dict__) + return fnCache diff --git a/pyVmomi/CoreTypes.py b/pyVmomi/CoreTypes.py new file mode 100644 index 0000000..530a436 --- /dev/null +++ b/pyVmomi/CoreTypes.py @@ -0,0 +1,79 @@ +# VMware vSphere Python SDK +# Copyright (c) 2008-2013 VMware, Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# ******* WARNING - AUTO GENERATED CODE - DO NOT EDIT ******* +from VmomiSupport import CreateDataType, CreateManagedType, CreateEnumType, AddVersion, AddVersionParent, F_LINK, F_LINKABLE, F_OPTIONAL + +AddVersion("vmodl.query.version.version1", "", "", 0, "vim25") +AddVersion("vmodl.query.version.version2", "", "", 0, "vim25") +AddVersion("vmodl.query.version.version3", "", "", 0, "vim25") +AddVersion("vmodl.version.version0", "", "", 0, "vim25") +AddVersion("vmodl.version.version1", "", "", 0, "vim25") +AddVersionParent("vmodl.query.version.version1", "vmodl.query.version.version1") +AddVersionParent("vmodl.query.version.version1", "vmodl.version.version0") +AddVersionParent("vmodl.query.version.version2", "vmodl.query.version.version1") +AddVersionParent("vmodl.query.version.version2", "vmodl.query.version.version2") +AddVersionParent("vmodl.query.version.version2", "vmodl.version.version0") +AddVersionParent("vmodl.query.version.version2", "vmodl.version.version1") +AddVersionParent("vmodl.query.version.version3", "vmodl.query.version.version1") +AddVersionParent("vmodl.query.version.version3", "vmodl.query.version.version2") +AddVersionParent("vmodl.query.version.version3", "vmodl.query.version.version3") +AddVersionParent("vmodl.query.version.version3", "vmodl.version.version0") +AddVersionParent("vmodl.query.version.version3", "vmodl.version.version1") +AddVersionParent("vmodl.version.version0", "vmodl.version.version0") +AddVersionParent("vmodl.version.version1", "vmodl.version.version0") +AddVersionParent("vmodl.version.version1", "vmodl.version.version1") + +CreateDataType("vmodl.DynamicArray", "DynamicArray", "vmodl.DataObject", "vmodl.version.version0", [("dynamicType", "string", "vmodl.version.version0", F_OPTIONAL), ("val", "anyType[]", "vmodl.version.version0", 0)]) +CreateDataType("vmodl.DynamicData", "DynamicData", "vmodl.DataObject", "vmodl.version.version0", [("dynamicType", "string", "vmodl.version.version0", F_OPTIONAL), ("dynamicProperty", "vmodl.DynamicProperty[]", "vmodl.version.version0", F_OPTIONAL)]) +CreateDataType("vmodl.DynamicProperty", "DynamicProperty", "vmodl.DataObject", "vmodl.version.version0", [("name", "vmodl.PropertyPath", "vmodl.version.version0", 0), ("val", "anyType", "vmodl.version.version0", 0)]) +CreateDataType("vmodl.KeyAnyValue", "KeyAnyValue", "vmodl.DynamicData", "vmodl.version.version1", [("key", "string", "vmodl.version.version1", 0), ("value", "anyType", "vmodl.version.version1", 0)]) +CreateDataType("vmodl.LocalizableMessage", "LocalizableMessage", "vmodl.DynamicData", "vmodl.version.version1", [("key", "string", "vmodl.version.version1", 0), ("arg", "vmodl.KeyAnyValue[]", "vmodl.version.version1", F_OPTIONAL), ("message", "string", "vmodl.version.version1", F_OPTIONAL)]) +CreateDataType("vmodl.fault.HostCommunication", "HostCommunication", "vmodl.RuntimeFault", "vmodl.version.version0", None) +CreateDataType("vmodl.fault.HostNotConnected", "HostNotConnected", "vmodl.fault.HostCommunication", "vmodl.version.version0", None) +CreateDataType("vmodl.fault.HostNotReachable", "HostNotReachable", "vmodl.fault.HostCommunication", "vmodl.version.version0", None) +CreateDataType("vmodl.fault.InvalidArgument", "InvalidArgument", "vmodl.RuntimeFault", "vmodl.version.version0", [("invalidProperty", "vmodl.PropertyPath", "vmodl.version.version0", F_OPTIONAL)]) +CreateDataType("vmodl.fault.InvalidRequest", "InvalidRequest", "vmodl.RuntimeFault", "vmodl.version.version0", None) +CreateDataType("vmodl.fault.InvalidType", "InvalidType", "vmodl.fault.InvalidRequest", "vmodl.version.version0", [("argument", "vmodl.PropertyPath", "vmodl.version.version0", F_OPTIONAL)]) +CreateDataType("vmodl.fault.ManagedObjectNotFound", "ManagedObjectNotFound", "vmodl.RuntimeFault", "vmodl.version.version0", [("obj", "vmodl.ManagedObject", "vmodl.version.version0", 0)]) +CreateDataType("vmodl.fault.MethodNotFound", "MethodNotFound", "vmodl.fault.InvalidRequest", "vmodl.version.version0", [("receiver", "vmodl.ManagedObject", "vmodl.version.version0", 0), ("method", "string", "vmodl.version.version0", 0)]) +CreateDataType("vmodl.fault.NotEnoughLicenses", "NotEnoughLicenses", "vmodl.RuntimeFault", "vmodl.version.version0", None) +CreateDataType("vmodl.fault.NotImplemented", "NotImplemented", "vmodl.RuntimeFault", "vmodl.version.version0", None) +CreateDataType("vmodl.fault.NotSupported", "NotSupported", "vmodl.RuntimeFault", "vmodl.version.version0", None) +CreateDataType("vmodl.fault.RequestCanceled", "RequestCanceled", "vmodl.RuntimeFault", "vmodl.version.version0", None) +CreateDataType("vmodl.fault.SecurityError", "SecurityError", "vmodl.RuntimeFault", "vmodl.version.version0", None) +CreateDataType("vmodl.fault.SystemError", "SystemError", "vmodl.RuntimeFault", "vmodl.version.version0", [("reason", "string", "vmodl.version.version0", 0)]) +CreateDataType("vmodl.fault.UnexpectedFault", "UnexpectedFault", "vmodl.RuntimeFault", "vmodl.version.version0", [("faultName", "vmodl.TypeName", "vmodl.version.version0", 0), ("fault", "vmodl.MethodFault", "vmodl.version.version0", F_OPTIONAL)]) +CreateDataType("vmodl.query.InvalidCollectorVersion", "InvalidCollectorVersion", "vmodl.MethodFault", "vmodl.query.version.version1", None) +CreateDataType("vmodl.query.InvalidProperty", "InvalidProperty", "vmodl.MethodFault", "vmodl.query.version.version1", [("name", "vmodl.PropertyPath", "vmodl.query.version.version1", 0)]) +CreateManagedType("vmodl.query.PropertyCollector", "PropertyCollector", "vmodl.ManagedObject", "vmodl.query.version.version1", [("filter", "vmodl.query.PropertyCollector.Filter[]", "vmodl.query.version.version1", F_OPTIONAL, "System.View")], [("createFilter", "CreateFilter", "vmodl.query.version.version1", (("spec", "vmodl.query.PropertyCollector.FilterSpec", "vmodl.query.version.version1", 0, None),("partialUpdates", "boolean", "vmodl.query.version.version1", 0, None),), (0, "vmodl.query.PropertyCollector.Filter", "vmodl.query.PropertyCollector.Filter"), "System.View", ["vmodl.query.InvalidProperty", ]), ("retrieveContents", "RetrieveProperties", "vmodl.query.version.version1", (("specSet", "vmodl.query.PropertyCollector.FilterSpec[]", "vmodl.query.version.version1", 0, None),), (F_OPTIONAL, "vmodl.query.PropertyCollector.ObjectContent[]", "vmodl.query.PropertyCollector.ObjectContent[]"), "System.Anonymous", ["vmodl.query.InvalidProperty", ]), ("checkForUpdates", "CheckForUpdates", "vmodl.query.version.version1", (("version", "string", "vmodl.query.version.version1", F_OPTIONAL, None),), (F_OPTIONAL, "vmodl.query.PropertyCollector.UpdateSet", "vmodl.query.PropertyCollector.UpdateSet"), "System.View", ["vmodl.query.InvalidCollectorVersion", ]), ("waitForUpdates", "WaitForUpdates", "vmodl.query.version.version1", (("version", "string", "vmodl.query.version.version1", F_OPTIONAL, None),), (0, "vmodl.query.PropertyCollector.UpdateSet", "vmodl.query.PropertyCollector.UpdateSet"), "System.View", ["vmodl.query.InvalidCollectorVersion", ]), ("cancelWaitForUpdates", "CancelWaitForUpdates", "vmodl.query.version.version1", (), (0, "void", "void"), "System.View", None), ("waitForUpdatesEx", "WaitForUpdatesEx", "vmodl.query.version.version3", (("version", "string", "vmodl.query.version.version3", F_OPTIONAL, None),("options", "vmodl.query.PropertyCollector.WaitOptions", "vmodl.query.version.version3", F_OPTIONAL, None),), (F_OPTIONAL, "vmodl.query.PropertyCollector.UpdateSet", "vmodl.query.PropertyCollector.UpdateSet"), "System.View", ["vmodl.query.InvalidCollectorVersion", ]), ("retrievePropertiesEx", "RetrievePropertiesEx", "vmodl.query.version.version3", (("specSet", "vmodl.query.PropertyCollector.FilterSpec[]", "vmodl.query.version.version3", 0, None),("options", "vmodl.query.PropertyCollector.RetrieveOptions", "vmodl.query.version.version3", 0, None),), (F_OPTIONAL, "vmodl.query.PropertyCollector.RetrieveResult", "vmodl.query.PropertyCollector.RetrieveResult"), "System.Anonymous", ["vmodl.query.InvalidProperty", ]), ("continueRetrievePropertiesEx", "ContinueRetrievePropertiesEx", "vmodl.query.version.version3", (("token", "string", "vmodl.query.version.version3", 0, None),), (0, "vmodl.query.PropertyCollector.RetrieveResult", "vmodl.query.PropertyCollector.RetrieveResult"), "System.Anonymous", ["vmodl.query.InvalidProperty", ]), ("cancelRetrievePropertiesEx", "CancelRetrievePropertiesEx", "vmodl.query.version.version3", (("token", "string", "vmodl.query.version.version3", 0, None),), (0, "void", "void"), "System.Anonymous", ["vmodl.query.InvalidProperty", ]), ("createPropertyCollector", "CreatePropertyCollector", "vmodl.query.version.version3", (), (0, "vmodl.query.PropertyCollector", "vmodl.query.PropertyCollector"), "System.View", None), ("destroy", "DestroyPropertyCollector", "vmodl.query.version.version3", (), (0, "void", "void"), "System.View", None)]) +CreateDataType("vmodl.query.PropertyCollector.FilterSpec", "PropertyFilterSpec", "vmodl.DynamicData", "vmodl.query.version.version1", [("propSet", "vmodl.query.PropertyCollector.PropertySpec[]", "vmodl.query.version.version1", 0), ("objectSet", "vmodl.query.PropertyCollector.ObjectSpec[]", "vmodl.query.version.version1", 0), ("reportMissingObjectsInResults", "boolean", "vmodl.query.version.version3", F_OPTIONAL)]) +CreateDataType("vmodl.query.PropertyCollector.PropertySpec", "PropertySpec", "vmodl.DynamicData", "vmodl.query.version.version1", [("type", "vmodl.TypeName", "vmodl.query.version.version1", 0), ("all", "boolean", "vmodl.query.version.version1", F_OPTIONAL), ("pathSet", "vmodl.PropertyPath[]", "vmodl.query.version.version1", F_OPTIONAL)]) +CreateDataType("vmodl.query.PropertyCollector.ObjectSpec", "ObjectSpec", "vmodl.DynamicData", "vmodl.query.version.version1", [("obj", "vmodl.ManagedObject", "vmodl.query.version.version1", 0), ("skip", "boolean", "vmodl.query.version.version1", F_OPTIONAL), ("selectSet", "vmodl.query.PropertyCollector.SelectionSpec[]", "vmodl.query.version.version1", F_OPTIONAL)]) +CreateDataType("vmodl.query.PropertyCollector.SelectionSpec", "SelectionSpec", "vmodl.DynamicData", "vmodl.query.version.version1", [("name", "string", "vmodl.query.version.version1", F_OPTIONAL)]) +CreateDataType("vmodl.query.PropertyCollector.TraversalSpec", "TraversalSpec", "vmodl.query.PropertyCollector.SelectionSpec", "vmodl.query.version.version1", [("type", "vmodl.TypeName", "vmodl.query.version.version1", 0), ("path", "vmodl.PropertyPath", "vmodl.query.version.version1", 0), ("skip", "boolean", "vmodl.query.version.version1", F_OPTIONAL), ("selectSet", "vmodl.query.PropertyCollector.SelectionSpec[]", "vmodl.query.version.version1", F_OPTIONAL)]) +CreateManagedType("vmodl.query.PropertyCollector.Filter", "PropertyFilter", "vmodl.ManagedObject", "vmodl.query.version.version1", [("spec", "vmodl.query.PropertyCollector.FilterSpec", "vmodl.query.version.version1", 0, None), ("partialUpdates", "boolean", "vmodl.query.version.version1", 0, None)], [("destroy", "DestroyPropertyFilter", "vmodl.query.version.version1", (), (0, "void", "void"), None, None)]) +CreateDataType("vmodl.query.PropertyCollector.ObjectContent", "ObjectContent", "vmodl.DynamicData", "vmodl.query.version.version1", [("obj", "vmodl.ManagedObject", "vmodl.query.version.version1", 0), ("propSet", "vmodl.DynamicProperty[]", "vmodl.query.version.version1", F_OPTIONAL), ("missingSet", "vmodl.query.PropertyCollector.MissingProperty[]", "vmodl.query.version.version1", F_OPTIONAL)]) +CreateDataType("vmodl.query.PropertyCollector.UpdateSet", "UpdateSet", "vmodl.DynamicData", "vmodl.query.version.version1", [("version", "string", "vmodl.query.version.version1", 0), ("filterSet", "vmodl.query.PropertyCollector.FilterUpdate[]", "vmodl.query.version.version1", F_OPTIONAL), ("truncated", "boolean", "vmodl.query.version.version3", F_OPTIONAL)]) +CreateDataType("vmodl.query.PropertyCollector.FilterUpdate", "PropertyFilterUpdate", "vmodl.DynamicData", "vmodl.query.version.version1", [("filter", "vmodl.query.PropertyCollector.Filter", "vmodl.query.version.version1", 0), ("objectSet", "vmodl.query.PropertyCollector.ObjectUpdate[]", "vmodl.query.version.version1", F_OPTIONAL), ("missingSet", "vmodl.query.PropertyCollector.MissingObject[]", "vmodl.query.version.version1", F_OPTIONAL)]) +CreateDataType("vmodl.query.PropertyCollector.ObjectUpdate", "ObjectUpdate", "vmodl.DynamicData", "vmodl.query.version.version1", [("kind", "vmodl.query.PropertyCollector.ObjectUpdate.Kind", "vmodl.query.version.version1", 0), ("obj", "vmodl.ManagedObject", "vmodl.query.version.version1", 0), ("changeSet", "vmodl.query.PropertyCollector.Change[]", "vmodl.query.version.version1", F_OPTIONAL), ("missingSet", "vmodl.query.PropertyCollector.MissingProperty[]", "vmodl.query.version.version1", F_OPTIONAL)]) +CreateEnumType("vmodl.query.PropertyCollector.ObjectUpdate.Kind", "ObjectUpdateKind", "vmodl.query.version.version1", ["modify", "enter", "leave"]) +CreateDataType("vmodl.query.PropertyCollector.Change", "PropertyChange", "vmodl.DynamicData", "vmodl.query.version.version1", [("name", "vmodl.PropertyPath", "vmodl.query.version.version1", 0), ("op", "vmodl.query.PropertyCollector.Change.Op", "vmodl.query.version.version1", 0), ("val", "anyType", "vmodl.query.version.version1", F_OPTIONAL)]) +CreateEnumType("vmodl.query.PropertyCollector.Change.Op", "PropertyChangeOp", "vmodl.query.version.version1", ["add", "remove", "assign", "indirectRemove"]) +CreateDataType("vmodl.query.PropertyCollector.MissingProperty", "MissingProperty", "vmodl.DynamicData", "vmodl.query.version.version1", [("path", "vmodl.PropertyPath", "vmodl.query.version.version1", 0), ("fault", "vmodl.MethodFault", "vmodl.query.version.version1", 0)]) +CreateDataType("vmodl.query.PropertyCollector.MissingObject", "MissingObject", "vmodl.DynamicData", "vmodl.query.version.version1", [("obj", "vmodl.ManagedObject", "vmodl.query.version.version1", 0), ("fault", "vmodl.MethodFault", "vmodl.query.version.version1", 0)]) +CreateDataType("vmodl.query.PropertyCollector.WaitOptions", "WaitOptions", "vmodl.DynamicData", "vmodl.query.version.version3", [("maxWaitSeconds", "int", "vmodl.query.version.version3", F_OPTIONAL), ("maxObjectUpdates", "int", "vmodl.query.version.version3", F_OPTIONAL)]) +CreateDataType("vmodl.query.PropertyCollector.RetrieveOptions", "RetrieveOptions", "vmodl.DynamicData", "vmodl.query.version.version3", [("maxObjects", "int", "vmodl.query.version.version3", F_OPTIONAL)]) +CreateDataType("vmodl.query.PropertyCollector.RetrieveResult", "RetrieveResult", "vmodl.DynamicData", "vmodl.query.version.version3", [("token", "string", "vmodl.query.version.version3", F_OPTIONAL), ("objects", "vmodl.query.PropertyCollector.ObjectContent[]", "vmodl.query.version.version3", 0)]) diff --git a/pyVmomi/Differ.py b/pyVmomi/Differ.py new file mode 100644 index 0000000..c693c98 --- /dev/null +++ b/pyVmomi/Differ.py @@ -0,0 +1,229 @@ +# VMware vSphere Python SDK +# Copyright (c) 2008-2013 VMware, Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +## Diff any two objects + +from pyVmomi import VmomiSupport, types +import itertools +import logging +from VmomiSupport import GetWsdlName, Type + +__Log__ = logging.getLogger('ObjDiffer') + +def LogIf(condition, message): + """Log a message if the condition is met""" + if condition: + __Log__.debug(message) + +def IsPrimitiveType(obj): + """See if the passed in type is a Primitive Type""" + return (isinstance(obj, types.bool) or isinstance(obj, types.byte) or + isinstance(obj, types.short) or isinstance(obj, types.int) or + isinstance(obj, types.double) or isinstance(obj, types.float) or + isinstance(obj, types.long) or isinstance(obj, types.str) or + isinstance(obj, unicode) or + isinstance(obj, types.PropertyPath) or + isinstance(obj, types.ManagedMethod) or + isinstance(obj, types.datetime) or + isinstance(obj, types.URI) or isinstance(obj, type)) + + +class Differ: + """Class for comparing two Objects""" + def __init__(self, looseMatch=False, ignoreArrayOrder=True): + self._looseMatch = looseMatch + self._ignoreArrayOrder = ignoreArrayOrder + + def DiffAnyObjects(self, oldObj, newObj, isObjLink=False): + """Diff any two Objects""" + if oldObj == newObj: + return True + if not oldObj or not newObj: + __Log__.debug('DiffAnyObjects: One of the objects is unset.') + return self._looseMatch + oldObjInstance = oldObj + newObjInstance = newObj + if isinstance(oldObj, list): + oldObjInstance = oldObj[0] + if isinstance(newObj, list): + newObjInstance = newObj[0] + # Need to see if it is a primitive type first since type information + # will not be available for them. + if (IsPrimitiveType(oldObj) and IsPrimitiveType(newObj) + and oldObj.__class__.__name__ == newObj.__class__.__name__): + if oldObj == newObj: + return True + elif oldObj == None or newObj == None: + __Log__.debug('DiffAnyObjects: One of the objects in None') + return False + oldType = Type(oldObjInstance) + newType = Type(newObjInstance) + if oldType != newType: + __Log__.debug('DiffAnyObjects: Types do not match %s != %s' % + (repr(GetWsdlName(oldObjInstance.__class__)), + repr(GetWsdlName(newObjInstance.__class__)))) + return False + elif isinstance(oldObj, list): + return self.DiffArrayObjects(oldObj, newObj, isObjLink) + elif isinstance(oldObjInstance, types.ManagedObject): + return (not oldObj and not newObj) or (oldObj and newObj + and oldObj._moId == newObj._moId) + elif isinstance(oldObjInstance, types.DataObject): + if isObjLink: + bMatch = oldObj.GetKey() == newObj.GetKey() + LogIf(not bMatch, 'DiffAnyObjects: Keys do not match %s != %s' + % (oldObj.GetKey(), newObj.GetKey())) + return bMatch + return self.DiffDataObjects(oldObj, newObj) + + else: + raise TypeError("Unknown type: "+repr(GetWsdlName(oldObj.__class__))) + + def DiffDoArrays(self, oldObj, newObj, isElementLinks): + """Diff two DataObject arrays""" + if len(oldObj) != len(newObj): + __Log__.debug('DiffDoArrays: Array lengths do not match %d != %d' + % (len(oldObj), len(newObj))) + return False + for i, j in itertools.izip(oldObj, newObj): + if isElementLinks: + if i.GetKey() != j.GetKey(): + __Log__.debug('DiffDoArrays: Keys do not match %s != %s' + % (i.GetKey(), j.GetKey())) + return False + else: + if not self.DiffDataObjects(i, j): + __Log__.debug( + 'DiffDoArrays: one of the elements do not match') + return False + return True + + def DiffAnyArrays(self, oldObj, newObj, isElementLinks): + """Diff two arrays which contain Any objects""" + if len(oldObj) != len(newObj): + __Log__.debug('DiffAnyArrays: Array lengths do not match. %d != %d' + % (len(oldObj), len(newObj))) + return False + for i, j in itertools.izip(oldObj, newObj): + if not self.DiffAnyObjects(i, j, isElementLinks): + __Log__.debug('DiffAnyArrays: One of the elements do not match.') + return False + return True + + def DiffPrimitiveArrays(self, oldObj, newObj): + """Diff two primitive arrays""" + if len(oldObj) != len(newObj): + __Log__.debug('DiffDoArrays: Array lengths do not match %d != %d' + % (len(oldObj), len(newObj))) + return False + match = True + if self._ignoreArrayOrder: + oldSet = oldObj and frozenset(oldObj) or frozenset() + newSet = newObj and frozenset(newObj) or frozenset() + match = (oldSet == newSet) + else: + for i, j in itertools.izip(oldObj, newObj): + if i != j: + match = False + break + if not match: + __Log__.debug( + 'DiffPrimitiveArrays: One of the elements do not match.') + return False + return True + + + def DiffArrayObjects(self, oldObj, newObj, isElementLinks=False): + """Method which deligates the diffing of arrays based on the type""" + if oldObj == newObj: + return True + if not oldObj or not newObj: + return False + if len(oldObj) != len(newObj): + __Log__.debug('DiffArrayObjects: Array lengths do not match %d != %d' + % (len(oldObj), len(newObj))) + return False + firstObj = oldObj[0] + if IsPrimitiveType(firstObj): + return self.DiffPrimitiveArrays(oldObj, newObj) + elif isinstance(firstObj, types.ManagedObject): + return self.DiffAnyArrays(oldObj, newObj, isElementLinks) + elif isinstance(firstObj, types.DataObject): + return self.DiffDoArrays(oldObj, newObj, isElementLinks) + else: + raise TypeError("Unknown type: %s" % oldObj.__class__) + + + def DiffDataObjects(self, oldObj, newObj): + """Diff Data Objects""" + if oldObj == newObj: + return True + if not oldObj or not newObj: + __Log__.debug('DiffDataObjects: One of the objects in None') + return False + oldType = Type(oldObj) + newType = Type(newObj) + if oldType != newType: + __Log__.debug( + 'DiffDataObjects: Types do not match for dataobjects. %s != %s' + % (oldObj._wsdlName, newObj._wsdlName)) + return False + for prop in oldObj._GetPropertyList(): + oldProp = getattr(oldObj, prop.name) + newProp = getattr(newObj, prop.name) + propType = oldObj._GetPropertyInfo(prop.name).type + if not oldProp and not newProp: + continue + elif ((prop.flags & VmomiSupport.F_OPTIONAL) and + self._looseMatch and (not newProp or not oldProp)): + continue + elif not oldProp or not newProp: + __Log__.debug( + 'DiffDataObjects: One of the objects has property %s unset' + % prop.name) + return False + + bMatch = True + if IsPrimitiveType(oldProp): + bMatch = oldProp == newProp + elif isinstance(oldProp, types.ManagedObject): + bMatch = self.DiffAnyObjects(oldProp, newProp, prop.flags + & VmomiSupport.F_LINK) + elif isinstance(oldProp, types.DataObject): + if prop.flags & VmomiSupport.F_LINK: + bMatch = oldObj.GetKey() == newObj.GetKey() + LogIf(not bMatch, 'DiffDataObjects: Key match failed %s != %s' + % (oldObj.GetKey(), newObj.GetKey())) + else: + bMatch = self.DiffAnyObjects(oldProp, newProp, prop.flags + & VmomiSupport.F_LINK) + elif isinstance(oldProp, list): + bMatch = self.DiffArrayObjects(oldProp, newProp, prop.flags + & VmomiSupport.F_LINK) + else: + raise TypeError("Unknown type: "+repr(propType)) + + if not bMatch: + __Log__.debug('DiffDataObjects: Objects differ in property %s' + % prop.name) + return False + return True + + +def DiffAnys(obj1, obj2, looseMatch=False, ignoreArrayOrder=True): + """Diff any two objects. Objects can either be primitive type + or DataObjects""" + differ = Differ(looseMatch = looseMatch, ignoreArrayOrder = ignoreArrayOrder) + return differ.DiffAnyObjects(obj1, obj2) diff --git a/pyVmomi/DynamicTypeManagerHelper.py b/pyVmomi/DynamicTypeManagerHelper.py new file mode 100644 index 0000000..10ef64e --- /dev/null +++ b/pyVmomi/DynamicTypeManagerHelper.py @@ -0,0 +1,290 @@ +#!/usr/bin/env python + +# VMware vSphere Python SDK +# Copyright (c) 2008-2013 VMware, Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +This module is a converter from dynamic type to pyVmomi type +""" +__author__ = "VMware, Inc." + +from pyVmomi import VmomiSupport, vmodl +from Cache import Cache + +## Dynamic type importer +# +class DynamicTypeImporter: + """ Dynamic type importer """ + + ## Constructor + # + # @param stub Server stub + def __init__(self, stub, hostSystem=None): + self.stub = stub + self.hostSystem = hostSystem + + ## Get dynamic type manager + # + # @return moRef to dynamic type manager + @Cache + def GetTypeManager(self): + """ Get dynamic type manager """ + dynTypeMgr = None + if self.hostSystem: + try: + dynTypeMgr = self.hostSystem.RetrieveDynamicTypeManager() + except vmodl.fault.MethodNotFound, err: + pass + + if not dynTypeMgr: + # Older host not support RetrieveDynamicTypeManager + cmdlineTypesMoId = "ha-dynamic-type-manager" + dynTypeMgr = vmodl.reflect.DynamicTypeManager(cmdlineTypesMoId, + self.stub) + return dynTypeMgr + + ## Import dynamic types + # + # @param prefix Only types with the specified prefix are imported + # @return dynamic types + @Cache + def ImportTypes(self, prefix=''): + """ Build dynamic types """ + # Use QueryTypeInfo to get all types + dynTypeMgr = self.GetTypeManager() + filterSpec = None + if prefix != '': + filterSpec = vmodl.reflect.DynamicTypeManager.TypeFilterSpec( + typeSubstr=prefix) + allTypes = dynTypeMgr.QueryTypeInfo(filterSpec) + + ## Convert dynamic types to pyVmomi types + # + DynamicTypeConstructor().CreateTypes(allTypes) + return allTypes + + +## Construct pyVmomi types from dynamic types definition +# +class DynamicTypeConstructor: + """ Dynamic type constructor """ + + _mapFlags = { "optional": VmomiSupport.F_OPTIONAL, + "linkable": VmomiSupport.F_LINKABLE, + "link": VmomiSupport.F_LINK } + + ## Constructor + # + def __init__(self): + """ Constructor """ + pass + + ## Create pyVmomi types from vmodl.reflect.DynamicTypeManager.AllTypeInfo + # + # @param allTypes vmodl.reflect.DynamicTypeManager.AllTypeInfo + def CreateTypes(self, allTypes): + """ + Create pyVmomi types from vmodl.reflect.DynamicTypeManager.AllTypeInfo + """ + enumTypes, dataTypes, managedTypes = self._ConvertAllTypes(allTypes) + self._CreateAllTypes(enumTypes, dataTypes, managedTypes) + + ## Convert all dynamic types to pyVmomi type definitions + # + # @param allTypes vmodl.reflect.DynamicTypeManager.AllTypeInfo + # @return a tuple of (enumTypes, dataTypes, managedTypes) + def _ConvertAllTypes(self, allTypes): + """ Convert all dynamic types to pyVmomi type definitions """ + # Generate lists good for VmomiSupport.CreateXYZType + enumTypes = self._Filter(self._ConvertEnumType, allTypes.enumTypeInfo) + dataTypes = self._Filter(self._ConvertDataType, allTypes.dataTypeInfo) + managedTypes = self._Filter(self._ConvertManagedType, + allTypes.managedTypeInfo) + retAllTypes = (enumTypes, dataTypes, managedTypes) + return retAllTypes + + ## Create pyVmomi types from pyVmomi type definitions + # + # @param enumTypes pyVmomi enum type definitions + # @param dataTypes pyVmomi data type definitions + # @param managedTypes pyVmomi managed type definitions + def _CreateAllTypes(self, enumTypes, dataTypes, managedTypes): + """ Create pyVmomi types from pyVmomi type definitions """ + + # Create versions + for typeInfo in managedTypes: + name = typeInfo[0] + version = typeInfo[3] + VmomiSupport.AddVersion(version, '', '1.0', 0, name) + VmomiSupport.AddVersionParent(version, 'vmodl.version.version0') + VmomiSupport.AddVersionParent(version, 'vmodl.version.version1') + VmomiSupport.AddVersionParent(version, version) + + # Create partial types + for fn, infos in (VmomiSupport.CreateEnumType, enumTypes), \ + (VmomiSupport.CreateDataType, dataTypes), \ + (VmomiSupport.CreateManagedType, managedTypes): + for typeInfo in infos: + try: + fn(*typeInfo) + except Exception, err: + #Ignore errors due to duplicate importing + pass + + def _ConvertAnnotations(self, annotations): + """ Convert annotations to pyVmomi flags """ + flags = 0 + if annotations: + for annotation in annotations: + flags |= self._mapFlags.get(annotation.name, 0) + return flags + + @staticmethod + def _Filter(fn, types): + """ Call fn for each non null element in types. Similiar to filter """ + if types: + return [fn(prop) for prop in types if prop is not None] + else: + return [] + + def _ConvertParamType(self, paramType): + """ + Convert vmodl.reflect.DynamicTypeManager.ParamTypeInfo to pyVmomi param + definition + """ + if paramType: + name = paramType.name + version = paramType.version + aType = paramType.type + flags = self._ConvertAnnotations(paramType.annotation) + privId = paramType.privId + param = (name, aType, version, flags, privId) + else: + param = None + return param + + def _ConvertMethodType(self, methodType): + """ + Convert vmodl.reflect.DynamicTypeManager.MethodTypeInfo to pyVmomi method + definition + """ + if methodType: + name = methodType.name + wsdlName = methodType.wsdlName + version = methodType.version + params = self._Filter(self._ConvertParamType, methodType.paramTypeInfo) + privId = methodType.privId + faults = methodType.fault + + # Figure out reture info + if methodType.returnTypeInfo: + returnTypeInfo = methodType.returnTypeInfo + retFlags = self._ConvertAnnotations(returnTypeInfo.annotation) + methodRetType = returnTypeInfo.type + else: + retFlags = 0 + methodRetType = "void" + if wsdlName.endswith("_Task"): + # TODO: Need a seperate task return type for task, instead of + # hardcode vim.Task as return type + retType = "vim.Task" + else: + retType = methodRetType + retInfo = (retFlags, retType, methodRetType) + + method = (name, wsdlName, version, params, retInfo, privId, faults) + else: + method = None + return method + + def _ConvertManagedPropertyType(self, propType): + """ + Convert vmodl.reflect.DynamicTypeManager.PropertyTypeInfo to pyVmomi + managed property definition + """ + if propType: + name = propType.name + version = propType.version + aType = propType.type + flags = self._ConvertAnnotations(propType.annotation) + privId = propType.privId + prop = (name, aType, version, flags, privId) + else: + prop = None + return prop + + def _ConvertManagedType(self, managedType): + """ + Convert vmodl.reflect.DynamicTypeManager.ManagedTypeInfo to pyVmomi + managed type definition + """ + if managedType: + vmodlName = managedType.name + wsdlName = managedType.wsdlName + version = managedType.version + parent = managedType.base[0] + props = self._Filter(self._ConvertManagedPropertyType, managedType.property) + methods = self._Filter(self._ConvertMethodType, managedType.method) + moType = (vmodlName, wsdlName, parent, version, props, methods) + else: + moType = None + return moType + + def _ConvertDataPropertyType(self, propType): + """ + Convert vmodl.reflect.DynamicTypeManager.PropertyTypeInfo to pyVmomi + data property definition + """ + if propType: + name = propType.name + version = propType.version + aType = propType.type + flags = self._ConvertAnnotations(propType.annotation) + prop = (name, aType, version, flags) + else: + prop = None + return prop + + def _ConvertDataType(self, dataType): + """ + Convert vmodl.reflect.DynamicTypeManager.DataTypeInfo to pyVmomi data + type definition + """ + if dataType: + vmodlName = dataType.name + wsdlName = dataType.wsdlName + version = dataType.version + parent = dataType.base[0] + props = self._Filter(self._ConvertDataPropertyType, dataType.property) + doType = (vmodlName, wsdlName, parent, version, props) + else: + doType = None + return doType + + def _ConvertEnumType(self, enumType): + """ + Convert vmodl.reflect.DynamicTypeManager.EnumTypeInfo to pyVmomi enum + type definition + """ + if enumType: + vmodlName = enumType.name + wsdlName = enumType.wsdlName + version = enumType.version + values = enumType.value + enumType = (vmodlName, wsdlName, version, values) + else: + enumType = None + return enumType + diff --git a/pyVmomi/Iso8601.py b/pyVmomi/Iso8601.py new file mode 100644 index 0000000..8f0e2f7 --- /dev/null +++ b/pyVmomi/Iso8601.py @@ -0,0 +1,356 @@ +#!/usr/bin/env python + +# VMware vSphere Python SDK +# Copyright (c) 2008-2013 VMware, Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +This module is for ISO 8601 parsing +""" +__author__ = 'VMware, Inc.' + +import time +from datetime import datetime, timedelta, tzinfo +import re + +""" Regular expression to parse a subset of ISO 8601 format """ +_dtExpr = re.compile( + # XMLSchema datetime. Mandatory to have - and : + # See: http://www.w3.org/TR/xmlschema-2/#isoformats + # Note: python datetime cannot handle the following: + # - leap second, ie. 0-60 seconds (not 0-59) + # - BC (negative years) + # year [-]0000..9999 + r'(?P-?\d{4})' \ + # month 01..12 + r'(-(?P(0[1-9]|1[0-2]))' \ + # day 01..31 + r'(-(?P(0[1-9]|[1-2]\d|3[01])))?)?' \ + # time separator 'T' + r'(T' \ + # hour 00..24 + r'(?P([01]\d|2[0-4]))' \ + # minute 00..59 + r'((:(?P[0-5]\d))' \ + # seconds 00..60 (leap second ok) + r'(:(?P([0-5]\d|60))' \ + # microsecond. max 16 digits + # - Should not allows trailing zeros. But python isoformat() put zeros + # after microseconds. Oh well, allows trailing zeros, quite harmless + r'(\.(?P\d{1,16}))?)?)?' \ + # UTC 'Z', or... + r'((?PZ)' \ + # tz [+-]00..13:0..59|14:00 + r'|((?P[+-](([0]\d)|(1[0-3])|(?P)14))' \ + r'(:(?P(?(tzlimit)00|([0-5]\d))))?))?' \ + r')?$') + +""" Default date time val. Key should match the tags in _dtExpr """ +_dtExprKeyDefValMap = {'year' : None, 'month' : 1, 'day' : 1, + 'hour' : 0, 'minute' : 0, 'second' : 0, + 'microsecond' : 0} + +class TZInfo(tzinfo): + """ Timezone info class """ + + timedelta0 = timedelta(hours=0) + timedelta1 = timedelta(hours=1) + + def __init__(self, tzname='UTC', utcOffset=None, dst=None): + self._tzname = tzname + if not utcOffset: + utcOffset = self.timedelta0 + self._utcOffset = utcOffset + if not dst: + dst = None + self._dst = dst + + def utcoffset(self, dt): + return self._utcOffset + self.dst(dt) + + def tzname(self, dt): + return self._tzname + + def dst(self, dt): + ret = self.timedelta0 + if self._dst: + if self._dst[0] <= dt.replace(tzinfo=None) < self._dst[1]: + ret = self.timedelta1 + return ret + + +class TZManager: + """ Time zone manager """ + _tzInfos = {} + + @staticmethod + def GetTZInfo(tzname='UTC', utcOffset=None, dst=None): + """ Get / Add timezone info """ + key = (tzname, utcOffset, dst) + tzInfo = TZManager._tzInfos.get(key) + if not tzInfo: + tzInfo = TZInfo(tzname, utcOffset, dst) + TZManager._tzInfos[key] = tzInfo + return tzInfo + + +def ParseISO8601(datetimeStr): + """ + Parse ISO 8601 date time from string. + Returns datetime if ok, None otherwise + Note: Allows YYYY / YYYY-MM, but truncate YYYY -> YYYY-01-01, + YYYY-MM -> YYYY-MM-01 + Truncate microsecond to most significant 6 digits + """ + datetimeVal = None + match = _dtExpr.match(datetimeStr) + if match: + try: + dt = {} + for key, defaultVal in _dtExprKeyDefValMap.iteritems(): + val = match.group(key) + if val: + if key == 'microsecond': + val = val[:6] + '0' * (6 - len(val)) + dt[key] = int(val) + elif defaultVal: + dt[key] = defaultVal + + # Orig. XMLSchema don't allow all zeros year. But newer draft is ok + #if dt['year'] == 0: + # # Year cannot be all zeros + # raise Exception('Year cannot be all zeros') + + # 24 is a special case. It is actually represented as next day 00:00 + delta = None + if dt.get('hour', 0) == 24: + # Must be 24:00:00.0 + if dt.get('minute', 0) == 0 and dt.get('second', 0) == 0 and \ + dt.get('microsecond', 0) == 0: + dt['hour'] = 23 + delta = timedelta(hours=1) + else: + return None + + # Set tzinfo + # TODO: dst + tzInfo = None + val = match.group('tzutc') + if val: + tzInfo = TZManager.GetTZInfo() + else: + val = match.group('tzhr') + if val: + # tz hours offset + tzhr = int(val) + utcsign = val[0] + + # tz minutes offset + tzmin = 0 + val = match.group('tzmin') + if val: + tzmin = tzhr >= 0 and int(val) or -int(val) + + # Better tzname (map UTC +-00:00 to UTC) + tzname = 'UTC' + if tzhr != 0 or tzmin != 0: + tzname += ' %s%02d:%02d' % (utcsign, abs(tzhr), abs(tzmin)) + + tzInfo = TZManager.GetTZInfo(tzname=tzname, + utcOffset=timedelta(hours=tzhr, + minutes=tzmin)) + if tzInfo: + dt['tzinfo'] = tzInfo + + datetimeVal = datetime(**dt) + if delta: + datetimeVal += delta + except Exception, e: + pass + return datetimeVal + + +def ISO8601Format(dt): + """ + Python datetime isoformat() has the following problems: + - leave trailing 0 at the end of microseconds (violates XMLSchema rule) + - tz print +00:00 instead of Z + - Missing timezone offset for datetime without tzinfo + """ + isoStr = dt.strftime('%Y-%m-%dT%H:%M:%S') + if dt.microsecond: + isoStr += ('.%06d' % dt.microsecond).rstrip('0') + if dt.tzinfo: + tz = dt.strftime('%z') + else: + utcOffset_minutes = -time.altzone / 60 + tz = "%+.2d%.2d" % (utcOffset_minutes / 60, (abs(utcOffset_minutes) % 60)) + if tz == '+0000': + return isoStr + 'Z' + elif tz: + return isoStr + tz[:3] + ':' + tz[3:] + else: + # Local offset is unknown + return isoStr + '-00:00' + + +# Testing +if __name__ == '__main__': + # Valid entries + for testStr in [ + '1971', # 1971-01-01 + '1971-11', # 1971-11-01 + '1971-11-02', + '1971-11-02T23', + '1971-11-02T23Z', + '1971-11-02T23:04', + '1971-11-02T23:04Z', + '1971-11-02T23:04:15', + '1971-11-02T23:04:15Z', + '1971-11-02T23:04:15.1', + '1971-11-02T23:04:15.01', + '1971-11-02T23:04:15.023456', + '1971-11-02T23:04:15.103456Z', + '1971-11-02T23:04:15.123456+11', + '1971-11-02T23:04:15.123456-11', + '1971-11-02T23:04:15.123456+11:30', + '1971-11-02T23:04:15.123456-11:30', + '1971-11-02T23:04:15.123456+00:00', # Same as Z + '1971-11-02T23:04:15.123456-00:00', # Same as Z + + '1971-01-02T23:04:15+14', + '1971-01-02T23:04:15+14:00', + '1971-01-02T23:04:15-14', + '1971-01-02T23:04:15-14:00', + + # Valid: Truncate microsec to 6 digits + '1971-01-02T23:04:15.123456891+11', + + '1971-01-02T24', # 24 is valid. It should represent the 00:00 the + # next day + '1971-01-02T24:00', + '1971-01-02T24:00:00', + '1971-01-02T24:00:00.0', + + # Should NOT be valid but python isoformat adding trailing zeros + '1971-01-02T23:04:15.123430', # Microseconds ends in zero + '1971-01-02T23:04:15.0', # Microseconds ends in zero + + # Should be valid but python datetime don't support it + #'2005-12-31T23:59:60Z', # Leap second + #'-0001', # BC 1 + ]: + dt = ParseISO8601(testStr) + if dt == None: + print 'Failed to parse (%s)' % testStr + assert(False) + + # Make sure we can translate back + isoformat = ISO8601Format(dt) + dt1 = ParseISO8601(isoformat) + if dt.tzinfo is None: + dt = dt.replace(tzinfo=dt1.tzinfo) + if dt1 != dt: + print 'ParseISO8601 -> ISO8601Format -> ParseISO8601 failed (%s)' % testStr + assert(False) + + # Make sure we can parse python isoformat() + dt2 = ParseISO8601(dt.isoformat()) + if dt2 == None: + print 'ParseISO8601("%s".isoformat()) failed' % testStr + assert(False) + + print testStr, '->', dt, isoformat + + # Basic form + for testStr in [ + '197111', # 1971-11-01 + '19711102', + '19711102T23', + '19711102T23Z', + '19711102T2304', + '19711102T2304Z', + '19711102T230415', + '19711102T230415Z', + '19711102T230415.123456', + '19711102T230415.123456Z', + '19711102T230415.123456+11', + '19711102T230415.123456-11', + '19711102T230415.123456+1130', + '19711102T230415.123456-1130', + ]: + # Reject for now + dt = ParseISO8601(testStr) + if dt != None: + print 'ParseISO8601 (%s) should fail, but it did not' % testStr + assert(False) + #print testStr, '->', dt + #assert(dt != None) + + # Invalid entries + for testStr in [ + # Xml schema reject year 0 + '0000', # 0 years are not allowed + '+0001', # Leading + is not allowed + + '', # Empty datetime str + '09', # Years must be at least 4 digits + '1971-01-02T', # T not follow by time + '1971-01-02TZ', # T not follow by time + '1971-01-02T+10', # T not follow by time + '1971-01-02T-10', # T not follow by time + '1971-01-02T23:', # extra : + '1971-01-02T23:04:', # extra : + '1971-01-02T23:0d', # 0d + '1971-01-02T23:04:15.', # Dot not follows by microsec + '1971-01-02+12', # time without T + '1971Z', # Z without T + '1971-01-02T23:04:15.123456Z+11', # Z follows by + + '1971-01-02T23:04:15.123456Z-11', # Z follows by - + '1971-01-02T23:04:15.123456+:30', # extra : + '1971-01-02T23:04:15.123456+30:', # extra : + '1971-01-02T23:04:15.01234567890123456789', # Too many microseconds digits + + # Python isoformat leave trailing zeros in microseconds + # Relax regular expression to accept it + #'1971-01-02T23:04:15.123430', # Microseconds ends in zero + #'1971-01-02T23:04:15.0', # Microseconds ends in zero + + # Timezone must be between +14 / -14 + '1971-01-02T23:04:15+15', + '1971-01-02T23:04:15-15', + '1971-01-02T23:04:15+14:01', + '1971-01-02T23:04:15-14:01', + + # Mix basic form with extended format + '197101-02T23:04:15.123456', + '19710102T23:04:15.123456', + '19710102T230415.123456+11:30', + '1971-01-02T230415.123456', + '1971-01-02T23:04:15.123456+1130', + + # Error captured by datetime class + '1971-00-02', # Less than 1 month + '1971-13-02', # Larger than 12 months + '1971-01-00', # Less than 1 day + '1971-11-32', # Larger than 30 days for Nov + '1971-12-32', # Larger than 31 days + '1971-01-02T24:01', # Larger than 23 hr + '1971-01-02T23:61', # Larger than 60 min + '1971-01-02T23:60:61', # Larger than 61 sec + ]: + dt = ParseISO8601(testStr) + if dt != None: + print 'ParseISO8601 (%s) should fail, but it did not' % testStr + assert(False) diff --git a/pyVmomi/ManagedMethodExecutorHelper.py b/pyVmomi/ManagedMethodExecutorHelper.py new file mode 100644 index 0000000..abf806d --- /dev/null +++ b/pyVmomi/ManagedMethodExecutorHelper.py @@ -0,0 +1,120 @@ +#!/usr/bin/env python + +# VMware vSphere Python SDK +# Copyright (c) 2008-2013 VMware, Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +This module provides convinent fns related to ManagedMethodExecutor +""" +__author__ = "VMware, Inc." + +from pyVmomi import VmomiSupport, SoapAdapter, vmodl +from SoapAdapter import SoapStubAdapterBase, Serialize, Deserialize + +## ManagedMethodExecutor soap stub adapter +# +class MMESoapStubAdapter(SoapStubAdapterBase): + """ Managed method executor stub adapter """ + + ## Constructor + # + # The endpoint can be specified individually as either a host/port + # combination, or with a URL (using a url= keyword). + # + # @param self self + # @param mme managed method executor + def __init__(self, mme): + stub = mme._stub + SoapStubAdapterBase.__init__(self, version=stub.version) + self.mme = mme + + ## Compute the version information for the specified namespace + # + # @param ns the namespace + def ComputeVersionInfo(self, version): + SoapStubAdapterBase.ComputeVersionInfo(self, version) + self.versionId = self.versionId[1:-1] + + ## Invoke a managed method, with _ExecuteSoap. Wohooo! + # + # @param self self + # @param mo the 'this' + # @param info method info + # @param args arguments + def InvokeMethod(self, mo, info, args): + # Serialize parameters to soap parameters + methodArgs = None + if info.params: + methodArgs = vmodl.Reflect.ManagedMethodExecutor.SoapArgument.Array() + for param, arg in zip(info.params, args): + if arg is not None: + # Serialize parameters to soap snippets + soapVal = Serialize(val=arg, info=param, version=self.version) + + # Insert argument + soapArg = vmodl.Reflect.ManagedMethodExecutor.SoapArgument( + name=param.name, val=soapVal) + methodArgs.append(soapArg) + + moid = mo._GetMoId() + version = self.versionId + methodName = VmomiSupport.GetVmodlName(info.type) + "." + info.name + + # Execute method + result = self.mme.ExecuteSoap(moid=moid, + version=version, + method=methodName, + argument=methodArgs) + return self._DeserializeExecutorResult(result, info.result) + + ## Invoke a managed property accessor + # + # @param self self + # @param mo the 'this' + # @param info property info + def InvokeAccessor(self, mo, info): + moid = mo._GetMoId() + version = self.versionId + prop = info.name + + # Fetch property + result = self.mme.FetchSoap(moid=moid, version=version, prop=prop) + return self._DeserializeExecutorResult(result, info.type) + + ## Deserialize result from ExecuteSoap / FetchSoap + # + # @param self self + # @param result result from ExecuteSoap / FetchSoap + # @param resultType Expected result type + def _DeserializeExecutorResult(self, result, resultType): + obj = None + if result: + # Parse the return soap snippet. If fault, raise exception + if result.response: + # Deserialize back to result + obj = Deserialize(result.response, resultType, stub=self) + elif result.fault: + # Deserialize back to fault (or vmomi fault) + fault = Deserialize(result.fault.faultDetail, + object, + stub=self) + # Silent pylint + raise fault # pylint: disable-msg=E0702 + else: + # Unexpected: result should have either response or fault + msg = "Unexpected execute/fetchSoap error" + reason = "execute/fetchSoap did not return response or fault" + raise vmodl.Fault.SystemError(msg=msg, reason=reason) + return obj diff --git a/pyVmomi/ServerObjects.py b/pyVmomi/ServerObjects.py new file mode 100644 index 0000000..a524cd5 --- /dev/null +++ b/pyVmomi/ServerObjects.py @@ -0,0 +1,2876 @@ +# VMware vSphere Python SDK +# Copyright (c) 2008-2013 VMware, Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# ******* WARNING - AUTO GENERATED CODE - DO NOT EDIT ******* +from VmomiSupport import CreateDataType, CreateManagedType, CreateEnumType, AddVersion, AddVersionParent, F_LINK, F_LINKABLE, F_OPTIONAL + +AddVersion("vim.version.version1", "vim2", "2.0", 1, "vim25") +AddVersion("vim.version.version2", "vim25", "2.5", 0, "vim25") +AddVersion("vim.version.version3", "vim25", "2.5u2", 1, "vim25") +AddVersion("vim.version.version4", "vim25", "2.5u2server", 0, "vim25") +AddVersion("vim.version.version5", "vim25", "4.0", 0, "vim25") +AddVersion("vim.version.version6", "vim25", "4.1", 0, "vim25") +AddVersion("vim.version.version7", "vim25", "5.0", 0, "vim25") +AddVersion("vim.version.version8", "vim25", "5.1", 0, "vim25") +AddVersion("vim.version.version9", "vim25", "5.5", 0, "vim25") +AddVersion("vmodl.query.version.version1", "", "", 0, "vim25") +AddVersion("vmodl.query.version.version2", "", "", 0, "vim25") +AddVersion("vmodl.query.version.version3", "", "", 0, "vim25") +AddVersion("vmodl.query.version.version4", "", "", 0, "vim25") +AddVersion("vmodl.reflect.version.version1", "reflect", "1.0", 0, "reflect") +AddVersion("vmodl.version.version0", "", "", 0, "vim25") +AddVersion("vmodl.version.version1", "", "", 0, "vim25") +AddVersion("vmodl.version.version2", "", "", 0, "vim25") +AddVersionParent("vim.version.version1", "vim.version.version1") +AddVersionParent("vim.version.version1", "vmodl.query.version.version1") +AddVersionParent("vim.version.version1", "vmodl.version.version0") +AddVersionParent("vim.version.version2", "vim.version.version1") +AddVersionParent("vim.version.version2", "vim.version.version2") +AddVersionParent("vim.version.version2", "vmodl.query.version.version1") +AddVersionParent("vim.version.version2", "vmodl.version.version0") +AddVersionParent("vim.version.version3", "vim.version.version1") +AddVersionParent("vim.version.version3", "vim.version.version2") +AddVersionParent("vim.version.version3", "vim.version.version3") +AddVersionParent("vim.version.version3", "vmodl.query.version.version1") +AddVersionParent("vim.version.version3", "vmodl.version.version0") +AddVersionParent("vim.version.version4", "vim.version.version1") +AddVersionParent("vim.version.version4", "vim.version.version2") +AddVersionParent("vim.version.version4", "vim.version.version3") +AddVersionParent("vim.version.version4", "vim.version.version4") +AddVersionParent("vim.version.version4", "vmodl.query.version.version1") +AddVersionParent("vim.version.version4", "vmodl.version.version0") +AddVersionParent("vim.version.version5", "vim.version.version1") +AddVersionParent("vim.version.version5", "vim.version.version2") +AddVersionParent("vim.version.version5", "vim.version.version3") +AddVersionParent("vim.version.version5", "vim.version.version4") +AddVersionParent("vim.version.version5", "vim.version.version5") +AddVersionParent("vim.version.version5", "vmodl.query.version.version1") +AddVersionParent("vim.version.version5", "vmodl.query.version.version2") +AddVersionParent("vim.version.version5", "vmodl.version.version0") +AddVersionParent("vim.version.version5", "vmodl.version.version1") +AddVersionParent("vim.version.version6", "vim.version.version1") +AddVersionParent("vim.version.version6", "vim.version.version2") +AddVersionParent("vim.version.version6", "vim.version.version3") +AddVersionParent("vim.version.version6", "vim.version.version4") +AddVersionParent("vim.version.version6", "vim.version.version5") +AddVersionParent("vim.version.version6", "vim.version.version6") +AddVersionParent("vim.version.version6", "vmodl.query.version.version1") +AddVersionParent("vim.version.version6", "vmodl.query.version.version2") +AddVersionParent("vim.version.version6", "vmodl.query.version.version3") +AddVersionParent("vim.version.version6", "vmodl.version.version0") +AddVersionParent("vim.version.version6", "vmodl.version.version1") +AddVersionParent("vim.version.version7", "vim.version.version1") +AddVersionParent("vim.version.version7", "vim.version.version2") +AddVersionParent("vim.version.version7", "vim.version.version3") +AddVersionParent("vim.version.version7", "vim.version.version4") +AddVersionParent("vim.version.version7", "vim.version.version5") +AddVersionParent("vim.version.version7", "vim.version.version6") +AddVersionParent("vim.version.version7", "vim.version.version7") +AddVersionParent("vim.version.version7", "vmodl.query.version.version1") +AddVersionParent("vim.version.version7", "vmodl.query.version.version2") +AddVersionParent("vim.version.version7", "vmodl.query.version.version3") +AddVersionParent("vim.version.version7", "vmodl.query.version.version4") +AddVersionParent("vim.version.version7", "vmodl.reflect.version.version1") +AddVersionParent("vim.version.version7", "vmodl.version.version0") +AddVersionParent("vim.version.version7", "vmodl.version.version1") +AddVersionParent("vim.version.version7", "vmodl.version.version2") +AddVersionParent("vim.version.version8", "vim.version.version1") +AddVersionParent("vim.version.version8", "vim.version.version2") +AddVersionParent("vim.version.version8", "vim.version.version3") +AddVersionParent("vim.version.version8", "vim.version.version4") +AddVersionParent("vim.version.version8", "vim.version.version5") +AddVersionParent("vim.version.version8", "vim.version.version6") +AddVersionParent("vim.version.version8", "vim.version.version7") +AddVersionParent("vim.version.version8", "vim.version.version8") +AddVersionParent("vim.version.version8", "vmodl.query.version.version1") +AddVersionParent("vim.version.version8", "vmodl.query.version.version2") +AddVersionParent("vim.version.version8", "vmodl.query.version.version3") +AddVersionParent("vim.version.version8", "vmodl.query.version.version4") +AddVersionParent("vim.version.version8", "vmodl.reflect.version.version1") +AddVersionParent("vim.version.version8", "vmodl.version.version0") +AddVersionParent("vim.version.version8", "vmodl.version.version1") +AddVersionParent("vim.version.version8", "vmodl.version.version2") +AddVersionParent("vim.version.version9", "vim.version.version1") +AddVersionParent("vim.version.version9", "vim.version.version2") +AddVersionParent("vim.version.version9", "vim.version.version3") +AddVersionParent("vim.version.version9", "vim.version.version4") +AddVersionParent("vim.version.version9", "vim.version.version5") +AddVersionParent("vim.version.version9", "vim.version.version6") +AddVersionParent("vim.version.version9", "vim.version.version7") +AddVersionParent("vim.version.version9", "vim.version.version8") +AddVersionParent("vim.version.version9", "vim.version.version9") +AddVersionParent("vim.version.version9", "vmodl.query.version.version1") +AddVersionParent("vim.version.version9", "vmodl.query.version.version2") +AddVersionParent("vim.version.version9", "vmodl.query.version.version3") +AddVersionParent("vim.version.version9", "vmodl.query.version.version4") +AddVersionParent("vim.version.version9", "vmodl.reflect.version.version1") +AddVersionParent("vim.version.version9", "vmodl.version.version0") +AddVersionParent("vim.version.version9", "vmodl.version.version1") +AddVersionParent("vim.version.version9", "vmodl.version.version2") +AddVersionParent("vmodl.query.version.version1", "vmodl.query.version.version1") +AddVersionParent("vmodl.query.version.version1", "vmodl.version.version0") +AddVersionParent("vmodl.query.version.version2", "vmodl.query.version.version1") +AddVersionParent("vmodl.query.version.version2", "vmodl.query.version.version2") +AddVersionParent("vmodl.query.version.version2", "vmodl.version.version0") +AddVersionParent("vmodl.query.version.version2", "vmodl.version.version1") +AddVersionParent("vmodl.query.version.version3", "vmodl.query.version.version1") +AddVersionParent("vmodl.query.version.version3", "vmodl.query.version.version2") +AddVersionParent("vmodl.query.version.version3", "vmodl.query.version.version3") +AddVersionParent("vmodl.query.version.version3", "vmodl.version.version0") +AddVersionParent("vmodl.query.version.version3", "vmodl.version.version1") +AddVersionParent("vmodl.query.version.version4", "vmodl.query.version.version1") +AddVersionParent("vmodl.query.version.version4", "vmodl.query.version.version2") +AddVersionParent("vmodl.query.version.version4", "vmodl.query.version.version3") +AddVersionParent("vmodl.query.version.version4", "vmodl.query.version.version4") +AddVersionParent("vmodl.query.version.version4", "vmodl.version.version0") +AddVersionParent("vmodl.query.version.version4", "vmodl.version.version1") +AddVersionParent("vmodl.query.version.version4", "vmodl.version.version2") +AddVersionParent("vmodl.reflect.version.version1", "vmodl.reflect.version.version1") +AddVersionParent("vmodl.reflect.version.version1", "vmodl.version.version0") +AddVersionParent("vmodl.reflect.version.version1", "vmodl.version.version1") +AddVersionParent("vmodl.reflect.version.version1", "vmodl.version.version2") +AddVersionParent("vmodl.version.version0", "vmodl.version.version0") +AddVersionParent("vmodl.version.version1", "vmodl.version.version0") +AddVersionParent("vmodl.version.version1", "vmodl.version.version1") +AddVersionParent("vmodl.version.version2", "vmodl.version.version0") +AddVersionParent("vmodl.version.version2", "vmodl.version.version1") +AddVersionParent("vmodl.version.version2", "vmodl.version.version2") + +CreateDataType("vim.AboutInfo", "AboutInfo", "vmodl.DynamicData", "vim.version.version1", [("name", "string", "vim.version.version1", 0), ("fullName", "string", "vim.version.version1", 0), ("vendor", "string", "vim.version.version1", 0), ("version", "string", "vim.version.version1", 0), ("build", "string", "vim.version.version1", 0), ("localeVersion", "string", "vim.version.version1", F_OPTIONAL), ("localeBuild", "string", "vim.version.version1", F_OPTIONAL), ("osType", "string", "vim.version.version1", 0), ("productLineId", "string", "vim.version.version1", 0), ("apiType", "string", "vim.version.version1", 0), ("apiVersion", "string", "vim.version.version1", 0), ("instanceUuid", "string", "vim.version.version5", F_OPTIONAL), ("licenseProductName", "string", "vim.version.version5", F_OPTIONAL), ("licenseProductVersion", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.AuthorizationDescription", "AuthorizationDescription", "vmodl.DynamicData", "vim.version.version1", [("privilege", "vim.ElementDescription[]", "vim.version.version1", 0), ("privilegeGroup", "vim.ElementDescription[]", "vim.version.version1", 0)]) +CreateDataType("vim.Capability", "Capability", "vmodl.DynamicData", "vim.version.version1", [("provisioningSupported", "boolean", "vim.version.version1", 0), ("multiHostSupported", "boolean", "vim.version.version1", 0), ("userShellAccessSupported", "boolean", "vim.version.version2", 0), ("supportedEVCMode", "vim.EVCMode[]", "vim.version.version5", F_OPTIONAL), ("networkBackupAndRestoreSupported", "boolean", "vim.version.version8", F_OPTIONAL)]) +CreateEnumType("vim.ConfigSpecOperation", "ConfigSpecOperation", "vim.version.version5", ["add", "edit", "remove"]) +CreateManagedType("vim.CustomFieldsManager", "CustomFieldsManager", "vmodl.ManagedObject", "vim.version.version1", [("field", "vim.CustomFieldsManager.FieldDef[]", "vim.version.version1", F_OPTIONAL, "System.View")], [("addFieldDefinition", "AddCustomFieldDef", "vim.version.version1", (("name", "string", "vim.version.version1", 0, None),("moType", "vmodl.TypeName", "vim.version.version2", F_OPTIONAL, None),("fieldDefPolicy", "vim.PrivilegePolicyDef", "vim.version.version2", F_OPTIONAL, None),("fieldPolicy", "vim.PrivilegePolicyDef", "vim.version.version2", F_OPTIONAL, None),), (0, "vim.CustomFieldsManager.FieldDef", "vim.CustomFieldsManager.FieldDef"), "Global.ManageCustomFields", ["vim.fault.DuplicateName", "vim.fault.InvalidPrivilege", ]), ("removeFieldDefinition", "RemoveCustomFieldDef", "vim.version.version1", (("key", "int", "vim.version.version1", 0, None),), (0, "void", "void"), "Global.ManageCustomFields", None), ("renameFieldDefinition", "RenameCustomFieldDef", "vim.version.version1", (("key", "int", "vim.version.version1", 0, None),("name", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "Global.ManageCustomFields", ["vim.fault.DuplicateName", ]), ("setField", "SetField", "vim.version.version1", (("entity", "vim.ManagedEntity", "vim.version.version1", 0, "Global.SetCustomField"),("key", "int", "vim.version.version1", 0, None),("value", "string", "vim.version.version1", 0, None),), (0, "void", "void"), None, None)]) +CreateDataType("vim.CustomFieldsManager.FieldDef", "CustomFieldDef", "vmodl.DynamicData", "vim.version.version1", [("key", "int", "vim.version.version1", 0), ("name", "string", "vim.version.version1", 0), ("type", "vmodl.TypeName", "vim.version.version1", 0), ("managedObjectType", "vmodl.TypeName", "vim.version.version2", F_OPTIONAL), ("fieldDefPrivileges", "vim.PrivilegePolicyDef", "vim.version.version2", F_OPTIONAL), ("fieldInstancePrivileges", "vim.PrivilegePolicyDef", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.CustomFieldsManager.Value", "CustomFieldValue", "vmodl.DynamicData", "vim.version.version1", [("key", "int", "vim.version.version1", 0)]) +CreateDataType("vim.CustomFieldsManager.StringValue", "CustomFieldStringValue", "vim.CustomFieldsManager.Value", "vim.version.version1", [("value", "string", "vim.version.version1", 0)]) +CreateManagedType("vim.CustomizationSpecManager", "CustomizationSpecManager", "vmodl.ManagedObject", "vim.version.version1", [("info", "vim.CustomizationSpecInfo[]", "vim.version.version1", F_OPTIONAL, "VirtualMachine.Provisioning.ReadCustSpecs"), ("encryptionKey", "byte[]", "vim.version.version1", F_OPTIONAL, "System.View")], [("exists", "DoesCustomizationSpecExist", "vim.version.version1", (("name", "string", "vim.version.version1", 0, None),), (0, "boolean", "boolean"), "VirtualMachine.Provisioning.ReadCustSpecs", None), ("get", "GetCustomizationSpec", "vim.version.version1", (("name", "string", "vim.version.version1", 0, None),), (0, "vim.CustomizationSpecItem", "vim.CustomizationSpecItem"), "VirtualMachine.Provisioning.ReadCustSpecs", ["vim.fault.NotFound", ]), ("create", "CreateCustomizationSpec", "vim.version.version1", (("item", "vim.CustomizationSpecItem", "vim.version.version1", 0, None),), (0, "void", "void"), "VirtualMachine.Provisioning.ModifyCustSpecs", ["vim.fault.CustomizationFault", "vim.fault.AlreadyExists", ]), ("overwrite", "OverwriteCustomizationSpec", "vim.version.version1", (("item", "vim.CustomizationSpecItem", "vim.version.version1", 0, None),), (0, "void", "void"), "VirtualMachine.Provisioning.ModifyCustSpecs", ["vim.fault.CustomizationFault", "vim.fault.NotFound", "vim.fault.ConcurrentAccess", ]), ("delete", "DeleteCustomizationSpec", "vim.version.version1", (("name", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "VirtualMachine.Provisioning.ModifyCustSpecs", ["vim.fault.NotFound", ]), ("duplicate", "DuplicateCustomizationSpec", "vim.version.version1", (("name", "string", "vim.version.version1", 0, None),("newName", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "VirtualMachine.Provisioning.ModifyCustSpecs", ["vim.fault.NotFound", "vim.fault.AlreadyExists", ]), ("rename", "RenameCustomizationSpec", "vim.version.version1", (("name", "string", "vim.version.version1", 0, None),("newName", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "VirtualMachine.Provisioning.ModifyCustSpecs", ["vim.fault.NotFound", "vim.fault.AlreadyExists", ]), ("specItemToXml", "CustomizationSpecItemToXml", "vim.version.version1", (("item", "vim.CustomizationSpecItem", "vim.version.version1", 0, None),), (0, "string", "string"), "System.View", None), ("xmlToSpecItem", "XmlToCustomizationSpecItem", "vim.version.version1", (("specItemXml", "string", "vim.version.version1", 0, None),), (0, "vim.CustomizationSpecItem", "vim.CustomizationSpecItem"), "System.View", ["vim.fault.CustomizationFault", ]), ("checkResources", "CheckCustomizationResources", "vim.version.version1", (("guestOs", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "System.View", ["vim.fault.CustomizationFault", ])]) +CreateDataType("vim.CustomizationSpecInfo", "CustomizationSpecInfo", "vmodl.DynamicData", "vim.version.version1", [("name", "string", "vim.version.version1", 0), ("description", "string", "vim.version.version1", 0), ("type", "string", "vim.version.version1", 0), ("changeVersion", "string", "vim.version.version1", F_OPTIONAL), ("lastUpdateTime", "vmodl.DateTime", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.CustomizationSpecItem", "CustomizationSpecItem", "vmodl.DynamicData", "vim.version.version1", [("info", "vim.CustomizationSpecInfo", "vim.version.version1", 0), ("spec", "vim.vm.customization.Specification", "vim.version.version1", 0)]) +CreateManagedType("vim.DatastoreNamespaceManager", "DatastoreNamespaceManager", "vmodl.ManagedObject", "vim.version.version9", None, [("CreateDirectory", "CreateDirectory", "vim.version.version9", (("datastore", "vim.Datastore", "vim.version.version9", 0, None),("displayName", "string", "vim.version.version9", F_OPTIONAL, None),("policy", "string", "vim.version.version9", F_OPTIONAL, None),), (0, "string", "string"), "Datastore.Config", ["vim.fault.CannotCreateFile", "vim.fault.FileAlreadyExists", "vim.fault.InvalidDatastore", ]), ("DeleteDirectory", "DeleteDirectory", "vim.version.version9", (("datacenter", "vim.Datacenter", "vim.version.version9", F_OPTIONAL, "System.View"),("datastorePath", "string", "vim.version.version9", 0, None),), (0, "void", "void"), "Datastore.Config", ["vim.fault.FileFault", "vim.fault.FileNotFound", "vim.fault.InvalidDatastore", "vim.fault.InvalidDatastorePath", ])]) +CreateDataType("vim.Description", "Description", "vmodl.DynamicData", "vim.version.version1", [("label", "string", "vim.version.version1", 0), ("summary", "string", "vim.version.version1", 0)]) +CreateManagedType("vim.DiagnosticManager", "DiagnosticManager", "vmodl.ManagedObject", "vim.version.version1", None, [("queryDescriptions", "QueryDescriptions", "vim.version.version1", (("host", "vim.HostSystem", "vim.version.version1", F_OPTIONAL, None),), (F_OPTIONAL, "vim.DiagnosticManager.LogDescriptor[]", "vim.DiagnosticManager.LogDescriptor[]"), "Global.Diagnostics", None), ("browse", "BrowseDiagnosticLog", "vim.version.version1", (("host", "vim.HostSystem", "vim.version.version1", F_OPTIONAL, None),("key", "string", "vim.version.version1", 0, None),("start", "int", "vim.version.version1", F_OPTIONAL, None),("lines", "int", "vim.version.version1", F_OPTIONAL, None),), (0, "vim.DiagnosticManager.LogHeader", "vim.DiagnosticManager.LogHeader"), "Global.Diagnostics", ["vim.fault.CannotAccessFile", ]), ("generateLogBundles", "GenerateLogBundles_Task", "vim.version.version1", (("includeDefault", "boolean", "vim.version.version1", 0, None),("host", "vim.HostSystem[]", "vim.version.version1", F_OPTIONAL, None),), (F_OPTIONAL, "vim.Task", "vim.DiagnosticManager.BundleInfo[]"), "Global.Diagnostics", ["vim.fault.LogBundlingFailed", "vim.fault.TaskInProgress", ])]) +CreateDataType("vim.DiagnosticManager.LogDescriptor", "DiagnosticManagerLogDescriptor", "vmodl.DynamicData", "vim.version.version1", [("key", "string", "vim.version.version1", 0), ("fileName", "string", "vim.version.version1", 0), ("creator", "string", "vim.version.version1", 0), ("format", "string", "vim.version.version1", 0), ("mimeType", "string", "vim.version.version1", 0), ("info", "vim.Description", "vim.version.version1", 0)]) +CreateEnumType("vim.DiagnosticManager.LogDescriptor.Creator", "DiagnosticManagerLogCreator", "vim.version.version1", ["vpxd", "vpxa", "hostd", "serverd", "install", "vpxClient", "recordLog"]) +CreateEnumType("vim.DiagnosticManager.LogDescriptor.Format", "DiagnosticManagerLogFormat", "vim.version.version1", ["plain"]) +CreateDataType("vim.DiagnosticManager.LogHeader", "DiagnosticManagerLogHeader", "vmodl.DynamicData", "vim.version.version1", [("lineStart", "int", "vim.version.version1", 0), ("lineEnd", "int", "vim.version.version1", 0), ("lineText", "string[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.DiagnosticManager.BundleInfo", "DiagnosticManagerBundleInfo", "vmodl.DynamicData", "vim.version.version1", [("system", "vim.HostSystem", "vim.version.version1", F_OPTIONAL), ("url", "string", "vim.version.version1", 0)]) +CreateEnumType("vim.DrsStatsManager.InjectorWorkload.CorrelationState", "DrsInjectorWorkloadCorrelationState", "vim.version.version8", ["Correlated", "Uncorrelated"]) +CreateDataType("vim.ElementDescription", "ElementDescription", "vim.Description", "vim.version.version1", [("key", "string", "vim.version.version1", 0)]) +CreateDataType("vim.EnumDescription", "EnumDescription", "vmodl.DynamicData", "vim.version.version5", [("key", "vmodl.TypeName", "vim.version.version5", 0), ("tags", "vim.ElementDescription[]", "vim.version.version5", 0)]) +CreateManagedType("vim.EnvironmentBrowser", "EnvironmentBrowser", "vmodl.ManagedObject", "vim.version.version1", [("datastoreBrowser", "vim.host.DatastoreBrowser", "vim.version.version1", F_OPTIONAL, "System.View")], [("queryConfigOptionDescriptor", "QueryConfigOptionDescriptor", "vim.version.version1", (), (F_OPTIONAL, "vim.vm.ConfigOptionDescriptor[]", "vim.vm.ConfigOptionDescriptor[]"), "System.View", None), ("queryConfigOption", "QueryConfigOption", "vim.version.version1", (("key", "string", "vim.version.version1", F_OPTIONAL, None),("host", "vim.HostSystem", "vim.version.version1", F_OPTIONAL, None),), (F_OPTIONAL, "vim.vm.ConfigOption", "vim.vm.ConfigOption"), "System.View", None), ("queryConfigTarget", "QueryConfigTarget", "vim.version.version1", (("host", "vim.HostSystem", "vim.version.version1", F_OPTIONAL, None),), (F_OPTIONAL, "vim.vm.ConfigTarget", "vim.vm.ConfigTarget"), "System.View", None), ("queryTargetCapabilities", "QueryTargetCapabilities", "vim.version.version5", (("host", "vim.HostSystem", "vim.version.version5", F_OPTIONAL, None),), (F_OPTIONAL, "vim.host.Capability", "vim.host.Capability"), "System.View", None)]) +CreateEnumType("vim.EsxAgentConfigManager.AgentVmState", "EsxAgentConfigManagerAgentVmState", "vim.version.version7", ["enabled", "disabled", "unavailable", "manuallyEnabled"]) +CreateDataType("vim.ExtendedDescription", "ExtendedDescription", "vim.Description", "vim.version.version5", [("messageCatalogKeyPrefix", "string", "vim.version.version5", 0), ("messageArg", "vmodl.KeyAnyValue[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.ExtendedElementDescription", "ExtendedElementDescription", "vim.ElementDescription", "vim.version.version5", [("messageCatalogKeyPrefix", "string", "vim.version.version5", 0), ("messageArg", "vmodl.KeyAnyValue[]", "vim.version.version5", F_OPTIONAL)]) +CreateManagedType("vim.ExtensibleManagedObject", "ExtensibleManagedObject", "vmodl.ManagedObject", "vim.version.version1", [("value", "vim.CustomFieldsManager.Value[]", "vim.version.version2", F_OPTIONAL, "System.View"), ("availableField", "vim.CustomFieldsManager.FieldDef[]", "vim.version.version2", F_OPTIONAL, "System.View")], [("setCustomValue", "setCustomValue", "vim.version.version2", (("key", "string", "vim.version.version2", 0, None),("value", "string", "vim.version.version2", 0, None),), (0, "void", "void"), None, None)]) +CreateDataType("vim.Extension", "Extension", "vmodl.DynamicData", "vim.version.version2", [("description", "vim.Description", "vim.version.version2", 0), ("key", "string", "vim.version.version2", 0), ("company", "string", "vim.version.version5", F_OPTIONAL), ("type", "string", "vim.version.version5", F_OPTIONAL), ("version", "string", "vim.version.version2", 0), ("subjectName", "string", "vim.version.version2", F_OPTIONAL), ("server", "vim.Extension.ServerInfo[]", "vim.version.version2", F_OPTIONAL), ("client", "vim.Extension.ClientInfo[]", "vim.version.version2", F_OPTIONAL), ("taskList", "vim.Extension.TaskTypeInfo[]", "vim.version.version2", F_OPTIONAL), ("eventList", "vim.Extension.EventTypeInfo[]", "vim.version.version2", F_OPTIONAL), ("faultList", "vim.Extension.FaultTypeInfo[]", "vim.version.version2", F_OPTIONAL), ("privilegeList", "vim.Extension.PrivilegeInfo[]", "vim.version.version2", F_OPTIONAL), ("resourceList", "vim.Extension.ResourceInfo[]", "vim.version.version2", F_OPTIONAL), ("lastHeartbeatTime", "vmodl.DateTime", "vim.version.version2", 0), ("healthInfo", "vim.Extension.HealthInfo", "vim.version.version5", F_OPTIONAL), ("ovfConsumerInfo", "vim.Extension.OvfConsumerInfo", "vim.version.version7", F_OPTIONAL), ("extendedProductInfo", "vim.ext.ExtendedProductInfo", "vim.version.version7", F_OPTIONAL), ("managedEntityInfo", "vim.ext.ManagedEntityInfo[]", "vim.version.version7", F_OPTIONAL), ("shownInSolutionManager", "boolean", "vim.version.version7", F_OPTIONAL), ("solutionManagerInfo", "vim.ext.SolutionManagerInfo", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.Extension.ServerInfo", "ExtensionServerInfo", "vmodl.DynamicData", "vim.version.version2", [("url", "string", "vim.version.version2", 0), ("description", "vim.Description", "vim.version.version2", 0), ("company", "string", "vim.version.version2", 0), ("type", "string", "vim.version.version2", 0), ("adminEmail", "string[]", "vim.version.version2", 0), ("serverThumbprint", "string", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.Extension.ClientInfo", "ExtensionClientInfo", "vmodl.DynamicData", "vim.version.version2", [("version", "string", "vim.version.version2", 0), ("description", "vim.Description", "vim.version.version2", 0), ("company", "string", "vim.version.version2", 0), ("type", "string", "vim.version.version2", 0), ("url", "string", "vim.version.version2", 0)]) +CreateDataType("vim.Extension.TaskTypeInfo", "ExtensionTaskTypeInfo", "vmodl.DynamicData", "vim.version.version2", [("taskID", "string", "vim.version.version2", 0)]) +CreateDataType("vim.Extension.EventTypeInfo", "ExtensionEventTypeInfo", "vmodl.DynamicData", "vim.version.version2", [("eventID", "string", "vim.version.version2", 0), ("eventTypeSchema", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.Extension.FaultTypeInfo", "ExtensionFaultTypeInfo", "vmodl.DynamicData", "vim.version.version2", [("faultID", "string", "vim.version.version2", 0)]) +CreateDataType("vim.Extension.PrivilegeInfo", "ExtensionPrivilegeInfo", "vmodl.DynamicData", "vim.version.version2", [("privID", "string", "vim.version.version2", 0), ("privGroupName", "string", "vim.version.version2", 0)]) +CreateDataType("vim.Extension.ResourceInfo", "ExtensionResourceInfo", "vmodl.DynamicData", "vim.version.version2", [("locale", "string", "vim.version.version2", 0), ("module", "string", "vim.version.version2", 0), ("data", "vim.KeyValue[]", "vim.version.version2", 0)]) +CreateDataType("vim.Extension.HealthInfo", "ExtensionHealthInfo", "vmodl.DynamicData", "vim.version.version5", [("url", "string", "vim.version.version5", 0)]) +CreateDataType("vim.Extension.OvfConsumerInfo", "ExtensionOvfConsumerInfo", "vmodl.DynamicData", "vim.version.version7", [("callbackUrl", "string", "vim.version.version7", 0), ("sectionType", "string[]", "vim.version.version7", 0)]) +CreateManagedType("vim.ExtensionManager", "ExtensionManager", "vmodl.ManagedObject", "vim.version.version2", [("extensionList", "vim.Extension[]", "vim.version.version2", F_OPTIONAL, "System.View")], [("unregisterExtension", "UnregisterExtension", "vim.version.version2", (("extensionKey", "string", "vim.version.version2", 0, None),), (0, "void", "void"), "Extension.Unregister", ["vim.fault.NotFound", ]), ("findExtension", "FindExtension", "vim.version.version2", (("extensionKey", "string", "vim.version.version2", 0, None),), (F_OPTIONAL, "vim.Extension", "vim.Extension"), "System.View", None), ("registerExtension", "RegisterExtension", "vim.version.version2", (("extension", "vim.Extension", "vim.version.version2", 0, None),), (0, "void", "void"), "Extension.Register", None), ("updateExtension", "UpdateExtension", "vim.version.version2", (("extension", "vim.Extension", "vim.version.version2", 0, None),), (0, "void", "void"), "Extension.Update", ["vim.fault.NotFound", ]), ("getPublicKey", "GetPublicKey", "vim.version.version2", (), (0, "string", "string"), "System.View", None), ("setPublicKey", "SetPublicKey", "vim.version.version2", (("extensionKey", "string", "vim.version.version2", 0, None),("publicKey", "string", "vim.version.version2", 0, None),), (0, "void", "void"), "Extension.Update", None), ("setCertificate", "SetExtensionCertificate", "vim.version.version5", (("extensionKey", "string", "vim.version.version5", 0, None),("certificatePem", "string", "vim.version.version5", F_OPTIONAL, None),), (0, "void", "void"), "Extension.Update", ["vim.fault.NotFound", "vim.fault.NoClientCertificate", ]), ("queryManagedBy", "QueryManagedBy", "vim.version.version7", (("extensionKey", "string", "vim.version.version7", 0, None),), (F_OPTIONAL, "vim.ManagedEntity[]", "vim.ManagedEntity[]"), "System.View", None), ("queryExtensionIpAllocationUsage", "QueryExtensionIpAllocationUsage", "vim.version.version8", (("extensionKeys", "string[]", "vim.version.version8", F_OPTIONAL, None),), (F_OPTIONAL, "vim.ExtensionManager.IpAllocationUsage[]", "vim.ExtensionManager.IpAllocationUsage[]"), "System.View", None)]) +CreateDataType("vim.ExtensionManager.IpAllocationUsage", "ExtensionManagerIpAllocationUsage", "vmodl.DynamicData", "vim.version.version8", [("extensionKey", "string", "vim.version.version8", 0), ("numAddresses", "int", "vim.version.version8", 0)]) +CreateManagedType("vim.FileManager", "FileManager", "vmodl.ManagedObject", "vim.version.version2", None, [("moveFile", "MoveDatastoreFile_Task", "vim.version.version2", (("sourceName", "string", "vim.version.version2", 0, None),("sourceDatacenter", "vim.Datacenter", "vim.version.version2", F_OPTIONAL, "System.View"),("destinationName", "string", "vim.version.version2", 0, None),("destinationDatacenter", "vim.Datacenter", "vim.version.version2", F_OPTIONAL, "System.View"),("force", "boolean", "vim.version.version2", F_OPTIONAL, None),), (0, "vim.Task", "void"), None, ["vim.fault.InvalidDatastore", "vim.fault.FileFault", ]), ("copyFile", "CopyDatastoreFile_Task", "vim.version.version2", (("sourceName", "string", "vim.version.version2", 0, None),("sourceDatacenter", "vim.Datacenter", "vim.version.version2", F_OPTIONAL, "System.View"),("destinationName", "string", "vim.version.version2", 0, None),("destinationDatacenter", "vim.Datacenter", "vim.version.version2", F_OPTIONAL, "System.View"),("force", "boolean", "vim.version.version2", F_OPTIONAL, None),), (0, "vim.Task", "void"), None, ["vim.fault.InvalidDatastore", "vim.fault.FileFault", ]), ("deleteFile", "DeleteDatastoreFile_Task", "vim.version.version2", (("name", "string", "vim.version.version2", 0, None),("datacenter", "vim.Datacenter", "vim.version.version2", F_OPTIONAL, "System.View"),), (0, "vim.Task", "void"), None, ["vim.fault.InvalidDatastore", "vim.fault.FileFault", ]), ("makeDirectory", "MakeDirectory", "vim.version.version2", (("name", "string", "vim.version.version2", 0, None),("datacenter", "vim.Datacenter", "vim.version.version2", F_OPTIONAL, "System.View"),("createParentDirectories", "boolean", "vim.version.version2", F_OPTIONAL, None),), (0, "void", "void"), None, ["vim.fault.InvalidDatastore", "vim.fault.FileFault", ]), ("changeOwner", "ChangeOwner", "vim.version.version5", (("name", "string", "vim.version.version5", 0, None),("datacenter", "vim.Datacenter", "vim.version.version5", F_OPTIONAL, "System.View"),("owner", "string", "vim.version.version5", 0, None),), (0, "void", "void"), None, ["vim.fault.InvalidDatastore", "vim.fault.FileFault", "vim.fault.UserNotFound", ])]) +CreateEnumType("vim.FileManager.FileType", "FileManagerFileType", "vim.version.version2", ["File", "VirtualDisk"]) +CreateDataType("vim.HbrManager.ReplicationVmInfo", "HbrManagerReplicationVmInfo", "vmodl.DynamicData", "vim.version.version7", [("state", "string", "vim.version.version7", 0), ("progressInfo", "vim.HbrManager.ReplicationVmInfo.ProgressInfo", "vim.version.version7", F_OPTIONAL), ("imageId", "string", "vim.version.version7", F_OPTIONAL), ("lastError", "vmodl.MethodFault", "vim.version.version7", F_OPTIONAL)]) +CreateEnumType("vim.HbrManager.ReplicationVmInfo.State", "ReplicationVmState", "vim.version.version7", ["none", "paused", "syncing", "idle", "active", "error"]) +CreateDataType("vim.HbrManager.ReplicationVmInfo.ProgressInfo", "ReplicationVmProgressInfo", "vmodl.DynamicData", "vim.version.version7", [("progress", "int", "vim.version.version7", 0), ("bytesTransferred", "long", "vim.version.version7", 0), ("bytesToTransfer", "long", "vim.version.version7", 0), ("checksumTotalBytes", "long", "vim.version.version7", F_OPTIONAL), ("checksumComparedBytes", "long", "vim.version.version7", F_OPTIONAL)]) +CreateManagedType("vim.HistoryCollector", "HistoryCollector", "vmodl.ManagedObject", "vim.version.version1", [("filter", "anyType", "vim.version.version1", 0, None)], [("setLatestPageSize", "SetCollectorPageSize", "vim.version.version1", (("maxCount", "int", "vim.version.version1", 0, None),), (0, "void", "void"), None, None), ("rewind", "RewindCollector", "vim.version.version1", (), (0, "void", "void"), None, None), ("reset", "ResetCollector", "vim.version.version1", (), (0, "void", "void"), None, None), ("remove", "DestroyCollector", "vim.version.version1", (), (0, "void", "void"), None, None)]) +CreateDataType("vim.HostServiceTicket", "HostServiceTicket", "vmodl.DynamicData", "vim.version.version1", [("host", "string", "vim.version.version1", F_OPTIONAL), ("port", "int", "vim.version.version1", F_OPTIONAL), ("sslThumbprint", "string", "vim.version.version2", F_OPTIONAL), ("service", "string", "vim.version.version1", 0), ("serviceVersion", "string", "vim.version.version1", 0), ("sessionId", "string", "vim.version.version1", 0)]) +CreateManagedType("vim.HttpNfcLease", "HttpNfcLease", "vmodl.ManagedObject", "vim.version.version5", [("initializeProgress", "int", "vim.version.version5", 0, None), ("info", "vim.HttpNfcLease.Info", "vim.version.version5", F_OPTIONAL, None), ("state", "vim.HttpNfcLease.State", "vim.version.version5", 0, None), ("error", "vmodl.MethodFault", "vim.version.version5", F_OPTIONAL, None)], [("getManifest", "HttpNfcLeaseGetManifest", "vim.version.version6", (), (F_OPTIONAL, "vim.HttpNfcLease.ManifestEntry[]", "vim.HttpNfcLease.ManifestEntry[]"), None, ["vim.fault.Timedout", "vim.fault.InvalidState", ]), ("complete", "HttpNfcLeaseComplete", "vim.version.version5", (), (0, "void", "void"), None, ["vim.fault.Timedout", "vim.fault.InvalidState", ]), ("abort", "HttpNfcLeaseAbort", "vim.version.version5", (("fault", "vmodl.MethodFault", "vim.version.version5", F_OPTIONAL, None),), (0, "void", "void"), None, ["vim.fault.Timedout", "vim.fault.InvalidState", ]), ("progress", "HttpNfcLeaseProgress", "vim.version.version5", (("percent", "int", "vim.version.version5", 0, None),), (0, "void", "void"), None, ["vim.fault.Timedout", ])]) +CreateEnumType("vim.HttpNfcLease.State", "HttpNfcLeaseState", "vim.version.version5", ["initializing", "ready", "done", "error"]) +CreateDataType("vim.HttpNfcLease.DatastoreLeaseInfo", "HttpNfcLeaseDatastoreLeaseInfo", "vmodl.DynamicData", "vim.version.version6", [("datastoreKey", "string", "vim.version.version6", 0), ("hosts", "vim.HttpNfcLease.HostInfo[]", "vim.version.version6", 0)]) +CreateDataType("vim.HttpNfcLease.HostInfo", "HttpNfcLeaseHostInfo", "vmodl.DynamicData", "vim.version.version6", [("url", "string", "vim.version.version6", 0), ("sslThumbprint", "string", "vim.version.version6", 0)]) +CreateDataType("vim.HttpNfcLease.Info", "HttpNfcLeaseInfo", "vmodl.DynamicData", "vim.version.version5", [("lease", "vim.HttpNfcLease", "vim.version.version5", 0), ("entity", "vim.ManagedEntity", "vim.version.version5", 0), ("deviceUrl", "vim.HttpNfcLease.DeviceUrl[]", "vim.version.version5", F_OPTIONAL), ("totalDiskCapacityInKB", "long", "vim.version.version5", 0), ("leaseTimeout", "int", "vim.version.version5", 0), ("hostMap", "vim.HttpNfcLease.DatastoreLeaseInfo[]", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.HttpNfcLease.DeviceUrl", "HttpNfcLeaseDeviceUrl", "vmodl.DynamicData", "vim.version.version5", [("key", "string", "vim.version.version5", 0), ("importKey", "string", "vim.version.version5", 0), ("url", "string", "vim.version.version5", 0), ("sslThumbprint", "string", "vim.version.version5", 0), ("disk", "boolean", "vim.version.version6", F_OPTIONAL), ("targetId", "string", "vim.version.version6", F_OPTIONAL), ("datastoreKey", "string", "vim.version.version6", F_OPTIONAL), ("fileSize", "long", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.HttpNfcLease.ManifestEntry", "HttpNfcLeaseManifestEntry", "vmodl.DynamicData", "vim.version.version6", [("key", "string", "vim.version.version6", 0), ("sha1", "string", "vim.version.version6", 0), ("size", "long", "vim.version.version6", 0), ("disk", "boolean", "vim.version.version6", 0), ("capacity", "long", "vim.version.version6", F_OPTIONAL), ("populatedSize", "long", "vim.version.version6", F_OPTIONAL)]) +CreateEnumType("vim.ImageLibraryManager.MediaType", "ImageLibraryManagerMediaType", "vim.version.version5", ["Ovf", "Vmdk", "Iso", "Flp", "Cust", "Generic"]) +CreateDataType("vim.InheritablePolicy", "InheritablePolicy", "vmodl.DynamicData", "vim.version.version5", [("inherited", "boolean", "vim.version.version5", 0)]) +CreateDataType("vim.IntPolicy", "IntPolicy", "vim.InheritablePolicy", "vim.version.version5", [("value", "int", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.InternalStatsCollector.StatsSet", "InternalStatsSet", "vim.version.version5", ["vmMemoryOverheadStats", "vmFaultToleranceStats"]) +CreateManagedType("vim.IpPoolManager", "IpPoolManager", "vmodl.ManagedObject", "vim.version.version5", None, [("queryIpPools", "QueryIpPools", "vim.version.version5", (("dc", "vim.Datacenter", "vim.version.version5", 0, "System.Read"),), (F_OPTIONAL, "vim.vApp.IpPool[]", "vim.vApp.IpPool[]"), None, None), ("createIpPool", "CreateIpPool", "vim.version.version5", (("dc", "vim.Datacenter", "vim.version.version5", 0, "Datacenter.IpPoolConfig"),("pool", "vim.vApp.IpPool", "vim.version.version5", 0, None),), (0, "int", "int"), None, None), ("updateIpPool", "UpdateIpPool", "vim.version.version5", (("dc", "vim.Datacenter", "vim.version.version5", 0, "Datacenter.IpPoolConfig"),("pool", "vim.vApp.IpPool", "vim.version.version5", 0, None),), (0, "void", "void"), None, None), ("destroyIpPool", "DestroyIpPool", "vim.version.version5", (("dc", "vim.Datacenter", "vim.version.version5", 0, "Datacenter.IpPoolConfig"),("id", "int", "vim.version.version5", 0, None),("force", "boolean", "vim.version.version5", 0, None),), (0, "void", "void"), None, ["vim.fault.InvalidState", ]), ("allocateIpv4Address", "AllocateIpv4Address", "vim.version.version8", (("dc", "vim.Datacenter", "vim.version.version8", 0, None),("poolId", "int", "vim.version.version8", 0, None),("allocationId", "string", "vim.version.version8", 0, None),), (0, "string", "string"), None, None), ("allocateIpv6Address", "AllocateIpv6Address", "vim.version.version8", (("dc", "vim.Datacenter", "vim.version.version8", 0, None),("poolId", "int", "vim.version.version8", 0, None),("allocationId", "string", "vim.version.version8", 0, None),), (0, "string", "string"), None, None), ("releaseIpAllocation", "ReleaseIpAllocation", "vim.version.version8", (("dc", "vim.Datacenter", "vim.version.version8", 0, "Datacenter.IpPoolReleaseIp"),("poolId", "int", "vim.version.version8", 0, None),("allocationId", "string", "vim.version.version8", 0, None),), (0, "void", "void"), None, None), ("queryIPAllocations", "QueryIPAllocations", "vim.version.version8", (("dc", "vim.Datacenter", "vim.version.version8", 0, "Datacenter.IpPoolQueryAllocations"),("poolId", "int", "vim.version.version8", 0, None),("extensionKey", "string", "vim.version.version8", 0, None),), (0, "vim.IpPoolManager.IpAllocation[]", "vim.IpPoolManager.IpAllocation[]"), None, None)]) +CreateDataType("vim.IpPoolManager.IpAllocation", "IpPoolManagerIpAllocation", "vmodl.DynamicData", "vim.version.version8", [("ipAddress", "string", "vim.version.version8", 0), ("allocationId", "string", "vim.version.version8", 0)]) +CreateDataType("vim.KeyValue", "KeyValue", "vmodl.DynamicData", "vim.version.version2", [("key", "string", "vim.version.version2", 0), ("value", "string", "vim.version.version2", 0)]) +CreateDataType("vim.LatencySensitivity", "LatencySensitivity", "vmodl.DynamicData", "vim.version.version8", [("level", "vim.LatencySensitivity.SensitivityLevel", "vim.version.version8", 0), ("sensitivity", "int", "vim.version.version8", F_OPTIONAL)]) +CreateEnumType("vim.LatencySensitivity.SensitivityLevel", "LatencySensitivitySensitivityLevel", "vim.version.version8", ["low", "normal", "medium", "high", "custom"]) +CreateManagedType("vim.LicenseManager", "LicenseManager", "vmodl.ManagedObject", "vim.version.version1", [("source", "vim.LicenseManager.LicenseSource", "vim.version.version1", 0, None), ("sourceAvailable", "boolean", "vim.version.version1", 0, None), ("diagnostics", "vim.LicenseManager.DiagnosticInfo", "vim.version.version2", F_OPTIONAL, None), ("featureInfo", "vim.LicenseManager.FeatureInfo[]", "vim.version.version1", F_OPTIONAL, None), ("licensedEdition", "string", "vim.version.version2", 0, None), ("licenses", "vim.LicenseManager.LicenseInfo[]", "vim.version.version5", 0, None), ("licenseAssignmentManager", "vim.LicenseAssignmentManager", "vim.version.version5", F_OPTIONAL, "System.View"), ("evaluation", "vim.LicenseManager.EvaluationInfo", "vim.version.version5", 0, "System.Read")], [("querySupportedFeatures", "QuerySupportedFeatures", "vim.version.version2", (("host", "vim.HostSystem", "vim.version.version2", F_OPTIONAL, None),), (F_OPTIONAL, "vim.LicenseManager.FeatureInfo[]", "vim.LicenseManager.FeatureInfo[]"), "Global.Licenses", None), ("querySourceAvailability", "QueryLicenseSourceAvailability", "vim.version.version1", (("host", "vim.HostSystem", "vim.version.version1", F_OPTIONAL, None),), (F_OPTIONAL, "vim.LicenseManager.AvailabilityInfo[]", "vim.LicenseManager.AvailabilityInfo[]"), "Global.Licenses", None), ("queryUsage", "QueryLicenseUsage", "vim.version.version1", (("host", "vim.HostSystem", "vim.version.version1", F_OPTIONAL, None),), (0, "vim.LicenseManager.LicenseUsageInfo", "vim.LicenseManager.LicenseUsageInfo"), "System.Read", None), ("setEdition", "SetLicenseEdition", "vim.version.version1", (("host", "vim.HostSystem", "vim.version.version1", F_OPTIONAL, None),("featureKey", "string", "vim.version.version1", F_OPTIONAL, None),), (0, "void", "void"), "Global.Licenses", ["vim.fault.InvalidState", "vim.fault.LicenseServerUnavailable", ]), ("checkFeature", "CheckLicenseFeature", "vim.version.version1", (("host", "vim.HostSystem", "vim.version.version1", F_OPTIONAL, None),("featureKey", "string", "vim.version.version1", 0, None),), (0, "boolean", "boolean"), "System.Read", ["vim.fault.InvalidState", ]), ("enable", "EnableFeature", "vim.version.version1", (("host", "vim.HostSystem", "vim.version.version1", F_OPTIONAL, None),("featureKey", "string", "vim.version.version1", 0, None),), (0, "boolean", "boolean"), "Global.Licenses", ["vim.fault.InvalidState", "vim.fault.LicenseServerUnavailable", ]), ("disable", "DisableFeature", "vim.version.version1", (("host", "vim.HostSystem", "vim.version.version1", F_OPTIONAL, None),("featureKey", "string", "vim.version.version1", 0, None),), (0, "boolean", "boolean"), "Global.Licenses", ["vim.fault.InvalidState", "vim.fault.LicenseServerUnavailable", ]), ("configureSource", "ConfigureLicenseSource", "vim.version.version1", (("host", "vim.HostSystem", "vim.version.version1", F_OPTIONAL, None),("licenseSource", "vim.LicenseManager.LicenseSource", "vim.version.version1", 0, None),), (0, "void", "void"), "Global.Licenses", ["vim.fault.CannotAccessLocalSource", "vim.fault.InvalidLicense", "vim.fault.LicenseServerUnavailable", ]), ("updateLicense", "UpdateLicense", "vim.version.version5", (("licenseKey", "string", "vim.version.version5", 0, None),("labels", "vim.KeyValue[]", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.LicenseManager.LicenseInfo", "vim.LicenseManager.LicenseInfo"), "Global.Licenses", None), ("addLicense", "AddLicense", "vim.version.version5", (("licenseKey", "string", "vim.version.version5", 0, None),("labels", "vim.KeyValue[]", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.LicenseManager.LicenseInfo", "vim.LicenseManager.LicenseInfo"), "Global.Licenses", None), ("removeLicense", "RemoveLicense", "vim.version.version5", (("licenseKey", "string", "vim.version.version5", 0, None),), (0, "void", "void"), "Global.Licenses", None), ("decodeLicense", "DecodeLicense", "vim.version.version5", (("licenseKey", "string", "vim.version.version5", 0, None),), (0, "vim.LicenseManager.LicenseInfo", "vim.LicenseManager.LicenseInfo"), "Global.Licenses", None), ("updateLabel", "UpdateLicenseLabel", "vim.version.version5", (("licenseKey", "string", "vim.version.version5", 0, None),("labelKey", "string", "vim.version.version5", 0, None),("labelValue", "string", "vim.version.version5", 0, None),), (0, "void", "void"), "Global.Licenses", None), ("removeLabel", "RemoveLicenseLabel", "vim.version.version5", (("licenseKey", "string", "vim.version.version5", 0, None),("labelKey", "string", "vim.version.version5", 0, None),), (0, "void", "void"), "Global.Licenses", None)]) +CreateEnumType("vim.LicenseManager.LicenseState", "LicenseManagerState", "vim.version.version2", ["initializing", "normal", "marginal", "fault"]) +CreateEnumType("vim.LicenseManager.LicenseKey", "LicenseManagerLicenseKey", "vim.version.version1", ["esxFull", "esxVmtn", "esxExpress", "san", "iscsi", "nas", "vsmp", "backup", "vc", "vcExpress", "esxHost", "gsxHost", "serverHost", "drsPower", "vmotion", "drs", "das"]) +CreateDataType("vim.LicenseManager.LicenseSource", "LicenseSource", "vmodl.DynamicData", "vim.version.version1", None) +CreateDataType("vim.LicenseManager.LicenseServer", "LicenseServerSource", "vim.LicenseManager.LicenseSource", "vim.version.version1", [("licenseServer", "string", "vim.version.version1", 0)]) +CreateDataType("vim.LicenseManager.LocalLicense", "LocalLicenseSource", "vim.LicenseManager.LicenseSource", "vim.version.version1", [("licenseKeys", "string", "vim.version.version1", 0)]) +CreateDataType("vim.LicenseManager.EvaluationLicense", "EvaluationLicenseSource", "vim.LicenseManager.LicenseSource", "vim.version.version2", [("remainingHours", "long", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.LicenseManager.FeatureInfo", "LicenseFeatureInfo", "vmodl.DynamicData", "vim.version.version1", [("key", "string", "vim.version.version1", 0), ("featureName", "string", "vim.version.version1", 0), ("featureDescription", "string", "vim.version.version2", F_OPTIONAL), ("state", "vim.LicenseManager.FeatureInfo.State", "vim.version.version1", F_OPTIONAL), ("costUnit", "string", "vim.version.version1", 0), ("sourceRestriction", "string", "vim.version.version2", F_OPTIONAL), ("dependentKey", "string[]", "vim.version.version2", F_OPTIONAL), ("edition", "boolean", "vim.version.version2", F_OPTIONAL), ("expiresOn", "vmodl.DateTime", "vim.version.version2", F_OPTIONAL)]) +CreateEnumType("vim.LicenseManager.FeatureInfo.CostUnit", "LicenseFeatureInfoUnit", "vim.version.version1", ["host", "cpuCore", "cpuPackage", "server", "vm"]) +CreateEnumType("vim.LicenseManager.FeatureInfo.State", "LicenseFeatureInfoState", "vim.version.version1", ["enabled", "disabled", "optional"]) +CreateEnumType("vim.LicenseManager.FeatureInfo.SourceRestriction", "LicenseFeatureInfoSourceRestriction", "vim.version.version2", ["unrestricted", "served", "file"]) +CreateDataType("vim.LicenseManager.ReservationInfo", "LicenseReservationInfo", "vmodl.DynamicData", "vim.version.version1", [("key", "string", "vim.version.version1", 0), ("state", "vim.LicenseManager.ReservationInfo.State", "vim.version.version1", 0), ("required", "int", "vim.version.version1", 0)]) +CreateEnumType("vim.LicenseManager.ReservationInfo.State", "LicenseReservationInfoState", "vim.version.version1", ["notUsed", "noLicense", "unlicensedUse", "licensed"]) +CreateDataType("vim.LicenseManager.AvailabilityInfo", "LicenseAvailabilityInfo", "vmodl.DynamicData", "vim.version.version1", [("feature", "vim.LicenseManager.FeatureInfo", "vim.version.version1", 0), ("total", "int", "vim.version.version1", 0), ("available", "int", "vim.version.version1", 0)]) +CreateDataType("vim.LicenseManager.DiagnosticInfo", "LicenseDiagnostics", "vmodl.DynamicData", "vim.version.version2", [("sourceLastChanged", "vmodl.DateTime", "vim.version.version2", 0), ("sourceLost", "string", "vim.version.version2", 0), ("sourceLatency", "float", "vim.version.version2", 0), ("licenseRequests", "string", "vim.version.version2", 0), ("licenseRequestFailures", "string", "vim.version.version2", 0), ("licenseFeatureUnknowns", "string", "vim.version.version2", 0), ("opState", "vim.LicenseManager.LicenseState", "vim.version.version2", 0), ("lastStatusUpdate", "vmodl.DateTime", "vim.version.version2", 0), ("opFailureMessage", "string", "vim.version.version2", 0)]) +CreateDataType("vim.LicenseManager.LicenseUsageInfo", "LicenseUsageInfo", "vmodl.DynamicData", "vim.version.version1", [("source", "vim.LicenseManager.LicenseSource", "vim.version.version1", 0), ("sourceAvailable", "boolean", "vim.version.version1", 0), ("reservationInfo", "vim.LicenseManager.ReservationInfo[]", "vim.version.version1", F_OPTIONAL), ("featureInfo", "vim.LicenseManager.FeatureInfo[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.LicenseManager.EvaluationInfo", "LicenseManagerEvaluationInfo", "vmodl.DynamicData", "vim.version.version5", [("properties", "vmodl.KeyAnyValue[]", "vim.version.version5", 0)]) +CreateDataType("vim.LicenseManager.LicensableResourceInfo", "HostLicensableResourceInfo", "vmodl.DynamicData", "vim.version.version7", [("resource", "vmodl.KeyAnyValue[]", "vim.version.version7", 0)]) +CreateEnumType("vim.LicenseManager.LicensableResourceInfo.ResourceKey", "HostLicensableResourceKey", "vim.version.version7", ["numCpuPackages", "numCpuCores", "memorySize", "memoryForVms", "numVmsStarted", "numVmsStarting"]) +CreateDataType("vim.LicenseManager.LicenseInfo", "LicenseManagerLicenseInfo", "vmodl.DynamicData", "vim.version.version5", [("licenseKey", "string", "vim.version.version5", 0), ("editionKey", "string", "vim.version.version5", 0), ("name", "string", "vim.version.version5", 0), ("total", "int", "vim.version.version5", 0), ("used", "int", "vim.version.version5", F_OPTIONAL), ("costUnit", "string", "vim.version.version5", 0), ("properties", "vmodl.KeyAnyValue[]", "vim.version.version5", F_OPTIONAL), ("labels", "vim.KeyValue[]", "vim.version.version5", F_OPTIONAL)]) +CreateManagedType("vim.LocalizationManager", "LocalizationManager", "vmodl.ManagedObject", "vim.version.version5", [("catalog", "vim.LocalizationManager.MessageCatalog[]", "vim.version.version5", F_OPTIONAL, "System.View")], None) +CreateDataType("vim.LocalizationManager.MessageCatalog", "LocalizationManagerMessageCatalog", "vmodl.DynamicData", "vim.version.version5", [("moduleName", "string", "vim.version.version5", 0), ("catalogName", "string", "vim.version.version5", 0), ("locale", "string", "vim.version.version5", 0), ("catalogUri", "string", "vim.version.version5", 0), ("lastModified", "vmodl.DateTime", "vim.version.version5", F_OPTIONAL), ("md5sum", "string", "vim.version.version5", F_OPTIONAL), ("version", "string", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.LongPolicy", "LongPolicy", "vim.InheritablePolicy", "vim.version.version5", [("value", "long", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.MethodDescription", "MethodDescription", "vim.Description", "vim.version.version1", [("key", "vmodl.MethodName", "vim.version.version1", 0)]) +CreateDataType("vim.NegatableExpression", "NegatableExpression", "vmodl.DynamicData", "vim.version.version9", [("negate", "boolean", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.NumericRange", "NumericRange", "vmodl.DynamicData", "vim.version.version5", [("start", "int", "vim.version.version5", 0), ("end", "int", "vim.version.version5", 0)]) +CreateDataType("vim.OvfConsumer.OvfSection", "OvfConsumerOvfSection", "vmodl.DynamicData", "vim.version.version7", [("lineNumber", "int", "vim.version.version7", 0), ("xml", "string", "vim.version.version7", 0)]) +CreateEnumType("vim.OvfConsumer.OstNodeType", "OvfConsumerOstNodeType", "vim.version.version7", ["envelope", "virtualSystem", "virtualSystemCollection"]) +CreateDataType("vim.OvfConsumer.OstNode", "OvfConsumerOstNode", "vmodl.DynamicData", "vim.version.version7", [("id", "string", "vim.version.version7", 0), ("type", "string", "vim.version.version7", 0), ("section", "vim.OvfConsumer.OvfSection[]", "vim.version.version7", F_OPTIONAL), ("child", "vim.OvfConsumer.OstNode[]", "vim.version.version7", F_OPTIONAL), ("entity", "vim.ManagedEntity", "vim.version.version7", F_OPTIONAL)]) +CreateManagedType("vim.OvfManager", "OvfManager", "vmodl.ManagedObject", "vim.version.version5", [("ovfImportOption", "vim.OvfManager.OvfOptionInfo[]", "vim.version.version8", F_OPTIONAL, "System.View"), ("ovfExportOption", "vim.OvfManager.OvfOptionInfo[]", "vim.version.version8", F_OPTIONAL, "System.View")], [("validateHost", "ValidateHost", "vim.version.version5", (("ovfDescriptor", "string", "vim.version.version5", 0, None),("host", "vim.HostSystem", "vim.version.version5", 0, None),("vhp", "vim.OvfManager.ValidateHostParams", "vim.version.version5", 0, None),), (0, "vim.OvfManager.ValidateHostResult", "vim.OvfManager.ValidateHostResult"), "System.View", ["vim.fault.TaskInProgress", "vim.fault.ConcurrentAccess", "vim.fault.FileFault", "vim.fault.InvalidState", ]), ("parseDescriptor", "ParseDescriptor", "vim.version.version5", (("ovfDescriptor", "string", "vim.version.version5", 0, None),("pdp", "vim.OvfManager.ParseDescriptorParams", "vim.version.version5", 0, None),), (0, "vim.OvfManager.ParseDescriptorResult", "vim.OvfManager.ParseDescriptorResult"), "System.View", ["vim.fault.TaskInProgress", "vim.fault.VmConfigFault", "vim.fault.ConcurrentAccess", "vim.fault.FileFault", "vim.fault.InvalidState", ]), ("createImportSpec", "CreateImportSpec", "vim.version.version5", (("ovfDescriptor", "string", "vim.version.version5", 0, None),("resourcePool", "vim.ResourcePool", "vim.version.version5", 0, "VApp.Import"),("datastore", "vim.Datastore", "vim.version.version5", 0, "Datastore.AllocateSpace"),("cisp", "vim.OvfManager.CreateImportSpecParams", "vim.version.version5", 0, None),), (0, "vim.OvfManager.CreateImportSpecResult", "vim.OvfManager.CreateImportSpecResult"), "System.View", ["vim.fault.TaskInProgress", "vim.fault.VmConfigFault", "vim.fault.ConcurrentAccess", "vim.fault.FileFault", "vim.fault.InvalidState", "vim.fault.InvalidDatastore", ]), ("createDescriptor", "CreateDescriptor", "vim.version.version5", (("obj", "vim.ManagedEntity", "vim.version.version5", 0, "VApp.Export"),("cdp", "vim.OvfManager.CreateDescriptorParams", "vim.version.version5", 0, None),), (0, "vim.OvfManager.CreateDescriptorResult", "vim.OvfManager.CreateDescriptorResult"), "System.View", ["vim.fault.TaskInProgress", "vim.fault.VmConfigFault", "vim.fault.ConcurrentAccess", "vim.fault.FileFault", "vim.fault.InvalidState", ])]) +CreateDataType("vim.OvfManager.OvfOptionInfo", "OvfOptionInfo", "vmodl.DynamicData", "vim.version.version8", [("option", "string", "vim.version.version8", 0), ("description", "vmodl.LocalizableMessage", "vim.version.version8", 0)]) +CreateDataType("vim.OvfManager.DeploymentOption", "OvfDeploymentOption", "vmodl.DynamicData", "vim.version.version5", [("key", "string", "vim.version.version5", 0), ("label", "string", "vim.version.version5", 0), ("description", "string", "vim.version.version5", 0)]) +CreateDataType("vim.OvfManager.CommonParams", "OvfManagerCommonParams", "vmodl.DynamicData", "vim.version.version5", [("locale", "string", "vim.version.version5", 0), ("deploymentOption", "string", "vim.version.version5", 0), ("msgBundle", "vim.KeyValue[]", "vim.version.version5", F_OPTIONAL), ("importOption", "string[]", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.OvfManager.ValidateHostParams", "OvfValidateHostParams", "vim.OvfManager.CommonParams", "vim.version.version5", None) +CreateDataType("vim.OvfManager.ValidateHostResult", "OvfValidateHostResult", "vmodl.DynamicData", "vim.version.version5", [("downloadSize", "long", "vim.version.version5", F_OPTIONAL), ("flatDeploymentSize", "long", "vim.version.version5", F_OPTIONAL), ("sparseDeploymentSize", "long", "vim.version.version5", F_OPTIONAL), ("error", "vmodl.MethodFault[]", "vim.version.version5", F_OPTIONAL), ("warning", "vmodl.MethodFault[]", "vim.version.version5", F_OPTIONAL), ("supportedDiskProvisioning", "string[]", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.OvfManager.ParseDescriptorParams", "OvfParseDescriptorParams", "vim.OvfManager.CommonParams", "vim.version.version5", None) +CreateDataType("vim.OvfManager.ParseDescriptorResult", "OvfParseDescriptorResult", "vmodl.DynamicData", "vim.version.version5", [("eula", "string[]", "vim.version.version5", F_OPTIONAL), ("network", "vim.OvfManager.NetworkInfo[]", "vim.version.version5", F_OPTIONAL), ("ipAllocationScheme", "string[]", "vim.version.version5", F_OPTIONAL), ("ipProtocols", "string[]", "vim.version.version5", F_OPTIONAL), ("property", "vim.vApp.PropertyInfo[]", "vim.version.version5", F_OPTIONAL), ("productInfo", "vim.vApp.ProductInfo", "vim.version.version5", F_OPTIONAL), ("annotation", "string", "vim.version.version5", 0), ("approximateDownloadSize", "long", "vim.version.version5", F_OPTIONAL), ("approximateFlatDeploymentSize", "long", "vim.version.version5", F_OPTIONAL), ("approximateSparseDeploymentSize", "long", "vim.version.version5", F_OPTIONAL), ("defaultEntityName", "string", "vim.version.version5", 0), ("virtualApp", "boolean", "vim.version.version5", 0), ("deploymentOption", "vim.OvfManager.DeploymentOption[]", "vim.version.version5", F_OPTIONAL), ("defaultDeploymentOption", "string", "vim.version.version5", 0), ("entityName", "vim.KeyValue[]", "vim.version.version6", F_OPTIONAL), ("annotatedOst", "vim.OvfConsumer.OstNode", "vim.version.version7", F_OPTIONAL), ("error", "vmodl.MethodFault[]", "vim.version.version5", F_OPTIONAL), ("warning", "vmodl.MethodFault[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.OvfManager.NetworkInfo", "OvfNetworkInfo", "vmodl.DynamicData", "vim.version.version5", [("name", "string", "vim.version.version5", 0), ("description", "string", "vim.version.version5", 0)]) +CreateDataType("vim.OvfManager.CreateImportSpecParams", "OvfCreateImportSpecParams", "vim.OvfManager.CommonParams", "vim.version.version5", [("entityName", "string", "vim.version.version5", 0), ("hostSystem", "vim.HostSystem", "vim.version.version5", F_OPTIONAL), ("networkMapping", "vim.OvfManager.NetworkMapping[]", "vim.version.version5", F_OPTIONAL), ("ipAllocationPolicy", "string", "vim.version.version5", F_OPTIONAL), ("ipProtocol", "string", "vim.version.version5", F_OPTIONAL), ("propertyMapping", "vim.KeyValue[]", "vim.version.version5", F_OPTIONAL), ("resourceMapping", "vim.OvfManager.ResourceMap[]", "vim.version.version6", F_OPTIONAL), ("diskProvisioning", "string", "vim.version.version6", F_OPTIONAL), ("instantiationOst", "vim.OvfConsumer.OstNode", "vim.version.version7", F_OPTIONAL)]) +CreateEnumType("vim.OvfManager.CreateImportSpecParams.DiskProvisioningType", "OvfCreateImportSpecParamsDiskProvisioningType", "vim.version.version6", ["monolithicSparse", "monolithicFlat", "twoGbMaxExtentSparse", "twoGbMaxExtentFlat", "thin", "thick", "seSparse", "eagerZeroedThick", "sparse", "flat"]) +CreateDataType("vim.OvfManager.ResourceMap", "OvfResourceMap", "vmodl.DynamicData", "vim.version.version6", [("source", "string", "vim.version.version6", 0), ("parent", "vim.ResourcePool", "vim.version.version6", F_OPTIONAL), ("resourceSpec", "vim.ResourceConfigSpec", "vim.version.version6", F_OPTIONAL), ("datastore", "vim.Datastore", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.OvfManager.NetworkMapping", "OvfNetworkMapping", "vmodl.DynamicData", "vim.version.version5", [("name", "string", "vim.version.version5", 0), ("network", "vim.Network", "vim.version.version5", 0)]) +CreateDataType("vim.OvfManager.CreateImportSpecResult", "OvfCreateImportSpecResult", "vmodl.DynamicData", "vim.version.version5", [("importSpec", "vim.ImportSpec", "vim.version.version5", F_OPTIONAL), ("fileItem", "vim.OvfManager.FileItem[]", "vim.version.version5", F_OPTIONAL), ("warning", "vmodl.MethodFault[]", "vim.version.version5", F_OPTIONAL), ("error", "vmodl.MethodFault[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.OvfManager.FileItem", "OvfFileItem", "vmodl.DynamicData", "vim.version.version5", [("deviceId", "string", "vim.version.version5", 0), ("path", "string", "vim.version.version5", 0), ("compressionMethod", "string", "vim.version.version5", F_OPTIONAL), ("chunkSize", "long", "vim.version.version5", F_OPTIONAL), ("size", "long", "vim.version.version5", F_OPTIONAL), ("cimType", "int", "vim.version.version5", 0), ("create", "boolean", "vim.version.version5", 0)]) +CreateDataType("vim.OvfManager.CreateDescriptorParams", "OvfCreateDescriptorParams", "vmodl.DynamicData", "vim.version.version5", [("ovfFiles", "vim.OvfManager.OvfFile[]", "vim.version.version5", F_OPTIONAL), ("name", "string", "vim.version.version5", F_OPTIONAL), ("description", "string", "vim.version.version5", F_OPTIONAL), ("includeImageFiles", "boolean", "vim.version.version6", F_OPTIONAL), ("exportOption", "string[]", "vim.version.version8", F_OPTIONAL), ("snapshot", "vim.vm.Snapshot", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.OvfManager.CreateDescriptorResult", "OvfCreateDescriptorResult", "vmodl.DynamicData", "vim.version.version5", [("ovfDescriptor", "string", "vim.version.version5", 0), ("error", "vmodl.MethodFault[]", "vim.version.version5", F_OPTIONAL), ("warning", "vmodl.MethodFault[]", "vim.version.version5", F_OPTIONAL), ("includeImageFiles", "boolean", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.OvfManager.OvfFile", "OvfFile", "vmodl.DynamicData", "vim.version.version5", [("deviceId", "string", "vim.version.version5", 0), ("path", "string", "vim.version.version5", 0), ("compressionMethod", "string", "vim.version.version5", F_OPTIONAL), ("chunkSize", "long", "vim.version.version5", F_OPTIONAL), ("size", "long", "vim.version.version5", 0), ("capacity", "long", "vim.version.version6", F_OPTIONAL), ("populatedSize", "long", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.PasswordField", "PasswordField", "vmodl.DynamicData", "vim.version.version5", [("value", "string", "vim.version.version5", 0)]) +CreateDataType("vim.PerformanceDescription", "PerformanceDescription", "vmodl.DynamicData", "vim.version.version1", [("counterType", "vim.ElementDescription[]", "vim.version.version1", 0), ("statsType", "vim.ElementDescription[]", "vim.version.version1", 0)]) +CreateManagedType("vim.PerformanceManager", "PerformanceManager", "vmodl.ManagedObject", "vim.version.version1", [("description", "vim.PerformanceDescription", "vim.version.version1", 0, "System.View"), ("historicalInterval", "vim.HistoricalInterval[]", "vim.version.version1", F_OPTIONAL, "System.View"), ("perfCounter", "vim.PerformanceManager.CounterInfo[]", "vim.version.version1", F_OPTIONAL, "System.View")], [("queryProviderSummary", "QueryPerfProviderSummary", "vim.version.version1", (("entity", "vmodl.ManagedObject", "vim.version.version1", 0, None),), (0, "vim.PerformanceManager.ProviderSummary", "vim.PerformanceManager.ProviderSummary"), "System.Read", None), ("queryAvailableMetric", "QueryAvailablePerfMetric", "vim.version.version1", (("entity", "vmodl.ManagedObject", "vim.version.version1", 0, None),("beginTime", "vmodl.DateTime", "vim.version.version1", F_OPTIONAL, None),("endTime", "vmodl.DateTime", "vim.version.version1", F_OPTIONAL, None),("intervalId", "int", "vim.version.version1", F_OPTIONAL, None),), (F_OPTIONAL, "vim.PerformanceManager.MetricId[]", "vim.PerformanceManager.MetricId[]"), "System.Read", None), ("queryCounter", "QueryPerfCounter", "vim.version.version1", (("counterId", "int[]", "vim.version.version1", 0, None),), (F_OPTIONAL, "vim.PerformanceManager.CounterInfo[]", "vim.PerformanceManager.CounterInfo[]"), "System.View", None), ("queryCounterByLevel", "QueryPerfCounterByLevel", "vim.version.version2", (("level", "int", "vim.version.version2", 0, None),), (0, "vim.PerformanceManager.CounterInfo[]", "vim.PerformanceManager.CounterInfo[]"), "System.View", None), ("queryStats", "QueryPerf", "vim.version.version1", (("querySpec", "vim.PerformanceManager.QuerySpec[]", "vim.version.version1", 0, None),), (F_OPTIONAL, "vim.PerformanceManager.EntityMetricBase[]", "vim.PerformanceManager.EntityMetricBase[]"), "System.View", None), ("queryCompositeStats", "QueryPerfComposite", "vim.version.version1", (("querySpec", "vim.PerformanceManager.QuerySpec", "vim.version.version1", 0, None),), (0, "vim.PerformanceManager.CompositeEntityMetric", "vim.PerformanceManager.CompositeEntityMetric"), "System.View", None), ("createHistoricalInterval", "CreatePerfInterval", "vim.version.version1", (("intervalId", "vim.HistoricalInterval", "vim.version.version1", 0, None),), (0, "void", "void"), "Performance.ModifyIntervals", None), ("removeHistoricalInterval", "RemovePerfInterval", "vim.version.version1", (("samplePeriod", "int", "vim.version.version1", 0, None),), (0, "void", "void"), "Performance.ModifyIntervals", None), ("updateHistoricalInterval", "UpdatePerfInterval", "vim.version.version1", (("interval", "vim.HistoricalInterval", "vim.version.version1", 0, None),), (0, "void", "void"), "Performance.ModifyIntervals", None), ("updateCounterLevelMapping", "UpdateCounterLevelMapping", "vim.version.version6", (("counterLevelMap", "vim.PerformanceManager.CounterLevelMapping[]", "vim.version.version6", 0, None),), (0, "void", "void"), "Performance.ModifyIntervals", None), ("resetCounterLevelMapping", "ResetCounterLevelMapping", "vim.version.version6", (("counters", "int[]", "vim.version.version6", 0, None),), (0, "void", "void"), "Performance.ModifyIntervals", None)]) +CreateEnumType("vim.PerformanceManager.Format", "PerfFormat", "vim.version.version1", ["normal", "csv"]) +CreateDataType("vim.PerformanceManager.ProviderSummary", "PerfProviderSummary", "vmodl.DynamicData", "vim.version.version1", [("entity", "vmodl.ManagedObject", "vim.version.version1", 0), ("currentSupported", "boolean", "vim.version.version1", 0), ("summarySupported", "boolean", "vim.version.version1", 0), ("refreshRate", "int", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.PerformanceManager.CounterInfo", "PerfCounterInfo", "vmodl.DynamicData", "vim.version.version1", [("key", "int", "vim.version.version1", 0), ("nameInfo", "vim.ElementDescription", "vim.version.version1", 0), ("groupInfo", "vim.ElementDescription", "vim.version.version1", 0), ("unitInfo", "vim.ElementDescription", "vim.version.version1", 0), ("rollupType", "vim.PerformanceManager.CounterInfo.RollupType", "vim.version.version1", 0), ("statsType", "vim.PerformanceManager.CounterInfo.StatsType", "vim.version.version1", 0), ("level", "int", "vim.version.version2", F_OPTIONAL), ("perDeviceLevel", "int", "vim.version.version6", F_OPTIONAL), ("associatedCounterId", "int[]", "vim.version.version1", F_OPTIONAL)]) +CreateEnumType("vim.PerformanceManager.CounterInfo.RollupType", "PerfSummaryType", "vim.version.version1", ["average", "maximum", "minimum", "latest", "summation", "none"]) +CreateEnumType("vim.PerformanceManager.CounterInfo.StatsType", "PerfStatsType", "vim.version.version1", ["absolute", "delta", "rate"]) +CreateEnumType("vim.PerformanceManager.CounterInfo.Unit", "PerformanceManagerUnit", "vim.version.version1", ["percent", "kiloBytes", "megaBytes", "megaHertz", "number", "microsecond", "millisecond", "second", "kiloBytesPerSecond", "megaBytesPerSecond", "watt", "joule"]) +CreateDataType("vim.PerformanceManager.MetricId", "PerfMetricId", "vmodl.DynamicData", "vim.version.version1", [("counterId", "int", "vim.version.version1", 0), ("instance", "string", "vim.version.version1", 0)]) +CreateDataType("vim.PerformanceManager.QuerySpec", "PerfQuerySpec", "vmodl.DynamicData", "vim.version.version1", [("entity", "vmodl.ManagedObject", "vim.version.version1", 0), ("startTime", "vmodl.DateTime", "vim.version.version1", F_OPTIONAL), ("endTime", "vmodl.DateTime", "vim.version.version1", F_OPTIONAL), ("maxSample", "int", "vim.version.version1", F_OPTIONAL), ("metricId", "vim.PerformanceManager.MetricId[]", "vim.version.version1", F_OPTIONAL), ("intervalId", "int", "vim.version.version1", F_OPTIONAL), ("format", "string", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.PerformanceManager.SampleInfo", "PerfSampleInfo", "vmodl.DynamicData", "vim.version.version1", [("timestamp", "vmodl.DateTime", "vim.version.version1", 0), ("interval", "int", "vim.version.version1", 0)]) +CreateDataType("vim.PerformanceManager.MetricSeries", "PerfMetricSeries", "vmodl.DynamicData", "vim.version.version1", [("id", "vim.PerformanceManager.MetricId", "vim.version.version1", 0)]) +CreateDataType("vim.PerformanceManager.IntSeries", "PerfMetricIntSeries", "vim.PerformanceManager.MetricSeries", "vim.version.version1", [("value", "long[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.PerformanceManager.MetricSeriesCSV", "PerfMetricSeriesCSV", "vim.PerformanceManager.MetricSeries", "vim.version.version1", [("value", "string", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.PerformanceManager.EntityMetricBase", "PerfEntityMetricBase", "vmodl.DynamicData", "vim.version.version1", [("entity", "vmodl.ManagedObject", "vim.version.version1", 0)]) +CreateDataType("vim.PerformanceManager.EntityMetric", "PerfEntityMetric", "vim.PerformanceManager.EntityMetricBase", "vim.version.version1", [("sampleInfo", "vim.PerformanceManager.SampleInfo[]", "vim.version.version1", F_OPTIONAL), ("value", "vim.PerformanceManager.MetricSeries[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.PerformanceManager.EntityMetricCSV", "PerfEntityMetricCSV", "vim.PerformanceManager.EntityMetricBase", "vim.version.version1", [("sampleInfoCSV", "string", "vim.version.version1", 0), ("value", "vim.PerformanceManager.MetricSeriesCSV[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.PerformanceManager.CompositeEntityMetric", "PerfCompositeMetric", "vmodl.DynamicData", "vim.version.version1", [("entity", "vim.PerformanceManager.EntityMetricBase", "vim.version.version1", F_OPTIONAL), ("childEntity", "vim.PerformanceManager.EntityMetricBase[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.PerformanceManager.CounterLevelMapping", "PerformanceManagerCounterLevelMapping", "vmodl.DynamicData", "vim.version.version6", [("counterId", "int", "vim.version.version6", 0), ("aggregateLevel", "int", "vim.version.version6", F_OPTIONAL), ("perDeviceLevel", "int", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.HistoricalInterval", "PerfInterval", "vmodl.DynamicData", "vim.version.version1", [("key", "int", "vim.version.version2", 0), ("samplingPeriod", "int", "vim.version.version1", 0), ("name", "string", "vim.version.version1", 0), ("length", "int", "vim.version.version1", 0), ("level", "int", "vim.version.version2", F_OPTIONAL), ("enabled", "boolean", "vim.version.version2", 0)]) +CreateDataType("vim.PrivilegePolicyDef", "PrivilegePolicyDef", "vmodl.DynamicData", "vim.version.version2", [("createPrivilege", "string", "vim.version.version2", 0), ("readPrivilege", "string", "vim.version.version2", 0), ("updatePrivilege", "string", "vim.version.version2", 0), ("deletePrivilege", "string", "vim.version.version2", 0)]) +CreateEnumType("vim.ProxyService.AccessMode", "ProxyServiceAccessMode", "vim.version.version2", ["httpOnly", "httpsOnly", "httpsWithRedirect", "httpAndHttps"]) +CreateEnumType("vim.ProxyService.RedirectSpec.RedirectType", "ProxyServiceRedirectSpecRedirectType", "vim.version.version7", ["permanent", "found"]) +CreateDataType("vim.ResourceAllocationInfo", "ResourceAllocationInfo", "vmodl.DynamicData", "vim.version.version1", [("reservation", "long", "vim.version.version1", F_OPTIONAL), ("expandableReservation", "boolean", "vim.version.version1", F_OPTIONAL), ("limit", "long", "vim.version.version1", F_OPTIONAL), ("shares", "vim.SharesInfo", "vim.version.version1", F_OPTIONAL), ("overheadLimit", "long", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.ResourceAllocationOption", "ResourceAllocationOption", "vmodl.DynamicData", "vim.version.version6", [("sharesOption", "vim.SharesOption", "vim.version.version6", 0)]) +CreateDataType("vim.ResourceConfigOption", "ResourceConfigOption", "vmodl.DynamicData", "vim.version.version6", [("cpuAllocationOption", "vim.ResourceAllocationOption", "vim.version.version6", 0), ("memoryAllocationOption", "vim.ResourceAllocationOption", "vim.version.version6", 0)]) +CreateDataType("vim.ResourceConfigSpec", "ResourceConfigSpec", "vmodl.DynamicData", "vim.version.version1", [("entity", "vim.ManagedEntity", "vim.version.version1", F_OPTIONAL), ("changeVersion", "string", "vim.version.version1", F_OPTIONAL), ("lastModified", "vmodl.DateTime", "vim.version.version1", F_OPTIONAL), ("cpuAllocation", "vim.ResourceAllocationInfo", "vim.version.version1", 0), ("memoryAllocation", "vim.ResourceAllocationInfo", "vim.version.version1", 0)]) +CreateManagedType("vim.ResourcePlanningManager", "ResourcePlanningManager", "vmodl.ManagedObject", "vim.version.version5", None, [("estimateDatabaseSize", "EstimateDatabaseSize", "vim.version.version5", (("dbSizeParam", "vim.ResourcePlanningManager.DatabaseSizeParam", "vim.version.version5", 0, None),), (0, "vim.ResourcePlanningManager.DatabaseSizeEstimate", "vim.ResourcePlanningManager.DatabaseSizeEstimate"), "System.Read", None)]) +CreateDataType("vim.ResourcePlanningManager.DatabaseSizeParam", "DatabaseSizeParam", "vmodl.DynamicData", "vim.version.version5", [("inventoryDesc", "vim.ResourcePlanningManager.InventoryDescription", "vim.version.version5", 0), ("perfStatsDesc", "vim.ResourcePlanningManager.PerfStatsDescription", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.ResourcePlanningManager.InventoryDescription", "InventoryDescription", "vmodl.DynamicData", "vim.version.version5", [("numHosts", "int", "vim.version.version5", 0), ("numVirtualMachines", "int", "vim.version.version5", 0), ("numResourcePools", "int", "vim.version.version5", F_OPTIONAL), ("numClusters", "int", "vim.version.version5", F_OPTIONAL), ("numCpuDev", "int", "vim.version.version5", F_OPTIONAL), ("numNetDev", "int", "vim.version.version5", F_OPTIONAL), ("numDiskDev", "int", "vim.version.version5", F_OPTIONAL), ("numvCpuDev", "int", "vim.version.version5", F_OPTIONAL), ("numvNetDev", "int", "vim.version.version5", F_OPTIONAL), ("numvDiskDev", "int", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.ResourcePlanningManager.PerfStatsDescription", "PerformanceStatisticsDescription", "vmodl.DynamicData", "vim.version.version5", [("intervals", "vim.HistoricalInterval[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.ResourcePlanningManager.DatabaseSizeEstimate", "DatabaseSizeEstimate", "vmodl.DynamicData", "vim.version.version5", [("size", "long", "vim.version.version5", 0)]) +CreateManagedType("vim.SearchIndex", "SearchIndex", "vmodl.ManagedObject", "vim.version.version1", None, [("findByUuid", "FindByUuid", "vim.version.version1", (("datacenter", "vim.Datacenter", "vim.version.version1", F_OPTIONAL, None),("uuid", "string", "vim.version.version1", 0, None),("vmSearch", "boolean", "vim.version.version1", 0, None),("instanceUuid", "boolean", "vim.version.version5", F_OPTIONAL, None),), (F_OPTIONAL, "vim.ManagedEntity", "vim.ManagedEntity"), "System.View", None), ("findByDatastorePath", "FindByDatastorePath", "vim.version.version1", (("datacenter", "vim.Datacenter", "vim.version.version1", 0, None),("path", "string", "vim.version.version1", 0, None),), (F_OPTIONAL, "vim.VirtualMachine", "vim.VirtualMachine"), "System.View", ["vim.fault.InvalidDatastore", ]), ("findByDnsName", "FindByDnsName", "vim.version.version1", (("datacenter", "vim.Datacenter", "vim.version.version1", F_OPTIONAL, None),("dnsName", "string", "vim.version.version1", 0, None),("vmSearch", "boolean", "vim.version.version1", 0, None),), (F_OPTIONAL, "vim.ManagedEntity", "vim.ManagedEntity"), "System.View", None), ("findByIp", "FindByIp", "vim.version.version1", (("datacenter", "vim.Datacenter", "vim.version.version1", F_OPTIONAL, None),("ip", "string", "vim.version.version1", 0, None),("vmSearch", "boolean", "vim.version.version1", 0, None),), (F_OPTIONAL, "vim.ManagedEntity", "vim.ManagedEntity"), "System.View", None), ("findByInventoryPath", "FindByInventoryPath", "vim.version.version1", (("inventoryPath", "string", "vim.version.version1", 0, None),), (F_OPTIONAL, "vim.ManagedEntity", "vim.ManagedEntity"), "System.View", None), ("findChild", "FindChild", "vim.version.version1", (("entity", "vim.ManagedEntity", "vim.version.version1", 0, None),("name", "string", "vim.version.version1", 0, None),), (F_OPTIONAL, "vim.ManagedEntity", "vim.ManagedEntity"), "System.View", None), ("findAllByUuid", "FindAllByUuid", "vim.version.version5", (("datacenter", "vim.Datacenter", "vim.version.version5", F_OPTIONAL, None),("uuid", "string", "vim.version.version5", 0, None),("vmSearch", "boolean", "vim.version.version5", 0, None),("instanceUuid", "boolean", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.ManagedEntity[]", "vim.ManagedEntity[]"), "System.View", None), ("findAllByDnsName", "FindAllByDnsName", "vim.version.version5", (("datacenter", "vim.Datacenter", "vim.version.version5", F_OPTIONAL, None),("dnsName", "string", "vim.version.version5", 0, None),("vmSearch", "boolean", "vim.version.version5", 0, None),), (0, "vim.ManagedEntity[]", "vim.ManagedEntity[]"), "System.View", None), ("findAllByIp", "FindAllByIp", "vim.version.version5", (("datacenter", "vim.Datacenter", "vim.version.version5", F_OPTIONAL, None),("ip", "string", "vim.version.version5", 0, None),("vmSearch", "boolean", "vim.version.version5", 0, None),), (0, "vim.ManagedEntity[]", "vim.ManagedEntity[]"), "System.View", None)]) +CreateDataType("vim.SelectionSet", "SelectionSet", "vmodl.DynamicData", "vim.version.version7", None) +CreateEnumType("vim.ServiceDirectory.ServiceProtocol", "ServiceProtocol", "vim.version.version5", ["vimApi", "vimWebServices", "viImageLibrary", "unknown"]) +CreateDataType("vim.ServiceInstanceContent", "ServiceContent", "vmodl.DynamicData", "vim.version.version1", [("rootFolder", "vim.Folder", "vim.version.version1", 0), ("propertyCollector", "vmodl.query.PropertyCollector", "vim.version.version1", 0), ("viewManager", "vim.view.ViewManager", "vim.version.version2", F_OPTIONAL), ("about", "vim.AboutInfo", "vim.version.version1", 0), ("setting", "vim.option.OptionManager", "vim.version.version1", F_OPTIONAL), ("userDirectory", "vim.UserDirectory", "vim.version.version1", F_OPTIONAL), ("sessionManager", "vim.SessionManager", "vim.version.version1", F_OPTIONAL), ("authorizationManager", "vim.AuthorizationManager", "vim.version.version1", F_OPTIONAL), ("serviceManager", "vim.ServiceManager", "vim.version.version8", F_OPTIONAL), ("perfManager", "vim.PerformanceManager", "vim.version.version1", F_OPTIONAL), ("scheduledTaskManager", "vim.scheduler.ScheduledTaskManager", "vim.version.version1", F_OPTIONAL), ("alarmManager", "vim.alarm.AlarmManager", "vim.version.version1", F_OPTIONAL), ("eventManager", "vim.event.EventManager", "vim.version.version1", F_OPTIONAL), ("taskManager", "vim.TaskManager", "vim.version.version1", F_OPTIONAL), ("extensionManager", "vim.ExtensionManager", "vim.version.version2", F_OPTIONAL), ("customizationSpecManager", "vim.CustomizationSpecManager", "vim.version.version1", F_OPTIONAL), ("customFieldsManager", "vim.CustomFieldsManager", "vim.version.version1", F_OPTIONAL), ("accountManager", "vim.host.LocalAccountManager", "vim.version.version1", F_OPTIONAL), ("diagnosticManager", "vim.DiagnosticManager", "vim.version.version1", F_OPTIONAL), ("licenseManager", "vim.LicenseManager", "vim.version.version1", F_OPTIONAL), ("searchIndex", "vim.SearchIndex", "vim.version.version1", F_OPTIONAL), ("fileManager", "vim.FileManager", "vim.version.version2", F_OPTIONAL), ("datastoreNamespaceManager", "vim.DatastoreNamespaceManager", "vim.version.version9", F_OPTIONAL), ("virtualDiskManager", "vim.VirtualDiskManager", "vim.version.version2", F_OPTIONAL), ("virtualizationManager", "vim.VirtualizationManager", "vim.version.version2", F_OPTIONAL), ("snmpSystem", "vim.host.SnmpSystem", "vim.version.version5", F_OPTIONAL), ("vmProvisioningChecker", "vim.vm.check.ProvisioningChecker", "vim.version.version5", F_OPTIONAL), ("vmCompatibilityChecker", "vim.vm.check.CompatibilityChecker", "vim.version.version5", F_OPTIONAL), ("ovfManager", "vim.OvfManager", "vim.version.version5", F_OPTIONAL), ("ipPoolManager", "vim.IpPoolManager", "vim.version.version5", F_OPTIONAL), ("dvSwitchManager", "vim.dvs.DistributedVirtualSwitchManager", "vim.version.version5", F_OPTIONAL), ("hostProfileManager", "vim.profile.host.ProfileManager", "vim.version.version5", F_OPTIONAL), ("clusterProfileManager", "vim.profile.cluster.ProfileManager", "vim.version.version5", F_OPTIONAL), ("complianceManager", "vim.profile.ComplianceManager", "vim.version.version5", F_OPTIONAL), ("localizationManager", "vim.LocalizationManager", "vim.version.version5", F_OPTIONAL), ("storageResourceManager", "vim.StorageResourceManager", "vim.version.version6", F_OPTIONAL), ("guestOperationsManager", "vim.vm.guest.GuestOperationsManager", "vim.version.version7", F_OPTIONAL)]) +CreateManagedType("vim.ServiceManager", "ServiceManager", "vmodl.ManagedObject", "vim.version.version2", [("service", "vim.ServiceManager.ServiceInfo[]", "vim.version.version2", F_OPTIONAL, "Global.ServiceManagers")], [("queryServiceList", "QueryServiceList", "vim.version.version2", (("serviceName", "string", "vim.version.version2", F_OPTIONAL, None),("location", "string[]", "vim.version.version2", F_OPTIONAL, None),), (F_OPTIONAL, "vim.ServiceManager.ServiceInfo[]", "vim.ServiceManager.ServiceInfo[]"), "Global.ServiceManagers", None)]) +CreateDataType("vim.ServiceManager.ServiceInfo", "ServiceManagerServiceInfo", "vmodl.DynamicData", "vim.version.version1", [("serviceName", "string", "vim.version.version1", 0), ("location", "string[]", "vim.version.version1", F_OPTIONAL), ("service", "vmodl.ManagedObject", "vim.version.version1", 0), ("description", "string", "vim.version.version1", 0)]) +CreateManagedType("vim.SessionManager", "SessionManager", "vmodl.ManagedObject", "vim.version.version1", [("sessionList", "vim.UserSession[]", "vim.version.version1", F_OPTIONAL, "Sessions.TerminateSession"), ("currentSession", "vim.UserSession", "vim.version.version1", F_OPTIONAL, "System.Anonymous"), ("message", "string", "vim.version.version1", F_OPTIONAL, "System.View"), ("messageLocaleList", "string[]", "vim.version.version1", F_OPTIONAL, "System.Anonymous"), ("supportedLocaleList", "string[]", "vim.version.version1", F_OPTIONAL, "System.Anonymous"), ("defaultLocale", "string", "vim.version.version1", 0, "System.Anonymous")], [("updateMessage", "UpdateServiceMessage", "vim.version.version1", (("message", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "Sessions.GlobalMessage", None), ("loginByToken", "LoginByToken", "vim.version.version8", (("locale", "string", "vim.version.version8", F_OPTIONAL, None),), (0, "vim.UserSession", "vim.UserSession"), "System.Anonymous", ["vim.fault.InvalidLogin", "vim.fault.InvalidLocale", ]), ("login", "Login", "vim.version.version1", (("userName", "string", "vim.version.version1", 0, None),("password", "string", "vim.version.version1", 0, None),("locale", "string", "vim.version.version1", F_OPTIONAL, None),), (0, "vim.UserSession", "vim.UserSession"), "System.Anonymous", ["vim.fault.InvalidLogin", "vim.fault.InvalidLocale", ]), ("loginBySSPI", "LoginBySSPI", "vim.version.version2", (("base64Token", "string", "vim.version.version2", 0, None),("locale", "string", "vim.version.version2", F_OPTIONAL, None),), (0, "vim.UserSession", "vim.UserSession"), "System.Anonymous", ["vim.fault.SSPIChallenge", "vim.fault.InvalidLogin", "vim.fault.InvalidLocale", ]), ("logout", "Logout", "vim.version.version1", (), (0, "void", "void"), "System.View", None), ("acquireLocalTicket", "AcquireLocalTicket", "vim.version.version1", (("userName", "string", "vim.version.version1", 0, None),), (0, "vim.SessionManager.LocalTicket", "vim.SessionManager.LocalTicket"), "System.Anonymous", ["vim.fault.InvalidLogin", ]), ("acquireGenericServiceTicket", "AcquireGenericServiceTicket", "vim.version.version7", (("spec", "vim.SessionManager.ServiceRequestSpec", "vim.version.version7", 0, None),), (0, "vim.SessionManager.GenericServiceTicket", "vim.SessionManager.GenericServiceTicket"), "System.Anonymous", None), ("terminate", "TerminateSession", "vim.version.version1", (("sessionId", "string[]", "vim.version.version1", 0, None),), (0, "void", "void"), "Sessions.TerminateSession", ["vim.fault.NotFound", ]), ("setLocale", "SetLocale", "vim.version.version1", (("locale", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "System.View", ["vim.fault.InvalidLocale", ]), ("loginExtensionBySubjectName", "LoginExtensionBySubjectName", "vim.version.version2", (("extensionKey", "string", "vim.version.version2", 0, None),("locale", "string", "vim.version.version2", F_OPTIONAL, None),), (0, "vim.UserSession", "vim.UserSession"), "System.Anonymous", ["vim.fault.InvalidLogin", "vim.fault.InvalidLocale", "vim.fault.NotFound", "vim.fault.NoClientCertificate", "vim.fault.NoSubjectName", ]), ("loginExtensionByCertificate", "LoginExtensionByCertificate", "vim.version.version5", (("extensionKey", "string", "vim.version.version5", 0, None),("locale", "string", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.UserSession", "vim.UserSession"), "System.Anonymous", ["vim.fault.InvalidLogin", "vim.fault.InvalidLocale", "vim.fault.NoClientCertificate", ]), ("impersonateUser", "ImpersonateUser", "vim.version.version2", (("userName", "string", "vim.version.version2", 0, None),("locale", "string", "vim.version.version2", F_OPTIONAL, None),), (0, "vim.UserSession", "vim.UserSession"), "Sessions.ImpersonateUser", ["vim.fault.InvalidLogin", "vim.fault.InvalidLocale", ]), ("sessionIsActive", "SessionIsActive", "vim.version.version2", (("sessionID", "string", "vim.version.version2", 0, None),("userName", "string", "vim.version.version2", 0, None),), (0, "boolean", "boolean"), "Sessions.ValidateSession", None), ("acquireCloneTicket", "AcquireCloneTicket", "vim.version.version3", (), (0, "string", "string"), "System.View", None), ("cloneSession", "CloneSession", "vim.version.version3", (("cloneTicket", "string", "vim.version.version3", 0, None),), (0, "vim.UserSession", "vim.UserSession"), "System.Anonymous", ["vim.fault.InvalidLogin", ])]) +CreateDataType("vim.SessionManager.LocalTicket", "SessionManagerLocalTicket", "vmodl.DynamicData", "vim.version.version1", [("userName", "string", "vim.version.version1", 0), ("passwordFilePath", "string", "vim.version.version1", 0)]) +CreateDataType("vim.SessionManager.GenericServiceTicket", "SessionManagerGenericServiceTicket", "vmodl.DynamicData", "vim.version.version7", [("id", "string", "vim.version.version7", 0), ("hostName", "string", "vim.version.version8", F_OPTIONAL), ("sslThumbprint", "string", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.SessionManager.ServiceRequestSpec", "SessionManagerServiceRequestSpec", "vmodl.DynamicData", "vim.version.version7", None) +CreateDataType("vim.SessionManager.VmomiServiceRequestSpec", "SessionManagerVmomiServiceRequestSpec", "vim.SessionManager.ServiceRequestSpec", "vim.version.version8", [("method", "vmodl.MethodName", "vim.version.version8", 0)]) +CreateDataType("vim.SessionManager.HttpServiceRequestSpec", "SessionManagerHttpServiceRequestSpec", "vim.SessionManager.ServiceRequestSpec", "vim.version.version7", [("method", "string", "vim.version.version7", F_OPTIONAL), ("url", "string", "vim.version.version7", 0)]) +CreateEnumType("vim.SessionManager.HttpServiceRequestSpec.Method", "SessionManagerHttpServiceRequestSpecMethod", "vim.version.version7", ["httpOptions", "httpGet", "httpHead", "httpPost", "httpPut", "httpDelete", "httpTrace", "httpConnect"]) +CreateDataType("vim.SharesInfo", "SharesInfo", "vmodl.DynamicData", "vim.version.version1", [("shares", "int", "vim.version.version1", 0), ("level", "vim.SharesInfo.Level", "vim.version.version1", 0)]) +CreateEnumType("vim.SharesInfo.Level", "SharesLevel", "vim.version.version1", ["low", "normal", "high", "custom"]) +CreateDataType("vim.SharesOption", "SharesOption", "vmodl.DynamicData", "vim.version.version6", [("sharesOption", "vim.option.IntOption", "vim.version.version6", 0), ("defaultLevel", "vim.SharesInfo.Level", "vim.version.version6", 0)]) +CreateManagedType("vim.SimpleCommand", "SimpleCommand", "vmodl.ManagedObject", "vim.version.version2", [("encodingType", "vim.SimpleCommand.Encoding", "vim.version.version2", 0, None), ("entity", "vim.ServiceManager.ServiceInfo", "vim.version.version2", 0, None)], [("Execute", "ExecuteSimpleCommand", "vim.version.version2", (("arguments", "string[]", "vim.version.version2", F_OPTIONAL, None),), (0, "string", "string"), "Global.ServiceManagers", None)]) +CreateEnumType("vim.SimpleCommand.Encoding", "SimpleCommandEncoding", "vim.version.version2", ["CSV", "HEX", "STRING"]) +CreateManagedType("vim.StorageResourceManager", "StorageResourceManager", "vmodl.ManagedObject", "vim.version.version6", None, [("ConfigureDatastoreIORM", "ConfigureDatastoreIORM_Task", "vim.version.version6", (("datastore", "vim.Datastore", "vim.version.version6", 0, "Datastore.Config"),("spec", "vim.StorageResourceManager.IORMConfigSpec", "vim.version.version6", 0, None),), (0, "vim.Task", "void"), None, ["vim.fault.IORMNotSupportedHostOnDatastore", "vim.fault.InaccessibleDatastore", ]), ("QueryIORMConfigOption", "QueryIORMConfigOption", "vim.version.version6", (("host", "vim.HostSystem", "vim.version.version6", 0, None),), (0, "vim.StorageResourceManager.IORMConfigOption", "vim.StorageResourceManager.IORMConfigOption"), "Datastore.Config", None), ("queryDatastorePerformanceSummary", "QueryDatastorePerformanceSummary", "vim.version.version8", (("datastore", "vim.Datastore", "vim.version.version8", 0, None),), (F_OPTIONAL, "vim.StorageResourceManager.StoragePerformanceSummary[]", "vim.StorageResourceManager.StoragePerformanceSummary[]"), "System.View", ["vim.fault.NotFound", ]), ("applyRecommendationToPod", "ApplyStorageDrsRecommendationToPod_Task", "vim.version.version7", (("pod", "vim.StoragePod", "vim.version.version7", 0, None),("key", "string", "vim.version.version7", 0, None),), (0, "vim.Task", "vim.storageDrs.ApplyRecommendationResult"), "System.View", None), ("applyRecommendation", "ApplyStorageDrsRecommendation_Task", "vim.version.version7", (("key", "string[]", "vim.version.version7", 0, None),), (0, "vim.Task", "vim.storageDrs.ApplyRecommendationResult"), "System.View", None), ("cancelRecommendation", "CancelStorageDrsRecommendation", "vim.version.version7", (("key", "string[]", "vim.version.version7", 0, None),), (0, "void", "void"), "System.View", None), ("refreshRecommendation", "RefreshStorageDrsRecommendation", "vim.version.version7", (("pod", "vim.StoragePod", "vim.version.version7", 0, None),), (0, "void", "void"), "System.View", None), ("configureStorageDrsForPod", "ConfigureStorageDrsForPod_Task", "vim.version.version7", (("pod", "vim.StoragePod", "vim.version.version7", 0, "StoragePod.Config"),("spec", "vim.storageDrs.ConfigSpec", "vim.version.version7", 0, None),("modify", "boolean", "vim.version.version7", 0, None),), (0, "vim.Task", "void"), None, None), ("recommendDatastores", "RecommendDatastores", "vim.version.version7", (("storageSpec", "vim.storageDrs.StoragePlacementSpec", "vim.version.version7", 0, None),), (0, "vim.storageDrs.StoragePlacementResult", "vim.storageDrs.StoragePlacementResult"), "System.View", None)]) +CreateDataType("vim.StorageResourceManager.IOAllocationInfo", "StorageIOAllocationInfo", "vmodl.DynamicData", "vim.version.version6", [("limit", "long", "vim.version.version6", F_OPTIONAL), ("shares", "vim.SharesInfo", "vim.version.version6", F_OPTIONAL), ("reservation", "int", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.StorageResourceManager.IOAllocationOption", "StorageIOAllocationOption", "vmodl.DynamicData", "vim.version.version6", [("limitOption", "vim.option.LongOption", "vim.version.version6", 0), ("sharesOption", "vim.SharesOption", "vim.version.version6", 0)]) +CreateEnumType("vim.StorageResourceManager.CongestionThresholdMode", "StorageIORMThresholdMode", "vim.version.version8", ["automatic", "manual"]) +CreateDataType("vim.StorageResourceManager.IORMConfigInfo", "StorageIORMInfo", "vmodl.DynamicData", "vim.version.version6", [("enabled", "boolean", "vim.version.version6", 0), ("congestionThresholdMode", "string", "vim.version.version8", 0), ("congestionThreshold", "int", "vim.version.version6", 0), ("percentOfPeakThroughput", "int", "vim.version.version8", F_OPTIONAL), ("statsCollectionEnabled", "boolean", "vim.version.version7", 0), ("statsAggregationDisabled", "boolean", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.StorageResourceManager.IORMConfigSpec", "StorageIORMConfigSpec", "vmodl.DynamicData", "vim.version.version6", [("enabled", "boolean", "vim.version.version6", F_OPTIONAL), ("congestionThresholdMode", "string", "vim.version.version8", F_OPTIONAL), ("congestionThreshold", "int", "vim.version.version6", F_OPTIONAL), ("percentOfPeakThroughput", "int", "vim.version.version8", F_OPTIONAL), ("statsCollectionEnabled", "boolean", "vim.version.version7", F_OPTIONAL), ("statsAggregationDisabled", "boolean", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.StorageResourceManager.IORMConfigOption", "StorageIORMConfigOption", "vmodl.DynamicData", "vim.version.version6", [("enabledOption", "vim.option.BoolOption", "vim.version.version6", 0), ("congestionThresholdOption", "vim.option.IntOption", "vim.version.version6", 0), ("statsCollectionEnabledOption", "vim.option.BoolOption", "vim.version.version7", 0)]) +CreateDataType("vim.StorageResourceManager.StoragePerformanceSummary", "StoragePerformanceSummary", "vmodl.DynamicData", "vim.version.version8", [("interval", "int", "vim.version.version8", 0), ("percentile", "int[]", "vim.version.version8", 0), ("datastoreReadLatency", "double[]", "vim.version.version8", 0), ("datastoreWriteLatency", "double[]", "vim.version.version8", 0), ("datastoreVmLatency", "double[]", "vim.version.version8", 0), ("datastoreReadIops", "double[]", "vim.version.version8", 0), ("datastoreWriteIops", "double[]", "vim.version.version8", 0), ("siocActivityDuration", "int", "vim.version.version8", 0)]) +CreateDataType("vim.StorageResourceManager.PodStorageDrsEntry", "PodStorageDrsEntry", "vmodl.DynamicData", "vim.version.version7", [("storageDrsConfig", "vim.storageDrs.ConfigInfo", "vim.version.version7", 0), ("recommendation", "vim.cluster.Recommendation[]", "vim.version.version7", F_OPTIONAL), ("drsFault", "vim.cluster.DrsFaults[]", "vim.version.version7", F_OPTIONAL), ("actionHistory", "vim.cluster.ActionHistory[]", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.StringExpression", "StringExpression", "vim.NegatableExpression", "vim.version.version9", [("value", "string", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.StringPolicy", "StringPolicy", "vim.InheritablePolicy", "vim.version.version5", [("value", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.Tag", "Tag", "vmodl.DynamicData", "vim.version.version5", [("key", "string", "vim.version.version5", 0)]) +CreateDataType("vim.TaskDescription", "TaskDescription", "vmodl.DynamicData", "vim.version.version1", [("methodInfo", "vim.ElementDescription[]", "vim.version.version1", 0), ("state", "vim.ElementDescription[]", "vim.version.version1", 0), ("reason", "vim.TypeDescription[]", "vim.version.version1", 0)]) +CreateManagedType("vim.TaskHistoryCollector", "TaskHistoryCollector", "vim.HistoryCollector", "vim.version.version1", [("latestPage", "vim.TaskInfo[]", "vim.version.version1", F_OPTIONAL, None)], [("readNext", "ReadNextTasks", "vim.version.version1", (("maxCount", "int", "vim.version.version1", 0, None),), (F_OPTIONAL, "vim.TaskInfo[]", "vim.TaskInfo[]"), None, None), ("readPrev", "ReadPreviousTasks", "vim.version.version1", (("maxCount", "int", "vim.version.version1", 0, None),), (F_OPTIONAL, "vim.TaskInfo[]", "vim.TaskInfo[]"), None, None)]) +CreateDataType("vim.TaskInfo", "TaskInfo", "vmodl.DynamicData", "vim.version.version1", [("key", "string", "vim.version.version1", 0), ("task", "vim.Task", "vim.version.version1", 0), ("description", "vmodl.LocalizableMessage", "vim.version.version5", F_OPTIONAL), ("name", "vmodl.MethodName", "vim.version.version1", F_OPTIONAL), ("descriptionId", "string", "vim.version.version1", 0), ("entity", "vim.ManagedEntity", "vim.version.version1", F_OPTIONAL), ("entityName", "string", "vim.version.version1", F_OPTIONAL), ("locked", "vim.ManagedEntity[]", "vim.version.version1", F_OPTIONAL), ("state", "vim.TaskInfo.State", "vim.version.version1", 0), ("cancelled", "boolean", "vim.version.version1", 0), ("cancelable", "boolean", "vim.version.version1", 0), ("error", "vmodl.MethodFault", "vim.version.version1", F_OPTIONAL), ("result", "anyType", "vim.version.version1", F_OPTIONAL), ("progress", "int", "vim.version.version1", F_OPTIONAL), ("reason", "vim.TaskReason", "vim.version.version1", 0), ("queueTime", "vmodl.DateTime", "vim.version.version1", 0), ("startTime", "vmodl.DateTime", "vim.version.version1", F_OPTIONAL), ("completeTime", "vmodl.DateTime", "vim.version.version1", F_OPTIONAL), ("eventChainId", "int", "vim.version.version1", 0), ("changeTag", "string", "vim.version.version5", F_OPTIONAL), ("parentTaskKey", "string", "vim.version.version5", F_OPTIONAL), ("rootTaskKey", "string", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.TaskInfo.State", "TaskInfoState", "vim.version.version1", ["queued", "running", "success", "error"]) +CreateManagedType("vim.TaskManager", "TaskManager", "vmodl.ManagedObject", "vim.version.version1", [("recentTask", "vim.Task[]", "vim.version.version1", F_OPTIONAL, "System.View"), ("description", "vim.TaskDescription", "vim.version.version1", 0, "System.View"), ("maxCollector", "int", "vim.version.version1", 0, "System.View")], [("createCollector", "CreateCollectorForTasks", "vim.version.version1", (("filter", "vim.TaskFilterSpec", "vim.version.version1", 0, None),), (0, "vim.TaskHistoryCollector", "vim.TaskHistoryCollector"), "System.View", ["vim.fault.InvalidState", ]), ("createTask", "CreateTask", "vim.version.version2", (("obj", "vmodl.ManagedObject", "vim.version.version2", 0, None),("taskTypeId", "string", "vim.version.version2", 0, None),("initiatedBy", "string", "vim.version.version2", F_OPTIONAL, None),("cancelable", "boolean", "vim.version.version2", 0, None),("parentTaskKey", "string", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.TaskInfo", "vim.TaskInfo"), "Task.Create", None)]) +CreateDataType("vim.TaskReason", "TaskReason", "vmodl.DynamicData", "vim.version.version1", None) +CreateDataType("vim.TaskReasonSystem", "TaskReasonSystem", "vim.TaskReason", "vim.version.version1", None) +CreateDataType("vim.TaskReasonUser", "TaskReasonUser", "vim.TaskReason", "vim.version.version1", [("userName", "string", "vim.version.version1", 0)]) +CreateDataType("vim.TaskReasonAlarm", "TaskReasonAlarm", "vim.TaskReason", "vim.version.version1", [("alarmName", "string", "vim.version.version1", 0), ("alarm", "vim.alarm.Alarm", "vim.version.version1", 0), ("entityName", "string", "vim.version.version1", 0), ("entity", "vim.ManagedEntity", "vim.version.version1", 0)]) +CreateDataType("vim.TaskReasonSchedule", "TaskReasonSchedule", "vim.TaskReason", "vim.version.version1", [("name", "string", "vim.version.version1", 0), ("scheduledTask", "vim.scheduler.ScheduledTask", "vim.version.version1", 0)]) +CreateDataType("vim.TypeDescription", "TypeDescription", "vim.Description", "vim.version.version1", [("key", "vmodl.TypeName", "vim.version.version1", 0)]) +CreateDataType("vim.UpdateVirtualMachineFilesResult", "UpdateVirtualMachineFilesResult", "vmodl.DynamicData", "vim.version.version6", [("failedVmFile", "vim.UpdateVirtualMachineFilesResult.FailedVmFileInfo[]", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.UpdateVirtualMachineFilesResult.FailedVmFileInfo", "UpdateVirtualMachineFilesResultFailedVmFileInfo", "vmodl.DynamicData", "vim.version.version6", [("vmFile", "string", "vim.version.version6", 0), ("fault", "vmodl.MethodFault", "vim.version.version6", 0)]) +CreateManagedType("vim.UserDirectory", "UserDirectory", "vmodl.ManagedObject", "vim.version.version1", [("domainList", "string[]", "vim.version.version1", F_OPTIONAL, "System.View")], [("retrieveUserGroups", "RetrieveUserGroups", "vim.version.version1", (("domain", "string", "vim.version.version1", F_OPTIONAL, None),("searchStr", "string", "vim.version.version1", 0, None),("belongsToGroup", "string", "vim.version.version1", F_OPTIONAL, None),("belongsToUser", "string", "vim.version.version1", F_OPTIONAL, None),("exactMatch", "boolean", "vim.version.version1", 0, None),("findUsers", "boolean", "vim.version.version1", 0, None),("findGroups", "boolean", "vim.version.version1", 0, None),), (F_OPTIONAL, "vim.UserSearchResult[]", "vim.UserSearchResult[]"), None, ["vim.fault.NotFound", ])]) +CreateDataType("vim.UserSearchResult", "UserSearchResult", "vmodl.DynamicData", "vim.version.version1", [("principal", "string", "vim.version.version1", 0), ("fullName", "string", "vim.version.version1", F_OPTIONAL), ("group", "boolean", "vim.version.version1", 0)]) +CreateDataType("vim.UserSession", "UserSession", "vmodl.DynamicData", "vim.version.version1", [("key", "string", "vim.version.version1", 0), ("userName", "string", "vim.version.version1", 0), ("fullName", "string", "vim.version.version1", 0), ("loginTime", "vmodl.DateTime", "vim.version.version1", 0), ("lastActiveTime", "vmodl.DateTime", "vim.version.version1", 0), ("locale", "string", "vim.version.version1", 0), ("messageLocale", "string", "vim.version.version1", 0), ("extensionSession", "boolean", "vim.version.version7", 0), ("ipAddress", "string", "vim.version.version8", 0), ("userAgent", "string", "vim.version.version8", 0), ("callCount", "long", "vim.version.version8", 0)]) +CreateManagedType("vim.VirtualizationManager", "VirtualizationManager", "vmodl.ManagedObject", "vim.version.version2", None, None) +CreateDataType("vim.action.Action", "Action", "vmodl.DynamicData", "vim.version.version1", None) +CreateEnumType("vim.action.Action.ActionParameter", "ActionParameter", "vim.version.version1", ["targetName", "alarmName", "oldStatus", "newStatus", "triggeringSummary", "declaringSummary", "eventDescription", "target", "alarm"]) +CreateDataType("vim.action.MethodActionArgument", "MethodActionArgument", "vmodl.DynamicData", "vim.version.version1", [("value", "anyType", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.action.MethodAction", "MethodAction", "vim.action.Action", "vim.version.version1", [("name", "vmodl.MethodName", "vim.version.version1", 0), ("argument", "vim.action.MethodActionArgument[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.action.SendEmailAction", "SendEmailAction", "vim.action.Action", "vim.version.version1", [("toList", "string", "vim.version.version1", 0), ("ccList", "string", "vim.version.version1", 0), ("subject", "string", "vim.version.version1", 0), ("body", "string", "vim.version.version1", 0)]) +CreateDataType("vim.action.SendSNMPAction", "SendSNMPAction", "vim.action.Action", "vim.version.version1", None) +CreateDataType("vim.action.RunScriptAction", "RunScriptAction", "vim.action.Action", "vim.version.version1", [("script", "string", "vim.version.version1", 0)]) +CreateDataType("vim.action.CreateTaskAction", "CreateTaskAction", "vim.action.Action", "vim.version.version2", [("taskTypeId", "string", "vim.version.version2", 0), ("cancelable", "boolean", "vim.version.version2", 0)]) +CreateManagedType("vim.alarm.Alarm", "Alarm", "vim.ExtensibleManagedObject", "vim.version.version1", [("info", "vim.alarm.AlarmInfo", "vim.version.version1", 0, "System.View")], [("remove", "RemoveAlarm", "vim.version.version1", (), (0, "void", "void"), "Alarm.Delete", None), ("reconfigure", "ReconfigureAlarm", "vim.version.version1", (("spec", "vim.alarm.AlarmSpec", "vim.version.version1", 0, None),), (0, "void", "void"), "Alarm.Edit", ["vim.fault.InvalidName", "vim.fault.DuplicateName", ])]) +CreateDataType("vim.alarm.AlarmAction", "AlarmAction", "vmodl.DynamicData", "vim.version.version1", None) +CreateDataType("vim.alarm.GroupAlarmAction", "GroupAlarmAction", "vim.alarm.AlarmAction", "vim.version.version1", [("action", "vim.alarm.AlarmAction[]", "vim.version.version1", 0)]) +CreateDataType("vim.alarm.AlarmDescription", "AlarmDescription", "vmodl.DynamicData", "vim.version.version1", [("expr", "vim.TypeDescription[]", "vim.version.version1", 0), ("stateOperator", "vim.ElementDescription[]", "vim.version.version1", 0), ("metricOperator", "vim.ElementDescription[]", "vim.version.version1", 0), ("hostSystemConnectionState", "vim.ElementDescription[]", "vim.version.version1", 0), ("virtualMachinePowerState", "vim.ElementDescription[]", "vim.version.version1", 0), ("datastoreConnectionState", "vim.ElementDescription[]", "vim.version.version5", 0), ("hostSystemPowerState", "vim.ElementDescription[]", "vim.version.version5", 0), ("virtualMachineGuestHeartbeatStatus", "vim.ElementDescription[]", "vim.version.version5", 0), ("entityStatus", "vim.ElementDescription[]", "vim.version.version1", 0), ("action", "vim.TypeDescription[]", "vim.version.version1", 0)]) +CreateDataType("vim.alarm.AlarmExpression", "AlarmExpression", "vmodl.DynamicData", "vim.version.version1", None) +CreateDataType("vim.alarm.AndAlarmExpression", "AndAlarmExpression", "vim.alarm.AlarmExpression", "vim.version.version1", [("expression", "vim.alarm.AlarmExpression[]", "vim.version.version1", 0)]) +CreateDataType("vim.alarm.OrAlarmExpression", "OrAlarmExpression", "vim.alarm.AlarmExpression", "vim.version.version1", [("expression", "vim.alarm.AlarmExpression[]", "vim.version.version1", 0)]) +CreateDataType("vim.alarm.StateAlarmExpression", "StateAlarmExpression", "vim.alarm.AlarmExpression", "vim.version.version1", [("operator", "vim.alarm.StateAlarmExpression.StateOperator", "vim.version.version1", 0), ("type", "vmodl.TypeName", "vim.version.version1", 0), ("statePath", "vmodl.PropertyPath", "vim.version.version1", 0), ("yellow", "string", "vim.version.version1", F_OPTIONAL), ("red", "string", "vim.version.version1", F_OPTIONAL)]) +CreateEnumType("vim.alarm.StateAlarmExpression.StateOperator", "StateAlarmOperator", "vim.version.version1", ["isEqual", "isUnequal"]) +CreateDataType("vim.alarm.MetricAlarmExpression", "MetricAlarmExpression", "vim.alarm.AlarmExpression", "vim.version.version1", [("operator", "vim.alarm.MetricAlarmExpression.MetricOperator", "vim.version.version1", 0), ("type", "vmodl.TypeName", "vim.version.version1", 0), ("metric", "vim.PerformanceManager.MetricId", "vim.version.version1", 0), ("yellow", "int", "vim.version.version1", F_OPTIONAL), ("yellowInterval", "int", "vim.version.version5", F_OPTIONAL), ("red", "int", "vim.version.version1", F_OPTIONAL), ("redInterval", "int", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.alarm.MetricAlarmExpression.MetricOperator", "MetricAlarmOperator", "vim.version.version1", ["isAbove", "isBelow"]) +CreateDataType("vim.alarm.AlarmSetting", "AlarmSetting", "vmodl.DynamicData", "vim.version.version1", [("toleranceRange", "int", "vim.version.version1", 0), ("reportingFrequency", "int", "vim.version.version1", 0)]) +CreateDataType("vim.alarm.AlarmSpec", "AlarmSpec", "vmodl.DynamicData", "vim.version.version1", [("name", "string", "vim.version.version1", 0), ("systemName", "string", "vim.version.version7", F_OPTIONAL), ("description", "string", "vim.version.version1", 0), ("enabled", "boolean", "vim.version.version1", 0), ("expression", "vim.alarm.AlarmExpression", "vim.version.version1", 0), ("action", "vim.alarm.AlarmAction", "vim.version.version1", F_OPTIONAL), ("actionFrequency", "int", "vim.version.version5", F_OPTIONAL), ("setting", "vim.alarm.AlarmSetting", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.cluster.Action", "ClusterAction", "vmodl.DynamicData", "vim.version.version2", [("type", "string", "vim.version.version2", 0), ("target", "vmodl.ManagedObject", "vim.version.version2", F_OPTIONAL)]) +CreateEnumType("vim.cluster.Action.ActionType", "ActionType", "vim.version.version2", ["MigrationV1", "VmPowerV1", "HostPowerV1", "IncreaseLimitV1", "IncreaseSizeV1", "IncreaseSharesV1", "IncreaseReservationV1", "DecreaseOthersReservationV1", "IncreaseClusterCapacityV1", "DecreaseMigrationThresholdV1", "HostMaintenanceV1", "StorageMigrationV1", "StoragePlacementV1", "PlacementV1"]) +CreateDataType("vim.cluster.ActionHistory", "ClusterActionHistory", "vmodl.DynamicData", "vim.version.version2", [("action", "vim.cluster.Action", "vim.version.version2", 0), ("time", "vmodl.DateTime", "vim.version.version2", 0)]) +CreateDataType("vim.cluster.AttemptedVmInfo", "ClusterAttemptedVmInfo", "vmodl.DynamicData", "vim.version.version2", [("vm", "vim.VirtualMachine", "vim.version.version2", 0), ("task", "vim.Task", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.cluster.ConfigInfo", "ClusterConfigInfo", "vmodl.DynamicData", "vim.version.version1", [("dasConfig", "vim.cluster.DasConfigInfo", "vim.version.version1", 0), ("dasVmConfig", "vim.cluster.DasVmConfigInfo[]", "vim.version.version1", F_OPTIONAL), ("drsConfig", "vim.cluster.DrsConfigInfo", "vim.version.version1", 0), ("drsVmConfig", "vim.cluster.DrsVmConfigInfo[]", "vim.version.version1", F_OPTIONAL), ("rule", "vim.cluster.RuleInfo[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.cluster.DrsConfigInfo", "ClusterDrsConfigInfo", "vmodl.DynamicData", "vim.version.version1", [("enabled", "boolean", "vim.version.version1", F_OPTIONAL), ("enableVmBehaviorOverrides", "boolean", "vim.version.version5", F_OPTIONAL), ("defaultVmBehavior", "vim.cluster.DrsConfigInfo.DrsBehavior", "vim.version.version1", F_OPTIONAL), ("vmotionRate", "int", "vim.version.version1", F_OPTIONAL), ("option", "vim.option.OptionValue[]", "vim.version.version1", F_OPTIONAL)]) +CreateEnumType("vim.cluster.DrsConfigInfo.DrsBehavior", "DrsBehavior", "vim.version.version1", ["manual", "partiallyAutomated", "fullyAutomated"]) +CreateDataType("vim.cluster.DrsVmConfigInfo", "ClusterDrsVmConfigInfo", "vmodl.DynamicData", "vim.version.version1", [("key", "vim.VirtualMachine", "vim.version.version1", 0), ("enabled", "boolean", "vim.version.version1", F_OPTIONAL), ("behavior", "vim.cluster.DrsConfigInfo.DrsBehavior", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.cluster.DpmConfigInfo", "ClusterDpmConfigInfo", "vmodl.DynamicData", "vim.version.version2", [("enabled", "boolean", "vim.version.version2", F_OPTIONAL), ("defaultDpmBehavior", "vim.cluster.DpmConfigInfo.DpmBehavior", "vim.version.version2", F_OPTIONAL), ("hostPowerActionRate", "int", "vim.version.version5", F_OPTIONAL), ("option", "vim.option.OptionValue[]", "vim.version.version2", F_OPTIONAL)]) +CreateEnumType("vim.cluster.DpmConfigInfo.DpmBehavior", "DpmBehavior", "vim.version.version2", ["manual", "automated"]) +CreateDataType("vim.cluster.DpmHostConfigInfo", "ClusterDpmHostConfigInfo", "vmodl.DynamicData", "vim.version.version2", [("key", "vim.HostSystem", "vim.version.version2", 0), ("enabled", "boolean", "vim.version.version2", F_OPTIONAL), ("behavior", "vim.cluster.DpmConfigInfo.DpmBehavior", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.cluster.ConfigSpec", "ClusterConfigSpec", "vmodl.DynamicData", "vim.version.version1", [("dasConfig", "vim.cluster.DasConfigInfo", "vim.version.version1", F_OPTIONAL), ("dasVmConfigSpec", "vim.cluster.DasVmConfigSpec[]", "vim.version.version1", F_OPTIONAL), ("drsConfig", "vim.cluster.DrsConfigInfo", "vim.version.version1", F_OPTIONAL), ("drsVmConfigSpec", "vim.cluster.DrsVmConfigSpec[]", "vim.version.version1", F_OPTIONAL), ("rulesSpec", "vim.cluster.RuleSpec[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.cluster.DasAamNodeState", "ClusterDasAamNodeState", "vmodl.DynamicData", "vim.version.version5", [("host", "vim.HostSystem", "vim.version.version5", 0), ("name", "string", "vim.version.version5", 0), ("configState", "string", "vim.version.version5", 0), ("runtimeState", "string", "vim.version.version5", 0)]) +CreateEnumType("vim.cluster.DasAamNodeState.DasState", "ClusterDasAamNodeStateDasState", "vim.version.version5", ["uninitialized", "initialized", "configuring", "unconfiguring", "running", "error", "agentShutdown", "nodeFailed"]) +CreateDataType("vim.cluster.DasAdmissionControlInfo", "ClusterDasAdmissionControlInfo", "vmodl.DynamicData", "vim.version.version5", None) +CreateDataType("vim.cluster.DasAdmissionControlPolicy", "ClusterDasAdmissionControlPolicy", "vmodl.DynamicData", "vim.version.version5", None) +CreateDataType("vim.cluster.DasAdvancedRuntimeInfo", "ClusterDasAdvancedRuntimeInfo", "vmodl.DynamicData", "vim.version.version5", [("dasHostInfo", "vim.cluster.DasHostInfo", "vim.version.version5", F_OPTIONAL), ("heartbeatDatastoreInfo", "vim.cluster.DasAdvancedRuntimeInfo.HeartbeatDatastoreInfo[]", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.cluster.DasAdvancedRuntimeInfo.HeartbeatDatastoreInfo", "DasHeartbeatDatastoreInfo", "vmodl.DynamicData", "vim.version.version7", [("datastore", "vim.Datastore", "vim.version.version7", 0), ("hosts", "vim.HostSystem[]", "vim.version.version7", 0)]) +CreateDataType("vim.cluster.DasConfigInfo", "ClusterDasConfigInfo", "vmodl.DynamicData", "vim.version.version1", [("enabled", "boolean", "vim.version.version1", F_OPTIONAL), ("vmMonitoring", "string", "vim.version.version5", F_OPTIONAL), ("hostMonitoring", "string", "vim.version.version5", F_OPTIONAL), ("failoverLevel", "int", "vim.version.version1", F_OPTIONAL), ("admissionControlPolicy", "vim.cluster.DasAdmissionControlPolicy", "vim.version.version5", F_OPTIONAL), ("admissionControlEnabled", "boolean", "vim.version.version1", F_OPTIONAL), ("defaultVmSettings", "vim.cluster.DasVmSettings", "vim.version.version2", F_OPTIONAL), ("option", "vim.option.OptionValue[]", "vim.version.version1", F_OPTIONAL), ("heartbeatDatastore", "vim.Datastore[]", "vim.version.version7", F_OPTIONAL), ("hBDatastoreCandidatePolicy", "string", "vim.version.version7", F_OPTIONAL)]) +CreateEnumType("vim.cluster.DasConfigInfo.ServiceState", "ClusterDasConfigInfoServiceState", "vim.version.version5", ["disabled", "enabled"]) +CreateEnumType("vim.cluster.DasConfigInfo.VmMonitoringState", "ClusterDasConfigInfoVmMonitoringState", "vim.version.version6", ["vmMonitoringDisabled", "vmMonitoringOnly", "vmAndAppMonitoring"]) +CreateEnumType("vim.cluster.DasConfigInfo.HBDatastoreCandidate", "ClusterDasConfigInfoHBDatastoreCandidate", "vim.version.version7", ["userSelectedDs", "allFeasibleDs", "allFeasibleDsWithUserPreference"]) +CreateDataType("vim.cluster.DasData", "ClusterDasData", "vmodl.DynamicData", "vim.version.version7", None) +CreateDataType("vim.cluster.DasDataSummary", "ClusterDasDataSummary", "vim.cluster.DasData", "vim.version.version7", [("hostListVersion", "long", "vim.version.version7", 0), ("clusterConfigVersion", "long", "vim.version.version7", 0), ("compatListVersion", "long", "vim.version.version7", 0)]) +CreateDataType("vim.cluster.DasFailoverLevelAdvancedRuntimeInfo", "ClusterDasFailoverLevelAdvancedRuntimeInfo", "vim.cluster.DasAdvancedRuntimeInfo", "vim.version.version5", [("slotInfo", "vim.cluster.DasFailoverLevelAdvancedRuntimeInfo.SlotInfo", "vim.version.version5", 0), ("totalSlots", "int", "vim.version.version5", 0), ("usedSlots", "int", "vim.version.version5", 0), ("unreservedSlots", "int", "vim.version.version5", 0), ("totalVms", "int", "vim.version.version5", 0), ("totalHosts", "int", "vim.version.version5", 0), ("totalGoodHosts", "int", "vim.version.version5", 0), ("hostSlots", "vim.cluster.DasFailoverLevelAdvancedRuntimeInfo.HostSlots[]", "vim.version.version5", F_OPTIONAL), ("vmsRequiringMultipleSlots", "vim.cluster.DasFailoverLevelAdvancedRuntimeInfo.VmSlots[]", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.cluster.DasFailoverLevelAdvancedRuntimeInfo.SlotInfo", "ClusterDasFailoverLevelAdvancedRuntimeInfoSlotInfo", "vmodl.DynamicData", "vim.version.version5", [("numVcpus", "int", "vim.version.version5", 0), ("cpuMHz", "int", "vim.version.version5", 0), ("memoryMB", "int", "vim.version.version5", 0)]) +CreateDataType("vim.cluster.DasFailoverLevelAdvancedRuntimeInfo.HostSlots", "ClusterDasFailoverLevelAdvancedRuntimeInfoHostSlots", "vmodl.DynamicData", "vim.version.version5", [("host", "vim.HostSystem", "vim.version.version5", 0), ("slots", "int", "vim.version.version5", 0)]) +CreateDataType("vim.cluster.DasFailoverLevelAdvancedRuntimeInfo.VmSlots", "ClusterDasFailoverLevelAdvancedRuntimeInfoVmSlots", "vmodl.DynamicData", "vim.version.version8", [("vm", "vim.VirtualMachine", "vim.version.version8", 0), ("slots", "int", "vim.version.version8", 0)]) +CreateEnumType("vim.cluster.DasFdmAvailabilityState", "ClusterDasFdmAvailabilityState", "vim.version.version7", ["uninitialized", "election", "master", "connectedToMaster", "networkPartitionedFromMaster", "networkIsolated", "hostDown", "initializationError", "uninitializationError", "fdmUnreachable"]) +CreateDataType("vim.cluster.DasFdmHostState", "ClusterDasFdmHostState", "vmodl.DynamicData", "vim.version.version7", [("state", "string", "vim.version.version7", 0), ("stateReporter", "vim.HostSystem", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.cluster.DasHostInfo", "ClusterDasHostInfo", "vmodl.DynamicData", "vim.version.version5", None) +CreateDataType("vim.cluster.DasHostRecommendation", "ClusterDasHostRecommendation", "vmodl.DynamicData", "vim.version.version5", [("host", "vim.HostSystem", "vim.version.version5", 0), ("drsRating", "int", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.cluster.DasVmConfigInfo", "ClusterDasVmConfigInfo", "vmodl.DynamicData", "vim.version.version1", [("key", "vim.VirtualMachine", "vim.version.version1", 0), ("restartPriority", "vim.cluster.DasVmConfigInfo.Priority", "vim.version.version1", F_OPTIONAL), ("powerOffOnIsolation", "boolean", "vim.version.version1", F_OPTIONAL), ("dasSettings", "vim.cluster.DasVmSettings", "vim.version.version2", F_OPTIONAL)]) +CreateEnumType("vim.cluster.DasVmConfigInfo.Priority", "DasVmPriority", "vim.version.version1", ["disabled", "low", "medium", "high"]) +CreateDataType("vim.cluster.DasVmSettings", "ClusterDasVmSettings", "vmodl.DynamicData", "vim.version.version2", [("restartPriority", "string", "vim.version.version2", F_OPTIONAL), ("isolationResponse", "string", "vim.version.version2", F_OPTIONAL), ("vmToolsMonitoringSettings", "vim.cluster.VmToolsMonitoringSettings", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.cluster.DasVmSettings.RestartPriority", "ClusterDasVmSettingsRestartPriority", "vim.version.version2", ["disabled", "low", "medium", "high", "clusterRestartPriority"]) +CreateEnumType("vim.cluster.DasVmSettings.IsolationResponse", "ClusterDasVmSettingsIsolationResponse", "vim.version.version2", ["none", "powerOff", "shutdown", "clusterIsolationResponse"]) +CreateDataType("vim.cluster.DrsFaults", "ClusterDrsFaults", "vmodl.DynamicData", "vim.version.version5", [("reason", "string", "vim.version.version5", 0), ("faultsByVm", "vim.cluster.DrsFaults.FaultsByVm[]", "vim.version.version5", 0)]) +CreateDataType("vim.cluster.DrsFaults.FaultsByVm", "ClusterDrsFaultsFaultsByVm", "vmodl.DynamicData", "vim.version.version5", [("vm", "vim.VirtualMachine", "vim.version.version5", F_OPTIONAL), ("fault", "vmodl.MethodFault[]", "vim.version.version5", 0)]) +CreateDataType("vim.cluster.DrsFaults.FaultsByVirtualDisk", "ClusterDrsFaultsFaultsByVirtualDisk", "vim.cluster.DrsFaults.FaultsByVm", "vim.version.version7", [("disk", "vim.vm.device.VirtualDiskId", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.cluster.DrsMigration", "ClusterDrsMigration", "vmodl.DynamicData", "vim.version.version1", [("key", "string", "vim.version.version1", 0), ("time", "vmodl.DateTime", "vim.version.version1", 0), ("vm", "vim.VirtualMachine", "vim.version.version1", 0), ("cpuLoad", "int", "vim.version.version1", F_OPTIONAL), ("memoryLoad", "long", "vim.version.version1", F_OPTIONAL), ("source", "vim.HostSystem", "vim.version.version1", 0), ("sourceCpuLoad", "int", "vim.version.version1", F_OPTIONAL), ("sourceMemoryLoad", "long", "vim.version.version1", F_OPTIONAL), ("destination", "vim.HostSystem", "vim.version.version1", 0), ("destinationCpuLoad", "int", "vim.version.version1", F_OPTIONAL), ("destinationMemoryLoad", "long", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.cluster.DrsRecommendation", "ClusterDrsRecommendation", "vmodl.DynamicData", "vim.version.version1", [("key", "string", "vim.version.version1", 0), ("rating", "int", "vim.version.version1", 0), ("reason", "string", "vim.version.version1", 0), ("reasonText", "string", "vim.version.version1", 0), ("migrationList", "vim.cluster.DrsMigration[]", "vim.version.version1", 0)]) +CreateEnumType("vim.cluster.DrsRecommendation.ReasonCode", "DrsRecommendationReasonCode", "vim.version.version1", ["fairnessCpuAvg", "fairnessMemAvg", "jointAffin", "antiAffin", "hostMaint"]) +CreateDataType("vim.cluster.EnterMaintenanceResult", "ClusterEnterMaintenanceResult", "vmodl.DynamicData", "vim.version.version7", [("recommendations", "vim.cluster.Recommendation[]", "vim.version.version7", F_OPTIONAL), ("fault", "vim.cluster.DrsFaults", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.cluster.FailoverHostAdmissionControlPolicy", "ClusterFailoverHostAdmissionControlPolicy", "vim.cluster.DasAdmissionControlPolicy", "vim.version.version5", [("failoverHosts", "vim.HostSystem[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.cluster.FailoverLevelAdmissionControlInfo", "ClusterFailoverLevelAdmissionControlInfo", "vim.cluster.DasAdmissionControlInfo", "vim.version.version5", [("currentFailoverLevel", "int", "vim.version.version5", 0)]) +CreateDataType("vim.cluster.FailoverLevelAdmissionControlPolicy", "ClusterFailoverLevelAdmissionControlPolicy", "vim.cluster.DasAdmissionControlPolicy", "vim.version.version5", [("failoverLevel", "int", "vim.version.version5", 0), ("slotPolicy", "vim.cluster.SlotPolicy", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.cluster.FailoverResourcesAdmissionControlInfo", "ClusterFailoverResourcesAdmissionControlInfo", "vim.cluster.DasAdmissionControlInfo", "vim.version.version5", [("currentCpuFailoverResourcesPercent", "int", "vim.version.version5", 0), ("currentMemoryFailoverResourcesPercent", "int", "vim.version.version5", 0)]) +CreateDataType("vim.cluster.FailoverResourcesAdmissionControlPolicy", "ClusterFailoverResourcesAdmissionControlPolicy", "vim.cluster.DasAdmissionControlPolicy", "vim.version.version5", [("cpuFailoverResourcesPercent", "int", "vim.version.version5", 0), ("memoryFailoverResourcesPercent", "int", "vim.version.version5", 0)]) +CreateDataType("vim.cluster.GroupInfo", "ClusterGroupInfo", "vmodl.DynamicData", "vim.version.version6", [("name", "string", "vim.version.version6", 0), ("userCreated", "boolean", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.cluster.HostGroup", "ClusterHostGroup", "vim.cluster.GroupInfo", "vim.version.version6", [("host", "vim.HostSystem[]", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.cluster.HostPowerAction", "ClusterHostPowerAction", "vim.cluster.Action", "vim.version.version2", [("operationType", "vim.cluster.HostPowerAction.OperationType", "vim.version.version2", 0), ("powerConsumptionWatt", "int", "vim.version.version2", F_OPTIONAL), ("cpuCapacityMHz", "int", "vim.version.version2", F_OPTIONAL), ("memCapacityMB", "int", "vim.version.version2", F_OPTIONAL)]) +CreateEnumType("vim.cluster.HostPowerAction.OperationType", "HostPowerOperationType", "vim.version.version2", ["powerOn", "powerOff"]) +CreateDataType("vim.cluster.HostRecommendation", "ClusterHostRecommendation", "vmodl.DynamicData", "vim.version.version1", [("host", "vim.HostSystem", "vim.version.version1", 0), ("rating", "int", "vim.version.version1", 0)]) +CreateDataType("vim.cluster.InitialPlacementAction", "ClusterInitialPlacementAction", "vim.cluster.Action", "vim.version.version2", [("targetHost", "vim.HostSystem", "vim.version.version2", 0), ("pool", "vim.ResourcePool", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.cluster.MigrationAction", "ClusterMigrationAction", "vim.cluster.Action", "vim.version.version2", [("drsMigration", "vim.cluster.DrsMigration", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.cluster.NotAttemptedVmInfo", "ClusterNotAttemptedVmInfo", "vmodl.DynamicData", "vim.version.version2", [("vm", "vim.VirtualMachine", "vim.version.version2", 0), ("fault", "vmodl.MethodFault", "vim.version.version2", 0)]) +CreateEnumType("vim.cluster.PowerOnVmOption", "ClusterPowerOnVmOption", "vim.version.version6", ["OverrideAutomationLevel", "ReserveResources"]) +CreateDataType("vim.cluster.PowerOnVmResult", "ClusterPowerOnVmResult", "vmodl.DynamicData", "vim.version.version2", [("attempted", "vim.cluster.AttemptedVmInfo[]", "vim.version.version2", F_OPTIONAL), ("notAttempted", "vim.cluster.NotAttemptedVmInfo[]", "vim.version.version2", F_OPTIONAL), ("recommendations", "vim.cluster.Recommendation[]", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.cluster.Recommendation", "ClusterRecommendation", "vmodl.DynamicData", "vim.version.version2", [("key", "string", "vim.version.version2", 0), ("type", "string", "vim.version.version2", 0), ("time", "vmodl.DateTime", "vim.version.version2", 0), ("rating", "int", "vim.version.version2", 0), ("reason", "string", "vim.version.version2", 0), ("reasonText", "string", "vim.version.version2", 0), ("prerequisite", "string[]", "vim.version.version2", F_OPTIONAL), ("action", "vim.cluster.Action[]", "vim.version.version2", F_OPTIONAL), ("target", "vmodl.ManagedObject", "vim.version.version2", F_OPTIONAL)]) +CreateEnumType("vim.cluster.Recommendation.RecommendationType", "RecommendationType", "vim.version.version2", ["V1"]) +CreateEnumType("vim.cluster.Recommendation.ReasonCode", "RecommendationReasonCode", "vim.version.version2", ["fairnessCpuAvg", "fairnessMemAvg", "jointAffin", "antiAffin", "hostMaint", "enterStandby", "reservationCpu", "reservationMem", "powerOnVm", "powerSaving", "increaseCapacity", "checkResource", "unreservedCapacity", "colocateCommunicatingVM", "balanceNetworkBandwidthUsage", "vmHostHardAffinity", "vmHostSoftAffinity", "increaseAllocation", "balanceDatastoreSpaceUsage", "balanceDatastoreIOLoad", "datastoreMaint", "virtualDiskJointAffin", "virtualDiskAntiAffin", "datastoreSpaceOutage", "storagePlacement", "iolbDisabledInternal", "xvmotionPlacement"]) +CreateDataType("vim.cluster.SlotPolicy", "ClusterSlotPolicy", "vmodl.DynamicData", "vim.version.version8", None) +CreateDataType("vim.cluster.FixedSizeSlotPolicy", "ClusterFixedSizeSlotPolicy", "vim.cluster.SlotPolicy", "vim.version.version8", [("cpu", "int", "vim.version.version8", 0), ("memory", "int", "vim.version.version8", 0)]) +CreateDataType("vim.cluster.VmGroup", "ClusterVmGroup", "vim.cluster.GroupInfo", "vim.version.version6", [("vm", "vim.VirtualMachine[]", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.cluster.VmToolsMonitoringSettings", "ClusterVmToolsMonitoringSettings", "vmodl.DynamicData", "vim.version.version5", [("enabled", "boolean", "vim.version.version5", F_OPTIONAL), ("vmMonitoring", "string", "vim.version.version6", F_OPTIONAL), ("clusterSettings", "boolean", "vim.version.version5", F_OPTIONAL), ("failureInterval", "int", "vim.version.version5", F_OPTIONAL), ("minUpTime", "int", "vim.version.version5", F_OPTIONAL), ("maxFailures", "int", "vim.version.version5", F_OPTIONAL), ("maxFailureWindow", "int", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.dvs.DistributedVirtualPort", "DistributedVirtualPort", "vmodl.DynamicData", "vim.version.version5", [("key", "string", "vim.version.version5", 0), ("config", "vim.dvs.DistributedVirtualPort.ConfigInfo", "vim.version.version5", 0), ("dvsUuid", "string", "vim.version.version5", 0), ("portgroupKey", "string", "vim.version.version5", F_OPTIONAL), ("proxyHost", "vim.HostSystem", "vim.version.version5", F_OPTIONAL), ("connectee", "vim.dvs.PortConnectee", "vim.version.version5", F_OPTIONAL), ("conflict", "boolean", "vim.version.version5", 0), ("conflictPortKey", "string", "vim.version.version5", F_OPTIONAL), ("state", "vim.dvs.DistributedVirtualPort.State", "vim.version.version5", F_OPTIONAL), ("connectionCookie", "int", "vim.version.version5", F_OPTIONAL), ("lastStatusChange", "vmodl.DateTime", "vim.version.version5", 0), ("hostLocalPort", "boolean", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.dvs.DistributedVirtualPort.ConfigSpec", "DVPortConfigSpec", "vmodl.DynamicData", "vim.version.version5", [("operation", "string", "vim.version.version5", 0), ("key", "string", "vim.version.version5", F_OPTIONAL), ("name", "string", "vim.version.version5", F_OPTIONAL), ("scope", "vim.ManagedEntity[]", "vim.version.version5", F_OPTIONAL), ("description", "string", "vim.version.version5", F_OPTIONAL), ("setting", "vim.dvs.DistributedVirtualPort.Setting", "vim.version.version5", F_OPTIONAL), ("configVersion", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.dvs.DistributedVirtualPort.ConfigInfo", "DVPortConfigInfo", "vmodl.DynamicData", "vim.version.version5", [("name", "string", "vim.version.version5", F_OPTIONAL), ("scope", "vim.ManagedEntity[]", "vim.version.version5", F_OPTIONAL), ("description", "string", "vim.version.version5", F_OPTIONAL), ("setting", "vim.dvs.DistributedVirtualPort.Setting", "vim.version.version5", F_OPTIONAL), ("configVersion", "string", "vim.version.version5", 0)]) +CreateDataType("vim.dvs.DistributedVirtualPort.TrafficShapingPolicy", "DVSTrafficShapingPolicy", "vim.InheritablePolicy", "vim.version.version5", [("enabled", "vim.BoolPolicy", "vim.version.version5", F_OPTIONAL), ("averageBandwidth", "vim.LongPolicy", "vim.version.version5", F_OPTIONAL), ("peakBandwidth", "vim.LongPolicy", "vim.version.version5", F_OPTIONAL), ("burstSize", "vim.LongPolicy", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.dvs.DistributedVirtualPort.HostLocalPortInfo", "DVSHostLocalPortInfo", "vmodl.DynamicData", "vim.version.version8", [("switchUuid", "string", "vim.version.version8", 0), ("portKey", "string", "vim.version.version8", 0), ("setting", "vim.dvs.DistributedVirtualPort.Setting", "vim.version.version8", 0), ("vnic", "string", "vim.version.version8", 0)]) +CreateDataType("vim.dvs.DistributedVirtualPort.VendorSpecificConfig", "DVSVendorSpecificConfig", "vim.InheritablePolicy", "vim.version.version5", [("keyValue", "vim.dvs.KeyedOpaqueBlob[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.dvs.DistributedVirtualPort.FilterParameter", "DvsFilterParameter", "vmodl.DynamicData", "vim.version.version9", [("parameters", "string[]", "vim.version.version9", F_OPTIONAL)]) +CreateEnumType("vim.dvs.DistributedVirtualPort.FilterOnFailure", "DvsFilterOnFailure", "vim.version.version9", ["failOpen", "failClosed"]) +CreateDataType("vim.dvs.DistributedVirtualPort.FilterConfig", "DvsFilterConfig", "vim.InheritablePolicy", "vim.version.version9", [("key", "string", "vim.version.version9", F_OPTIONAL), ("agentName", "string", "vim.version.version9", F_OPTIONAL), ("slotNumber", "string", "vim.version.version9", F_OPTIONAL), ("parameters", "vim.dvs.DistributedVirtualPort.FilterParameter", "vim.version.version9", F_OPTIONAL), ("onFailure", "string", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.dvs.DistributedVirtualPort.TrafficFilterConfig", "DvsTrafficFilterConfig", "vim.dvs.DistributedVirtualPort.FilterConfig", "vim.version.version9", [("trafficRuleset", "vim.dvs.TrafficRuleset", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.dvs.DistributedVirtualPort.FilterConfigSpec", "DvsFilterConfigSpec", "vim.dvs.DistributedVirtualPort.FilterConfig", "vim.version.version9", [("operation", "string", "vim.version.version9", 0)]) +CreateDataType("vim.dvs.DistributedVirtualPort.TrafficFilterConfigSpec", "DvsTrafficFilterConfigSpec", "vim.dvs.DistributedVirtualPort.TrafficFilterConfig", "vim.version.version9", [("operation", "string", "vim.version.version9", 0)]) +CreateDataType("vim.dvs.DistributedVirtualPort.FilterPolicy", "DvsFilterPolicy", "vim.InheritablePolicy", "vim.version.version9", [("filterConfig", "vim.dvs.DistributedVirtualPort.FilterConfig[]", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.dvs.DistributedVirtualPort.Setting", "DVPortSetting", "vmodl.DynamicData", "vim.version.version5", [("blocked", "vim.BoolPolicy", "vim.version.version5", F_OPTIONAL), ("vmDirectPathGen2Allowed", "vim.BoolPolicy", "vim.version.version6", F_OPTIONAL), ("inShapingPolicy", "vim.dvs.DistributedVirtualPort.TrafficShapingPolicy", "vim.version.version5", F_OPTIONAL), ("outShapingPolicy", "vim.dvs.DistributedVirtualPort.TrafficShapingPolicy", "vim.version.version5", F_OPTIONAL), ("vendorSpecificConfig", "vim.dvs.DistributedVirtualPort.VendorSpecificConfig", "vim.version.version5", F_OPTIONAL), ("networkResourcePoolKey", "vim.StringPolicy", "vim.version.version7", F_OPTIONAL), ("filterPolicy", "vim.dvs.DistributedVirtualPort.FilterPolicy", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.dvs.DistributedVirtualPort.RuntimeInfo", "DVPortStatus", "vmodl.DynamicData", "vim.version.version5", [("linkUp", "boolean", "vim.version.version5", 0), ("blocked", "boolean", "vim.version.version5", 0), ("vlanIds", "vim.NumericRange[]", "vim.version.version5", F_OPTIONAL), ("trunkingMode", "boolean", "vim.version.version5", F_OPTIONAL), ("mtu", "int", "vim.version.version5", F_OPTIONAL), ("linkPeer", "string", "vim.version.version5", F_OPTIONAL), ("macAddress", "string", "vim.version.version5", F_OPTIONAL), ("statusDetail", "string", "vim.version.version6", F_OPTIONAL), ("vmDirectPathGen2Active", "boolean", "vim.version.version6", F_OPTIONAL), ("vmDirectPathGen2InactiveReasonNetwork", "string[]", "vim.version.version6", F_OPTIONAL), ("vmDirectPathGen2InactiveReasonOther", "string[]", "vim.version.version6", F_OPTIONAL), ("vmDirectPathGen2InactiveReasonExtended", "string", "vim.version.version6", F_OPTIONAL)]) +CreateEnumType("vim.dvs.DistributedVirtualPort.RuntimeInfo.VmDirectPathGen2InactiveReasonNetwork", "DVPortStatusVmDirectPathGen2InactiveReasonNetwork", "vim.version.version6", ["portNptIncompatibleDvs", "portNptNoCompatibleNics", "portNptNoVirtualFunctionsAvailable", "portNptDisabledForPort"]) +CreateEnumType("vim.dvs.DistributedVirtualPort.RuntimeInfo.VmDirectPathGen2InactiveReasonOther", "DVPortStatusVmDirectPathGen2InactiveReasonOther", "vim.version.version6", ["portNptIncompatibleHost", "portNptIncompatibleConnectee"]) +CreateDataType("vim.dvs.DistributedVirtualPort.State", "DVPortState", "vmodl.DynamicData", "vim.version.version5", [("runtimeInfo", "vim.dvs.DistributedVirtualPort.RuntimeInfo", "vim.version.version5", F_OPTIONAL), ("stats", "vim.dvs.PortStatistics", "vim.version.version5", 0), ("vendorSpecificState", "vim.dvs.KeyedOpaqueBlob[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.dvs.DistributedVirtualPortgroupInfo", "DistributedVirtualPortgroupInfo", "vmodl.DynamicData", "vim.version.version5", [("switchName", "string", "vim.version.version5", 0), ("switchUuid", "string", "vim.version.version5", 0), ("portgroupName", "string", "vim.version.version5", 0), ("portgroupKey", "string", "vim.version.version5", 0), ("portgroupType", "string", "vim.version.version5", 0), ("uplinkPortgroup", "boolean", "vim.version.version5", 0), ("portgroup", "vim.dvs.DistributedVirtualPortgroup", "vim.version.version5", 0)]) +CreateDataType("vim.dvs.DistributedVirtualPortgroupSelection", "DVPortgroupSelection", "vim.SelectionSet", "vim.version.version7", [("dvsUuid", "string", "vim.version.version7", 0), ("portgroupKey", "string[]", "vim.version.version7", 0)]) +CreateDataType("vim.dvs.DistributedVirtualSwitchInfo", "DistributedVirtualSwitchInfo", "vmodl.DynamicData", "vim.version.version5", [("switchName", "string", "vim.version.version5", 0), ("switchUuid", "string", "vim.version.version5", 0), ("distributedVirtualSwitch", "vim.DistributedVirtualSwitch", "vim.version.version5", 0)]) +CreateDataType("vim.dvs.DistributedVirtualSwitchSelection", "DVSSelection", "vim.SelectionSet", "vim.version.version7", [("dvsUuid", "string", "vim.version.version7", 0)]) +CreateDataType("vim.dvs.EntityBackup", "EntityBackup", "vmodl.DynamicData", "vim.version.version8", None) +CreateDataType("vim.dvs.EntityBackup.Config", "EntityBackupConfig", "vmodl.DynamicData", "vim.version.version8", [("entityType", "string", "vim.version.version8", 0), ("configBlob", "vmodl.Binary", "vim.version.version8", 0), ("key", "string", "vim.version.version8", F_OPTIONAL), ("name", "string", "vim.version.version8", F_OPTIONAL), ("container", "vim.ManagedEntity", "vim.version.version8", F_OPTIONAL), ("configVersion", "string", "vim.version.version8", F_OPTIONAL)]) +CreateEnumType("vim.dvs.EntityBackup.EntityType", "EntityType", "vim.version.version8", ["distributedVirtualSwitch", "distributedVirtualPortgroup"]) +CreateEnumType("vim.dvs.EntityBackup.ImportType", "EntityImportType", "vim.version.version8", ["createEntityWithNewIdentifier", "createEntityWithOriginalIdentifier", "applyToEntitySpecified"]) +CreateDataType("vim.dvs.HostMember", "DistributedVirtualSwitchHostMember", "vmodl.DynamicData", "vim.version.version5", [("runtimeState", "vim.dvs.HostMember.RuntimeState", "vim.version.version7", F_OPTIONAL), ("config", "vim.dvs.HostMember.ConfigInfo", "vim.version.version5", 0), ("productInfo", "vim.dvs.ProductSpec", "vim.version.version5", F_OPTIONAL), ("uplinkPortKey", "string[]", "vim.version.version5", F_OPTIONAL), ("status", "string", "vim.version.version5", 0), ("statusDetail", "string", "vim.version.version6", F_OPTIONAL)]) +CreateEnumType("vim.dvs.HostMember.HostComponentState", "DistributedVirtualSwitchHostMemberHostComponentState", "vim.version.version5", ["up", "pending", "outOfSync", "warning", "disconnected", "down"]) +CreateDataType("vim.dvs.HostMember.ConfigSpec", "DistributedVirtualSwitchHostMemberConfigSpec", "vmodl.DynamicData", "vim.version.version5", [("operation", "string", "vim.version.version5", 0), ("host", "vim.HostSystem", "vim.version.version5", 0), ("backing", "vim.dvs.HostMember.Backing", "vim.version.version5", F_OPTIONAL), ("maxProxySwitchPorts", "int", "vim.version.version5", F_OPTIONAL), ("vendorSpecificConfig", "vim.dvs.KeyedOpaqueBlob[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.dvs.HostMember.PnicSpec", "DistributedVirtualSwitchHostMemberPnicSpec", "vmodl.DynamicData", "vim.version.version5", [("pnicDevice", "string", "vim.version.version5", 0), ("uplinkPortKey", "string", "vim.version.version5", F_OPTIONAL), ("uplinkPortgroupKey", "string", "vim.version.version5", F_OPTIONAL), ("connectionCookie", "int", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.dvs.HostMember.Backing", "DistributedVirtualSwitchHostMemberBacking", "vmodl.DynamicData", "vim.version.version5", None) +CreateDataType("vim.dvs.HostMember.PnicBacking", "DistributedVirtualSwitchHostMemberPnicBacking", "vim.dvs.HostMember.Backing", "vim.version.version5", [("pnicSpec", "vim.dvs.HostMember.PnicSpec[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.dvs.HostMember.RuntimeState", "DistributedVirtualSwitchHostMemberRuntimeState", "vmodl.DynamicData", "vim.version.version7", [("currentMaxProxySwitchPorts", "int", "vim.version.version7", 0)]) +CreateDataType("vim.dvs.HostMember.ConfigInfo", "DistributedVirtualSwitchHostMemberConfigInfo", "vmodl.DynamicData", "vim.version.version5", [("host", "vim.HostSystem", "vim.version.version5", F_OPTIONAL), ("maxProxySwitchPorts", "int", "vim.version.version5", 0), ("vendorSpecificConfig", "vim.dvs.KeyedOpaqueBlob[]", "vim.version.version5", F_OPTIONAL), ("backing", "vim.dvs.HostMember.Backing", "vim.version.version5", 0)]) +CreateDataType("vim.dvs.HostMember.RuntimeInfo", "HostMemberRuntimeInfo", "vmodl.DynamicData", "vim.version.version8", [("host", "vim.HostSystem", "vim.version.version8", 0), ("status", "string", "vim.version.version8", F_OPTIONAL), ("statusDetail", "string", "vim.version.version8", F_OPTIONAL), ("healthCheckResult", "vim.dvs.HostMember.HealthCheckResult[]", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.dvs.HostMember.HealthCheckResult", "HostMemberHealthCheckResult", "vmodl.DynamicData", "vim.version.version8", [("summary", "string", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.dvs.HostMember.UplinkHealthCheckResult", "HostMemberUplinkHealthCheckResult", "vim.dvs.HostMember.HealthCheckResult", "vim.version.version8", [("uplinkPortKey", "string", "vim.version.version8", 0)]) +CreateDataType("vim.dvs.HostProductSpec", "DistributedVirtualSwitchHostProductSpec", "vmodl.DynamicData", "vim.version.version5", [("productLineId", "string", "vim.version.version5", F_OPTIONAL), ("version", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.dvs.KeyedOpaqueBlob", "DistributedVirtualSwitchKeyedOpaqueBlob", "vmodl.DynamicData", "vim.version.version5", [("key", "string", "vim.version.version5", 0), ("opaqueData", "string", "vim.version.version5", 0)]) +CreateDataType("vim.dvs.NetworkResourcePool", "DVSNetworkResourcePool", "vmodl.DynamicData", "vim.version.version6", [("key", "string", "vim.version.version6", 0), ("name", "string", "vim.version.version6", F_OPTIONAL), ("description", "string", "vim.version.version6", F_OPTIONAL), ("configVersion", "string", "vim.version.version6", 0), ("allocationInfo", "vim.dvs.NetworkResourcePool.AllocationInfo", "vim.version.version6", 0)]) +CreateDataType("vim.dvs.NetworkResourcePool.AllocationInfo", "DVSNetworkResourcePoolAllocationInfo", "vmodl.DynamicData", "vim.version.version6", [("limit", "long", "vim.version.version6", F_OPTIONAL), ("shares", "vim.SharesInfo", "vim.version.version6", F_OPTIONAL), ("priorityTag", "int", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.dvs.NetworkResourcePool.ConfigSpec", "DVSNetworkResourcePoolConfigSpec", "vmodl.DynamicData", "vim.version.version6", [("key", "string", "vim.version.version6", 0), ("configVersion", "string", "vim.version.version6", F_OPTIONAL), ("allocationInfo", "vim.dvs.NetworkResourcePool.AllocationInfo", "vim.version.version6", F_OPTIONAL), ("name", "string", "vim.version.version7", F_OPTIONAL), ("description", "string", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.dvs.PortConnectee", "DistributedVirtualSwitchPortConnectee", "vmodl.DynamicData", "vim.version.version5", [("connectedEntity", "vim.ManagedEntity", "vim.version.version5", F_OPTIONAL), ("nicKey", "string", "vim.version.version5", F_OPTIONAL), ("type", "string", "vim.version.version5", F_OPTIONAL), ("addressHint", "string", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.dvs.PortConnectee.ConnecteeType", "DistributedVirtualSwitchPortConnecteeConnecteeType", "vim.version.version5", ["pnic", "vmVnic", "hostConsoleVnic", "hostVmkVnic"]) +CreateDataType("vim.dvs.PortConnection", "DistributedVirtualSwitchPortConnection", "vmodl.DynamicData", "vim.version.version5", [("switchUuid", "string", "vim.version.version5", 0), ("portgroupKey", "string", "vim.version.version5", F_OPTIONAL), ("portKey", "string", "vim.version.version5", F_OPTIONAL), ("connectionCookie", "int", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.dvs.PortCriteria", "DistributedVirtualSwitchPortCriteria", "vmodl.DynamicData", "vim.version.version5", [("connected", "boolean", "vim.version.version5", F_OPTIONAL), ("active", "boolean", "vim.version.version5", F_OPTIONAL), ("uplinkPort", "boolean", "vim.version.version5", F_OPTIONAL), ("scope", "vim.ManagedEntity", "vim.version.version5", F_OPTIONAL), ("portgroupKey", "string[]", "vim.version.version5", F_OPTIONAL), ("inside", "boolean", "vim.version.version5", F_OPTIONAL), ("portKey", "string[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.dvs.PortStatistics", "DistributedVirtualSwitchPortStatistics", "vmodl.DynamicData", "vim.version.version5", [("packetsInMulticast", "long", "vim.version.version5", 0), ("packetsOutMulticast", "long", "vim.version.version5", 0), ("bytesInMulticast", "long", "vim.version.version5", 0), ("bytesOutMulticast", "long", "vim.version.version5", 0), ("packetsInUnicast", "long", "vim.version.version5", 0), ("packetsOutUnicast", "long", "vim.version.version5", 0), ("bytesInUnicast", "long", "vim.version.version5", 0), ("bytesOutUnicast", "long", "vim.version.version5", 0), ("packetsInBroadcast", "long", "vim.version.version5", 0), ("packetsOutBroadcast", "long", "vim.version.version5", 0), ("bytesInBroadcast", "long", "vim.version.version5", 0), ("bytesOutBroadcast", "long", "vim.version.version5", 0), ("packetsInDropped", "long", "vim.version.version5", 0), ("packetsOutDropped", "long", "vim.version.version5", 0), ("packetsInException", "long", "vim.version.version5", 0), ("packetsOutException", "long", "vim.version.version5", 0)]) +CreateDataType("vim.dvs.ProductSpec", "DistributedVirtualSwitchProductSpec", "vmodl.DynamicData", "vim.version.version5", [("name", "string", "vim.version.version5", F_OPTIONAL), ("vendor", "string", "vim.version.version5", F_OPTIONAL), ("version", "string", "vim.version.version5", F_OPTIONAL), ("build", "string", "vim.version.version5", F_OPTIONAL), ("forwardingClass", "string", "vim.version.version5", F_OPTIONAL), ("bundleId", "string", "vim.version.version5", F_OPTIONAL), ("bundleUrl", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.dvs.TrafficRule", "DvsTrafficRule", "vmodl.DynamicData", "vim.version.version9", [("key", "string", "vim.version.version9", F_OPTIONAL), ("description", "string", "vim.version.version9", F_OPTIONAL), ("sequence", "int", "vim.version.version9", F_OPTIONAL), ("qualifier", "vim.dvs.TrafficRule.Qualifier[]", "vim.version.version9", F_OPTIONAL), ("action", "vim.dvs.TrafficRule.Action", "vim.version.version9", F_OPTIONAL), ("direction", "string", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.dvs.TrafficRule.Qualifier", "DvsNetworkRuleQualifier", "vmodl.DynamicData", "vim.version.version9", [("key", "string", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.dvs.TrafficRule.Action", "DvsNetworkRuleAction", "vmodl.DynamicData", "vim.version.version9", None) +CreateEnumType("vim.dvs.TrafficRule.RuleDirectionType", "DvsNetworkRuleDirectionType", "vim.version.version9", ["incomingPackets", "outgoingPackets", "both"]) +CreateDataType("vim.dvs.TrafficRule.IpQualifier", "DvsIpNetworkRuleQualifier", "vim.dvs.TrafficRule.Qualifier", "vim.version.version9", [("sourceAddress", "vim.IpAddress", "vim.version.version9", F_OPTIONAL), ("destinationAddress", "vim.IpAddress", "vim.version.version9", F_OPTIONAL), ("protocol", "vim.IntExpression", "vim.version.version9", F_OPTIONAL), ("sourceIpPort", "vim.dvs.TrafficRule.IpPort", "vim.version.version9", F_OPTIONAL), ("destinationIpPort", "vim.dvs.TrafficRule.IpPort", "vim.version.version9", F_OPTIONAL), ("tcpFlags", "vim.IntExpression", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.dvs.TrafficRule.IpPort", "DvsIpPort", "vim.NegatableExpression", "vim.version.version9", None) +CreateDataType("vim.dvs.TrafficRule.SingleIpPort", "DvsSingleIpPort", "vim.dvs.TrafficRule.IpPort", "vim.version.version9", [("portNumber", "int", "vim.version.version9", 0)]) +CreateDataType("vim.dvs.TrafficRule.IpPortRange", "DvsIpPortRange", "vim.dvs.TrafficRule.IpPort", "vim.version.version9", [("startPortNumber", "int", "vim.version.version9", 0), ("endPortNumber", "int", "vim.version.version9", 0)]) +CreateDataType("vim.dvs.TrafficRule.MacQualifier", "DvsMacNetworkRuleQualifier", "vim.dvs.TrafficRule.Qualifier", "vim.version.version9", [("sourceAddress", "vim.MacAddress", "vim.version.version9", F_OPTIONAL), ("destinationAddress", "vim.MacAddress", "vim.version.version9", F_OPTIONAL), ("protocol", "vim.IntExpression", "vim.version.version9", F_OPTIONAL), ("vlanId", "vim.IntExpression", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.dvs.TrafficRule.SystemTrafficQualifier", "DvsSystemTrafficNetworkRuleQualifier", "vim.dvs.TrafficRule.Qualifier", "vim.version.version9", [("typeOfSystemTraffic", "vim.StringExpression", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.dvs.TrafficRule.DropAction", "DvsDropNetworkRuleAction", "vim.dvs.TrafficRule.Action", "vim.version.version9", None) +CreateDataType("vim.dvs.TrafficRule.AcceptAction", "DvsAcceptNetworkRuleAction", "vim.dvs.TrafficRule.Action", "vim.version.version9", None) +CreateDataType("vim.dvs.TrafficRule.UpdateTagAction", "DvsUpdateTagNetworkRuleAction", "vim.dvs.TrafficRule.Action", "vim.version.version9", [("qosTag", "int", "vim.version.version9", F_OPTIONAL), ("dscpTag", "int", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.dvs.TrafficRule.RateLimitAction", "DvsRateLimitNetworkRuleAction", "vim.dvs.TrafficRule.Action", "vim.version.version9", [("packetsPerSecond", "int", "vim.version.version9", 0)]) +CreateDataType("vim.dvs.TrafficRule.LogAction", "DvsLogNetworkRuleAction", "vim.dvs.TrafficRule.Action", "vim.version.version9", None) +CreateDataType("vim.dvs.TrafficRule.GreAction", "DvsGreEncapNetworkRuleAction", "vim.dvs.TrafficRule.Action", "vim.version.version9", [("encapsulationIp", "vim.SingleIp", "vim.version.version9", 0)]) +CreateDataType("vim.dvs.TrafficRule.MacRewriteAction", "DvsMacRewriteNetworkRuleAction", "vim.dvs.TrafficRule.Action", "vim.version.version9", [("rewriteMac", "string", "vim.version.version9", 0)]) +CreateDataType("vim.dvs.TrafficRule.PuntAction", "DvsPuntNetworkRuleAction", "vim.dvs.TrafficRule.Action", "vim.version.version9", None) +CreateDataType("vim.dvs.TrafficRule.CopyAction", "DvsCopyNetworkRuleAction", "vim.dvs.TrafficRule.Action", "vim.version.version9", None) +CreateDataType("vim.dvs.TrafficRuleset", "DvsTrafficRuleset", "vmodl.DynamicData", "vim.version.version9", [("key", "string", "vim.version.version9", F_OPTIONAL), ("enabled", "boolean", "vim.version.version9", F_OPTIONAL), ("precedence", "int", "vim.version.version9", F_OPTIONAL), ("rules", "vim.dvs.TrafficRule[]", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.event.Event", "Event", "vmodl.DynamicData", "vim.version.version1", [("key", "int", "vim.version.version1", 0), ("chainId", "int", "vim.version.version1", 0), ("createdTime", "vmodl.DateTime", "vim.version.version1", 0), ("userName", "string", "vim.version.version1", 0), ("datacenter", "vim.event.DatacenterEventArgument", "vim.version.version1", F_OPTIONAL), ("computeResource", "vim.event.ComputeResourceEventArgument", "vim.version.version1", F_OPTIONAL), ("host", "vim.event.HostEventArgument", "vim.version.version1", F_OPTIONAL), ("vm", "vim.event.VmEventArgument", "vim.version.version1", F_OPTIONAL), ("ds", "vim.event.DatastoreEventArgument", "vim.version.version5", F_OPTIONAL), ("net", "vim.event.NetworkEventArgument", "vim.version.version5", F_OPTIONAL), ("dvs", "vim.event.DvsEventArgument", "vim.version.version5", F_OPTIONAL), ("fullFormattedMessage", "string", "vim.version.version1", F_OPTIONAL), ("changeTag", "string", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.event.Event.EventSeverity", "EventEventSeverity", "vim.version.version5", ["error", "warning", "info", "user"]) +CreateDataType("vim.event.GeneralEvent", "GeneralEvent", "vim.event.Event", "vim.version.version1", [("message", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.GeneralHostInfoEvent", "GeneralHostInfoEvent", "vim.event.GeneralEvent", "vim.version.version1", None) +CreateDataType("vim.event.GeneralHostWarningEvent", "GeneralHostWarningEvent", "vim.event.GeneralEvent", "vim.version.version1", None) +CreateDataType("vim.event.GeneralHostErrorEvent", "GeneralHostErrorEvent", "vim.event.GeneralEvent", "vim.version.version1", None) +CreateDataType("vim.event.GeneralVmInfoEvent", "GeneralVmInfoEvent", "vim.event.GeneralEvent", "vim.version.version1", None) +CreateDataType("vim.event.GeneralVmWarningEvent", "GeneralVmWarningEvent", "vim.event.GeneralEvent", "vim.version.version1", None) +CreateDataType("vim.event.GeneralVmErrorEvent", "GeneralVmErrorEvent", "vim.event.GeneralEvent", "vim.version.version1", None) +CreateDataType("vim.event.GeneralUserEvent", "GeneralUserEvent", "vim.event.GeneralEvent", "vim.version.version1", [("entity", "vim.event.ManagedEntityEventArgument", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.event.ExtendedEvent", "ExtendedEvent", "vim.event.GeneralEvent", "vim.version.version2", [("eventTypeId", "string", "vim.version.version2", 0), ("managedObject", "vmodl.ManagedObject", "vim.version.version2", 0), ("data", "vim.event.ExtendedEvent.Pair[]", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.event.ExtendedEvent.Pair", "ExtendedEventPair", "vmodl.DynamicData", "vim.version.version2", [("key", "string", "vim.version.version2", 0), ("value", "string", "vim.version.version2", 0)]) +CreateDataType("vim.event.HealthStatusChangedEvent", "HealthStatusChangedEvent", "vim.event.Event", "vim.version.version5", [("componentId", "string", "vim.version.version5", 0), ("oldStatus", "string", "vim.version.version5", 0), ("newStatus", "string", "vim.version.version5", 0), ("componentName", "string", "vim.version.version5", 0)]) +CreateDataType("vim.event.HostInventoryUnreadableEvent", "HostInventoryUnreadableEvent", "vim.event.Event", "vim.version.version5", None) +CreateDataType("vim.event.DatacenterEvent", "DatacenterEvent", "vim.event.Event", "vim.version.version2", None) +CreateDataType("vim.event.DatacenterCreatedEvent", "DatacenterCreatedEvent", "vim.event.DatacenterEvent", "vim.version.version2", [("parent", "vim.event.FolderEventArgument", "vim.version.version2", 0)]) +CreateDataType("vim.event.DatacenterRenamedEvent", "DatacenterRenamedEvent", "vim.event.DatacenterEvent", "vim.version.version2", [("oldName", "string", "vim.version.version2", 0), ("newName", "string", "vim.version.version2", 0)]) +CreateDataType("vim.event.SessionEvent", "SessionEvent", "vim.event.Event", "vim.version.version1", None) +CreateDataType("vim.event.ServerStartedSessionEvent", "ServerStartedSessionEvent", "vim.event.SessionEvent", "vim.version.version1", None) +CreateDataType("vim.event.UserLoginSessionEvent", "UserLoginSessionEvent", "vim.event.SessionEvent", "vim.version.version1", [("ipAddress", "string", "vim.version.version1", 0), ("userAgent", "string", "vim.version.version8", F_OPTIONAL), ("locale", "string", "vim.version.version1", 0), ("sessionId", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.UserLogoutSessionEvent", "UserLogoutSessionEvent", "vim.event.SessionEvent", "vim.version.version1", [("ipAddress", "string", "vim.version.version8", F_OPTIONAL), ("userAgent", "string", "vim.version.version8", F_OPTIONAL), ("callCount", "long", "vim.version.version8", F_OPTIONAL), ("sessionId", "string", "vim.version.version8", F_OPTIONAL), ("loginTime", "vmodl.DateTime", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.event.BadUsernameSessionEvent", "BadUsernameSessionEvent", "vim.event.SessionEvent", "vim.version.version1", [("ipAddress", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.AlreadyAuthenticatedSessionEvent", "AlreadyAuthenticatedSessionEvent", "vim.event.SessionEvent", "vim.version.version1", None) +CreateDataType("vim.event.NoAccessUserEvent", "NoAccessUserEvent", "vim.event.SessionEvent", "vim.version.version1", [("ipAddress", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.SessionTerminatedEvent", "SessionTerminatedEvent", "vim.event.SessionEvent", "vim.version.version1", [("sessionId", "string", "vim.version.version1", 0), ("terminatedUsername", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.GlobalMessageChangedEvent", "GlobalMessageChangedEvent", "vim.event.SessionEvent", "vim.version.version1", [("message", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.UpgradeEvent", "UpgradeEvent", "vim.event.Event", "vim.version.version1", [("message", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.InfoUpgradeEvent", "InfoUpgradeEvent", "vim.event.UpgradeEvent", "vim.version.version1", None) +CreateDataType("vim.event.WarningUpgradeEvent", "WarningUpgradeEvent", "vim.event.UpgradeEvent", "vim.version.version1", None) +CreateDataType("vim.event.ErrorUpgradeEvent", "ErrorUpgradeEvent", "vim.event.UpgradeEvent", "vim.version.version1", None) +CreateDataType("vim.event.UserUpgradeEvent", "UserUpgradeEvent", "vim.event.UpgradeEvent", "vim.version.version1", None) +CreateDataType("vim.event.HostEvent", "HostEvent", "vim.event.Event", "vim.version.version1", None) +CreateDataType("vim.event.HostDasEvent", "HostDasEvent", "vim.event.HostEvent", "vim.version.version2", None) +CreateDataType("vim.event.HostConnectedEvent", "HostConnectedEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.HostDisconnectedEvent", "HostDisconnectedEvent", "vim.event.HostEvent", "vim.version.version1", [("reason", "string", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.event.HostDisconnectedEvent.ReasonCode", "HostDisconnectedEventReasonCode", "vim.version.version5", ["sslThumbprintVerifyFailed", "licenseExpired", "agentUpgrade", "userRequest", "insufficientLicenses", "agentOutOfDate", "passwordDecryptFailure", "unknown", "vcVRAMCapacityExceeded"]) +CreateDataType("vim.event.HostSyncFailedEvent", "HostSyncFailedEvent", "vim.event.HostEvent", "vim.version.version5", [("reason", "vmodl.MethodFault", "vim.version.version5", 0)]) +CreateDataType("vim.event.HostConnectionLostEvent", "HostConnectionLostEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.HostReconnectionFailedEvent", "HostReconnectionFailedEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.HostCnxFailedNoConnectionEvent", "HostCnxFailedNoConnectionEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.HostCnxFailedBadUsernameEvent", "HostCnxFailedBadUsernameEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.HostCnxFailedBadVersionEvent", "HostCnxFailedBadVersionEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.HostCnxFailedAlreadyManagedEvent", "HostCnxFailedAlreadyManagedEvent", "vim.event.HostEvent", "vim.version.version1", [("serverName", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.HostCnxFailedNoLicenseEvent", "HostCnxFailedNoLicenseEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.HostCnxFailedNetworkErrorEvent", "HostCnxFailedNetworkErrorEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.HostRemovedEvent", "HostRemovedEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.HostCnxFailedCcagentUpgradeEvent", "HostCnxFailedCcagentUpgradeEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.HostCnxFailedBadCcagentEvent", "HostCnxFailedBadCcagentEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.HostCnxFailedEvent", "HostCnxFailedEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.HostCnxFailedAccountFailedEvent", "HostCnxFailedAccountFailedEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.HostCnxFailedNoAccessEvent", "HostCnxFailedNoAccessEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.HostShutdownEvent", "HostShutdownEvent", "vim.event.HostEvent", "vim.version.version1", [("reason", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.HostCnxFailedNotFoundEvent", "HostCnxFailedNotFoundEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.HostCnxFailedTimeoutEvent", "HostCnxFailedTimeoutEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.HostUpgradeFailedEvent", "HostUpgradeFailedEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.EnteringMaintenanceModeEvent", "EnteringMaintenanceModeEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.EnteredMaintenanceModeEvent", "EnteredMaintenanceModeEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.ExitMaintenanceModeEvent", "ExitMaintenanceModeEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.CanceledHostOperationEvent", "CanceledHostOperationEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.TimedOutHostOperationEvent", "TimedOutHostOperationEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.HostDasEnabledEvent", "HostDasEnabledEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.HostDasDisabledEvent", "HostDasDisabledEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.HostDasEnablingEvent", "HostDasEnablingEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.HostDasDisablingEvent", "HostDasDisablingEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.HostDasErrorEvent", "HostDasErrorEvent", "vim.event.HostEvent", "vim.version.version1", [("message", "string", "vim.version.version2", F_OPTIONAL), ("reason", "string", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.event.HostDasErrorEvent.HostDasErrorReason", "HostDasErrorEventHostDasErrorReason", "vim.version.version5", ["configFailed", "timeout", "communicationInitFailed", "healthCheckScriptFailed", "agentFailed", "agentShutdown", "isolationAddressUnpingable", "other"]) +CreateDataType("vim.event.HostDasOkEvent", "HostDasOkEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.VcAgentUpgradedEvent", "VcAgentUpgradedEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.VcAgentUninstalledEvent", "VcAgentUninstalledEvent", "vim.event.HostEvent", "vim.version.version5", None) +CreateDataType("vim.event.VcAgentUpgradeFailedEvent", "VcAgentUpgradeFailedEvent", "vim.event.HostEvent", "vim.version.version1", [("reason", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.event.VcAgentUninstallFailedEvent", "VcAgentUninstallFailedEvent", "vim.event.HostEvent", "vim.version.version5", [("reason", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.event.HostAddedEvent", "HostAddedEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.HostAddFailedEvent", "HostAddFailedEvent", "vim.event.HostEvent", "vim.version.version1", [("hostname", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.HostIpChangedEvent", "HostIpChangedEvent", "vim.event.HostEvent", "vim.version.version2", [("oldIP", "string", "vim.version.version2", 0), ("newIP", "string", "vim.version.version2", 0)]) +CreateDataType("vim.event.EnteringStandbyModeEvent", "EnteringStandbyModeEvent", "vim.event.HostEvent", "vim.version.version2", None) +CreateDataType("vim.event.DrsEnteringStandbyModeEvent", "DrsEnteringStandbyModeEvent", "vim.event.EnteringStandbyModeEvent", "vim.version.version5", None) +CreateDataType("vim.event.EnteredStandbyModeEvent", "EnteredStandbyModeEvent", "vim.event.HostEvent", "vim.version.version2", None) +CreateDataType("vim.event.DrsEnteredStandbyModeEvent", "DrsEnteredStandbyModeEvent", "vim.event.EnteredStandbyModeEvent", "vim.version.version2", None) +CreateDataType("vim.event.ExitingStandbyModeEvent", "ExitingStandbyModeEvent", "vim.event.HostEvent", "vim.version.version5", None) +CreateDataType("vim.event.DrsExitingStandbyModeEvent", "DrsExitingStandbyModeEvent", "vim.event.ExitingStandbyModeEvent", "vim.version.version5", None) +CreateDataType("vim.event.ExitedStandbyModeEvent", "ExitedStandbyModeEvent", "vim.event.HostEvent", "vim.version.version2", None) +CreateDataType("vim.event.DrsExitedStandbyModeEvent", "DrsExitedStandbyModeEvent", "vim.event.ExitedStandbyModeEvent", "vim.version.version2", None) +CreateDataType("vim.event.ExitStandbyModeFailedEvent", "ExitStandbyModeFailedEvent", "vim.event.HostEvent", "vim.version.version5", None) +CreateDataType("vim.event.DrsExitStandbyModeFailedEvent", "DrsExitStandbyModeFailedEvent", "vim.event.ExitStandbyModeFailedEvent", "vim.version.version5", None) +CreateDataType("vim.event.UpdatedAgentBeingRestartedEvent", "UpdatedAgentBeingRestartedEvent", "vim.event.HostEvent", "vim.version.version2", None) +CreateDataType("vim.event.AccountRemovedEvent", "AccountRemovedEvent", "vim.event.HostEvent", "vim.version.version1", [("account", "string", "vim.version.version1", 0), ("group", "boolean", "vim.version.version1", 0)]) +CreateDataType("vim.event.UserPasswordChanged", "UserPasswordChanged", "vim.event.HostEvent", "vim.version.version1", [("userLogin", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.UserAssignedToGroup", "UserAssignedToGroup", "vim.event.HostEvent", "vim.version.version1", [("userLogin", "string", "vim.version.version1", 0), ("group", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.UserUnassignedFromGroup", "UserUnassignedFromGroup", "vim.event.HostEvent", "vim.version.version1", [("userLogin", "string", "vim.version.version1", 0), ("group", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.DatastorePrincipalConfigured", "DatastorePrincipalConfigured", "vim.event.HostEvent", "vim.version.version1", [("datastorePrincipal", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.VMFSDatastoreCreatedEvent", "VMFSDatastoreCreatedEvent", "vim.event.HostEvent", "vim.version.version1", [("datastore", "vim.event.DatastoreEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.NASDatastoreCreatedEvent", "NASDatastoreCreatedEvent", "vim.event.HostEvent", "vim.version.version1", [("datastore", "vim.event.DatastoreEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.LocalDatastoreCreatedEvent", "LocalDatastoreCreatedEvent", "vim.event.HostEvent", "vim.version.version1", [("datastore", "vim.event.DatastoreEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.VMFSDatastoreExtendedEvent", "VMFSDatastoreExtendedEvent", "vim.event.HostEvent", "vim.version.version5", [("datastore", "vim.event.DatastoreEventArgument", "vim.version.version5", 0)]) +CreateDataType("vim.event.VMFSDatastoreExpandedEvent", "VMFSDatastoreExpandedEvent", "vim.event.HostEvent", "vim.version.version5", [("datastore", "vim.event.DatastoreEventArgument", "vim.version.version5", 0)]) +CreateDataType("vim.event.DatastoreRemovedOnHostEvent", "DatastoreRemovedOnHostEvent", "vim.event.HostEvent", "vim.version.version1", [("datastore", "vim.event.DatastoreEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.DatastoreRenamedOnHostEvent", "DatastoreRenamedOnHostEvent", "vim.event.HostEvent", "vim.version.version1", [("oldName", "string", "vim.version.version1", 0), ("newName", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.DuplicateIpDetectedEvent", "DuplicateIpDetectedEvent", "vim.event.HostEvent", "vim.version.version2", [("duplicateIP", "string", "vim.version.version2", 0), ("macAddress", "string", "vim.version.version2", 0)]) +CreateDataType("vim.event.DatastoreDiscoveredEvent", "DatastoreDiscoveredEvent", "vim.event.HostEvent", "vim.version.version1", [("datastore", "vim.event.DatastoreEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.DrsResourceConfigureFailedEvent", "DrsResourceConfigureFailedEvent", "vim.event.HostEvent", "vim.version.version1", [("reason", "vmodl.MethodFault", "vim.version.version1", 0)]) +CreateDataType("vim.event.DrsResourceConfigureSyncedEvent", "DrsResourceConfigureSyncedEvent", "vim.event.HostEvent", "vim.version.version1", None) +CreateDataType("vim.event.HostGetShortNameFailedEvent", "HostGetShortNameFailedEvent", "vim.event.HostEvent", "vim.version.version2", None) +CreateDataType("vim.event.HostShortNameToIpFailedEvent", "HostShortNameToIpFailedEvent", "vim.event.HostEvent", "vim.version.version2", [("shortName", "string", "vim.version.version2", 0)]) +CreateDataType("vim.event.HostIpToShortNameFailedEvent", "HostIpToShortNameFailedEvent", "vim.event.HostEvent", "vim.version.version2", None) +CreateDataType("vim.event.HostPrimaryAgentNotShortNameEvent", "HostPrimaryAgentNotShortNameEvent", "vim.event.HostDasEvent", "vim.version.version2", [("primaryAgent", "string", "vim.version.version2", 0)]) +CreateDataType("vim.event.HostNotInClusterEvent", "HostNotInClusterEvent", "vim.event.HostDasEvent", "vim.version.version2", None) +CreateDataType("vim.event.HostIsolationIpPingFailedEvent", "HostIsolationIpPingFailedEvent", "vim.event.HostDasEvent", "vim.version.version2", [("isolationIp", "string", "vim.version.version2", 0)]) +CreateDataType("vim.event.HostIpInconsistentEvent", "HostIpInconsistentEvent", "vim.event.HostEvent", "vim.version.version2", [("ipAddress", "string", "vim.version.version2", 0), ("ipAddress2", "string", "vim.version.version2", 0)]) +CreateDataType("vim.event.HostUserWorldSwapNotEnabledEvent", "HostUserWorldSwapNotEnabledEvent", "vim.event.HostEvent", "vim.version.version5", None) +CreateDataType("vim.event.HostNonCompliantEvent", "HostNonCompliantEvent", "vim.event.HostEvent", "vim.version.version5", None) +CreateDataType("vim.event.HostCompliantEvent", "HostCompliantEvent", "vim.event.HostEvent", "vim.version.version5", None) +CreateDataType("vim.event.HostComplianceCheckedEvent", "HostComplianceCheckedEvent", "vim.event.HostEvent", "vim.version.version5", [("profile", "vim.event.ProfileEventArgument", "vim.version.version5", 0)]) +CreateDataType("vim.event.ProfileEvent", "ProfileEvent", "vim.event.Event", "vim.version.version5", [("profile", "vim.event.ProfileEventArgument", "vim.version.version5", 0)]) +CreateDataType("vim.event.ProfileCreatedEvent", "ProfileCreatedEvent", "vim.event.ProfileEvent", "vim.version.version5", None) +CreateDataType("vim.event.ProfileRemovedEvent", "ProfileRemovedEvent", "vim.event.ProfileEvent", "vim.version.version5", None) +CreateDataType("vim.event.ProfileAssociatedEvent", "ProfileAssociatedEvent", "vim.event.ProfileEvent", "vim.version.version5", None) +CreateDataType("vim.event.ProfileDissociatedEvent", "ProfileDissociatedEvent", "vim.event.ProfileEvent", "vim.version.version5", None) +CreateDataType("vim.event.HostConfigAppliedEvent", "HostConfigAppliedEvent", "vim.event.HostEvent", "vim.version.version5", None) +CreateDataType("vim.event.ProfileReferenceHostChangedEvent", "ProfileReferenceHostChangedEvent", "vim.event.ProfileEvent", "vim.version.version5", [("referenceHost", "vim.HostSystem", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.event.ProfileChangedEvent", "ProfileChangedEvent", "vim.event.ProfileEvent", "vim.version.version5", None) +CreateDataType("vim.event.HostProfileAppliedEvent", "HostProfileAppliedEvent", "vim.event.HostEvent", "vim.version.version5", [("profile", "vim.event.ProfileEventArgument", "vim.version.version5", 0)]) +CreateDataType("vim.event.HostShortNameInconsistentEvent", "HostShortNameInconsistentEvent", "vim.event.HostDasEvent", "vim.version.version2", [("shortName", "string", "vim.version.version2", 0), ("shortName2", "string", "vim.version.version2", 0)]) +CreateDataType("vim.event.HostNoRedundantManagementNetworkEvent", "HostNoRedundantManagementNetworkEvent", "vim.event.HostDasEvent", "vim.version.version2", None) +CreateDataType("vim.event.HostNoAvailableNetworksEvent", "HostNoAvailableNetworksEvent", "vim.event.HostDasEvent", "vim.version.version5", [("ips", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.event.HostExtraNetworksEvent", "HostExtraNetworksEvent", "vim.event.HostDasEvent", "vim.version.version5", [("ips", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.event.HostNoHAEnabledPortGroupsEvent", "HostNoHAEnabledPortGroupsEvent", "vim.event.HostDasEvent", "vim.version.version5", None) +CreateDataType("vim.event.HostMissingNetworksEvent", "HostMissingNetworksEvent", "vim.event.HostDasEvent", "vim.version.version5", [("ips", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.event.VnicPortArgument", "VnicPortArgument", "vmodl.DynamicData", "vim.version.version5", [("vnic", "string", "vim.version.version5", 0), ("port", "vim.dvs.PortConnection", "vim.version.version5", 0)]) +CreateDataType("vim.event.HostVnicConnectedToCustomizedDVPortEvent", "HostVnicConnectedToCustomizedDVPortEvent", "vim.event.HostEvent", "vim.version.version5", [("vnic", "vim.event.VnicPortArgument", "vim.version.version5", 0)]) +CreateDataType("vim.event.GhostDvsProxySwitchDetectedEvent", "GhostDvsProxySwitchDetectedEvent", "vim.event.HostEvent", "vim.version.version5", [("switchUuid", "string[]", "vim.version.version5", 0)]) +CreateDataType("vim.event.GhostDvsProxySwitchRemovedEvent", "GhostDvsProxySwitchRemovedEvent", "vim.event.HostEvent", "vim.version.version5", [("switchUuid", "string[]", "vim.version.version5", 0)]) +CreateDataType("vim.event.VmEvent", "VmEvent", "vim.event.Event", "vim.version.version1", [("template", "boolean", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmPoweredOffEvent", "VmPoweredOffEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmPoweredOnEvent", "VmPoweredOnEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmSuspendedEvent", "VmSuspendedEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmStartingEvent", "VmStartingEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmStoppingEvent", "VmStoppingEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmSuspendingEvent", "VmSuspendingEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmResumingEvent", "VmResumingEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmDisconnectedEvent", "VmDisconnectedEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmRemoteConsoleConnectedEvent", "VmRemoteConsoleConnectedEvent", "vim.event.VmEvent", "vim.version.version5", None) +CreateDataType("vim.event.VmRemoteConsoleDisconnectedEvent", "VmRemoteConsoleDisconnectedEvent", "vim.event.VmEvent", "vim.version.version5", None) +CreateDataType("vim.event.VmDiscoveredEvent", "VmDiscoveredEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmOrphanedEvent", "VmOrphanedEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmBeingCreatedEvent", "VmBeingCreatedEvent", "vim.event.VmEvent", "vim.version.version1", [("configSpec", "vim.vm.ConfigSpec", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.event.VmCreatedEvent", "VmCreatedEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmStartRecordingEvent", "VmStartRecordingEvent", "vim.event.VmEvent", "vim.version.version5", None) +CreateDataType("vim.event.VmEndRecordingEvent", "VmEndRecordingEvent", "vim.event.VmEvent", "vim.version.version5", None) +CreateDataType("vim.event.VmStartReplayingEvent", "VmStartReplayingEvent", "vim.event.VmEvent", "vim.version.version5", None) +CreateDataType("vim.event.VmEndReplayingEvent", "VmEndReplayingEvent", "vim.event.VmEvent", "vim.version.version5", None) +CreateDataType("vim.event.VmRegisteredEvent", "VmRegisteredEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmAutoRenameEvent", "VmAutoRenameEvent", "vim.event.VmEvent", "vim.version.version1", [("oldName", "string", "vim.version.version1", 0), ("newName", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmBeingHotMigratedEvent", "VmBeingHotMigratedEvent", "vim.event.VmEvent", "vim.version.version1", [("destHost", "vim.event.HostEventArgument", "vim.version.version1", 0), ("destDatacenter", "vim.event.DatacenterEventArgument", "vim.version.version7", F_OPTIONAL), ("destDatastore", "vim.event.DatastoreEventArgument", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.event.VmResettingEvent", "VmResettingEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmStaticMacConflictEvent", "VmStaticMacConflictEvent", "vim.event.VmEvent", "vim.version.version1", [("conflictedVm", "vim.event.VmEventArgument", "vim.version.version1", 0), ("mac", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmMacConflictEvent", "VmMacConflictEvent", "vim.event.VmEvent", "vim.version.version1", [("conflictedVm", "vim.event.VmEventArgument", "vim.version.version1", 0), ("mac", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmBeingDeployedEvent", "VmBeingDeployedEvent", "vim.event.VmEvent", "vim.version.version1", [("srcTemplate", "vim.event.VmEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmDeployFailedEvent", "VmDeployFailedEvent", "vim.event.VmEvent", "vim.version.version1", [("destDatastore", "vim.event.EntityEventArgument", "vim.version.version1", 0), ("reason", "vmodl.MethodFault", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmDeployedEvent", "VmDeployedEvent", "vim.event.VmEvent", "vim.version.version1", [("srcTemplate", "vim.event.VmEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmMacChangedEvent", "VmMacChangedEvent", "vim.event.VmEvent", "vim.version.version1", [("adapter", "string", "vim.version.version1", 0), ("oldMac", "string", "vim.version.version1", 0), ("newMac", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmMacAssignedEvent", "VmMacAssignedEvent", "vim.event.VmEvent", "vim.version.version1", [("adapter", "string", "vim.version.version1", 0), ("mac", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmUuidConflictEvent", "VmUuidConflictEvent", "vim.event.VmEvent", "vim.version.version1", [("conflictedVm", "vim.event.VmEventArgument", "vim.version.version1", 0), ("uuid", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmInstanceUuidConflictEvent", "VmInstanceUuidConflictEvent", "vim.event.VmEvent", "vim.version.version5", [("conflictedVm", "vim.event.VmEventArgument", "vim.version.version5", 0), ("instanceUuid", "string", "vim.version.version5", 0)]) +CreateDataType("vim.event.VmBeingMigratedEvent", "VmBeingMigratedEvent", "vim.event.VmEvent", "vim.version.version1", [("destHost", "vim.event.HostEventArgument", "vim.version.version1", 0), ("destDatacenter", "vim.event.DatacenterEventArgument", "vim.version.version7", F_OPTIONAL), ("destDatastore", "vim.event.DatastoreEventArgument", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.event.VmFailedMigrateEvent", "VmFailedMigrateEvent", "vim.event.VmEvent", "vim.version.version1", [("destHost", "vim.event.HostEventArgument", "vim.version.version1", 0), ("reason", "vmodl.MethodFault", "vim.version.version1", 0), ("destDatacenter", "vim.event.DatacenterEventArgument", "vim.version.version7", F_OPTIONAL), ("destDatastore", "vim.event.DatastoreEventArgument", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.event.VmMigratedEvent", "VmMigratedEvent", "vim.event.VmEvent", "vim.version.version1", [("sourceHost", "vim.event.HostEventArgument", "vim.version.version1", 0), ("sourceDatacenter", "vim.event.DatacenterEventArgument", "vim.version.version7", F_OPTIONAL), ("sourceDatastore", "vim.event.DatastoreEventArgument", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.event.VmUnsupportedStartingEvent", "VmUnsupportedStartingEvent", "vim.event.VmStartingEvent", "vim.version.version1", [("guestId", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.DrsVmMigratedEvent", "DrsVmMigratedEvent", "vim.event.VmMigratedEvent", "vim.version.version1", None) +CreateDataType("vim.event.DrsVmPoweredOnEvent", "DrsVmPoweredOnEvent", "vim.event.VmPoweredOnEvent", "vim.version.version2", None) +CreateDataType("vim.event.DrsRuleViolationEvent", "DrsRuleViolationEvent", "vim.event.VmEvent", "vim.version.version6", None) +CreateDataType("vim.event.DrsRuleComplianceEvent", "DrsRuleComplianceEvent", "vim.event.VmEvent", "vim.version.version6", None) +CreateDataType("vim.event.VmRelocateSpecEvent", "VmRelocateSpecEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmBeingRelocatedEvent", "VmBeingRelocatedEvent", "vim.event.VmRelocateSpecEvent", "vim.version.version1", [("destHost", "vim.event.HostEventArgument", "vim.version.version1", 0), ("destDatacenter", "vim.event.DatacenterEventArgument", "vim.version.version7", F_OPTIONAL), ("destDatastore", "vim.event.DatastoreEventArgument", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.event.VmRelocatedEvent", "VmRelocatedEvent", "vim.event.VmRelocateSpecEvent", "vim.version.version1", [("sourceHost", "vim.event.HostEventArgument", "vim.version.version1", 0), ("sourceDatacenter", "vim.event.DatacenterEventArgument", "vim.version.version7", F_OPTIONAL), ("sourceDatastore", "vim.event.DatastoreEventArgument", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.event.VmRelocateFailedEvent", "VmRelocateFailedEvent", "vim.event.VmRelocateSpecEvent", "vim.version.version1", [("destHost", "vim.event.HostEventArgument", "vim.version.version1", 0), ("reason", "vmodl.MethodFault", "vim.version.version1", 0), ("destDatacenter", "vim.event.DatacenterEventArgument", "vim.version.version7", F_OPTIONAL), ("destDatastore", "vim.event.DatastoreEventArgument", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.event.VmEmigratingEvent", "VmEmigratingEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmCloneEvent", "VmCloneEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmBeingClonedEvent", "VmBeingClonedEvent", "vim.event.VmCloneEvent", "vim.version.version1", [("destFolder", "vim.event.FolderEventArgument", "vim.version.version1", 0), ("destName", "string", "vim.version.version1", 0), ("destHost", "vim.event.HostEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmBeingClonedNoFolderEvent", "VmBeingClonedNoFolderEvent", "vim.event.VmCloneEvent", "vim.version.version6", [("destName", "string", "vim.version.version6", 0), ("destHost", "vim.event.HostEventArgument", "vim.version.version6", 0)]) +CreateDataType("vim.event.VmCloneFailedEvent", "VmCloneFailedEvent", "vim.event.VmCloneEvent", "vim.version.version1", [("destFolder", "vim.event.FolderEventArgument", "vim.version.version1", 0), ("destName", "string", "vim.version.version1", 0), ("destHost", "vim.event.HostEventArgument", "vim.version.version1", 0), ("reason", "vmodl.MethodFault", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmClonedEvent", "VmClonedEvent", "vim.event.VmCloneEvent", "vim.version.version1", [("sourceVm", "vim.event.VmEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmResourceReallocatedEvent", "VmResourceReallocatedEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmRenamedEvent", "VmRenamedEvent", "vim.event.VmEvent", "vim.version.version1", [("oldName", "string", "vim.version.version1", 0), ("newName", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmDateRolledBackEvent", "VmDateRolledBackEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmNoNetworkAccessEvent", "VmNoNetworkAccessEvent", "vim.event.VmEvent", "vim.version.version1", [("destHost", "vim.event.HostEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmDiskFailedEvent", "VmDiskFailedEvent", "vim.event.VmEvent", "vim.version.version1", [("disk", "string", "vim.version.version1", 0), ("reason", "vmodl.MethodFault", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmFailedToPowerOnEvent", "VmFailedToPowerOnEvent", "vim.event.VmEvent", "vim.version.version1", [("reason", "vmodl.MethodFault", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmFailedToPowerOffEvent", "VmFailedToPowerOffEvent", "vim.event.VmEvent", "vim.version.version1", [("reason", "vmodl.MethodFault", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmFailedToSuspendEvent", "VmFailedToSuspendEvent", "vim.event.VmEvent", "vim.version.version1", [("reason", "vmodl.MethodFault", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmFailedToResetEvent", "VmFailedToResetEvent", "vim.event.VmEvent", "vim.version.version1", [("reason", "vmodl.MethodFault", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmFailedToShutdownGuestEvent", "VmFailedToShutdownGuestEvent", "vim.event.VmEvent", "vim.version.version1", [("reason", "vmodl.MethodFault", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmFailedToRebootGuestEvent", "VmFailedToRebootGuestEvent", "vim.event.VmEvent", "vim.version.version1", [("reason", "vmodl.MethodFault", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmFailedToStandbyGuestEvent", "VmFailedToStandbyGuestEvent", "vim.event.VmEvent", "vim.version.version1", [("reason", "vmodl.MethodFault", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmRemovedEvent", "VmRemovedEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmGuestShutdownEvent", "VmGuestShutdownEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmGuestRebootEvent", "VmGuestRebootEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmGuestStandbyEvent", "VmGuestStandbyEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmUpgradingEvent", "VmUpgradingEvent", "vim.event.VmEvent", "vim.version.version1", [("version", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmUpgradeCompleteEvent", "VmUpgradeCompleteEvent", "vim.event.VmEvent", "vim.version.version1", [("version", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmUpgradeFailedEvent", "VmUpgradeFailedEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmRestartedOnAlternateHostEvent", "VmRestartedOnAlternateHostEvent", "vim.event.VmPoweredOnEvent", "vim.version.version1", [("sourceHost", "vim.event.HostEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmReconfiguredEvent", "VmReconfiguredEvent", "vim.event.VmEvent", "vim.version.version1", [("configSpec", "vim.vm.ConfigSpec", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmMessageEvent", "VmMessageEvent", "vim.event.VmEvent", "vim.version.version1", [("message", "string", "vim.version.version1", 0), ("messageInfo", "vim.vm.Message[]", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.event.VmMessageWarningEvent", "VmMessageWarningEvent", "vim.event.VmEvent", "vim.version.version5", [("message", "string", "vim.version.version5", 0), ("messageInfo", "vim.vm.Message[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.event.VmMessageErrorEvent", "VmMessageErrorEvent", "vim.event.VmEvent", "vim.version.version5", [("message", "string", "vim.version.version5", 0), ("messageInfo", "vim.vm.Message[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.event.VmConfigMissingEvent", "VmConfigMissingEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmPowerOffOnIsolationEvent", "VmPowerOffOnIsolationEvent", "vim.event.VmPoweredOffEvent", "vim.version.version1", [("isolatedHost", "vim.event.HostEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmShutdownOnIsolationEvent", "VmShutdownOnIsolationEvent", "vim.event.VmPoweredOffEvent", "vim.version.version5", [("isolatedHost", "vim.event.HostEventArgument", "vim.version.version5", 0), ("shutdownResult", "string", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.event.VmShutdownOnIsolationEvent.Operation", "VmShutdownOnIsolationEventOperation", "vim.version.version5", ["shutdown", "poweredOff"]) +CreateDataType("vim.event.VmFailoverFailed", "VmFailoverFailed", "vim.event.VmEvent", "vim.version.version1", [("reason", "vmodl.MethodFault", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.event.VmDasBeingResetEvent", "VmDasBeingResetEvent", "vim.event.VmEvent", "vim.version.version5", [("reason", "string", "vim.version.version6", F_OPTIONAL)]) +CreateEnumType("vim.event.VmDasBeingResetEvent.ReasonCode", "VmDasBeingResetEventReasonCode", "vim.version.version6", ["vmtoolsHeartbeatFailure", "appHeartbeatFailure", "appImmediateResetRequest", "vmcpResetApdCleared"]) +CreateDataType("vim.event.VmDasResetFailedEvent", "VmDasResetFailedEvent", "vim.event.VmEvent", "vim.version.version5", None) +CreateDataType("vim.event.VmMaxRestartCountReached", "VmMaxRestartCountReached", "vim.event.VmEvent", "vim.version.version5", None) +CreateDataType("vim.event.VmMaxFTRestartCountReached", "VmMaxFTRestartCountReached", "vim.event.VmEvent", "vim.version.version5", None) +CreateDataType("vim.event.VmDasBeingResetWithScreenshotEvent", "VmDasBeingResetWithScreenshotEvent", "vim.event.VmDasBeingResetEvent", "vim.version.version5", [("screenshotFilePath", "string", "vim.version.version5", 0)]) +CreateDataType("vim.event.NotEnoughResourcesToStartVmEvent", "NotEnoughResourcesToStartVmEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmUuidAssignedEvent", "VmUuidAssignedEvent", "vim.event.VmEvent", "vim.version.version1", [("uuid", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmInstanceUuidAssignedEvent", "VmInstanceUuidAssignedEvent", "vim.event.VmEvent", "vim.version.version5", [("instanceUuid", "string", "vim.version.version5", 0)]) +CreateDataType("vim.event.VmUuidChangedEvent", "VmUuidChangedEvent", "vim.event.VmEvent", "vim.version.version1", [("oldUuid", "string", "vim.version.version1", 0), ("newUuid", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmInstanceUuidChangedEvent", "VmInstanceUuidChangedEvent", "vim.event.VmEvent", "vim.version.version5", [("oldInstanceUuid", "string", "vim.version.version5", 0), ("newInstanceUuid", "string", "vim.version.version5", 0)]) +CreateDataType("vim.event.VmWwnConflictEvent", "VmWwnConflictEvent", "vim.event.VmEvent", "vim.version.version2", [("conflictedVms", "vim.event.VmEventArgument[]", "vim.version.version2", F_OPTIONAL), ("conflictedHosts", "vim.event.HostEventArgument[]", "vim.version.version2", F_OPTIONAL), ("wwn", "long", "vim.version.version2", 0)]) +CreateDataType("vim.event.VmAcquiredMksTicketEvent", "VmAcquiredMksTicketEvent", "vim.event.VmEvent", "vim.version.version2", None) +CreateDataType("vim.event.VmAcquiredTicketEvent", "VmAcquiredTicketEvent", "vim.event.VmEvent", "vim.version.version6", [("ticketType", "string", "vim.version.version6", 0)]) +CreateDataType("vim.event.HostWwnConflictEvent", "HostWwnConflictEvent", "vim.event.HostEvent", "vim.version.version2", [("conflictedVms", "vim.event.VmEventArgument[]", "vim.version.version2", F_OPTIONAL), ("conflictedHosts", "vim.event.HostEventArgument[]", "vim.version.version2", F_OPTIONAL), ("wwn", "long", "vim.version.version2", 0)]) +CreateDataType("vim.event.VmWwnAssignedEvent", "VmWwnAssignedEvent", "vim.event.VmEvent", "vim.version.version2", [("nodeWwns", "long[]", "vim.version.version2", 0), ("portWwns", "long[]", "vim.version.version2", 0)]) +CreateDataType("vim.event.VmWwnChangedEvent", "VmWwnChangedEvent", "vim.event.VmEvent", "vim.version.version2", [("oldNodeWwns", "long[]", "vim.version.version2", F_OPTIONAL), ("oldPortWwns", "long[]", "vim.version.version2", F_OPTIONAL), ("newNodeWwns", "long[]", "vim.version.version2", F_OPTIONAL), ("newPortWwns", "long[]", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.event.VmSecondaryAddedEvent", "VmSecondaryAddedEvent", "vim.event.VmEvent", "vim.version.version5", None) +CreateDataType("vim.event.VmFaultToleranceTurnedOffEvent", "VmFaultToleranceTurnedOffEvent", "vim.event.VmEvent", "vim.version.version5", None) +CreateDataType("vim.event.VmSecondaryDisabledEvent", "VmSecondaryDisabledEvent", "vim.event.VmEvent", "vim.version.version5", None) +CreateDataType("vim.event.VmSecondaryDisabledBySystemEvent", "VmSecondaryDisabledBySystemEvent", "vim.event.VmEvent", "vim.version.version5", [("reason", "vmodl.MethodFault", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.event.VmSecondaryEnabledEvent", "VmSecondaryEnabledEvent", "vim.event.VmEvent", "vim.version.version5", None) +CreateDataType("vim.event.VmStartingSecondaryEvent", "VmStartingSecondaryEvent", "vim.event.VmEvent", "vim.version.version5", None) +CreateDataType("vim.event.VmSecondaryStartedEvent", "VmSecondaryStartedEvent", "vim.event.VmEvent", "vim.version.version5", None) +CreateDataType("vim.event.VmFailedUpdatingSecondaryConfig", "VmFailedUpdatingSecondaryConfig", "vim.event.VmEvent", "vim.version.version5", None) +CreateDataType("vim.event.VmFailedStartingSecondaryEvent", "VmFailedStartingSecondaryEvent", "vim.event.VmEvent", "vim.version.version5", [("reason", "string", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.event.VmFailedStartingSecondaryEvent.FailureReason", "VmFailedStartingSecondaryEventFailureReason", "vim.version.version5", ["incompatibleHost", "loginFailed", "registerVmFailed", "migrateFailed"]) +CreateDataType("vim.event.VmTimedoutStartingSecondaryEvent", "VmTimedoutStartingSecondaryEvent", "vim.event.VmEvent", "vim.version.version5", [("timeout", "long", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.event.VmNoCompatibleHostForSecondaryEvent", "VmNoCompatibleHostForSecondaryEvent", "vim.event.VmEvent", "vim.version.version5", None) +CreateDataType("vim.event.VmPrimaryFailoverEvent", "VmPrimaryFailoverEvent", "vim.event.VmEvent", "vim.version.version5", [("reason", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.event.VmFaultToleranceVmTerminatedEvent", "VmFaultToleranceVmTerminatedEvent", "vim.event.VmEvent", "vim.version.version5", [("reason", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.event.HostWwnChangedEvent", "HostWwnChangedEvent", "vim.event.HostEvent", "vim.version.version2", [("oldNodeWwns", "long[]", "vim.version.version2", F_OPTIONAL), ("oldPortWwns", "long[]", "vim.version.version2", F_OPTIONAL), ("newNodeWwns", "long[]", "vim.version.version2", F_OPTIONAL), ("newPortWwns", "long[]", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.event.HostAdminDisableEvent", "HostAdminDisableEvent", "vim.event.HostEvent", "vim.version.version2", None) +CreateDataType("vim.event.HostAdminEnableEvent", "HostAdminEnableEvent", "vim.event.HostEvent", "vim.version.version2", None) +CreateDataType("vim.event.VmFailedRelayoutOnVmfs2DatastoreEvent", "VmFailedRelayoutOnVmfs2DatastoreEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmFailedRelayoutEvent", "VmFailedRelayoutEvent", "vim.event.VmEvent", "vim.version.version1", [("reason", "vmodl.MethodFault", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmRelayoutSuccessfulEvent", "VmRelayoutSuccessfulEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmRelayoutUpToDateEvent", "VmRelayoutUpToDateEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmConnectedEvent", "VmConnectedEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmPoweringOnWithCustomizedDVPortEvent", "VmPoweringOnWithCustomizedDVPortEvent", "vim.event.VmEvent", "vim.version.version5", [("vnic", "vim.event.VnicPortArgument[]", "vim.version.version5", 0)]) +CreateDataType("vim.event.VmDasUpdateErrorEvent", "VmDasUpdateErrorEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.NoMaintenanceModeDrsRecommendationForVM", "NoMaintenanceModeDrsRecommendationForVM", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmDasUpdateOkEvent", "VmDasUpdateOkEvent", "vim.event.VmEvent", "vim.version.version1", None) +CreateDataType("vim.event.ScheduledTaskEvent", "ScheduledTaskEvent", "vim.event.Event", "vim.version.version1", [("scheduledTask", "vim.event.ScheduledTaskEventArgument", "vim.version.version1", 0), ("entity", "vim.event.ManagedEntityEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.ScheduledTaskCreatedEvent", "ScheduledTaskCreatedEvent", "vim.event.ScheduledTaskEvent", "vim.version.version1", None) +CreateDataType("vim.event.ScheduledTaskStartedEvent", "ScheduledTaskStartedEvent", "vim.event.ScheduledTaskEvent", "vim.version.version1", None) +CreateDataType("vim.event.ScheduledTaskRemovedEvent", "ScheduledTaskRemovedEvent", "vim.event.ScheduledTaskEvent", "vim.version.version1", None) +CreateDataType("vim.event.ScheduledTaskReconfiguredEvent", "ScheduledTaskReconfiguredEvent", "vim.event.ScheduledTaskEvent", "vim.version.version1", None) +CreateDataType("vim.event.ScheduledTaskCompletedEvent", "ScheduledTaskCompletedEvent", "vim.event.ScheduledTaskEvent", "vim.version.version1", None) +CreateDataType("vim.event.ScheduledTaskFailedEvent", "ScheduledTaskFailedEvent", "vim.event.ScheduledTaskEvent", "vim.version.version1", [("reason", "vmodl.MethodFault", "vim.version.version1", 0)]) +CreateDataType("vim.event.ScheduledTaskEmailCompletedEvent", "ScheduledTaskEmailCompletedEvent", "vim.event.ScheduledTaskEvent", "vim.version.version1", [("to", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.ScheduledTaskEmailFailedEvent", "ScheduledTaskEmailFailedEvent", "vim.event.ScheduledTaskEvent", "vim.version.version1", [("to", "string", "vim.version.version1", 0), ("reason", "vmodl.MethodFault", "vim.version.version1", 0)]) +CreateDataType("vim.event.AlarmEvent", "AlarmEvent", "vim.event.Event", "vim.version.version1", [("alarm", "vim.event.AlarmEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.AlarmCreatedEvent", "AlarmCreatedEvent", "vim.event.AlarmEvent", "vim.version.version1", [("entity", "vim.event.ManagedEntityEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.AlarmStatusChangedEvent", "AlarmStatusChangedEvent", "vim.event.AlarmEvent", "vim.version.version1", [("source", "vim.event.ManagedEntityEventArgument", "vim.version.version1", 0), ("entity", "vim.event.ManagedEntityEventArgument", "vim.version.version1", 0), ("from", "string", "vim.version.version1", 0), ("to", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.AlarmActionTriggeredEvent", "AlarmActionTriggeredEvent", "vim.event.AlarmEvent", "vim.version.version1", [("source", "vim.event.ManagedEntityEventArgument", "vim.version.version1", 0), ("entity", "vim.event.ManagedEntityEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.AlarmEmailCompletedEvent", "AlarmEmailCompletedEvent", "vim.event.AlarmEvent", "vim.version.version1", [("entity", "vim.event.ManagedEntityEventArgument", "vim.version.version1", 0), ("to", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.AlarmEmailFailedEvent", "AlarmEmailFailedEvent", "vim.event.AlarmEvent", "vim.version.version1", [("entity", "vim.event.ManagedEntityEventArgument", "vim.version.version1", 0), ("to", "string", "vim.version.version1", 0), ("reason", "vmodl.MethodFault", "vim.version.version1", 0)]) +CreateDataType("vim.event.AlarmSnmpCompletedEvent", "AlarmSnmpCompletedEvent", "vim.event.AlarmEvent", "vim.version.version1", [("entity", "vim.event.ManagedEntityEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.AlarmSnmpFailedEvent", "AlarmSnmpFailedEvent", "vim.event.AlarmEvent", "vim.version.version1", [("entity", "vim.event.ManagedEntityEventArgument", "vim.version.version1", 0), ("reason", "vmodl.MethodFault", "vim.version.version1", 0)]) +CreateDataType("vim.event.AlarmScriptCompleteEvent", "AlarmScriptCompleteEvent", "vim.event.AlarmEvent", "vim.version.version1", [("entity", "vim.event.ManagedEntityEventArgument", "vim.version.version1", 0), ("script", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.AlarmScriptFailedEvent", "AlarmScriptFailedEvent", "vim.event.AlarmEvent", "vim.version.version1", [("entity", "vim.event.ManagedEntityEventArgument", "vim.version.version1", 0), ("script", "string", "vim.version.version1", 0), ("reason", "vmodl.MethodFault", "vim.version.version1", 0)]) +CreateDataType("vim.event.AlarmRemovedEvent", "AlarmRemovedEvent", "vim.event.AlarmEvent", "vim.version.version1", [("entity", "vim.event.ManagedEntityEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.AlarmReconfiguredEvent", "AlarmReconfiguredEvent", "vim.event.AlarmEvent", "vim.version.version1", [("entity", "vim.event.ManagedEntityEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.AlarmAcknowledgedEvent", "AlarmAcknowledgedEvent", "vim.event.AlarmEvent", "vim.version.version7", [("source", "vim.event.ManagedEntityEventArgument", "vim.version.version7", 0), ("entity", "vim.event.ManagedEntityEventArgument", "vim.version.version7", 0)]) +CreateDataType("vim.event.AlarmClearedEvent", "AlarmClearedEvent", "vim.event.AlarmEvent", "vim.version.version7", [("source", "vim.event.ManagedEntityEventArgument", "vim.version.version7", 0), ("entity", "vim.event.ManagedEntityEventArgument", "vim.version.version7", 0), ("from", "string", "vim.version.version7", 0)]) +CreateDataType("vim.event.CustomFieldEvent", "CustomFieldEvent", "vim.event.Event", "vim.version.version1", None) +CreateDataType("vim.event.CustomFieldDefEvent", "CustomFieldDefEvent", "vim.event.CustomFieldEvent", "vim.version.version1", [("fieldKey", "int", "vim.version.version1", 0), ("name", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.CustomFieldDefAddedEvent", "CustomFieldDefAddedEvent", "vim.event.CustomFieldDefEvent", "vim.version.version1", None) +CreateDataType("vim.event.CustomFieldDefRemovedEvent", "CustomFieldDefRemovedEvent", "vim.event.CustomFieldDefEvent", "vim.version.version1", None) +CreateDataType("vim.event.CustomFieldDefRenamedEvent", "CustomFieldDefRenamedEvent", "vim.event.CustomFieldDefEvent", "vim.version.version1", [("newName", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.CustomFieldValueChangedEvent", "CustomFieldValueChangedEvent", "vim.event.CustomFieldEvent", "vim.version.version1", [("entity", "vim.event.ManagedEntityEventArgument", "vim.version.version1", 0), ("fieldKey", "int", "vim.version.version1", 0), ("name", "string", "vim.version.version1", 0), ("value", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.AuthorizationEvent", "AuthorizationEvent", "vim.event.Event", "vim.version.version1", None) +CreateDataType("vim.event.PermissionEvent", "PermissionEvent", "vim.event.AuthorizationEvent", "vim.version.version1", [("entity", "vim.event.ManagedEntityEventArgument", "vim.version.version1", 0), ("principal", "string", "vim.version.version1", 0), ("group", "boolean", "vim.version.version1", 0)]) +CreateDataType("vim.event.PermissionAddedEvent", "PermissionAddedEvent", "vim.event.PermissionEvent", "vim.version.version1", [("role", "vim.event.RoleEventArgument", "vim.version.version1", 0), ("propagate", "boolean", "vim.version.version1", 0)]) +CreateDataType("vim.event.PermissionUpdatedEvent", "PermissionUpdatedEvent", "vim.event.PermissionEvent", "vim.version.version1", [("role", "vim.event.RoleEventArgument", "vim.version.version1", 0), ("propagate", "boolean", "vim.version.version1", 0)]) +CreateDataType("vim.event.PermissionRemovedEvent", "PermissionRemovedEvent", "vim.event.PermissionEvent", "vim.version.version1", None) +CreateDataType("vim.event.RoleEvent", "RoleEvent", "vim.event.AuthorizationEvent", "vim.version.version1", [("role", "vim.event.RoleEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.RoleAddedEvent", "RoleAddedEvent", "vim.event.RoleEvent", "vim.version.version1", [("privilegeList", "string[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.event.RoleUpdatedEvent", "RoleUpdatedEvent", "vim.event.RoleEvent", "vim.version.version1", [("privilegeList", "string[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.event.RoleRemovedEvent", "RoleRemovedEvent", "vim.event.RoleEvent", "vim.version.version1", None) +CreateDataType("vim.event.DatastoreEvent", "DatastoreEvent", "vim.event.Event", "vim.version.version1", [("datastore", "vim.event.DatastoreEventArgument", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.event.DatastoreDestroyedEvent", "DatastoreDestroyedEvent", "vim.event.DatastoreEvent", "vim.version.version1", None) +CreateDataType("vim.event.DatastoreRenamedEvent", "DatastoreRenamedEvent", "vim.event.DatastoreEvent", "vim.version.version1", [("oldName", "string", "vim.version.version1", 0), ("newName", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.DatastoreCapacityIncreasedEvent", "DatastoreCapacityIncreasedEvent", "vim.event.DatastoreEvent", "vim.version.version5", [("oldCapacity", "long", "vim.version.version5", 0), ("newCapacity", "long", "vim.version.version5", 0)]) +CreateDataType("vim.event.DatastoreDuplicatedEvent", "DatastoreDuplicatedEvent", "vim.event.DatastoreEvent", "vim.version.version1", None) +CreateDataType("vim.event.DatastoreFileEvent", "DatastoreFileEvent", "vim.event.DatastoreEvent", "vim.version.version5", [("targetFile", "string", "vim.version.version5", 0)]) +CreateDataType("vim.event.DatastoreFileCopiedEvent", "DatastoreFileCopiedEvent", "vim.event.DatastoreFileEvent", "vim.version.version5", [("sourceDatastore", "vim.event.DatastoreEventArgument", "vim.version.version5", 0), ("sourceFile", "string", "vim.version.version5", 0)]) +CreateDataType("vim.event.DatastoreFileMovedEvent", "DatastoreFileMovedEvent", "vim.event.DatastoreFileEvent", "vim.version.version5", [("sourceDatastore", "vim.event.DatastoreEventArgument", "vim.version.version5", 0), ("sourceFile", "string", "vim.version.version5", 0)]) +CreateDataType("vim.event.DatastoreFileDeletedEvent", "DatastoreFileDeletedEvent", "vim.event.DatastoreFileEvent", "vim.version.version5", None) +CreateDataType("vim.event.NonVIWorkloadDetectedOnDatastoreEvent", "NonVIWorkloadDetectedOnDatastoreEvent", "vim.event.DatastoreEvent", "vim.version.version6", None) +CreateDataType("vim.event.DatastoreIORMReconfiguredEvent", "DatastoreIORMReconfiguredEvent", "vim.event.DatastoreEvent", "vim.version.version6", None) +CreateDataType("vim.event.TaskEvent", "TaskEvent", "vim.event.Event", "vim.version.version1", [("info", "vim.TaskInfo", "vim.version.version1", 0)]) +CreateDataType("vim.event.TaskTimeoutEvent", "TaskTimeoutEvent", "vim.event.TaskEvent", "vim.version.version2", None) +CreateDataType("vim.event.LicenseEvent", "LicenseEvent", "vim.event.Event", "vim.version.version1", None) +CreateDataType("vim.event.ServerLicenseExpiredEvent", "ServerLicenseExpiredEvent", "vim.event.LicenseEvent", "vim.version.version1", [("product", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.HostLicenseExpiredEvent", "HostLicenseExpiredEvent", "vim.event.LicenseEvent", "vim.version.version1", None) +CreateDataType("vim.event.VMotionLicenseExpiredEvent", "VMotionLicenseExpiredEvent", "vim.event.LicenseEvent", "vim.version.version1", None) +CreateDataType("vim.event.NoLicenseEvent", "NoLicenseEvent", "vim.event.LicenseEvent", "vim.version.version1", [("feature", "vim.LicenseManager.FeatureInfo", "vim.version.version1", 0)]) +CreateDataType("vim.event.LicenseServerUnavailableEvent", "LicenseServerUnavailableEvent", "vim.event.LicenseEvent", "vim.version.version1", [("licenseServer", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.LicenseServerAvailableEvent", "LicenseServerAvailableEvent", "vim.event.LicenseEvent", "vim.version.version1", [("licenseServer", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.LicenseExpiredEvent", "LicenseExpiredEvent", "vim.event.Event", "vim.version.version1", [("feature", "vim.LicenseManager.FeatureInfo", "vim.version.version1", 0)]) +CreateDataType("vim.event.InvalidEditionEvent", "InvalidEditionEvent", "vim.event.LicenseEvent", "vim.version.version2", [("feature", "string", "vim.version.version2", 0)]) +CreateDataType("vim.event.HostInventoryFullEvent", "HostInventoryFullEvent", "vim.event.LicenseEvent", "vim.version.version2", [("capacity", "int", "vim.version.version2", 0)]) +CreateDataType("vim.event.LicenseRestrictedEvent", "LicenseRestrictedEvent", "vim.event.LicenseEvent", "vim.version.version2", None) +CreateDataType("vim.event.IncorrectHostInformationEvent", "IncorrectHostInformationEvent", "vim.event.LicenseEvent", "vim.version.version2", None) +CreateDataType("vim.event.UnlicensedVirtualMachinesEvent", "UnlicensedVirtualMachinesEvent", "vim.event.LicenseEvent", "vim.version.version2", [("unlicensed", "int", "vim.version.version2", 0), ("available", "int", "vim.version.version2", 0)]) +CreateDataType("vim.event.UnlicensedVirtualMachinesFoundEvent", "UnlicensedVirtualMachinesFoundEvent", "vim.event.LicenseEvent", "vim.version.version2", [("available", "int", "vim.version.version2", 0)]) +CreateDataType("vim.event.AllVirtualMachinesLicensedEvent", "AllVirtualMachinesLicensedEvent", "vim.event.LicenseEvent", "vim.version.version2", None) +CreateDataType("vim.event.LicenseNonComplianceEvent", "LicenseNonComplianceEvent", "vim.event.LicenseEvent", "vim.version.version5", [("url", "string", "vim.version.version5", 0)]) +CreateDataType("vim.event.MigrationEvent", "MigrationEvent", "vim.event.VmEvent", "vim.version.version1", [("fault", "vmodl.MethodFault", "vim.version.version1", 0)]) +CreateDataType("vim.event.MigrationWarningEvent", "MigrationWarningEvent", "vim.event.MigrationEvent", "vim.version.version1", None) +CreateDataType("vim.event.MigrationErrorEvent", "MigrationErrorEvent", "vim.event.MigrationEvent", "vim.version.version1", None) +CreateDataType("vim.event.MigrationHostWarningEvent", "MigrationHostWarningEvent", "vim.event.MigrationEvent", "vim.version.version1", [("dstHost", "vim.event.HostEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.MigrationHostErrorEvent", "MigrationHostErrorEvent", "vim.event.MigrationEvent", "vim.version.version1", [("dstHost", "vim.event.HostEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.MigrationResourceWarningEvent", "MigrationResourceWarningEvent", "vim.event.MigrationEvent", "vim.version.version1", [("dstPool", "vim.event.ResourcePoolEventArgument", "vim.version.version1", 0), ("dstHost", "vim.event.HostEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.MigrationResourceErrorEvent", "MigrationResourceErrorEvent", "vim.event.MigrationEvent", "vim.version.version1", [("dstPool", "vim.event.ResourcePoolEventArgument", "vim.version.version1", 0), ("dstHost", "vim.event.HostEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.ClusterEvent", "ClusterEvent", "vim.event.Event", "vim.version.version1", None) +CreateDataType("vim.event.DasEnabledEvent", "DasEnabledEvent", "vim.event.ClusterEvent", "vim.version.version1", None) +CreateDataType("vim.event.DasDisabledEvent", "DasDisabledEvent", "vim.event.ClusterEvent", "vim.version.version1", None) +CreateDataType("vim.event.DasAdmissionControlDisabledEvent", "DasAdmissionControlDisabledEvent", "vim.event.ClusterEvent", "vim.version.version1", None) +CreateDataType("vim.event.DasAdmissionControlEnabledEvent", "DasAdmissionControlEnabledEvent", "vim.event.ClusterEvent", "vim.version.version1", None) +CreateDataType("vim.event.DasHostFailedEvent", "DasHostFailedEvent", "vim.event.ClusterEvent", "vim.version.version1", [("failedHost", "vim.event.HostEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.DasHostIsolatedEvent", "DasHostIsolatedEvent", "vim.event.ClusterEvent", "vim.version.version1", [("isolatedHost", "vim.event.HostEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.DasClusterIsolatedEvent", "DasClusterIsolatedEvent", "vim.event.ClusterEvent", "vim.version.version5", None) +CreateDataType("vim.event.DasAgentUnavailableEvent", "DasAgentUnavailableEvent", "vim.event.ClusterEvent", "vim.version.version1", None) +CreateDataType("vim.event.DasAgentFoundEvent", "DasAgentFoundEvent", "vim.event.ClusterEvent", "vim.version.version1", None) +CreateDataType("vim.event.InsufficientFailoverResourcesEvent", "InsufficientFailoverResourcesEvent", "vim.event.ClusterEvent", "vim.version.version1", None) +CreateDataType("vim.event.FailoverLevelRestored", "FailoverLevelRestored", "vim.event.ClusterEvent", "vim.version.version1", None) +CreateDataType("vim.event.ClusterOvercommittedEvent", "ClusterOvercommittedEvent", "vim.event.ClusterEvent", "vim.version.version1", None) +CreateDataType("vim.event.HostOvercommittedEvent", "HostOvercommittedEvent", "vim.event.ClusterOvercommittedEvent", "vim.version.version5", None) +CreateDataType("vim.event.ClusterStatusChangedEvent", "ClusterStatusChangedEvent", "vim.event.ClusterEvent", "vim.version.version1", [("oldStatus", "string", "vim.version.version1", 0), ("newStatus", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.HostStatusChangedEvent", "HostStatusChangedEvent", "vim.event.ClusterStatusChangedEvent", "vim.version.version5", None) +CreateDataType("vim.event.ClusterCreatedEvent", "ClusterCreatedEvent", "vim.event.ClusterEvent", "vim.version.version1", [("parent", "vim.event.FolderEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.ClusterDestroyedEvent", "ClusterDestroyedEvent", "vim.event.ClusterEvent", "vim.version.version1", None) +CreateDataType("vim.event.DrsEnabledEvent", "DrsEnabledEvent", "vim.event.ClusterEvent", "vim.version.version1", [("behavior", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.DrsDisabledEvent", "DrsDisabledEvent", "vim.event.ClusterEvent", "vim.version.version1", None) +CreateDataType("vim.event.ClusterReconfiguredEvent", "ClusterReconfiguredEvent", "vim.event.ClusterEvent", "vim.version.version1", None) +CreateDataType("vim.event.HostMonitoringStateChangedEvent", "HostMonitoringStateChangedEvent", "vim.event.ClusterEvent", "vim.version.version5", [("state", "string", "vim.version.version5", 0)]) +CreateDataType("vim.event.VmHealthMonitoringStateChangedEvent", "VmHealthMonitoringStateChangedEvent", "vim.event.ClusterEvent", "vim.version.version5", [("state", "string", "vim.version.version5", 0)]) +CreateDataType("vim.event.ResourcePoolEvent", "ResourcePoolEvent", "vim.event.Event", "vim.version.version1", [("resourcePool", "vim.event.ResourcePoolEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.ResourcePoolCreatedEvent", "ResourcePoolCreatedEvent", "vim.event.ResourcePoolEvent", "vim.version.version1", [("parent", "vim.event.ResourcePoolEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.ResourcePoolDestroyedEvent", "ResourcePoolDestroyedEvent", "vim.event.ResourcePoolEvent", "vim.version.version1", None) +CreateDataType("vim.event.ResourcePoolMovedEvent", "ResourcePoolMovedEvent", "vim.event.ResourcePoolEvent", "vim.version.version1", [("oldParent", "vim.event.ResourcePoolEventArgument", "vim.version.version1", 0), ("newParent", "vim.event.ResourcePoolEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.ResourcePoolReconfiguredEvent", "ResourcePoolReconfiguredEvent", "vim.event.ResourcePoolEvent", "vim.version.version1", None) +CreateDataType("vim.event.ResourceViolatedEvent", "ResourceViolatedEvent", "vim.event.ResourcePoolEvent", "vim.version.version1", None) +CreateDataType("vim.event.VmResourcePoolMovedEvent", "VmResourcePoolMovedEvent", "vim.event.VmEvent", "vim.version.version1", [("oldParent", "vim.event.ResourcePoolEventArgument", "vim.version.version1", 0), ("newParent", "vim.event.ResourcePoolEventArgument", "vim.version.version1", 0)]) +CreateDataType("vim.event.TemplateUpgradeEvent", "TemplateUpgradeEvent", "vim.event.Event", "vim.version.version1", [("legacyTemplate", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.TemplateBeingUpgradedEvent", "TemplateBeingUpgradedEvent", "vim.event.TemplateUpgradeEvent", "vim.version.version1", None) +CreateDataType("vim.event.TemplateUpgradeFailedEvent", "TemplateUpgradeFailedEvent", "vim.event.TemplateUpgradeEvent", "vim.version.version1", [("reason", "vmodl.MethodFault", "vim.version.version1", 0)]) +CreateDataType("vim.event.TemplateUpgradedEvent", "TemplateUpgradedEvent", "vim.event.TemplateUpgradeEvent", "vim.version.version1", None) +CreateDataType("vim.event.CustomizationEvent", "CustomizationEvent", "vim.event.VmEvent", "vim.version.version2", [("logLocation", "string", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.event.CustomizationStartedEvent", "CustomizationStartedEvent", "vim.event.CustomizationEvent", "vim.version.version2", None) +CreateDataType("vim.event.CustomizationSucceeded", "CustomizationSucceeded", "vim.event.CustomizationEvent", "vim.version.version2", None) +CreateDataType("vim.event.CustomizationFailed", "CustomizationFailed", "vim.event.CustomizationEvent", "vim.version.version2", None) +CreateDataType("vim.event.CustomizationUnknownFailure", "CustomizationUnknownFailure", "vim.event.CustomizationFailed", "vim.version.version2", None) +CreateDataType("vim.event.CustomizationSysprepFailed", "CustomizationSysprepFailed", "vim.event.CustomizationFailed", "vim.version.version2", [("sysprepVersion", "string", "vim.version.version2", 0), ("systemVersion", "string", "vim.version.version2", 0)]) +CreateDataType("vim.event.CustomizationLinuxIdentityFailed", "CustomizationLinuxIdentityFailed", "vim.event.CustomizationFailed", "vim.version.version2", None) +CreateDataType("vim.event.CustomizationNetworkSetupFailed", "CustomizationNetworkSetupFailed", "vim.event.CustomizationFailed", "vim.version.version2", None) +CreateDataType("vim.event.LockerMisconfiguredEvent", "LockerMisconfiguredEvent", "vim.event.Event", "vim.version.version2", [("datastore", "vim.event.DatastoreEventArgument", "vim.version.version2", 0)]) +CreateDataType("vim.event.LockerReconfiguredEvent", "LockerReconfiguredEvent", "vim.event.Event", "vim.version.version2", [("oldDatastore", "vim.event.DatastoreEventArgument", "vim.version.version2", F_OPTIONAL), ("newDatastore", "vim.event.DatastoreEventArgument", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.event.NoDatastoresConfiguredEvent", "NoDatastoresConfiguredEvent", "vim.event.HostEvent", "vim.version.version2", None) +CreateDataType("vim.event.AdminPasswordNotChangedEvent", "AdminPasswordNotChangedEvent", "vim.event.HostEvent", "vim.version.version2", None) +CreateDataType("vim.event.HostInAuditModeEvent", "HostInAuditModeEvent", "vim.event.HostEvent", "vim.version.version7", None) +CreateDataType("vim.event.LocalTSMEnabledEvent", "LocalTSMEnabledEvent", "vim.event.HostEvent", "vim.version.version6", None) +CreateDataType("vim.event.RemoteTSMEnabledEvent", "RemoteTSMEnabledEvent", "vim.event.HostEvent", "vim.version.version6", None) +CreateDataType("vim.event.VimAccountPasswordChangedEvent", "VimAccountPasswordChangedEvent", "vim.event.HostEvent", "vim.version.version2", None) +CreateDataType("vim.event.iScsiBootFailureEvent", "IScsiBootFailureEvent", "vim.event.HostEvent", "vim.version.version6", None) +CreateDataType("vim.event.DvsHealthStatusChangeEvent", "DvsHealthStatusChangeEvent", "vim.event.HostEvent", "vim.version.version8", [("switchUuid", "string", "vim.version.version8", 0), ("healthResult", "vim.dvs.HostMember.HealthCheckResult", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.event.NetworkRollbackEvent", "NetworkRollbackEvent", "vim.event.Event", "vim.version.version8", [("methodName", "string", "vim.version.version8", 0), ("transactionId", "string", "vim.version.version8", 0)]) +CreateDataType("vim.event.UplinkPortVlanTrunkedEvent", "UplinkPortVlanTrunkedEvent", "vim.event.DvsHealthStatusChangeEvent", "vim.version.version8", None) +CreateDataType("vim.event.UplinkPortVlanUntrunkedEvent", "UplinkPortVlanUntrunkedEvent", "vim.event.DvsHealthStatusChangeEvent", "vim.version.version8", None) +CreateDataType("vim.event.MtuMatchEvent", "MtuMatchEvent", "vim.event.DvsHealthStatusChangeEvent", "vim.version.version8", None) +CreateDataType("vim.event.MtuMismatchEvent", "MtuMismatchEvent", "vim.event.DvsHealthStatusChangeEvent", "vim.version.version8", None) +CreateDataType("vim.event.UplinkPortMtuNotSupportEvent", "UplinkPortMtuNotSupportEvent", "vim.event.DvsHealthStatusChangeEvent", "vim.version.version8", None) +CreateDataType("vim.event.UplinkPortMtuSupportEvent", "UplinkPortMtuSupportEvent", "vim.event.DvsHealthStatusChangeEvent", "vim.version.version8", None) +CreateDataType("vim.event.TeamingMatchEvent", "TeamingMatchEvent", "vim.event.DvsHealthStatusChangeEvent", "vim.version.version8", None) +CreateDataType("vim.event.TeamingMisMatchEvent", "TeamingMisMatchEvent", "vim.event.DvsHealthStatusChangeEvent", "vim.version.version8", None) +CreateDataType("vim.event.DvsEvent", "DvsEvent", "vim.event.Event", "vim.version.version5", None) +CreateDataType("vim.event.DvsCreatedEvent", "DvsCreatedEvent", "vim.event.DvsEvent", "vim.version.version5", [("parent", "vim.event.FolderEventArgument", "vim.version.version5", 0)]) +CreateDataType("vim.event.DvsRenamedEvent", "DvsRenamedEvent", "vim.event.DvsEvent", "vim.version.version5", [("oldName", "string", "vim.version.version5", 0), ("newName", "string", "vim.version.version5", 0)]) +CreateDataType("vim.event.DvsUpgradeAvailableEvent", "DvsUpgradeAvailableEvent", "vim.event.DvsEvent", "vim.version.version5", [("productInfo", "vim.dvs.ProductSpec", "vim.version.version5", 0)]) +CreateDataType("vim.event.DvsUpgradeInProgressEvent", "DvsUpgradeInProgressEvent", "vim.event.DvsEvent", "vim.version.version5", [("productInfo", "vim.dvs.ProductSpec", "vim.version.version5", 0)]) +CreateDataType("vim.event.DvsUpgradeRejectedEvent", "DvsUpgradeRejectedEvent", "vim.event.DvsEvent", "vim.version.version5", [("productInfo", "vim.dvs.ProductSpec", "vim.version.version5", 0)]) +CreateDataType("vim.event.DvsUpgradedEvent", "DvsUpgradedEvent", "vim.event.DvsEvent", "vim.version.version5", [("productInfo", "vim.dvs.ProductSpec", "vim.version.version5", 0)]) +CreateDataType("vim.event.DvsHostJoinedEvent", "DvsHostJoinedEvent", "vim.event.DvsEvent", "vim.version.version5", [("hostJoined", "vim.event.HostEventArgument", "vim.version.version5", 0)]) +CreateDataType("vim.event.DvsHostLeftEvent", "DvsHostLeftEvent", "vim.event.DvsEvent", "vim.version.version5", [("hostLeft", "vim.event.HostEventArgument", "vim.version.version5", 0)]) +CreateDataType("vim.event.DvsOutOfSyncHostArgument", "DvsOutOfSyncHostArgument", "vmodl.DynamicData", "vim.version.version5", [("outOfSyncHost", "vim.event.HostEventArgument", "vim.version.version5", 0), ("configParamters", "string[]", "vim.version.version5", 0)]) +CreateDataType("vim.event.OutOfSyncDvsHost", "OutOfSyncDvsHost", "vim.event.DvsEvent", "vim.version.version5", [("hostOutOfSync", "vim.event.DvsOutOfSyncHostArgument[]", "vim.version.version5", 0)]) +CreateDataType("vim.event.DvsHostWentOutOfSyncEvent", "DvsHostWentOutOfSyncEvent", "vim.event.DvsEvent", "vim.version.version5", [("hostOutOfSync", "vim.event.DvsOutOfSyncHostArgument", "vim.version.version5", 0)]) +CreateDataType("vim.event.DvsHostBackInSyncEvent", "DvsHostBackInSyncEvent", "vim.event.DvsEvent", "vim.version.version5", [("hostBackInSync", "vim.event.HostEventArgument", "vim.version.version5", 0)]) +CreateDataType("vim.event.DvsHostStatusUpdated", "DvsHostStatusUpdated", "vim.event.DvsEvent", "vim.version.version6", [("hostMember", "vim.event.HostEventArgument", "vim.version.version6", 0), ("oldStatus", "string", "vim.version.version6", F_OPTIONAL), ("newStatus", "string", "vim.version.version6", F_OPTIONAL), ("oldStatusDetail", "string", "vim.version.version6", F_OPTIONAL), ("newStatusDetail", "string", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.event.DvsPortCreatedEvent", "DvsPortCreatedEvent", "vim.event.DvsEvent", "vim.version.version5", [("portKey", "string[]", "vim.version.version5", 0)]) +CreateDataType("vim.event.DvsPortReconfiguredEvent", "DvsPortReconfiguredEvent", "vim.event.DvsEvent", "vim.version.version5", [("portKey", "string[]", "vim.version.version5", 0)]) +CreateDataType("vim.event.DvsPortDeletedEvent", "DvsPortDeletedEvent", "vim.event.DvsEvent", "vim.version.version5", [("portKey", "string[]", "vim.version.version5", 0)]) +CreateDataType("vim.event.DvsPortConnectedEvent", "DvsPortConnectedEvent", "vim.event.DvsEvent", "vim.version.version5", [("portKey", "string", "vim.version.version5", 0), ("connectee", "vim.dvs.PortConnectee", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.event.DvsPortDisconnectedEvent", "DvsPortDisconnectedEvent", "vim.event.DvsEvent", "vim.version.version5", [("portKey", "string", "vim.version.version5", 0), ("connectee", "vim.dvs.PortConnectee", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.event.DvsPortVendorSpecificStateChangeEvent", "DvsPortVendorSpecificStateChangeEvent", "vim.event.DvsEvent", "vim.version.version8", [("portKey", "string", "vim.version.version8", 0)]) +CreateDataType("vim.event.DvsPortRuntimeChangeEvent", "DvsPortRuntimeChangeEvent", "vim.event.DvsEvent", "vim.version.version8", [("portKey", "string", "vim.version.version8", 0), ("runtimeInfo", "vim.dvs.DistributedVirtualPort.RuntimeInfo", "vim.version.version8", 0)]) +CreateDataType("vim.event.DvsPortLinkUpEvent", "DvsPortLinkUpEvent", "vim.event.DvsEvent", "vim.version.version5", [("portKey", "string", "vim.version.version5", 0), ("runtimeInfo", "vim.dvs.DistributedVirtualPort.RuntimeInfo", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.event.DvsPortLinkDownEvent", "DvsPortLinkDownEvent", "vim.event.DvsEvent", "vim.version.version5", [("portKey", "string", "vim.version.version5", 0), ("runtimeInfo", "vim.dvs.DistributedVirtualPort.RuntimeInfo", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.event.DvsPortJoinPortgroupEvent", "DvsPortJoinPortgroupEvent", "vim.event.DvsEvent", "vim.version.version5", [("portKey", "string", "vim.version.version5", 0), ("portgroupKey", "string", "vim.version.version5", 0), ("portgroupName", "string", "vim.version.version5", 0)]) +CreateDataType("vim.event.DvsPortLeavePortgroupEvent", "DvsPortLeavePortgroupEvent", "vim.event.DvsEvent", "vim.version.version5", [("portKey", "string", "vim.version.version5", 0), ("portgroupKey", "string", "vim.version.version5", 0), ("portgroupName", "string", "vim.version.version5", 0)]) +CreateDataType("vim.event.DvsPortBlockedEvent", "DvsPortBlockedEvent", "vim.event.DvsEvent", "vim.version.version5", [("portKey", "string", "vim.version.version5", 0), ("statusDetail", "string", "vim.version.version6", F_OPTIONAL), ("runtimeInfo", "vim.dvs.DistributedVirtualPort.RuntimeInfo", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.event.DvsPortUnblockedEvent", "DvsPortUnblockedEvent", "vim.event.DvsEvent", "vim.version.version5", [("portKey", "string", "vim.version.version5", 0), ("runtimeInfo", "vim.dvs.DistributedVirtualPort.RuntimeInfo", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.event.DvsPortEnteredPassthruEvent", "DvsPortEnteredPassthruEvent", "vim.event.DvsEvent", "vim.version.version6", [("portKey", "string", "vim.version.version6", 0), ("runtimeInfo", "vim.dvs.DistributedVirtualPort.RuntimeInfo", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.event.DvsPortExitedPassthruEvent", "DvsPortExitedPassthruEvent", "vim.event.DvsEvent", "vim.version.version6", [("portKey", "string", "vim.version.version6", 0), ("runtimeInfo", "vim.dvs.DistributedVirtualPort.RuntimeInfo", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.event.DvsDestroyedEvent", "DvsDestroyedEvent", "vim.event.DvsEvent", "vim.version.version5", None) +CreateDataType("vim.event.DvsMergedEvent", "DvsMergedEvent", "vim.event.DvsEvent", "vim.version.version5", [("sourceDvs", "vim.event.DvsEventArgument", "vim.version.version5", 0), ("destinationDvs", "vim.event.DvsEventArgument", "vim.version.version5", 0)]) +CreateDataType("vim.event.HostLocalPortCreatedEvent", "HostLocalPortCreatedEvent", "vim.event.DvsEvent", "vim.version.version8", [("hostLocalPort", "vim.dvs.DistributedVirtualPort.HostLocalPortInfo", "vim.version.version8", 0)]) +CreateDataType("vim.event.RollbackEvent", "RollbackEvent", "vim.event.DvsEvent", "vim.version.version8", [("hostName", "string", "vim.version.version8", 0), ("methodName", "string", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.event.RecoveryEvent", "RecoveryEvent", "vim.event.DvsEvent", "vim.version.version8", [("hostName", "string", "vim.version.version8", 0), ("portKey", "string", "vim.version.version8", 0), ("dvsUuid", "string", "vim.version.version8", F_OPTIONAL), ("vnic", "string", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.event.DvsImportEvent", "DvsImportEvent", "vim.event.DvsEvent", "vim.version.version8", [("importType", "string", "vim.version.version8", 0)]) +CreateDataType("vim.event.DvsRestoreEvent", "DvsRestoreEvent", "vim.event.DvsEvent", "vim.version.version8", None) +CreateDataType("vim.event.DVPortgroupEvent", "DVPortgroupEvent", "vim.event.Event", "vim.version.version5", None) +CreateDataType("vim.event.DVPortgroupCreatedEvent", "DVPortgroupCreatedEvent", "vim.event.DVPortgroupEvent", "vim.version.version5", None) +CreateDataType("vim.event.DVPortgroupRenamedEvent", "DVPortgroupRenamedEvent", "vim.event.DVPortgroupEvent", "vim.version.version5", [("oldName", "string", "vim.version.version5", 0), ("newName", "string", "vim.version.version5", 0)]) +CreateDataType("vim.event.DVPortgroupDestroyedEvent", "DVPortgroupDestroyedEvent", "vim.event.DVPortgroupEvent", "vim.version.version5", None) +CreateDataType("vim.event.DvpgImportEvent", "DvpgImportEvent", "vim.event.DVPortgroupEvent", "vim.version.version8", [("importType", "string", "vim.version.version8", 0)]) +CreateDataType("vim.event.DvpgRestoreEvent", "DvpgRestoreEvent", "vim.event.DVPortgroupEvent", "vim.version.version8", None) +CreateDataType("vim.event.DrsInvocationFailedEvent", "DrsInvocationFailedEvent", "vim.event.ClusterEvent", "vim.version.version5", None) +CreateDataType("vim.event.DrsRecoveredFromFailureEvent", "DrsRecoveredFromFailureEvent", "vim.event.ClusterEvent", "vim.version.version5", None) +CreateDataType("vim.event.VmReloadFromPathEvent", "VmReloadFromPathEvent", "vim.event.VmEvent", "vim.version.version6", [("configPath", "string", "vim.version.version6", 0)]) +CreateDataType("vim.event.VmReloadFromPathFailedEvent", "VmReloadFromPathFailedEvent", "vim.event.VmEvent", "vim.version.version6", [("configPath", "string", "vim.version.version6", 0)]) +CreateDataType("vim.event.VmRequirementsExceedCurrentEVCModeEvent", "VmRequirementsExceedCurrentEVCModeEvent", "vim.event.VmEvent", "vim.version.version8", None) +CreateDataType("vim.event.EventArgument", "EventArgument", "vmodl.DynamicData", "vim.version.version1", None) +CreateDataType("vim.event.RoleEventArgument", "RoleEventArgument", "vim.event.EventArgument", "vim.version.version1", [("roleId", "int", "vim.version.version1", 0), ("name", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.EntityEventArgument", "EntityEventArgument", "vim.event.EventArgument", "vim.version.version1", [("name", "string", "vim.version.version1", 0)]) +CreateDataType("vim.event.ManagedEntityEventArgument", "ManagedEntityEventArgument", "vim.event.EntityEventArgument", "vim.version.version1", [("entity", "vim.ManagedEntity", "vim.version.version1", 0)]) +CreateDataType("vim.event.FolderEventArgument", "FolderEventArgument", "vim.event.EntityEventArgument", "vim.version.version1", [("folder", "vim.Folder", "vim.version.version1", 0)]) +CreateDataType("vim.event.DatacenterEventArgument", "DatacenterEventArgument", "vim.event.EntityEventArgument", "vim.version.version1", [("datacenter", "vim.Datacenter", "vim.version.version1", 0)]) +CreateDataType("vim.event.ComputeResourceEventArgument", "ComputeResourceEventArgument", "vim.event.EntityEventArgument", "vim.version.version1", [("computeResource", "vim.ComputeResource", "vim.version.version1", 0)]) +CreateDataType("vim.event.ResourcePoolEventArgument", "ResourcePoolEventArgument", "vim.event.EntityEventArgument", "vim.version.version1", [("resourcePool", "vim.ResourcePool", "vim.version.version1", 0)]) +CreateDataType("vim.event.HostEventArgument", "HostEventArgument", "vim.event.EntityEventArgument", "vim.version.version1", [("host", "vim.HostSystem", "vim.version.version1", 0)]) +CreateDataType("vim.event.VmEventArgument", "VmEventArgument", "vim.event.EntityEventArgument", "vim.version.version1", [("vm", "vim.VirtualMachine", "vim.version.version1", 0)]) +CreateDataType("vim.event.DatastoreEventArgument", "DatastoreEventArgument", "vim.event.EntityEventArgument", "vim.version.version1", [("datastore", "vim.Datastore", "vim.version.version1", 0)]) +CreateDataType("vim.event.NetworkEventArgument", "NetworkEventArgument", "vim.event.EntityEventArgument", "vim.version.version5", [("network", "vim.Network", "vim.version.version5", 0)]) +CreateDataType("vim.event.AlarmEventArgument", "AlarmEventArgument", "vim.event.EntityEventArgument", "vim.version.version1", [("alarm", "vim.alarm.Alarm", "vim.version.version1", 0)]) +CreateDataType("vim.event.ScheduledTaskEventArgument", "ScheduledTaskEventArgument", "vim.event.EntityEventArgument", "vim.version.version1", [("scheduledTask", "vim.scheduler.ScheduledTask", "vim.version.version1", 0)]) +CreateDataType("vim.event.ProfileEventArgument", "ProfileEventArgument", "vim.event.EventArgument", "vim.version.version5", [("profile", "vim.profile.Profile", "vim.version.version5", 0), ("name", "string", "vim.version.version5", 0)]) +CreateDataType("vim.event.DvsEventArgument", "DvsEventArgument", "vim.event.EntityEventArgument", "vim.version.version5", [("dvs", "vim.DistributedVirtualSwitch", "vim.version.version5", 0)]) +CreateDataType("vim.event.EventDescription", "EventDescription", "vmodl.DynamicData", "vim.version.version1", [("category", "vim.ElementDescription[]", "vim.version.version1", 0), ("eventInfo", "vim.event.EventDescription.EventDetail[]", "vim.version.version1", 0), ("enumeratedTypes", "vim.EnumDescription[]", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.event.EventDescription.EventCategory", "EventCategory", "vim.version.version1", ["info", "warning", "error", "user"]) +CreateDataType("vim.event.EventDescription.EventArgDesc", "EventArgDesc", "vmodl.DynamicData", "vim.version.version5", [("name", "string", "vim.version.version5", 0), ("type", "string", "vim.version.version5", 0), ("description", "vim.ElementDescription", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.event.EventDescription.EventDetail", "EventDescriptionEventDetail", "vmodl.DynamicData", "vim.version.version1", [("key", "vmodl.TypeName", "vim.version.version1", 0), ("description", "string", "vim.version.version5", F_OPTIONAL), ("category", "string", "vim.version.version1", 0), ("formatOnDatacenter", "string", "vim.version.version1", 0), ("formatOnComputeResource", "string", "vim.version.version1", 0), ("formatOnHost", "string", "vim.version.version1", 0), ("formatOnVm", "string", "vim.version.version1", 0), ("fullFormat", "string", "vim.version.version1", 0), ("longDescription", "string", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.event.EventEx", "EventEx", "vim.event.Event", "vim.version.version5", [("eventTypeId", "string", "vim.version.version5", 0), ("severity", "string", "vim.version.version5", F_OPTIONAL), ("message", "string", "vim.version.version5", F_OPTIONAL), ("arguments", "vmodl.KeyAnyValue[]", "vim.version.version5", F_OPTIONAL), ("objectId", "string", "vim.version.version5", F_OPTIONAL), ("objectType", "vmodl.TypeName", "vim.version.version5", F_OPTIONAL), ("objectName", "string", "vim.version.version6", F_OPTIONAL), ("fault", "vmodl.MethodFault", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.event.EventFilterSpec", "EventFilterSpec", "vmodl.DynamicData", "vim.version.version1", [("entity", "vim.event.EventFilterSpec.ByEntity", "vim.version.version1", F_OPTIONAL), ("time", "vim.event.EventFilterSpec.ByTime", "vim.version.version1", F_OPTIONAL), ("userName", "vim.event.EventFilterSpec.ByUsername", "vim.version.version1", F_OPTIONAL), ("eventChainId", "int", "vim.version.version1", F_OPTIONAL), ("alarm", "vim.alarm.Alarm", "vim.version.version1", F_OPTIONAL), ("scheduledTask", "vim.scheduler.ScheduledTask", "vim.version.version1", F_OPTIONAL), ("disableFullMessage", "boolean", "vim.version.version1", F_OPTIONAL), ("category", "string[]", "vim.version.version1", F_OPTIONAL), ("type", "vmodl.TypeName[]", "vim.version.version1", F_OPTIONAL), ("tag", "string[]", "vim.version.version5", F_OPTIONAL), ("eventTypeId", "string[]", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.event.EventFilterSpec.RecursionOption", "EventFilterSpecRecursionOption", "vim.version.version1", ["self", "children", "all"]) +CreateDataType("vim.event.EventFilterSpec.ByEntity", "EventFilterSpecByEntity", "vmodl.DynamicData", "vim.version.version1", [("entity", "vim.ManagedEntity", "vim.version.version1", 0), ("recursion", "vim.event.EventFilterSpec.RecursionOption", "vim.version.version1", 0)]) +CreateDataType("vim.event.EventFilterSpec.ByTime", "EventFilterSpecByTime", "vmodl.DynamicData", "vim.version.version1", [("beginTime", "vmodl.DateTime", "vim.version.version1", F_OPTIONAL), ("endTime", "vmodl.DateTime", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.event.EventFilterSpec.ByUsername", "EventFilterSpecByUsername", "vmodl.DynamicData", "vim.version.version1", [("systemUser", "boolean", "vim.version.version1", 0), ("userList", "string[]", "vim.version.version1", F_OPTIONAL)]) +CreateManagedType("vim.event.EventHistoryCollector", "EventHistoryCollector", "vim.HistoryCollector", "vim.version.version1", [("latestPage", "vim.event.Event[]", "vim.version.version1", F_OPTIONAL, None)], [("readNext", "ReadNextEvents", "vim.version.version1", (("maxCount", "int", "vim.version.version1", 0, None),), (F_OPTIONAL, "vim.event.Event[]", "vim.event.Event[]"), None, None), ("readPrev", "ReadPreviousEvents", "vim.version.version1", (("maxCount", "int", "vim.version.version1", 0, None),), (F_OPTIONAL, "vim.event.Event[]", "vim.event.Event[]"), None, None)]) +CreateManagedType("vim.event.EventManager", "EventManager", "vmodl.ManagedObject", "vim.version.version1", [("description", "vim.event.EventDescription", "vim.version.version1", 0, "System.View"), ("latestEvent", "vim.event.Event", "vim.version.version1", F_OPTIONAL, "System.View"), ("maxCollector", "int", "vim.version.version1", 0, "System.View")], [("retrieveArgumentDescription", "RetrieveArgumentDescription", "vim.version.version5", (("eventTypeId", "string", "vim.version.version5", 0, None),), (F_OPTIONAL, "vim.event.EventDescription.EventArgDesc[]", "vim.event.EventDescription.EventArgDesc[]"), "System.View", None), ("createCollector", "CreateCollectorForEvents", "vim.version.version1", (("filter", "vim.event.EventFilterSpec", "vim.version.version1", 0, None),), (0, "vim.event.EventHistoryCollector", "vim.event.EventHistoryCollector"), "System.View", ["vim.fault.InvalidState", ]), ("logUserEvent", "LogUserEvent", "vim.version.version1", (("entity", "vim.ManagedEntity", "vim.version.version1", 0, "Global.LogEvent"),("msg", "string", "vim.version.version1", 0, None),), (0, "void", "void"), None, None), ("QueryEvent", "QueryEvents", "vim.version.version1", (("filter", "vim.event.EventFilterSpec", "vim.version.version1", 0, None),), (F_OPTIONAL, "vim.event.Event[]", "vim.event.Event[]"), "System.View", None), ("postEvent", "PostEvent", "vim.version.version2", (("eventToPost", "vim.event.Event", "vim.version.version2", 0, None),("taskInfo", "vim.TaskInfo", "vim.version.version2", F_OPTIONAL, None),), (0, "void", "void"), "Global.LogEvent", ["vim.fault.InvalidEvent", ])]) +CreateDataType("vim.ext.ExtendedProductInfo", "ExtExtendedProductInfo", "vmodl.DynamicData", "vim.version.version7", [("companyUrl", "string", "vim.version.version7", F_OPTIONAL), ("productUrl", "string", "vim.version.version7", F_OPTIONAL), ("managementUrl", "string", "vim.version.version7", F_OPTIONAL), ("self", "vim.ManagedEntity", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.ext.ManagedByInfo", "ManagedByInfo", "vmodl.DynamicData", "vim.version.version7", [("extensionKey", "string", "vim.version.version7", 0), ("type", "string", "vim.version.version7", 0)]) +CreateDataType("vim.ext.ManagedEntityInfo", "ExtManagedEntityInfo", "vmodl.DynamicData", "vim.version.version7", [("type", "string", "vim.version.version7", 0), ("smallIconUrl", "string", "vim.version.version7", F_OPTIONAL), ("iconUrl", "string", "vim.version.version8", F_OPTIONAL), ("description", "string", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.ext.SolutionManagerInfo", "ExtSolutionManagerInfo", "vmodl.DynamicData", "vim.version.version7", [("tab", "vim.ext.SolutionManagerInfo.TabInfo[]", "vim.version.version7", F_OPTIONAL), ("smallIconUrl", "string", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.ext.SolutionManagerInfo.TabInfo", "ExtSolutionManagerInfoTabInfo", "vmodl.DynamicData", "vim.version.version7", [("label", "string", "vim.version.version7", 0), ("url", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.CannotDisableDrsOnClustersWithVApps", "CannotDisableDrsOnClustersWithVApps", "vmodl.RuntimeFault", "vim.version.version6", None) +CreateDataType("vim.fault.ConflictingDatastoreFound", "ConflictingDatastoreFound", "vmodl.RuntimeFault", "vim.version.version8", [("name", "string", "vim.version.version8", 0), ("url", "string", "vim.version.version8", 0)]) +CreateDataType("vim.fault.DatabaseError", "DatabaseError", "vmodl.RuntimeFault", "vim.version.version1", None) +CreateDataType("vim.fault.DisallowedChangeByService", "DisallowedChangeByService", "vmodl.RuntimeFault", "vim.version.version7", [("serviceName", "string", "vim.version.version7", 0), ("disallowedChange", "string", "vim.version.version7", F_OPTIONAL)]) +CreateEnumType("vim.fault.DisallowedChangeByService.DisallowedChange", "DisallowedChangeByServiceDisallowedChange", "vim.version.version7", ["hotExtendDisk"]) +CreateDataType("vim.fault.DisallowedOperationOnFailoverHost", "DisallowedOperationOnFailoverHost", "vmodl.RuntimeFault", "vim.version.version5", [("host", "vim.HostSystem", "vim.version.version5", 0), ("hostname", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.ExpiredFeatureLicense", "ExpiredFeatureLicense", "vmodl.fault.NotEnoughLicenses", "vim.version.version2", [("feature", "string", "vim.version.version2", 0), ("count", "int", "vim.version.version2", 0), ("expirationDate", "vmodl.DateTime", "vim.version.version2", 0)]) +CreateDataType("vim.fault.FailToLockFaultToleranceVMs", "FailToLockFaultToleranceVMs", "vmodl.RuntimeFault", "vim.version.version6", [("vmName", "string", "vim.version.version6", 0), ("vm", "vim.VirtualMachine", "vim.version.version6", 0), ("alreadyLockedVm", "vim.VirtualMachine", "vim.version.version6", 0)]) +CreateDataType("vim.fault.HostAccessRestrictedToManagementServer", "HostAccessRestrictedToManagementServer", "vmodl.fault.NotSupported", "vim.version.version7", [("managementServer", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.HostInventoryFull", "HostInventoryFull", "vmodl.fault.NotEnoughLicenses", "vim.version.version2", [("capacity", "int", "vim.version.version2", 0)]) +CreateDataType("vim.fault.InUseFeatureManipulationDisallowed", "InUseFeatureManipulationDisallowed", "vmodl.fault.NotEnoughLicenses", "vim.version.version5", None) +CreateDataType("vim.fault.IncompatibleSetting", "IncompatibleSetting", "vmodl.fault.InvalidArgument", "vim.version.version1", [("conflictingProperty", "vmodl.PropertyPath", "vim.version.version1", 0)]) +CreateDataType("vim.fault.IncorrectHostInformation", "IncorrectHostInformation", "vmodl.fault.NotEnoughLicenses", "vim.version.version2", None) +CreateDataType("vim.fault.InvalidDasConfigArgument", "InvalidDasConfigArgument", "vmodl.fault.InvalidArgument", "vim.version.version8", [("entry", "string", "vim.version.version8", F_OPTIONAL), ("clusterName", "string", "vim.version.version8", F_OPTIONAL)]) +CreateEnumType("vim.fault.InvalidDasConfigArgument.EntryForInvalidArgument", "InvalidDasConfigArgumentEntryForInvalidArgument", "vim.version.version8", ["admissionControl", "userHeartbeatDs", "vmConfig"]) +CreateDataType("vim.fault.InvalidDasRestartPriorityForFtVm", "InvalidDasRestartPriorityForFtVm", "vmodl.fault.InvalidArgument", "vim.version.version6", [("vm", "vim.VirtualMachine", "vim.version.version6", 0), ("vmName", "string", "vim.version.version6", 0)]) +CreateDataType("vim.fault.InvalidDrsBehaviorForFtVm", "InvalidDrsBehaviorForFtVm", "vmodl.fault.InvalidArgument", "vim.version.version5", [("vm", "vim.VirtualMachine", "vim.version.version5", 0), ("vmName", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.InvalidEditionLicense", "InvalidEditionLicense", "vmodl.fault.NotEnoughLicenses", "vim.version.version2", [("feature", "string", "vim.version.version2", 0)]) +CreateDataType("vim.fault.InvalidIndexArgument", "InvalidIndexArgument", "vmodl.fault.InvalidArgument", "vim.version.version5", [("key", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.InvalidProfileReferenceHost", "InvalidProfileReferenceHost", "vmodl.RuntimeFault", "vim.version.version7", [("reason", "string", "vim.version.version7", F_OPTIONAL), ("host", "vim.HostSystem", "vim.version.version7", F_OPTIONAL), ("profile", "vim.profile.Profile", "vim.version.version7", F_OPTIONAL)]) +CreateEnumType("vim.fault.InvalidProfileReferenceHost.Reason", "InvalidProfileReferenceHostReason", "vim.version.version7", ["incompatibleVersion", "missingReferenceHost"]) +CreateDataType("vim.fault.InventoryHasStandardAloneHosts", "InventoryHasStandardAloneHosts", "vmodl.fault.NotEnoughLicenses", "vim.version.version5", [("hosts", "string[]", "vim.version.version5", 0)]) +CreateDataType("vim.fault.LicenseAssignmentFailed", "LicenseAssignmentFailed", "vmodl.RuntimeFault", "vim.version.version5", [("reason", "string", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.fault.LicenseAssignmentFailed.Reason", "LicenseAssignmentFailedReason", "vim.version.version5", ["keyEntityMismatch", "downgradeDisallowed", "inventoryNotManageableByVirtualCenter", "hostsUnmanageableByVirtualCenterWithoutLicenseServer"]) +CreateDataType("vim.fault.LicenseDowngradeDisallowed", "LicenseDowngradeDisallowed", "vmodl.fault.NotEnoughLicenses", "vim.version.version5", [("edition", "string", "vim.version.version5", 0), ("entityId", "string", "vim.version.version5", 0), ("features", "vmodl.KeyAnyValue[]", "vim.version.version5", 0)]) +CreateDataType("vim.fault.LicenseExpired", "LicenseExpired", "vmodl.fault.NotEnoughLicenses", "vim.version.version5", [("licenseKey", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.LicenseKeyEntityMismatch", "LicenseKeyEntityMismatch", "vmodl.fault.NotEnoughLicenses", "vim.version.version5", None) +CreateDataType("vim.fault.LicenseRestricted", "LicenseRestricted", "vmodl.fault.NotEnoughLicenses", "vim.version.version2", None) +CreateDataType("vim.fault.LicenseSourceUnavailable", "LicenseSourceUnavailable", "vmodl.fault.NotEnoughLicenses", "vim.version.version2", [("licenseSource", "vim.LicenseManager.LicenseSource", "vim.version.version2", 0)]) +CreateDataType("vim.fault.MethodAlreadyDisabledFault", "MethodAlreadyDisabledFault", "vmodl.RuntimeFault", "vim.version.version6", [("sourceId", "string", "vim.version.version6", 0)]) +CreateDataType("vim.fault.MethodDisabled", "MethodDisabled", "vmodl.RuntimeFault", "vim.version.version2", [("source", "string", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.fault.NoLicenseServerConfigured", "NoLicenseServerConfigured", "vmodl.fault.NotEnoughLicenses", "vim.version.version5", None) +CreateDataType("vim.fault.NoPermission", "NoPermission", "vmodl.fault.SecurityError", "vim.version.version1", [("object", "vmodl.ManagedObject", "vim.version.version1", 0), ("privilegeId", "string", "vim.version.version1", 0)]) +CreateDataType("vim.fault.NotAuthenticated", "NotAuthenticated", "vim.fault.NoPermission", "vim.version.version2", None) +CreateDataType("vim.fault.OperationDisallowedOnHost", "OperationDisallowedOnHost", "vmodl.RuntimeFault", "vim.version.version7", None) +CreateDataType("vim.fault.RestrictedVersion", "RestrictedVersion", "vmodl.fault.SecurityError", "vim.version.version2", None) +CreateDataType("vim.fault.ThirdPartyLicenseAssignmentFailed", "ThirdPartyLicenseAssignmentFailed", "vmodl.RuntimeFault", "vim.version.version7", [("host", "vim.HostSystem", "vim.version.version7", 0), ("module", "string", "vim.version.version7", 0), ("reason", "string", "vim.version.version7", F_OPTIONAL)]) +CreateEnumType("vim.fault.ThirdPartyLicenseAssignmentFailed.Reason", "ThirdPartyLicenseAssignmentFailedReason", "vim.version.version7", ["licenseAssignmentFailed", "moduleNotInstalled"]) +CreateDataType("vim.fault.VAppOperationInProgress", "VAppOperationInProgress", "vmodl.RuntimeFault", "vim.version.version7", None) +CreateDataType("vim.fault.VimFault", "VimFault", "vmodl.MethodFault", "vim.version.version1", None) +CreateDataType("vim.fault.VmConfigFault", "VmConfigFault", "vim.fault.VimFault", "vim.version.version1", None) +CreateDataType("vim.fault.VmConfigIncompatibleForFaultTolerance", "VmConfigIncompatibleForFaultTolerance", "vim.fault.VmConfigFault", "vim.version.version5", [("fault", "vmodl.MethodFault", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.fault.VmConfigIncompatibleForRecordReplay", "VmConfigIncompatibleForRecordReplay", "vim.fault.VmConfigFault", "vim.version.version5", [("fault", "vmodl.MethodFault", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.fault.VmFaultToleranceIssue", "VmFaultToleranceIssue", "vim.fault.VimFault", "vim.version.version5", None) +CreateDataType("vim.fault.VmFaultToleranceOpIssuesList", "VmFaultToleranceOpIssuesList", "vim.fault.VmFaultToleranceIssue", "vim.version.version5", [("errors", "vmodl.MethodFault[]", "vim.version.version5", F_OPTIONAL), ("warnings", "vmodl.MethodFault[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.fault.VmHostAffinityRuleViolation", "VmHostAffinityRuleViolation", "vim.fault.VmConfigFault", "vim.version.version6", [("vmName", "string", "vim.version.version6", 0), ("hostName", "string", "vim.version.version6", 0)]) +CreateDataType("vim.fault.VmLimitLicense", "VmLimitLicense", "vmodl.fault.NotEnoughLicenses", "vim.version.version1", [("limit", "int", "vim.version.version1", 0)]) +CreateDataType("vim.fault.VmMetadataManagerFault", "VmMetadataManagerFault", "vim.fault.VimFault", "vim.version.version9", None) +CreateDataType("vim.fault.VmMonitorIncompatibleForFaultTolerance", "VmMonitorIncompatibleForFaultTolerance", "vim.fault.VimFault", "vim.version.version6", None) +CreateDataType("vim.fault.VmToolsUpgradeFault", "VmToolsUpgradeFault", "vim.fault.VimFault", "vim.version.version1", None) +CreateDataType("vim.fault.VmValidateMaxDevice", "VmValidateMaxDevice", "vim.fault.VimFault", "vim.version.version5", [("device", "string", "vim.version.version5", 0), ("max", "int", "vim.version.version5", 0), ("count", "int", "vim.version.version5", 0)]) +CreateDataType("vim.fault.VramLimitLicense", "VramLimitLicense", "vmodl.fault.NotEnoughLicenses", "vim.version.version7", [("limit", "int", "vim.version.version7", 0)]) +CreateDataType("vim.fault.VsanFault", "VsanFault", "vim.fault.VimFault", "vim.version.version9", None) +CreateDataType("vim.fault.WipeDiskFault", "WipeDiskFault", "vim.fault.VimFault", "vim.version.version8", None) +CreateDataType("vim.host.ActiveDirectorySpec", "HostActiveDirectory", "vmodl.DynamicData", "vim.version.version6", [("changeOperation", "string", "vim.version.version6", 0), ("spec", "vim.host.ActiveDirectorySpec.Specification", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.host.ActiveDirectorySpec.Specification", "HostActiveDirectorySpec", "vmodl.DynamicData", "vim.version.version6", [("domainName", "string", "vim.version.version6", F_OPTIONAL), ("userName", "string", "vim.version.version6", F_OPTIONAL), ("password", "string", "vim.version.version6", F_OPTIONAL), ("camServer", "string", "vim.version.version7", F_OPTIONAL), ("thumbprint", "string", "vim.version.version7", F_OPTIONAL)]) +CreateManagedType("vim.host.AuthenticationManager", "HostAuthenticationManager", "vmodl.ManagedObject", "vim.version.version6", [("info", "vim.host.AuthenticationManagerInfo", "vim.version.version6", 0, None), ("supportedStore", "vim.host.AuthenticationStore[]", "vim.version.version6", 0, None)], None) +CreateDataType("vim.host.AuthenticationManagerInfo", "HostAuthenticationManagerInfo", "vmodl.DynamicData", "vim.version.version6", [("authConfig", "vim.host.AuthenticationStoreInfo[]", "vim.version.version6", 0)]) +CreateManagedType("vim.host.AuthenticationStore", "HostAuthenticationStore", "vmodl.ManagedObject", "vim.version.version6", [("info", "vim.host.AuthenticationStoreInfo", "vim.version.version6", 0, None)], None) +CreateDataType("vim.host.AuthenticationStoreInfo", "HostAuthenticationStoreInfo", "vmodl.DynamicData", "vim.version.version6", [("enabled", "boolean", "vim.version.version6", 0)]) +CreateManagedType("vim.host.AutoStartManager", "HostAutoStartManager", "vmodl.ManagedObject", "vim.version.version1", [("config", "vim.host.AutoStartManager.Config", "vim.version.version1", 0, None)], [("reconfigure", "ReconfigureAutostart", "vim.version.version1", (("spec", "vim.host.AutoStartManager.Config", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.AutoStart", None), ("autoPowerOn", "AutoStartPowerOn", "vim.version.version1", (), (0, "void", "void"), "Host.Config.AutoStart", None), ("autoPowerOff", "AutoStartPowerOff", "vim.version.version1", (), (0, "void", "void"), "Host.Config.AutoStart", None)]) +CreateEnumType("vim.host.AutoStartManager.Action", "AutoStartAction", "vim.version.version1", ["none", "systemDefault", "powerOn", "powerOff", "guestShutdown", "suspend"]) +CreateDataType("vim.host.AutoStartManager.SystemDefaults", "AutoStartDefaults", "vmodl.DynamicData", "vim.version.version1", [("enabled", "boolean", "vim.version.version1", F_OPTIONAL), ("startDelay", "int", "vim.version.version1", F_OPTIONAL), ("stopDelay", "int", "vim.version.version1", F_OPTIONAL), ("waitForHeartbeat", "boolean", "vim.version.version1", F_OPTIONAL), ("stopAction", "string", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.AutoStartManager.AutoPowerInfo", "AutoStartPowerInfo", "vmodl.DynamicData", "vim.version.version1", [("key", "vim.VirtualMachine", "vim.version.version1", 0), ("startOrder", "int", "vim.version.version1", 0), ("startDelay", "int", "vim.version.version1", 0), ("waitForHeartbeat", "vim.host.AutoStartManager.AutoPowerInfo.WaitHeartbeatSetting", "vim.version.version1", 0), ("startAction", "string", "vim.version.version1", 0), ("stopDelay", "int", "vim.version.version1", 0), ("stopAction", "string", "vim.version.version1", 0)]) +CreateEnumType("vim.host.AutoStartManager.AutoPowerInfo.WaitHeartbeatSetting", "AutoStartWaitHeartbeatSetting", "vim.version.version1", ["yes", "no", "systemDefault"]) +CreateDataType("vim.host.AutoStartManager.Config", "HostAutoStartManagerConfig", "vmodl.DynamicData", "vim.version.version1", [("defaults", "vim.host.AutoStartManager.SystemDefaults", "vim.version.version1", F_OPTIONAL), ("powerInfo", "vim.host.AutoStartManager.AutoPowerInfo[]", "vim.version.version1", F_OPTIONAL)]) +CreateManagedType("vim.host.BootDeviceSystem", "HostBootDeviceSystem", "vmodl.ManagedObject", "vim.version.version2", None, [("queryBootDevices", "QueryBootDevices", "vim.version.version2", (), (F_OPTIONAL, "vim.host.BootDeviceInfo", "vim.host.BootDeviceInfo"), "System.Read", None), ("updateBootDevice", "UpdateBootDevice", "vim.version.version2", (("key", "string", "vim.version.version2", 0, None),), (0, "void", "void"), "Host.Config.Maintenance", None)]) +CreateDataType("vim.host.BootDeviceSystem.BootDevice", "HostBootDevice", "vmodl.DynamicData", "vim.version.version2", [("key", "string", "vim.version.version2", 0), ("description", "string", "vim.version.version2", 0)]) +CreateManagedType("vim.host.CacheConfigurationManager", "HostCacheConfigurationManager", "vmodl.ManagedObject", "vim.version.version7", [("cacheConfigurationInfo", "vim.host.CacheConfigurationManager.CacheConfigurationInfo[]", "vim.version.version7", F_OPTIONAL, "Host.Config.AdvancedConfig")], [("configureCache", "ConfigureHostCache_Task", "vim.version.version7", (("spec", "vim.host.CacheConfigurationManager.CacheConfigurationSpec", "vim.version.version7", 0, None),), (0, "vim.Task", "void"), "Host.Config.AdvancedConfig", None)]) +CreateDataType("vim.host.CacheConfigurationManager.CacheConfigurationSpec", "HostCacheConfigurationSpec", "vmodl.DynamicData", "vim.version.version7", [("datastore", "vim.Datastore", "vim.version.version7", 0), ("swapSize", "long", "vim.version.version7", 0)]) +CreateDataType("vim.host.CacheConfigurationManager.CacheConfigurationInfo", "HostCacheConfigurationInfo", "vmodl.DynamicData", "vim.version.version7", [("key", "vim.Datastore", "vim.version.version7", 0), ("swapSize", "long", "vim.version.version7", 0)]) +CreateDataType("vim.host.Capability", "HostCapability", "vmodl.DynamicData", "vim.version.version1", [("recursiveResourcePoolsSupported", "boolean", "vim.version.version1", 0), ("cpuMemoryResourceConfigurationSupported", "boolean", "vim.version.version2", 0), ("rebootSupported", "boolean", "vim.version.version1", 0), ("shutdownSupported", "boolean", "vim.version.version1", 0), ("vmotionSupported", "boolean", "vim.version.version1", 0), ("standbySupported", "boolean", "vim.version.version2", 0), ("ipmiSupported", "boolean", "vim.version.version5", F_OPTIONAL), ("maxSupportedVMs", "int", "vim.version.version1", F_OPTIONAL), ("maxRunningVMs", "int", "vim.version.version1", F_OPTIONAL), ("maxSupportedVcpus", "int", "vim.version.version1", F_OPTIONAL), ("maxRegisteredVMs", "int", "vim.version.version8", F_OPTIONAL), ("datastorePrincipalSupported", "boolean", "vim.version.version1", 0), ("sanSupported", "boolean", "vim.version.version1", 0), ("nfsSupported", "boolean", "vim.version.version1", 0), ("iscsiSupported", "boolean", "vim.version.version1", 0), ("vlanTaggingSupported", "boolean", "vim.version.version1", 0), ("nicTeamingSupported", "boolean", "vim.version.version1", 0), ("highGuestMemSupported", "boolean", "vim.version.version1", 0), ("maintenanceModeSupported", "boolean", "vim.version.version1", 0), ("suspendedRelocateSupported", "boolean", "vim.version.version1", 0), ("restrictedSnapshotRelocateSupported", "boolean", "vim.version.version2", 0), ("perVmSwapFiles", "boolean", "vim.version.version2", 0), ("localSwapDatastoreSupported", "boolean", "vim.version.version2", 0), ("unsharedSwapVMotionSupported", "boolean", "vim.version.version2", 0), ("backgroundSnapshotsSupported", "boolean", "vim.version.version2", 0), ("preAssignedPCIUnitNumbersSupported", "boolean", "vim.version.version2", 0), ("screenshotSupported", "boolean", "vim.version.version2", 0), ("scaledScreenshotSupported", "boolean", "vim.version.version2", 0), ("storageVMotionSupported", "boolean", "vim.version.version5", 0), ("vmotionWithStorageVMotionSupported", "boolean", "vim.version.version5", 0), ("vmotionAcrossNetworkSupported", "boolean", "vim.version.version9", F_OPTIONAL), ("hbrNicSelectionSupported", "boolean", "vim.version.version8", 0), ("recordReplaySupported", "boolean", "vim.version.version5", 0), ("ftSupported", "boolean", "vim.version.version5", 0), ("replayUnsupportedReason", "string", "vim.version.version5", F_OPTIONAL), ("replayCompatibilityIssues", "string[]", "vim.version.version6", F_OPTIONAL), ("ftCompatibilityIssues", "string[]", "vim.version.version6", F_OPTIONAL), ("loginBySSLThumbprintSupported", "boolean", "vim.version.version5", F_OPTIONAL), ("cloneFromSnapshotSupported", "boolean", "vim.version.version5", 0), ("deltaDiskBackingsSupported", "boolean", "vim.version.version5", 0), ("perVMNetworkTrafficShapingSupported", "boolean", "vim.version.version4", 0), ("tpmSupported", "boolean", "vim.version.version5", 0), ("supportedCpuFeature", "vim.host.CpuIdInfo[]", "vim.version.version5", F_OPTIONAL), ("virtualExecUsageSupported", "boolean", "vim.version.version5", 0), ("storageIORMSupported", "boolean", "vim.version.version6", 0), ("vmDirectPathGen2Supported", "boolean", "vim.version.version6", 0), ("vmDirectPathGen2UnsupportedReason", "string[]", "vim.version.version6", F_OPTIONAL), ("vmDirectPathGen2UnsupportedReasonExtended", "string", "vim.version.version6", F_OPTIONAL), ("supportedVmfsMajorVersion", "int[]", "vim.version.version7", F_OPTIONAL), ("vStorageCapable", "boolean", "vim.version.version6", 0), ("snapshotRelayoutSupported", "boolean", "vim.version.version7", 0), ("firewallIpRulesSupported", "boolean", "vim.version.version7", F_OPTIONAL), ("servicePackageInfoSupported", "boolean", "vim.version.version7", F_OPTIONAL), ("maxHostRunningVms", "int", "vim.version.version7", F_OPTIONAL), ("maxHostSupportedVcpus", "int", "vim.version.version7", F_OPTIONAL), ("vmfsDatastoreMountCapable", "boolean", "vim.version.version7", 0), ("eightPlusHostVmfsSharedAccessSupported", "boolean", "vim.version.version8", 0), ("nestedHVSupported", "boolean", "vim.version.version8", 0), ("vPMCSupported", "boolean", "vim.version.version8", 0), ("interVMCommunicationThroughVMCISupported", "boolean", "vim.version.version8", 0), ("scheduledHardwareUpgradeSupported", "boolean", "vim.version.version8", F_OPTIONAL), ("featureCapabilitiesSupported", "boolean", "vim.version.version8", 0), ("latencySensitivitySupported", "boolean", "vim.version.version8", 0), ("storagePolicySupported", "boolean", "vim.version.version9", F_OPTIONAL), ("accel3dSupported", "boolean", "vim.version.version8", 0), ("reliableMemoryAware", "boolean", "vim.version.version9", F_OPTIONAL), ("multipleNetworkStackInstanceSupported", "boolean", "vim.version.version9", F_OPTIONAL), ("vsanSupported", "boolean", "vim.version.version9", F_OPTIONAL), ("vFlashSupported", "boolean", "vim.version.version9", F_OPTIONAL)]) +CreateEnumType("vim.host.Capability.ReplayUnsupportedReason", "HostReplayUnsupportedReason", "vim.version.version5", ["incompatibleProduct", "incompatibleCpu", "hvDisabled", "cpuidLimitSet", "oldBIOS", "unknown"]) +CreateEnumType("vim.host.Capability.FtUnsupportedReason", "HostCapabilityFtUnsupportedReason", "vim.version.version6", ["vMotionNotLicensed", "missingVMotionNic", "missingFTLoggingNic", "ftNotLicensed", "haAgentIssue", "unsupportedProduct", "cpuHvUnsupported", "cpuHwmmuUnsupported", "cpuHvDisabled"]) +CreateEnumType("vim.host.Capability.VmDirectPathGen2UnsupportedReason", "HostCapabilityVmDirectPathGen2UnsupportedReason", "vim.version.version6", ["hostNptIncompatibleProduct", "hostNptIncompatibleHardware", "hostNptDisabled"]) +CreateDataType("vim.host.ConfigChange", "HostConfigChange", "vmodl.DynamicData", "vim.version.version1", None) +CreateEnumType("vim.host.ConfigChange.Mode", "HostConfigChangeMode", "vim.version.version1", ["modify", "replace"]) +CreateEnumType("vim.host.ConfigChange.Operation", "HostConfigChangeOperation", "vim.version.version1", ["add", "remove", "edit"]) +CreateDataType("vim.host.ConfigManager", "HostConfigManager", "vmodl.DynamicData", "vim.version.version1", [("cpuScheduler", "vim.host.CpuSchedulerSystem", "vim.version.version1", F_OPTIONAL), ("datastoreSystem", "vim.host.DatastoreSystem", "vim.version.version1", F_OPTIONAL), ("memoryManager", "vim.host.MemoryManagerSystem", "vim.version.version1", F_OPTIONAL), ("storageSystem", "vim.host.StorageSystem", "vim.version.version1", F_OPTIONAL), ("networkSystem", "vim.host.NetworkSystem", "vim.version.version1", F_OPTIONAL), ("vmotionSystem", "vim.host.VMotionSystem", "vim.version.version1", F_OPTIONAL), ("virtualNicManager", "vim.host.VirtualNicManager", "vim.version.version5", F_OPTIONAL), ("serviceSystem", "vim.host.ServiceSystem", "vim.version.version1", F_OPTIONAL), ("firewallSystem", "vim.host.FirewallSystem", "vim.version.version1", F_OPTIONAL), ("advancedOption", "vim.option.OptionManager", "vim.version.version1", F_OPTIONAL), ("diagnosticSystem", "vim.host.DiagnosticSystem", "vim.version.version1", F_OPTIONAL), ("autoStartManager", "vim.host.AutoStartManager", "vim.version.version1", F_OPTIONAL), ("snmpSystem", "vim.host.SnmpSystem", "vim.version.version1", F_OPTIONAL), ("dateTimeSystem", "vim.host.DateTimeSystem", "vim.version.version2", F_OPTIONAL), ("patchManager", "vim.host.PatchManager", "vim.version.version2", F_OPTIONAL), ("imageConfigManager", "vim.host.ImageConfigManager", "vim.version.version7", F_OPTIONAL), ("bootDeviceSystem", "vim.host.BootDeviceSystem", "vim.version.version2", F_OPTIONAL), ("firmwareSystem", "vim.host.FirmwareSystem", "vim.version.version2", F_OPTIONAL), ("healthStatusSystem", "vim.host.HealthStatusSystem", "vim.version.version2", F_OPTIONAL), ("pciPassthruSystem", "vim.host.PciPassthruSystem", "vim.version.version5", F_OPTIONAL), ("licenseManager", "vim.LicenseManager", "vim.version.version5", F_OPTIONAL), ("kernelModuleSystem", "vim.host.KernelModuleSystem", "vim.version.version5", F_OPTIONAL), ("authenticationManager", "vim.host.AuthenticationManager", "vim.version.version6", F_OPTIONAL), ("powerSystem", "vim.host.PowerSystem", "vim.version.version6", F_OPTIONAL), ("cacheConfigurationManager", "vim.host.CacheConfigurationManager", "vim.version.version7", F_OPTIONAL), ("esxAgentHostManager", "vim.host.EsxAgentHostManager", "vim.version.version7", F_OPTIONAL), ("iscsiManager", "vim.host.IscsiManager", "vim.version.version7", F_OPTIONAL), ("vFlashManager", "vim.host.VFlashManager", "vim.version.version9", F_OPTIONAL), ("vsanSystem", "vim.host.VsanSystem", "vim.version.version9", F_OPTIONAL), ("graphicsManager", "vim.host.GraphicsManager", "vim.version.version9", F_OPTIONAL), ("vsanInternalSystem", "vim.host.VsanInternalSystem", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.host.ConnectSpec", "HostConnectSpec", "vmodl.DynamicData", "vim.version.version1", [("hostName", "string", "vim.version.version1", F_OPTIONAL), ("port", "int", "vim.version.version1", F_OPTIONAL), ("sslThumbprint", "string", "vim.version.version2", F_OPTIONAL), ("userName", "string", "vim.version.version1", F_OPTIONAL), ("password", "string", "vim.version.version1", F_OPTIONAL), ("vmFolder", "vim.Folder", "vim.version.version1", F_OPTIONAL), ("force", "boolean", "vim.version.version1", 0), ("vimAccountName", "string", "vim.version.version1", F_OPTIONAL), ("vimAccountPassword", "string", "vim.version.version1", F_OPTIONAL), ("managementIp", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.CpuIdInfo", "HostCpuIdInfo", "vmodl.DynamicData", "vim.version.version1", [("level", "int", "vim.version.version1", 0), ("vendor", "string", "vim.version.version1", F_OPTIONAL), ("eax", "string", "vim.version.version1", F_OPTIONAL), ("ebx", "string", "vim.version.version1", F_OPTIONAL), ("ecx", "string", "vim.version.version1", F_OPTIONAL), ("edx", "string", "vim.version.version1", F_OPTIONAL)]) +CreateManagedType("vim.host.CpuSchedulerSystem", "HostCpuSchedulerSystem", "vim.ExtensibleManagedObject", "vim.version.version1", [("hyperthreadInfo", "vim.host.CpuSchedulerSystem.HyperThreadScheduleInfo", "vim.version.version1", F_OPTIONAL, None)], [("enableHyperThreading", "EnableHyperThreading", "vim.version.version1", (), (0, "void", "void"), "Host.Config.HyperThreading", None), ("disableHyperThreading", "DisableHyperThreading", "vim.version.version1", (), (0, "void", "void"), "Host.Config.HyperThreading", None)]) +CreateDataType("vim.host.CpuSchedulerSystem.HyperThreadScheduleInfo", "HostHyperThreadScheduleInfo", "vmodl.DynamicData", "vim.version.version1", [("available", "boolean", "vim.version.version1", 0), ("active", "boolean", "vim.version.version1", 0), ("config", "boolean", "vim.version.version1", 0)]) +CreateManagedType("vim.host.DatastoreBrowser", "HostDatastoreBrowser", "vmodl.ManagedObject", "vim.version.version1", [("datastore", "vim.Datastore[]", "vim.version.version1", F_OPTIONAL, "System.View"), ("supportedType", "vim.host.DatastoreBrowser.Query[]", "vim.version.version1", F_OPTIONAL, None)], [("search", "SearchDatastore_Task", "vim.version.version1", (("datastorePath", "string", "vim.version.version1", 0, None),("searchSpec", "vim.host.DatastoreBrowser.SearchSpec", "vim.version.version1", F_OPTIONAL, None),), (0, "vim.Task", "vim.host.DatastoreBrowser.SearchResults"), None, ["vim.fault.InvalidDatastore", "vim.fault.FileFault", ]), ("searchSubFolders", "SearchDatastoreSubFolders_Task", "vim.version.version1", (("datastorePath", "string", "vim.version.version1", 0, None),("searchSpec", "vim.host.DatastoreBrowser.SearchSpec", "vim.version.version1", F_OPTIONAL, None),), (F_OPTIONAL, "vim.Task", "vim.host.DatastoreBrowser.SearchResults[]"), None, ["vim.fault.InvalidDatastore", "vim.fault.FileFault", ]), ("deleteFile", "DeleteFile", "vim.version.version1", (("datastorePath", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "Datastore.DeleteFile", ["vim.fault.InvalidDatastore", "vim.fault.FileFault", ])]) +CreateDataType("vim.host.DatastoreBrowser.FileInfo", "FileInfo", "vmodl.DynamicData", "vim.version.version1", [("path", "string", "vim.version.version1", 0), ("fileSize", "long", "vim.version.version1", F_OPTIONAL), ("modification", "vmodl.DateTime", "vim.version.version1", F_OPTIONAL), ("owner", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.DatastoreBrowser.FileInfo.Details", "FileQueryFlags", "vmodl.DynamicData", "vim.version.version1", [("fileType", "boolean", "vim.version.version1", 0), ("fileSize", "boolean", "vim.version.version1", 0), ("modification", "boolean", "vim.version.version1", 0), ("fileOwner", "boolean", "vim.version.version5", 0)]) +CreateDataType("vim.host.DatastoreBrowser.Query", "FileQuery", "vmodl.DynamicData", "vim.version.version1", None) +CreateDataType("vim.host.DatastoreBrowser.VmConfigQuery", "VmConfigFileQuery", "vim.host.DatastoreBrowser.Query", "vim.version.version1", [("filter", "vim.host.DatastoreBrowser.VmConfigQuery.Filter", "vim.version.version1", F_OPTIONAL), ("details", "vim.host.DatastoreBrowser.VmConfigQuery.Details", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.DatastoreBrowser.VmConfigQuery.Filter", "VmConfigFileQueryFilter", "vmodl.DynamicData", "vim.version.version1", [("matchConfigVersion", "int[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.DatastoreBrowser.VmConfigQuery.Details", "VmConfigFileQueryFlags", "vmodl.DynamicData", "vim.version.version1", [("configVersion", "boolean", "vim.version.version1", 0)]) +CreateDataType("vim.host.DatastoreBrowser.TemplateVmConfigQuery", "TemplateConfigFileQuery", "vim.host.DatastoreBrowser.VmConfigQuery", "vim.version.version1", None) +CreateDataType("vim.host.DatastoreBrowser.VmDiskQuery", "VmDiskFileQuery", "vim.host.DatastoreBrowser.Query", "vim.version.version1", [("filter", "vim.host.DatastoreBrowser.VmDiskQuery.Filter", "vim.version.version1", F_OPTIONAL), ("details", "vim.host.DatastoreBrowser.VmDiskQuery.Details", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.DatastoreBrowser.VmDiskQuery.Filter", "VmDiskFileQueryFilter", "vmodl.DynamicData", "vim.version.version1", [("diskType", "vmodl.TypeName[]", "vim.version.version1", F_OPTIONAL), ("matchHardwareVersion", "int[]", "vim.version.version1", F_OPTIONAL), ("controllerType", "vmodl.TypeName[]", "vim.version.version2", F_OPTIONAL), ("thin", "boolean", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.DatastoreBrowser.VmDiskQuery.Details", "VmDiskFileQueryFlags", "vmodl.DynamicData", "vim.version.version1", [("diskType", "boolean", "vim.version.version1", 0), ("capacityKb", "boolean", "vim.version.version1", 0), ("hardwareVersion", "boolean", "vim.version.version1", 0), ("controllerType", "boolean", "vim.version.version2", F_OPTIONAL), ("diskExtents", "boolean", "vim.version.version2", F_OPTIONAL), ("thin", "boolean", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.DatastoreBrowser.FolderQuery", "FolderFileQuery", "vim.host.DatastoreBrowser.Query", "vim.version.version1", None) +CreateDataType("vim.host.DatastoreBrowser.VmSnapshotQuery", "VmSnapshotFileQuery", "vim.host.DatastoreBrowser.Query", "vim.version.version1", None) +CreateDataType("vim.host.DatastoreBrowser.IsoImageQuery", "IsoImageFileQuery", "vim.host.DatastoreBrowser.Query", "vim.version.version1", None) +CreateDataType("vim.host.DatastoreBrowser.FloppyImageQuery", "FloppyImageFileQuery", "vim.host.DatastoreBrowser.Query", "vim.version.version1", None) +CreateDataType("vim.host.DatastoreBrowser.VmNvramQuery", "VmNvramFileQuery", "vim.host.DatastoreBrowser.Query", "vim.version.version1", None) +CreateDataType("vim.host.DatastoreBrowser.VmLogQuery", "VmLogFileQuery", "vim.host.DatastoreBrowser.Query", "vim.version.version1", None) +CreateDataType("vim.host.DatastoreBrowser.VmConfigInfo", "VmConfigFileInfo", "vim.host.DatastoreBrowser.FileInfo", "vim.version.version1", [("configVersion", "int", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.DatastoreBrowser.TemplateVmConfigInfo", "TemplateConfigFileInfo", "vim.host.DatastoreBrowser.VmConfigInfo", "vim.version.version1", None) +CreateDataType("vim.host.DatastoreBrowser.VmDiskInfo", "VmDiskFileInfo", "vim.host.DatastoreBrowser.FileInfo", "vim.version.version1", [("diskType", "vmodl.TypeName", "vim.version.version1", F_OPTIONAL), ("capacityKb", "long", "vim.version.version1", F_OPTIONAL), ("hardwareVersion", "int", "vim.version.version1", F_OPTIONAL), ("controllerType", "vmodl.TypeName", "vim.version.version2", F_OPTIONAL), ("diskExtents", "string[]", "vim.version.version2", F_OPTIONAL), ("thin", "boolean", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.DatastoreBrowser.FolderInfo", "FolderFileInfo", "vim.host.DatastoreBrowser.FileInfo", "vim.version.version1", None) +CreateDataType("vim.host.DatastoreBrowser.VmSnapshotInfo", "VmSnapshotFileInfo", "vim.host.DatastoreBrowser.FileInfo", "vim.version.version1", None) +CreateDataType("vim.host.DatastoreBrowser.IsoImageInfo", "IsoImageFileInfo", "vim.host.DatastoreBrowser.FileInfo", "vim.version.version1", None) +CreateDataType("vim.host.DatastoreBrowser.FloppyImageInfo", "FloppyImageFileInfo", "vim.host.DatastoreBrowser.FileInfo", "vim.version.version1", None) +CreateDataType("vim.host.DatastoreBrowser.VmNvramInfo", "VmNvramFileInfo", "vim.host.DatastoreBrowser.FileInfo", "vim.version.version1", None) +CreateDataType("vim.host.DatastoreBrowser.VmLogInfo", "VmLogFileInfo", "vim.host.DatastoreBrowser.FileInfo", "vim.version.version1", None) +CreateDataType("vim.host.DatastoreBrowser.SearchSpec", "HostDatastoreBrowserSearchSpec", "vmodl.DynamicData", "vim.version.version1", [("query", "vim.host.DatastoreBrowser.Query[]", "vim.version.version1", F_OPTIONAL), ("details", "vim.host.DatastoreBrowser.FileInfo.Details", "vim.version.version1", F_OPTIONAL), ("searchCaseInsensitive", "boolean", "vim.version.version1", F_OPTIONAL), ("matchPattern", "string[]", "vim.version.version1", F_OPTIONAL), ("sortFoldersFirst", "boolean", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.DatastoreBrowser.SearchResults", "HostDatastoreBrowserSearchResults", "vmodl.DynamicData", "vim.version.version1", [("datastore", "vim.Datastore", "vim.version.version1", F_OPTIONAL), ("folderPath", "string", "vim.version.version1", F_OPTIONAL), ("file", "vim.host.DatastoreBrowser.FileInfo[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.VmfsDatastoreSpec", "VmfsDatastoreSpec", "vmodl.DynamicData", "vim.version.version1", [("diskUuid", "string", "vim.version.version1", 0)]) +CreateDataType("vim.host.DateTimeConfig", "HostDateTimeConfig", "vmodl.DynamicData", "vim.version.version2", [("timeZone", "string", "vim.version.version2", F_OPTIONAL), ("ntpConfig", "vim.host.NtpConfig", "vim.version.version2", F_OPTIONAL)]) +CreateManagedType("vim.host.DateTimeSystem", "HostDateTimeSystem", "vmodl.ManagedObject", "vim.version.version2", [("dateTimeInfo", "vim.host.DateTimeInfo", "vim.version.version2", 0, "System.Read")], [("updateConfig", "UpdateDateTimeConfig", "vim.version.version2", (("config", "vim.host.DateTimeConfig", "vim.version.version2", 0, None),), (0, "void", "void"), "Host.Config.DateTime", ["vim.fault.HostConfigFault", ]), ("queryAvailableTimeZones", "QueryAvailableTimeZones", "vim.version.version2", (), (F_OPTIONAL, "vim.host.DateTimeSystem.TimeZone[]", "vim.host.DateTimeSystem.TimeZone[]"), "System.Read", None), ("queryDateTime", "QueryDateTime", "vim.version.version2", (), (0, "vmodl.DateTime", "vmodl.DateTime"), "System.Read", None), ("updateDateTime", "UpdateDateTime", "vim.version.version2", (("dateTime", "vmodl.DateTime", "vim.version.version2", 0, None),), (0, "void", "void"), "Host.Config.DateTime", ["vim.fault.HostConfigFault", ]), ("refresh", "RefreshDateTimeSystem", "vim.version.version2", (), (0, "void", "void"), "Host.Config.DateTime", None)]) +CreateDataType("vim.host.DateTimeSystem.TimeZone", "HostDateTimeSystemTimeZone", "vmodl.DynamicData", "vim.version.version2", [("key", "string", "vim.version.version2", 0), ("name", "string", "vim.version.version2", 0), ("description", "string", "vim.version.version2", 0), ("gmtOffset", "int", "vim.version.version2", 0)]) +CreateDataType("vim.host.Device", "HostDevice", "vmodl.DynamicData", "vim.version.version1", [("deviceName", "string", "vim.version.version1", 0), ("deviceType", "string", "vim.version.version1", 0)]) +CreateDataType("vim.host.DhcpService", "HostDhcpService", "vmodl.DynamicData", "vim.version.version2", [("key", "string", "vim.version.version2", 0), ("spec", "vim.host.DhcpService.Specification", "vim.version.version2", 0)]) +CreateDataType("vim.host.DhcpService.Specification", "HostDhcpServiceSpec", "vmodl.DynamicData", "vim.version.version2", [("virtualSwitch", "string", "vim.version.version2", 0), ("defaultLeaseDuration", "int", "vim.version.version2", 0), ("leaseBeginIp", "string", "vim.version.version2", 0), ("leaseEndIp", "string", "vim.version.version2", 0), ("maxLeaseDuration", "int", "vim.version.version2", 0), ("unlimitedLease", "boolean", "vim.version.version2", 0), ("ipSubnetAddr", "string", "vim.version.version2", 0), ("ipSubnetMask", "string", "vim.version.version2", 0)]) +CreateDataType("vim.host.DhcpService.Config", "HostDhcpServiceConfig", "vmodl.DynamicData", "vim.version.version2", [("changeOperation", "string", "vim.version.version2", F_OPTIONAL), ("key", "string", "vim.version.version2", 0), ("spec", "vim.host.DhcpService.Specification", "vim.version.version2", 0)]) +CreateManagedType("vim.host.DirectoryStore", "HostDirectoryStore", "vim.host.AuthenticationStore", "vim.version.version6", None, None) +CreateDataType("vim.host.DirectoryStoreInfo", "HostDirectoryStoreInfo", "vim.host.AuthenticationStoreInfo", "vim.version.version6", None) +CreateDataType("vim.host.DiskConfigurationResult", "HostDiskConfigurationResult", "vmodl.DynamicData", "vim.version.version9", [("devicePath", "string", "vim.version.version9", F_OPTIONAL), ("success", "boolean", "vim.version.version9", F_OPTIONAL), ("fault", "vmodl.MethodFault", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.host.DiskDimensions", "HostDiskDimensions", "vmodl.DynamicData", "vim.version.version1", None) +CreateDataType("vim.host.DiskDimensions.Chs", "HostDiskDimensionsChs", "vmodl.DynamicData", "vim.version.version1", [("cylinder", "long", "vim.version.version1", 0), ("head", "int", "vim.version.version1", 0), ("sector", "int", "vim.version.version1", 0)]) +CreateDataType("vim.host.DiskDimensions.Lba", "HostDiskDimensionsLba", "vmodl.DynamicData", "vim.version.version1", [("blockSize", "int", "vim.version.version1", 0), ("block", "long", "vim.version.version1", 0)]) +CreateDataType("vim.host.DiskPartitionInfo", "HostDiskPartitionInfo", "vmodl.DynamicData", "vim.version.version1", [("deviceName", "string", "vim.version.version1", 0), ("spec", "vim.host.DiskPartitionInfo.Specification", "vim.version.version1", 0), ("layout", "vim.host.DiskPartitionInfo.Layout", "vim.version.version1", 0)]) +CreateEnumType("vim.host.DiskPartitionInfo.PartitionFormat", "HostDiskPartitionInfoPartitionFormat", "vim.version.version7", ["gpt", "mbr", "unknown"]) +CreateEnumType("vim.host.DiskPartitionInfo.Type", "HostDiskPartitionInfoType", "vim.version.version1", ["none", "vmfs", "linuxNative", "linuxSwap", "extended", "ntfs", "vmkDiagnostic", "vffs"]) +CreateDataType("vim.host.DiskPartitionInfo.Partition", "HostDiskPartitionAttributes", "vmodl.DynamicData", "vim.version.version1", [("partition", "int", "vim.version.version1", 0), ("startSector", "long", "vim.version.version1", 0), ("endSector", "long", "vim.version.version1", 0), ("type", "string", "vim.version.version1", 0), ("guid", "string", "vim.version.version7", F_OPTIONAL), ("logical", "boolean", "vim.version.version1", 0), ("attributes", "byte", "vim.version.version1", 0), ("partitionAlignment", "long", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.host.DiskPartitionInfo.BlockRange", "HostDiskPartitionBlockRange", "vmodl.DynamicData", "vim.version.version1", [("partition", "int", "vim.version.version1", F_OPTIONAL), ("type", "string", "vim.version.version1", 0), ("start", "vim.host.DiskDimensions.Lba", "vim.version.version1", 0), ("end", "vim.host.DiskDimensions.Lba", "vim.version.version1", 0)]) +CreateDataType("vim.host.DiskPartitionInfo.Specification", "HostDiskPartitionSpec", "vmodl.DynamicData", "vim.version.version1", [("partitionFormat", "string", "vim.version.version7", F_OPTIONAL), ("chs", "vim.host.DiskDimensions.Chs", "vim.version.version1", F_OPTIONAL), ("totalSectors", "long", "vim.version.version1", F_OPTIONAL), ("partition", "vim.host.DiskPartitionInfo.Partition[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.DiskPartitionInfo.Layout", "HostDiskPartitionLayout", "vmodl.DynamicData", "vim.version.version1", [("total", "vim.host.DiskDimensions.Lba", "vim.version.version1", F_OPTIONAL), ("partition", "vim.host.DiskPartitionInfo.BlockRange[]", "vim.version.version1", 0)]) +CreateDataType("vim.host.DnsConfig", "HostDnsConfig", "vmodl.DynamicData", "vim.version.version1", [("dhcp", "boolean", "vim.version.version1", 0), ("virtualNicDevice", "string", "vim.version.version1", F_OPTIONAL), ("hostName", "string", "vim.version.version1", 0), ("domainName", "string", "vim.version.version1", 0), ("address", "string[]", "vim.version.version1", F_OPTIONAL), ("searchDomain", "string[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.DnsConfigSpec", "HostDnsConfigSpec", "vim.host.DnsConfig", "vim.version.version5", [("virtualNicConnection", "vim.host.VirtualNicConnection", "vim.version.version5", F_OPTIONAL)]) +CreateManagedType("vim.host.EsxAgentHostManager", "HostEsxAgentHostManager", "vmodl.ManagedObject", "vim.version.version7", [("configInfo", "vim.host.EsxAgentHostManager.ConfigInfo", "vim.version.version7", 0, "Host.Config.Settings")], [("updateConfig", "EsxAgentHostManagerUpdateConfig", "vim.version.version7", (("configInfo", "vim.host.EsxAgentHostManager.ConfigInfo", "vim.version.version7", 0, None),), (0, "void", "void"), "Host.Config.Settings", ["vim.fault.HostConfigFault", ])]) +CreateDataType("vim.host.EsxAgentHostManager.ConfigInfo", "HostEsxAgentHostManagerConfigInfo", "vmodl.DynamicData", "vim.version.version7", [("agentVmDatastore", "vim.Datastore", "vim.version.version7", F_OPTIONAL), ("agentVmNetwork", "vim.Network", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.host.FcoeConfig", "FcoeConfig", "vmodl.DynamicData", "vim.version.version7", [("priorityClass", "int", "vim.version.version7", 0), ("sourceMac", "string", "vim.version.version7", 0), ("vlanRange", "vim.host.FcoeConfig.VlanRange[]", "vim.version.version7", 0), ("capabilities", "vim.host.FcoeConfig.FcoeCapabilities", "vim.version.version7", 0), ("fcoeActive", "boolean", "vim.version.version7", 0)]) +CreateDataType("vim.host.FcoeConfig.VlanRange", "FcoeConfigVlanRange", "vmodl.DynamicData", "vim.version.version7", [("vlanLow", "int", "vim.version.version7", 0), ("vlanHigh", "int", "vim.version.version7", 0)]) +CreateDataType("vim.host.FcoeConfig.FcoeCapabilities", "FcoeConfigFcoeCapabilities", "vmodl.DynamicData", "vim.version.version7", [("priorityClass", "boolean", "vim.version.version7", 0), ("sourceMacAddress", "boolean", "vim.version.version7", 0), ("vlanRange", "boolean", "vim.version.version7", 0)]) +CreateDataType("vim.host.FcoeConfig.FcoeSpecification", "FcoeConfigFcoeSpecification", "vmodl.DynamicData", "vim.version.version7", [("underlyingPnic", "string", "vim.version.version7", 0), ("priorityClass", "int", "vim.version.version7", F_OPTIONAL), ("sourceMac", "string", "vim.version.version7", F_OPTIONAL), ("vlanRange", "vim.host.FcoeConfig.VlanRange[]", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.host.FeatureCapability", "HostFeatureCapability", "vmodl.DynamicData", "vim.version.version8", [("key", "string", "vim.version.version8", 0), ("featureName", "string", "vim.version.version8", 0), ("value", "string", "vim.version.version8", 0)]) +CreateDataType("vim.host.FeatureMask", "HostFeatureMask", "vmodl.DynamicData", "vim.version.version8", [("key", "string", "vim.version.version8", 0), ("featureName", "string", "vim.version.version8", 0), ("value", "string", "vim.version.version8", 0)]) +CreateDataType("vim.host.FeatureVersionInfo", "HostFeatureVersionInfo", "vmodl.DynamicData", "vim.version.version6", [("key", "string", "vim.version.version6", 0), ("value", "string", "vim.version.version6", 0)]) +CreateEnumType("vim.host.FeatureVersionInfo.FeatureVersionKey", "HostFeatureVersionKey", "vim.version.version6", ["faultTolerance"]) +CreateDataType("vim.host.FileAccess", "HostFileAccess", "vmodl.DynamicData", "vim.version.version1", [("who", "string", "vim.version.version1", 0), ("what", "string", "vim.version.version1", 0)]) +CreateDataType("vim.host.FileAccess.Modes", "ModeInfo", "vmodl.DynamicData", "vim.version.version1", [("browse", "string", "vim.version.version1", F_OPTIONAL), ("read", "string", "vim.version.version1", 0), ("modify", "string", "vim.version.version1", 0), ("use", "string", "vim.version.version1", 0), ("admin", "string", "vim.version.version1", F_OPTIONAL), ("full", "string", "vim.version.version1", 0)]) +CreateDataType("vim.host.FileSystemVolumeInfo", "HostFileSystemVolumeInfo", "vmodl.DynamicData", "vim.version.version1", [("volumeTypeList", "string[]", "vim.version.version1", F_OPTIONAL), ("mountInfo", "vim.host.FileSystemMountInfo[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.FileSystemMountInfo", "HostFileSystemMountInfo", "vmodl.DynamicData", "vim.version.version1", [("mountInfo", "vim.host.MountInfo", "vim.version.version1", 0), ("volume", "vim.host.FileSystemVolume", "vim.version.version1", 0), ("vStorageSupport", "string", "vim.version.version6", F_OPTIONAL)]) +CreateEnumType("vim.host.FileSystemMountInfo.VStorageSupportStatus", "FileSystemMountInfoVStorageSupportStatus", "vim.version.version6", ["vStorageSupported", "vStorageUnsupported", "vStorageUnknown"]) +CreateDataType("vim.host.FileSystemVolume", "HostFileSystemVolume", "vmodl.DynamicData", "vim.version.version1", [("type", "string", "vim.version.version1", 0), ("name", "string", "vim.version.version1", 0), ("capacity", "long", "vim.version.version1", 0)]) +CreateDataType("vim.host.NasVolume", "HostNasVolume", "vim.host.FileSystemVolume", "vim.version.version1", [("remoteHost", "string", "vim.version.version1", 0), ("remotePath", "string", "vim.version.version1", 0), ("userName", "string", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.host.NasVolume.Specification", "HostNasVolumeSpec", "vmodl.DynamicData", "vim.version.version1", [("remoteHost", "string", "vim.version.version1", 0), ("remotePath", "string", "vim.version.version1", 0), ("localPath", "string", "vim.version.version1", 0), ("accessMode", "string", "vim.version.version1", 0), ("type", "string", "vim.version.version2", F_OPTIONAL), ("userName", "string", "vim.version.version2", F_OPTIONAL), ("password", "string", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.host.NasVolume.Config", "HostNasVolumeConfig", "vmodl.DynamicData", "vim.version.version5", [("changeOperation", "string", "vim.version.version5", F_OPTIONAL), ("spec", "vim.host.NasVolume.Specification", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.LocalFileSystemVolume", "HostLocalFileSystemVolume", "vim.host.FileSystemVolume", "vim.version.version1", [("device", "string", "vim.version.version1", 0)]) +CreateDataType("vim.host.LocalFileSystemVolume.Specification", "HostLocalFileSystemVolumeSpec", "vmodl.DynamicData", "vim.version.version1", [("device", "string", "vim.version.version1", 0), ("localPath", "string", "vim.version.version1", 0)]) +CreateDataType("vim.host.VfatVolume", "HostVfatVolume", "vim.host.FileSystemVolume", "vim.version.version7", None) +CreateDataType("vim.host.FirewallInfo", "HostFirewallInfo", "vmodl.DynamicData", "vim.version.version1", [("defaultPolicy", "vim.host.FirewallInfo.DefaultPolicy", "vim.version.version1", 0), ("ruleset", "vim.host.Ruleset[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.FirewallInfo.DefaultPolicy", "HostFirewallDefaultPolicy", "vmodl.DynamicData", "vim.version.version1", [("incomingBlocked", "boolean", "vim.version.version1", F_OPTIONAL), ("outgoingBlocked", "boolean", "vim.version.version1", F_OPTIONAL)]) +CreateManagedType("vim.host.FirmwareSystem", "HostFirmwareSystem", "vmodl.ManagedObject", "vim.version.version2", None, [("resetToFactoryDefaults", "ResetFirmwareToFactoryDefaults", "vim.version.version2", (), (0, "void", "void"), "Host.Config.Firmware", ["vim.fault.InvalidState", ]), ("backupConfiguration", "BackupFirmwareConfiguration", "vim.version.version2", (), (0, "string", "string"), "Host.Config.Firmware", None), ("queryConfigUploadURL", "QueryFirmwareConfigUploadURL", "vim.version.version2", (), (0, "string", "string"), "Host.Config.Firmware", None), ("restoreConfiguration", "RestoreFirmwareConfiguration", "vim.version.version2", (("force", "boolean", "vim.version.version2", 0, None),), (0, "void", "void"), "Host.Config.Firmware", ["vim.fault.InvalidState", "vim.fault.FileFault", "vim.fault.MismatchedBundle", "vim.fault.InvalidBundle", ])]) +CreateDataType("vim.host.FlagInfo", "HostFlagInfo", "vmodl.DynamicData", "vim.version.version2", [("backgroundSnapshotsEnabled", "boolean", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.host.ForceMountedInfo", "HostForceMountedInfo", "vmodl.DynamicData", "vim.version.version5", [("persist", "boolean", "vim.version.version5", 0), ("mounted", "boolean", "vim.version.version5", 0)]) +CreateDataType("vim.host.GraphicsInfo", "HostGraphicsInfo", "vmodl.DynamicData", "vim.version.version9", [("deviceName", "string", "vim.version.version9", 0), ("vendorName", "string", "vim.version.version9", 0), ("pciId", "string", "vim.version.version9", 0), ("graphicsType", "string", "vim.version.version9", 0), ("memorySizeInKB", "long", "vim.version.version9", 0), ("vm", "vim.VirtualMachine[]", "vim.version.version9", F_OPTIONAL)]) +CreateEnumType("vim.host.GraphicsInfo.GraphicsType", "HostGraphicsInfoGraphicsType", "vim.version.version9", ["basic", "shared", "direct"]) +CreateManagedType("vim.host.GraphicsManager", "HostGraphicsManager", "vim.ExtensibleManagedObject", "vim.version.version9", [("graphicsInfo", "vim.host.GraphicsInfo[]", "vim.version.version9", F_OPTIONAL, "System.Read")], [("refresh", "RefreshGraphicsManager", "vim.version.version9", (), (0, "void", "void"), "Host.Config.Settings", None), ("isSharedGraphicsActive", "IsSharedGraphicsActive", "vim.version.version9", (), (0, "boolean", "boolean"), "System.Read", None)]) +CreateDataType("vim.host.HardwareInfo", "HostHardwareInfo", "vmodl.DynamicData", "vim.version.version1", [("systemInfo", "vim.host.SystemInfo", "vim.version.version1", 0), ("cpuPowerManagementInfo", "vim.host.CpuPowerManagementInfo", "vim.version.version5", F_OPTIONAL), ("cpuInfo", "vim.host.CpuInfo", "vim.version.version1", 0), ("cpuPkg", "vim.host.CpuPackage[]", "vim.version.version1", 0), ("memorySize", "long", "vim.version.version1", 0), ("numaInfo", "vim.host.NumaInfo", "vim.version.version1", F_OPTIONAL), ("smcPresent", "boolean", "vim.version.version7", 0), ("pciDevice", "vim.host.PciDevice[]", "vim.version.version1", F_OPTIONAL), ("cpuFeature", "vim.host.CpuIdInfo[]", "vim.version.version1", F_OPTIONAL), ("biosInfo", "vim.host.BIOSInfo", "vim.version.version2", F_OPTIONAL), ("reliableMemoryInfo", "vim.host.ReliableMemoryInfo", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.host.SystemInfo", "HostSystemInfo", "vmodl.DynamicData", "vim.version.version1", [("vendor", "string", "vim.version.version1", 0), ("model", "string", "vim.version.version1", 0), ("uuid", "string", "vim.version.version1", 0), ("otherIdentifyingInfo", "vim.host.SystemIdentificationInfo[]", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.host.CpuPowerManagementInfo", "HostCpuPowerManagementInfo", "vmodl.DynamicData", "vim.version.version5", [("currentPolicy", "string", "vim.version.version5", F_OPTIONAL), ("hardwareSupport", "string", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.host.CpuPowerManagementInfo.PolicyType", "HostCpuPowerManagementInfoPolicyType", "vim.version.version5", ["off", "staticPolicy", "dynamicPolicy"]) +CreateDataType("vim.host.CpuInfo", "HostCpuInfo", "vmodl.DynamicData", "vim.version.version1", [("numCpuPackages", "short", "vim.version.version1", 0), ("numCpuCores", "short", "vim.version.version1", 0), ("numCpuThreads", "short", "vim.version.version1", 0), ("hz", "long", "vim.version.version1", 0)]) +CreateDataType("vim.host.CpuPackage", "HostCpuPackage", "vmodl.DynamicData", "vim.version.version1", [("index", "short", "vim.version.version1", 0), ("vendor", "string", "vim.version.version1", 0), ("hz", "long", "vim.version.version1", 0), ("busHz", "long", "vim.version.version1", 0), ("description", "string", "vim.version.version1", 0), ("threadId", "short[]", "vim.version.version1", 0), ("cpuFeature", "vim.host.CpuIdInfo[]", "vim.version.version1", F_OPTIONAL)]) +CreateEnumType("vim.host.CpuPackage.Vendor", "HostCpuPackageVendor", "vim.version.version1", ["unknown", "intel", "amd"]) +CreateDataType("vim.host.NumaInfo", "HostNumaInfo", "vmodl.DynamicData", "vim.version.version1", [("type", "string", "vim.version.version1", 0), ("numNodes", "int", "vim.version.version1", 0), ("numaNode", "vim.host.NumaNode[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.NumaNode", "HostNumaNode", "vmodl.DynamicData", "vim.version.version1", [("typeId", "byte", "vim.version.version1", 0), ("cpuID", "short[]", "vim.version.version1", 0), ("memoryRangeBegin", "long", "vim.version.version1", 0), ("memoryRangeLength", "long", "vim.version.version1", 0)]) +CreateDataType("vim.host.BIOSInfo", "HostBIOSInfo", "vmodl.DynamicData", "vim.version.version2", [("biosVersion", "string", "vim.version.version2", F_OPTIONAL), ("releaseDate", "vmodl.DateTime", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.host.ReliableMemoryInfo", "HostReliableMemoryInfo", "vmodl.DynamicData", "vim.version.version9", [("memorySize", "long", "vim.version.version9", 0)]) +CreateDataType("vim.host.HardwareStatusInfo", "HostHardwareStatusInfo", "vmodl.DynamicData", "vim.version.version2", [("memoryStatusInfo", "vim.host.HardwareStatusInfo.HardwareElementInfo[]", "vim.version.version2", F_OPTIONAL), ("cpuStatusInfo", "vim.host.HardwareStatusInfo.HardwareElementInfo[]", "vim.version.version2", F_OPTIONAL), ("storageStatusInfo", "vim.host.HardwareStatusInfo.StorageStatusInfo[]", "vim.version.version2", F_OPTIONAL)]) +CreateEnumType("vim.host.HardwareStatusInfo.Status", "HostHardwareElementStatus", "vim.version.version2", ["Unknown", "Green", "Yellow", "Red"]) +CreateDataType("vim.host.HardwareStatusInfo.HardwareElementInfo", "HostHardwareElementInfo", "vmodl.DynamicData", "vim.version.version2", [("name", "string", "vim.version.version2", 0), ("status", "vim.ElementDescription", "vim.version.version2", 0)]) +CreateDataType("vim.host.HardwareStatusInfo.StorageStatusInfo", "HostStorageElementInfo", "vim.host.HardwareStatusInfo.HardwareElementInfo", "vim.version.version2", [("operationalInfo", "vim.host.HardwareStatusInfo.StorageStatusInfo.OperationalInfo[]", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.host.HardwareStatusInfo.StorageStatusInfo.OperationalInfo", "HostStorageOperationalInfo", "vmodl.DynamicData", "vim.version.version2", [("property", "string", "vim.version.version2", 0), ("value", "string", "vim.version.version2", 0)]) +CreateManagedType("vim.host.HealthStatusSystem", "HostHealthStatusSystem", "vmodl.ManagedObject", "vim.version.version2", [("runtime", "vim.host.HealthStatusSystem.Runtime", "vim.version.version2", 0, None)], [("refresh", "RefreshHealthStatusSystem", "vim.version.version2", (), (0, "void", "void"), "System.Read", None), ("resetSystemHealthInfo", "ResetSystemHealthInfo", "vim.version.version2", (), (0, "void", "void"), "Host.Config.Settings", None)]) +CreateDataType("vim.host.HealthStatusSystem.Runtime", "HealthSystemRuntime", "vmodl.DynamicData", "vim.version.version2", [("systemHealthInfo", "vim.host.SystemHealthInfo", "vim.version.version2", F_OPTIONAL), ("hardwareStatusInfo", "vim.host.HardwareStatusInfo", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.host.HostBusAdapter", "HostHostBusAdapter", "vmodl.DynamicData", "vim.version.version1", [("key", "string", "vim.version.version1", F_OPTIONAL), ("device", "string", "vim.version.version1", 0), ("bus", "int", "vim.version.version1", 0), ("status", "string", "vim.version.version1", 0), ("model", "string", "vim.version.version1", 0), ("driver", "string", "vim.version.version1", F_OPTIONAL), ("pci", "string", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.ParallelScsiHba", "HostParallelScsiHba", "vim.host.HostBusAdapter", "vim.version.version1", None) +CreateDataType("vim.host.BlockHba", "HostBlockHba", "vim.host.HostBusAdapter", "vim.version.version1", None) +CreateDataType("vim.host.FibreChannelHba", "HostFibreChannelHba", "vim.host.HostBusAdapter", "vim.version.version1", [("portWorldWideName", "long", "vim.version.version1", 0), ("nodeWorldWideName", "long", "vim.version.version1", 0), ("portType", "vim.host.FibreChannelHba.PortType", "vim.version.version1", 0), ("speed", "long", "vim.version.version1", 0)]) +CreateEnumType("vim.host.FibreChannelHba.PortType", "FibreChannelPortType", "vim.version.version1", ["fabric", "loop", "pointToPoint", "unknown"]) +CreateDataType("vim.host.FibreChannelOverEthernetHba", "HostFibreChannelOverEthernetHba", "vim.host.FibreChannelHba", "vim.version.version7", [("underlyingNic", "string", "vim.version.version7", 0), ("linkInfo", "vim.host.FibreChannelOverEthernetHba.LinkInfo", "vim.version.version7", 0), ("isSoftwareFcoe", "boolean", "vim.version.version7", 0), ("markedForRemoval", "boolean", "vim.version.version7", 0)]) +CreateDataType("vim.host.FibreChannelOverEthernetHba.LinkInfo", "HostFibreChannelOverEthernetHbaLinkInfo", "vmodl.DynamicData", "vim.version.version7", [("vnportMac", "string", "vim.version.version7", 0), ("fcfMac", "string", "vim.version.version7", 0), ("vlanId", "int", "vim.version.version7", 0)]) +CreateDataType("vim.host.HostProxySwitch", "HostProxySwitch", "vmodl.DynamicData", "vim.version.version5", [("dvsUuid", "string", "vim.version.version5", 0), ("dvsName", "string", "vim.version.version5", 0), ("key", "string", "vim.version.version5", 0), ("numPorts", "int", "vim.version.version5", 0), ("configNumPorts", "int", "vim.version.version7", F_OPTIONAL), ("numPortsAvailable", "int", "vim.version.version5", 0), ("uplinkPort", "vim.KeyValue[]", "vim.version.version5", F_OPTIONAL), ("mtu", "int", "vim.version.version5", F_OPTIONAL), ("pnic", "vim.host.PhysicalNic[]", "vim.version.version5", F_LINK | F_OPTIONAL), ("spec", "vim.host.HostProxySwitch.Specification", "vim.version.version5", 0), ("hostLag", "vim.host.HostProxySwitch.HostLagConfig[]", "vim.version.version9", F_OPTIONAL), ("networkReservationSupported", "boolean", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.host.HostProxySwitch.Specification", "HostProxySwitchSpec", "vmodl.DynamicData", "vim.version.version5", [("backing", "vim.dvs.HostMember.Backing", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.HostProxySwitch.Config", "HostProxySwitchConfig", "vmodl.DynamicData", "vim.version.version5", [("changeOperation", "string", "vim.version.version5", F_OPTIONAL), ("uuid", "string", "vim.version.version5", 0), ("spec", "vim.host.HostProxySwitch.Specification", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.HostProxySwitch.HostLagConfig", "HostProxySwitchHostLagConfig", "vmodl.DynamicData", "vim.version.version9", [("lagKey", "string", "vim.version.version9", 0), ("lagName", "string", "vim.version.version9", F_OPTIONAL), ("uplinkPort", "vim.KeyValue[]", "vim.version.version9", F_OPTIONAL)]) +CreateManagedType("vim.host.ImageConfigManager", "HostImageConfigManager", "vmodl.ManagedObject", "vim.version.version7", None, [("queryHostAcceptanceLevel", "HostImageConfigGetAcceptance", "vim.version.version7", (), (0, "string", "string"), "System.Read", ["vim.fault.HostConfigFault", ]), ("queryHostImageProfile", "HostImageConfigGetProfile", "vim.version.version7", (), (0, "vim.host.ImageConfigManager.ImageProfileSummary", "vim.host.ImageConfigManager.ImageProfileSummary"), "System.Read", None), ("updateAcceptanceLevel", "UpdateHostImageAcceptanceLevel", "vim.version.version7", (("newAcceptanceLevel", "string", "vim.version.version7", 0, None),), (0, "void", "void"), "Host.Config.Image", ["vim.fault.HostConfigFault", ])]) +CreateEnumType("vim.host.ImageConfigManager.AcceptanceLevel", "HostImageAcceptanceLevel", "vim.version.version7", ["vmware_certified", "vmware_accepted", "partner", "community"]) +CreateDataType("vim.host.ImageConfigManager.ImageProfileSummary", "HostImageProfileSummary", "vmodl.DynamicData", "vim.version.version7", [("name", "string", "vim.version.version7", 0), ("vendor", "string", "vim.version.version7", 0)]) +CreateDataType("vim.host.IpConfig", "HostIpConfig", "vmodl.DynamicData", "vim.version.version1", [("dhcp", "boolean", "vim.version.version1", 0), ("ipAddress", "string", "vim.version.version1", F_OPTIONAL), ("subnetMask", "string", "vim.version.version1", F_OPTIONAL), ("ipV6Config", "vim.host.IpConfig.IpV6AddressConfiguration", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.host.IpConfig.IpV6AddressConfigType", "HostIpConfigIpV6AddressConfigType", "vim.version.version5", ["other", "manual", "dhcp", "linklayer", "random"]) +CreateEnumType("vim.host.IpConfig.IpV6AddressStatus", "HostIpConfigIpV6AddressStatus", "vim.version.version5", ["preferred", "deprecated", "invalid", "inaccessible", "unknown", "tentative", "duplicate"]) +CreateDataType("vim.host.IpConfig.IpV6Address", "HostIpConfigIpV6Address", "vmodl.DynamicData", "vim.version.version5", [("ipAddress", "string", "vim.version.version5", 0), ("prefixLength", "int", "vim.version.version5", 0), ("origin", "string", "vim.version.version5", F_OPTIONAL), ("dadState", "string", "vim.version.version5", F_OPTIONAL), ("lifetime", "vmodl.DateTime", "vim.version.version5", F_OPTIONAL), ("operation", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.IpConfig.IpV6AddressConfiguration", "HostIpConfigIpV6AddressConfiguration", "vmodl.DynamicData", "vim.version.version5", [("ipV6Address", "vim.host.IpConfig.IpV6Address[]", "vim.version.version5", F_OPTIONAL), ("autoConfigurationEnabled", "boolean", "vim.version.version5", F_OPTIONAL), ("dhcpV6Enabled", "boolean", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.IpRouteConfig", "HostIpRouteConfig", "vmodl.DynamicData", "vim.version.version1", [("defaultGateway", "string", "vim.version.version1", F_OPTIONAL), ("gatewayDevice", "string", "vim.version.version1", F_OPTIONAL), ("ipV6DefaultGateway", "string", "vim.version.version5", F_OPTIONAL), ("ipV6GatewayDevice", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.IpRouteConfigSpec", "HostIpRouteConfigSpec", "vim.host.IpRouteConfig", "vim.version.version5", [("gatewayDeviceConnection", "vim.host.VirtualNicConnection", "vim.version.version5", F_OPTIONAL), ("ipV6GatewayDeviceConnection", "vim.host.VirtualNicConnection", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.IpRouteEntry", "HostIpRouteEntry", "vmodl.DynamicData", "vim.version.version5", [("network", "string", "vim.version.version5", 0), ("prefixLength", "int", "vim.version.version5", 0), ("gateway", "string", "vim.version.version5", 0), ("deviceName", "string", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.host.IpRouteOp", "HostIpRouteOp", "vmodl.DynamicData", "vim.version.version5", [("changeOperation", "string", "vim.version.version5", 0), ("route", "vim.host.IpRouteEntry", "vim.version.version5", 0)]) +CreateDataType("vim.host.IpRouteTableConfig", "HostIpRouteTableConfig", "vmodl.DynamicData", "vim.version.version5", [("ipRoute", "vim.host.IpRouteOp[]", "vim.version.version5", F_OPTIONAL), ("ipv6Route", "vim.host.IpRouteOp[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.IpRouteTableInfo", "HostIpRouteTableInfo", "vmodl.DynamicData", "vim.version.version5", [("ipRoute", "vim.host.IpRouteEntry[]", "vim.version.version5", F_OPTIONAL), ("ipv6Route", "vim.host.IpRouteEntry[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.IpmiInfo", "HostIpmiInfo", "vmodl.DynamicData", "vim.version.version5", [("bmcIpAddress", "string", "vim.version.version5", F_OPTIONAL), ("bmcMacAddress", "string", "vim.version.version5", F_OPTIONAL), ("login", "string", "vim.version.version5", F_OPTIONAL), ("password", "string", "vim.version.version5", F_OPTIONAL)]) +CreateManagedType("vim.host.IscsiManager", "IscsiManager", "vmodl.ManagedObject", "vim.version.version7", None, [("queryVnicStatus", "QueryVnicStatus", "vim.version.version7", (("vnicDevice", "string", "vim.version.version7", 0, None),), (0, "vim.host.IscsiManager.IscsiStatus", "vim.host.IscsiManager.IscsiStatus"), "Host.Config.Storage", ["vim.fault.IscsiFault", ]), ("queryPnicStatus", "QueryPnicStatus", "vim.version.version7", (("pnicDevice", "string", "vim.version.version7", 0, None),), (0, "vim.host.IscsiManager.IscsiStatus", "vim.host.IscsiManager.IscsiStatus"), "Host.Config.Storage", ["vim.fault.IscsiFault", ]), ("queryBoundVnics", "QueryBoundVnics", "vim.version.version7", (("iScsiHbaName", "string", "vim.version.version7", 0, None),), (F_OPTIONAL, "vim.host.IscsiManager.IscsiPortInfo[]", "vim.host.IscsiManager.IscsiPortInfo[]"), "Host.Config.Storage", ["vim.fault.IscsiFault", "vim.fault.NotFound", ]), ("queryCandidateNics", "QueryCandidateNics", "vim.version.version7", (("iScsiHbaName", "string", "vim.version.version7", 0, None),), (F_OPTIONAL, "vim.host.IscsiManager.IscsiPortInfo[]", "vim.host.IscsiManager.IscsiPortInfo[]"), "Host.Config.Storage", ["vim.fault.IscsiFault", "vim.fault.NotFound", ]), ("bindVnic", "BindVnic", "vim.version.version7", (("iScsiHbaName", "string", "vim.version.version7", 0, None),("vnicDevice", "string", "vim.version.version7", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.IscsiFaultVnicAlreadyBound", "vim.fault.IscsiFaultVnicHasNoUplinks", "vim.fault.IscsiFaultVnicHasMultipleUplinks", "vim.fault.IscsiFaultVnicHasWrongUplink", "vim.fault.IscsiFaultVnicNotFound", "vim.fault.IscsiFaultInvalidVnic", "vim.fault.PlatformConfigFault", "vim.fault.IscsiFault", "vim.fault.NotFound", ]), ("unbindVnic", "UnbindVnic", "vim.version.version7", (("iScsiHbaName", "string", "vim.version.version7", 0, None),("vnicDevice", "string", "vim.version.version7", 0, None),("force", "boolean", "vim.version.version7", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.IscsiFaultVnicNotBound", "vim.fault.IscsiFaultVnicHasActivePaths", "vim.fault.IscsiFaultVnicIsLastPath", "vim.fault.PlatformConfigFault", "vim.fault.IscsiFault", "vim.fault.NotFound", ]), ("queryMigrationDependencies", "QueryMigrationDependencies", "vim.version.version7", (("pnicDevice", "string[]", "vim.version.version7", 0, None),), (0, "vim.host.IscsiManager.IscsiMigrationDependency", "vim.host.IscsiManager.IscsiMigrationDependency"), "Host.Config.Storage", None)]) +CreateDataType("vim.host.IscsiManager.IscsiStatus", "IscsiStatus", "vmodl.DynamicData", "vim.version.version7", [("reason", "vmodl.MethodFault[]", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.host.IscsiManager.IscsiPortInfo", "IscsiPortInfo", "vmodl.DynamicData", "vim.version.version7", [("vnicDevice", "string", "vim.version.version7", F_OPTIONAL), ("vnic", "vim.host.VirtualNic", "vim.version.version7", F_OPTIONAL), ("pnicDevice", "string", "vim.version.version7", F_OPTIONAL), ("pnic", "vim.host.PhysicalNic", "vim.version.version7", F_OPTIONAL), ("switchName", "string", "vim.version.version7", F_OPTIONAL), ("switchUuid", "string", "vim.version.version7", F_OPTIONAL), ("portgroupName", "string", "vim.version.version7", F_OPTIONAL), ("portgroupKey", "string", "vim.version.version7", F_OPTIONAL), ("portKey", "string", "vim.version.version7", F_OPTIONAL), ("complianceStatus", "vim.host.IscsiManager.IscsiStatus", "vim.version.version7", F_OPTIONAL), ("pathStatus", "string", "vim.version.version7", F_OPTIONAL)]) +CreateEnumType("vim.host.IscsiManager.IscsiPortInfo.PathStatus", "IscsiPortInfoPathStatus", "vim.version.version7", ["notUsed", "active", "standBy", "lastActive"]) +CreateDataType("vim.host.IscsiManager.IscsiDependencyEntity", "IscsiDependencyEntity", "vmodl.DynamicData", "vim.version.version7", [("pnicDevice", "string", "vim.version.version7", 0), ("vnicDevice", "string", "vim.version.version7", 0), ("vmhbaName", "string", "vim.version.version7", 0)]) +CreateDataType("vim.host.IscsiManager.IscsiMigrationDependency", "IscsiMigrationDependency", "vmodl.DynamicData", "vim.version.version7", [("migrationAllowed", "boolean", "vim.version.version7", 0), ("disallowReason", "vim.host.IscsiManager.IscsiStatus", "vim.version.version7", F_OPTIONAL), ("dependency", "vim.host.IscsiManager.IscsiDependencyEntity[]", "vim.version.version7", F_OPTIONAL)]) +CreateManagedType("vim.host.KernelModuleSystem", "HostKernelModuleSystem", "vmodl.ManagedObject", "vim.version.version3", None, [("queryModules", "QueryModules", "vim.version.version5", (), (F_OPTIONAL, "vim.host.KernelModuleSystem.ModuleInfo[]", "vim.host.KernelModuleSystem.ModuleInfo[]"), "Host.Config.Settings", None), ("updateModuleOptionString", "UpdateModuleOptionString", "vim.version.version3", (("name", "string", "vim.version.version3", 0, None),("options", "string", "vim.version.version3", 0, None),), (0, "void", "void"), "Host.Config.Settings", ["vim.fault.NotFound", ]), ("queryConfiguredModuleOptionString", "QueryConfiguredModuleOptionString", "vim.version.version3", (("name", "string", "vim.version.version3", 0, None),), (0, "string", "string"), "Host.Config.Settings", ["vim.fault.NotFound", ])]) +CreateDataType("vim.host.KernelModuleSystem.ModuleInfo", "KernelModuleInfo", "vmodl.DynamicData", "vim.version.version5", [("id", "int", "vim.version.version5", 0), ("name", "string", "vim.version.version5", 0), ("version", "string", "vim.version.version5", 0), ("filename", "string", "vim.version.version5", 0), ("optionString", "string", "vim.version.version5", 0), ("loaded", "boolean", "vim.version.version5", 0), ("enabled", "boolean", "vim.version.version5", 0), ("useCount", "int", "vim.version.version5", 0), ("readOnlySection", "vim.host.KernelModuleSystem.ModuleInfo.SectionInfo", "vim.version.version5", 0), ("writableSection", "vim.host.KernelModuleSystem.ModuleInfo.SectionInfo", "vim.version.version5", 0), ("textSection", "vim.host.KernelModuleSystem.ModuleInfo.SectionInfo", "vim.version.version5", 0), ("dataSection", "vim.host.KernelModuleSystem.ModuleInfo.SectionInfo", "vim.version.version5", 0), ("bssSection", "vim.host.KernelModuleSystem.ModuleInfo.SectionInfo", "vim.version.version5", 0)]) +CreateDataType("vim.host.KernelModuleSystem.ModuleInfo.SectionInfo", "KernelModuleSectionInfo", "vmodl.DynamicData", "vim.version.version5", [("address", "long", "vim.version.version5", 0), ("length", "int", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.LicenseSpec", "HostLicenseSpec", "vmodl.DynamicData", "vim.version.version5", [("source", "vim.LicenseManager.LicenseSource", "vim.version.version5", F_OPTIONAL), ("editionKey", "string", "vim.version.version5", F_OPTIONAL), ("disabledFeatureKey", "string[]", "vim.version.version5", F_OPTIONAL), ("enabledFeatureKey", "string[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.LinkDiscoveryProtocolConfig", "LinkDiscoveryProtocolConfig", "vmodl.DynamicData", "vim.version.version5", [("protocol", "string", "vim.version.version5", 0), ("operation", "string", "vim.version.version5", 0)]) +CreateEnumType("vim.host.LinkDiscoveryProtocolConfig.ProtocolType", "LinkDiscoveryProtocolConfigProtocolType", "vim.version.version5", ["cdp", "lldp"]) +CreateEnumType("vim.host.LinkDiscoveryProtocolConfig.OperationType", "LinkDiscoveryProtocolConfigOperationType", "vim.version.version5", ["none", "listen", "advertise", "both"]) +CreateManagedType("vim.host.LocalAccountManager", "HostLocalAccountManager", "vmodl.ManagedObject", "vim.version.version1", None, [("createUser", "CreateUser", "vim.version.version1", (("user", "vim.host.LocalAccountManager.AccountSpecification", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Local.ManageUserGroups", ["vim.fault.AlreadyExists", ]), ("updateUser", "UpdateUser", "vim.version.version1", (("user", "vim.host.LocalAccountManager.AccountSpecification", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Local.ManageUserGroups", ["vim.fault.UserNotFound", "vim.fault.AlreadyExists", ]), ("createGroup", "CreateGroup", "vim.version.version1", (("group", "vim.host.LocalAccountManager.AccountSpecification", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Local.ManageUserGroups", ["vim.fault.AlreadyExists", ]), ("removeUser", "RemoveUser", "vim.version.version1", (("userName", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Local.ManageUserGroups", ["vim.fault.UserNotFound", ]), ("removeGroup", "RemoveGroup", "vim.version.version1", (("groupName", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Local.ManageUserGroups", ["vim.fault.UserNotFound", ]), ("assignUserToGroup", "AssignUserToGroup", "vim.version.version1", (("user", "string", "vim.version.version1", 0, None),("group", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Local.ManageUserGroups", ["vim.fault.UserNotFound", "vim.fault.AlreadyExists", ]), ("unassignUserFromGroup", "UnassignUserFromGroup", "vim.version.version1", (("user", "string", "vim.version.version1", 0, None),("group", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Local.ManageUserGroups", ["vim.fault.UserNotFound", ])]) +CreateDataType("vim.host.LocalAccountManager.AccountSpecification", "HostAccountSpec", "vmodl.DynamicData", "vim.version.version1", [("id", "string", "vim.version.version1", 0), ("password", "string", "vim.version.version1", F_OPTIONAL), ("description", "string", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.LocalAccountManager.PosixAccountSpecification", "HostPosixAccountSpec", "vim.host.LocalAccountManager.AccountSpecification", "vim.version.version1", [("posixId", "int", "vim.version.version1", F_OPTIONAL), ("shellAccess", "boolean", "vim.version.version1", F_OPTIONAL)]) +CreateManagedType("vim.host.LocalAuthentication", "HostLocalAuthentication", "vim.host.AuthenticationStore", "vim.version.version6", None, None) +CreateDataType("vim.host.LocalAuthenticationInfo", "HostLocalAuthenticationInfo", "vim.host.AuthenticationStoreInfo", "vim.version.version6", None) +CreateDataType("vim.host.LowLevelProvisioningManager.VmRecoveryInfo", "HostLowLevelProvisioningManagerVmRecoveryInfo", "vmodl.DynamicData", "vim.version.version8", [("version", "string", "vim.version.version8", 0), ("biosUUID", "string", "vim.version.version8", 0), ("instanceUUID", "string", "vim.version.version8", 0), ("ftInfo", "vim.vm.FaultToleranceConfigInfo", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.host.LowLevelProvisioningManager.VmMigrationStatus", "HostLowLevelProvisioningManagerVmMigrationStatus", "vmodl.DynamicData", "vim.version.version8", [("migrationId", "long", "vim.version.version8", 0), ("type", "string", "vim.version.version8", 0), ("source", "boolean", "vim.version.version8", 0), ("consideredSuccessful", "boolean", "vim.version.version8", 0)]) +CreateEnumType("vim.host.LowLevelProvisioningManager.ReloadTarget", "HostLowLevelProvisioningManagerReloadTarget", "vim.version.version5", ["currentConfig", "snapshotConfig"]) +CreateDataType("vim.host.LowLevelProvisioningManager.DiskLayoutSpec", "HostLowLevelProvisioningManagerDiskLayoutSpec", "vmodl.DynamicData", "vim.version.version7", [("controllerType", "vmodl.TypeName", "vim.version.version7", 0), ("busNumber", "int", "vim.version.version7", 0), ("unitNumber", "int", "vim.version.version7", 0), ("srcFilename", "string", "vim.version.version7", 0), ("dstFilename", "string", "vim.version.version7", 0)]) +CreateDataType("vim.host.LowLevelProvisioningManager.SnapshotLayoutSpec", "HostLowLevelProvisioningManagerSnapshotLayoutSpec", "vmodl.DynamicData", "vim.version.version7", [("id", "int", "vim.version.version7", 0), ("srcFilename", "string", "vim.version.version7", 0), ("dstFilename", "string", "vim.version.version7", 0), ("disk", "vim.host.LowLevelProvisioningManager.DiskLayoutSpec[]", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.host.MaintenanceSpec", "HostMaintenanceSpec", "vmodl.DynamicData", "vim.version.version9", [("vsanMode", "vim.vsan.host.DecommissionMode", "vim.version.version9", F_OPTIONAL)]) +CreateManagedType("vim.host.MemoryManagerSystem", "HostMemorySystem", "vim.ExtensibleManagedObject", "vim.version.version1", [("consoleReservationInfo", "vim.host.MemoryManagerSystem.ServiceConsoleReservationInfo", "vim.version.version1", F_OPTIONAL, None), ("virtualMachineReservationInfo", "vim.host.MemoryManagerSystem.VirtualMachineReservationInfo", "vim.version.version2", F_OPTIONAL, None)], [("reconfigureServiceConsoleReservation", "ReconfigureServiceConsoleReservation", "vim.version.version1", (("cfgBytes", "long", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Memory", None), ("reconfigureVirtualMachineReservation", "ReconfigureVirtualMachineReservation", "vim.version.version2", (("spec", "vim.host.MemoryManagerSystem.VirtualMachineReservationSpec", "vim.version.version2", 0, None),), (0, "void", "void"), "Host.Config.Memory", None)]) +CreateDataType("vim.host.MemoryManagerSystem.ServiceConsoleReservationInfo", "ServiceConsoleReservationInfo", "vmodl.DynamicData", "vim.version.version1", [("serviceConsoleReservedCfg", "long", "vim.version.version1", 0), ("serviceConsoleReserved", "long", "vim.version.version1", 0), ("unreserved", "long", "vim.version.version1", 0)]) +CreateDataType("vim.host.MemoryManagerSystem.VirtualMachineReservationInfo", "VirtualMachineMemoryReservationInfo", "vmodl.DynamicData", "vim.version.version2", [("virtualMachineMin", "long", "vim.version.version2", 0), ("virtualMachineMax", "long", "vim.version.version2", 0), ("virtualMachineReserved", "long", "vim.version.version2", 0), ("allocationPolicy", "string", "vim.version.version2", 0)]) +CreateEnumType("vim.host.MemoryManagerSystem.VirtualMachineReservationInfo.AllocationPolicy", "VirtualMachineMemoryAllocationPolicy", "vim.version.version2", ["swapNone", "swapSome", "swapMost"]) +CreateDataType("vim.host.MemoryManagerSystem.VirtualMachineReservationSpec", "VirtualMachineMemoryReservationSpec", "vmodl.DynamicData", "vim.version.version2", [("virtualMachineReserved", "long", "vim.version.version2", F_OPTIONAL), ("allocationPolicy", "string", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.host.MemorySpec", "HostMemorySpec", "vmodl.DynamicData", "vim.version.version5", [("serviceConsoleReservation", "long", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.MountInfo", "HostMountInfo", "vmodl.DynamicData", "vim.version.version1", [("path", "string", "vim.version.version1", F_OPTIONAL), ("accessMode", "string", "vim.version.version1", 0), ("mounted", "boolean", "vim.version.version7", F_OPTIONAL), ("accessible", "boolean", "vim.version.version2", F_OPTIONAL), ("inaccessibleReason", "string", "vim.version.version8", F_OPTIONAL)]) +CreateEnumType("vim.host.MountInfo.AccessMode", "HostMountMode", "vim.version.version1", ["readWrite", "readOnly"]) +CreateEnumType("vim.host.MountInfo.InaccessibleReason", "HostMountInfoInaccessibleReason", "vim.version.version8", ["AllPathsDown_Start", "AllPathsDown_Timeout", "PermanentDeviceLoss"]) +CreateDataType("vim.host.MultipathInfo", "HostMultipathInfo", "vmodl.DynamicData", "vim.version.version1", [("lun", "vim.host.MultipathInfo.LogicalUnit[]", "vim.version.version1", F_LINKABLE | F_OPTIONAL)]) +CreateEnumType("vim.host.MultipathInfo.PathState", "MultipathState", "vim.version.version1", ["standby", "active", "disabled", "dead", "unknown"]) +CreateDataType("vim.host.MultipathInfo.LogicalUnitPolicy", "HostMultipathInfoLogicalUnitPolicy", "vmodl.DynamicData", "vim.version.version1", [("policy", "string", "vim.version.version1", 0)]) +CreateDataType("vim.host.MultipathInfo.LogicalUnitStorageArrayTypePolicy", "HostMultipathInfoLogicalUnitStorageArrayTypePolicy", "vmodl.DynamicData", "vim.version.version5", [("policy", "string", "vim.version.version5", 0)]) +CreateDataType("vim.host.MultipathInfo.FixedLogicalUnitPolicy", "HostMultipathInfoFixedLogicalUnitPolicy", "vim.host.MultipathInfo.LogicalUnitPolicy", "vim.version.version1", [("prefer", "string", "vim.version.version1", 0)]) +CreateDataType("vim.host.MultipathInfo.LogicalUnit", "HostMultipathInfoLogicalUnit", "vmodl.DynamicData", "vim.version.version1", [("key", "string", "vim.version.version1", 0), ("id", "string", "vim.version.version1", 0), ("lun", "vim.host.ScsiLun", "vim.version.version1", F_LINK), ("path", "vim.host.MultipathInfo.Path[]", "vim.version.version1", 0), ("policy", "vim.host.MultipathInfo.LogicalUnitPolicy", "vim.version.version1", 0), ("storageArrayTypePolicy", "vim.host.MultipathInfo.LogicalUnitStorageArrayTypePolicy", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.MultipathInfo.Path", "HostMultipathInfoPath", "vmodl.DynamicData", "vim.version.version1", [("key", "string", "vim.version.version1", 0), ("name", "string", "vim.version.version1", 0), ("pathState", "string", "vim.version.version1", 0), ("state", "string", "vim.version.version5", F_OPTIONAL), ("isWorkingPath", "boolean", "vim.version.version5", F_OPTIONAL), ("adapter", "vim.host.HostBusAdapter", "vim.version.version1", F_LINK), ("lun", "vim.host.MultipathInfo.LogicalUnit", "vim.version.version1", F_LINK), ("transport", "vim.host.TargetTransport", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.MultipathStateInfo", "HostMultipathStateInfo", "vmodl.DynamicData", "vim.version.version5", [("path", "vim.host.MultipathStateInfo.Path[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.MultipathStateInfo.Path", "HostMultipathStateInfoPath", "vmodl.DynamicData", "vim.version.version5", [("name", "string", "vim.version.version5", 0), ("pathState", "string", "vim.version.version5", 0)]) +CreateDataType("vim.host.NatService", "HostNatService", "vmodl.DynamicData", "vim.version.version2", [("key", "string", "vim.version.version2", 0), ("spec", "vim.host.NatService.Specification", "vim.version.version2", 0)]) +CreateDataType("vim.host.NatService.PortForwardSpecification", "HostNatServicePortForwardSpec", "vmodl.DynamicData", "vim.version.version2", [("type", "string", "vim.version.version2", 0), ("name", "string", "vim.version.version2", 0), ("hostPort", "int", "vim.version.version2", 0), ("guestPort", "int", "vim.version.version2", 0), ("guestIpAddress", "string", "vim.version.version2", 0)]) +CreateDataType("vim.host.NatService.NameServiceSpec", "HostNatServiceNameServiceSpec", "vmodl.DynamicData", "vim.version.version2", [("dnsAutoDetect", "boolean", "vim.version.version2", 0), ("dnsPolicy", "string", "vim.version.version2", 0), ("dnsRetries", "int", "vim.version.version2", 0), ("dnsTimeout", "int", "vim.version.version2", 0), ("dnsNameServer", "string[]", "vim.version.version2", F_OPTIONAL), ("nbdsTimeout", "int", "vim.version.version2", 0), ("nbnsRetries", "int", "vim.version.version2", 0), ("nbnsTimeout", "int", "vim.version.version2", 0)]) +CreateDataType("vim.host.NatService.Specification", "HostNatServiceSpec", "vmodl.DynamicData", "vim.version.version2", [("virtualSwitch", "string", "vim.version.version2", 0), ("activeFtp", "boolean", "vim.version.version2", 0), ("allowAnyOui", "boolean", "vim.version.version2", 0), ("configPort", "boolean", "vim.version.version2", 0), ("ipGatewayAddress", "string", "vim.version.version2", 0), ("udpTimeout", "int", "vim.version.version2", 0), ("portForward", "vim.host.NatService.PortForwardSpecification[]", "vim.version.version2", F_OPTIONAL), ("nameService", "vim.host.NatService.NameServiceSpec", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.host.NatService.Config", "HostNatServiceConfig", "vmodl.DynamicData", "vim.version.version2", [("changeOperation", "string", "vim.version.version2", F_OPTIONAL), ("key", "string", "vim.version.version2", 0), ("spec", "vim.host.NatService.Specification", "vim.version.version2", 0)]) +CreateDataType("vim.host.NetCapabilities", "HostNetCapabilities", "vmodl.DynamicData", "vim.version.version1", [("canSetPhysicalNicLinkSpeed", "boolean", "vim.version.version1", 0), ("supportsNicTeaming", "boolean", "vim.version.version1", 0), ("nicTeamingPolicy", "string[]", "vim.version.version1", F_OPTIONAL), ("supportsVlan", "boolean", "vim.version.version1", 0), ("usesServiceConsoleNic", "boolean", "vim.version.version1", 0), ("supportsNetworkHints", "boolean", "vim.version.version1", 0), ("maxPortGroupsPerVswitch", "int", "vim.version.version2", F_OPTIONAL), ("vswitchConfigSupported", "boolean", "vim.version.version2", 0), ("vnicConfigSupported", "boolean", "vim.version.version2", 0), ("ipRouteConfigSupported", "boolean", "vim.version.version2", 0), ("dnsConfigSupported", "boolean", "vim.version.version2", 0), ("dhcpOnVnicSupported", "boolean", "vim.version.version2", 0), ("ipV6Supported", "boolean", "vim.version.version5", 0)]) +CreateDataType("vim.host.NetOffloadCapabilities", "HostNetOffloadCapabilities", "vmodl.DynamicData", "vim.version.version1", [("csumOffload", "boolean", "vim.version.version1", F_OPTIONAL), ("tcpSegmentation", "boolean", "vim.version.version1", F_OPTIONAL), ("zeroCopyXmit", "boolean", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.NetStackInstance", "HostNetStackInstance", "vmodl.DynamicData", "vim.version.version9", [("key", "string", "vim.version.version9", F_OPTIONAL), ("name", "string", "vim.version.version9", F_OPTIONAL), ("dnsConfig", "vim.host.DnsConfig", "vim.version.version9", F_OPTIONAL), ("ipRouteConfig", "vim.host.IpRouteConfig", "vim.version.version9", F_OPTIONAL), ("requestedMaxNumberOfConnections", "int", "vim.version.version9", F_OPTIONAL), ("congestionControlAlgorithm", "string", "vim.version.version9", F_OPTIONAL), ("ipV6Enabled", "boolean", "vim.version.version9", F_OPTIONAL), ("routeTableConfig", "vim.host.IpRouteTableConfig", "vim.version.version9", F_OPTIONAL)]) +CreateEnumType("vim.host.NetStackInstance.SystemStackKey", "HostNetStackInstanceSystemStackKey", "vim.version.version9", ["defaultTcpipStack"]) +CreateEnumType("vim.host.NetStackInstance.CongestionControlAlgorithmType", "HostNetStackInstanceCongestionControlAlgorithmType", "vim.version.version9", ["newreno", "cubic"]) +CreateDataType("vim.host.NetworkInfo", "HostNetworkInfo", "vmodl.DynamicData", "vim.version.version1", [("vswitch", "vim.host.VirtualSwitch[]", "vim.version.version1", F_LINKABLE | F_OPTIONAL), ("proxySwitch", "vim.host.HostProxySwitch[]", "vim.version.version5", F_OPTIONAL), ("portgroup", "vim.host.PortGroup[]", "vim.version.version1", F_LINKABLE | F_OPTIONAL), ("pnic", "vim.host.PhysicalNic[]", "vim.version.version1", F_LINKABLE | F_OPTIONAL), ("vnic", "vim.host.VirtualNic[]", "vim.version.version1", F_OPTIONAL), ("consoleVnic", "vim.host.VirtualNic[]", "vim.version.version1", F_OPTIONAL), ("dnsConfig", "vim.host.DnsConfig", "vim.version.version1", F_OPTIONAL), ("ipRouteConfig", "vim.host.IpRouteConfig", "vim.version.version1", F_OPTIONAL), ("consoleIpRouteConfig", "vim.host.IpRouteConfig", "vim.version.version1", F_OPTIONAL), ("routeTableInfo", "vim.host.IpRouteTableInfo", "vim.version.version5", F_OPTIONAL), ("dhcp", "vim.host.DhcpService[]", "vim.version.version2", F_OPTIONAL), ("nat", "vim.host.NatService[]", "vim.version.version2", F_OPTIONAL), ("ipV6Enabled", "boolean", "vim.version.version5", F_OPTIONAL), ("atBootIpV6Enabled", "boolean", "vim.version.version6", F_OPTIONAL), ("netStackInstance", "vim.host.NetStackInstance[]", "vim.version.version9", F_OPTIONAL), ("opaqueSwitch", "vim.host.OpaqueSwitch[]", "vim.version.version9", F_OPTIONAL), ("opaqueNetwork", "vim.host.OpaqueNetworkInfo[]", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.host.NetworkPolicy", "HostNetworkPolicy", "vmodl.DynamicData", "vim.version.version1", [("security", "vim.host.NetworkPolicy.SecurityPolicy", "vim.version.version1", F_OPTIONAL), ("nicTeaming", "vim.host.NetworkPolicy.NicTeamingPolicy", "vim.version.version1", F_OPTIONAL), ("offloadPolicy", "vim.host.NetOffloadCapabilities", "vim.version.version1", F_OPTIONAL), ("shapingPolicy", "vim.host.NetworkPolicy.TrafficShapingPolicy", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.NetworkPolicy.SecurityPolicy", "HostNetworkSecurityPolicy", "vmodl.DynamicData", "vim.version.version1", [("allowPromiscuous", "boolean", "vim.version.version1", F_OPTIONAL), ("macChanges", "boolean", "vim.version.version1", F_OPTIONAL), ("forgedTransmits", "boolean", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.NetworkPolicy.TrafficShapingPolicy", "HostNetworkTrafficShapingPolicy", "vmodl.DynamicData", "vim.version.version1", [("enabled", "boolean", "vim.version.version1", F_OPTIONAL), ("averageBandwidth", "long", "vim.version.version1", F_OPTIONAL), ("peakBandwidth", "long", "vim.version.version1", F_OPTIONAL), ("burstSize", "long", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.NetworkPolicy.NicFailureCriteria", "HostNicFailureCriteria", "vmodl.DynamicData", "vim.version.version1", [("checkSpeed", "string", "vim.version.version1", F_OPTIONAL), ("speed", "int", "vim.version.version1", F_OPTIONAL), ("checkDuplex", "boolean", "vim.version.version1", F_OPTIONAL), ("fullDuplex", "boolean", "vim.version.version1", F_OPTIONAL), ("checkErrorPercent", "boolean", "vim.version.version1", F_OPTIONAL), ("percentage", "int", "vim.version.version1", F_OPTIONAL), ("checkBeacon", "boolean", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.NetworkPolicy.NicOrderPolicy", "HostNicOrderPolicy", "vmodl.DynamicData", "vim.version.version1", [("activeNic", "string[]", "vim.version.version1", F_OPTIONAL), ("standbyNic", "string[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.NetworkPolicy.NicTeamingPolicy", "HostNicTeamingPolicy", "vmodl.DynamicData", "vim.version.version1", [("policy", "string", "vim.version.version1", F_OPTIONAL), ("reversePolicy", "boolean", "vim.version.version1", F_OPTIONAL), ("notifySwitches", "boolean", "vim.version.version1", F_OPTIONAL), ("rollingOrder", "boolean", "vim.version.version1", F_OPTIONAL), ("failureCriteria", "vim.host.NetworkPolicy.NicFailureCriteria", "vim.version.version1", F_OPTIONAL), ("nicOrder", "vim.host.NetworkPolicy.NicOrderPolicy", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.NtpConfig", "HostNtpConfig", "vmodl.DynamicData", "vim.version.version2", [("server", "string[]", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.host.NumericSensorInfo", "HostNumericSensorInfo", "vmodl.DynamicData", "vim.version.version2", [("name", "string", "vim.version.version2", 0), ("healthState", "vim.ElementDescription", "vim.version.version2", F_OPTIONAL), ("currentReading", "long", "vim.version.version2", 0), ("unitModifier", "int", "vim.version.version2", 0), ("baseUnits", "string", "vim.version.version2", 0), ("rateUnits", "string", "vim.version.version2", F_OPTIONAL), ("sensorType", "string", "vim.version.version2", 0)]) +CreateEnumType("vim.host.NumericSensorInfo.HealthState", "HostNumericSensorHealthState", "vim.version.version2", ["unknown", "green", "yellow", "red"]) +CreateEnumType("vim.host.NumericSensorInfo.SensorType", "HostNumericSensorType", "vim.version.version2", ["fan", "power", "temperature", "voltage", "other"]) +CreateDataType("vim.host.OpaqueNetworkInfo", "HostOpaqueNetworkInfo", "vmodl.DynamicData", "vim.version.version9", [("opaqueNetworkId", "string", "vim.version.version9", 0), ("opaqueNetworkName", "string", "vim.version.version9", 0), ("opaqueNetworkType", "string", "vim.version.version9", 0)]) +CreateDataType("vim.host.OpaqueSwitch", "HostOpaqueSwitch", "vmodl.DynamicData", "vim.version.version9", [("key", "string", "vim.version.version9", 0), ("name", "string", "vim.version.version9", F_OPTIONAL), ("pnic", "vim.host.PhysicalNic[]", "vim.version.version9", F_LINK | F_OPTIONAL)]) +CreateManagedType("vim.host.PatchManager", "HostPatchManager", "vmodl.ManagedObject", "vim.version.version1", None, [("Check", "CheckHostPatch_Task", "vim.version.version5", (("metaUrls", "string[]", "vim.version.version5", F_OPTIONAL, None),("bundleUrls", "string[]", "vim.version.version5", F_OPTIONAL, None),("spec", "vim.host.PatchManager.PatchManagerOperationSpec", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.Task", "vim.host.PatchManager.Result"), "System.Read", ["vmodl.fault.RequestCanceled", "vim.fault.InvalidState", "vim.fault.TaskInProgress", "vim.fault.PlatformConfigFault", ]), ("Scan", "ScanHostPatch_Task", "vim.version.version1", (("repository", "vim.host.PatchManager.Locator", "vim.version.version1", 0, None),("updateID", "string[]", "vim.version.version1", F_OPTIONAL, None),), (F_OPTIONAL, "vim.Task", "vim.host.PatchManager.Status[]"), "System.Read", ["vmodl.fault.RequestCanceled", "vim.fault.PatchMetadataInvalid", "vim.fault.PlatformConfigFault", ]), ("ScanV2", "ScanHostPatchV2_Task", "vim.version.version5", (("metaUrls", "string[]", "vim.version.version5", F_OPTIONAL, None),("bundleUrls", "string[]", "vim.version.version5", F_OPTIONAL, None),("spec", "vim.host.PatchManager.PatchManagerOperationSpec", "vim.version.version5", F_OPTIONAL, None),), (F_OPTIONAL, "vim.Task", "vim.host.PatchManager.Result"), "System.Read", ["vmodl.fault.RequestCanceled", "vim.fault.InvalidState", "vim.fault.TaskInProgress", "vim.fault.PlatformConfigFault", ]), ("Stage", "StageHostPatch_Task", "vim.version.version5", (("metaUrls", "string[]", "vim.version.version5", F_OPTIONAL, None),("bundleUrls", "string[]", "vim.version.version5", F_OPTIONAL, None),("vibUrls", "string[]", "vim.version.version5", F_OPTIONAL, None),("spec", "vim.host.PatchManager.PatchManagerOperationSpec", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.Task", "vim.host.PatchManager.Result"), "Host.Config.Patch", ["vmodl.fault.RequestCanceled", "vim.fault.InvalidState", "vim.fault.TaskInProgress", "vim.fault.PlatformConfigFault", ]), ("Install", "InstallHostPatch_Task", "vim.version.version1", (("repository", "vim.host.PatchManager.Locator", "vim.version.version1", 0, None),("updateID", "string", "vim.version.version1", 0, None),("force", "boolean", "vim.version.version1", F_OPTIONAL, None),), (0, "vim.Task", "void"), "Host.Config.Patch", ["vim.fault.PatchMetadataInvalid", "vim.fault.PatchBinariesNotFound", "vim.fault.PatchNotApplicable", "vim.fault.NoDiskSpace", "vim.fault.PatchInstallFailed", "vim.fault.RebootRequired", "vim.fault.InvalidState", "vim.fault.TaskInProgress", ]), ("InstallV2", "InstallHostPatchV2_Task", "vim.version.version5", (("metaUrls", "string[]", "vim.version.version5", F_OPTIONAL, None),("bundleUrls", "string[]", "vim.version.version5", F_OPTIONAL, None),("vibUrls", "string[]", "vim.version.version5", F_OPTIONAL, None),("spec", "vim.host.PatchManager.PatchManagerOperationSpec", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.Task", "vim.host.PatchManager.Result"), "Host.Config.Patch", ["vmodl.fault.RequestCanceled", "vim.fault.InvalidState", "vim.fault.TaskInProgress", "vim.fault.PlatformConfigFault", ]), ("Uninstall", "UninstallHostPatch_Task", "vim.version.version5", (("bulletinIds", "string[]", "vim.version.version5", F_OPTIONAL, None),("spec", "vim.host.PatchManager.PatchManagerOperationSpec", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.Task", "vim.host.PatchManager.Result"), "Host.Config.Patch", ["vim.fault.InvalidState", "vim.fault.TaskInProgress", "vim.fault.PlatformConfigFault", ]), ("Query", "QueryHostPatch_Task", "vim.version.version5", (("spec", "vim.host.PatchManager.PatchManagerOperationSpec", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.Task", "vim.host.PatchManager.Result"), "System.Read", ["vmodl.fault.RequestCanceled", "vim.fault.InvalidState", "vim.fault.TaskInProgress", "vim.fault.PlatformConfigFault", ])]) +CreateDataType("vim.host.PatchManager.Result", "HostPatchManagerResult", "vmodl.DynamicData", "vim.version.version5", [("version", "string", "vim.version.version5", 0), ("status", "vim.host.PatchManager.Status[]", "vim.version.version5", F_OPTIONAL), ("xmlResult", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.PatchManager.Status", "HostPatchManagerStatus", "vmodl.DynamicData", "vim.version.version1", [("id", "string", "vim.version.version1", 0), ("applicable", "boolean", "vim.version.version1", 0), ("reason", "string[]", "vim.version.version1", F_OPTIONAL), ("integrity", "string", "vim.version.version1", F_OPTIONAL), ("installed", "boolean", "vim.version.version1", 0), ("installState", "string[]", "vim.version.version1", F_OPTIONAL), ("prerequisitePatch", "vim.host.PatchManager.Status.PrerequisitePatch[]", "vim.version.version1", F_OPTIONAL), ("restartRequired", "boolean", "vim.version.version1", 0), ("reconnectRequired", "boolean", "vim.version.version1", 0), ("vmOffRequired", "boolean", "vim.version.version1", 0), ("supersededPatchIds", "string[]", "vim.version.version1", F_OPTIONAL)]) +CreateEnumType("vim.host.PatchManager.Status.Reason", "HostPatchManagerReason", "vim.version.version1", ["obsoleted", "missingPatch", "missingLib", "hasDependentPatch", "conflictPatch", "conflictLib"]) +CreateEnumType("vim.host.PatchManager.Status.Integrity", "HostPatchManagerIntegrityStatus", "vim.version.version1", ["validated", "keyNotFound", "keyRevoked", "keyExpired", "digestMismatch", "notEnoughSignatures", "validationError"]) +CreateEnumType("vim.host.PatchManager.Status.InstallState", "HostPatchManagerInstallState", "vim.version.version1", ["hostRestarted", "imageActive"]) +CreateDataType("vim.host.PatchManager.Status.PrerequisitePatch", "HostPatchManagerStatusPrerequisitePatch", "vmodl.DynamicData", "vim.version.version1", [("id", "string", "vim.version.version1", 0), ("installState", "string[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.PatchManager.Locator", "HostPatchManagerLocator", "vmodl.DynamicData", "vim.version.version1", [("url", "string", "vim.version.version1", 0), ("proxy", "string", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.PatchManager.PatchManagerOperationSpec", "HostPatchManagerPatchManagerOperationSpec", "vmodl.DynamicData", "vim.version.version5", [("proxy", "string", "vim.version.version5", F_OPTIONAL), ("port", "int", "vim.version.version5", F_OPTIONAL), ("userName", "string", "vim.version.version5", F_OPTIONAL), ("password", "string", "vim.version.version5", F_OPTIONAL), ("cmdOption", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.PathSelectionPolicyOption", "HostPathSelectionPolicyOption", "vmodl.DynamicData", "vim.version.version5", [("policy", "vim.ElementDescription", "vim.version.version5", 0)]) +CreateDataType("vim.host.PciDevice", "HostPciDevice", "vmodl.DynamicData", "vim.version.version1", [("id", "string", "vim.version.version1", 0), ("classId", "short", "vim.version.version1", 0), ("bus", "byte", "vim.version.version1", 0), ("slot", "byte", "vim.version.version1", 0), ("function", "byte", "vim.version.version1", 0), ("vendorId", "short", "vim.version.version1", 0), ("subVendorId", "short", "vim.version.version1", 0), ("vendorName", "string", "vim.version.version1", 0), ("deviceId", "short", "vim.version.version1", 0), ("subDeviceId", "short", "vim.version.version1", 0), ("parentBridge", "string", "vim.version.version5", F_OPTIONAL), ("deviceName", "string", "vim.version.version1", 0)]) +CreateDataType("vim.host.PciPassthruConfig", "HostPciPassthruConfig", "vmodl.DynamicData", "vim.version.version5", [("id", "string", "vim.version.version5", 0), ("passthruEnabled", "boolean", "vim.version.version5", 0)]) +CreateDataType("vim.host.PciPassthruInfo", "HostPciPassthruInfo", "vmodl.DynamicData", "vim.version.version5", [("id", "string", "vim.version.version5", 0), ("dependentDevice", "string", "vim.version.version5", 0), ("passthruEnabled", "boolean", "vim.version.version5", 0), ("passthruCapable", "boolean", "vim.version.version5", 0), ("passthruActive", "boolean", "vim.version.version5", 0)]) +CreateManagedType("vim.host.PciPassthruSystem", "HostPciPassthruSystem", "vim.ExtensibleManagedObject", "vim.version.version5", [("pciPassthruInfo", "vim.host.PciPassthruInfo[]", "vim.version.version5", 0, "System.Read")], [("refresh", "Refresh", "vim.version.version5", (), (0, "void", "void"), "Host.Config.Settings", None), ("updatePassthruConfig", "UpdatePassthruConfig", "vim.version.version5", (("config", "vim.host.PciPassthruConfig[]", "vim.version.version5", 0, None),), (0, "void", "void"), "Host.Config.PciPassthru", ["vim.fault.HostConfigFault", ])]) +CreateDataType("vim.host.PhysicalNic", "PhysicalNic", "vmodl.DynamicData", "vim.version.version1", [("key", "string", "vim.version.version1", F_OPTIONAL), ("device", "string", "vim.version.version1", 0), ("pci", "string", "vim.version.version1", 0), ("driver", "string", "vim.version.version1", F_OPTIONAL), ("linkSpeed", "vim.host.PhysicalNic.LinkSpeedDuplex", "vim.version.version1", F_OPTIONAL), ("validLinkSpecification", "vim.host.PhysicalNic.LinkSpeedDuplex[]", "vim.version.version1", F_OPTIONAL), ("spec", "vim.host.PhysicalNic.Specification", "vim.version.version1", 0), ("wakeOnLanSupported", "boolean", "vim.version.version2", 0), ("mac", "string", "vim.version.version2", 0), ("fcoeConfiguration", "vim.host.FcoeConfig", "vim.version.version7", F_OPTIONAL), ("vmDirectPathGen2Supported", "boolean", "vim.version.version6", F_OPTIONAL), ("vmDirectPathGen2SupportedMode", "string", "vim.version.version6", F_OPTIONAL), ("resourcePoolSchedulerAllowed", "boolean", "vim.version.version6", F_OPTIONAL), ("resourcePoolSchedulerDisallowedReason", "string[]", "vim.version.version6", F_OPTIONAL), ("autoNegotiateSupported", "boolean", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.host.PhysicalNic.Specification", "PhysicalNicSpec", "vmodl.DynamicData", "vim.version.version1", [("ip", "vim.host.IpConfig", "vim.version.version1", F_OPTIONAL), ("linkSpeed", "vim.host.PhysicalNic.LinkSpeedDuplex", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.PhysicalNic.Config", "PhysicalNicConfig", "vmodl.DynamicData", "vim.version.version1", [("device", "string", "vim.version.version1", 0), ("spec", "vim.host.PhysicalNic.Specification", "vim.version.version1", 0)]) +CreateDataType("vim.host.PhysicalNic.LinkSpeedDuplex", "PhysicalNicLinkInfo", "vmodl.DynamicData", "vim.version.version1", [("speedMb", "int", "vim.version.version1", 0), ("duplex", "boolean", "vim.version.version1", 0)]) +CreateDataType("vim.host.PhysicalNic.NetworkHint", "PhysicalNicHintInfo", "vmodl.DynamicData", "vim.version.version1", [("device", "string", "vim.version.version1", 0), ("subnet", "vim.host.PhysicalNic.NetworkHint.IpNetwork[]", "vim.version.version1", F_OPTIONAL), ("network", "vim.host.PhysicalNic.NetworkHint.NamedNetwork[]", "vim.version.version1", F_OPTIONAL), ("connectedSwitchPort", "vim.host.PhysicalNic.CdpInfo", "vim.version.version2", F_OPTIONAL), ("lldpInfo", "vim.host.PhysicalNic.LldpInfo", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.host.PhysicalNic.NetworkHint.HintElement", "PhysicalNicHint", "vmodl.DynamicData", "vim.version.version1", [("vlanId", "int", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.PhysicalNic.NetworkHint.IpNetwork", "PhysicalNicIpHint", "vim.host.PhysicalNic.NetworkHint.HintElement", "vim.version.version1", [("ipSubnet", "string", "vim.version.version1", 0)]) +CreateDataType("vim.host.PhysicalNic.NetworkHint.NamedNetwork", "PhysicalNicNameHint", "vim.host.PhysicalNic.NetworkHint.HintElement", "vim.version.version1", [("network", "string", "vim.version.version1", 0)]) +CreateDataType("vim.host.PhysicalNic.CdpDeviceCapability", "PhysicalNicCdpDeviceCapability", "vmodl.DynamicData", "vim.version.version2", [("router", "boolean", "vim.version.version2", 0), ("transparentBridge", "boolean", "vim.version.version2", 0), ("sourceRouteBridge", "boolean", "vim.version.version2", 0), ("networkSwitch", "boolean", "vim.version.version2", 0), ("host", "boolean", "vim.version.version2", 0), ("igmpEnabled", "boolean", "vim.version.version2", 0), ("repeater", "boolean", "vim.version.version2", 0)]) +CreateDataType("vim.host.PhysicalNic.CdpInfo", "PhysicalNicCdpInfo", "vmodl.DynamicData", "vim.version.version2", [("cdpVersion", "int", "vim.version.version2", F_OPTIONAL), ("timeout", "int", "vim.version.version2", F_OPTIONAL), ("ttl", "int", "vim.version.version2", F_OPTIONAL), ("samples", "int", "vim.version.version2", F_OPTIONAL), ("devId", "string", "vim.version.version2", F_OPTIONAL), ("address", "string", "vim.version.version2", F_OPTIONAL), ("portId", "string", "vim.version.version2", F_OPTIONAL), ("deviceCapability", "vim.host.PhysicalNic.CdpDeviceCapability", "vim.version.version2", F_OPTIONAL), ("softwareVersion", "string", "vim.version.version2", F_OPTIONAL), ("hardwarePlatform", "string", "vim.version.version2", F_OPTIONAL), ("ipPrefix", "string", "vim.version.version2", F_OPTIONAL), ("ipPrefixLen", "int", "vim.version.version2", F_OPTIONAL), ("vlan", "int", "vim.version.version2", F_OPTIONAL), ("fullDuplex", "boolean", "vim.version.version2", F_OPTIONAL), ("mtu", "int", "vim.version.version2", F_OPTIONAL), ("systemName", "string", "vim.version.version2", F_OPTIONAL), ("systemOID", "string", "vim.version.version2", F_OPTIONAL), ("mgmtAddr", "string", "vim.version.version2", F_OPTIONAL), ("location", "string", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.host.PhysicalNic.LldpInfo", "LinkLayerDiscoveryProtocolInfo", "vmodl.DynamicData", "vim.version.version7", [("chassisId", "string", "vim.version.version7", 0), ("portId", "string", "vim.version.version7", 0), ("timeToLive", "int", "vim.version.version7", 0), ("parameter", "vmodl.KeyAnyValue[]", "vim.version.version7", F_OPTIONAL)]) +CreateEnumType("vim.host.PhysicalNic.VmDirectPathGen2SupportedMode", "PhysicalNicVmDirectPathGen2SupportedMode", "vim.version.version6", ["upt", "cdpt"]) +CreateEnumType("vim.host.PhysicalNic.ResourcePoolSchedulerDisallowedReason", "PhysicalNicResourcePoolSchedulerDisallowedReason", "vim.version.version6", ["userOptOut", "hardwareUnsupported"]) +CreateDataType("vim.host.PlugStoreTopology", "HostPlugStoreTopology", "vmodl.DynamicData", "vim.version.version5", [("adapter", "vim.host.PlugStoreTopology.Adapter[]", "vim.version.version5", F_LINKABLE | F_OPTIONAL), ("path", "vim.host.PlugStoreTopology.Path[]", "vim.version.version5", F_LINKABLE | F_OPTIONAL), ("target", "vim.host.PlugStoreTopology.Target[]", "vim.version.version5", F_LINKABLE | F_OPTIONAL), ("device", "vim.host.PlugStoreTopology.Device[]", "vim.version.version5", F_LINKABLE | F_OPTIONAL), ("plugin", "vim.host.PlugStoreTopology.Plugin[]", "vim.version.version5", F_LINKABLE | F_OPTIONAL)]) +CreateDataType("vim.host.PlugStoreTopology.Adapter", "HostPlugStoreTopologyAdapter", "vmodl.DynamicData", "vim.version.version5", [("key", "string", "vim.version.version5", 0), ("adapter", "vim.host.HostBusAdapter", "vim.version.version5", F_LINK), ("path", "vim.host.PlugStoreTopology.Path[]", "vim.version.version5", F_LINK | F_OPTIONAL)]) +CreateDataType("vim.host.PlugStoreTopology.Path", "HostPlugStoreTopologyPath", "vmodl.DynamicData", "vim.version.version5", [("key", "string", "vim.version.version5", 0), ("name", "string", "vim.version.version5", 0), ("channelNumber", "int", "vim.version.version5", F_OPTIONAL), ("targetNumber", "int", "vim.version.version5", F_OPTIONAL), ("lunNumber", "int", "vim.version.version5", F_OPTIONAL), ("adapter", "vim.host.PlugStoreTopology.Adapter", "vim.version.version5", F_LINK | F_OPTIONAL), ("target", "vim.host.PlugStoreTopology.Target", "vim.version.version5", F_LINK | F_OPTIONAL), ("device", "vim.host.PlugStoreTopology.Device", "vim.version.version5", F_LINK | F_OPTIONAL)]) +CreateDataType("vim.host.PlugStoreTopology.Device", "HostPlugStoreTopologyDevice", "vmodl.DynamicData", "vim.version.version5", [("key", "string", "vim.version.version5", 0), ("lun", "vim.host.ScsiLun", "vim.version.version5", F_LINK), ("path", "vim.host.PlugStoreTopology.Path[]", "vim.version.version5", F_LINK | F_OPTIONAL)]) +CreateDataType("vim.host.PlugStoreTopology.Plugin", "HostPlugStoreTopologyPlugin", "vmodl.DynamicData", "vim.version.version5", [("key", "string", "vim.version.version5", 0), ("name", "string", "vim.version.version5", 0), ("device", "vim.host.PlugStoreTopology.Device[]", "vim.version.version5", F_LINK | F_OPTIONAL), ("claimedPath", "vim.host.PlugStoreTopology.Path[]", "vim.version.version5", F_LINK | F_OPTIONAL)]) +CreateDataType("vim.host.PlugStoreTopology.Target", "HostPlugStoreTopologyTarget", "vmodl.DynamicData", "vim.version.version5", [("key", "string", "vim.version.version5", 0), ("transport", "vim.host.TargetTransport", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.PortGroup", "HostPortGroup", "vmodl.DynamicData", "vim.version.version1", [("key", "string", "vim.version.version1", F_OPTIONAL), ("port", "vim.host.PortGroup.Port[]", "vim.version.version1", F_LINKABLE | F_OPTIONAL), ("vswitch", "vim.host.VirtualSwitch", "vim.version.version1", F_LINK | F_OPTIONAL), ("computedPolicy", "vim.host.NetworkPolicy", "vim.version.version1", 0), ("spec", "vim.host.PortGroup.Specification", "vim.version.version1", 0)]) +CreateEnumType("vim.host.PortGroup.PortConnecteeType", "PortGroupConnecteeType", "vim.version.version1", ["virtualMachine", "systemManagement", "host", "unknown"]) +CreateDataType("vim.host.PortGroup.Specification", "HostPortGroupSpec", "vmodl.DynamicData", "vim.version.version1", [("name", "string", "vim.version.version1", 0), ("vlanId", "int", "vim.version.version1", 0), ("vswitchName", "string", "vim.version.version1", 0), ("policy", "vim.host.NetworkPolicy", "vim.version.version1", 0)]) +CreateDataType("vim.host.PortGroup.Config", "HostPortGroupConfig", "vmodl.DynamicData", "vim.version.version1", [("changeOperation", "string", "vim.version.version1", F_OPTIONAL), ("spec", "vim.host.PortGroup.Specification", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.PortGroup.Port", "HostPortGroupPort", "vmodl.DynamicData", "vim.version.version1", [("key", "string", "vim.version.version1", F_OPTIONAL), ("mac", "string[]", "vim.version.version1", F_OPTIONAL), ("type", "string", "vim.version.version1", 0)]) +CreateManagedType("vim.host.PowerSystem", "HostPowerSystem", "vmodl.ManagedObject", "vim.version.version6", [("capability", "vim.host.PowerSystem.Capability", "vim.version.version6", 0, "Host.Config.Power"), ("info", "vim.host.PowerSystem.Info", "vim.version.version6", 0, "Host.Config.Power")], [("configurePolicy", "ConfigurePowerPolicy", "vim.version.version6", (("key", "int", "vim.version.version6", 0, None),), (0, "void", "void"), "Host.Config.Power", ["vim.fault.HostConfigFault", ])]) +CreateDataType("vim.host.PowerSystem.PowerPolicy", "HostPowerPolicy", "vmodl.DynamicData", "vim.version.version6", [("key", "int", "vim.version.version6", 0), ("name", "string", "vim.version.version6", 0), ("shortName", "string", "vim.version.version6", 0), ("description", "string", "vim.version.version6", 0)]) +CreateDataType("vim.host.PowerSystem.Capability", "PowerSystemCapability", "vmodl.DynamicData", "vim.version.version6", [("availablePolicy", "vim.host.PowerSystem.PowerPolicy[]", "vim.version.version6", 0)]) +CreateDataType("vim.host.PowerSystem.Info", "PowerSystemInfo", "vmodl.DynamicData", "vim.version.version6", [("currentPolicy", "vim.host.PowerSystem.PowerPolicy", "vim.version.version6", 0)]) +CreateDataType("vim.host.ResignatureRescanResult", "HostResignatureRescanResult", "vmodl.DynamicData", "vim.version.version5", [("rescan", "vim.host.VmfsRescanResult[]", "vim.version.version5", F_OPTIONAL), ("result", "vim.Datastore", "vim.version.version5", 0)]) +CreateDataType("vim.host.Ruleset", "HostFirewallRuleset", "vmodl.DynamicData", "vim.version.version1", [("key", "string", "vim.version.version1", 0), ("label", "string", "vim.version.version1", 0), ("required", "boolean", "vim.version.version1", 0), ("rule", "vim.host.Ruleset.Rule[]", "vim.version.version1", 0), ("service", "string", "vim.version.version1", F_OPTIONAL), ("enabled", "boolean", "vim.version.version1", 0), ("allowedHosts", "vim.host.Ruleset.IpList", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.host.Ruleset.IpNetwork", "HostFirewallRulesetIpNetwork", "vmodl.DynamicData", "vim.version.version7", [("network", "string", "vim.version.version7", 0), ("prefixLength", "int", "vim.version.version7", 0)]) +CreateDataType("vim.host.Ruleset.IpList", "HostFirewallRulesetIpList", "vmodl.DynamicData", "vim.version.version7", [("ipAddress", "string[]", "vim.version.version7", F_OPTIONAL), ("ipNetwork", "vim.host.Ruleset.IpNetwork[]", "vim.version.version7", F_OPTIONAL), ("allIp", "boolean", "vim.version.version7", 0)]) +CreateDataType("vim.host.Ruleset.RulesetSpec", "HostFirewallRulesetRulesetSpec", "vmodl.DynamicData", "vim.version.version7", [("allowedHosts", "vim.host.Ruleset.IpList", "vim.version.version7", 0)]) +CreateDataType("vim.host.Ruleset.Rule", "HostFirewallRule", "vmodl.DynamicData", "vim.version.version1", [("port", "int", "vim.version.version1", 0), ("endPort", "int", "vim.version.version1", F_OPTIONAL), ("direction", "vim.host.Ruleset.Rule.Direction", "vim.version.version1", 0), ("portType", "vim.host.Ruleset.Rule.PortType", "vim.version.version7", F_OPTIONAL), ("protocol", "string", "vim.version.version1", 0)]) +CreateEnumType("vim.host.Ruleset.Rule.Direction", "HostFirewallRuleDirection", "vim.version.version1", ["inbound", "outbound"]) +CreateEnumType("vim.host.Ruleset.Rule.PortType", "HostFirewallRulePortType", "vim.version.version7", ["src", "dst"]) +CreateEnumType("vim.host.Ruleset.Rule.Protocol", "HostFirewallRuleProtocol", "vim.version.version1", ["tcp", "udp"]) +CreateDataType("vim.host.ScsiLun", "ScsiLun", "vim.host.Device", "vim.version.version1", [("key", "string", "vim.version.version1", F_OPTIONAL), ("uuid", "string", "vim.version.version1", 0), ("descriptor", "vim.host.ScsiLun.Descriptor[]", "vim.version.version5", F_OPTIONAL), ("canonicalName", "string", "vim.version.version1", F_OPTIONAL), ("displayName", "string", "vim.version.version5", F_OPTIONAL), ("lunType", "string", "vim.version.version1", 0), ("vendor", "string", "vim.version.version1", F_OPTIONAL), ("model", "string", "vim.version.version1", F_OPTIONAL), ("revision", "string", "vim.version.version1", F_OPTIONAL), ("scsiLevel", "int", "vim.version.version1", F_OPTIONAL), ("serialNumber", "string", "vim.version.version1", F_OPTIONAL), ("durableName", "vim.host.ScsiLun.DurableName", "vim.version.version1", F_OPTIONAL), ("alternateName", "vim.host.ScsiLun.DurableName[]", "vim.version.version2", F_OPTIONAL), ("standardInquiry", "byte[]", "vim.version.version2", F_OPTIONAL), ("queueDepth", "int", "vim.version.version1", F_OPTIONAL), ("operationalState", "string[]", "vim.version.version1", 0), ("capabilities", "vim.host.ScsiLun.Capabilities", "vim.version.version5", F_OPTIONAL), ("vStorageSupport", "string", "vim.version.version6", F_OPTIONAL)]) +CreateEnumType("vim.host.ScsiLun.ScsiLunType", "ScsiLunType", "vim.version.version1", ["disk", "tape", "printer", "processor", "worm", "cdrom", "scanner", "opticalDevice", "mediaChanger", "communications", "storageArrayController", "enclosure", "unknown"]) +CreateDataType("vim.host.ScsiLun.Capabilities", "ScsiLunCapabilities", "vmodl.DynamicData", "vim.version.version5", [("updateDisplayNameSupported", "boolean", "vim.version.version5", 0)]) +CreateDataType("vim.host.ScsiLun.DurableName", "ScsiLunDurableName", "vmodl.DynamicData", "vim.version.version1", [("namespace", "string", "vim.version.version1", 0), ("namespaceId", "byte", "vim.version.version1", 0), ("data", "byte[]", "vim.version.version1", F_OPTIONAL)]) +CreateEnumType("vim.host.ScsiLun.State", "ScsiLunState", "vim.version.version1", ["unknownState", "ok", "error", "off", "quiesced", "degraded", "lostCommunication", "timeout"]) +CreateEnumType("vim.host.ScsiLun.DescriptorQuality", "ScsiLunDescriptorQuality", "vim.version.version5", ["highQuality", "mediumQuality", "lowQuality", "unknownQuality"]) +CreateDataType("vim.host.ScsiLun.Descriptor", "ScsiLunDescriptor", "vmodl.DynamicData", "vim.version.version5", [("quality", "string", "vim.version.version5", 0), ("id", "string", "vim.version.version5", 0)]) +CreateEnumType("vim.host.ScsiLun.VStorageSupportStatus", "ScsiLunVStorageSupportStatus", "vim.version.version6", ["vStorageSupported", "vStorageUnsupported", "vStorageUnknown"]) +CreateDataType("vim.host.ScsiTopology", "HostScsiTopology", "vmodl.DynamicData", "vim.version.version1", [("adapter", "vim.host.ScsiTopology.Interface[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.ScsiTopology.Interface", "HostScsiTopologyInterface", "vmodl.DynamicData", "vim.version.version1", [("key", "string", "vim.version.version1", 0), ("adapter", "vim.host.HostBusAdapter", "vim.version.version1", F_LINK), ("target", "vim.host.ScsiTopology.Target[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.ScsiTopology.Target", "HostScsiTopologyTarget", "vmodl.DynamicData", "vim.version.version1", [("key", "string", "vim.version.version1", 0), ("target", "int", "vim.version.version1", 0), ("lun", "vim.host.ScsiTopology.Lun[]", "vim.version.version1", F_OPTIONAL), ("transport", "vim.host.TargetTransport", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.ScsiTopology.Lun", "HostScsiTopologyLun", "vmodl.DynamicData", "vim.version.version1", [("key", "string", "vim.version.version1", 0), ("lun", "int", "vim.version.version1", 0), ("scsiLun", "vim.host.ScsiLun", "vim.version.version1", F_LINK)]) +CreateDataType("vim.host.Service", "HostService", "vmodl.DynamicData", "vim.version.version1", [("key", "string", "vim.version.version1", 0), ("label", "string", "vim.version.version1", 0), ("required", "boolean", "vim.version.version1", 0), ("uninstallable", "boolean", "vim.version.version1", 0), ("running", "boolean", "vim.version.version1", 0), ("ruleset", "string[]", "vim.version.version1", F_OPTIONAL), ("policy", "string", "vim.version.version1", 0), ("sourcePackage", "vim.host.Service.SourcePackage", "vim.version.version7", F_OPTIONAL)]) +CreateEnumType("vim.host.Service.Policy", "HostServicePolicy", "vim.version.version1", ["on", "automatic", "off"]) +CreateDataType("vim.host.Service.SourcePackage", "HostServiceSourcePackage", "vmodl.DynamicData", "vim.version.version7", [("sourcePackageName", "string", "vim.version.version7", 0), ("description", "string", "vim.version.version7", 0)]) +CreateDataType("vim.host.ServiceConfig", "HostServiceConfig", "vmodl.DynamicData", "vim.version.version5", [("serviceId", "string", "vim.version.version5", 0), ("startupPolicy", "string", "vim.version.version5", 0)]) +CreateDataType("vim.host.ServiceInfo", "HostServiceInfo", "vmodl.DynamicData", "vim.version.version1", [("service", "vim.host.Service[]", "vim.version.version1", F_OPTIONAL)]) +CreateManagedType("vim.host.ServiceSystem", "HostServiceSystem", "vim.ExtensibleManagedObject", "vim.version.version1", [("serviceInfo", "vim.host.ServiceInfo", "vim.version.version1", 0, None)], [("updatePolicy", "UpdateServicePolicy", "vim.version.version1", (("id", "string", "vim.version.version1", 0, None),("policy", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.NetService", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("start", "StartService", "vim.version.version1", (("id", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.NetService", ["vim.fault.InvalidState", "vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("stop", "StopService", "vim.version.version1", (("id", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.NetService", ["vim.fault.InvalidState", "vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("restart", "RestartService", "vim.version.version1", (("id", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.NetService", ["vim.fault.InvalidState", "vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("uninstall", "UninstallService", "vim.version.version1", (("id", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.NetService", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("refresh", "RefreshServices", "vim.version.version1", (), (0, "void", "void"), "Host.Config.NetService", None)]) +CreateEnumType("vim.host.SignatureInfo.SigningMethodType", "HostSignatureInfoSigningMethodType", "vim.version.version5", ["DSA_SHA1", "RSA_SHA1", "RSA_MD5"]) +CreateManagedType("vim.host.SnmpSystem", "HostSnmpSystem", "vmodl.ManagedObject", "vim.version.version1", [("configuration", "vim.host.SnmpSystem.SnmpConfigSpec", "vim.version.version2", 0, "Global.Settings"), ("limits", "vim.host.SnmpSystem.AgentLimits", "vim.version.version2", 0, "Global.Settings")], [("reconfigureSnmpAgent", "ReconfigureSnmpAgent", "vim.version.version2", (("spec", "vim.host.SnmpSystem.SnmpConfigSpec", "vim.version.version2", 0, None),), (0, "void", "void"), "Global.Settings", ["vim.fault.NotFound", "vim.fault.InsufficientResourcesFault", ]), ("sendTestNotification", "SendTestNotification", "vim.version.version2", (), (0, "void", "void"), "Global.Settings", ["vim.fault.NotFound", "vim.fault.InsufficientResourcesFault", ])]) +CreateDataType("vim.host.SnmpSystem.SnmpConfigSpec", "HostSnmpConfigSpec", "vmodl.DynamicData", "vim.version.version2", [("enabled", "boolean", "vim.version.version2", F_OPTIONAL), ("port", "int", "vim.version.version2", F_OPTIONAL), ("readOnlyCommunities", "string[]", "vim.version.version2", F_OPTIONAL), ("trapTargets", "vim.host.SnmpSystem.SnmpConfigSpec.Destination[]", "vim.version.version2", F_OPTIONAL), ("option", "vim.KeyValue[]", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.host.SnmpSystem.SnmpConfigSpec.Destination", "HostSnmpDestination", "vmodl.DynamicData", "vim.version.version1", [("hostName", "string", "vim.version.version1", 0), ("port", "int", "vim.version.version1", 0), ("community", "string", "vim.version.version1", 0)]) +CreateDataType("vim.host.SnmpSystem.AgentLimits", "HostSnmpSystemAgentLimits", "vmodl.DynamicData", "vim.version.version2", [("maxReadOnlyCommunities", "int", "vim.version.version2", 0), ("maxTrapDestinations", "int", "vim.version.version2", 0), ("maxCommunityLength", "int", "vim.version.version2", 0), ("maxBufferSize", "int", "vim.version.version2", 0), ("capability", "vim.host.SnmpSystem.AgentLimits.Capability", "vim.version.version5", 0)]) +CreateEnumType("vim.host.SnmpSystem.AgentLimits.Capability", "HostSnmpAgentCapability", "vim.version.version5", ["COMPLETE", "DIAGNOSTICS", "CONFIGURATION"]) +CreateDataType("vim.host.SriovConfig", "HostSriovConfig", "vim.host.PciPassthruConfig", "vim.version.version9", [("sriovEnabled", "boolean", "vim.version.version9", 0), ("numVirtualFunction", "int", "vim.version.version9", 0)]) +CreateDataType("vim.host.SriovInfo", "HostSriovInfo", "vim.host.PciPassthruInfo", "vim.version.version9", [("sriovEnabled", "boolean", "vim.version.version9", 0), ("sriovCapable", "boolean", "vim.version.version9", 0), ("sriovActive", "boolean", "vim.version.version9", 0), ("numVirtualFunctionRequested", "int", "vim.version.version9", 0), ("numVirtualFunction", "int", "vim.version.version9", 0), ("maxVirtualFunctionSupported", "int", "vim.version.version9", 0)]) +CreateDataType("vim.host.SslThumbprintInfo", "HostSslThumbprintInfo", "vmodl.DynamicData", "vim.version.version5", [("principal", "string", "vim.version.version5", 0), ("ownerTag", "string", "vim.version.version7", 0), ("sslThumbprints", "string[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.StorageArrayTypePolicyOption", "HostStorageArrayTypePolicyOption", "vmodl.DynamicData", "vim.version.version5", [("policy", "vim.ElementDescription", "vim.version.version5", 0)]) +CreateDataType("vim.host.StorageDeviceInfo", "HostStorageDeviceInfo", "vmodl.DynamicData", "vim.version.version1", [("hostBusAdapter", "vim.host.HostBusAdapter[]", "vim.version.version1", F_LINKABLE | F_OPTIONAL), ("scsiLun", "vim.host.ScsiLun[]", "vim.version.version1", F_LINKABLE | F_OPTIONAL), ("scsiTopology", "vim.host.ScsiTopology", "vim.version.version1", F_OPTIONAL), ("multipathInfo", "vim.host.MultipathInfo", "vim.version.version1", F_OPTIONAL), ("plugStoreTopology", "vim.host.PlugStoreTopology", "vim.version.version5", F_OPTIONAL), ("softwareInternetScsiEnabled", "boolean", "vim.version.version1", 0)]) +CreateEnumType("vim.host.SystemDebugManager.ProcessKey", "HostSystemDebugManagerProcessKey", "vim.version.version5", ["hostd"]) +CreateDataType("vim.host.SystemHealthInfo", "HostSystemHealthInfo", "vmodl.DynamicData", "vim.version.version2", [("numericSensorInfo", "vim.host.NumericSensorInfo[]", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.host.SystemIdentificationInfo", "HostSystemIdentificationInfo", "vmodl.DynamicData", "vim.version.version2", [("identifierValue", "string", "vim.version.version2", 0), ("identifierType", "vim.ElementDescription", "vim.version.version2", 0)]) +CreateEnumType("vim.host.SystemIdentificationInfo.Identifier", "HostSystemIdentificationInfoIdentifier", "vim.version.version2", ["AssetTag", "ServiceTag", "OemSpecificString"]) +CreateDataType("vim.host.SystemResourceInfo", "HostSystemResourceInfo", "vmodl.DynamicData", "vim.version.version1", [("key", "string", "vim.version.version1", 0), ("config", "vim.ResourceConfigSpec", "vim.version.version1", F_OPTIONAL), ("child", "vim.host.SystemResourceInfo[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.SystemSwapConfiguration", "HostSystemSwapConfiguration", "vmodl.DynamicData", "vim.version.version8", [("option", "vim.host.SystemSwapConfiguration.SystemSwapOption[]", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.host.SystemSwapConfiguration.SystemSwapOption", "HostSystemSwapConfigurationSystemSwapOption", "vmodl.DynamicData", "vim.version.version8", [("key", "int", "vim.version.version8", 0)]) +CreateDataType("vim.host.SystemSwapConfiguration.DisabledOption", "HostSystemSwapConfigurationDisabledOption", "vim.host.SystemSwapConfiguration.SystemSwapOption", "vim.version.version8", None) +CreateDataType("vim.host.SystemSwapConfiguration.HostCacheOption", "HostSystemSwapConfigurationHostCacheOption", "vim.host.SystemSwapConfiguration.SystemSwapOption", "vim.version.version8", None) +CreateDataType("vim.host.SystemSwapConfiguration.HostLocalSwapOption", "HostSystemSwapConfigurationHostLocalSwapOption", "vim.host.SystemSwapConfiguration.SystemSwapOption", "vim.version.version8", None) +CreateDataType("vim.host.SystemSwapConfiguration.DatastoreOption", "HostSystemSwapConfigurationDatastoreOption", "vim.host.SystemSwapConfiguration.SystemSwapOption", "vim.version.version8", [("datastore", "string", "vim.version.version8", 0)]) +CreateDataType("vim.host.TargetTransport", "HostTargetTransport", "vmodl.DynamicData", "vim.version.version1", None) +CreateDataType("vim.host.ParallelScsiTargetTransport", "HostParallelScsiTargetTransport", "vim.host.TargetTransport", "vim.version.version1", None) +CreateDataType("vim.host.BlockAdapterTargetTransport", "HostBlockAdapterTargetTransport", "vim.host.TargetTransport", "vim.version.version1", None) +CreateDataType("vim.host.FibreChannelTargetTransport", "HostFibreChannelTargetTransport", "vim.host.TargetTransport", "vim.version.version1", [("portWorldWideName", "long", "vim.version.version1", 0), ("nodeWorldWideName", "long", "vim.version.version1", 0)]) +CreateDataType("vim.host.InternetScsiTargetTransport", "HostInternetScsiTargetTransport", "vim.host.TargetTransport", "vim.version.version1", [("iScsiName", "string", "vim.version.version1", 0), ("iScsiAlias", "string", "vim.version.version1", 0), ("address", "string[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.FibreChannelOverEthernetTargetTransport", "HostFibreChannelOverEthernetTargetTransport", "vim.host.FibreChannelTargetTransport", "vim.version.version7", [("vnportMac", "string", "vim.version.version7", 0), ("fcfMac", "string", "vim.version.version7", 0), ("vlanId", "int", "vim.version.version7", 0)]) +CreateDataType("vim.host.TpmAttestationReport", "HostTpmAttestationReport", "vmodl.DynamicData", "vim.version.version8", [("tpmPcrValues", "vim.host.TpmDigestInfo[]", "vim.version.version8", 0), ("tpmEvents", "vim.host.TpmEventLogEntry[]", "vim.version.version8", 0), ("tpmLogReliable", "boolean", "vim.version.version8", 0)]) +CreateDataType("vim.host.DigestInfo", "HostDigestInfo", "vmodl.DynamicData", "vim.version.version5", [("digestMethod", "string", "vim.version.version5", 0), ("digestValue", "byte[]", "vim.version.version5", 0), ("objectName", "string", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.host.DigestInfo.DigestMethodType", "HostDigestInfoDigestMethodType", "vim.version.version5", ["SHA1", "MD5"]) +CreateDataType("vim.host.TpmDigestInfo", "HostTpmDigestInfo", "vim.host.DigestInfo", "vim.version.version5", [("pcrNumber", "int", "vim.version.version5", 0)]) +CreateDataType("vim.host.TpmEventDetails", "HostTpmEventDetails", "vmodl.DynamicData", "vim.version.version8", [("dataHash", "byte[]", "vim.version.version8", 0)]) +CreateDataType("vim.host.TpmEventLogEntry", "HostTpmEventLogEntry", "vmodl.DynamicData", "vim.version.version8", [("pcrIndex", "int", "vim.version.version8", 0), ("eventDetails", "vim.host.TpmEventDetails", "vim.version.version8", 0)]) +CreateDataType("vim.host.TpmOptionEventDetails", "HostTpmOptionEventDetails", "vim.host.TpmEventDetails", "vim.version.version8", [("optionsFileName", "string", "vim.version.version8", 0), ("bootOptions", "byte[]", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.host.TpmSoftwareComponentEventDetails", "HostTpmSoftwareComponentEventDetails", "vim.host.TpmEventDetails", "vim.version.version8", [("componentName", "string", "vim.version.version8", 0), ("vibName", "string", "vim.version.version8", 0), ("vibVersion", "string", "vim.version.version8", 0), ("vibVendor", "string", "vim.version.version8", 0)]) +CreateDataType("vim.host.UnresolvedVmfsResignatureSpec", "HostUnresolvedVmfsResignatureSpec", "vmodl.DynamicData", "vim.version.version5", [("extentDevicePath", "string[]", "vim.version.version5", 0)]) +CreateDataType("vim.host.UnresolvedVmfsResolutionResult", "HostUnresolvedVmfsResolutionResult", "vmodl.DynamicData", "vim.version.version5", [("spec", "vim.host.UnresolvedVmfsResolutionSpec", "vim.version.version5", 0), ("vmfs", "vim.host.VmfsVolume", "vim.version.version5", F_OPTIONAL), ("fault", "vmodl.MethodFault", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.UnresolvedVmfsResolutionSpec", "HostUnresolvedVmfsResolutionSpec", "vmodl.DynamicData", "vim.version.version5", [("extentDevicePath", "string[]", "vim.version.version5", 0), ("uuidResolution", "string", "vim.version.version5", 0)]) +CreateEnumType("vim.host.UnresolvedVmfsResolutionSpec.VmfsUuidResolution", "HostUnresolvedVmfsResolutionSpecVmfsUuidResolution", "vim.version.version5", ["resignature", "forceMount"]) +CreateDataType("vim.host.UnresolvedVmfsVolume", "HostUnresolvedVmfsVolume", "vmodl.DynamicData", "vim.version.version5", [("extent", "vim.host.UnresolvedVmfsExtent[]", "vim.version.version5", 0), ("vmfsLabel", "string", "vim.version.version5", 0), ("vmfsUuid", "string", "vim.version.version5", 0), ("totalBlocks", "int", "vim.version.version5", 0), ("resolveStatus", "vim.host.UnresolvedVmfsVolume.ResolveStatus", "vim.version.version5", 0)]) +CreateDataType("vim.host.UnresolvedVmfsVolume.ResolveStatus", "HostUnresolvedVmfsVolumeResolveStatus", "vmodl.DynamicData", "vim.version.version5", [("resolvable", "boolean", "vim.version.version5", 0), ("incompleteExtents", "boolean", "vim.version.version5", F_OPTIONAL), ("multipleCopies", "boolean", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.VFlashResourceConfigurationResult", "HostVFlashResourceConfigurationResult", "vmodl.DynamicData", "vim.version.version9", [("devicePath", "string[]", "vim.version.version9", F_OPTIONAL), ("vffs", "vim.host.VffsVolume", "vim.version.version9", F_OPTIONAL), ("diskConfigurationResult", "vim.host.DiskConfigurationResult[]", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.host.VMotionConfig", "HostVMotionConfig", "vmodl.DynamicData", "vim.version.version1", [("vmotionNicKey", "string", "vim.version.version1", F_OPTIONAL), ("enabled", "boolean", "vim.version.version1", 0)]) +CreateManagedType("vim.host.VMotionSystem", "HostVMotionSystem", "vim.ExtensibleManagedObject", "vim.version.version1", [("netConfig", "vim.host.VMotionSystem.NetConfig", "vim.version.version1", F_OPTIONAL, None), ("ipConfig", "vim.host.IpConfig", "vim.version.version1", F_OPTIONAL, None)], [("updateIpConfig", "UpdateIpConfig", "vim.version.version1", (("ipConfig", "vim.host.IpConfig", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Network", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("selectVnic", "SelectVnic", "vim.version.version1", (("device", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Network", ["vim.fault.HostConfigFault", ]), ("deselectVnic", "DeselectVnic", "vim.version.version1", (), (0, "void", "void"), "Host.Config.Network", ["vim.fault.HostConfigFault", ])]) +CreateDataType("vim.host.VMotionSystem.NetConfig", "HostVMotionNetConfig", "vmodl.DynamicData", "vim.version.version1", [("candidateVnic", "vim.host.VirtualNic[]", "vim.version.version1", F_LINKABLE | F_OPTIONAL), ("selectedVnic", "vim.host.VirtualNic", "vim.version.version1", F_LINK | F_OPTIONAL)]) +CreateDataType("vim.host.VirtualNic", "HostVirtualNic", "vmodl.DynamicData", "vim.version.version1", [("device", "string", "vim.version.version1", 0), ("key", "string", "vim.version.version1", 0), ("portgroup", "string", "vim.version.version1", 0), ("spec", "vim.host.VirtualNic.Specification", "vim.version.version1", 0), ("port", "vim.host.PortGroup.Port", "vim.version.version1", F_LINK | F_OPTIONAL)]) +CreateDataType("vim.host.VirtualNic.Specification", "HostVirtualNicSpec", "vmodl.DynamicData", "vim.version.version1", [("ip", "vim.host.IpConfig", "vim.version.version1", F_OPTIONAL), ("mac", "string", "vim.version.version1", F_OPTIONAL), ("distributedVirtualPort", "vim.dvs.PortConnection", "vim.version.version5", F_OPTIONAL), ("portgroup", "string", "vim.version.version5", F_OPTIONAL), ("mtu", "int", "vim.version.version5", F_OPTIONAL), ("tsoEnabled", "boolean", "vim.version.version5", F_OPTIONAL), ("netStackInstanceKey", "string", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.host.VirtualNic.Config", "HostVirtualNicConfig", "vmodl.DynamicData", "vim.version.version1", [("changeOperation", "string", "vim.version.version1", F_OPTIONAL), ("device", "string", "vim.version.version1", F_OPTIONAL), ("portgroup", "string", "vim.version.version1", 0), ("spec", "vim.host.VirtualNic.Specification", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.VirtualNicConnection", "HostVirtualNicConnection", "vmodl.DynamicData", "vim.version.version5", [("portgroup", "string", "vim.version.version5", F_OPTIONAL), ("dvPort", "vim.dvs.PortConnection", "vim.version.version5", F_OPTIONAL)]) +CreateManagedType("vim.host.VirtualNicManager", "HostVirtualNicManager", "vim.ExtensibleManagedObject", "vim.version.version5", [("info", "vim.host.VirtualNicManagerInfo", "vim.version.version5", 0, None)], [("queryNetConfig", "QueryNetConfig", "vim.version.version5", (("nicType", "string", "vim.version.version5", 0, None),), (F_OPTIONAL, "vim.host.VirtualNicManager.NetConfig", "vim.host.VirtualNicManager.NetConfig"), "Host.Config.Network", ["vim.fault.HostConfigFault", "vmodl.fault.InvalidArgument", ]), ("selectVnic", "SelectVnicForNicType", "vim.version.version5", (("nicType", "string", "vim.version.version5", 0, None),("device", "string", "vim.version.version5", 0, None),), (0, "void", "void"), "Host.Config.Network", ["vim.fault.HostConfigFault", "vmodl.fault.InvalidArgument", ]), ("deselectVnic", "DeselectVnicForNicType", "vim.version.version5", (("nicType", "string", "vim.version.version5", 0, None),("device", "string", "vim.version.version5", 0, None),), (0, "void", "void"), "Host.Config.Network", ["vim.fault.HostConfigFault", "vmodl.fault.InvalidArgument", ])]) +CreateEnumType("vim.host.VirtualNicManager.NicType", "HostVirtualNicManagerNicType", "vim.version.version5", ["vmotion", "faultToleranceLogging", "vSphereReplication", "vSphereReplicationNFC", "management", "vsan"]) +CreateDataType("vim.host.VirtualNicManager.NicTypeSelection", "HostVirtualNicManagerNicTypeSelection", "vmodl.DynamicData", "vim.version.version5", [("vnic", "vim.host.VirtualNicConnection", "vim.version.version5", 0), ("nicType", "string[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.VirtualNicManager.NetConfig", "VirtualNicManagerNetConfig", "vmodl.DynamicData", "vim.version.version5", [("nicType", "string", "vim.version.version5", 0), ("multiSelectAllowed", "boolean", "vim.version.version5", 0), ("candidateVnic", "vim.host.VirtualNic[]", "vim.version.version5", F_LINKABLE | F_OPTIONAL), ("selectedVnic", "vim.host.VirtualNic[]", "vim.version.version5", F_LINK | F_OPTIONAL)]) +CreateDataType("vim.host.VirtualNicManagerInfo", "HostVirtualNicManagerInfo", "vmodl.DynamicData", "vim.version.version5", [("netConfig", "vim.host.VirtualNicManager.NetConfig[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.VirtualSwitch", "HostVirtualSwitch", "vmodl.DynamicData", "vim.version.version1", [("name", "string", "vim.version.version1", 0), ("key", "string", "vim.version.version1", 0), ("numPorts", "int", "vim.version.version1", 0), ("numPortsAvailable", "int", "vim.version.version1", 0), ("mtu", "int", "vim.version.version2", F_OPTIONAL), ("portgroup", "vim.host.PortGroup[]", "vim.version.version1", F_LINK | F_OPTIONAL), ("pnic", "vim.host.PhysicalNic[]", "vim.version.version1", F_LINK | F_OPTIONAL), ("spec", "vim.host.VirtualSwitch.Specification", "vim.version.version1", 0)]) +CreateDataType("vim.host.VirtualSwitch.Bridge", "HostVirtualSwitchBridge", "vmodl.DynamicData", "vim.version.version1", None) +CreateDataType("vim.host.VirtualSwitch.AutoBridge", "HostVirtualSwitchAutoBridge", "vim.host.VirtualSwitch.Bridge", "vim.version.version1", [("excludedNicDevice", "string[]", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.host.VirtualSwitch.SimpleBridge", "HostVirtualSwitchSimpleBridge", "vim.host.VirtualSwitch.Bridge", "vim.version.version1", [("nicDevice", "string", "vim.version.version1", 0)]) +CreateDataType("vim.host.VirtualSwitch.BondBridge", "HostVirtualSwitchBondBridge", "vim.host.VirtualSwitch.Bridge", "vim.version.version1", [("nicDevice", "string[]", "vim.version.version1", 0), ("beacon", "vim.host.VirtualSwitch.BeaconConfig", "vim.version.version1", F_OPTIONAL), ("linkDiscoveryProtocolConfig", "vim.host.LinkDiscoveryProtocolConfig", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.VirtualSwitch.BeaconConfig", "HostVirtualSwitchBeaconConfig", "vmodl.DynamicData", "vim.version.version1", [("interval", "int", "vim.version.version1", 0)]) +CreateDataType("vim.host.VirtualSwitch.Specification", "HostVirtualSwitchSpec", "vmodl.DynamicData", "vim.version.version1", [("numPorts", "int", "vim.version.version1", 0), ("bridge", "vim.host.VirtualSwitch.Bridge", "vim.version.version1", F_OPTIONAL), ("policy", "vim.host.NetworkPolicy", "vim.version.version1", F_OPTIONAL), ("mtu", "int", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.host.VirtualSwitch.Config", "HostVirtualSwitchConfig", "vmodl.DynamicData", "vim.version.version1", [("changeOperation", "string", "vim.version.version1", F_OPTIONAL), ("name", "string", "vim.version.version1", 0), ("spec", "vim.host.VirtualSwitch.Specification", "vim.version.version1", F_OPTIONAL)]) +CreateEnumType("vim.host.VmciAccessManager.Mode", "HostVmciAccessManagerMode", "vim.version.version7", ["grant", "replace", "revoke"]) +CreateDataType("vim.host.VmciAccessManager.AccessSpec", "HostVmciAccessManagerAccessSpec", "vmodl.DynamicData", "vim.version.version7", [("vm", "vim.VirtualMachine", "vim.version.version7", 0), ("services", "string[]", "vim.version.version7", F_OPTIONAL), ("mode", "string", "vim.version.version7", 0)]) +CreateDataType("vim.host.VmfsRescanResult", "HostVmfsRescanResult", "vmodl.DynamicData", "vim.version.version5", [("host", "vim.HostSystem", "vim.version.version5", 0), ("fault", "vmodl.MethodFault", "vim.version.version5", F_OPTIONAL)]) +CreateManagedType("vim.host.VsanInternalSystem", "HostVsanInternalSystem", "vmodl.ManagedObject", "vim.version.version9", None, [("queryCmmds", "QueryCmmds", "vim.version.version9", (("queries", "vim.host.VsanInternalSystem.CmmdsQuery[]", "vim.version.version9", 0, None),), (0, "string", "string"), "System.Read", None), ("queryPhysicalVsanDisks", "QueryPhysicalVsanDisks", "vim.version.version9", (("props", "string[]", "vim.version.version9", F_OPTIONAL, None),), (0, "string", "string"), "System.Read", None), ("queryVsanObjects", "QueryVsanObjects", "vim.version.version9", (("uuids", "string[]", "vim.version.version9", F_OPTIONAL, None),), (0, "string", "string"), "System.Read", None), ("queryObjectsOnPhysicalVsanDisk", "QueryObjectsOnPhysicalVsanDisk", "vim.version.version9", (("disks", "string[]", "vim.version.version9", 0, None),), (0, "string", "string"), "System.Read", None)]) +CreateDataType("vim.host.VsanInternalSystem.CmmdsQuery", "HostVsanInternalSystemCmmdsQuery", "vmodl.DynamicData", "vim.version.version9", [("type", "string", "vim.version.version9", F_OPTIONAL), ("uuid", "string", "vim.version.version9", F_OPTIONAL), ("owner", "string", "vim.version.version9", F_OPTIONAL)]) +CreateManagedType("vim.host.VsanSystem", "HostVsanSystem", "vmodl.ManagedObject", "vim.version.version9", [("config", "vim.vsan.host.ConfigInfo", "vim.version.version9", 0, "System.Read")], [("queryDisksForVsan", "QueryDisksForVsan", "vim.version.version9", (("canonicalName", "string[]", "vim.version.version9", F_OPTIONAL, None),), (F_OPTIONAL, "vim.vsan.host.DiskResult[]", "vim.vsan.host.DiskResult[]"), "System.Read", None), ("addDisks", "AddDisks_Task", "vim.version.version9", (("disk", "vim.host.ScsiDisk[]", "vim.version.version9", 0, None),), (F_OPTIONAL, "vim.Task", "vim.vsan.host.DiskMapResult[]"), "Host.Config.Storage", None), ("initializeDisks", "InitializeDisks_Task", "vim.version.version9", (("mapping", "vim.vsan.host.DiskMapping[]", "vim.version.version9", 0, None),), (F_OPTIONAL, "vim.Task", "vim.vsan.host.DiskMapResult[]"), "Host.Config.Storage", None), ("removeDisk", "RemoveDisk_Task", "vim.version.version9", (("disk", "vim.host.ScsiDisk[]", "vim.version.version9", 0, None),), (F_OPTIONAL, "vim.Task", "vim.vsan.host.DiskResult[]"), "Host.Config.Storage", None), ("removeDiskMapping", "RemoveDiskMapping_Task", "vim.version.version9", (("mapping", "vim.vsan.host.DiskMapping[]", "vim.version.version9", 0, None),), (F_OPTIONAL, "vim.Task", "vim.vsan.host.DiskMapResult[]"), "Host.Config.Storage", None), ("update", "UpdateVsan_Task", "vim.version.version9", (("config", "vim.vsan.host.ConfigInfo", "vim.version.version9", 0, None),), (0, "vim.Task", "void"), "Host.Config.Storage", None), ("queryHostStatus", "QueryHostStatus", "vim.version.version9", (), (0, "vim.vsan.host.ClusterStatus", "vim.vsan.host.ClusterStatus"), "System.Read", None)]) +CreateDataType("vim.net.DhcpConfigInfo", "NetDhcpConfigInfo", "vmodl.DynamicData", "vim.version.version6", [("ipv6", "vim.net.DhcpConfigInfo.DhcpOptions", "vim.version.version6", F_OPTIONAL), ("ipv4", "vim.net.DhcpConfigInfo.DhcpOptions", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.net.DhcpConfigInfo.DhcpOptions", "NetDhcpConfigInfoDhcpOptions", "vmodl.DynamicData", "vim.version.version6", [("enable", "boolean", "vim.version.version6", 0), ("config", "vim.KeyValue[]", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.net.DhcpConfigSpec", "NetDhcpConfigSpec", "vmodl.DynamicData", "vim.version.version6", [("ipv6", "vim.net.DhcpConfigSpec.DhcpOptionsSpec", "vim.version.version6", F_OPTIONAL), ("ipv4", "vim.net.DhcpConfigSpec.DhcpOptionsSpec", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.net.DhcpConfigSpec.DhcpOptionsSpec", "NetDhcpConfigSpecDhcpOptionsSpec", "vmodl.DynamicData", "vim.version.version6", [("enable", "boolean", "vim.version.version6", F_OPTIONAL), ("config", "vim.KeyValue[]", "vim.version.version6", 0), ("operation", "string", "vim.version.version6", 0)]) +CreateDataType("vim.net.DnsConfigInfo", "NetDnsConfigInfo", "vmodl.DynamicData", "vim.version.version6", [("dhcp", "boolean", "vim.version.version6", 0), ("hostName", "string", "vim.version.version6", 0), ("domainName", "string", "vim.version.version6", 0), ("ipAddress", "string[]", "vim.version.version6", F_OPTIONAL), ("searchDomain", "string[]", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.net.DnsConfigSpec", "NetDnsConfigSpec", "vmodl.DynamicData", "vim.version.version6", [("dhcp", "boolean", "vim.version.version6", F_OPTIONAL), ("hostName", "string", "vim.version.version6", F_OPTIONAL), ("domainName", "string", "vim.version.version6", F_OPTIONAL), ("ipAddress", "string[]", "vim.version.version6", F_OPTIONAL), ("searchDomain", "string[]", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.net.IpConfigInfo", "NetIpConfigInfo", "vmodl.DynamicData", "vim.version.version6", [("ipAddress", "vim.net.IpConfigInfo.IpAddress[]", "vim.version.version6", F_OPTIONAL), ("dhcp", "vim.net.DhcpConfigInfo", "vim.version.version6", F_OPTIONAL), ("autoConfigurationEnabled", "boolean", "vim.version.version6", F_OPTIONAL)]) +CreateEnumType("vim.net.IpConfigInfo.IpAddressOrigin", "NetIpConfigInfoIpAddressOrigin", "vim.version.version6", ["other", "manual", "dhcp", "linklayer", "random"]) +CreateEnumType("vim.net.IpConfigInfo.IpAddressStatus", "NetIpConfigInfoIpAddressStatus", "vim.version.version6", ["preferred", "deprecated", "invalid", "inaccessible", "unknown", "tentative", "duplicate"]) +CreateDataType("vim.net.IpConfigInfo.IpAddress", "NetIpConfigInfoIpAddress", "vmodl.DynamicData", "vim.version.version6", [("ipAddress", "string", "vim.version.version6", 0), ("prefixLength", "int", "vim.version.version6", 0), ("origin", "string", "vim.version.version6", F_OPTIONAL), ("state", "string", "vim.version.version6", F_OPTIONAL), ("lifetime", "vmodl.DateTime", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.net.IpConfigSpec", "NetIpConfigSpec", "vmodl.DynamicData", "vim.version.version6", [("ipAddress", "vim.net.IpConfigSpec.IpAddressSpec[]", "vim.version.version6", F_OPTIONAL), ("dhcp", "vim.net.DhcpConfigSpec", "vim.version.version6", F_OPTIONAL), ("autoConfigurationEnabled", "boolean", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.net.IpConfigSpec.IpAddressSpec", "NetIpConfigSpecIpAddressSpec", "vmodl.DynamicData", "vim.version.version6", [("ipAddress", "string", "vim.version.version6", 0), ("prefixLength", "int", "vim.version.version6", 0), ("operation", "string", "vim.version.version6", 0)]) +CreateDataType("vim.net.IpRouteConfigInfo", "NetIpRouteConfigInfo", "vmodl.DynamicData", "vim.version.version6", [("ipRoute", "vim.net.IpRouteConfigInfo.IpRoute[]", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.net.IpRouteConfigInfo.Gateway", "NetIpRouteConfigInfoGateway", "vmodl.DynamicData", "vim.version.version6", [("ipAddress", "string", "vim.version.version6", F_OPTIONAL), ("device", "string", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.net.IpRouteConfigInfo.IpRoute", "NetIpRouteConfigInfoIpRoute", "vmodl.DynamicData", "vim.version.version6", [("network", "string", "vim.version.version6", 0), ("prefixLength", "int", "vim.version.version6", 0), ("gateway", "vim.net.IpRouteConfigInfo.Gateway", "vim.version.version6", 0)]) +CreateDataType("vim.net.IpRouteConfigSpec", "NetIpRouteConfigSpec", "vmodl.DynamicData", "vim.version.version6", [("ipRoute", "vim.net.IpRouteConfigSpec.IpRouteSpec[]", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.net.IpRouteConfigSpec.GatewaySpec", "NetIpRouteConfigSpecGatewaySpec", "vmodl.DynamicData", "vim.version.version6", [("ipAddress", "string", "vim.version.version6", F_OPTIONAL), ("device", "string", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.net.IpRouteConfigSpec.IpRouteSpec", "NetIpRouteConfigSpecIpRouteSpec", "vmodl.DynamicData", "vim.version.version6", [("network", "string", "vim.version.version6", 0), ("prefixLength", "int", "vim.version.version6", 0), ("gateway", "vim.net.IpRouteConfigSpec.GatewaySpec", "vim.version.version6", 0), ("operation", "string", "vim.version.version6", 0)]) +CreateDataType("vim.net.IpStackInfo", "NetIpStackInfo", "vmodl.DynamicData", "vim.version.version6", [("neighbor", "vim.net.IpStackInfo.NetToMedia[]", "vim.version.version6", F_OPTIONAL), ("defaultRouter", "vim.net.IpStackInfo.DefaultRouter[]", "vim.version.version6", F_OPTIONAL)]) +CreateEnumType("vim.net.IpStackInfo.EntryType", "NetIpStackInfoEntryType", "vim.version.version6", ["other", "invalid", "dynamic", "manual"]) +CreateEnumType("vim.net.IpStackInfo.Preference", "NetIpStackInfoPreference", "vim.version.version6", ["reserved", "low", "medium", "high"]) +CreateDataType("vim.net.IpStackInfo.NetToMedia", "NetIpStackInfoNetToMedia", "vmodl.DynamicData", "vim.version.version6", [("ipAddress", "string", "vim.version.version6", 0), ("physicalAddress", "string", "vim.version.version6", 0), ("device", "string", "vim.version.version6", 0), ("type", "string", "vim.version.version6", 0)]) +CreateDataType("vim.net.IpStackInfo.DefaultRouter", "NetIpStackInfoDefaultRouter", "vmodl.DynamicData", "vim.version.version6", [("ipAddress", "string", "vim.version.version6", 0), ("device", "string", "vim.version.version6", 0), ("lifetime", "vmodl.DateTime", "vim.version.version6", 0), ("preference", "string", "vim.version.version6", 0)]) +CreateDataType("vim.net.NetBIOSConfigInfo", "NetBIOSConfigInfo", "vmodl.DynamicData", "vim.version.version6", [("mode", "string", "vim.version.version6", 0)]) +CreateEnumType("vim.net.NetBIOSConfigInfo.Mode", "NetBIOSConfigInfoMode", "vim.version.version6", ["unknown", "enabled", "disabled", "enabledViaDHCP"]) +CreateDataType("vim.net.WinNetBIOSConfigInfo", "WinNetBIOSConfigInfo", "vim.net.NetBIOSConfigInfo", "vim.version.version6", [("primaryWINS", "string", "vim.version.version6", 0), ("secondaryWINS", "string", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.option.ArrayUpdateSpec", "ArrayUpdateSpec", "vmodl.DynamicData", "vim.version.version1", [("operation", "vim.option.ArrayUpdateSpec.Operation", "vim.version.version1", 0), ("removeKey", "anyType", "vim.version.version1", F_OPTIONAL)]) +CreateEnumType("vim.option.ArrayUpdateSpec.Operation", "ArrayUpdateOperation", "vim.version.version1", ["add", "remove", "edit"]) +CreateDataType("vim.option.OptionDef", "OptionDef", "vim.ElementDescription", "vim.version.version1", [("optionType", "vim.option.OptionType", "vim.version.version1", 0)]) +CreateManagedType("vim.option.OptionManager", "OptionManager", "vmodl.ManagedObject", "vim.version.version1", [("supportedOption", "vim.option.OptionDef[]", "vim.version.version1", F_OPTIONAL, None), ("setting", "vim.option.OptionValue[]", "vim.version.version1", F_OPTIONAL, None)], [("queryView", "QueryOptions", "vim.version.version1", (("name", "string", "vim.version.version1", F_OPTIONAL, None),), (F_OPTIONAL, "vim.option.OptionValue[]", "vim.option.OptionValue[]"), "System.View", ["vim.fault.InvalidName", ]), ("updateValues", "UpdateOptions", "vim.version.version1", (("changedValue", "vim.option.OptionValue[]", "vim.version.version1", 0, None),), (0, "void", "void"), None, ["vim.fault.InvalidName", ])]) +CreateDataType("vim.option.OptionType", "OptionType", "vmodl.DynamicData", "vim.version.version1", [("valueIsReadonly", "boolean", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.option.OptionValue", "OptionValue", "vmodl.DynamicData", "vim.version.version1", [("key", "string", "vim.version.version1", 0), ("value", "anyType", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.option.StringOption", "StringOption", "vim.option.OptionType", "vim.version.version1", [("defaultValue", "string", "vim.version.version1", 0), ("validCharacters", "string", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.profile.ApplyProfile", "ApplyProfile", "vmodl.DynamicData", "vim.version.version5", [("enabled", "boolean", "vim.version.version5", 0), ("policy", "vim.profile.Policy[]", "vim.version.version5", F_OPTIONAL), ("profileTypeName", "string", "vim.version.version7", F_OPTIONAL), ("profileVersion", "string", "vim.version.version7", F_OPTIONAL), ("property", "vim.profile.ApplyProfileProperty[]", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.profile.ApplyProfileElement", "ProfileApplyProfileElement", "vim.profile.ApplyProfile", "vim.version.version7", [("key", "string", "vim.version.version7", 0)]) +CreateDataType("vim.profile.ApplyProfileProperty", "ProfileApplyProfileProperty", "vmodl.DynamicData", "vim.version.version7", [("propertyName", "string", "vim.version.version7", 0), ("array", "boolean", "vim.version.version7", 0), ("profile", "vim.profile.ApplyProfile[]", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.profile.ComplianceLocator", "ComplianceLocator", "vmodl.DynamicData", "vim.version.version5", [("expressionName", "string", "vim.version.version5", 0), ("applyPath", "vim.profile.ProfilePropertyPath", "vim.version.version5", 0)]) +CreateManagedType("vim.profile.ComplianceManager", "ProfileComplianceManager", "vmodl.ManagedObject", "vim.version.version5", None, [("checkCompliance", "CheckCompliance_Task", "vim.version.version5", (("profile", "vim.profile.Profile[]", "vim.version.version5", F_OPTIONAL, None),("entity", "vim.ManagedEntity[]", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.Task", "vim.profile.ComplianceResult[]"), "System.View", None), ("queryComplianceStatus", "QueryComplianceStatus", "vim.version.version5", (("profile", "vim.profile.Profile[]", "vim.version.version5", F_OPTIONAL, None),("entity", "vim.ManagedEntity[]", "vim.version.version5", F_OPTIONAL, None),), (F_OPTIONAL, "vim.profile.ComplianceResult[]", "vim.profile.ComplianceResult[]"), "System.View", None), ("clearComplianceStatus", "ClearComplianceStatus", "vim.version.version5", (("profile", "vim.profile.Profile[]", "vim.version.version5", F_OPTIONAL, None),("entity", "vim.ManagedEntity[]", "vim.version.version5", F_OPTIONAL, None),), (0, "void", "void"), "Profile.Clear", None), ("queryExpressionMetadata", "QueryExpressionMetadata", "vim.version.version5", (("expressionName", "string[]", "vim.version.version5", F_OPTIONAL, None),("profile", "vim.profile.Profile", "vim.version.version7", F_OPTIONAL, None),), (F_OPTIONAL, "vim.profile.ExpressionMetadata[]", "vim.profile.ExpressionMetadata[]"), "System.View", None)]) +CreateDataType("vim.profile.ComplianceProfile", "ComplianceProfile", "vmodl.DynamicData", "vim.version.version5", [("expression", "vim.profile.Expression[]", "vim.version.version5", 0), ("rootExpression", "string", "vim.version.version5", 0)]) +CreateDataType("vim.profile.ComplianceResult", "ComplianceResult", "vmodl.DynamicData", "vim.version.version5", [("profile", "vim.profile.Profile", "vim.version.version5", F_OPTIONAL), ("complianceStatus", "string", "vim.version.version5", 0), ("entity", "vim.ManagedEntity", "vim.version.version5", F_OPTIONAL), ("checkTime", "vmodl.DateTime", "vim.version.version5", F_OPTIONAL), ("failure", "vim.profile.ComplianceResult.ComplianceFailure[]", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.profile.ComplianceResult.Status", "ComplianceResultStatus", "vim.version.version5", ["compliant", "nonCompliant", "unknown"]) +CreateDataType("vim.profile.ComplianceResult.ComplianceFailure", "ComplianceFailure", "vmodl.DynamicData", "vim.version.version5", [("failureType", "string", "vim.version.version5", 0), ("message", "vmodl.LocalizableMessage", "vim.version.version5", 0), ("expressionName", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.profile.DeferredPolicyOptionParameter", "ProfileDeferredPolicyOptionParameter", "vmodl.DynamicData", "vim.version.version5", [("inputPath", "vim.profile.ProfilePropertyPath", "vim.version.version5", 0), ("parameter", "vmodl.KeyAnyValue[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.profile.Expression", "ProfileExpression", "vmodl.DynamicData", "vim.version.version5", [("id", "string", "vim.version.version5", 0), ("displayName", "string", "vim.version.version5", 0), ("negated", "boolean", "vim.version.version5", 0)]) +CreateDataType("vim.profile.SimpleExpression", "ProfileSimpleExpression", "vim.profile.Expression", "vim.version.version5", [("expressionType", "string", "vim.version.version5", 0), ("parameter", "vmodl.KeyAnyValue[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.profile.CompositeExpression", "ProfileCompositeExpression", "vim.profile.Expression", "vim.version.version5", [("operator", "string", "vim.version.version5", 0), ("expressionName", "string[]", "vim.version.version5", 0)]) +CreateDataType("vim.profile.ExpressionMetadata", "ProfileExpressionMetadata", "vmodl.DynamicData", "vim.version.version5", [("expressionId", "vim.ExtendedElementDescription", "vim.version.version5", 0), ("parameter", "vim.profile.ParameterMetadata[]", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.profile.NumericComparator", "ProfileNumericComparator", "vim.version.version5", ["lessThan", "lessThanEqual", "equal", "notEqual", "greaterThanEqual", "greaterThan"]) +CreateDataType("vim.profile.ParameterMetadata", "ProfileParameterMetadata", "vmodl.DynamicData", "vim.version.version5", [("id", "vim.ExtendedElementDescription", "vim.version.version5", 0), ("type", "vmodl.TypeName", "vim.version.version5", 0), ("optional", "boolean", "vim.version.version5", 0), ("defaultValue", "anyType", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.profile.Policy", "ProfilePolicy", "vmodl.DynamicData", "vim.version.version5", [("id", "string", "vim.version.version5", 0), ("policyOption", "vim.profile.PolicyOption", "vim.version.version5", 0)]) +CreateDataType("vim.profile.PolicyOptionMetadata", "ProfilePolicyOptionMetadata", "vmodl.DynamicData", "vim.version.version5", [("id", "vim.ExtendedElementDescription", "vim.version.version5", 0), ("parameter", "vim.profile.ParameterMetadata[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.profile.CompositePolicyOptionMetadata", "ProfileCompositePolicyOptionMetadata", "vim.profile.PolicyOptionMetadata", "vim.version.version5", [("option", "string[]", "vim.version.version5", 0)]) +CreateDataType("vim.profile.UserInputRequiredParameterMetadata", "UserInputRequiredParameterMetadata", "vim.profile.PolicyOptionMetadata", "vim.version.version5", [("userInputParameter", "vim.profile.ParameterMetadata[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.profile.PolicyMetadata", "ProfilePolicyMetadata", "vmodl.DynamicData", "vim.version.version5", [("id", "vim.ExtendedElementDescription", "vim.version.version5", 0), ("possibleOption", "vim.profile.PolicyOptionMetadata[]", "vim.version.version5", 0)]) +CreateDataType("vim.profile.PolicyOption", "PolicyOption", "vmodl.DynamicData", "vim.version.version5", [("id", "string", "vim.version.version5", 0), ("parameter", "vmodl.KeyAnyValue[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.profile.CompositePolicyOption", "CompositePolicyOption", "vim.profile.PolicyOption", "vim.version.version5", [("option", "vim.profile.PolicyOption[]", "vim.version.version5", F_OPTIONAL)]) +CreateManagedType("vim.profile.Profile", "Profile", "vmodl.ManagedObject", "vim.version.version5", [("config", "vim.profile.Profile.ConfigInfo", "vim.version.version5", 0, "Profile.Edit"), ("description", "vim.profile.Profile.Description", "vim.version.version5", F_OPTIONAL, None), ("name", "string", "vim.version.version5", 0, None), ("createdTime", "vmodl.DateTime", "vim.version.version5", 0, None), ("modifiedTime", "vmodl.DateTime", "vim.version.version5", 0, None), ("entity", "vim.ManagedEntity[]", "vim.version.version5", F_OPTIONAL, None), ("complianceStatus", "string", "vim.version.version5", 0, None)], [("retrieveDescription", "RetrieveDescription", "vim.version.version7", (), (F_OPTIONAL, "vim.profile.Profile.Description", "vim.profile.Profile.Description"), "System.View", None), ("destroy", "DestroyProfile", "vim.version.version5", (), (0, "void", "void"), "Profile.Delete", None), ("associateEntities", "AssociateProfile", "vim.version.version5", (("entity", "vim.ManagedEntity[]", "vim.version.version5", 0, None),), (0, "void", "void"), "Profile.Edit", None), ("dissociateEntities", "DissociateProfile", "vim.version.version5", (("entity", "vim.ManagedEntity[]", "vim.version.version5", F_OPTIONAL, None),), (0, "void", "void"), "Profile.Edit", None), ("checkCompliance", "CheckProfileCompliance_Task", "vim.version.version5", (("entity", "vim.ManagedEntity[]", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.Task", "vim.profile.ComplianceResult[]"), "System.View", None), ("exportProfile", "ExportProfile", "vim.version.version5", (), (0, "string", "string"), "Profile.Export", None)]) +CreateDataType("vim.profile.Profile.CreateSpec", "ProfileCreateSpec", "vmodl.DynamicData", "vim.version.version5", [("name", "string", "vim.version.version5", F_OPTIONAL), ("annotation", "string", "vim.version.version5", F_OPTIONAL), ("enabled", "boolean", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.profile.Profile.SerializedCreateSpec", "ProfileSerializedCreateSpec", "vim.profile.Profile.CreateSpec", "vim.version.version5", [("profileConfigString", "string", "vim.version.version5", 0)]) +CreateDataType("vim.profile.Profile.ConfigInfo", "ProfileConfigInfo", "vmodl.DynamicData", "vim.version.version5", [("name", "string", "vim.version.version5", 0), ("annotation", "string", "vim.version.version5", F_OPTIONAL), ("enabled", "boolean", "vim.version.version5", 0)]) +CreateDataType("vim.profile.Profile.Description", "ProfileDescription", "vmodl.DynamicData", "vim.version.version5", [("section", "vim.profile.Profile.Description.Section[]", "vim.version.version5", 0)]) +CreateDataType("vim.profile.Profile.Description.Section", "ProfileDescriptionSection", "vmodl.DynamicData", "vim.version.version5", [("description", "vim.ExtendedElementDescription", "vim.version.version5", 0), ("message", "vmodl.LocalizableMessage[]", "vim.version.version5", F_OPTIONAL)]) +CreateManagedType("vim.profile.ProfileManager", "ProfileManager", "vmodl.ManagedObject", "vim.version.version5", [("profile", "vim.profile.Profile[]", "vim.version.version5", F_OPTIONAL, "Profile.View")], [("createProfile", "CreateProfile", "vim.version.version5", (("createSpec", "vim.profile.Profile.CreateSpec", "vim.version.version5", 0, None),), (0, "vim.profile.Profile", "vim.profile.Profile"), "Profile.Create", ["vim.fault.DuplicateName", ]), ("queryPolicyMetadata", "QueryPolicyMetadata", "vim.version.version5", (("policyName", "string[]", "vim.version.version5", F_OPTIONAL, None),("profile", "vim.profile.Profile", "vim.version.version7", F_OPTIONAL, None),), (F_OPTIONAL, "vim.profile.PolicyMetadata[]", "vim.profile.PolicyMetadata[]"), "System.View", None), ("findAssociatedProfile", "FindAssociatedProfile", "vim.version.version5", (("entity", "vim.ManagedEntity", "vim.version.version5", 0, None),), (F_OPTIONAL, "vim.profile.Profile[]", "vim.profile.Profile[]"), "System.View", None)]) +CreateDataType("vim.profile.ProfileMetadata", "ProfileMetadata", "vmodl.DynamicData", "vim.version.version5", [("key", "vmodl.TypeName", "vim.version.version5", 0), ("profileTypeName", "string", "vim.version.version7", F_OPTIONAL), ("description", "vim.ExtendedDescription", "vim.version.version5", F_OPTIONAL), ("sortSpec", "vim.profile.ProfileMetadata.ProfileSortSpec[]", "vim.version.version7", F_OPTIONAL), ("profileCategory", "string", "vim.version.version8", F_OPTIONAL), ("profileComponent", "string", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.profile.ProfileMetadata.ProfileSortSpec", "ProfileMetadataProfileSortSpec", "vmodl.DynamicData", "vim.version.version7", [("policyId", "string", "vim.version.version7", 0), ("parameter", "string", "vim.version.version7", 0)]) +CreateDataType("vim.profile.ProfilePropertyPath", "ProfilePropertyPath", "vmodl.DynamicData", "vim.version.version5", [("profilePath", "vmodl.PropertyPath", "vim.version.version5", 0), ("policyId", "string", "vim.version.version5", F_OPTIONAL), ("parameterId", "string", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.profile.ProfileStructure", "ProfileProfileStructure", "vmodl.DynamicData", "vim.version.version7", [("profileTypeName", "string", "vim.version.version7", 0), ("child", "vim.profile.ProfileStructureProperty[]", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.profile.ProfileStructureProperty", "ProfileProfileStructureProperty", "vmodl.DynamicData", "vim.version.version7", [("propertyName", "string", "vim.version.version7", 0), ("array", "boolean", "vim.version.version7", 0), ("element", "vim.profile.ProfileStructure", "vim.version.version7", 0)]) +CreateManagedType("vim.profile.cluster.ClusterProfile", "ClusterProfile", "vim.profile.Profile", "vim.version.version5", None, [("update", "UpdateClusterProfile", "vim.version.version5", (("config", "vim.profile.cluster.ClusterProfile.ConfigSpec", "vim.version.version5", 0, None),), (0, "void", "void"), "Profile.Edit", ["vim.fault.DuplicateName", ])]) +CreateDataType("vim.profile.cluster.ClusterProfile.ConfigInfo", "ClusterProfileConfigInfo", "vim.profile.Profile.ConfigInfo", "vim.version.version5", [("complyProfile", "vim.profile.ComplianceProfile", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.profile.cluster.ClusterProfile.CreateSpec", "ClusterProfileCreateSpec", "vim.profile.Profile.CreateSpec", "vim.version.version5", None) +CreateDataType("vim.profile.cluster.ClusterProfile.ConfigSpec", "ClusterProfileConfigSpec", "vim.profile.cluster.ClusterProfile.CreateSpec", "vim.version.version5", None) +CreateDataType("vim.profile.cluster.ClusterProfile.CompleteConfigSpec", "ClusterProfileCompleteConfigSpec", "vim.profile.cluster.ClusterProfile.ConfigSpec", "vim.version.version5", [("complyProfile", "vim.profile.ComplianceProfile", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.profile.cluster.ClusterProfile.ServiceType", "ClusterProfileServiceType", "vim.version.version5", ["DRS", "HA", "DPM", "FT"]) +CreateDataType("vim.profile.cluster.ClusterProfile.ConfigServiceCreateSpec", "ClusterProfileConfigServiceCreateSpec", "vim.profile.cluster.ClusterProfile.ConfigSpec", "vim.version.version5", [("serviceType", "string[]", "vim.version.version5", F_OPTIONAL)]) +CreateManagedType("vim.profile.cluster.ProfileManager", "ClusterProfileManager", "vim.profile.ProfileManager", "vim.version.version5", None, None) +CreateDataType("vim.profile.host.AnswerFile", "AnswerFile", "vmodl.DynamicData", "vim.version.version7", [("userInput", "vim.profile.DeferredPolicyOptionParameter[]", "vim.version.version7", F_OPTIONAL), ("createdTime", "vmodl.DateTime", "vim.version.version7", 0), ("modifiedTime", "vmodl.DateTime", "vim.version.version7", 0)]) +CreateDataType("vim.profile.host.AnswerFileStatusResult", "AnswerFileStatusResult", "vmodl.DynamicData", "vim.version.version7", [("checkedTime", "vmodl.DateTime", "vim.version.version7", 0), ("host", "vim.HostSystem", "vim.version.version7", 0), ("status", "string", "vim.version.version7", 0), ("error", "vim.profile.host.AnswerFileStatusResult.AnswerFileStatusError[]", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.profile.host.AnswerFileStatusResult.AnswerFileStatusError", "AnswerFileStatusError", "vmodl.DynamicData", "vim.version.version7", [("userInputPath", "vim.profile.ProfilePropertyPath", "vim.version.version7", 0), ("errMsg", "vmodl.LocalizableMessage", "vim.version.version7", 0)]) +CreateDataType("vim.profile.host.ExecuteResult", "ProfileExecuteResult", "vmodl.DynamicData", "vim.version.version5", [("status", "string", "vim.version.version5", 0), ("configSpec", "vim.host.ConfigSpec", "vim.version.version5", F_OPTIONAL), ("inapplicablePath", "vmodl.PropertyPath[]", "vim.version.version5", F_OPTIONAL), ("requireInput", "vim.profile.DeferredPolicyOptionParameter[]", "vim.version.version5", F_OPTIONAL), ("error", "vim.profile.host.ExecuteResult.ExecuteError[]", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.profile.host.ExecuteResult.Status", "ProfileExecuteResultStatus", "vim.version.version5", ["success", "needInput", "error"]) +CreateDataType("vim.profile.host.ExecuteResult.ExecuteError", "ProfileExecuteError", "vmodl.DynamicData", "vim.version.version5", [("path", "vim.profile.ProfilePropertyPath", "vim.version.version5", F_OPTIONAL), ("message", "vmodl.LocalizableMessage", "vim.version.version5", 0)]) +CreateDataType("vim.profile.host.HostApplyProfile", "HostApplyProfile", "vim.profile.ApplyProfile", "vim.version.version5", [("memory", "vim.profile.host.HostMemoryProfile", "vim.version.version5", F_OPTIONAL), ("storage", "vim.profile.host.StorageProfile", "vim.version.version5", F_OPTIONAL), ("network", "vim.profile.host.NetworkProfile", "vim.version.version5", F_OPTIONAL), ("datetime", "vim.profile.host.DateTimeProfile", "vim.version.version5", F_OPTIONAL), ("firewall", "vim.profile.host.FirewallProfile", "vim.version.version5", F_OPTIONAL), ("security", "vim.profile.host.SecurityProfile", "vim.version.version5", F_OPTIONAL), ("service", "vim.profile.host.ServiceProfile[]", "vim.version.version5", F_OPTIONAL), ("option", "vim.profile.host.OptionProfile[]", "vim.version.version5", F_OPTIONAL), ("userAccount", "vim.profile.host.UserProfile[]", "vim.version.version5", F_OPTIONAL), ("usergroupAccount", "vim.profile.host.UserGroupProfile[]", "vim.version.version5", F_OPTIONAL), ("authentication", "vim.profile.host.AuthenticationProfile", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.profile.host.PhysicalNicProfile", "PhysicalNicProfile", "vim.profile.ApplyProfile", "vim.version.version5", [("key", "string", "vim.version.version5", 0)]) +CreateDataType("vim.profile.host.HostMemoryProfile", "HostMemoryProfile", "vim.profile.ApplyProfile", "vim.version.version5", None) +CreateDataType("vim.profile.host.UserProfile", "UserProfile", "vim.profile.ApplyProfile", "vim.version.version5", [("key", "string", "vim.version.version5", 0)]) +CreateDataType("vim.profile.host.UserGroupProfile", "UserGroupProfile", "vim.profile.ApplyProfile", "vim.version.version5", [("key", "string", "vim.version.version5", 0)]) +CreateDataType("vim.profile.host.SecurityProfile", "SecurityProfile", "vim.profile.ApplyProfile", "vim.version.version5", [("permission", "vim.profile.host.PermissionProfile[]", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.profile.host.OptionProfile", "OptionProfile", "vim.profile.ApplyProfile", "vim.version.version5", [("key", "string", "vim.version.version5", 0)]) +CreateDataType("vim.profile.host.DateTimeProfile", "DateTimeProfile", "vim.profile.ApplyProfile", "vim.version.version5", None) +CreateDataType("vim.profile.host.ServiceProfile", "ServiceProfile", "vim.profile.ApplyProfile", "vim.version.version5", [("key", "string", "vim.version.version5", 0)]) +CreateDataType("vim.profile.host.FirewallProfile", "FirewallProfile", "vim.profile.ApplyProfile", "vim.version.version5", [("ruleset", "vim.profile.host.FirewallProfile.RulesetProfile[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.profile.host.FirewallProfile.RulesetProfile", "FirewallProfileRulesetProfile", "vim.profile.ApplyProfile", "vim.version.version5", [("key", "string", "vim.version.version5", 0)]) +CreateDataType("vim.profile.host.NasStorageProfile", "NasStorageProfile", "vim.profile.ApplyProfile", "vim.version.version5", [("key", "string", "vim.version.version5", 0)]) +CreateDataType("vim.profile.host.StorageProfile", "StorageProfile", "vim.profile.ApplyProfile", "vim.version.version5", [("nasStorage", "vim.profile.host.NasStorageProfile[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.profile.host.NetworkProfile", "NetworkProfile", "vim.profile.ApplyProfile", "vim.version.version5", [("vswitch", "vim.profile.host.VirtualSwitchProfile[]", "vim.version.version5", F_OPTIONAL), ("vmPortGroup", "vim.profile.host.VmPortGroupProfile[]", "vim.version.version5", F_OPTIONAL), ("hostPortGroup", "vim.profile.host.HostPortGroupProfile[]", "vim.version.version5", F_OPTIONAL), ("serviceConsolePortGroup", "vim.profile.host.ServiceConsolePortGroupProfile[]", "vim.version.version5", F_OPTIONAL), ("dnsConfig", "vim.profile.host.NetworkProfile.DnsConfigProfile", "vim.version.version5", F_OPTIONAL), ("ipRouteConfig", "vim.profile.host.IpRouteProfile", "vim.version.version5", F_OPTIONAL), ("consoleIpRouteConfig", "vim.profile.host.IpRouteProfile", "vim.version.version5", F_OPTIONAL), ("pnic", "vim.profile.host.PhysicalNicProfile[]", "vim.version.version5", F_OPTIONAL), ("dvswitch", "vim.profile.host.DvsProfile[]", "vim.version.version5", F_OPTIONAL), ("dvsServiceConsoleNic", "vim.profile.host.DvsServiceConsoleVNicProfile[]", "vim.version.version5", F_OPTIONAL), ("dvsHostNic", "vim.profile.host.DvsHostVNicProfile[]", "vim.version.version5", F_OPTIONAL), ("netStackInstance", "vim.profile.host.NetStackInstanceProfile[]", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.profile.host.NetworkProfile.DnsConfigProfile", "NetworkProfileDnsConfigProfile", "vim.profile.ApplyProfile", "vim.version.version5", None) +CreateDataType("vim.profile.host.DvsVNicProfile", "DvsVNicProfile", "vim.profile.ApplyProfile", "vim.version.version5", [("key", "string", "vim.version.version5", 0), ("ipConfig", "vim.profile.host.IpAddressProfile", "vim.version.version5", 0)]) +CreateDataType("vim.profile.host.DvsServiceConsoleVNicProfile", "DvsServiceConsoleVNicProfile", "vim.profile.host.DvsVNicProfile", "vim.version.version5", None) +CreateDataType("vim.profile.host.DvsHostVNicProfile", "DvsHostVNicProfile", "vim.profile.host.DvsVNicProfile", "vim.version.version5", None) +CreateDataType("vim.profile.host.DvsProfile", "DvsProfile", "vim.profile.ApplyProfile", "vim.version.version5", [("key", "string", "vim.version.version5", 0), ("name", "string", "vim.version.version5", 0), ("uplink", "vim.profile.host.PnicUplinkProfile[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.profile.host.PnicUplinkProfile", "PnicUplinkProfile", "vim.profile.ApplyProfile", "vim.version.version5", [("key", "string", "vim.version.version5", 0)]) +CreateDataType("vim.profile.host.IpRouteProfile", "IpRouteProfile", "vim.profile.ApplyProfile", "vim.version.version5", [("staticRoute", "vim.profile.host.StaticRouteProfile[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.profile.host.StaticRouteProfile", "StaticRouteProfile", "vim.profile.ApplyProfile", "vim.version.version5", [("key", "string", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.profile.host.VirtualSwitchProfile", "VirtualSwitchProfile", "vim.profile.ApplyProfile", "vim.version.version5", [("key", "string", "vim.version.version5", 0), ("name", "string", "vim.version.version5", 0), ("link", "vim.profile.host.VirtualSwitchProfile.LinkProfile", "vim.version.version5", 0), ("numPorts", "vim.profile.host.VirtualSwitchProfile.NumPortsProfile", "vim.version.version5", 0), ("networkPolicy", "vim.profile.host.NetworkPolicyProfile", "vim.version.version5", 0)]) +CreateDataType("vim.profile.host.VirtualSwitchProfile.LinkProfile", "LinkProfile", "vim.profile.ApplyProfile", "vim.version.version5", None) +CreateDataType("vim.profile.host.VirtualSwitchProfile.NumPortsProfile", "NumPortsProfile", "vim.profile.ApplyProfile", "vim.version.version5", None) +CreateDataType("vim.profile.host.NetStackInstanceProfile", "NetStackInstanceProfile", "vim.profile.ApplyProfile", "vim.version.version9", [("key", "string", "vim.version.version9", 0), ("dnsConfig", "vim.profile.host.NetworkProfile.DnsConfigProfile", "vim.version.version9", 0), ("ipRouteConfig", "vim.profile.host.IpRouteProfile", "vim.version.version9", 0)]) +CreateDataType("vim.profile.host.PortGroupProfile", "PortGroupProfile", "vim.profile.ApplyProfile", "vim.version.version5", [("key", "string", "vim.version.version5", 0), ("name", "string", "vim.version.version5", 0), ("vlan", "vim.profile.host.PortGroupProfile.VlanProfile", "vim.version.version5", 0), ("vswitch", "vim.profile.host.PortGroupProfile.VirtualSwitchSelectionProfile", "vim.version.version5", 0), ("networkPolicy", "vim.profile.host.NetworkPolicyProfile", "vim.version.version5", 0)]) +CreateDataType("vim.profile.host.PortGroupProfile.VlanProfile", "VlanProfile", "vim.profile.ApplyProfile", "vim.version.version5", None) +CreateDataType("vim.profile.host.PortGroupProfile.VirtualSwitchSelectionProfile", "VirtualSwitchSelectionProfile", "vim.profile.ApplyProfile", "vim.version.version5", None) +CreateDataType("vim.profile.host.VmPortGroupProfile", "VmPortGroupProfile", "vim.profile.host.PortGroupProfile", "vim.version.version5", None) +CreateDataType("vim.profile.host.HostPortGroupProfile", "HostPortGroupProfile", "vim.profile.host.PortGroupProfile", "vim.version.version5", [("ipConfig", "vim.profile.host.IpAddressProfile", "vim.version.version5", 0)]) +CreateDataType("vim.profile.host.ServiceConsolePortGroupProfile", "ServiceConsolePortGroupProfile", "vim.profile.host.PortGroupProfile", "vim.version.version5", [("ipConfig", "vim.profile.host.IpAddressProfile", "vim.version.version5", 0)]) +CreateDataType("vim.profile.host.NetworkPolicyProfile", "NetworkPolicyProfile", "vim.profile.ApplyProfile", "vim.version.version5", None) +CreateDataType("vim.profile.host.IpAddressProfile", "IpAddressProfile", "vim.profile.ApplyProfile", "vim.version.version5", None) +CreateDataType("vim.profile.host.AuthenticationProfile", "AuthenticationProfile", "vim.profile.ApplyProfile", "vim.version.version6", [("activeDirectory", "vim.profile.host.ActiveDirectoryProfile", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.profile.host.ActiveDirectoryProfile", "ActiveDirectoryProfile", "vim.profile.ApplyProfile", "vim.version.version6", None) +CreateDataType("vim.profile.host.PermissionProfile", "PermissionProfile", "vim.profile.ApplyProfile", "vim.version.version6", [("key", "string", "vim.version.version6", 0)]) +CreateManagedType("vim.profile.host.HostProfile", "HostProfile", "vim.profile.Profile", "vim.version.version5", [("referenceHost", "vim.HostSystem", "vim.version.version5", F_OPTIONAL, None)], [("updateReferenceHost", "UpdateReferenceHost", "vim.version.version5", (("host", "vim.HostSystem", "vim.version.version5", F_OPTIONAL, None),), (0, "void", "void"), "Profile.Edit", None), ("update", "UpdateHostProfile", "vim.version.version5", (("config", "vim.profile.host.HostProfile.ConfigSpec", "vim.version.version5", 0, None),), (0, "void", "void"), "Profile.Edit", ["vim.fault.DuplicateName", "vim.fault.ProfileUpdateFailed", ]), ("execute", "ExecuteHostProfile", "vim.version.version5", (("host", "vim.HostSystem", "vim.version.version5", 0, None),("deferredParam", "vim.profile.DeferredPolicyOptionParameter[]", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.profile.host.ExecuteResult", "vim.profile.host.ExecuteResult"), "System.View", None)]) +CreateDataType("vim.profile.host.HostProfile.ConfigInfo", "HostProfileConfigInfo", "vim.profile.Profile.ConfigInfo", "vim.version.version5", [("applyProfile", "vim.profile.host.HostApplyProfile", "vim.version.version5", F_OPTIONAL), ("defaultComplyProfile", "vim.profile.ComplianceProfile", "vim.version.version5", F_OPTIONAL), ("defaultComplyLocator", "vim.profile.ComplianceLocator[]", "vim.version.version5", F_OPTIONAL), ("customComplyProfile", "vim.profile.ComplianceProfile", "vim.version.version5", F_OPTIONAL), ("disabledExpressionList", "string[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.profile.host.HostProfile.ConfigSpec", "HostProfileConfigSpec", "vim.profile.Profile.CreateSpec", "vim.version.version5", None) +CreateDataType("vim.profile.host.HostProfile.SerializedHostProfileSpec", "HostProfileSerializedHostProfileSpec", "vim.profile.Profile.SerializedCreateSpec", "vim.version.version7", [("validatorHost", "vim.HostSystem", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.profile.host.HostProfile.CompleteConfigSpec", "HostProfileCompleteConfigSpec", "vim.profile.host.HostProfile.ConfigSpec", "vim.version.version5", [("applyProfile", "vim.profile.host.HostApplyProfile", "vim.version.version5", F_OPTIONAL), ("customComplyProfile", "vim.profile.ComplianceProfile", "vim.version.version5", F_OPTIONAL), ("disabledExpressionListChanged", "boolean", "vim.version.version5", 0), ("disabledExpressionList", "string[]", "vim.version.version5", F_OPTIONAL), ("validatorHost", "vim.HostSystem", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.profile.host.HostProfile.HostBasedConfigSpec", "HostProfileHostBasedConfigSpec", "vim.profile.host.HostProfile.ConfigSpec", "vim.version.version5", [("host", "vim.HostSystem", "vim.version.version5", 0), ("useHostProfileEngine", "boolean", "vim.version.version7", F_OPTIONAL)]) +CreateManagedType("vim.scheduler.ScheduledTask", "ScheduledTask", "vim.ExtensibleManagedObject", "vim.version.version1", [("info", "vim.scheduler.ScheduledTaskInfo", "vim.version.version1", 0, None)], [("remove", "RemoveScheduledTask", "vim.version.version1", (), (0, "void", "void"), "ScheduledTask.Delete", ["vim.fault.InvalidState", ]), ("reconfigure", "ReconfigureScheduledTask", "vim.version.version1", (("spec", "vim.scheduler.ScheduledTaskSpec", "vim.version.version1", 0, None),), (0, "void", "void"), "ScheduledTask.Edit", ["vim.fault.InvalidState", "vim.fault.InvalidName", "vim.fault.DuplicateName", ]), ("run", "RunScheduledTask", "vim.version.version1", (), (0, "void", "void"), "ScheduledTask.Run", ["vim.fault.InvalidState", ])]) +CreateDataType("vim.scheduler.ScheduledTaskDescription", "ScheduledTaskDescription", "vmodl.DynamicData", "vim.version.version1", [("action", "vim.TypeDescription[]", "vim.version.version1", 0), ("schedulerInfo", "vim.scheduler.ScheduledTaskDescription.SchedulerDetail[]", "vim.version.version1", 0), ("state", "vim.ElementDescription[]", "vim.version.version1", 0), ("dayOfWeek", "vim.ElementDescription[]", "vim.version.version1", 0), ("weekOfMonth", "vim.ElementDescription[]", "vim.version.version1", 0)]) +CreateDataType("vim.scheduler.ScheduledTaskDescription.SchedulerDetail", "ScheduledTaskDetail", "vim.TypeDescription", "vim.version.version1", [("frequency", "string", "vim.version.version1", 0)]) +CreateManagedType("vim.scheduler.ScheduledTaskManager", "ScheduledTaskManager", "vmodl.ManagedObject", "vim.version.version1", [("scheduledTask", "vim.scheduler.ScheduledTask[]", "vim.version.version1", F_OPTIONAL, "System.View"), ("description", "vim.scheduler.ScheduledTaskDescription", "vim.version.version1", 0, "System.View")], [("create", "CreateScheduledTask", "vim.version.version1", (("entity", "vim.ManagedEntity", "vim.version.version1", 0, "ScheduledTask.Create"),("spec", "vim.scheduler.ScheduledTaskSpec", "vim.version.version1", 0, None),), (0, "vim.scheduler.ScheduledTask", "vim.scheduler.ScheduledTask"), None, ["vim.fault.InvalidName", "vim.fault.DuplicateName", ]), ("retrieveEntityScheduledTask", "RetrieveEntityScheduledTask", "vim.version.version1", (("entity", "vim.ManagedEntity", "vim.version.version1", F_OPTIONAL, None),), (F_OPTIONAL, "vim.scheduler.ScheduledTask[]", "vim.scheduler.ScheduledTask[]"), "System.View", None), ("createObjectScheduledTask", "CreateObjectScheduledTask", "vim.version.version5", (("obj", "vmodl.ManagedObject", "vim.version.version5", 0, "ScheduledTask.Create"),("spec", "vim.scheduler.ScheduledTaskSpec", "vim.version.version5", 0, None),), (0, "vim.scheduler.ScheduledTask", "vim.scheduler.ScheduledTask"), None, ["vim.fault.InvalidName", "vim.fault.DuplicateName", ]), ("retrieveObjectScheduledTask", "RetrieveObjectScheduledTask", "vim.version.version5", (("obj", "vmodl.ManagedObject", "vim.version.version5", F_OPTIONAL, None),), (F_OPTIONAL, "vim.scheduler.ScheduledTask[]", "vim.scheduler.ScheduledTask[]"), "System.View", None)]) +CreateDataType("vim.scheduler.TaskScheduler", "TaskScheduler", "vmodl.DynamicData", "vim.version.version1", [("activeTime", "vmodl.DateTime", "vim.version.version1", F_OPTIONAL), ("expireTime", "vmodl.DateTime", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.scheduler.AfterStartupTaskScheduler", "AfterStartupTaskScheduler", "vim.scheduler.TaskScheduler", "vim.version.version1", [("minute", "int", "vim.version.version1", 0)]) +CreateDataType("vim.scheduler.OnceTaskScheduler", "OnceTaskScheduler", "vim.scheduler.TaskScheduler", "vim.version.version1", [("runAt", "vmodl.DateTime", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.scheduler.RecurrentTaskScheduler", "RecurrentTaskScheduler", "vim.scheduler.TaskScheduler", "vim.version.version1", [("interval", "int", "vim.version.version1", 0)]) +CreateDataType("vim.scheduler.HourlyTaskScheduler", "HourlyTaskScheduler", "vim.scheduler.RecurrentTaskScheduler", "vim.version.version1", [("minute", "int", "vim.version.version1", 0)]) +CreateDataType("vim.scheduler.DailyTaskScheduler", "DailyTaskScheduler", "vim.scheduler.HourlyTaskScheduler", "vim.version.version1", [("hour", "int", "vim.version.version1", 0)]) +CreateDataType("vim.scheduler.WeeklyTaskScheduler", "WeeklyTaskScheduler", "vim.scheduler.DailyTaskScheduler", "vim.version.version1", [("sunday", "boolean", "vim.version.version1", 0), ("monday", "boolean", "vim.version.version1", 0), ("tuesday", "boolean", "vim.version.version1", 0), ("wednesday", "boolean", "vim.version.version1", 0), ("thursday", "boolean", "vim.version.version1", 0), ("friday", "boolean", "vim.version.version1", 0), ("saturday", "boolean", "vim.version.version1", 0)]) +CreateDataType("vim.scheduler.MonthlyTaskScheduler", "MonthlyTaskScheduler", "vim.scheduler.DailyTaskScheduler", "vim.version.version1", None) +CreateDataType("vim.scheduler.MonthlyByDayTaskScheduler", "MonthlyByDayTaskScheduler", "vim.scheduler.MonthlyTaskScheduler", "vim.version.version1", [("day", "int", "vim.version.version1", 0)]) +CreateDataType("vim.scheduler.MonthlyByWeekdayTaskScheduler", "MonthlyByWeekdayTaskScheduler", "vim.scheduler.MonthlyTaskScheduler", "vim.version.version1", [("offset", "vim.scheduler.MonthlyByWeekdayTaskScheduler.WeekOfMonth", "vim.version.version1", 0), ("weekday", "vim.scheduler.MonthlyByWeekdayTaskScheduler.DayOfWeek", "vim.version.version1", 0)]) +CreateEnumType("vim.scheduler.MonthlyByWeekdayTaskScheduler.DayOfWeek", "DayOfWeek", "vim.version.version1", ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"]) +CreateEnumType("vim.scheduler.MonthlyByWeekdayTaskScheduler.WeekOfMonth", "WeekOfMonth", "vim.version.version1", ["first", "second", "third", "fourth", "last"]) +CreateDataType("vim.scheduler.ScheduledTaskSpec", "ScheduledTaskSpec", "vmodl.DynamicData", "vim.version.version1", [("name", "string", "vim.version.version1", 0), ("description", "string", "vim.version.version1", 0), ("enabled", "boolean", "vim.version.version1", 0), ("scheduler", "vim.scheduler.TaskScheduler", "vim.version.version1", 0), ("action", "vim.action.Action", "vim.version.version1", 0), ("notification", "string", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.storageDrs.ApplyRecommendationResult", "ApplyStorageRecommendationResult", "vmodl.DynamicData", "vim.version.version7", [("vm", "vim.VirtualMachine", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.storageDrs.ConfigInfo", "StorageDrsConfigInfo", "vmodl.DynamicData", "vim.version.version7", [("podConfig", "vim.storageDrs.PodConfigInfo", "vim.version.version7", 0), ("vmConfig", "vim.storageDrs.VmConfigInfo[]", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.storageDrs.ConfigSpec", "StorageDrsConfigSpec", "vmodl.DynamicData", "vim.version.version7", [("podConfigSpec", "vim.storageDrs.PodConfigSpec", "vim.version.version7", F_OPTIONAL), ("vmConfigSpec", "vim.storageDrs.VmConfigSpec[]", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.storageDrs.VmConfigSpec", "StorageDrsVmConfigSpec", "vim.option.ArrayUpdateSpec", "vim.version.version7", [("info", "vim.storageDrs.VmConfigInfo", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.storageDrs.PodConfigInfo", "StorageDrsPodConfigInfo", "vmodl.DynamicData", "vim.version.version7", [("enabled", "boolean", "vim.version.version7", 0), ("ioLoadBalanceEnabled", "boolean", "vim.version.version7", 0), ("defaultVmBehavior", "string", "vim.version.version7", 0), ("loadBalanceInterval", "int", "vim.version.version7", F_OPTIONAL), ("defaultIntraVmAffinity", "boolean", "vim.version.version7", F_OPTIONAL), ("spaceLoadBalanceConfig", "vim.storageDrs.SpaceLoadBalanceConfig", "vim.version.version7", F_OPTIONAL), ("ioLoadBalanceConfig", "vim.storageDrs.IoLoadBalanceConfig", "vim.version.version7", F_OPTIONAL), ("rule", "vim.cluster.RuleInfo[]", "vim.version.version7", F_OPTIONAL), ("option", "vim.option.OptionValue[]", "vim.version.version7", F_OPTIONAL)]) +CreateEnumType("vim.storageDrs.PodConfigInfo.Behavior", "StorageDrsPodConfigInfoBehavior", "vim.version.version7", ["manual", "automated"]) +CreateDataType("vim.storageDrs.SpaceLoadBalanceConfig", "StorageDrsSpaceLoadBalanceConfig", "vmodl.DynamicData", "vim.version.version7", [("spaceUtilizationThreshold", "int", "vim.version.version7", F_OPTIONAL), ("minSpaceUtilizationDifference", "int", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.storageDrs.IoLoadBalanceConfig", "StorageDrsIoLoadBalanceConfig", "vmodl.DynamicData", "vim.version.version7", [("ioLatencyThreshold", "int", "vim.version.version7", F_OPTIONAL), ("ioLoadImbalanceThreshold", "int", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.storageDrs.PodConfigSpec", "StorageDrsPodConfigSpec", "vmodl.DynamicData", "vim.version.version7", [("enabled", "boolean", "vim.version.version7", F_OPTIONAL), ("ioLoadBalanceEnabled", "boolean", "vim.version.version7", F_OPTIONAL), ("defaultVmBehavior", "string", "vim.version.version7", F_OPTIONAL), ("loadBalanceInterval", "int", "vim.version.version7", F_OPTIONAL), ("defaultIntraVmAffinity", "boolean", "vim.version.version7", F_OPTIONAL), ("spaceLoadBalanceConfig", "vim.storageDrs.SpaceLoadBalanceConfig", "vim.version.version7", F_OPTIONAL), ("ioLoadBalanceConfig", "vim.storageDrs.IoLoadBalanceConfig", "vim.version.version7", F_OPTIONAL), ("rule", "vim.cluster.RuleSpec[]", "vim.version.version7", F_OPTIONAL), ("option", "vim.storageDrs.OptionSpec[]", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.storageDrs.OptionSpec", "StorageDrsOptionSpec", "vim.option.ArrayUpdateSpec", "vim.version.version7", [("option", "vim.option.OptionValue", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.storageDrs.StorageMigrationAction", "StorageMigrationAction", "vim.cluster.Action", "vim.version.version7", [("vm", "vim.VirtualMachine", "vim.version.version7", 0), ("relocateSpec", "vim.vm.RelocateSpec", "vim.version.version7", 0), ("source", "vim.Datastore", "vim.version.version7", 0), ("destination", "vim.Datastore", "vim.version.version7", 0), ("sizeTransferred", "long", "vim.version.version7", 0), ("spaceUtilSrcBefore", "float", "vim.version.version7", F_OPTIONAL), ("spaceUtilDstBefore", "float", "vim.version.version7", F_OPTIONAL), ("spaceUtilSrcAfter", "float", "vim.version.version7", F_OPTIONAL), ("spaceUtilDstAfter", "float", "vim.version.version7", F_OPTIONAL), ("ioLatencySrcBefore", "float", "vim.version.version7", F_OPTIONAL), ("ioLatencyDstBefore", "float", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.storageDrs.StoragePlacementAction", "StoragePlacementAction", "vim.cluster.Action", "vim.version.version7", [("vm", "vim.VirtualMachine", "vim.version.version7", F_OPTIONAL), ("relocateSpec", "vim.vm.RelocateSpec", "vim.version.version7", 0), ("destination", "vim.Datastore", "vim.version.version7", 0), ("spaceUtilBefore", "float", "vim.version.version7", F_OPTIONAL), ("spaceUtilAfter", "float", "vim.version.version7", F_OPTIONAL), ("ioLatencyBefore", "float", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.storageDrs.StoragePlacementResult", "StoragePlacementResult", "vmodl.DynamicData", "vim.version.version7", [("recommendations", "vim.cluster.Recommendation[]", "vim.version.version7", F_OPTIONAL), ("drsFault", "vim.cluster.DrsFaults", "vim.version.version7", F_OPTIONAL), ("task", "vim.Task", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.storageDrs.VmConfigInfo", "StorageDrsVmConfigInfo", "vmodl.DynamicData", "vim.version.version7", [("vm", "vim.VirtualMachine", "vim.version.version7", F_OPTIONAL), ("enabled", "boolean", "vim.version.version7", F_OPTIONAL), ("behavior", "string", "vim.version.version7", F_OPTIONAL), ("intraVmAffinity", "boolean", "vim.version.version7", F_OPTIONAL), ("intraVmAntiAffinity", "vim.storageDrs.VirtualDiskAntiAffinityRuleSpec", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.vApp.CloneSpec", "VAppCloneSpec", "vmodl.DynamicData", "vim.version.version5", [("location", "vim.Datastore", "vim.version.version5", 0), ("host", "vim.HostSystem", "vim.version.version5", F_OPTIONAL), ("resourceSpec", "vim.ResourceConfigSpec", "vim.version.version5", F_OPTIONAL), ("vmFolder", "vim.Folder", "vim.version.version5", F_OPTIONAL), ("networkMapping", "vim.vApp.CloneSpec.NetworkMappingPair[]", "vim.version.version5", F_OPTIONAL), ("property", "vim.KeyValue[]", "vim.version.version5", F_OPTIONAL), ("resourceMapping", "vim.vApp.CloneSpec.ResourceMap[]", "vim.version.version6", F_OPTIONAL), ("provisioning", "string", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.vApp.CloneSpec.NetworkMappingPair", "VAppCloneSpecNetworkMappingPair", "vmodl.DynamicData", "vim.version.version5", [("source", "vim.Network", "vim.version.version5", 0), ("destination", "vim.Network", "vim.version.version5", 0)]) +CreateDataType("vim.vApp.CloneSpec.ResourceMap", "VAppCloneSpecResourceMap", "vmodl.DynamicData", "vim.version.version6", [("source", "vim.ManagedEntity", "vim.version.version6", 0), ("parent", "vim.ResourcePool", "vim.version.version6", F_OPTIONAL), ("resourceSpec", "vim.ResourceConfigSpec", "vim.version.version6", F_OPTIONAL), ("location", "vim.Datastore", "vim.version.version6", F_OPTIONAL)]) +CreateEnumType("vim.vApp.CloneSpec.ProvisioningType", "VAppCloneSpecProvisioningType", "vim.version.version6", ["sameAsSource", "thin", "thick"]) +CreateDataType("vim.vApp.EntityConfigInfo", "VAppEntityConfigInfo", "vmodl.DynamicData", "vim.version.version5", [("key", "vim.ManagedEntity", "vim.version.version5", F_OPTIONAL), ("tag", "string", "vim.version.version5", F_OPTIONAL), ("startOrder", "int", "vim.version.version5", F_OPTIONAL), ("startDelay", "int", "vim.version.version5", F_OPTIONAL), ("waitingForGuest", "boolean", "vim.version.version5", F_OPTIONAL), ("startAction", "string", "vim.version.version5", F_OPTIONAL), ("stopDelay", "int", "vim.version.version5", F_OPTIONAL), ("stopAction", "string", "vim.version.version5", F_OPTIONAL), ("destroyWithParent", "boolean", "vim.version.version6", F_OPTIONAL)]) +CreateEnumType("vim.vApp.EntityConfigInfo.Action", "VAppAutoStartAction", "vim.version.version5", ["none", "powerOn", "powerOff", "guestShutdown", "suspend"]) +CreateDataType("vim.vApp.IPAssignmentInfo", "VAppIPAssignmentInfo", "vmodl.DynamicData", "vim.version.version5", [("supportedAllocationScheme", "string[]", "vim.version.version5", F_OPTIONAL), ("ipAllocationPolicy", "string", "vim.version.version5", F_OPTIONAL), ("supportedIpProtocol", "string[]", "vim.version.version5", F_OPTIONAL), ("ipProtocol", "string", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.vApp.IPAssignmentInfo.IpAllocationPolicy", "VAppIPAssignmentInfoIpAllocationPolicy", "vim.version.version5", ["dhcpPolicy", "transientPolicy", "fixedPolicy", "fixedAllocatedPolicy"]) +CreateEnumType("vim.vApp.IPAssignmentInfo.AllocationSchemes", "VAppIPAssignmentInfoAllocationSchemes", "vim.version.version5", ["dhcp", "ovfenv"]) +CreateEnumType("vim.vApp.IPAssignmentInfo.Protocols", "VAppIPAssignmentInfoProtocols", "vim.version.version5", ["IPv4", "IPv6"]) +CreateDataType("vim.vApp.IpPool", "IpPool", "vmodl.DynamicData", "vim.version.version5", [("id", "int", "vim.version.version5", F_OPTIONAL), ("name", "string", "vim.version.version5", F_OPTIONAL), ("ipv4Config", "vim.vApp.IpPool.IpPoolConfigInfo", "vim.version.version5", F_OPTIONAL), ("ipv6Config", "vim.vApp.IpPool.IpPoolConfigInfo", "vim.version.version5", F_OPTIONAL), ("dnsDomain", "string", "vim.version.version5", F_OPTIONAL), ("dnsSearchPath", "string", "vim.version.version5", F_OPTIONAL), ("hostPrefix", "string", "vim.version.version5", F_OPTIONAL), ("httpProxy", "string", "vim.version.version5", F_OPTIONAL), ("networkAssociation", "vim.vApp.IpPool.Association[]", "vim.version.version5", F_OPTIONAL), ("availableIpv4Addresses", "int", "vim.version.version8", F_OPTIONAL), ("availableIpv6Addresses", "int", "vim.version.version8", F_OPTIONAL), ("allocatedIpv4Addresses", "int", "vim.version.version8", F_OPTIONAL), ("allocatedIpv6Addresses", "int", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.vApp.IpPool.IpPoolConfigInfo", "IpPoolIpPoolConfigInfo", "vmodl.DynamicData", "vim.version.version5", [("subnetAddress", "string", "vim.version.version5", F_OPTIONAL), ("netmask", "string", "vim.version.version5", F_OPTIONAL), ("gateway", "string", "vim.version.version5", F_OPTIONAL), ("range", "string", "vim.version.version5", F_OPTIONAL), ("dns", "string[]", "vim.version.version5", F_OPTIONAL), ("dhcpServerAvailable", "boolean", "vim.version.version5", F_OPTIONAL), ("ipPoolEnabled", "boolean", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.vApp.IpPool.Association", "IpPoolAssociation", "vmodl.DynamicData", "vim.version.version5", [("network", "vim.Network", "vim.version.version5", F_OPTIONAL), ("networkName", "string", "vim.version.version5", 0)]) +CreateDataType("vim.vApp.OvfSectionInfo", "VAppOvfSectionInfo", "vmodl.DynamicData", "vim.version.version5", [("key", "int", "vim.version.version5", F_OPTIONAL), ("namespace", "string", "vim.version.version5", F_OPTIONAL), ("type", "string", "vim.version.version5", F_OPTIONAL), ("atEnvelopeLevel", "boolean", "vim.version.version5", F_OPTIONAL), ("contents", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.vApp.ProductInfo", "VAppProductInfo", "vmodl.DynamicData", "vim.version.version5", [("key", "int", "vim.version.version5", 0), ("classId", "string", "vim.version.version5", F_OPTIONAL), ("instanceId", "string", "vim.version.version5", F_OPTIONAL), ("name", "string", "vim.version.version5", F_OPTIONAL), ("vendor", "string", "vim.version.version5", F_OPTIONAL), ("version", "string", "vim.version.version5", F_OPTIONAL), ("fullVersion", "string", "vim.version.version5", F_OPTIONAL), ("vendorUrl", "string", "vim.version.version5", F_OPTIONAL), ("productUrl", "string", "vim.version.version5", F_OPTIONAL), ("appUrl", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.vApp.PropertyInfo", "VAppPropertyInfo", "vmodl.DynamicData", "vim.version.version5", [("key", "int", "vim.version.version5", 0), ("classId", "string", "vim.version.version5", F_OPTIONAL), ("instanceId", "string", "vim.version.version5", F_OPTIONAL), ("id", "string", "vim.version.version5", F_OPTIONAL), ("category", "string", "vim.version.version5", F_OPTIONAL), ("label", "string", "vim.version.version5", F_OPTIONAL), ("type", "string", "vim.version.version5", F_OPTIONAL), ("typeReference", "string", "vim.version.version8", F_OPTIONAL), ("userConfigurable", "boolean", "vim.version.version5", F_OPTIONAL), ("defaultValue", "string", "vim.version.version5", F_OPTIONAL), ("value", "string", "vim.version.version5", F_OPTIONAL), ("description", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.vApp.VmConfigInfo", "VmConfigInfo", "vmodl.DynamicData", "vim.version.version5", [("product", "vim.vApp.ProductInfo[]", "vim.version.version5", F_OPTIONAL), ("property", "vim.vApp.PropertyInfo[]", "vim.version.version5", F_OPTIONAL), ("ipAssignment", "vim.vApp.IPAssignmentInfo", "vim.version.version5", 0), ("eula", "string[]", "vim.version.version5", F_OPTIONAL), ("ovfSection", "vim.vApp.OvfSectionInfo[]", "vim.version.version5", F_OPTIONAL), ("ovfEnvironmentTransport", "string[]", "vim.version.version5", F_OPTIONAL), ("installBootRequired", "boolean", "vim.version.version5", 0), ("installBootStopDelay", "int", "vim.version.version5", 0)]) +CreateDataType("vim.vApp.VmConfigSpec", "VmConfigSpec", "vmodl.DynamicData", "vim.version.version5", [("product", "vim.vApp.ProductSpec[]", "vim.version.version5", F_OPTIONAL), ("property", "vim.vApp.PropertySpec[]", "vim.version.version5", F_OPTIONAL), ("ipAssignment", "vim.vApp.IPAssignmentInfo", "vim.version.version5", F_OPTIONAL), ("eula", "string[]", "vim.version.version5", F_OPTIONAL), ("ovfSection", "vim.vApp.OvfSectionSpec[]", "vim.version.version5", F_OPTIONAL), ("ovfEnvironmentTransport", "string[]", "vim.version.version5", F_OPTIONAL), ("installBootRequired", "boolean", "vim.version.version5", F_OPTIONAL), ("installBootStopDelay", "int", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.vApp.ProductSpec", "VAppProductSpec", "vim.option.ArrayUpdateSpec", "vim.version.version5", [("info", "vim.vApp.ProductInfo", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.vApp.PropertySpec", "VAppPropertySpec", "vim.option.ArrayUpdateSpec", "vim.version.version5", [("info", "vim.vApp.PropertyInfo", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.vApp.OvfSectionSpec", "VAppOvfSectionSpec", "vim.option.ArrayUpdateSpec", "vim.version.version5", [("info", "vim.vApp.OvfSectionInfo", "vim.version.version5", F_OPTIONAL)]) +CreateManagedType("vim.view.View", "View", "vmodl.ManagedObject", "vim.version.version2", None, [("destroy", "DestroyView", "vim.version.version2", (), (0, "void", "void"), "System.View", None)]) +CreateManagedType("vim.view.ViewManager", "ViewManager", "vmodl.ManagedObject", "vim.version.version2", [("viewList", "vim.view.View[]", "vim.version.version2", F_OPTIONAL, "System.View")], [("createInventoryView", "CreateInventoryView", "vim.version.version2", (), (0, "vim.view.InventoryView", "vim.view.InventoryView"), "System.View", None), ("createContainerView", "CreateContainerView", "vim.version.version2", (("container", "vim.ManagedEntity", "vim.version.version2", 0, "System.View"),("type", "vmodl.TypeName[]", "vim.version.version2", F_OPTIONAL, None),("recursive", "boolean", "vim.version.version2", 0, None),), (0, "vim.view.ContainerView", "vim.view.ContainerView"), "System.View", None), ("createListView", "CreateListView", "vim.version.version2", (("obj", "vmodl.ManagedObject[]", "vim.version.version2", F_OPTIONAL, "System.View"),), (0, "vim.view.ListView", "vim.view.ListView"), "System.View", None), ("createListViewFromView", "CreateListViewFromView", "vim.version.version2", (("view", "vim.view.View", "vim.version.version2", 0, None),), (0, "vim.view.ListView", "vim.view.ListView"), "System.View", None)]) +CreateDataType("vim.vm.AffinityInfo", "VirtualMachineAffinityInfo", "vmodl.DynamicData", "vim.version.version1", [("affinitySet", "int[]", "vim.version.version1", F_OPTIONAL)]) +CreateEnumType("vim.vm.BackupEventInfo.BackupEventType", "VirtualMachineBackupEventInfoBackupEventType", "vim.version.version4", ["reset", "requestorError", "requestorAbort", "providerAbort", "snapshotPrepare", "snapshotCommit", "requestorDone", "backupManifest", "writerError", "keepAlive"]) +CreateDataType("vim.vm.BootOptions", "VirtualMachineBootOptions", "vmodl.DynamicData", "vim.version.version2", [("bootDelay", "long", "vim.version.version2", F_OPTIONAL), ("enterBIOSSetup", "boolean", "vim.version.version2", F_OPTIONAL), ("bootRetryEnabled", "boolean", "vim.version.version6", F_OPTIONAL), ("bootRetryDelay", "long", "vim.version.version6", F_OPTIONAL), ("bootOrder", "vim.vm.BootOptions.BootableDevice[]", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.vm.BootOptions.BootableDevice", "VirtualMachineBootOptionsBootableDevice", "vmodl.DynamicData", "vim.version.version7", None) +CreateDataType("vim.vm.BootOptions.BootableDiskDevice", "VirtualMachineBootOptionsBootableDiskDevice", "vim.vm.BootOptions.BootableDevice", "vim.version.version7", [("deviceKey", "int", "vim.version.version7", 0)]) +CreateDataType("vim.vm.BootOptions.BootableEthernetDevice", "VirtualMachineBootOptionsBootableEthernetDevice", "vim.vm.BootOptions.BootableDevice", "vim.version.version7", [("deviceKey", "int", "vim.version.version7", 0)]) +CreateDataType("vim.vm.BootOptions.BootableFloppyDevice", "VirtualMachineBootOptionsBootableFloppyDevice", "vim.vm.BootOptions.BootableDevice", "vim.version.version7", None) +CreateDataType("vim.vm.BootOptions.BootableCdromDevice", "VirtualMachineBootOptionsBootableCdromDevice", "vim.vm.BootOptions.BootableDevice", "vim.version.version7", None) +CreateDataType("vim.vm.Capability", "VirtualMachineCapability", "vmodl.DynamicData", "vim.version.version1", [("snapshotOperationsSupported", "boolean", "vim.version.version1", 0), ("multipleSnapshotsSupported", "boolean", "vim.version.version1", 0), ("snapshotConfigSupported", "boolean", "vim.version.version1", 0), ("poweredOffSnapshotsSupported", "boolean", "vim.version.version1", 0), ("memorySnapshotsSupported", "boolean", "vim.version.version1", 0), ("revertToSnapshotSupported", "boolean", "vim.version.version1", 0), ("quiescedSnapshotsSupported", "boolean", "vim.version.version1", 0), ("disableSnapshotsSupported", "boolean", "vim.version.version2", 0), ("lockSnapshotsSupported", "boolean", "vim.version.version2", 0), ("consolePreferencesSupported", "boolean", "vim.version.version1", 0), ("cpuFeatureMaskSupported", "boolean", "vim.version.version1", 0), ("s1AcpiManagementSupported", "boolean", "vim.version.version1", 0), ("settingScreenResolutionSupported", "boolean", "vim.version.version1", 0), ("toolsAutoUpdateSupported", "boolean", "vim.version.version1", 0), ("vmNpivWwnSupported", "boolean", "vim.version.version2", 0), ("npivWwnOnNonRdmVmSupported", "boolean", "vim.version.version2", 0), ("vmNpivWwnDisableSupported", "boolean", "vim.version.version5", 0), ("vmNpivWwnUpdateSupported", "boolean", "vim.version.version5", 0), ("swapPlacementSupported", "boolean", "vim.version.version2", 0), ("toolsSyncTimeSupported", "boolean", "vim.version.version2", 0), ("virtualMmuUsageSupported", "boolean", "vim.version.version2", 0), ("diskSharesSupported", "boolean", "vim.version.version2", 0), ("bootOptionsSupported", "boolean", "vim.version.version2", 0), ("bootRetryOptionsSupported", "boolean", "vim.version.version6", 0), ("settingVideoRamSizeSupported", "boolean", "vim.version.version2", 0), ("settingDisplayTopologySupported", "boolean", "vim.version.version4", 0), ("recordReplaySupported", "boolean", "vim.version.version5", 0), ("changeTrackingSupported", "boolean", "vim.version.version5", 0), ("multipleCoresPerSocketSupported", "boolean", "vim.version.version7", 0), ("hostBasedReplicationSupported", "boolean", "vim.version.version7", 0), ("guestAutoLockSupported", "boolean", "vim.version.version7", 0), ("memoryReservationLockSupported", "boolean", "vim.version.version7", 0), ("featureRequirementSupported", "boolean", "vim.version.version8", 0), ("poweredOnMonitorTypeChangeSupported", "boolean", "vim.version.version8", 0), ("seSparseDiskSupported", "boolean", "vim.version.version8", 0), ("nestedHVSupported", "boolean", "vim.version.version8", 0), ("vPMCSupported", "boolean", "vim.version.version8", 0)]) +CreateDataType("vim.vm.CloneSpec", "VirtualMachineCloneSpec", "vmodl.DynamicData", "vim.version.version1", [("location", "vim.vm.RelocateSpec", "vim.version.version1", 0), ("template", "boolean", "vim.version.version1", 0), ("config", "vim.vm.ConfigSpec", "vim.version.version1", F_OPTIONAL), ("customization", "vim.vm.customization.Specification", "vim.version.version1", F_OPTIONAL), ("powerOn", "boolean", "vim.version.version1", 0), ("snapshot", "vim.vm.Snapshot", "vim.version.version5", F_OPTIONAL), ("memory", "boolean", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.vm.ConfigInfo", "VirtualMachineConfigInfo", "vmodl.DynamicData", "vim.version.version1", [("changeVersion", "string", "vim.version.version1", 0), ("modified", "vmodl.DateTime", "vim.version.version1", 0), ("name", "string", "vim.version.version1", 0), ("guestFullName", "string", "vim.version.version1", 0), ("version", "string", "vim.version.version1", 0), ("uuid", "string", "vim.version.version1", 0), ("instanceUuid", "string", "vim.version.version5", F_OPTIONAL), ("npivNodeWorldWideName", "long[]", "vim.version.version2", F_OPTIONAL), ("npivPortWorldWideName", "long[]", "vim.version.version2", F_OPTIONAL), ("npivWorldWideNameType", "string", "vim.version.version2", F_OPTIONAL), ("npivDesiredNodeWwns", "short", "vim.version.version5", F_OPTIONAL), ("npivDesiredPortWwns", "short", "vim.version.version5", F_OPTIONAL), ("npivTemporaryDisabled", "boolean", "vim.version.version5", F_OPTIONAL), ("npivOnNonRdmDisks", "boolean", "vim.version.version5", F_OPTIONAL), ("locationId", "string", "vim.version.version1", F_OPTIONAL), ("template", "boolean", "vim.version.version1", 0), ("guestId", "string", "vim.version.version1", 0), ("alternateGuestName", "string", "vim.version.version2", 0), ("annotation", "string", "vim.version.version1", F_OPTIONAL), ("files", "vim.vm.FileInfo", "vim.version.version1", 0), ("tools", "vim.vm.ToolsConfigInfo", "vim.version.version1", F_OPTIONAL), ("flags", "vim.vm.FlagInfo", "vim.version.version1", 0), ("consolePreferences", "vim.vm.ConsolePreferences", "vim.version.version1", F_OPTIONAL), ("defaultPowerOps", "vim.vm.DefaultPowerOpInfo", "vim.version.version1", 0), ("hardware", "vim.vm.VirtualHardware", "vim.version.version1", 0), ("cpuAllocation", "vim.ResourceAllocationInfo", "vim.version.version1", F_OPTIONAL), ("memoryAllocation", "vim.ResourceAllocationInfo", "vim.version.version1", F_OPTIONAL), ("latencySensitivity", "vim.LatencySensitivity", "vim.version.version8", F_OPTIONAL), ("memoryHotAddEnabled", "boolean", "vim.version.version4", F_OPTIONAL), ("cpuHotAddEnabled", "boolean", "vim.version.version4", F_OPTIONAL), ("cpuHotRemoveEnabled", "boolean", "vim.version.version4", F_OPTIONAL), ("hotPlugMemoryLimit", "long", "vim.version.version4", F_OPTIONAL), ("hotPlugMemoryIncrementSize", "long", "vim.version.version4", F_OPTIONAL), ("cpuAffinity", "vim.vm.AffinityInfo", "vim.version.version1", F_OPTIONAL), ("memoryAffinity", "vim.vm.AffinityInfo", "vim.version.version1", F_OPTIONAL), ("networkShaper", "vim.vm.NetworkShaperInfo", "vim.version.version1", F_OPTIONAL), ("extraConfig", "vim.option.OptionValue[]", "vim.version.version1", F_OPTIONAL), ("cpuFeatureMask", "vim.host.CpuIdInfo[]", "vim.version.version1", F_OPTIONAL), ("datastoreUrl", "vim.vm.ConfigInfo.DatastoreUrlPair[]", "vim.version.version1", F_OPTIONAL), ("swapPlacement", "string", "vim.version.version2", F_OPTIONAL), ("bootOptions", "vim.vm.BootOptions", "vim.version.version2", F_OPTIONAL), ("ftInfo", "vim.vm.FaultToleranceConfigInfo", "vim.version.version5", F_OPTIONAL), ("vAppConfig", "vim.vApp.VmConfigInfo", "vim.version.version5", F_OPTIONAL), ("vAssertsEnabled", "boolean", "vim.version.version5", F_OPTIONAL), ("changeTrackingEnabled", "boolean", "vim.version.version5", F_OPTIONAL), ("firmware", "string", "vim.version.version7", F_OPTIONAL), ("maxMksConnections", "int", "vim.version.version7", F_OPTIONAL), ("guestAutoLockEnabled", "boolean", "vim.version.version7", F_OPTIONAL), ("managedBy", "vim.ext.ManagedByInfo", "vim.version.version7", F_OPTIONAL), ("memoryReservationLockedToMax", "boolean", "vim.version.version7", F_OPTIONAL), ("initialOverhead", "vim.vm.ConfigInfo.OverheadInfo", "vim.version.version7", F_OPTIONAL), ("nestedHVEnabled", "boolean", "vim.version.version8", F_OPTIONAL), ("vPMCEnabled", "boolean", "vim.version.version8", F_OPTIONAL), ("scheduledHardwareUpgradeInfo", "vim.vm.ScheduledHardwareUpgradeInfo", "vim.version.version8", F_OPTIONAL), ("vFlashCacheReservation", "long", "vim.version.version9", F_OPTIONAL)]) +CreateEnumType("vim.vm.ConfigInfo.NpivWwnType", "VirtualMachineConfigInfoNpivWwnType", "vim.version.version2", ["vc", "host", "external"]) +CreateEnumType("vim.vm.ConfigInfo.SwapPlacementType", "VirtualMachineConfigInfoSwapPlacementType", "vim.version.version2", ["inherit", "vmDirectory", "hostLocal", "vmConfigured"]) +CreateDataType("vim.vm.ConfigInfo.DatastoreUrlPair", "VirtualMachineConfigInfoDatastoreUrlPair", "vmodl.DynamicData", "vim.version.version1", [("name", "string", "vim.version.version1", 0), ("url", "string", "vim.version.version1", 0)]) +CreateDataType("vim.vm.ConfigInfo.OverheadInfo", "VirtualMachineConfigInfoOverheadInfo", "vmodl.DynamicData", "vim.version.version7", [("initialMemoryReservation", "long", "vim.version.version7", F_OPTIONAL), ("initialSwapReservation", "long", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.vm.ConfigOption", "VirtualMachineConfigOption", "vmodl.DynamicData", "vim.version.version1", [("version", "string", "vim.version.version1", 0), ("description", "string", "vim.version.version1", 0), ("guestOSDescriptor", "vim.vm.GuestOsDescriptor[]", "vim.version.version1", 0), ("guestOSDefaultIndex", "int", "vim.version.version1", 0), ("hardwareOptions", "vim.vm.VirtualHardwareOption", "vim.version.version1", 0), ("capabilities", "vim.vm.Capability", "vim.version.version1", 0), ("datastore", "vim.vm.DatastoreOption", "vim.version.version1", 0), ("defaultDevice", "vim.vm.device.VirtualDevice[]", "vim.version.version1", F_OPTIONAL), ("supportedMonitorType", "string[]", "vim.version.version2", 0), ("supportedOvfEnvironmentTransport", "string[]", "vim.version.version5", F_OPTIONAL), ("supportedOvfInstallTransport", "string[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.vm.ConfigOptionDescriptor", "VirtualMachineConfigOptionDescriptor", "vmodl.DynamicData", "vim.version.version1", [("key", "string", "vim.version.version1", 0), ("description", "string", "vim.version.version1", F_OPTIONAL), ("host", "vim.HostSystem[]", "vim.version.version1", F_OPTIONAL), ("createSupported", "boolean", "vim.version.version4", 0), ("defaultConfigOption", "boolean", "vim.version.version4", 0), ("runSupported", "boolean", "vim.version.version8", 0), ("upgradeSupported", "boolean", "vim.version.version8", 0)]) +CreateDataType("vim.vm.ConfigSpec", "VirtualMachineConfigSpec", "vmodl.DynamicData", "vim.version.version1", [("changeVersion", "string", "vim.version.version1", F_OPTIONAL), ("name", "string", "vim.version.version1", F_OPTIONAL), ("version", "string", "vim.version.version1", F_OPTIONAL), ("uuid", "string", "vim.version.version1", F_OPTIONAL), ("instanceUuid", "string", "vim.version.version5", F_OPTIONAL), ("npivNodeWorldWideName", "long[]", "vim.version.version2", F_OPTIONAL), ("npivPortWorldWideName", "long[]", "vim.version.version2", F_OPTIONAL), ("npivWorldWideNameType", "string", "vim.version.version2", F_OPTIONAL), ("npivDesiredNodeWwns", "short", "vim.version.version5", F_OPTIONAL), ("npivDesiredPortWwns", "short", "vim.version.version5", F_OPTIONAL), ("npivTemporaryDisabled", "boolean", "vim.version.version5", F_OPTIONAL), ("npivOnNonRdmDisks", "boolean", "vim.version.version5", F_OPTIONAL), ("npivWorldWideNameOp", "string", "vim.version.version2", F_OPTIONAL), ("locationId", "string", "vim.version.version1", F_OPTIONAL), ("guestId", "string", "vim.version.version1", F_OPTIONAL), ("alternateGuestName", "string", "vim.version.version2", F_OPTIONAL), ("annotation", "string", "vim.version.version1", F_OPTIONAL), ("files", "vim.vm.FileInfo", "vim.version.version1", F_OPTIONAL), ("tools", "vim.vm.ToolsConfigInfo", "vim.version.version1", F_OPTIONAL), ("flags", "vim.vm.FlagInfo", "vim.version.version1", F_OPTIONAL), ("consolePreferences", "vim.vm.ConsolePreferences", "vim.version.version1", F_OPTIONAL), ("powerOpInfo", "vim.vm.DefaultPowerOpInfo", "vim.version.version1", F_OPTIONAL), ("numCPUs", "int", "vim.version.version1", F_OPTIONAL), ("numCoresPerSocket", "int", "vim.version.version7", F_OPTIONAL), ("memoryMB", "long", "vim.version.version1", F_OPTIONAL), ("memoryHotAddEnabled", "boolean", "vim.version.version4", F_OPTIONAL), ("cpuHotAddEnabled", "boolean", "vim.version.version4", F_OPTIONAL), ("cpuHotRemoveEnabled", "boolean", "vim.version.version4", F_OPTIONAL), ("virtualICH7MPresent", "boolean", "vim.version.version7", F_OPTIONAL), ("virtualSMCPresent", "boolean", "vim.version.version7", F_OPTIONAL), ("deviceChange", "vim.vm.device.VirtualDeviceSpec[]", "vim.version.version1", F_OPTIONAL), ("cpuAllocation", "vim.ResourceAllocationInfo", "vim.version.version1", F_OPTIONAL), ("memoryAllocation", "vim.ResourceAllocationInfo", "vim.version.version1", F_OPTIONAL), ("latencySensitivity", "vim.LatencySensitivity", "vim.version.version8", F_OPTIONAL), ("cpuAffinity", "vim.vm.AffinityInfo", "vim.version.version1", F_OPTIONAL), ("memoryAffinity", "vim.vm.AffinityInfo", "vim.version.version1", F_OPTIONAL), ("networkShaper", "vim.vm.NetworkShaperInfo", "vim.version.version1", F_OPTIONAL), ("cpuFeatureMask", "vim.vm.ConfigSpec.CpuIdInfoSpec[]", "vim.version.version1", F_OPTIONAL), ("extraConfig", "vim.option.OptionValue[]", "vim.version.version1", F_OPTIONAL), ("swapPlacement", "string", "vim.version.version2", F_OPTIONAL), ("bootOptions", "vim.vm.BootOptions", "vim.version.version2", F_OPTIONAL), ("vAppConfig", "vim.vApp.VmConfigSpec", "vim.version.version5", F_OPTIONAL), ("ftInfo", "vim.vm.FaultToleranceConfigInfo", "vim.version.version5", F_OPTIONAL), ("vAppConfigRemoved", "boolean", "vim.version.version5", F_OPTIONAL), ("vAssertsEnabled", "boolean", "vim.version.version5", F_OPTIONAL), ("changeTrackingEnabled", "boolean", "vim.version.version5", F_OPTIONAL), ("firmware", "string", "vim.version.version7", F_OPTIONAL), ("maxMksConnections", "int", "vim.version.version7", F_OPTIONAL), ("guestAutoLockEnabled", "boolean", "vim.version.version7", F_OPTIONAL), ("managedBy", "vim.ext.ManagedByInfo", "vim.version.version7", F_OPTIONAL), ("memoryReservationLockedToMax", "boolean", "vim.version.version7", F_OPTIONAL), ("nestedHVEnabled", "boolean", "vim.version.version8", F_OPTIONAL), ("vPMCEnabled", "boolean", "vim.version.version8", F_OPTIONAL), ("scheduledHardwareUpgradeInfo", "vim.vm.ScheduledHardwareUpgradeInfo", "vim.version.version8", F_OPTIONAL), ("vmProfile", "vim.vm.ProfileSpec[]", "vim.version.version9", F_OPTIONAL)]) +CreateEnumType("vim.vm.ConfigSpec.NpivWwnOp", "VirtualMachineConfigSpecNpivWwnOp", "vim.version.version2", ["generate", "set", "remove", "extend"]) +CreateDataType("vim.vm.ConfigSpec.CpuIdInfoSpec", "VirtualMachineCpuIdInfoSpec", "vim.option.ArrayUpdateSpec", "vim.version.version1", [("info", "vim.host.CpuIdInfo", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.vm.ConsolePreferences", "VirtualMachineConsolePreferences", "vmodl.DynamicData", "vim.version.version1", [("powerOnWhenOpened", "boolean", "vim.version.version1", F_OPTIONAL), ("enterFullScreenOnPowerOn", "boolean", "vim.version.version1", F_OPTIONAL), ("closeOnPowerOffOrSuspend", "boolean", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.vm.DatastoreOption", "DatastoreOption", "vmodl.DynamicData", "vim.version.version1", [("unsupportedVolumes", "vim.vm.DatastoreOption.FileSystemVolumeOption[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.vm.DatastoreOption.FileSystemVolumeOption", "VirtualMachineDatastoreVolumeOption", "vmodl.DynamicData", "vim.version.version1", [("fileSystemType", "vmodl.TypeName", "vim.version.version1", 0), ("majorVersion", "int", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.vm.DefaultPowerOpInfo", "VirtualMachineDefaultPowerOpInfo", "vmodl.DynamicData", "vim.version.version1", [("powerOffType", "string", "vim.version.version1", F_OPTIONAL), ("suspendType", "string", "vim.version.version1", F_OPTIONAL), ("resetType", "string", "vim.version.version1", F_OPTIONAL), ("defaultPowerOffType", "string", "vim.version.version1", F_OPTIONAL), ("defaultSuspendType", "string", "vim.version.version1", F_OPTIONAL), ("defaultResetType", "string", "vim.version.version1", F_OPTIONAL), ("standbyAction", "string", "vim.version.version1", F_OPTIONAL)]) +CreateEnumType("vim.vm.DefaultPowerOpInfo.PowerOpType", "VirtualMachinePowerOpType", "vim.version.version1", ["soft", "hard", "preset"]) +CreateEnumType("vim.vm.DefaultPowerOpInfo.StandbyActionType", "VirtualMachineStandbyActionType", "vim.version.version1", ["checkpoint", "powerOnSuspend"]) +CreateDataType("vim.vm.DeviceRuntimeInfo", "VirtualMachineDeviceRuntimeInfo", "vmodl.DynamicData", "vim.version.version6", [("runtimeState", "vim.vm.DeviceRuntimeInfo.DeviceRuntimeState", "vim.version.version6", 0), ("key", "int", "vim.version.version6", 0)]) +CreateDataType("vim.vm.DeviceRuntimeInfo.DeviceRuntimeState", "VirtualMachineDeviceRuntimeInfoDeviceRuntimeState", "vmodl.DynamicData", "vim.version.version6", None) +CreateDataType("vim.vm.DeviceRuntimeInfo.VirtualEthernetCardRuntimeState", "VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeState", "vim.vm.DeviceRuntimeInfo.DeviceRuntimeState", "vim.version.version6", [("vmDirectPathGen2Active", "boolean", "vim.version.version6", 0), ("vmDirectPathGen2InactiveReasonVm", "string[]", "vim.version.version6", F_OPTIONAL), ("vmDirectPathGen2InactiveReasonOther", "string[]", "vim.version.version6", F_OPTIONAL), ("vmDirectPathGen2InactiveReasonExtended", "string", "vim.version.version6", F_OPTIONAL), ("reservationStatus", "string", "vim.version.version9", F_OPTIONAL)]) +CreateEnumType("vim.vm.DeviceRuntimeInfo.VirtualEthernetCardRuntimeState.VmDirectPathGen2InactiveReasonVm", "VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm", "vim.version.version6", ["vmNptIncompatibleGuest", "vmNptIncompatibleGuestDriver", "vmNptIncompatibleAdapterType", "vmNptDisabledOrDisconnectedAdapter", "vmNptIncompatibleAdapterFeatures", "vmNptIncompatibleBackingType", "vmNptInsufficientMemoryReservation", "vmNptFaultToleranceOrRecordReplayConfigured", "vmNptConflictingIOChainConfigured", "vmNptMonitorBlocks", "vmNptConflictingOperationInProgress", "vmNptRuntimeError", "vmNptOutOfIntrVector", "vmNptVMCIActive"]) +CreateEnumType("vim.vm.DeviceRuntimeInfo.VirtualEthernetCardRuntimeState.VmDirectPathGen2InactiveReasonOther", "VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOther", "vim.version.version6", ["vmNptIncompatibleHost", "vmNptIncompatibleNetwork"]) +CreateDataType("vim.vm.FaultToleranceConfigInfo", "FaultToleranceConfigInfo", "vmodl.DynamicData", "vim.version.version5", [("role", "int", "vim.version.version5", 0), ("instanceUuids", "string[]", "vim.version.version5", 0), ("configPaths", "string[]", "vim.version.version5", 0)]) +CreateDataType("vim.vm.FaultTolerancePrimaryConfigInfo", "FaultTolerancePrimaryConfigInfo", "vim.vm.FaultToleranceConfigInfo", "vim.version.version5", [("secondaries", "vim.VirtualMachine[]", "vim.version.version5", 0)]) +CreateDataType("vim.vm.FaultToleranceSecondaryConfigInfo", "FaultToleranceSecondaryConfigInfo", "vim.vm.FaultToleranceConfigInfo", "vim.version.version5", [("primaryVM", "vim.VirtualMachine", "vim.version.version5", 0)]) +CreateDataType("vim.vm.FaultToleranceSecondaryOpResult", "FaultToleranceSecondaryOpResult", "vmodl.DynamicData", "vim.version.version5", [("vm", "vim.VirtualMachine", "vim.version.version5", 0), ("powerOnAttempted", "boolean", "vim.version.version5", 0), ("powerOnResult", "vim.cluster.PowerOnVmResult", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.vm.FeatureRequirement", "VirtualMachineFeatureRequirement", "vmodl.DynamicData", "vim.version.version8", [("key", "string", "vim.version.version8", 0), ("featureName", "string", "vim.version.version8", 0), ("value", "string", "vim.version.version8", 0)]) +CreateDataType("vim.vm.FileInfo", "VirtualMachineFileInfo", "vmodl.DynamicData", "vim.version.version1", [("vmPathName", "string", "vim.version.version1", F_OPTIONAL), ("snapshotDirectory", "string", "vim.version.version1", F_OPTIONAL), ("suspendDirectory", "string", "vim.version.version1", F_OPTIONAL), ("logDirectory", "string", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.vm.FileLayout", "VirtualMachineFileLayout", "vmodl.DynamicData", "vim.version.version1", [("configFile", "string[]", "vim.version.version1", F_OPTIONAL), ("logFile", "string[]", "vim.version.version1", F_OPTIONAL), ("disk", "vim.vm.FileLayout.DiskLayout[]", "vim.version.version1", F_OPTIONAL), ("snapshot", "vim.vm.FileLayout.SnapshotLayout[]", "vim.version.version1", F_OPTIONAL), ("swapFile", "string", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.vm.FileLayout.DiskLayout", "VirtualMachineFileLayoutDiskLayout", "vmodl.DynamicData", "vim.version.version1", [("key", "int", "vim.version.version1", 0), ("diskFile", "string[]", "vim.version.version1", 0)]) +CreateDataType("vim.vm.FileLayout.SnapshotLayout", "VirtualMachineFileLayoutSnapshotLayout", "vmodl.DynamicData", "vim.version.version1", [("key", "vim.vm.Snapshot", "vim.version.version1", 0), ("snapshotFile", "string[]", "vim.version.version1", 0)]) +CreateDataType("vim.vm.FileLayoutEx", "VirtualMachineFileLayoutEx", "vmodl.DynamicData", "vim.version.version5", [("file", "vim.vm.FileLayoutEx.FileInfo[]", "vim.version.version5", F_OPTIONAL), ("disk", "vim.vm.FileLayoutEx.DiskLayout[]", "vim.version.version5", F_OPTIONAL), ("snapshot", "vim.vm.FileLayoutEx.SnapshotLayout[]", "vim.version.version5", F_OPTIONAL), ("timestamp", "vmodl.DateTime", "vim.version.version5", 0)]) +CreateEnumType("vim.vm.FileLayoutEx.FileType", "VirtualMachineFileLayoutExFileType", "vim.version.version5", ["config", "extendedConfig", "diskDescriptor", "diskExtent", "digestDescriptor", "digestExtent", "diskReplicationState", "log", "stat", "namespaceData", "nvram", "snapshotData", "snapshotList", "snapshotManifestList", "suspend", "swap", "uwswap", "core", "screenshot", "ftMetadata"]) +CreateDataType("vim.vm.FileLayoutEx.FileInfo", "VirtualMachineFileLayoutExFileInfo", "vmodl.DynamicData", "vim.version.version5", [("key", "int", "vim.version.version5", 0), ("name", "string", "vim.version.version5", 0), ("type", "string", "vim.version.version5", 0), ("size", "long", "vim.version.version5", 0), ("uniqueSize", "long", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.vm.FileLayoutEx.DiskUnit", "VirtualMachineFileLayoutExDiskUnit", "vmodl.DynamicData", "vim.version.version5", [("fileKey", "int[]", "vim.version.version5", 0)]) +CreateDataType("vim.vm.FileLayoutEx.DiskLayout", "VirtualMachineFileLayoutExDiskLayout", "vmodl.DynamicData", "vim.version.version5", [("key", "int", "vim.version.version5", 0), ("chain", "vim.vm.FileLayoutEx.DiskUnit[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.vm.FileLayoutEx.SnapshotLayout", "VirtualMachineFileLayoutExSnapshotLayout", "vmodl.DynamicData", "vim.version.version5", [("key", "vim.vm.Snapshot", "vim.version.version5", 0), ("dataKey", "int", "vim.version.version5", 0), ("disk", "vim.vm.FileLayoutEx.DiskLayout[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.vm.FlagInfo", "VirtualMachineFlagInfo", "vmodl.DynamicData", "vim.version.version1", [("disableAcceleration", "boolean", "vim.version.version1", F_OPTIONAL), ("enableLogging", "boolean", "vim.version.version1", F_OPTIONAL), ("useToe", "boolean", "vim.version.version1", F_OPTIONAL), ("runWithDebugInfo", "boolean", "vim.version.version1", F_OPTIONAL), ("monitorType", "string", "vim.version.version2", F_OPTIONAL), ("htSharing", "string", "vim.version.version1", F_OPTIONAL), ("snapshotDisabled", "boolean", "vim.version.version2", F_OPTIONAL), ("snapshotLocked", "boolean", "vim.version.version2", F_OPTIONAL), ("diskUuidEnabled", "boolean", "vim.version.version2", F_OPTIONAL), ("virtualMmuUsage", "string", "vim.version.version2", F_OPTIONAL), ("virtualExecUsage", "string", "vim.version.version5", F_OPTIONAL), ("snapshotPowerOffBehavior", "string", "vim.version.version2", F_OPTIONAL), ("recordReplayEnabled", "boolean", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.vm.FlagInfo.HtSharing", "VirtualMachineHtSharing", "vim.version.version1", ["any", "none", "internal"]) +CreateEnumType("vim.vm.FlagInfo.PowerOffBehavior", "VirtualMachinePowerOffBehavior", "vim.version.version2", ["powerOff", "revert", "prompt"]) +CreateEnumType("vim.vm.FlagInfo.MonitorType", "VirtualMachineFlagInfoMonitorType", "vim.version.version2", ["release", "debug", "stats"]) +CreateEnumType("vim.vm.FlagInfo.VirtualMmuUsage", "VirtualMachineFlagInfoVirtualMmuUsage", "vim.version.version2", ["automatic", "on", "off"]) +CreateEnumType("vim.vm.FlagInfo.VirtualExecUsage", "VirtualMachineFlagInfoVirtualExecUsage", "vim.version.version5", ["hvAuto", "hvOn", "hvOff"]) +CreateDataType("vim.vm.GuestInfo", "GuestInfo", "vmodl.DynamicData", "vim.version.version1", [("toolsStatus", "vim.vm.GuestInfo.ToolsStatus", "vim.version.version1", F_OPTIONAL), ("toolsVersionStatus", "string", "vim.version.version5", F_OPTIONAL), ("toolsVersionStatus2", "string", "vim.version.version7", F_OPTIONAL), ("toolsRunningStatus", "string", "vim.version.version5", F_OPTIONAL), ("toolsVersion", "string", "vim.version.version1", F_OPTIONAL), ("guestId", "string", "vim.version.version1", F_OPTIONAL), ("guestFamily", "string", "vim.version.version1", F_OPTIONAL), ("guestFullName", "string", "vim.version.version1", F_OPTIONAL), ("hostName", "string", "vim.version.version1", F_OPTIONAL), ("ipAddress", "string", "vim.version.version1", F_OPTIONAL), ("net", "vim.vm.GuestInfo.NicInfo[]", "vim.version.version1", F_OPTIONAL), ("ipStack", "vim.vm.GuestInfo.StackInfo[]", "vim.version.version6", F_OPTIONAL), ("disk", "vim.vm.GuestInfo.DiskInfo[]", "vim.version.version1", F_OPTIONAL), ("screen", "vim.vm.GuestInfo.ScreenInfo", "vim.version.version1", F_OPTIONAL), ("guestState", "string", "vim.version.version1", 0), ("appHeartbeatStatus", "string", "vim.version.version6", F_OPTIONAL), ("appState", "string", "vim.version.version9", F_OPTIONAL), ("guestOperationsReady", "boolean", "vim.version.version7", F_OPTIONAL), ("interactiveGuestOperationsReady", "boolean", "vim.version.version7", F_OPTIONAL), ("generationInfo", "vim.vm.GuestInfo.NamespaceGenerationInfo[]", "vim.version.version8", F_OPTIONAL)]) +CreateEnumType("vim.vm.GuestInfo.ToolsStatus", "VirtualMachineToolsStatus", "vim.version.version1", ["toolsNotInstalled", "toolsNotRunning", "toolsOld", "toolsOk"]) +CreateEnumType("vim.vm.GuestInfo.ToolsVersionStatus", "VirtualMachineToolsVersionStatus", "vim.version.version5", ["guestToolsNotInstalled", "guestToolsNeedUpgrade", "guestToolsCurrent", "guestToolsUnmanaged", "guestToolsTooOld", "guestToolsSupportedOld", "guestToolsSupportedNew", "guestToolsTooNew", "guestToolsBlacklisted"]) +CreateEnumType("vim.vm.GuestInfo.ToolsRunningStatus", "VirtualMachineToolsRunningStatus", "vim.version.version5", ["guestToolsNotRunning", "guestToolsRunning", "guestToolsExecutingScripts"]) +CreateDataType("vim.vm.GuestInfo.DiskInfo", "GuestDiskInfo", "vmodl.DynamicData", "vim.version.version1", [("diskPath", "string", "vim.version.version1", F_OPTIONAL), ("capacity", "long", "vim.version.version1", F_OPTIONAL), ("freeSpace", "long", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.vm.GuestInfo.NicInfo", "GuestNicInfo", "vmodl.DynamicData", "vim.version.version1", [("network", "string", "vim.version.version1", F_OPTIONAL), ("ipAddress", "string[]", "vim.version.version1", F_OPTIONAL), ("macAddress", "string", "vim.version.version1", F_OPTIONAL), ("connected", "boolean", "vim.version.version1", 0), ("deviceConfigId", "int", "vim.version.version1", 0), ("dnsConfig", "vim.net.DnsConfigInfo", "vim.version.version6", F_OPTIONAL), ("ipConfig", "vim.net.IpConfigInfo", "vim.version.version6", F_OPTIONAL), ("netBIOSConfig", "vim.net.NetBIOSConfigInfo", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.vm.GuestInfo.StackInfo", "GuestStackInfo", "vmodl.DynamicData", "vim.version.version6", [("dnsConfig", "vim.net.DnsConfigInfo", "vim.version.version6", F_OPTIONAL), ("ipRouteConfig", "vim.net.IpRouteConfigInfo", "vim.version.version6", F_OPTIONAL), ("ipStackConfig", "vim.KeyValue[]", "vim.version.version6", F_OPTIONAL), ("dhcpConfig", "vim.net.DhcpConfigInfo", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.vm.GuestInfo.ScreenInfo", "GuestScreenInfo", "vmodl.DynamicData", "vim.version.version1", [("width", "int", "vim.version.version1", 0), ("height", "int", "vim.version.version1", 0)]) +CreateEnumType("vim.vm.GuestInfo.GuestState", "VirtualMachineGuestState", "vim.version.version1", ["running", "shuttingDown", "resetting", "standby", "notRunning", "unknown"]) +CreateEnumType("vim.vm.GuestInfo.AppStateType", "GuestInfoAppStateType", "vim.version.version9", ["none", "appStateOk", "appStateNeedReset"]) +CreateDataType("vim.vm.GuestInfo.NamespaceGenerationInfo", "GuestInfoNamespaceGenerationInfo", "vmodl.DynamicData", "vim.version.version8", [("key", "string", "vim.version.version8", 0), ("generationNo", "int", "vim.version.version8", 0)]) +CreateDataType("vim.vm.GuestOsDescriptor", "GuestOsDescriptor", "vmodl.DynamicData", "vim.version.version1", [("id", "string", "vim.version.version1", 0), ("family", "string", "vim.version.version1", 0), ("fullName", "string", "vim.version.version1", 0), ("supportedMaxCPUs", "int", "vim.version.version1", 0), ("numSupportedPhysicalSockets", "int", "vim.version.version7", 0), ("numSupportedCoresPerSocket", "int", "vim.version.version7", 0), ("supportedMinMemMB", "int", "vim.version.version1", 0), ("supportedMaxMemMB", "int", "vim.version.version1", 0), ("recommendedMemMB", "int", "vim.version.version1", 0), ("recommendedColorDepth", "int", "vim.version.version1", 0), ("supportedDiskControllerList", "vmodl.TypeName[]", "vim.version.version1", 0), ("recommendedSCSIController", "vmodl.TypeName", "vim.version.version1", F_OPTIONAL), ("recommendedDiskController", "vmodl.TypeName", "vim.version.version1", 0), ("supportedNumDisks", "int", "vim.version.version1", 0), ("recommendedDiskSizeMB", "int", "vim.version.version1", 0), ("recommendedCdromController", "vmodl.TypeName", "vim.version.version9", 0), ("supportedEthernetCard", "vmodl.TypeName[]", "vim.version.version1", 0), ("recommendedEthernetCard", "vmodl.TypeName", "vim.version.version1", F_OPTIONAL), ("supportsSlaveDisk", "boolean", "vim.version.version1", F_OPTIONAL), ("cpuFeatureMask", "vim.host.CpuIdInfo[]", "vim.version.version1", F_OPTIONAL), ("smcRequired", "boolean", "vim.version.version7", 0), ("supportsWakeOnLan", "boolean", "vim.version.version1", 0), ("supportsVMI", "boolean", "vim.version.version4", 0), ("supportsMemoryHotAdd", "boolean", "vim.version.version4", 0), ("supportsCpuHotAdd", "boolean", "vim.version.version4", 0), ("supportsCpuHotRemove", "boolean", "vim.version.version4", 0), ("supportedFirmware", "string[]", "vim.version.version7", 0), ("recommendedFirmware", "string", "vim.version.version7", 0), ("supportedUSBControllerList", "vmodl.TypeName[]", "vim.version.version7", F_OPTIONAL), ("recommendedUSBController", "vmodl.TypeName", "vim.version.version7", F_OPTIONAL), ("supports3D", "boolean", "vim.version.version7", 0), ("recommended3D", "boolean", "vim.version.version8", 0), ("smcRecommended", "boolean", "vim.version.version7", 0), ("ich7mRecommended", "boolean", "vim.version.version7", 0), ("usbRecommended", "boolean", "vim.version.version7", 0), ("supportLevel", "string", "vim.version.version7", 0), ("supportedForCreate", "boolean", "vim.version.version7", 0), ("vRAMSizeInKB", "vim.option.IntOption", "vim.version.version7", 0)]) +CreateEnumType("vim.vm.GuestOsDescriptor.GuestOsFamily", "VirtualMachineGuestOsFamily", "vim.version.version1", ["windowsGuest", "linuxGuest", "netwareGuest", "solarisGuest", "darwinGuestFamily", "otherGuestFamily"]) +CreateEnumType("vim.vm.GuestOsDescriptor.GuestOsIdentifier", "VirtualMachineGuestOsIdentifier", "vim.version.version1", ["dosGuest", "win31Guest", "win95Guest", "win98Guest", "winMeGuest", "winNTGuest", "win2000ProGuest", "win2000ServGuest", "win2000AdvServGuest", "winXPHomeGuest", "winXPProGuest", "winXPPro64Guest", "winNetWebGuest", "winNetStandardGuest", "winNetEnterpriseGuest", "winNetDatacenterGuest", "winNetBusinessGuest", "winNetStandard64Guest", "winNetEnterprise64Guest", "winLonghornGuest", "winLonghorn64Guest", "winNetDatacenter64Guest", "winVistaGuest", "winVista64Guest", "windows7Guest", "windows7_64Guest", "windows7Server64Guest", "windows8Guest", "windows8_64Guest", "windows8Server64Guest", "windowsHyperVGuest", "freebsdGuest", "freebsd64Guest", "redhatGuest", "rhel2Guest", "rhel3Guest", "rhel3_64Guest", "rhel4Guest", "rhel4_64Guest", "rhel5Guest", "rhel5_64Guest", "rhel6Guest", "rhel6_64Guest", "rhel7Guest", "rhel7_64Guest", "centosGuest", "centos64Guest", "oracleLinuxGuest", "oracleLinux64Guest", "suseGuest", "suse64Guest", "slesGuest", "sles64Guest", "sles10Guest", "sles10_64Guest", "sles11Guest", "sles11_64Guest", "sles12Guest", "sles12_64Guest", "nld9Guest", "oesGuest", "sjdsGuest", "mandrakeGuest", "mandrivaGuest", "mandriva64Guest", "turboLinuxGuest", "turboLinux64Guest", "ubuntuGuest", "ubuntu64Guest", "debian4Guest", "debian4_64Guest", "debian5Guest", "debian5_64Guest", "debian6Guest", "debian6_64Guest", "debian7Guest", "debian7_64Guest", "asianux3Guest", "asianux3_64Guest", "asianux4Guest", "asianux4_64Guest", "opensuseGuest", "opensuse64Guest", "fedoraGuest", "fedora64Guest", "other24xLinuxGuest", "other26xLinuxGuest", "otherLinuxGuest", "other3xLinuxGuest", "genericLinuxGuest", "other24xLinux64Guest", "other26xLinux64Guest", "other3xLinux64Guest", "otherLinux64Guest", "solaris6Guest", "solaris7Guest", "solaris8Guest", "solaris9Guest", "solaris10Guest", "solaris10_64Guest", "solaris11_64Guest", "os2Guest", "eComStationGuest", "eComStation2Guest", "netware4Guest", "netware5Guest", "netware6Guest", "openServer5Guest", "openServer6Guest", "unixWare7Guest", "darwinGuest", "darwin64Guest", "darwin10Guest", "darwin10_64Guest", "darwin11Guest", "darwin11_64Guest", "darwin12_64Guest", "darwin13_64Guest", "vmkernelGuest", "vmkernel5Guest", "otherGuest", "otherGuest64"]) +CreateEnumType("vim.vm.GuestOsDescriptor.FirmwareType", "GuestOsDescriptorFirmwareType", "vim.version.version7", ["bios", "efi", "csm"]) +CreateEnumType("vim.vm.GuestOsDescriptor.SupportLevel", "GuestOsDescriptorSupportLevel", "vim.version.version7", ["experimental", "legacy", "terminated", "supported", "unsupported", "deprecated", "techPreview"]) +CreateDataType("vim.vm.LegacyNetworkSwitchInfo", "VirtualMachineLegacyNetworkSwitchInfo", "vmodl.DynamicData", "vim.version.version1", [("name", "string", "vim.version.version1", 0)]) +CreateDataType("vim.vm.Message", "VirtualMachineMessage", "vmodl.DynamicData", "vim.version.version2", [("id", "string", "vim.version.version2", 0), ("argument", "anyType[]", "vim.version.version2", F_OPTIONAL), ("text", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.vm.MetadataManager.VmMetadataOwner", "VirtualMachineMetadataManagerVmMetadataOwner", "vmodl.DynamicData", "vim.version.version9", [("name", "string", "vim.version.version9", 0)]) +CreateEnumType("vim.vm.MetadataManager.VmMetadataOwner.Owner", "VirtualMachineMetadataManagerVmMetadataOwnerOwner", "vim.version.version9", ["ComVmwareVsphereHA"]) +CreateEnumType("vim.vm.MetadataManager.VmMetadataOp", "VirtualMachineMetadataManagerVmMetadataOp", "vim.version.version9", ["Update", "Remove"]) +CreateDataType("vim.vm.MetadataManager.VmMetadata", "VirtualMachineMetadataManagerVmMetadata", "vmodl.DynamicData", "vim.version.version9", [("vmId", "string", "vim.version.version9", 0), ("metadata", "string", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.vm.MetadataManager.VmMetadataInput", "VirtualMachineMetadataManagerVmMetadataInput", "vmodl.DynamicData", "vim.version.version9", [("operation", "string", "vim.version.version9", 0), ("vmMetadata", "vim.vm.MetadataManager.VmMetadata", "vim.version.version9", 0)]) +CreateDataType("vim.vm.MetadataManager.VmMetadataResult", "VirtualMachineMetadataManagerVmMetadataResult", "vmodl.DynamicData", "vim.version.version9", [("vmMetadata", "vim.vm.MetadataManager.VmMetadata", "vim.version.version9", 0), ("error", "vmodl.MethodFault", "vim.version.version9", F_OPTIONAL)]) +CreateEnumType("vim.vm.NamespaceManager.DataSpec.OpCode", "VirtualMachineNamespaceManagerDataSpecOpCode", "vim.version.version8", ["updateAlways", "updateIfEqual"]) +CreateDataType("vim.vm.NetworkShaperInfo", "VirtualMachineNetworkShaperInfo", "vmodl.DynamicData", "vim.version.version1", [("enabled", "boolean", "vim.version.version1", F_OPTIONAL), ("peakBps", "long", "vim.version.version1", F_OPTIONAL), ("averageBps", "long", "vim.version.version1", F_OPTIONAL), ("burstSize", "long", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.vm.ProfileRawData", "VirtualMachineProfileRawData", "vmodl.DynamicData", "vim.version.version9", [("extensionKey", "string", "vim.version.version9", 0), ("objectData", "string", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.vm.ProfileSpec", "VirtualMachineProfileSpec", "vmodl.DynamicData", "vim.version.version9", None) +CreateEnumType("vim.vm.ProvisioningPolicy.OpType", "VirtualMachineProvisioningPolicyOpType", "vim.version.version7", ["clone", "migrate", "createSecondary"]) +CreateEnumType("vim.vm.ProvisioningPolicy.Action", "VirtualMachineProvisioningPolicyAction", "vim.version.version7", ["keep", "remove"]) +CreateDataType("vim.vm.QuestionInfo", "VirtualMachineQuestionInfo", "vmodl.DynamicData", "vim.version.version1", [("id", "string", "vim.version.version1", 0), ("text", "string", "vim.version.version1", 0), ("choice", "vim.option.ChoiceOption", "vim.version.version1", 0), ("message", "vim.vm.Message[]", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.vm.ReplicationConfigSpec.DiskSettings", "ReplicationInfoDiskSettings", "vmodl.DynamicData", "vim.version.version7", [("key", "int", "vim.version.version7", 0), ("diskReplicationId", "string", "vim.version.version7", 0)]) +CreateDataType("vim.vm.ScheduledHardwareUpgradeInfo", "ScheduledHardwareUpgradeInfo", "vmodl.DynamicData", "vim.version.version8", [("upgradePolicy", "string", "vim.version.version8", F_OPTIONAL), ("versionKey", "string", "vim.version.version8", F_OPTIONAL), ("scheduledHardwareUpgradeStatus", "string", "vim.version.version8", F_OPTIONAL), ("fault", "vmodl.MethodFault", "vim.version.version8", F_OPTIONAL)]) +CreateEnumType("vim.vm.ScheduledHardwareUpgradeInfo.HardwareUpgradePolicy", "ScheduledHardwareUpgradeInfoHardwareUpgradePolicy", "vim.version.version8", ["never", "onSoftPowerOff", "always"]) +CreateEnumType("vim.vm.ScheduledHardwareUpgradeInfo.HardwareUpgradeStatus", "ScheduledHardwareUpgradeInfoHardwareUpgradeStatus", "vim.version.version8", ["none", "pending", "success", "failed"]) +CreateManagedType("vim.vm.Snapshot", "VirtualMachineSnapshot", "vim.ExtensibleManagedObject", "vim.version.version1", [("config", "vim.vm.ConfigInfo", "vim.version.version1", 0, None), ("childSnapshot", "vim.vm.Snapshot[]", "vim.version.version6", F_OPTIONAL, None)], [("revert", "RevertToSnapshot_Task", "vim.version.version1", (("host", "vim.HostSystem", "vim.version.version1", F_OPTIONAL, None),("suppressPowerOn", "boolean", "vim.version.version4", F_OPTIONAL, None),), (0, "vim.Task", "void"), "VirtualMachine.State.RevertToSnapshot", ["vim.fault.TaskInProgress", "vim.fault.InsufficientResourcesFault", "vim.fault.InvalidState", "vim.fault.FileFault", "vim.fault.VmConfigFault", ]), ("remove", "RemoveSnapshot_Task", "vim.version.version1", (("removeChildren", "boolean", "vim.version.version1", 0, None),("consolidate", "boolean", "vim.version.version7", F_OPTIONAL, None),), (0, "vim.Task", "void"), "VirtualMachine.State.RemoveSnapshot", ["vim.fault.TaskInProgress", ]), ("rename", "RenameSnapshot", "vim.version.version1", (("name", "string", "vim.version.version1", F_OPTIONAL, None),("description", "string", "vim.version.version1", F_OPTIONAL, None),), (0, "void", "void"), "VirtualMachine.State.RenameSnapshot", ["vim.fault.InvalidName", "vim.fault.TaskInProgress", "vim.fault.InvalidState", ]), ("exportSnapshot", "ExportSnapshot", "vim.version.version9", (), (0, "vim.HttpNfcLease", "vim.HttpNfcLease"), "VApp.Export", ["vim.fault.TaskInProgress", "vim.fault.InvalidState", "vim.fault.FileFault", ])]) +CreateDataType("vim.vm.SnapshotInfo", "VirtualMachineSnapshotInfo", "vmodl.DynamicData", "vim.version.version1", [("currentSnapshot", "vim.vm.Snapshot", "vim.version.version1", F_OPTIONAL), ("rootSnapshotList", "vim.vm.SnapshotTree[]", "vim.version.version1", 0)]) +CreateDataType("vim.vm.StorageInfo", "VirtualMachineStorageInfo", "vmodl.DynamicData", "vim.version.version5", [("perDatastoreUsage", "vim.vm.StorageInfo.UsageOnDatastore[]", "vim.version.version5", F_OPTIONAL), ("timestamp", "vmodl.DateTime", "vim.version.version5", 0)]) +CreateDataType("vim.vm.StorageInfo.UsageOnDatastore", "VirtualMachineUsageOnDatastore", "vmodl.DynamicData", "vim.version.version5", [("datastore", "vim.Datastore", "vim.version.version5", 0), ("committed", "long", "vim.version.version5", 0), ("uncommitted", "long", "vim.version.version5", 0), ("unshared", "long", "vim.version.version5", 0)]) +CreateDataType("vim.vm.TargetInfo", "VirtualMachineTargetInfo", "vmodl.DynamicData", "vim.version.version1", [("name", "string", "vim.version.version1", 0), ("configurationTag", "string[]", "vim.version.version1", F_OPTIONAL)]) +CreateEnumType("vim.vm.TargetInfo.ConfigurationTag", "VirtualMachineTargetInfoConfigurationTag", "vim.version.version1", ["compliant", "clusterWide"]) +CreateDataType("vim.vm.ToolsConfigInfo", "ToolsConfigInfo", "vmodl.DynamicData", "vim.version.version1", [("toolsVersion", "int", "vim.version.version1", F_OPTIONAL), ("afterPowerOn", "boolean", "vim.version.version1", F_OPTIONAL), ("afterResume", "boolean", "vim.version.version1", F_OPTIONAL), ("beforeGuestStandby", "boolean", "vim.version.version1", F_OPTIONAL), ("beforeGuestShutdown", "boolean", "vim.version.version1", F_OPTIONAL), ("beforeGuestReboot", "boolean", "vim.version.version1", F_OPTIONAL), ("toolsUpgradePolicy", "string", "vim.version.version2", F_OPTIONAL), ("pendingCustomization", "string", "vim.version.version2", F_OPTIONAL), ("syncTimeWithHost", "boolean", "vim.version.version2", F_OPTIONAL), ("lastInstallInfo", "vim.vm.ToolsConfigInfo.ToolsLastInstallInfo", "vim.version.version7", F_OPTIONAL)]) +CreateEnumType("vim.vm.ToolsConfigInfo.UpgradePolicy", "UpgradePolicy", "vim.version.version2", ["manual", "upgradeAtPowerCycle"]) +CreateDataType("vim.vm.ToolsConfigInfo.ToolsLastInstallInfo", "ToolsConfigInfoToolsLastInstallInfo", "vmodl.DynamicData", "vim.version.version7", [("counter", "int", "vim.version.version7", 0), ("fault", "vmodl.MethodFault", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.vm.UsbInfo", "VirtualMachineUsbInfo", "vim.vm.TargetInfo", "vim.version.version2", [("description", "string", "vim.version.version2", 0), ("vendor", "int", "vim.version.version2", 0), ("product", "int", "vim.version.version2", 0), ("physicalPath", "string", "vim.version.version2", 0), ("family", "string[]", "vim.version.version2", F_OPTIONAL), ("speed", "string[]", "vim.version.version2", F_OPTIONAL), ("summary", "vim.vm.Summary", "vim.version.version2", F_OPTIONAL)]) +CreateEnumType("vim.vm.UsbInfo.Speed", "VirtualMachineUsbInfoSpeed", "vim.version.version2", ["low", "full", "high", "superSpeed", "unknownSpeed"]) +CreateEnumType("vim.vm.UsbInfo.Family", "VirtualMachineUsbInfoFamily", "vim.version.version2", ["audio", "hid", "hid_bootable", "physical", "communication", "imaging", "printer", "storage", "hub", "smart_card", "security", "video", "wireless", "bluetooth", "wusb", "pda", "vendor_specific", "other", "unknownFamily"]) +CreateDataType("vim.vm.VirtualHardware", "VirtualHardware", "vmodl.DynamicData", "vim.version.version1", [("numCPU", "int", "vim.version.version1", 0), ("numCoresPerSocket", "int", "vim.version.version7", F_OPTIONAL), ("memoryMB", "int", "vim.version.version1", 0), ("virtualICH7MPresent", "boolean", "vim.version.version7", F_OPTIONAL), ("virtualSMCPresent", "boolean", "vim.version.version7", F_OPTIONAL), ("device", "vim.vm.device.VirtualDevice[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.vm.VirtualHardwareOption", "VirtualHardwareOption", "vmodl.DynamicData", "vim.version.version1", [("hwVersion", "int", "vim.version.version1", 0), ("virtualDeviceOption", "vim.vm.device.VirtualDeviceOption[]", "vim.version.version1", 0), ("deviceListReadonly", "boolean", "vim.version.version1", 0), ("numCPU", "int[]", "vim.version.version1", 0), ("numCoresPerSocket", "vim.option.IntOption", "vim.version.version7", 0), ("numCpuReadonly", "boolean", "vim.version.version1", 0), ("memoryMB", "vim.option.LongOption", "vim.version.version1", 0), ("numPCIControllers", "vim.option.IntOption", "vim.version.version1", 0), ("numIDEControllers", "vim.option.IntOption", "vim.version.version1", 0), ("numUSBControllers", "vim.option.IntOption", "vim.version.version1", 0), ("numUSBXHCIControllers", "vim.option.IntOption", "vim.version.version7", 0), ("numSIOControllers", "vim.option.IntOption", "vim.version.version1", 0), ("numPS2Controllers", "vim.option.IntOption", "vim.version.version1", 0), ("licensingLimit", "vmodl.PropertyPath[]", "vim.version.version1", F_OPTIONAL), ("numSupportedWwnPorts", "vim.option.IntOption", "vim.version.version5", F_OPTIONAL), ("numSupportedWwnNodes", "vim.option.IntOption", "vim.version.version5", F_OPTIONAL), ("resourceConfigOption", "vim.ResourceConfigOption", "vim.version.version6", 0)]) +CreateManagedType("vim.vm.check.CompatibilityChecker", "VirtualMachineCompatibilityChecker", "vmodl.ManagedObject", "vim.version.version5", None, [("checkCompatibility", "CheckCompatibility_Task", "vim.version.version5", (("vm", "vim.VirtualMachine", "vim.version.version5", 0, None),("host", "vim.HostSystem", "vim.version.version5", F_OPTIONAL, None),("pool", "vim.ResourcePool", "vim.version.version5", F_OPTIONAL, None),("testType", "string[]", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.Task", "vim.vm.check.Result[]"), "System.View", ["vim.fault.InvalidState", "vim.fault.NoActiveHostInCluster", ])]) +CreateDataType("vim.vm.check.Result", "CheckResult", "vmodl.DynamicData", "vim.version.version5", [("vm", "vim.VirtualMachine", "vim.version.version5", F_OPTIONAL), ("host", "vim.HostSystem", "vim.version.version5", F_OPTIONAL), ("warning", "vmodl.MethodFault[]", "vim.version.version5", F_OPTIONAL), ("error", "vmodl.MethodFault[]", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.vm.check.TestType", "CheckTestType", "vim.version.version5", ["sourceTests", "hostTests", "resourcePoolTests", "datastoreTests", "networkTests"]) +CreateDataType("vim.vm.customization.IPSettings", "CustomizationIPSettings", "vmodl.DynamicData", "vim.version.version1", [("ip", "vim.vm.customization.IpGenerator", "vim.version.version1", 0), ("subnetMask", "string", "vim.version.version1", F_OPTIONAL), ("gateway", "string[]", "vim.version.version1", F_OPTIONAL), ("ipV6Spec", "vim.vm.customization.IPSettings.IpV6AddressSpec", "vim.version.version5", F_OPTIONAL), ("dnsServerList", "string[]", "vim.version.version1", F_OPTIONAL), ("dnsDomain", "string", "vim.version.version1", F_OPTIONAL), ("primaryWINS", "string", "vim.version.version1", F_OPTIONAL), ("secondaryWINS", "string", "vim.version.version1", F_OPTIONAL), ("netBIOS", "vim.vm.customization.IPSettings.NetBIOSMode", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.vm.customization.IPSettings.IpV6AddressSpec", "CustomizationIPSettingsIpV6AddressSpec", "vmodl.DynamicData", "vim.version.version5", [("ip", "vim.vm.customization.IpV6Generator[]", "vim.version.version5", 0), ("gateway", "string[]", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.vm.customization.IPSettings.NetBIOSMode", "CustomizationNetBIOSMode", "vim.version.version1", ["enableNetBIOSViaDhcp", "enableNetBIOS", "disableNetBIOS"]) +CreateDataType("vim.vm.customization.Specification", "CustomizationSpec", "vmodl.DynamicData", "vim.version.version1", [("options", "vim.vm.customization.Options", "vim.version.version1", F_OPTIONAL), ("identity", "vim.vm.customization.IdentitySettings", "vim.version.version1", 0), ("globalIPSettings", "vim.vm.customization.GlobalIPSettings", "vim.version.version1", 0), ("nicSettingMap", "vim.vm.customization.AdapterMapping[]", "vim.version.version1", F_OPTIONAL), ("encryptionKey", "byte[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.vm.customization.NameGenerator", "CustomizationName", "vmodl.DynamicData", "vim.version.version1", None) +CreateDataType("vim.vm.customization.FixedName", "CustomizationFixedName", "vim.vm.customization.NameGenerator", "vim.version.version1", [("name", "string", "vim.version.version1", 0)]) +CreateDataType("vim.vm.customization.PrefixNameGenerator", "CustomizationPrefixName", "vim.vm.customization.NameGenerator", "vim.version.version1", [("base", "string", "vim.version.version1", 0)]) +CreateDataType("vim.vm.customization.VirtualMachineNameGenerator", "CustomizationVirtualMachineName", "vim.vm.customization.NameGenerator", "vim.version.version1", None) +CreateDataType("vim.vm.customization.UnknownNameGenerator", "CustomizationUnknownName", "vim.vm.customization.NameGenerator", "vim.version.version1", None) +CreateDataType("vim.vm.customization.CustomNameGenerator", "CustomizationCustomName", "vim.vm.customization.NameGenerator", "vim.version.version1", [("argument", "string", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.vm.customization.Password", "CustomizationPassword", "vmodl.DynamicData", "vim.version.version1", [("value", "string", "vim.version.version1", 0), ("plainText", "boolean", "vim.version.version1", 0)]) +CreateDataType("vim.vm.customization.Options", "CustomizationOptions", "vmodl.DynamicData", "vim.version.version1", None) +CreateDataType("vim.vm.customization.WinOptions", "CustomizationWinOptions", "vim.vm.customization.Options", "vim.version.version1", [("changeSID", "boolean", "vim.version.version1", 0), ("deleteAccounts", "boolean", "vim.version.version1", 0), ("reboot", "vim.vm.customization.WinOptions.SysprepRebootOption", "vim.version.version2", F_OPTIONAL)]) +CreateEnumType("vim.vm.customization.WinOptions.SysprepRebootOption", "CustomizationSysprepRebootOption", "vim.version.version2", ["reboot", "noreboot", "shutdown"]) +CreateDataType("vim.vm.customization.LinuxOptions", "CustomizationLinuxOptions", "vim.vm.customization.Options", "vim.version.version1", None) +CreateDataType("vim.vm.customization.GuiUnattended", "CustomizationGuiUnattended", "vmodl.DynamicData", "vim.version.version1", [("password", "vim.vm.customization.Password", "vim.version.version1", F_OPTIONAL), ("timeZone", "int", "vim.version.version1", 0), ("autoLogon", "boolean", "vim.version.version1", 0), ("autoLogonCount", "int", "vim.version.version1", 0)]) +CreateDataType("vim.vm.customization.UserData", "CustomizationUserData", "vmodl.DynamicData", "vim.version.version1", [("fullName", "string", "vim.version.version1", 0), ("orgName", "string", "vim.version.version1", 0), ("computerName", "vim.vm.customization.NameGenerator", "vim.version.version1", 0), ("productId", "string", "vim.version.version1", 0)]) +CreateDataType("vim.vm.customization.GuiRunOnce", "CustomizationGuiRunOnce", "vmodl.DynamicData", "vim.version.version1", [("commandList", "string[]", "vim.version.version1", 0)]) +CreateDataType("vim.vm.customization.Identification", "CustomizationIdentification", "vmodl.DynamicData", "vim.version.version1", [("joinWorkgroup", "string", "vim.version.version1", F_OPTIONAL), ("joinDomain", "string", "vim.version.version1", F_OPTIONAL), ("domainAdmin", "string", "vim.version.version1", F_OPTIONAL), ("domainAdminPassword", "vim.vm.customization.Password", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.vm.customization.LicenseFilePrintData", "CustomizationLicenseFilePrintData", "vmodl.DynamicData", "vim.version.version1", [("autoMode", "vim.vm.customization.LicenseFilePrintData.AutoMode", "vim.version.version1", 0), ("autoUsers", "int", "vim.version.version1", F_OPTIONAL)]) +CreateEnumType("vim.vm.customization.LicenseFilePrintData.AutoMode", "CustomizationLicenseDataMode", "vim.version.version1", ["perServer", "perSeat"]) +CreateDataType("vim.vm.customization.IdentitySettings", "CustomizationIdentitySettings", "vmodl.DynamicData", "vim.version.version1", None) +CreateDataType("vim.vm.customization.SysprepText", "CustomizationSysprepText", "vim.vm.customization.IdentitySettings", "vim.version.version1", [("value", "string", "vim.version.version1", 0)]) +CreateDataType("vim.vm.customization.Sysprep", "CustomizationSysprep", "vim.vm.customization.IdentitySettings", "vim.version.version1", [("guiUnattended", "vim.vm.customization.GuiUnattended", "vim.version.version1", 0), ("userData", "vim.vm.customization.UserData", "vim.version.version1", 0), ("guiRunOnce", "vim.vm.customization.GuiRunOnce", "vim.version.version1", F_OPTIONAL), ("identification", "vim.vm.customization.Identification", "vim.version.version1", 0), ("licenseFilePrintData", "vim.vm.customization.LicenseFilePrintData", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.vm.customization.LinuxPrep", "CustomizationLinuxPrep", "vim.vm.customization.IdentitySettings", "vim.version.version1", [("hostName", "vim.vm.customization.NameGenerator", "vim.version.version1", 0), ("domain", "string", "vim.version.version1", 0), ("timeZone", "string", "vim.version.version5", F_OPTIONAL), ("hwClockUTC", "boolean", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.vm.customization.GlobalIPSettings", "CustomizationGlobalIPSettings", "vmodl.DynamicData", "vim.version.version1", [("dnsSuffixList", "string[]", "vim.version.version1", F_OPTIONAL), ("dnsServerList", "string[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.vm.customization.IpGenerator", "CustomizationIpGenerator", "vmodl.DynamicData", "vim.version.version1", None) +CreateDataType("vim.vm.customization.DhcpIpGenerator", "CustomizationDhcpIpGenerator", "vim.vm.customization.IpGenerator", "vim.version.version1", None) +CreateDataType("vim.vm.customization.FixedIp", "CustomizationFixedIp", "vim.vm.customization.IpGenerator", "vim.version.version1", [("ipAddress", "string", "vim.version.version1", 0)]) +CreateDataType("vim.vm.customization.UnknownIpGenerator", "CustomizationUnknownIpGenerator", "vim.vm.customization.IpGenerator", "vim.version.version1", None) +CreateDataType("vim.vm.customization.CustomIpGenerator", "CustomizationCustomIpGenerator", "vim.vm.customization.IpGenerator", "vim.version.version1", [("argument", "string", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.vm.customization.IpV6Generator", "CustomizationIpV6Generator", "vmodl.DynamicData", "vim.version.version5", None) +CreateDataType("vim.vm.customization.DhcpIpV6Generator", "CustomizationDhcpIpV6Generator", "vim.vm.customization.IpV6Generator", "vim.version.version5", None) +CreateDataType("vim.vm.customization.StatelessIpV6Generator", "CustomizationStatelessIpV6Generator", "vim.vm.customization.IpV6Generator", "vim.version.version5", None) +CreateDataType("vim.vm.customization.FixedIpV6", "CustomizationFixedIpV6", "vim.vm.customization.IpV6Generator", "vim.version.version5", [("ipAddress", "string", "vim.version.version5", 0), ("subnetMask", "int", "vim.version.version5", 0)]) +CreateDataType("vim.vm.customization.AutoIpV6Generator", "CustomizationAutoIpV6Generator", "vim.vm.customization.IpV6Generator", "vim.version.version5", None) +CreateDataType("vim.vm.customization.UnknownIpV6Generator", "CustomizationUnknownIpV6Generator", "vim.vm.customization.IpV6Generator", "vim.version.version5", None) +CreateDataType("vim.vm.customization.CustomIpV6Generator", "CustomizationCustomIpV6Generator", "vim.vm.customization.IpV6Generator", "vim.version.version5", [("argument", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.vm.customization.AdapterMapping", "CustomizationAdapterMapping", "vmodl.DynamicData", "vim.version.version1", [("macAddress", "string", "vim.version.version1", F_OPTIONAL), ("adapter", "vim.vm.customization.IPSettings", "vim.version.version1", 0)]) +CreateDataType("vim.vm.device.HostDiskMappingInfo", "HostDiskMappingInfo", "vmodl.DynamicData", "vim.version.version1", [("physicalPartition", "vim.vm.device.HostDiskMappingInfo.PartitionInfo", "vim.version.version1", F_OPTIONAL), ("name", "string", "vim.version.version1", 0), ("exclusive", "boolean", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.vm.device.HostDiskMappingInfo.PartitionInfo", "HostDiskMappingPartitionInfo", "vmodl.DynamicData", "vim.version.version1", [("name", "string", "vim.version.version1", 0), ("fileSystem", "string", "vim.version.version1", 0), ("capacityInKb", "long", "vim.version.version1", 0)]) +CreateDataType("vim.vm.device.HostDiskMappingOption", "HostDiskMappingOption", "vmodl.DynamicData", "vim.version.version1", [("physicalPartition", "vim.vm.device.HostDiskMappingOption.PartitionOption[]", "vim.version.version1", F_OPTIONAL), ("name", "string", "vim.version.version1", 0)]) +CreateDataType("vim.vm.device.HostDiskMappingOption.PartitionOption", "HostDiskMappingPartitionOption", "vmodl.DynamicData", "vim.version.version1", [("name", "string", "vim.version.version1", 0), ("fileSystem", "string", "vim.version.version1", 0), ("capacityInKb", "long", "vim.version.version1", 0)]) +CreateDataType("vim.vm.device.VirtualDevice", "VirtualDevice", "vmodl.DynamicData", "vim.version.version1", [("key", "int", "vim.version.version1", 0), ("deviceInfo", "vim.Description", "vim.version.version1", F_OPTIONAL), ("backing", "vim.vm.device.VirtualDevice.BackingInfo", "vim.version.version1", F_OPTIONAL), ("connectable", "vim.vm.device.VirtualDevice.ConnectInfo", "vim.version.version1", F_OPTIONAL), ("slotInfo", "vim.vm.device.VirtualDevice.BusSlotInfo", "vim.version.version8", F_OPTIONAL), ("controllerKey", "int", "vim.version.version1", F_OPTIONAL), ("unitNumber", "int", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.vm.device.VirtualDevice.BackingInfo", "VirtualDeviceBackingInfo", "vmodl.DynamicData", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualDevice.FileBackingInfo", "VirtualDeviceFileBackingInfo", "vim.vm.device.VirtualDevice.BackingInfo", "vim.version.version1", [("fileName", "string", "vim.version.version1", 0), ("datastore", "vim.Datastore", "vim.version.version1", F_OPTIONAL), ("backingObjectId", "string", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.vm.device.VirtualDevice.DeviceBackingInfo", "VirtualDeviceDeviceBackingInfo", "vim.vm.device.VirtualDevice.BackingInfo", "vim.version.version1", [("deviceName", "string", "vim.version.version1", 0), ("useAutoDetect", "boolean", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.vm.device.VirtualDevice.RemoteDeviceBackingInfo", "VirtualDeviceRemoteDeviceBackingInfo", "vim.vm.device.VirtualDevice.BackingInfo", "vim.version.version1", [("deviceName", "string", "vim.version.version1", 0), ("useAutoDetect", "boolean", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.vm.device.VirtualDevice.PipeBackingInfo", "VirtualDevicePipeBackingInfo", "vim.vm.device.VirtualDevice.BackingInfo", "vim.version.version1", [("pipeName", "string", "vim.version.version1", 0)]) +CreateDataType("vim.vm.device.VirtualDevice.URIBackingInfo", "VirtualDeviceURIBackingInfo", "vim.vm.device.VirtualDevice.BackingInfo", "vim.version.version6", [("serviceURI", "string", "vim.version.version6", 0), ("direction", "string", "vim.version.version6", 0), ("proxyURI", "string", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.vm.device.VirtualDevice.ConnectInfo", "VirtualDeviceConnectInfo", "vmodl.DynamicData", "vim.version.version1", [("startConnected", "boolean", "vim.version.version1", 0), ("allowGuestControl", "boolean", "vim.version.version1", 0), ("connected", "boolean", "vim.version.version1", 0), ("status", "string", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.vm.device.VirtualDevice.ConnectInfo.Status", "VirtualDeviceConnectInfoStatus", "vim.version.version5", ["ok", "recoverableError", "unrecoverableError", "untried"]) +CreateDataType("vim.vm.device.VirtualDevice.BusSlotInfo", "VirtualDeviceBusSlotInfo", "vmodl.DynamicData", "vim.version.version8", None) +CreateDataType("vim.vm.device.VirtualDevice.PciBusSlotInfo", "VirtualDevicePciBusSlotInfo", "vim.vm.device.VirtualDevice.BusSlotInfo", "vim.version.version8", [("pciSlotNumber", "int", "vim.version.version8", 0)]) +CreateDataType("vim.vm.device.VirtualDeviceOption", "VirtualDeviceOption", "vmodl.DynamicData", "vim.version.version1", [("type", "vmodl.TypeName", "vim.version.version1", 0), ("connectOption", "vim.vm.device.VirtualDeviceOption.ConnectOption", "vim.version.version1", F_OPTIONAL), ("busSlotOption", "vim.vm.device.VirtualDeviceOption.BusSlotOption", "vim.version.version8", F_OPTIONAL), ("controllerType", "vmodl.TypeName", "vim.version.version1", F_OPTIONAL), ("autoAssignController", "vim.option.BoolOption", "vim.version.version1", F_OPTIONAL), ("backingOption", "vim.vm.device.VirtualDeviceOption.BackingOption[]", "vim.version.version1", F_OPTIONAL), ("defaultBackingOptionIndex", "int", "vim.version.version1", F_OPTIONAL), ("licensingLimit", "vmodl.PropertyPath[]", "vim.version.version1", F_OPTIONAL), ("deprecated", "boolean", "vim.version.version1", 0), ("plugAndPlay", "boolean", "vim.version.version1", 0), ("hotRemoveSupported", "boolean", "vim.version.version4", 0)]) +CreateDataType("vim.vm.device.VirtualDeviceOption.BackingOption", "VirtualDeviceBackingOption", "vmodl.DynamicData", "vim.version.version1", [("type", "vmodl.TypeName", "vim.version.version1", 0)]) +CreateDataType("vim.vm.device.VirtualDeviceOption.FileBackingOption", "VirtualDeviceFileBackingOption", "vim.vm.device.VirtualDeviceOption.BackingOption", "vim.version.version1", [("fileNameExtensions", "vim.option.ChoiceOption", "vim.version.version1", F_OPTIONAL)]) +CreateEnumType("vim.vm.device.VirtualDeviceOption.FileBackingOption.FileExtension", "VirtualDeviceFileExtension", "vim.version.version1", ["iso", "flp", "vmdk", "dsk", "rdm"]) +CreateDataType("vim.vm.device.VirtualDeviceOption.DeviceBackingOption", "VirtualDeviceDeviceBackingOption", "vim.vm.device.VirtualDeviceOption.BackingOption", "vim.version.version1", [("autoDetectAvailable", "vim.option.BoolOption", "vim.version.version2", 0)]) +CreateDataType("vim.vm.device.VirtualDeviceOption.RemoteDeviceBackingOption", "VirtualDeviceRemoteDeviceBackingOption", "vim.vm.device.VirtualDeviceOption.BackingOption", "vim.version.version1", [("autoDetectAvailable", "vim.option.BoolOption", "vim.version.version2", 0)]) +CreateDataType("vim.vm.device.VirtualDeviceOption.PipeBackingOption", "VirtualDevicePipeBackingOption", "vim.vm.device.VirtualDeviceOption.BackingOption", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualDeviceOption.URIBackingOption", "VirtualDeviceURIBackingOption", "vim.vm.device.VirtualDeviceOption.BackingOption", "vim.version.version6", [("directions", "vim.option.ChoiceOption", "vim.version.version6", 0)]) +CreateEnumType("vim.vm.device.VirtualDeviceOption.URIBackingOption.Direction", "VirtualDeviceURIBackingOptionDirection", "vim.version.version6", ["server", "client"]) +CreateDataType("vim.vm.device.VirtualDeviceOption.ConnectOption", "VirtualDeviceConnectOption", "vmodl.DynamicData", "vim.version.version1", [("startConnected", "vim.option.BoolOption", "vim.version.version1", 0), ("allowGuestControl", "vim.option.BoolOption", "vim.version.version1", 0)]) +CreateDataType("vim.vm.device.VirtualDeviceOption.BusSlotOption", "VirtualDeviceBusSlotOption", "vmodl.DynamicData", "vim.version.version8", [("type", "vmodl.TypeName", "vim.version.version8", 0)]) +CreateDataType("vim.vm.device.VirtualDeviceSpec", "VirtualDeviceConfigSpec", "vmodl.DynamicData", "vim.version.version1", [("operation", "vim.vm.device.VirtualDeviceSpec.Operation", "vim.version.version1", F_OPTIONAL), ("fileOperation", "vim.vm.device.VirtualDeviceSpec.FileOperation", "vim.version.version1", F_OPTIONAL), ("device", "vim.vm.device.VirtualDevice", "vim.version.version1", 0), ("profile", "vim.vm.ProfileSpec[]", "vim.version.version9", F_OPTIONAL)]) +CreateEnumType("vim.vm.device.VirtualDeviceSpec.Operation", "VirtualDeviceConfigSpecOperation", "vim.version.version1", ["add", "remove", "edit"]) +CreateEnumType("vim.vm.device.VirtualDeviceSpec.FileOperation", "VirtualDeviceConfigSpecFileOperation", "vim.version.version1", ["create", "destroy", "replace"]) +CreateDataType("vim.vm.device.VirtualDisk", "VirtualDisk", "vim.vm.device.VirtualDevice", "vim.version.version1", [("capacityInKB", "long", "vim.version.version1", 0), ("capacityInBytes", "long", "vim.version.version9", F_OPTIONAL), ("shares", "vim.SharesInfo", "vim.version.version1", F_OPTIONAL), ("storageIOAllocation", "vim.StorageResourceManager.IOAllocationInfo", "vim.version.version6", F_OPTIONAL), ("diskObjectId", "string", "vim.version.version9", F_OPTIONAL), ("vFlashCacheConfigInfo", "vim.vm.device.VirtualDisk.VFlashCacheConfigInfo", "vim.version.version9", F_OPTIONAL)]) +CreateEnumType("vim.vm.device.VirtualDisk.DeltaDiskFormat", "VirtualDiskDeltaDiskFormat", "vim.version.version7", ["redoLogFormat", "nativeFormat", "seSparseFormat"]) +CreateDataType("vim.vm.device.VirtualDisk.SparseVer1BackingInfo", "VirtualDiskSparseVer1BackingInfo", "vim.vm.device.VirtualDevice.FileBackingInfo", "vim.version.version1", [("diskMode", "string", "vim.version.version1", 0), ("split", "boolean", "vim.version.version1", F_OPTIONAL), ("writeThrough", "boolean", "vim.version.version1", F_OPTIONAL), ("spaceUsedInKB", "long", "vim.version.version1", F_OPTIONAL), ("contentId", "string", "vim.version.version5", F_OPTIONAL), ("parent", "vim.vm.device.VirtualDisk.SparseVer1BackingInfo", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.vm.device.VirtualDisk.SparseVer2BackingInfo", "VirtualDiskSparseVer2BackingInfo", "vim.vm.device.VirtualDevice.FileBackingInfo", "vim.version.version1", [("diskMode", "string", "vim.version.version1", 0), ("split", "boolean", "vim.version.version1", F_OPTIONAL), ("writeThrough", "boolean", "vim.version.version1", F_OPTIONAL), ("spaceUsedInKB", "long", "vim.version.version1", F_OPTIONAL), ("uuid", "string", "vim.version.version2", F_OPTIONAL), ("contentId", "string", "vim.version.version5", F_OPTIONAL), ("changeId", "string", "vim.version.version5", F_OPTIONAL), ("parent", "vim.vm.device.VirtualDisk.SparseVer2BackingInfo", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.vm.device.VirtualDisk.FlatVer1BackingInfo", "VirtualDiskFlatVer1BackingInfo", "vim.vm.device.VirtualDevice.FileBackingInfo", "vim.version.version1", [("diskMode", "string", "vim.version.version1", 0), ("split", "boolean", "vim.version.version1", F_OPTIONAL), ("writeThrough", "boolean", "vim.version.version1", F_OPTIONAL), ("contentId", "string", "vim.version.version5", F_OPTIONAL), ("parent", "vim.vm.device.VirtualDisk.FlatVer1BackingInfo", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.vm.device.VirtualDisk.FlatVer2BackingInfo", "VirtualDiskFlatVer2BackingInfo", "vim.vm.device.VirtualDevice.FileBackingInfo", "vim.version.version1", [("diskMode", "string", "vim.version.version1", 0), ("split", "boolean", "vim.version.version1", F_OPTIONAL), ("writeThrough", "boolean", "vim.version.version1", F_OPTIONAL), ("thinProvisioned", "boolean", "vim.version.version1", F_OPTIONAL), ("eagerlyScrub", "boolean", "vim.version.version5", F_OPTIONAL), ("uuid", "string", "vim.version.version2", F_OPTIONAL), ("contentId", "string", "vim.version.version5", F_OPTIONAL), ("changeId", "string", "vim.version.version5", F_OPTIONAL), ("parent", "vim.vm.device.VirtualDisk.FlatVer2BackingInfo", "vim.version.version5", F_OPTIONAL), ("deltaDiskFormat", "string", "vim.version.version7", F_OPTIONAL), ("digestEnabled", "boolean", "vim.version.version7", F_OPTIONAL), ("deltaGrainSize", "int", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.vm.device.VirtualDisk.SeSparseBackingInfo", "VirtualDiskSeSparseBackingInfo", "vim.vm.device.VirtualDevice.FileBackingInfo", "vim.version.version8", [("diskMode", "string", "vim.version.version8", 0), ("writeThrough", "boolean", "vim.version.version8", F_OPTIONAL), ("uuid", "string", "vim.version.version8", F_OPTIONAL), ("contentId", "string", "vim.version.version8", F_OPTIONAL), ("changeId", "string", "vim.version.version8", F_OPTIONAL), ("parent", "vim.vm.device.VirtualDisk.SeSparseBackingInfo", "vim.version.version8", F_OPTIONAL), ("deltaDiskFormat", "string", "vim.version.version8", F_OPTIONAL), ("digestEnabled", "boolean", "vim.version.version8", F_OPTIONAL), ("grainSize", "int", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.vm.device.VirtualDisk.RawDiskVer2BackingInfo", "VirtualDiskRawDiskVer2BackingInfo", "vim.vm.device.VirtualDevice.DeviceBackingInfo", "vim.version.version1", [("descriptorFileName", "string", "vim.version.version1", 0), ("uuid", "string", "vim.version.version2", F_OPTIONAL), ("changeId", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.vm.device.VirtualDisk.PartitionedRawDiskVer2BackingInfo", "VirtualDiskPartitionedRawDiskVer2BackingInfo", "vim.vm.device.VirtualDisk.RawDiskVer2BackingInfo", "vim.version.version1", [("partition", "int[]", "vim.version.version1", 0)]) +CreateDataType("vim.vm.device.VirtualDisk.RawDiskMappingVer1BackingInfo", "VirtualDiskRawDiskMappingVer1BackingInfo", "vim.vm.device.VirtualDevice.FileBackingInfo", "vim.version.version1", [("lunUuid", "string", "vim.version.version1", F_OPTIONAL), ("deviceName", "string", "vim.version.version1", F_OPTIONAL), ("compatibilityMode", "string", "vim.version.version1", F_OPTIONAL), ("diskMode", "string", "vim.version.version1", F_OPTIONAL), ("uuid", "string", "vim.version.version2", F_OPTIONAL), ("contentId", "string", "vim.version.version5", F_OPTIONAL), ("changeId", "string", "vim.version.version5", F_OPTIONAL), ("parent", "vim.vm.device.VirtualDisk.RawDiskMappingVer1BackingInfo", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.vm.device.VirtualDisk.VFlashCacheConfigInfo", "VirtualDiskVFlashCacheConfigInfo", "vmodl.DynamicData", "vim.version.version9", [("vFlashModule", "string", "vim.version.version9", F_OPTIONAL), ("reservationInMB", "long", "vim.version.version9", F_OPTIONAL), ("cacheConsistencyType", "string", "vim.version.version9", F_OPTIONAL), ("cacheMode", "string", "vim.version.version9", F_OPTIONAL), ("blockSizeInKB", "long", "vim.version.version9", F_OPTIONAL)]) +CreateEnumType("vim.vm.device.VirtualDisk.VFlashCacheConfigInfo.CacheConsistencyType", "VirtualDiskVFlashCacheConfigInfoCacheConsistencyType", "vim.version.version9", ["strong", "weak"]) +CreateEnumType("vim.vm.device.VirtualDisk.VFlashCacheConfigInfo.CacheMode", "VirtualDiskVFlashCacheConfigInfoCacheMode", "vim.version.version9", ["write_thru", "write_back"]) +CreateDataType("vim.vm.device.VirtualDiskId", "VirtualDiskId", "vmodl.DynamicData", "vim.version.version7", [("vm", "vim.VirtualMachine", "vim.version.version7", 0), ("diskId", "int", "vim.version.version7", 0)]) +CreateDataType("vim.vm.device.VirtualDiskOption", "VirtualDiskOption", "vim.vm.device.VirtualDeviceOption", "vim.version.version1", [("capacityInKB", "vim.option.LongOption", "vim.version.version1", 0), ("ioAllocationOption", "vim.StorageResourceManager.IOAllocationOption", "vim.version.version6", 0), ("vFlashCacheConfigOption", "vim.vm.device.VirtualDiskOption.VFlashCacheConfigOption", "vim.version.version9", F_OPTIONAL)]) +CreateEnumType("vim.vm.device.VirtualDiskOption.DiskMode", "VirtualDiskMode", "vim.version.version1", ["persistent", "nonpersistent", "undoable", "independent_persistent", "independent_nonpersistent", "append"]) +CreateEnumType("vim.vm.device.VirtualDiskOption.CompatibilityMode", "VirtualDiskCompatibilityMode", "vim.version.version1", ["virtualMode", "physicalMode"]) +CreateDataType("vim.vm.device.VirtualDiskOption.SparseVer1BackingOption", "VirtualDiskSparseVer1BackingOption", "vim.vm.device.VirtualDeviceOption.FileBackingOption", "vim.version.version1", [("diskModes", "vim.option.ChoiceOption", "vim.version.version1", 0), ("split", "vim.option.BoolOption", "vim.version.version1", 0), ("writeThrough", "vim.option.BoolOption", "vim.version.version1", 0), ("growable", "boolean", "vim.version.version1", 0)]) +CreateDataType("vim.vm.device.VirtualDiskOption.SparseVer2BackingOption", "VirtualDiskSparseVer2BackingOption", "vim.vm.device.VirtualDeviceOption.FileBackingOption", "vim.version.version1", [("diskMode", "vim.option.ChoiceOption", "vim.version.version1", 0), ("split", "vim.option.BoolOption", "vim.version.version1", 0), ("writeThrough", "vim.option.BoolOption", "vim.version.version1", 0), ("growable", "boolean", "vim.version.version1", 0), ("hotGrowable", "boolean", "vim.version.version2", 0), ("uuid", "boolean", "vim.version.version2", 0)]) +CreateDataType("vim.vm.device.VirtualDiskOption.FlatVer1BackingOption", "VirtualDiskFlatVer1BackingOption", "vim.vm.device.VirtualDeviceOption.FileBackingOption", "vim.version.version1", [("diskMode", "vim.option.ChoiceOption", "vim.version.version1", 0), ("split", "vim.option.BoolOption", "vim.version.version1", 0), ("writeThrough", "vim.option.BoolOption", "vim.version.version1", 0), ("growable", "boolean", "vim.version.version1", 0)]) +CreateDataType("vim.vm.device.VirtualDiskOption.DeltaDiskFormatsSupported", "VirtualDiskDeltaDiskFormatsSupported", "vmodl.DynamicData", "vim.version.version8", [("datastoreType", "vmodl.TypeName", "vim.version.version8", 0), ("deltaDiskFormat", "vim.option.ChoiceOption", "vim.version.version8", 0)]) +CreateDataType("vim.vm.device.VirtualDiskOption.FlatVer2BackingOption", "VirtualDiskFlatVer2BackingOption", "vim.vm.device.VirtualDeviceOption.FileBackingOption", "vim.version.version1", [("diskMode", "vim.option.ChoiceOption", "vim.version.version1", 0), ("split", "vim.option.BoolOption", "vim.version.version1", 0), ("writeThrough", "vim.option.BoolOption", "vim.version.version1", 0), ("growable", "boolean", "vim.version.version1", 0), ("hotGrowable", "boolean", "vim.version.version2", 0), ("uuid", "boolean", "vim.version.version2", 0), ("thinProvisioned", "vim.option.BoolOption", "vim.version.version5", 0), ("eagerlyScrub", "vim.option.BoolOption", "vim.version.version5", 0), ("deltaDiskFormat", "vim.option.ChoiceOption", "vim.version.version7", 0), ("deltaDiskFormatsSupported", "vim.vm.device.VirtualDiskOption.DeltaDiskFormatsSupported[]", "vim.version.version8", 0)]) +CreateDataType("vim.vm.device.VirtualDiskOption.SeSparseBackingOption", "VirtualDiskSeSparseBackingOption", "vim.vm.device.VirtualDeviceOption.FileBackingOption", "vim.version.version8", [("diskMode", "vim.option.ChoiceOption", "vim.version.version8", 0), ("writeThrough", "vim.option.BoolOption", "vim.version.version8", 0), ("growable", "boolean", "vim.version.version8", 0), ("hotGrowable", "boolean", "vim.version.version8", 0), ("uuid", "boolean", "vim.version.version8", 0), ("deltaDiskFormatsSupported", "vim.vm.device.VirtualDiskOption.DeltaDiskFormatsSupported[]", "vim.version.version8", 0)]) +CreateDataType("vim.vm.device.VirtualDiskOption.RawDiskVer2BackingOption", "VirtualDiskRawDiskVer2BackingOption", "vim.vm.device.VirtualDeviceOption.DeviceBackingOption", "vim.version.version1", [("descriptorFileNameExtensions", "vim.option.ChoiceOption", "vim.version.version1", 0), ("uuid", "boolean", "vim.version.version2", 0)]) +CreateDataType("vim.vm.device.VirtualDiskOption.PartitionedRawDiskVer2BackingOption", "VirtualDiskPartitionedRawDiskVer2BackingOption", "vim.vm.device.VirtualDiskOption.RawDiskVer2BackingOption", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualDiskOption.RawDiskMappingVer1BackingOption", "VirtualDiskRawDiskMappingVer1BackingOption", "vim.vm.device.VirtualDeviceOption.DeviceBackingOption", "vim.version.version1", [("descriptorFileNameExtensions", "vim.option.ChoiceOption", "vim.version.version1", F_OPTIONAL), ("compatibilityMode", "vim.option.ChoiceOption", "vim.version.version1", 0), ("diskMode", "vim.option.ChoiceOption", "vim.version.version1", 0), ("uuid", "boolean", "vim.version.version2", 0)]) +CreateDataType("vim.vm.device.VirtualDiskOption.VFlashCacheConfigOption", "VirtualDiskOptionVFlashCacheConfigOption", "vmodl.DynamicData", "vim.version.version9", [("cacheConsistencyType", "vim.option.ChoiceOption", "vim.version.version9", 0), ("cacheMode", "vim.option.ChoiceOption", "vim.version.version9", 0), ("reservationInMB", "vim.option.LongOption", "vim.version.version9", 0), ("blockSizeInKB", "vim.option.LongOption", "vim.version.version9", 0)]) +CreateDataType("vim.vm.device.VirtualDiskSpec", "VirtualDiskConfigSpec", "vim.vm.device.VirtualDeviceSpec", "vim.version.version9", [("migrateCache", "boolean", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.vm.device.VirtualEthernetCard", "VirtualEthernetCard", "vim.vm.device.VirtualDevice", "vim.version.version1", [("addressType", "string", "vim.version.version1", F_OPTIONAL), ("macAddress", "string", "vim.version.version1", F_OPTIONAL), ("wakeOnLanEnabled", "boolean", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.vm.device.VirtualEthernetCard.NetworkBackingInfo", "VirtualEthernetCardNetworkBackingInfo", "vim.vm.device.VirtualDevice.DeviceBackingInfo", "vim.version.version1", [("network", "vim.Network", "vim.version.version1", F_OPTIONAL), ("inPassthroughMode", "boolean", "vim.version.version4", F_OPTIONAL)]) +CreateDataType("vim.vm.device.VirtualEthernetCard.LegacyNetworkBackingInfo", "VirtualEthernetCardLegacyNetworkBackingInfo", "vim.vm.device.VirtualDevice.DeviceBackingInfo", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualEthernetCard.DistributedVirtualPortBackingInfo", "VirtualEthernetCardDistributedVirtualPortBackingInfo", "vim.vm.device.VirtualDevice.BackingInfo", "vim.version.version5", [("port", "vim.dvs.PortConnection", "vim.version.version5", 0)]) +CreateDataType("vim.vm.device.VirtualEthernetCard.OpaqueNetworkBackingInfo", "VirtualEthernetCardOpaqueNetworkBackingInfo", "vim.vm.device.VirtualDevice.BackingInfo", "vim.version.version9", [("opaqueNetworkId", "string", "vim.version.version9", 0), ("opaqueNetworkType", "string", "vim.version.version9", 0)]) +CreateDataType("vim.vm.device.VirtualEthernetCardOption", "VirtualEthernetCardOption", "vim.vm.device.VirtualDeviceOption", "vim.version.version1", [("supportedOUI", "vim.option.ChoiceOption", "vim.version.version1", 0), ("macType", "vim.option.ChoiceOption", "vim.version.version1", 0), ("wakeOnLanEnabled", "vim.option.BoolOption", "vim.version.version1", 0), ("vmDirectPathGen2Supported", "boolean", "vim.version.version6", 0)]) +CreateDataType("vim.vm.device.VirtualEthernetCardOption.NetworkBackingOption", "VirtualEthernetCardNetworkBackingOption", "vim.vm.device.VirtualDeviceOption.DeviceBackingOption", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualEthernetCardOption.OpaqueNetworkBackingOption", "VirtualEthernetCardOpaqueNetworkBackingOption", "vim.vm.device.VirtualDeviceOption.BackingOption", "vim.version.version9", None) +CreateDataType("vim.vm.device.VirtualEthernetCardOption.LegacyNetworkBackingOption", "VirtualEthernetCardLegacyNetworkBackingOption", "vim.vm.device.VirtualDeviceOption.DeviceBackingOption", "vim.version.version1", None) +CreateEnumType("vim.vm.device.VirtualEthernetCardOption.LegacyNetworkBackingOption.LegacyNetworkDeviceName", "VirtualEthernetCardLegacyNetworkDeviceName", "vim.version.version1", ["bridged", "nat", "hostonly"]) +CreateDataType("vim.vm.device.VirtualEthernetCardOption.DistributedVirtualPortBackingOption", "VirtualEthernetCardDVPortBackingOption", "vim.vm.device.VirtualDeviceOption.BackingOption", "vim.version.version5", None) +CreateEnumType("vim.vm.device.VirtualEthernetCardOption.MacTypes", "VirtualEthernetCardMacType", "vim.version.version1", ["manual", "generated", "assigned"]) +CreateDataType("vim.vm.device.VirtualFloppy", "VirtualFloppy", "vim.vm.device.VirtualDevice", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualFloppy.ImageBackingInfo", "VirtualFloppyImageBackingInfo", "vim.vm.device.VirtualDevice.FileBackingInfo", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualFloppy.DeviceBackingInfo", "VirtualFloppyDeviceBackingInfo", "vim.vm.device.VirtualDevice.DeviceBackingInfo", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualFloppy.RemoteDeviceBackingInfo", "VirtualFloppyRemoteDeviceBackingInfo", "vim.vm.device.VirtualDevice.RemoteDeviceBackingInfo", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualFloppyOption", "VirtualFloppyOption", "vim.vm.device.VirtualDeviceOption", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualFloppyOption.ImageBackingOption", "VirtualFloppyImageBackingOption", "vim.vm.device.VirtualDeviceOption.FileBackingOption", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualFloppyOption.DeviceBackingOption", "VirtualFloppyDeviceBackingOption", "vim.vm.device.VirtualDeviceOption.DeviceBackingOption", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualFloppyOption.RemoteDeviceBackingOption", "VirtualFloppyRemoteDeviceBackingOption", "vim.vm.device.VirtualDeviceOption.RemoteDeviceBackingOption", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualKeyboard", "VirtualKeyboard", "vim.vm.device.VirtualDevice", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualKeyboardOption", "VirtualKeyboardOption", "vim.vm.device.VirtualDeviceOption", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualPCIPassthrough", "VirtualPCIPassthrough", "vim.vm.device.VirtualDevice", "vim.version.version5", None) +CreateDataType("vim.vm.device.VirtualPCIPassthrough.DeviceBackingInfo", "VirtualPCIPassthroughDeviceBackingInfo", "vim.vm.device.VirtualDevice.DeviceBackingInfo", "vim.version.version5", [("id", "string", "vim.version.version5", 0), ("deviceId", "string", "vim.version.version5", 0), ("systemId", "string", "vim.version.version5", 0), ("vendorId", "short", "vim.version.version5", 0)]) +CreateDataType("vim.vm.device.VirtualPCIPassthroughOption", "VirtualPCIPassthroughOption", "vim.vm.device.VirtualDeviceOption", "vim.version.version5", None) +CreateDataType("vim.vm.device.VirtualPCIPassthroughOption.DeviceBackingOption", "VirtualPCIPassthroughDeviceBackingOption", "vim.vm.device.VirtualDeviceOption.DeviceBackingOption", "vim.version.version5", None) +CreateDataType("vim.vm.device.VirtualPCNet32", "VirtualPCNet32", "vim.vm.device.VirtualEthernetCard", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualPCNet32Option", "VirtualPCNet32Option", "vim.vm.device.VirtualEthernetCardOption", "vim.version.version1", [("supportsMorphing", "boolean", "vim.version.version1", 0)]) +CreateDataType("vim.vm.device.VirtualParallelPort", "VirtualParallelPort", "vim.vm.device.VirtualDevice", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualParallelPort.FileBackingInfo", "VirtualParallelPortFileBackingInfo", "vim.vm.device.VirtualDevice.FileBackingInfo", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualParallelPort.DeviceBackingInfo", "VirtualParallelPortDeviceBackingInfo", "vim.vm.device.VirtualDevice.DeviceBackingInfo", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualParallelPortOption", "VirtualParallelPortOption", "vim.vm.device.VirtualDeviceOption", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualParallelPortOption.FileBackingOption", "VirtualParallelPortFileBackingOption", "vim.vm.device.VirtualDeviceOption.FileBackingOption", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualParallelPortOption.DeviceBackingOption", "VirtualParallelPortDeviceBackingOption", "vim.vm.device.VirtualDeviceOption.DeviceBackingOption", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualPointingDevice", "VirtualPointingDevice", "vim.vm.device.VirtualDevice", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualPointingDevice.DeviceBackingInfo", "VirtualPointingDeviceDeviceBackingInfo", "vim.vm.device.VirtualDevice.DeviceBackingInfo", "vim.version.version1", [("hostPointingDevice", "string", "vim.version.version1", 0)]) +CreateDataType("vim.vm.device.VirtualPointingDeviceOption", "VirtualPointingDeviceOption", "vim.vm.device.VirtualDeviceOption", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualPointingDeviceOption.DeviceBackingOption", "VirtualPointingDeviceBackingOption", "vim.vm.device.VirtualDeviceOption.DeviceBackingOption", "vim.version.version1", [("hostPointingDevice", "vim.option.ChoiceOption", "vim.version.version1", 0)]) +CreateEnumType("vim.vm.device.VirtualPointingDeviceOption.DeviceBackingOption.HostPointingDeviceChoice", "VirtualPointingDeviceHostChoice", "vim.version.version1", ["autodetect", "intellimouseExplorer", "intellimousePs2", "logitechMouseman", "microsoft_serial", "mouseSystems", "mousemanSerial", "ps2"]) +CreateDataType("vim.vm.device.VirtualSCSIPassthrough", "VirtualSCSIPassthrough", "vim.vm.device.VirtualDevice", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualSCSIPassthrough.DeviceBackingInfo", "VirtualSCSIPassthroughDeviceBackingInfo", "vim.vm.device.VirtualDevice.DeviceBackingInfo", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualSCSIPassthroughOption", "VirtualSCSIPassthroughOption", "vim.vm.device.VirtualDeviceOption", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualSCSIPassthroughOption.DeviceBackingOption", "VirtualSCSIPassthroughDeviceBackingOption", "vim.vm.device.VirtualDeviceOption.DeviceBackingOption", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualSerialPort", "VirtualSerialPort", "vim.vm.device.VirtualDevice", "vim.version.version1", [("yieldOnPoll", "boolean", "vim.version.version1", 0)]) +CreateDataType("vim.vm.device.VirtualSerialPort.FileBackingInfo", "VirtualSerialPortFileBackingInfo", "vim.vm.device.VirtualDevice.FileBackingInfo", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualSerialPort.DeviceBackingInfo", "VirtualSerialPortDeviceBackingInfo", "vim.vm.device.VirtualDevice.DeviceBackingInfo", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualSerialPort.PipeBackingInfo", "VirtualSerialPortPipeBackingInfo", "vim.vm.device.VirtualDevice.PipeBackingInfo", "vim.version.version1", [("endpoint", "string", "vim.version.version1", 0), ("noRxLoss", "boolean", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.vm.device.VirtualSerialPort.URIBackingInfo", "VirtualSerialPortURIBackingInfo", "vim.vm.device.VirtualDevice.URIBackingInfo", "vim.version.version6", None) +CreateDataType("vim.vm.device.VirtualSerialPort.ThinPrintBackingInfo", "VirtualSerialPortThinPrintBackingInfo", "vim.vm.device.VirtualDevice.BackingInfo", "vim.version.version8", None) +CreateDataType("vim.vm.device.VirtualSerialPortOption", "VirtualSerialPortOption", "vim.vm.device.VirtualDeviceOption", "vim.version.version1", [("yieldOnPoll", "vim.option.BoolOption", "vim.version.version1", 0)]) +CreateEnumType("vim.vm.device.VirtualSerialPortOption.EndPoint", "VirtualSerialPortEndPoint", "vim.version.version1", ["client", "server"]) +CreateDataType("vim.vm.device.VirtualSerialPortOption.FileBackingOption", "VirtualSerialPortFileBackingOption", "vim.vm.device.VirtualDeviceOption.FileBackingOption", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualSerialPortOption.DeviceBackingOption", "VirtualSerialPortDeviceBackingOption", "vim.vm.device.VirtualDeviceOption.DeviceBackingOption", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualSerialPortOption.PipeBackingOption", "VirtualSerialPortPipeBackingOption", "vim.vm.device.VirtualDeviceOption.PipeBackingOption", "vim.version.version1", [("endpoint", "vim.option.ChoiceOption", "vim.version.version1", 0), ("noRxLoss", "vim.option.BoolOption", "vim.version.version1", 0)]) +CreateDataType("vim.vm.device.VirtualSerialPortOption.URIBackingOption", "VirtualSerialPortURIBackingOption", "vim.vm.device.VirtualDeviceOption.URIBackingOption", "vim.version.version6", None) +CreateDataType("vim.vm.device.VirtualSerialPortOption.ThinPrintBackingOption", "VirtualSerialPortThinPrintBackingOption", "vim.vm.device.VirtualDeviceOption.BackingOption", "vim.version.version8", None) +CreateDataType("vim.vm.device.VirtualSoundCard", "VirtualSoundCard", "vim.vm.device.VirtualDevice", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualSoundCard.DeviceBackingInfo", "VirtualSoundCardDeviceBackingInfo", "vim.vm.device.VirtualDevice.DeviceBackingInfo", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualSoundCardOption", "VirtualSoundCardOption", "vim.vm.device.VirtualDeviceOption", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualSoundCardOption.DeviceBackingOption", "VirtualSoundCardDeviceBackingOption", "vim.vm.device.VirtualDeviceOption.DeviceBackingOption", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualSriovEthernetCard", "VirtualSriovEthernetCard", "vim.vm.device.VirtualEthernetCard", "vim.version.version9", [("allowGuestOSMtuChange", "boolean", "vim.version.version9", F_OPTIONAL), ("sriovBacking", "vim.vm.device.VirtualSriovEthernetCard.SriovBackingInfo", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.vm.device.VirtualSriovEthernetCard.SriovBackingInfo", "VirtualSriovEthernetCardSriovBackingInfo", "vim.vm.device.VirtualDevice.BackingInfo", "vim.version.version9", [("physicalFunctionBacking", "vim.vm.device.VirtualPCIPassthrough.DeviceBackingInfo", "vim.version.version9", F_OPTIONAL), ("virtualFunctionBacking", "vim.vm.device.VirtualPCIPassthrough.DeviceBackingInfo", "vim.version.version9", F_OPTIONAL), ("virtualFunctionIndex", "int", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.vm.device.VirtualSriovEthernetCardOption", "VirtualSriovEthernetCardOption", "vim.vm.device.VirtualEthernetCardOption", "vim.version.version9", None) +CreateDataType("vim.vm.device.VirtualSriovEthernetCardOption.SriovBackingOption", "VirtualSriovEthernetCardSriovBackingOption", "vim.vm.device.VirtualDeviceOption.BackingOption", "vim.version.version9", None) +CreateDataType("vim.vm.device.VirtualUSB", "VirtualUSB", "vim.vm.device.VirtualDevice", "vim.version.version1", [("connected", "boolean", "vim.version.version2", 0), ("vendor", "int", "vim.version.version6", F_OPTIONAL), ("product", "int", "vim.version.version6", F_OPTIONAL), ("family", "string[]", "vim.version.version6", F_OPTIONAL), ("speed", "string[]", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.vm.device.VirtualUSB.USBBackingInfo", "VirtualUSBUSBBackingInfo", "vim.vm.device.VirtualDevice.DeviceBackingInfo", "vim.version.version2", None) +CreateDataType("vim.vm.device.VirtualUSB.RemoteHostBackingInfo", "VirtualUSBRemoteHostBackingInfo", "vim.vm.device.VirtualDevice.DeviceBackingInfo", "vim.version.version6", [("hostname", "string", "vim.version.version6", 0)]) +CreateDataType("vim.vm.device.VirtualUSB.RemoteClientBackingInfo", "VirtualUSBRemoteClientBackingInfo", "vim.vm.device.VirtualDevice.RemoteDeviceBackingInfo", "vim.version.version7", [("hostname", "string", "vim.version.version7", 0)]) +CreateDataType("vim.vm.device.VirtualUSBOption", "VirtualUSBOption", "vim.vm.device.VirtualDeviceOption", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualUSBOption.USBBackingOption", "VirtualUSBUSBBackingOption", "vim.vm.device.VirtualDeviceOption.DeviceBackingOption", "vim.version.version2", None) +CreateDataType("vim.vm.device.VirtualUSBOption.RemoteHostBackingOption", "VirtualUSBRemoteHostBackingOption", "vim.vm.device.VirtualDeviceOption.DeviceBackingOption", "vim.version.version6", None) +CreateDataType("vim.vm.device.VirtualUSBOption.RemoteClientBackingOption", "VirtualUSBRemoteClientBackingOption", "vim.vm.device.VirtualDeviceOption.RemoteDeviceBackingOption", "vim.version.version7", None) +CreateDataType("vim.vm.device.VirtualVMCIDevice", "VirtualMachineVMCIDevice", "vim.vm.device.VirtualDevice", "vim.version.version4", [("id", "long", "vim.version.version4", F_OPTIONAL), ("allowUnrestrictedCommunication", "boolean", "vim.version.version4", F_OPTIONAL)]) +CreateDataType("vim.vm.device.VirtualVMCIDeviceOption", "VirtualMachineVMCIDeviceOption", "vim.vm.device.VirtualDeviceOption", "vim.version.version4", [("allowUnrestrictedCommunication", "vim.option.BoolOption", "vim.version.version4", 0)]) +CreateDataType("vim.vm.device.VirtualVMIROM", "VirtualMachineVMIROM", "vim.vm.device.VirtualDevice", "vim.version.version2", None) +CreateDataType("vim.vm.device.VirtualVMIROMOption", "VirtualVMIROMOption", "vim.vm.device.VirtualDeviceOption", "vim.version.version2", None) +CreateDataType("vim.vm.device.VirtualVideoCard", "VirtualMachineVideoCard", "vim.vm.device.VirtualDevice", "vim.version.version1", [("videoRamSizeInKB", "long", "vim.version.version1", F_OPTIONAL), ("numDisplays", "int", "vim.version.version4", F_OPTIONAL), ("useAutoDetect", "boolean", "vim.version.version4", F_OPTIONAL), ("enable3DSupport", "boolean", "vim.version.version4", F_OPTIONAL), ("use3dRenderer", "string", "vim.version.version8", F_OPTIONAL)]) +CreateEnumType("vim.vm.device.VirtualVideoCard.Use3dRenderer", "VirtualMachineVideoCardUse3dRenderer", "vim.version.version8", ["automatic", "software", "hardware"]) +CreateDataType("vim.vm.device.VirtualVideoCardOption", "VirtualVideoCardOption", "vim.vm.device.VirtualDeviceOption", "vim.version.version1", [("videoRamSizeInKB", "vim.option.LongOption", "vim.version.version1", F_OPTIONAL), ("numDisplays", "vim.option.IntOption", "vim.version.version4", F_OPTIONAL), ("useAutoDetect", "vim.option.BoolOption", "vim.version.version4", F_OPTIONAL), ("support3D", "vim.option.BoolOption", "vim.version.version4", F_OPTIONAL), ("use3dRendererSupported", "vim.option.BoolOption", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.vm.device.VirtualVmxnet", "VirtualVmxnet", "vim.vm.device.VirtualEthernetCard", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualVmxnet2", "VirtualVmxnet2", "vim.vm.device.VirtualVmxnet", "vim.version.version2", None) +CreateDataType("vim.vm.device.VirtualVmxnet3", "VirtualVmxnet3", "vim.vm.device.VirtualVmxnet", "vim.version.version4", None) +CreateDataType("vim.vm.device.VirtualVmxnetOption", "VirtualVmxnetOption", "vim.vm.device.VirtualEthernetCardOption", "vim.version.version1", None) +CreateManagedType("vim.vm.guest.AuthManager", "GuestAuthManager", "vmodl.ManagedObject", "vim.version.version7", None, [("validateCredentials", "ValidateCredentialsInGuest", "vim.version.version7", (("vm", "vim.VirtualMachine", "vim.version.version7", 0, "VirtualMachine.GuestOperations.Query"),("auth", "vim.vm.guest.GuestAuthentication", "vim.version.version7", 0, None),), (0, "void", "void"), None, ["vim.fault.GuestOperationsFault", "vim.fault.InvalidState", "vim.fault.TaskInProgress", ]), ("acquireCredentials", "AcquireCredentialsInGuest", "vim.version.version7", (("vm", "vim.VirtualMachine", "vim.version.version7", 0, "VirtualMachine.GuestOperations.Query"),("requestedAuth", "vim.vm.guest.GuestAuthentication", "vim.version.version7", 0, None),("sessionID", "long", "vim.version.version7", F_OPTIONAL, None),), (0, "vim.vm.guest.GuestAuthentication", "vim.vm.guest.GuestAuthentication"), None, ["vim.fault.GuestOperationsFault", "vim.fault.TaskInProgress", "vim.fault.InvalidState", ]), ("releaseCredentials", "ReleaseCredentialsInGuest", "vim.version.version7", (("vm", "vim.VirtualMachine", "vim.version.version7", 0, "VirtualMachine.GuestOperations.Query"),("auth", "vim.vm.guest.GuestAuthentication", "vim.version.version7", 0, None),), (0, "void", "void"), None, ["vim.fault.GuestOperationsFault", "vim.fault.TaskInProgress", "vim.fault.InvalidState", ])]) +CreateManagedType("vim.vm.guest.FileManager", "GuestFileManager", "vmodl.ManagedObject", "vim.version.version7", None, [("makeDirectory", "MakeDirectoryInGuest", "vim.version.version7", (("vm", "vim.VirtualMachine", "vim.version.version7", 0, "VirtualMachine.GuestOperations.Modify"),("auth", "vim.vm.guest.GuestAuthentication", "vim.version.version7", 0, None),("directoryPath", "string", "vim.version.version7", 0, None),("createParentDirectories", "boolean", "vim.version.version7", 0, None),), (0, "void", "void"), None, ["vim.fault.GuestOperationsFault", "vim.fault.InvalidState", "vim.fault.TaskInProgress", "vim.fault.FileFault", ]), ("deleteFile", "DeleteFileInGuest", "vim.version.version7", (("vm", "vim.VirtualMachine", "vim.version.version7", 0, "VirtualMachine.GuestOperations.Modify"),("auth", "vim.vm.guest.GuestAuthentication", "vim.version.version7", 0, None),("filePath", "string", "vim.version.version7", 0, None),), (0, "void", "void"), None, ["vim.fault.GuestOperationsFault", "vim.fault.InvalidState", "vim.fault.TaskInProgress", "vim.fault.FileFault", ]), ("deleteDirectory", "DeleteDirectoryInGuest", "vim.version.version7", (("vm", "vim.VirtualMachine", "vim.version.version7", 0, "VirtualMachine.GuestOperations.Modify"),("auth", "vim.vm.guest.GuestAuthentication", "vim.version.version7", 0, None),("directoryPath", "string", "vim.version.version7", 0, None),("recursive", "boolean", "vim.version.version7", 0, None),), (0, "void", "void"), None, ["vim.fault.GuestOperationsFault", "vim.fault.InvalidState", "vim.fault.TaskInProgress", "vim.fault.FileFault", ]), ("moveDirectory", "MoveDirectoryInGuest", "vim.version.version7", (("vm", "vim.VirtualMachine", "vim.version.version7", 0, "VirtualMachine.GuestOperations.Modify"),("auth", "vim.vm.guest.GuestAuthentication", "vim.version.version7", 0, None),("srcDirectoryPath", "string", "vim.version.version7", 0, None),("dstDirectoryPath", "string", "vim.version.version7", 0, None),), (0, "void", "void"), None, ["vim.fault.GuestOperationsFault", "vim.fault.InvalidState", "vim.fault.TaskInProgress", "vim.fault.FileFault", ]), ("moveFile", "MoveFileInGuest", "vim.version.version7", (("vm", "vim.VirtualMachine", "vim.version.version7", 0, "VirtualMachine.GuestOperations.Modify"),("auth", "vim.vm.guest.GuestAuthentication", "vim.version.version7", 0, None),("srcFilePath", "string", "vim.version.version7", 0, None),("dstFilePath", "string", "vim.version.version7", 0, None),("overwrite", "boolean", "vim.version.version7", 0, None),), (0, "void", "void"), None, ["vim.fault.GuestOperationsFault", "vim.fault.InvalidState", "vim.fault.TaskInProgress", "vim.fault.FileFault", ]), ("createTemporaryFile", "CreateTemporaryFileInGuest", "vim.version.version7", (("vm", "vim.VirtualMachine", "vim.version.version7", 0, "VirtualMachine.GuestOperations.Modify"),("auth", "vim.vm.guest.GuestAuthentication", "vim.version.version7", 0, None),("prefix", "string", "vim.version.version7", 0, None),("suffix", "string", "vim.version.version7", 0, None),("directoryPath", "string", "vim.version.version7", F_OPTIONAL, None),), (0, "string", "string"), None, ["vim.fault.GuestOperationsFault", "vim.fault.InvalidState", "vim.fault.TaskInProgress", "vim.fault.FileFault", ]), ("createTemporaryDirectory", "CreateTemporaryDirectoryInGuest", "vim.version.version7", (("vm", "vim.VirtualMachine", "vim.version.version7", 0, "VirtualMachine.GuestOperations.Modify"),("auth", "vim.vm.guest.GuestAuthentication", "vim.version.version7", 0, None),("prefix", "string", "vim.version.version7", 0, None),("suffix", "string", "vim.version.version7", 0, None),("directoryPath", "string", "vim.version.version7", F_OPTIONAL, None),), (0, "string", "string"), None, ["vim.fault.GuestOperationsFault", "vim.fault.InvalidState", "vim.fault.TaskInProgress", "vim.fault.FileFault", ]), ("listFiles", "ListFilesInGuest", "vim.version.version7", (("vm", "vim.VirtualMachine", "vim.version.version7", 0, "VirtualMachine.GuestOperations.Query"),("auth", "vim.vm.guest.GuestAuthentication", "vim.version.version7", 0, None),("filePath", "string", "vim.version.version7", 0, None),("index", "int", "vim.version.version7", F_OPTIONAL, None),("maxResults", "int", "vim.version.version7", F_OPTIONAL, None),("matchPattern", "string", "vim.version.version7", F_OPTIONAL, None),), (0, "vim.vm.guest.FileManager.ListFileInfo", "vim.vm.guest.FileManager.ListFileInfo"), None, ["vim.fault.GuestOperationsFault", "vim.fault.InvalidState", "vim.fault.TaskInProgress", "vim.fault.FileFault", ]), ("changeFileAttributes", "ChangeFileAttributesInGuest", "vim.version.version7", (("vm", "vim.VirtualMachine", "vim.version.version7", 0, "VirtualMachine.GuestOperations.Modify"),("auth", "vim.vm.guest.GuestAuthentication", "vim.version.version7", 0, None),("guestFilePath", "string", "vim.version.version7", 0, None),("fileAttributes", "vim.vm.guest.FileManager.FileAttributes", "vim.version.version7", 0, None),), (0, "void", "void"), None, ["vim.fault.GuestOperationsFault", "vim.fault.InvalidState", "vim.fault.TaskInProgress", "vim.fault.FileFault", ]), ("initiateFileTransferFromGuest", "InitiateFileTransferFromGuest", "vim.version.version7", (("vm", "vim.VirtualMachine", "vim.version.version7", 0, "VirtualMachine.GuestOperations.Query"),("auth", "vim.vm.guest.GuestAuthentication", "vim.version.version7", 0, None),("guestFilePath", "string", "vim.version.version7", 0, None),), (0, "vim.vm.guest.FileManager.FileTransferInformation", "vim.vm.guest.FileManager.FileTransferInformation"), None, ["vim.fault.GuestOperationsFault", "vim.fault.InvalidState", "vim.fault.TaskInProgress", "vim.fault.FileFault", ]), ("initiateFileTransferToGuest", "InitiateFileTransferToGuest", "vim.version.version7", (("vm", "vim.VirtualMachine", "vim.version.version7", 0, "VirtualMachine.GuestOperations.Modify"),("auth", "vim.vm.guest.GuestAuthentication", "vim.version.version7", 0, None),("guestFilePath", "string", "vim.version.version7", 0, None),("fileAttributes", "vim.vm.guest.FileManager.FileAttributes", "vim.version.version7", 0, None),("fileSize", "long", "vim.version.version7", 0, None),("overwrite", "boolean", "vim.version.version7", 0, None),), (0, "string", "string"), None, ["vim.fault.GuestOperationsFault", "vim.fault.InvalidState", "vim.fault.TaskInProgress", "vim.fault.FileFault", ])]) +CreateDataType("vim.vm.guest.FileManager.FileAttributes", "GuestFileAttributes", "vmodl.DynamicData", "vim.version.version7", [("modificationTime", "vmodl.DateTime", "vim.version.version7", F_OPTIONAL), ("accessTime", "vmodl.DateTime", "vim.version.version7", F_OPTIONAL), ("symlinkTarget", "string", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.vm.guest.FileManager.PosixFileAttributes", "GuestPosixFileAttributes", "vim.vm.guest.FileManager.FileAttributes", "vim.version.version7", [("ownerId", "int", "vim.version.version7", F_OPTIONAL), ("groupId", "int", "vim.version.version7", F_OPTIONAL), ("permissions", "long", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.vm.guest.FileManager.WindowsFileAttributes", "GuestWindowsFileAttributes", "vim.vm.guest.FileManager.FileAttributes", "vim.version.version7", [("hidden", "boolean", "vim.version.version7", F_OPTIONAL), ("readOnly", "boolean", "vim.version.version7", F_OPTIONAL), ("createTime", "vmodl.DateTime", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.vm.guest.FileManager.FileInfo", "GuestFileInfo", "vmodl.DynamicData", "vim.version.version7", [("path", "string", "vim.version.version7", 0), ("type", "string", "vim.version.version7", 0), ("size", "long", "vim.version.version7", 0), ("attributes", "vim.vm.guest.FileManager.FileAttributes", "vim.version.version7", 0)]) +CreateEnumType("vim.vm.guest.FileManager.FileInfo.FileType", "GuestFileType", "vim.version.version7", ["file", "directory", "symlink"]) +CreateDataType("vim.vm.guest.FileManager.ListFileInfo", "GuestListFileInfo", "vmodl.DynamicData", "vim.version.version7", [("files", "vim.vm.guest.FileManager.FileInfo[]", "vim.version.version7", F_OPTIONAL), ("remaining", "int", "vim.version.version7", 0)]) +CreateDataType("vim.vm.guest.FileManager.FileTransferInformation", "FileTransferInformation", "vmodl.DynamicData", "vim.version.version7", [("attributes", "vim.vm.guest.FileManager.FileAttributes", "vim.version.version7", 0), ("size", "long", "vim.version.version7", 0), ("url", "string", "vim.version.version7", 0)]) +CreateDataType("vim.vm.guest.GuestAuthentication", "GuestAuthentication", "vmodl.DynamicData", "vim.version.version7", [("interactiveSession", "boolean", "vim.version.version7", 0)]) +CreateManagedType("vim.vm.guest.GuestOperationsManager", "GuestOperationsManager", "vmodl.ManagedObject", "vim.version.version7", [("authManager", "vim.vm.guest.AuthManager", "vim.version.version7", F_OPTIONAL, "System.Anonymous"), ("fileManager", "vim.vm.guest.FileManager", "vim.version.version7", F_OPTIONAL, "System.Anonymous"), ("processManager", "vim.vm.guest.ProcessManager", "vim.version.version7", F_OPTIONAL, "System.Anonymous")], None) +CreateDataType("vim.vm.guest.NamePasswordAuthentication", "NamePasswordAuthentication", "vim.vm.guest.GuestAuthentication", "vim.version.version7", [("username", "string", "vim.version.version7", 0), ("password", "string", "vim.version.version7", 0)]) +CreateManagedType("vim.vm.guest.ProcessManager", "GuestProcessManager", "vmodl.ManagedObject", "vim.version.version7", None, [("startProgram", "StartProgramInGuest", "vim.version.version7", (("vm", "vim.VirtualMachine", "vim.version.version7", 0, "VirtualMachine.GuestOperations.Execute"),("auth", "vim.vm.guest.GuestAuthentication", "vim.version.version7", 0, None),("spec", "vim.vm.guest.ProcessManager.ProgramSpec", "vim.version.version7", 0, None),), (0, "long", "long"), None, ["vim.fault.GuestOperationsFault", "vim.fault.InvalidState", "vim.fault.TaskInProgress", "vim.fault.FileFault", ]), ("listProcesses", "ListProcessesInGuest", "vim.version.version7", (("vm", "vim.VirtualMachine", "vim.version.version7", 0, "VirtualMachine.GuestOperations.Query"),("auth", "vim.vm.guest.GuestAuthentication", "vim.version.version7", 0, None),("pids", "long[]", "vim.version.version7", F_OPTIONAL, None),), (F_OPTIONAL, "vim.vm.guest.ProcessManager.ProcessInfo[]", "vim.vm.guest.ProcessManager.ProcessInfo[]"), None, ["vim.fault.GuestOperationsFault", "vim.fault.InvalidState", "vim.fault.TaskInProgress", ]), ("terminateProcess", "TerminateProcessInGuest", "vim.version.version7", (("vm", "vim.VirtualMachine", "vim.version.version7", 0, "VirtualMachine.GuestOperations.Execute"),("auth", "vim.vm.guest.GuestAuthentication", "vim.version.version7", 0, None),("pid", "long", "vim.version.version7", 0, None),), (0, "void", "void"), None, ["vim.fault.GuestOperationsFault", "vim.fault.InvalidState", "vim.fault.TaskInProgress", ]), ("readEnvironmentVariable", "ReadEnvironmentVariableInGuest", "vim.version.version7", (("vm", "vim.VirtualMachine", "vim.version.version7", 0, "VirtualMachine.GuestOperations.Query"),("auth", "vim.vm.guest.GuestAuthentication", "vim.version.version7", 0, None),("names", "string[]", "vim.version.version7", F_OPTIONAL, None),), (F_OPTIONAL, "string[]", "string[]"), None, ["vim.fault.GuestOperationsFault", "vim.fault.InvalidState", "vim.fault.TaskInProgress", ])]) +CreateDataType("vim.vm.guest.ProcessManager.ProgramSpec", "GuestProgramSpec", "vmodl.DynamicData", "vim.version.version7", [("programPath", "string", "vim.version.version7", 0), ("arguments", "string", "vim.version.version7", 0), ("workingDirectory", "string", "vim.version.version7", F_OPTIONAL), ("envVariables", "string[]", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.vm.guest.ProcessManager.WindowsProgramSpec", "GuestWindowsProgramSpec", "vim.vm.guest.ProcessManager.ProgramSpec", "vim.version.version7", [("startMinimized", "boolean", "vim.version.version7", 0)]) +CreateDataType("vim.vm.guest.ProcessManager.ProcessInfo", "GuestProcessInfo", "vmodl.DynamicData", "vim.version.version7", [("name", "string", "vim.version.version7", 0), ("pid", "long", "vim.version.version7", 0), ("owner", "string", "vim.version.version7", 0), ("cmdLine", "string", "vim.version.version7", 0), ("startTime", "vmodl.DateTime", "vim.version.version7", 0), ("endTime", "vmodl.DateTime", "vim.version.version7", F_OPTIONAL), ("exitCode", "int", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.vm.guest.SSPIAuthentication", "SSPIAuthentication", "vim.vm.guest.GuestAuthentication", "vim.version.version7", [("sspiToken", "string", "vim.version.version7", 0)]) +CreateDataType("vim.vm.guest.TicketedSessionAuthentication", "TicketedSessionAuthentication", "vim.vm.guest.GuestAuthentication", "vim.version.version7", [("ticket", "string", "vim.version.version7", 0)]) +CreateDataType("vim.vsan.cluster.ConfigInfo", "VsanClusterConfigInfo", "vmodl.DynamicData", "vim.version.version9", [("enabled", "boolean", "vim.version.version9", F_OPTIONAL), ("defaultConfig", "vim.vsan.cluster.ConfigInfo.HostDefaultInfo", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.vsan.cluster.ConfigInfo.HostDefaultInfo", "VsanClusterConfigInfoHostDefaultInfo", "vmodl.DynamicData", "vim.version.version9", [("uuid", "string", "vim.version.version9", F_OPTIONAL), ("autoClaimStorage", "boolean", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.vsan.host.ClusterStatus", "VsanHostClusterStatus", "vmodl.DynamicData", "vim.version.version9", [("uuid", "string", "vim.version.version9", F_OPTIONAL), ("nodeUuid", "string", "vim.version.version9", F_OPTIONAL), ("health", "string", "vim.version.version9", 0), ("nodeState", "vim.vsan.host.ClusterStatus.State", "vim.version.version9", 0), ("memberUuid", "string[]", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.vsan.host.ClusterStatus.State", "VsanHostClusterStatusState", "vmodl.DynamicData", "vim.version.version9", [("state", "string", "vim.version.version9", 0), ("completion", "vim.vsan.host.ClusterStatus.State.CompletionEstimate", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.vsan.host.ClusterStatus.State.CompletionEstimate", "VsanHostClusterStatusStateCompletionEstimate", "vmodl.DynamicData", "vim.version.version9", [("completeTime", "vmodl.DateTime", "vim.version.version9", F_OPTIONAL), ("percentComplete", "int", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.vsan.host.ConfigInfo", "VsanHostConfigInfo", "vmodl.DynamicData", "vim.version.version9", [("enabled", "boolean", "vim.version.version9", F_OPTIONAL), ("hostSystem", "vim.HostSystem", "vim.version.version9", F_OPTIONAL), ("clusterInfo", "vim.vsan.host.ConfigInfo.ClusterInfo", "vim.version.version9", F_OPTIONAL), ("storageInfo", "vim.vsan.host.ConfigInfo.StorageInfo", "vim.version.version9", F_OPTIONAL), ("networkInfo", "vim.vsan.host.ConfigInfo.NetworkInfo", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.vsan.host.ConfigInfo.StorageInfo", "VsanHostConfigInfoStorageInfo", "vmodl.DynamicData", "vim.version.version9", [("autoClaimStorage", "boolean", "vim.version.version9", F_OPTIONAL), ("diskMapping", "vim.vsan.host.DiskMapping[]", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.vsan.host.ConfigInfo.ClusterInfo", "VsanHostConfigInfoClusterInfo", "vmodl.DynamicData", "vim.version.version9", [("uuid", "string", "vim.version.version9", F_OPTIONAL), ("nodeUuid", "string", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.vsan.host.ConfigInfo.NetworkInfo", "VsanHostConfigInfoNetworkInfo", "vmodl.DynamicData", "vim.version.version9", [("port", "vim.vsan.host.ConfigInfo.NetworkInfo.PortConfig[]", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.vsan.host.ConfigInfo.NetworkInfo.PortConfig", "VsanHostConfigInfoNetworkInfoPortConfig", "vmodl.DynamicData", "vim.version.version9", [("ipConfig", "vim.vsan.host.IpConfig", "vim.version.version9", F_OPTIONAL), ("device", "string", "vim.version.version9", 0)]) +CreateDataType("vim.vsan.host.DecommissionMode", "VsanHostDecommissionMode", "vmodl.DynamicData", "vim.version.version9", [("objectAction", "string", "vim.version.version9", 0)]) +CreateEnumType("vim.vsan.host.DecommissionMode.ObjectAction", "VsanHostDecommissionModeObjectAction", "vim.version.version9", ["noAction", "ensureObjectAccessibility", "evacuateAllData"]) +CreateDataType("vim.vsan.host.DiskMapResult", "VsanHostDiskMapResult", "vmodl.DynamicData", "vim.version.version9", [("mapping", "vim.vsan.host.DiskMapping", "vim.version.version9", 0), ("diskResult", "vim.vsan.host.DiskResult[]", "vim.version.version9", F_OPTIONAL), ("error", "vmodl.MethodFault", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.vsan.host.DiskMapping", "VsanHostDiskMapping", "vmodl.DynamicData", "vim.version.version9", [("ssd", "vim.host.ScsiDisk", "vim.version.version9", 0), ("nonSsd", "vim.host.ScsiDisk[]", "vim.version.version9", 0)]) +CreateDataType("vim.vsan.host.DiskResult", "VsanHostDiskResult", "vmodl.DynamicData", "vim.version.version9", [("disk", "vim.host.ScsiDisk", "vim.version.version9", 0), ("state", "string", "vim.version.version9", 0), ("vsanUuid", "string", "vim.version.version9", F_OPTIONAL), ("error", "vmodl.MethodFault", "vim.version.version9", F_OPTIONAL)]) +CreateEnumType("vim.vsan.host.DiskResult.State", "VsanHostDiskResultState", "vim.version.version9", ["inUse", "eligible", "ineligible"]) +CreateEnumType("vim.vsan.host.HealthState", "VsanHostHealthState", "vim.version.version9", ["unknown", "healthy", "unhealthy"]) +CreateDataType("vim.vsan.host.IpConfig", "VsanHostIpConfig", "vmodl.DynamicData", "vim.version.version9", [("upstreamIpAddress", "string", "vim.version.version9", 0), ("downstreamIpAddress", "string", "vim.version.version9", 0)]) +CreateDataType("vim.vsan.host.MembershipInfo", "VsanHostMembershipInfo", "vmodl.DynamicData", "vim.version.version9", [("nodeUuid", "string", "vim.version.version9", 0), ("hostname", "string", "vim.version.version9", 0)]) +CreateEnumType("vim.vsan.host.NodeState", "VsanHostNodeState", "vim.version.version9", ["error", "disabled", "agent", "master", "backup", "starting", "stopping", "enteringMaintenanceMode", "exitingMaintenanceMode", "decommissioning"]) +CreateDataType("vim.vsan.host.VsanRuntimeInfo", "VsanHostRuntimeInfo", "vmodl.DynamicData", "vim.version.version9", [("membershipList", "vim.vsan.host.MembershipInfo[]", "vim.version.version9", F_OPTIONAL), ("diskIssues", "vim.vsan.host.VsanRuntimeInfo.DiskIssue[]", "vim.version.version9", F_OPTIONAL), ("accessGenNo", "int", "vim.version.version9", F_OPTIONAL)]) +CreateEnumType("vim.vsan.host.VsanRuntimeInfo.DiskIssueType", "VsanDiskIssueType", "vim.version.version9", ["nonExist", "stampMismatch", "unknown"]) +CreateDataType("vim.vsan.host.VsanRuntimeInfo.DiskIssue", "VsanHostRuntimeInfoDiskIssue", "vmodl.DynamicData", "vim.version.version9", [("diskId", "string", "vim.version.version9", 0), ("issue", "string", "vim.version.version9", 0)]) +CreateManagedType("vim.AuthorizationManager", "AuthorizationManager", "vmodl.ManagedObject", "vim.version.version1", [("privilegeList", "vim.AuthorizationManager.Privilege[]", "vim.version.version1", F_OPTIONAL, "System.View"), ("roleList", "vim.AuthorizationManager.Role[]", "vim.version.version1", F_OPTIONAL, "System.View"), ("description", "vim.AuthorizationDescription", "vim.version.version1", 0, "System.View")], [("addRole", "AddAuthorizationRole", "vim.version.version1", (("name", "string", "vim.version.version1", 0, None),("privIds", "string[]", "vim.version.version1", F_OPTIONAL, None),), (0, "int", "int"), "Authorization.ModifyRoles", ["vim.fault.AlreadyExists", "vim.fault.InvalidName", ]), ("removeRole", "RemoveAuthorizationRole", "vim.version.version1", (("roleId", "int", "vim.version.version1", 0, None),("failIfUsed", "boolean", "vim.version.version1", 0, None),), (0, "void", "void"), "Authorization.ModifyRoles", ["vim.fault.NotFound", "vim.fault.RemoveFailed", ]), ("updateRole", "UpdateAuthorizationRole", "vim.version.version1", (("roleId", "int", "vim.version.version1", 0, None),("newName", "string", "vim.version.version1", 0, None),("privIds", "string[]", "vim.version.version1", F_OPTIONAL, None),), (0, "void", "void"), "Authorization.ModifyRoles", ["vim.fault.NotFound", "vim.fault.InvalidName", "vim.fault.AlreadyExists", ]), ("mergePermissions", "MergePermissions", "vim.version.version1", (("srcRoleId", "int", "vim.version.version1", 0, None),("dstRoleId", "int", "vim.version.version1", 0, None),), (0, "void", "void"), "Authorization.ReassignRolePermissions", ["vim.fault.NotFound", "vim.fault.AuthMinimumAdminPermission", ]), ("retrieveRolePermissions", "RetrieveRolePermissions", "vim.version.version1", (("roleId", "int", "vim.version.version1", 0, None),), (F_OPTIONAL, "vim.AuthorizationManager.Permission[]", "vim.AuthorizationManager.Permission[]"), "System.View", ["vim.fault.NotFound", ]), ("retrieveEntityPermissions", "RetrieveEntityPermissions", "vim.version.version1", (("entity", "vim.ManagedEntity", "vim.version.version1", 0, "System.Read"),("inherited", "boolean", "vim.version.version1", 0, None),), (F_OPTIONAL, "vim.AuthorizationManager.Permission[]", "vim.AuthorizationManager.Permission[]"), None, None), ("retrieveAllPermissions", "RetrieveAllPermissions", "vim.version.version1", (), (F_OPTIONAL, "vim.AuthorizationManager.Permission[]", "vim.AuthorizationManager.Permission[]"), "System.View", None), ("setEntityPermissions", "SetEntityPermissions", "vim.version.version1", (("entity", "vim.ManagedEntity", "vim.version.version1", 0, "Authorization.ModifyPermissions"),("permission", "vim.AuthorizationManager.Permission[]", "vim.version.version1", F_OPTIONAL, None),), (0, "void", "void"), None, ["vim.fault.UserNotFound", "vim.fault.NotFound", "vim.fault.AuthMinimumAdminPermission", ]), ("resetEntityPermissions", "ResetEntityPermissions", "vim.version.version1", (("entity", "vim.ManagedEntity", "vim.version.version1", 0, "Authorization.ModifyPermissions"),("permission", "vim.AuthorizationManager.Permission[]", "vim.version.version1", F_OPTIONAL, None),), (0, "void", "void"), None, ["vim.fault.UserNotFound", "vim.fault.NotFound", "vim.fault.AuthMinimumAdminPermission", ]), ("removeEntityPermission", "RemoveEntityPermission", "vim.version.version1", (("entity", "vim.ManagedEntity", "vim.version.version1", 0, "Authorization.ModifyPermissions"),("user", "string", "vim.version.version1", 0, None),("isGroup", "boolean", "vim.version.version1", 0, None),), (0, "void", "void"), None, ["vim.fault.NotFound", "vim.fault.AuthMinimumAdminPermission", ]), ("hasPrivilegeOnEntity", "HasPrivilegeOnEntity", "vim.version.version7", (("entity", "vim.ManagedEntity", "vim.version.version7", 0, "System.Read"),("sessionId", "string", "vim.version.version7", 0, None),("privId", "string[]", "vim.version.version7", F_OPTIONAL, None),), (F_OPTIONAL, "boolean[]", "boolean[]"), "System.View", None), ("hasPrivilegeOnEntities", "HasPrivilegeOnEntities", "vim.version.version9", (("entity", "vim.ManagedEntity[]", "vim.version.version9", 0, "System.Read"),("sessionId", "string", "vim.version.version9", 0, None),("privId", "string[]", "vim.version.version9", F_OPTIONAL, None),), (F_OPTIONAL, "vim.AuthorizationManager.EntityPrivilege[]", "vim.AuthorizationManager.EntityPrivilege[]"), "System.View", None)]) +CreateDataType("vim.AuthorizationManager.Permission", "Permission", "vmodl.DynamicData", "vim.version.version1", [("entity", "vim.ManagedEntity", "vim.version.version1", F_OPTIONAL), ("principal", "string", "vim.version.version1", 0), ("group", "boolean", "vim.version.version1", 0), ("roleId", "int", "vim.version.version1", 0), ("propagate", "boolean", "vim.version.version1", 0)]) +CreateDataType("vim.AuthorizationManager.Role", "AuthorizationRole", "vmodl.DynamicData", "vim.version.version1", [("roleId", "int", "vim.version.version1", 0), ("system", "boolean", "vim.version.version1", 0), ("name", "string", "vim.version.version1", 0), ("info", "vim.Description", "vim.version.version1", 0), ("privilege", "string[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.AuthorizationManager.Privilege", "AuthorizationPrivilege", "vmodl.DynamicData", "vim.version.version1", [("privId", "string", "vim.version.version1", 0), ("onParent", "boolean", "vim.version.version1", 0), ("name", "string", "vim.version.version1", 0), ("privGroupName", "string", "vim.version.version1", 0)]) +CreateDataType("vim.AuthorizationManager.PrivilegeAvailability", "PrivilegeAvailability", "vmodl.DynamicData", "vim.version.version9", [("privId", "string", "vim.version.version9", 0), ("isGranted", "boolean", "vim.version.version9", 0)]) +CreateDataType("vim.AuthorizationManager.EntityPrivilege", "EntityPrivilege", "vmodl.DynamicData", "vim.version.version9", [("entity", "vim.ManagedEntity", "vim.version.version9", 0), ("privAvailability", "vim.AuthorizationManager.PrivilegeAvailability[]", "vim.version.version9", 0)]) +CreateDataType("vim.BoolPolicy", "BoolPolicy", "vim.InheritablePolicy", "vim.version.version5", [("value", "boolean", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.EVCMode", "EVCMode", "vim.ElementDescription", "vim.version.version5", [("guaranteedCPUFeatures", "vim.host.CpuIdInfo[]", "vim.version.version6", F_OPTIONAL), ("featureCapability", "vim.host.FeatureCapability[]", "vim.version.version8", F_OPTIONAL), ("featureMask", "vim.host.FeatureMask[]", "vim.version.version8", F_OPTIONAL), ("featureRequirement", "vim.vm.FeatureRequirement[]", "vim.version.version8", F_OPTIONAL), ("vendor", "string", "vim.version.version5", 0), ("track", "string[]", "vim.version.version6", 0), ("vendorTier", "int", "vim.version.version5", 0)]) +CreateDataType("vim.ImportSpec", "ImportSpec", "vmodl.DynamicData", "vim.version.version5", [("entityConfig", "vim.vApp.EntityConfigInfo", "vim.version.version5", F_OPTIONAL), ("instantiationOst", "vim.OvfConsumer.OstNode", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.IntExpression", "IntExpression", "vim.NegatableExpression", "vim.version.version9", [("value", "int", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.IpAddress", "IpAddress", "vim.NegatableExpression", "vim.version.version9", None) +CreateDataType("vim.IpRange", "IpRange", "vim.IpAddress", "vim.version.version9", [("addressPrefix", "string", "vim.version.version9", 0), ("prefixLength", "int", "vim.version.version9", F_OPTIONAL)]) +CreateManagedType("vim.LicenseAssignmentManager", "LicenseAssignmentManager", "vmodl.ManagedObject", "vim.version.version5", None, [("updateAssignedLicense", "UpdateAssignedLicense", "vim.version.version5", (("entity", "string", "vim.version.version5", 0, None),("licenseKey", "string", "vim.version.version5", 0, None),("entityDisplayName", "string", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.LicenseManager.LicenseInfo", "vim.LicenseManager.LicenseInfo"), "Global.Licenses", ["vim.fault.LicenseEntityNotFound", ]), ("removeAssignedLicense", "RemoveAssignedLicense", "vim.version.version5", (("entityId", "string", "vim.version.version5", 0, None),), (0, "void", "void"), "Global.Licenses", ["vim.fault.LicenseEntityNotFound", ]), ("queryAssignedLicenses", "QueryAssignedLicenses", "vim.version.version5", (("entityId", "string", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.LicenseAssignmentManager.LicenseAssignment[]", "vim.LicenseAssignmentManager.LicenseAssignment[]"), "System.View", None)]) +CreateDataType("vim.LicenseAssignmentManager.LicenseAssignment", "LicenseAssignmentManagerLicenseAssignment", "vmodl.DynamicData", "vim.version.version5", [("entityId", "string", "vim.version.version5", 0), ("scope", "string", "vim.version.version5", F_OPTIONAL), ("entityDisplayName", "string", "vim.version.version5", F_OPTIONAL), ("assignedLicense", "vim.LicenseManager.LicenseInfo", "vim.version.version5", 0), ("properties", "vmodl.KeyAnyValue[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.MacAddress", "MacAddress", "vim.NegatableExpression", "vim.version.version9", None) +CreateDataType("vim.MacRange", "MacRange", "vim.MacAddress", "vim.version.version9", [("address", "string", "vim.version.version9", 0), ("mask", "string", "vim.version.version9", 0)]) +CreateManagedType("vim.ManagedEntity", "ManagedEntity", "vim.ExtensibleManagedObject", "vim.version.version1", [("parent", "vim.ManagedEntity", "vim.version.version1", F_OPTIONAL, "System.View"), ("customValue", "vim.CustomFieldsManager.Value[]", "vim.version.version1", F_OPTIONAL, "System.View"), ("overallStatus", "vim.ManagedEntity.Status", "vim.version.version1", 0, None), ("configStatus", "vim.ManagedEntity.Status", "vim.version.version1", 0, None), ("configIssue", "vim.event.Event[]", "vim.version.version1", F_OPTIONAL, None), ("effectiveRole", "int[]", "vim.version.version1", F_OPTIONAL, "System.View"), ("permission", "vim.AuthorizationManager.Permission[]", "vim.version.version1", F_OPTIONAL, None), ("name", "string", "vim.version.version1", 0, "System.View"), ("disabledMethod", "vmodl.MethodName[]", "vim.version.version1", F_OPTIONAL, None), ("recentTask", "vim.Task[]", "vim.version.version1", F_OPTIONAL, None), ("declaredAlarmState", "vim.alarm.AlarmState[]", "vim.version.version1", F_OPTIONAL, "System.View"), ("triggeredAlarmState", "vim.alarm.AlarmState[]", "vim.version.version1", F_OPTIONAL, "System.View"), ("alarmActionsEnabled", "boolean", "vim.version.version5", F_OPTIONAL, "System.Read"), ("tag", "vim.Tag[]", "vim.version.version5", F_OPTIONAL, "System.View")], [("reload", "Reload", "vim.version.version1", (), (0, "void", "void"), "System.Read", None), ("rename", "Rename_Task", "vim.version.version1", (("newName", "string", "vim.version.version1", 0, None),), (0, "vim.Task", "void"), None, ["vim.fault.DuplicateName", "vim.fault.InvalidName", ]), ("destroy", "Destroy_Task", "vim.version.version1", (), (0, "vim.Task", "void"), None, ["vim.fault.VimFault", ])]) +CreateEnumType("vim.ManagedEntity.Status", "ManagedEntityStatus", "vim.version.version1", ["gray", "green", "yellow", "red"]) +CreateManagedType("vim.Network", "Network", "vim.ManagedEntity", "vim.version.version1", [("summary", "vim.Network.Summary", "vim.version.version1", 0, None), ("host", "vim.HostSystem[]", "vim.version.version1", F_OPTIONAL, None), ("vm", "vim.VirtualMachine[]", "vim.version.version1", F_OPTIONAL, None)], [("destroyNetwork", "DestroyNetwork", "vim.version.version1", (), (0, "void", "void"), "Network.Delete", ["vim.fault.ResourceInUse", ])]) +CreateDataType("vim.Network.Summary", "NetworkSummary", "vmodl.DynamicData", "vim.version.version1", [("network", "vim.Network", "vim.version.version1", F_OPTIONAL), ("name", "string", "vim.version.version1", 0), ("accessible", "boolean", "vim.version.version1", 0), ("ipPoolName", "string", "vim.version.version5", 0), ("ipPoolId", "int", "vim.version.version8", F_OPTIONAL)]) +CreateManagedType("vim.OpaqueNetwork", "OpaqueNetwork", "vim.Network", "vim.version.version9", None, None) +CreateDataType("vim.OpaqueNetwork.Summary", "OpaqueNetworkSummary", "vim.Network.Summary", "vim.version.version9", [("opaqueNetworkId", "string", "vim.version.version9", 0), ("opaqueNetworkType", "string", "vim.version.version9", 0)]) +CreateDataType("vim.PosixUserSearchResult", "PosixUserSearchResult", "vim.UserSearchResult", "vim.version.version1", [("id", "int", "vim.version.version1", 0), ("shellAccess", "boolean", "vim.version.version1", F_OPTIONAL)]) +CreateManagedType("vim.ResourcePool", "ResourcePool", "vim.ManagedEntity", "vim.version.version1", [("summary", "vim.ResourcePool.Summary", "vim.version.version1", 0, None), ("runtime", "vim.ResourcePool.RuntimeInfo", "vim.version.version1", 0, None), ("owner", "vim.ComputeResource", "vim.version.version1", 0, "System.View"), ("resourcePool", "vim.ResourcePool[]", "vim.version.version1", F_OPTIONAL, "System.View"), ("vm", "vim.VirtualMachine[]", "vim.version.version1", F_OPTIONAL, "System.View"), ("config", "vim.ResourceConfigSpec", "vim.version.version1", 0, None), ("childConfiguration", "vim.ResourceConfigSpec[]", "vim.version.version1", F_OPTIONAL, None)], [("updateConfig", "UpdateConfig", "vim.version.version1", (("name", "string", "vim.version.version1", F_OPTIONAL, None),("config", "vim.ResourceConfigSpec", "vim.version.version1", F_OPTIONAL, None),), (0, "void", "void"), None, ["vim.fault.InvalidName", "vim.fault.DuplicateName", "vim.fault.InsufficientResourcesFault", "vim.fault.ConcurrentAccess", ]), ("moveInto", "MoveIntoResourcePool", "vim.version.version1", (("list", "vim.ManagedEntity[]", "vim.version.version1", 0, None),), (0, "void", "void"), None, ["vim.fault.DuplicateName", "vim.fault.InsufficientResourcesFault", ]), ("updateChildResourceConfiguration", "UpdateChildResourceConfiguration", "vim.version.version1", (("spec", "vim.ResourceConfigSpec[]", "vim.version.version1", 0, None),), (0, "void", "void"), None, ["vim.fault.InvalidState", "vim.fault.InsufficientResourcesFault", ]), ("createResourcePool", "CreateResourcePool", "vim.version.version1", (("name", "string", "vim.version.version1", 0, None),("spec", "vim.ResourceConfigSpec", "vim.version.version1", 0, None),), (0, "vim.ResourcePool", "vim.ResourcePool"), "Resource.CreatePool", ["vim.fault.InvalidName", "vim.fault.DuplicateName", "vim.fault.InsufficientResourcesFault", ]), ("destroyChildren", "DestroyChildren", "vim.version.version1", (), (0, "void", "void"), None, None), ("createVApp", "CreateVApp", "vim.version.version5", (("name", "string", "vim.version.version5", 0, None),("resSpec", "vim.ResourceConfigSpec", "vim.version.version5", 0, None),("configSpec", "vim.vApp.VAppConfigSpec", "vim.version.version5", 0, None),("vmFolder", "vim.Folder", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.VirtualApp", "vim.VirtualApp"), "VApp.Create", ["vim.fault.InvalidName", "vim.fault.DuplicateName", "vim.fault.InsufficientResourcesFault", "vim.fault.InvalidState", "vim.fault.VmConfigFault", ]), ("createVm", "CreateChildVM_Task", "vim.version.version5", (("config", "vim.vm.ConfigSpec", "vim.version.version5", 0, None),("host", "vim.HostSystem", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.Task", "vim.VirtualMachine"), "VirtualMachine.Inventory.Create", ["vim.fault.VmConfigFault", "vim.fault.FileFault", "vim.fault.OutOfBounds", "vim.fault.InvalidName", "vim.fault.InvalidDatastore", "vim.fault.InsufficientResourcesFault", ]), ("registerVm", "RegisterChildVM_Task", "vim.version.version5", (("path", "string", "vim.version.version5", 0, None),("name", "string", "vim.version.version5", F_OPTIONAL, None),("host", "vim.HostSystem", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.Task", "vim.VirtualMachine"), "VirtualMachine.Inventory.Register", ["vim.fault.OutOfBounds", "vim.fault.AlreadyExists", "vim.fault.InvalidDatastore", "vim.fault.NotFound", "vim.fault.InvalidName", "vim.fault.VmConfigFault", "vim.fault.InsufficientResourcesFault", "vim.fault.FileFault", ]), ("importVApp", "ImportVApp", "vim.version.version5", (("spec", "vim.ImportSpec", "vim.version.version5", 0, None),("folder", "vim.Folder", "vim.version.version5", F_OPTIONAL, "VApp.Import"),("host", "vim.HostSystem", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.HttpNfcLease", "vim.HttpNfcLease"), "VApp.Import", ["vim.fault.VmConfigFault", "vim.fault.FileFault", "vim.fault.OutOfBounds", "vim.fault.DuplicateName", "vim.fault.InvalidName", "vim.fault.InvalidDatastore", "vim.fault.InsufficientResourcesFault", ]), ("queryResourceConfigOption", "QueryResourceConfigOption", "vim.version.version6", (), (0, "vim.ResourceConfigOption", "vim.ResourceConfigOption"), "Resource.EditPool", None), ("refreshRuntime", "RefreshRuntime", "vim.version.version6", (), (0, "void", "void"), "System.View", None)]) +CreateDataType("vim.ResourcePool.ResourceUsage", "ResourcePoolResourceUsage", "vmodl.DynamicData", "vim.version.version1", [("reservationUsed", "long", "vim.version.version1", 0), ("reservationUsedForVm", "long", "vim.version.version1", 0), ("unreservedForPool", "long", "vim.version.version1", 0), ("unreservedForVm", "long", "vim.version.version1", 0), ("overallUsage", "long", "vim.version.version1", 0), ("maxUsage", "long", "vim.version.version1", 0)]) +CreateDataType("vim.ResourcePool.RuntimeInfo", "ResourcePoolRuntimeInfo", "vmodl.DynamicData", "vim.version.version1", [("memory", "vim.ResourcePool.ResourceUsage", "vim.version.version1", 0), ("cpu", "vim.ResourcePool.ResourceUsage", "vim.version.version1", 0), ("overallStatus", "vim.ManagedEntity.Status", "vim.version.version1", 0)]) +CreateDataType("vim.ResourcePool.Summary", "ResourcePoolSummary", "vmodl.DynamicData", "vim.version.version1", [("name", "string", "vim.version.version1", 0), ("config", "vim.ResourceConfigSpec", "vim.version.version1", 0), ("runtime", "vim.ResourcePool.RuntimeInfo", "vim.version.version1", 0), ("quickStats", "vim.ResourcePool.Summary.QuickStats", "vim.version.version5", F_OPTIONAL), ("configuredMemoryMB", "int", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.ResourcePool.Summary.QuickStats", "ResourcePoolQuickStats", "vmodl.DynamicData", "vim.version.version5", [("overallCpuUsage", "long", "vim.version.version5", F_OPTIONAL), ("overallCpuDemand", "long", "vim.version.version5", F_OPTIONAL), ("guestMemoryUsage", "long", "vim.version.version5", F_OPTIONAL), ("hostMemoryUsage", "long", "vim.version.version5", F_OPTIONAL), ("distributedCpuEntitlement", "long", "vim.version.version5", F_OPTIONAL), ("distributedMemoryEntitlement", "long", "vim.version.version5", F_OPTIONAL), ("staticCpuEntitlement", "int", "vim.version.version5", F_OPTIONAL), ("staticMemoryEntitlement", "int", "vim.version.version5", F_OPTIONAL), ("privateMemory", "long", "vim.version.version5", F_OPTIONAL), ("sharedMemory", "long", "vim.version.version5", F_OPTIONAL), ("swappedMemory", "long", "vim.version.version5", F_OPTIONAL), ("balloonedMemory", "long", "vim.version.version5", F_OPTIONAL), ("overheadMemory", "long", "vim.version.version5", F_OPTIONAL), ("consumedOverheadMemory", "long", "vim.version.version5", F_OPTIONAL), ("compressedMemory", "long", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.SingleIp", "SingleIp", "vim.IpAddress", "vim.version.version9", [("address", "string", "vim.version.version9", 0)]) +CreateDataType("vim.SingleMac", "SingleMac", "vim.MacAddress", "vim.version.version9", [("address", "string", "vim.version.version9", 0)]) +CreateManagedType("vim.Task", "Task", "vim.ExtensibleManagedObject", "vim.version.version1", [("info", "vim.TaskInfo", "vim.version.version1", 0, None)], [("cancel", "CancelTask", "vim.version.version1", (), (0, "void", "void"), "Global.CancelTask", ["vim.fault.InvalidState", ]), ("UpdateProgress", "UpdateProgress", "vim.version.version2", (("percentDone", "int", "vim.version.version2", 0, None),), (0, "void", "void"), "Task.Update", ["vim.fault.InvalidState", "vim.fault.OutOfBounds", ]), ("setState", "SetTaskState", "vim.version.version2", (("state", "vim.TaskInfo.State", "vim.version.version2", 0, None),("result", "anyType", "vim.version.version2", F_OPTIONAL, None),("fault", "vmodl.MethodFault", "vim.version.version2", F_OPTIONAL, None),), (0, "void", "void"), "Task.Update", ["vim.fault.InvalidState", ]), ("UpdateDescription", "SetTaskDescription", "vim.version.version5", (("description", "vmodl.LocalizableMessage", "vim.version.version5", 0, None),), (0, "void", "void"), "Task.Update", None)]) +CreateDataType("vim.TaskFilterSpec", "TaskFilterSpec", "vmodl.DynamicData", "vim.version.version1", [("entity", "vim.TaskFilterSpec.ByEntity", "vim.version.version1", F_OPTIONAL), ("time", "vim.TaskFilterSpec.ByTime", "vim.version.version1", F_OPTIONAL), ("userName", "vim.TaskFilterSpec.ByUsername", "vim.version.version1", F_OPTIONAL), ("state", "vim.TaskInfo.State[]", "vim.version.version1", F_OPTIONAL), ("alarm", "vim.alarm.Alarm", "vim.version.version1", F_OPTIONAL), ("scheduledTask", "vim.scheduler.ScheduledTask", "vim.version.version1", F_OPTIONAL), ("eventChainId", "int[]", "vim.version.version5", F_OPTIONAL), ("tag", "string[]", "vim.version.version5", F_OPTIONAL), ("parentTaskKey", "string[]", "vim.version.version5", F_OPTIONAL), ("rootTaskKey", "string[]", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.TaskFilterSpec.RecursionOption", "TaskFilterSpecRecursionOption", "vim.version.version1", ["self", "children", "all"]) +CreateEnumType("vim.TaskFilterSpec.TimeOption", "TaskFilterSpecTimeOption", "vim.version.version1", ["queuedTime", "startedTime", "completedTime"]) +CreateDataType("vim.TaskFilterSpec.ByEntity", "TaskFilterSpecByEntity", "vmodl.DynamicData", "vim.version.version1", [("entity", "vim.ManagedEntity", "vim.version.version1", 0), ("recursion", "vim.TaskFilterSpec.RecursionOption", "vim.version.version1", 0)]) +CreateDataType("vim.TaskFilterSpec.ByTime", "TaskFilterSpecByTime", "vmodl.DynamicData", "vim.version.version1", [("timeType", "vim.TaskFilterSpec.TimeOption", "vim.version.version1", 0), ("beginTime", "vmodl.DateTime", "vim.version.version1", F_OPTIONAL), ("endTime", "vmodl.DateTime", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.TaskFilterSpec.ByUsername", "TaskFilterSpecByUsername", "vmodl.DynamicData", "vim.version.version1", [("systemUser", "boolean", "vim.version.version1", 0), ("userList", "string[]", "vim.version.version1", F_OPTIONAL)]) +CreateManagedType("vim.VirtualApp", "VirtualApp", "vim.ResourcePool", "vim.version.version5", [("parentFolder", "vim.Folder", "vim.version.version5", F_OPTIONAL, "System.View"), ("datastore", "vim.Datastore[]", "vim.version.version5", F_OPTIONAL, "System.View"), ("network", "vim.Network[]", "vim.version.version5", F_OPTIONAL, "System.View"), ("vAppConfig", "vim.vApp.VAppConfigInfo", "vim.version.version5", F_OPTIONAL, "System.Read"), ("parentVApp", "vim.ManagedEntity", "vim.version.version6", F_OPTIONAL, None), ("childLink", "vim.VirtualApp.LinkInfo[]", "vim.version.version6", F_OPTIONAL, None)], [("updateVAppConfig", "UpdateVAppConfig", "vim.version.version5", (("spec", "vim.vApp.VAppConfigSpec", "vim.version.version5", 0, None),), (0, "void", "void"), None, ["vim.fault.TaskInProgress", "vim.fault.VmConfigFault", "vim.fault.ConcurrentAccess", "vim.fault.FileFault", "vim.fault.InvalidName", "vim.fault.DuplicateName", "vim.fault.InvalidState", "vim.fault.InsufficientResourcesFault", "vim.fault.InvalidDatastore", ]), ("updateLinkedChildren", "UpdateLinkedChildren", "vim.version.version6", (("addChangeSet", "vim.VirtualApp.LinkInfo[]", "vim.version.version6", F_OPTIONAL, None),("removeSet", "vim.ManagedEntity[]", "vim.version.version6", F_OPTIONAL, None),), (0, "void", "void"), None, ["vim.fault.ConcurrentAccess", ]), ("clone", "CloneVApp_Task", "vim.version.version5", (("name", "string", "vim.version.version5", 0, None),("target", "vim.ResourcePool", "vim.version.version5", 0, None),("spec", "vim.vApp.CloneSpec", "vim.version.version5", 0, None),), (0, "vim.Task", "vim.VirtualApp"), "VApp.Clone", ["vim.fault.InvalidState", "vim.fault.InvalidDatastore", "vim.fault.TaskInProgress", "vim.fault.VmConfigFault", "vim.fault.FileFault", "vim.fault.MigrationFault", "vim.fault.InsufficientResourcesFault", ]), ("exportVApp", "ExportVApp", "vim.version.version5", (), (0, "vim.HttpNfcLease", "vim.HttpNfcLease"), "VApp.Export", ["vim.fault.InvalidPowerState", "vim.fault.TaskInProgress", "vim.fault.InvalidState", "vim.fault.FileFault", ]), ("powerOn", "PowerOnVApp_Task", "vim.version.version5", (), (0, "vim.Task", "void"), "VApp.PowerOn", ["vim.fault.TaskInProgress", "vim.fault.InvalidState", "vim.fault.InsufficientResourcesFault", "vim.fault.VmConfigFault", "vim.fault.VAppConfigFault", "vim.fault.FileFault", ]), ("powerOff", "PowerOffVApp_Task", "vim.version.version5", (("force", "boolean", "vim.version.version5", 0, None),), (0, "vim.Task", "void"), "VApp.PowerOff", ["vim.fault.TaskInProgress", "vim.fault.InvalidState", "vim.fault.VAppConfigFault", ]), ("suspend", "SuspendVApp_Task", "vim.version.version6", (), (0, "vim.Task", "void"), "VApp.Suspend", ["vim.fault.TaskInProgress", "vim.fault.InvalidState", "vim.fault.VAppConfigFault", ]), ("unregister", "unregisterVApp_Task", "vim.version.version5", (), (0, "vim.Task", "void"), "VApp.Unregister", ["vim.fault.ConcurrentAccess", "vim.fault.InvalidState", ])]) +CreateEnumType("vim.VirtualApp.VAppState", "VirtualAppVAppState", "vim.version.version5", ["started", "stopped", "starting", "stopping"]) +CreateDataType("vim.VirtualApp.Summary", "VirtualAppSummary", "vim.ResourcePool.Summary", "vim.version.version5", [("product", "vim.vApp.ProductInfo", "vim.version.version5", F_OPTIONAL), ("vAppState", "vim.VirtualApp.VAppState", "vim.version.version5", F_OPTIONAL), ("suspended", "boolean", "vim.version.version6", F_OPTIONAL), ("installBootRequired", "boolean", "vim.version.version5", F_OPTIONAL), ("instanceUuid", "string", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.VirtualApp.LinkInfo", "VirtualAppLinkInfo", "vmodl.DynamicData", "vim.version.version6", [("key", "vim.ManagedEntity", "vim.version.version6", 0), ("destroyWithParent", "boolean", "vim.version.version6", F_OPTIONAL)]) +CreateManagedType("vim.VirtualDiskManager", "VirtualDiskManager", "vmodl.ManagedObject", "vim.version.version2", None, [("createVirtualDisk", "CreateVirtualDisk_Task", "vim.version.version2", (("name", "string", "vim.version.version2", 0, None),("datacenter", "vim.Datacenter", "vim.version.version2", F_OPTIONAL, None),("spec", "vim.VirtualDiskManager.VirtualDiskSpec", "vim.version.version2", 0, None),), (0, "vim.Task", "string"), "System.View", ["vim.fault.FileFault", "vim.fault.InvalidDatastore", ]), ("deleteVirtualDisk", "DeleteVirtualDisk_Task", "vim.version.version2", (("name", "string", "vim.version.version2", 0, None),("datacenter", "vim.Datacenter", "vim.version.version2", F_OPTIONAL, None),), (0, "vim.Task", "void"), "System.View", ["vim.fault.FileFault", "vim.fault.InvalidDatastore", ]), ("moveVirtualDisk", "MoveVirtualDisk_Task", "vim.version.version2", (("sourceName", "string", "vim.version.version2", 0, None),("sourceDatacenter", "vim.Datacenter", "vim.version.version2", F_OPTIONAL, None),("destName", "string", "vim.version.version2", 0, None),("destDatacenter", "vim.Datacenter", "vim.version.version2", F_OPTIONAL, None),("force", "boolean", "vim.version.version2", F_OPTIONAL, None),("profile", "vim.vm.ProfileSpec[]", "vim.version.version9", F_OPTIONAL, None),), (0, "vim.Task", "string"), "System.View", ["vim.fault.FileFault", "vim.fault.InvalidDatastore", ]), ("copyVirtualDisk", "CopyVirtualDisk_Task", "vim.version.version2", (("sourceName", "string", "vim.version.version2", 0, None),("sourceDatacenter", "vim.Datacenter", "vim.version.version2", F_OPTIONAL, None),("destName", "string", "vim.version.version2", 0, None),("destDatacenter", "vim.Datacenter", "vim.version.version2", F_OPTIONAL, None),("destSpec", "vim.VirtualDiskManager.VirtualDiskSpec", "vim.version.version2", F_OPTIONAL, None),("force", "boolean", "vim.version.version2", F_OPTIONAL, None),), (0, "vim.Task", "string"), "System.View", ["vim.fault.FileFault", "vim.fault.InvalidDiskFormat", "vim.fault.InvalidDatastore", ]), ("extendVirtualDisk", "ExtendVirtualDisk_Task", "vim.version.version2", (("name", "string", "vim.version.version2", 0, None),("datacenter", "vim.Datacenter", "vim.version.version2", F_OPTIONAL, None),("newCapacityKb", "long", "vim.version.version2", 0, None),("eagerZero", "boolean", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.Task", "void"), "System.View", ["vim.fault.FileFault", "vim.fault.InvalidDatastore", ]), ("queryVirtualDiskFragmentation", "QueryVirtualDiskFragmentation", "vim.version.version2", (("name", "string", "vim.version.version2", 0, None),("datacenter", "vim.Datacenter", "vim.version.version2", F_OPTIONAL, None),), (0, "int", "int"), "System.View", ["vim.fault.FileFault", "vim.fault.InvalidDatastore", ]), ("defragmentVirtualDisk", "DefragmentVirtualDisk_Task", "vim.version.version2", (("name", "string", "vim.version.version2", 0, None),("datacenter", "vim.Datacenter", "vim.version.version2", F_OPTIONAL, None),), (0, "vim.Task", "void"), "System.View", ["vim.fault.FileFault", "vim.fault.InvalidDatastore", ]), ("shrinkVirtualDisk", "ShrinkVirtualDisk_Task", "vim.version.version2", (("name", "string", "vim.version.version2", 0, None),("datacenter", "vim.Datacenter", "vim.version.version2", F_OPTIONAL, None),("copy", "boolean", "vim.version.version2", F_OPTIONAL, None),), (0, "vim.Task", "void"), "System.View", ["vim.fault.FileFault", "vim.fault.InvalidDatastore", ]), ("inflateVirtualDisk", "InflateVirtualDisk_Task", "vim.version.version2", (("name", "string", "vim.version.version2", 0, None),("datacenter", "vim.Datacenter", "vim.version.version2", F_OPTIONAL, None),), (0, "vim.Task", "void"), "System.View", ["vim.fault.FileFault", "vim.fault.InvalidDatastore", ]), ("eagerZeroVirtualDisk", "EagerZeroVirtualDisk_Task", "vim.version.version5", (("name", "string", "vim.version.version5", 0, None),("datacenter", "vim.Datacenter", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.Task", "void"), "System.View", ["vim.fault.FileFault", "vim.fault.InvalidDatastore", ]), ("zeroFillVirtualDisk", "ZeroFillVirtualDisk_Task", "vim.version.version2", (("name", "string", "vim.version.version2", 0, None),("datacenter", "vim.Datacenter", "vim.version.version2", F_OPTIONAL, None),), (0, "vim.Task", "void"), "System.View", ["vim.fault.FileFault", "vim.fault.InvalidDatastore", ]), ("setVirtualDiskUuid", "SetVirtualDiskUuid", "vim.version.version2", (("name", "string", "vim.version.version2", 0, None),("datacenter", "vim.Datacenter", "vim.version.version2", F_OPTIONAL, None),("uuid", "string", "vim.version.version2", 0, None),), (0, "void", "void"), "System.View", ["vim.fault.FileFault", "vim.fault.InvalidDatastore", ]), ("queryVirtualDiskUuid", "QueryVirtualDiskUuid", "vim.version.version2", (("name", "string", "vim.version.version2", 0, None),("datacenter", "vim.Datacenter", "vim.version.version2", F_OPTIONAL, None),), (0, "string", "string"), "System.View", ["vim.fault.FileFault", "vim.fault.InvalidDatastore", ]), ("queryVirtualDiskGeometry", "QueryVirtualDiskGeometry", "vim.version.version2", (("name", "string", "vim.version.version2", 0, None),("datacenter", "vim.Datacenter", "vim.version.version2", F_OPTIONAL, None),), (0, "vim.host.DiskDimensions.Chs", "vim.host.DiskDimensions.Chs"), "System.View", ["vim.fault.FileFault", "vim.fault.InvalidDatastore", ])]) +CreateEnumType("vim.VirtualDiskManager.VirtualDiskType", "VirtualDiskType", "vim.version.version2", ["preallocated", "thin", "seSparse", "rdm", "rdmp", "raw", "delta", "sparse2Gb", "thick2Gb", "eagerZeroedThick", "sparseMonolithic", "flatMonolithic", "thick"]) +CreateEnumType("vim.VirtualDiskManager.VirtualDiskAdapterType", "VirtualDiskAdapterType", "vim.version.version2", ["ide", "busLogic", "lsiLogic"]) +CreateDataType("vim.VirtualDiskManager.VirtualDiskSpec", "VirtualDiskSpec", "vmodl.DynamicData", "vim.version.version2", [("diskType", "string", "vim.version.version2", 0), ("adapterType", "string", "vim.version.version2", 0)]) +CreateDataType("vim.VirtualDiskManager.FileBackedVirtualDiskSpec", "FileBackedVirtualDiskSpec", "vim.VirtualDiskManager.VirtualDiskSpec", "vim.version.version2", [("capacityKb", "long", "vim.version.version2", 0), ("profile", "vim.vm.ProfileSpec[]", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.VirtualDiskManager.SeSparseVirtualDiskSpec", "SeSparseVirtualDiskSpec", "vim.VirtualDiskManager.FileBackedVirtualDiskSpec", "vim.version.version8", [("grainSizeKb", "int", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.VirtualDiskManager.DeviceBackedVirtualDiskSpec", "DeviceBackedVirtualDiskSpec", "vim.VirtualDiskManager.VirtualDiskSpec", "vim.version.version2", [("device", "string", "vim.version.version2", 0)]) +CreateManagedType("vim.VirtualMachine", "VirtualMachine", "vim.ManagedEntity", "vim.version.version1", [("capability", "vim.vm.Capability", "vim.version.version1", 0, None), ("config", "vim.vm.ConfigInfo", "vim.version.version1", F_OPTIONAL, None), ("layout", "vim.vm.FileLayout", "vim.version.version1", F_OPTIONAL, None), ("layoutEx", "vim.vm.FileLayoutEx", "vim.version.version5", F_OPTIONAL, None), ("storage", "vim.vm.StorageInfo", "vim.version.version5", F_OPTIONAL, None), ("environmentBrowser", "vim.EnvironmentBrowser", "vim.version.version1", 0, None), ("resourcePool", "vim.ResourcePool", "vim.version.version1", F_OPTIONAL, None), ("parentVApp", "vim.ManagedEntity", "vim.version.version6", F_OPTIONAL, None), ("resourceConfig", "vim.ResourceConfigSpec", "vim.version.version1", F_OPTIONAL, None), ("runtime", "vim.vm.RuntimeInfo", "vim.version.version1", 0, None), ("guest", "vim.vm.GuestInfo", "vim.version.version1", F_OPTIONAL, None), ("summary", "vim.vm.Summary", "vim.version.version1", 0, None), ("datastore", "vim.Datastore[]", "vim.version.version1", F_OPTIONAL, "System.View"), ("network", "vim.Network[]", "vim.version.version1", F_OPTIONAL, "System.View"), ("snapshot", "vim.vm.SnapshotInfo", "vim.version.version1", F_OPTIONAL, None), ("rootSnapshot", "vim.vm.Snapshot[]", "vim.version.version6", F_OPTIONAL, None), ("guestHeartbeatStatus", "vim.ManagedEntity.Status", "vim.version.version1", 0, None)], [("refreshStorageInfo", "RefreshStorageInfo", "vim.version.version5", (), (0, "void", "void"), "System.Read", None), ("createSnapshot", "CreateSnapshot_Task", "vim.version.version1", (("name", "string", "vim.version.version1", 0, None),("description", "string", "vim.version.version1", F_OPTIONAL, None),("memory", "boolean", "vim.version.version1", 0, None),("quiesce", "boolean", "vim.version.version1", 0, None),), (0, "vim.Task", "vim.vm.Snapshot"), "VirtualMachine.State.CreateSnapshot", ["vim.fault.TaskInProgress", "vim.fault.SnapshotFault", "vim.fault.VmConfigFault", "vim.fault.FileFault", "vim.fault.InvalidName", "vim.fault.InvalidState", ]), ("revertToCurrentSnapshot", "RevertToCurrentSnapshot_Task", "vim.version.version1", (("host", "vim.HostSystem", "vim.version.version1", F_OPTIONAL, None),("suppressPowerOn", "boolean", "vim.version.version4", F_OPTIONAL, None),), (0, "vim.Task", "void"), "VirtualMachine.State.RevertToSnapshot", ["vim.fault.TaskInProgress", "vim.fault.SnapshotFault", "vim.fault.InsufficientResourcesFault", "vim.fault.InvalidState", "vim.fault.VmConfigFault", "vim.fault.NotFound", ]), ("removeAllSnapshots", "RemoveAllSnapshots_Task", "vim.version.version1", (("consolidate", "boolean", "vim.version.version7", F_OPTIONAL, None),), (0, "vim.Task", "void"), "VirtualMachine.State.RemoveSnapshot", ["vim.fault.TaskInProgress", "vim.fault.InvalidState", "vim.fault.SnapshotFault", ]), ("consolidateDisks", "ConsolidateVMDisks_Task", "vim.version.version7", (), (0, "vim.Task", "void"), "VirtualMachine.State.RemoveSnapshot", ["vim.fault.TaskInProgress", "vim.fault.InvalidState", "vim.fault.FileFault", "vim.fault.VmConfigFault", ]), ("estimateStorageRequirementForConsolidate", "EstimateStorageForConsolidateSnapshots_Task", "vim.version.version7", (), (F_OPTIONAL, "vim.Task", "vim.VirtualMachine.StorageRequirement[]"), "VirtualMachine.State.RemoveSnapshot", ["vim.fault.TaskInProgress", "vim.fault.InvalidState", "vim.fault.FileFault", "vim.fault.VmConfigFault", ]), ("reconfigure", "ReconfigVM_Task", "vim.version.version1", (("spec", "vim.vm.ConfigSpec", "vim.version.version1", 0, None),), (0, "vim.Task", "void"), None, ["vim.fault.TaskInProgress", "vim.fault.VmConfigFault", "vim.fault.ConcurrentAccess", "vim.fault.FileFault", "vim.fault.InvalidName", "vim.fault.DuplicateName", "vim.fault.InvalidState", "vim.fault.InsufficientResourcesFault", "vim.fault.InvalidDatastore", ]), ("upgradeVirtualHardware", "UpgradeVM_Task", "vim.version.version1", (("version", "string", "vim.version.version1", F_OPTIONAL, None),), (0, "vim.Task", "void"), "VirtualMachine.Config.UpgradeVirtualHardware", ["vim.fault.InvalidState", "vim.fault.TaskInProgress", "vim.fault.AlreadyUpgraded", "vim.fault.NoDiskFound", ]), ("extractOvfEnvironment", "ExtractOvfEnvironment", "vim.version.version5", (), (0, "string", "string"), "VApp.ExtractOvfEnvironment", ["vim.fault.InvalidState", ]), ("powerOn", "PowerOnVM_Task", "vim.version.version1", (("host", "vim.HostSystem", "vim.version.version1", F_OPTIONAL, None),), (0, "vim.Task", "void"), "VirtualMachine.Interact.PowerOn", ["vim.fault.TaskInProgress", "vim.fault.InvalidState", "vim.fault.InsufficientResourcesFault", "vim.fault.VmConfigFault", "vim.fault.FileFault", ]), ("powerOff", "PowerOffVM_Task", "vim.version.version1", (), (0, "vim.Task", "void"), "VirtualMachine.Interact.PowerOff", ["vim.fault.TaskInProgress", "vim.fault.InvalidState", ]), ("suspend", "SuspendVM_Task", "vim.version.version1", (), (0, "vim.Task", "void"), "VirtualMachine.Interact.Suspend", ["vim.fault.TaskInProgress", "vim.fault.InvalidState", ]), ("reset", "ResetVM_Task", "vim.version.version1", (), (0, "vim.Task", "void"), "VirtualMachine.Interact.Reset", ["vim.fault.TaskInProgress", "vim.fault.InvalidState", ]), ("shutdownGuest", "ShutdownGuest", "vim.version.version1", (), (0, "void", "void"), "VirtualMachine.Interact.PowerOff", ["vim.fault.ToolsUnavailable", "vim.fault.TaskInProgress", "vim.fault.InvalidState", ]), ("rebootGuest", "RebootGuest", "vim.version.version1", (), (0, "void", "void"), "VirtualMachine.Interact.Reset", ["vim.fault.ToolsUnavailable", "vim.fault.TaskInProgress", "vim.fault.InvalidState", ]), ("standbyGuest", "StandbyGuest", "vim.version.version1", (), (0, "void", "void"), "VirtualMachine.Interact.Suspend", ["vim.fault.ToolsUnavailable", "vim.fault.TaskInProgress", "vim.fault.InvalidState", ]), ("answer", "AnswerVM", "vim.version.version1", (("questionId", "string", "vim.version.version1", 0, None),("answerChoice", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "VirtualMachine.Interact.AnswerQuestion", ["vim.fault.ConcurrentAccess", ]), ("customize", "CustomizeVM_Task", "vim.version.version1", (("spec", "vim.vm.customization.Specification", "vim.version.version1", 0, None),), (0, "vim.Task", "void"), "VirtualMachine.Provisioning.Customize", ["vim.fault.CustomizationFault", ]), ("checkCustomizationSpec", "CheckCustomizationSpec", "vim.version.version1", (("spec", "vim.vm.customization.Specification", "vim.version.version1", 0, None),), (0, "void", "void"), "VirtualMachine.Provisioning.Customize", ["vim.fault.CustomizationFault", ]), ("migrate", "MigrateVM_Task", "vim.version.version1", (("pool", "vim.ResourcePool", "vim.version.version1", F_OPTIONAL, "Resource.AssignVMToPool"),("host", "vim.HostSystem", "vim.version.version1", F_OPTIONAL, None),("priority", "vim.VirtualMachine.MovePriority", "vim.version.version1", 0, None),("state", "vim.VirtualMachine.PowerState", "vim.version.version1", F_OPTIONAL, None),), (0, "vim.Task", "void"), None, ["vim.fault.MigrationFault", "vim.fault.FileFault", "vim.fault.Timedout", "vim.fault.InsufficientResourcesFault", "vim.fault.InvalidState", "vim.fault.VmConfigFault", ]), ("relocate", "RelocateVM_Task", "vim.version.version1", (("spec", "vim.vm.RelocateSpec", "vim.version.version1", 0, None),("priority", "vim.VirtualMachine.MovePriority", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.Task", "void"), "Resource.ColdMigrate", ["vim.fault.InvalidState", "vim.fault.InvalidDatastore", "vim.fault.MigrationFault", "vim.fault.VmConfigFault", "vim.fault.FileFault", "vim.fault.Timedout", "vim.fault.InsufficientResourcesFault", ]), ("clone", "CloneVM_Task", "vim.version.version1", (("folder", "vim.Folder", "vim.version.version1", 0, "VirtualMachine.Inventory.CreateFromExisting"),("name", "string", "vim.version.version1", 0, None),("spec", "vim.vm.CloneSpec", "vim.version.version1", 0, None),), (0, "vim.Task", "vim.VirtualMachine"), None, ["vim.fault.CustomizationFault", "vim.fault.InvalidState", "vim.fault.InvalidDatastore", "vim.fault.TaskInProgress", "vim.fault.VmConfigFault", "vim.fault.FileFault", "vim.fault.MigrationFault", "vim.fault.InsufficientResourcesFault", ]), ("exportVm", "ExportVm", "vim.version.version5", (), (0, "vim.HttpNfcLease", "vim.HttpNfcLease"), "VApp.Export", ["vim.fault.InvalidPowerState", "vim.fault.TaskInProgress", "vim.fault.InvalidState", "vim.fault.FileFault", ]), ("markAsTemplate", "MarkAsTemplate", "vim.version.version1", (), (0, "void", "void"), "VirtualMachine.Provisioning.MarkAsTemplate", ["vim.fault.InvalidState", "vim.fault.VmConfigFault", "vim.fault.FileFault", ]), ("markAsVirtualMachine", "MarkAsVirtualMachine", "vim.version.version1", (("pool", "vim.ResourcePool", "vim.version.version1", 0, "Resource.AssignVMToPool"),("host", "vim.HostSystem", "vim.version.version1", F_OPTIONAL, None),), (0, "void", "void"), "VirtualMachine.Provisioning.MarkAsVM", ["vim.fault.InvalidState", "vim.fault.InvalidDatastore", "vim.fault.VmConfigFault", "vim.fault.FileFault", ]), ("unregister", "UnregisterVM", "vim.version.version1", (), (0, "void", "void"), "VirtualMachine.Inventory.Unregister", ["vim.fault.TaskInProgress", "vim.fault.InvalidPowerState", ]), ("resetGuestInformation", "ResetGuestInformation", "vim.version.version1", (), (0, "void", "void"), "VirtualMachine.Config.ResetGuestInfo", ["vim.fault.InvalidState", ]), ("mountToolsInstaller", "MountToolsInstaller", "vim.version.version1", (), (0, "void", "void"), "VirtualMachine.Interact.ToolsInstall", ["vim.fault.InvalidState", "vim.fault.VmConfigFault", "vim.fault.VmToolsUpgradeFault", ]), ("unmountToolsInstaller", "UnmountToolsInstaller", "vim.version.version1", (), (0, "void", "void"), "VirtualMachine.Interact.ToolsInstall", ["vim.fault.InvalidState", "vim.fault.VmConfigFault", ]), ("upgradeTools", "UpgradeTools_Task", "vim.version.version1", (("installerOptions", "string", "vim.version.version1", F_OPTIONAL, None),), (0, "vim.Task", "void"), "VirtualMachine.Interact.ToolsInstall", ["vim.fault.InvalidState", "vim.fault.TaskInProgress", "vim.fault.VmToolsUpgradeFault", "vim.fault.ToolsUnavailable", "vim.fault.VmConfigFault", ]), ("acquireMksTicket", "AcquireMksTicket", "vim.version.version1", (), (0, "vim.VirtualMachine.MksTicket", "vim.VirtualMachine.MksTicket"), "VirtualMachine.Interact.ConsoleInteract", None), ("acquireTicket", "AcquireTicket", "vim.version.version6", (("ticketType", "string", "vim.version.version6", 0, None),), (0, "vim.VirtualMachine.Ticket", "vim.VirtualMachine.Ticket"), None, ["vim.fault.InvalidState", ]), ("setScreenResolution", "SetScreenResolution", "vim.version.version1", (("width", "int", "vim.version.version1", 0, None),("height", "int", "vim.version.version1", 0, None),), (0, "void", "void"), "VirtualMachine.Interact.ConsoleInteract", ["vim.fault.InvalidState", "vim.fault.ToolsUnavailable", ]), ("defragmentAllDisks", "DefragmentAllDisks", "vim.version.version2", (), (0, "void", "void"), "VirtualMachine.Interact.DefragmentAllDisks", ["vim.fault.InvalidState", "vim.fault.InvalidPowerState", "vim.fault.TaskInProgress", "vim.fault.FileFault", ]), ("createSecondary", "CreateSecondaryVM_Task", "vim.version.version5", (("host", "vim.HostSystem", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.Task", "vim.vm.FaultToleranceSecondaryOpResult"), "VirtualMachine.Interact.CreateSecondary", ["vim.fault.TaskInProgress", "vim.fault.InvalidState", "vim.fault.InsufficientResourcesFault", "vim.fault.VmFaultToleranceIssue", "vim.fault.FileFault", "vim.fault.VmConfigFault", ]), ("turnOffFaultTolerance", "TurnOffFaultToleranceForVM_Task", "vim.version.version5", (), (0, "vim.Task", "void"), "VirtualMachine.Interact.TurnOffFaultTolerance", ["vim.fault.TaskInProgress", "vim.fault.VmFaultToleranceIssue", "vim.fault.InvalidState", ]), ("makePrimary", "MakePrimaryVM_Task", "vim.version.version5", (("vm", "vim.VirtualMachine", "vim.version.version5", 0, None),), (0, "vim.Task", "void"), "VirtualMachine.Interact.MakePrimary", ["vim.fault.TaskInProgress", "vim.fault.VmFaultToleranceIssue", "vim.fault.InvalidState", ]), ("terminateFaultTolerantVM", "TerminateFaultTolerantVM_Task", "vim.version.version5", (("vm", "vim.VirtualMachine", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.Task", "void"), "VirtualMachine.Interact.TerminateFaultTolerantVM", ["vim.fault.TaskInProgress", "vim.fault.VmFaultToleranceIssue", "vim.fault.InvalidState", ]), ("disableSecondary", "DisableSecondaryVM_Task", "vim.version.version5", (("vm", "vim.VirtualMachine", "vim.version.version5", 0, None),), (0, "vim.Task", "void"), "VirtualMachine.Interact.DisableSecondary", ["vim.fault.TaskInProgress", "vim.fault.VmFaultToleranceIssue", "vim.fault.InvalidState", ]), ("enableSecondary", "EnableSecondaryVM_Task", "vim.version.version5", (("vm", "vim.VirtualMachine", "vim.version.version5", 0, None),("host", "vim.HostSystem", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.Task", "vim.vm.FaultToleranceSecondaryOpResult"), "VirtualMachine.Interact.EnableSecondary", ["vim.fault.TaskInProgress", "vim.fault.VmFaultToleranceIssue", "vim.fault.InvalidState", "vim.fault.VmConfigFault", ]), ("setDisplayTopology", "SetDisplayTopology", "vim.version.version4", (("displays", "vim.VirtualMachine.DisplayTopology[]", "vim.version.version4", 0, None),), (0, "void", "void"), "VirtualMachine.Interact.ConsoleInteract", ["vim.fault.InvalidState", "vim.fault.ToolsUnavailable", ]), ("startRecording", "StartRecording_Task", "vim.version.version5", (("name", "string", "vim.version.version5", 0, None),("description", "string", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.Task", "vim.vm.Snapshot"), "VirtualMachine.Interact.Record", ["vim.fault.InvalidState", "vim.fault.InvalidPowerState", "vim.fault.TaskInProgress", "vim.fault.FileFault", "vim.fault.SnapshotFault", "vim.fault.VmConfigFault", "vim.fault.RecordReplayDisabled", "vim.fault.HostIncompatibleForRecordReplay", "vim.fault.InvalidName", ]), ("stopRecording", "StopRecording_Task", "vim.version.version5", (), (0, "vim.Task", "void"), "VirtualMachine.Interact.Record", ["vim.fault.InvalidState", "vim.fault.InvalidPowerState", "vim.fault.TaskInProgress", "vim.fault.FileFault", "vim.fault.SnapshotFault", ]), ("startReplaying", "StartReplaying_Task", "vim.version.version5", (("replaySnapshot", "vim.vm.Snapshot", "vim.version.version5", 0, None),), (0, "vim.Task", "void"), "VirtualMachine.Interact.Replay", ["vim.fault.InvalidState", "vim.fault.InvalidPowerState", "vim.fault.TaskInProgress", "vim.fault.FileFault", "vim.fault.SnapshotFault", "vim.fault.NotFound", "vim.fault.VmConfigFault", "vim.fault.RecordReplayDisabled", "vim.fault.HostIncompatibleForRecordReplay", ]), ("stopReplaying", "StopReplaying_Task", "vim.version.version5", (), (0, "vim.Task", "void"), "VirtualMachine.Interact.Replay", ["vim.fault.InvalidState", "vim.fault.InvalidPowerState", "vim.fault.TaskInProgress", "vim.fault.FileFault", "vim.fault.SnapshotFault", ]), ("promoteDisks", "PromoteDisks_Task", "vim.version.version5", (("unlink", "boolean", "vim.version.version5", 0, None),("disks", "vim.vm.device.VirtualDisk[]", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.Task", "void"), "VirtualMachine.Provisioning.PromoteDisks", ["vim.fault.InvalidState", "vim.fault.InvalidPowerState", "vim.fault.TaskInProgress", ]), ("createScreenshot", "CreateScreenshot_Task", "vim.version.version5", (), (0, "vim.Task", "string"), "VirtualMachine.Interact.CreateScreenshot", ["vim.fault.TaskInProgress", "vim.fault.FileFault", "vim.fault.InvalidState", ]), ("queryChangedDiskAreas", "QueryChangedDiskAreas", "vim.version.version5", (("snapshot", "vim.vm.Snapshot", "vim.version.version5", F_OPTIONAL, None),("deviceKey", "int", "vim.version.version5", 0, None),("startOffset", "long", "vim.version.version5", 0, None),("changeId", "string", "vim.version.version5", 0, None),), (0, "vim.VirtualMachine.DiskChangeInfo", "vim.VirtualMachine.DiskChangeInfo"), "VirtualMachine.Provisioning.DiskRandomRead", ["vim.fault.FileFault", "vim.fault.NotFound", ]), ("queryUnownedFiles", "QueryUnownedFiles", "vim.version.version5", (), (F_OPTIONAL, "string[]", "string[]"), "VirtualMachine.Config.QueryUnownedFiles", None), ("reloadFromPath", "reloadVirtualMachineFromPath_Task", "vim.version.version6", (("configurationPath", "string", "vim.version.version6", 0, None),), (0, "vim.Task", "void"), "VirtualMachine.Config.ReloadFromPath", ["vim.fault.InvalidPowerState", "vim.fault.TaskInProgress", "vim.fault.FileFault", "vim.fault.InvalidState", "vim.fault.VmConfigFault", "vim.fault.AlreadyExists", ]), ("queryFaultToleranceCompatibility", "QueryFaultToleranceCompatibility", "vim.version.version6", (), (F_OPTIONAL, "vmodl.MethodFault[]", "vmodl.MethodFault[]"), "VirtualMachine.Config.QueryFTCompatibility", ["vim.fault.InvalidState", "vim.fault.VmConfigFault", ]), ("terminate", "TerminateVM", "vim.version.version7", (), (0, "void", "void"), "VirtualMachine.Interact.PowerOff", ["vim.fault.InvalidState", "vim.fault.TaskInProgress", ])]) +CreateDataType("vim.VirtualMachine.StorageRequirement", "StorageRequirement", "vmodl.DynamicData", "vim.version.version7", [("datastore", "vim.Datastore", "vim.version.version7", 0), ("freeSpaceRequiredInKb", "long", "vim.version.version7", 0)]) +CreateEnumType("vim.VirtualMachine.PowerState", "VirtualMachinePowerState", "vim.version.version1", ["poweredOff", "poweredOn", "suspended"]) +CreateEnumType("vim.VirtualMachine.AppHeartbeatStatusType", "VirtualMachineAppHeartbeatStatusType", "vim.version.version6", ["appStatusGray", "appStatusGreen", "appStatusRed"]) +CreateEnumType("vim.VirtualMachine.ConnectionState", "VirtualMachineConnectionState", "vim.version.version1", ["connected", "disconnected", "orphaned", "inaccessible", "invalid"]) +CreateEnumType("vim.VirtualMachine.MovePriority", "VirtualMachineMovePriority", "vim.version.version1", ["lowPriority", "highPriority", "defaultPriority"]) +CreateDataType("vim.VirtualMachine.Ticket", "VirtualMachineTicket", "vmodl.DynamicData", "vim.version.version6", [("ticket", "string", "vim.version.version6", 0), ("cfgFile", "string", "vim.version.version6", 0), ("host", "string", "vim.version.version6", F_OPTIONAL), ("port", "int", "vim.version.version6", F_OPTIONAL), ("sslThumbprint", "string", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.VirtualMachine.MksTicket", "VirtualMachineMksTicket", "vmodl.DynamicData", "vim.version.version1", [("ticket", "string", "vim.version.version1", 0), ("cfgFile", "string", "vim.version.version1", 0), ("host", "string", "vim.version.version1", F_OPTIONAL), ("port", "int", "vim.version.version1", F_OPTIONAL), ("sslThumbprint", "string", "vim.version.version2", F_OPTIONAL)]) +CreateEnumType("vim.VirtualMachine.FaultToleranceState", "VirtualMachineFaultToleranceState", "vim.version.version5", ["notConfigured", "disabled", "enabled", "needSecondary", "starting", "running"]) +CreateEnumType("vim.VirtualMachine.RecordReplayState", "VirtualMachineRecordReplayState", "vim.version.version5", ["recording", "replaying", "inactive"]) +CreateEnumType("vim.VirtualMachine.NeedSecondaryReason", "VirtualMachineNeedSecondaryReason", "vim.version.version5", ["initializing", "divergence", "lostConnection", "partialHardwareFailure", "userAction", "checkpointError", "other"]) +CreateEnumType("vim.VirtualMachine.TicketType", "VirtualMachineTicketType", "vim.version.version6", ["mks", "device", "guestControl"]) +CreateDataType("vim.VirtualMachine.DisplayTopology", "VirtualMachineDisplayTopology", "vmodl.DynamicData", "vim.version.version4", [("x", "int", "vim.version.version4", 0), ("y", "int", "vim.version.version4", 0), ("width", "int", "vim.version.version4", 0), ("height", "int", "vim.version.version4", 0)]) +CreateDataType("vim.VirtualMachine.DiskChangeInfo", "DiskChangeInfo", "vmodl.DynamicData", "vim.version.version5", [("startOffset", "long", "vim.version.version5", 0), ("length", "long", "vim.version.version5", 0), ("changedArea", "vim.VirtualMachine.DiskChangeInfo.DiskChangeExtent[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.VirtualMachine.DiskChangeInfo.DiskChangeExtent", "DiskChangeExtent", "vmodl.DynamicData", "vim.version.version5", [("start", "long", "vim.version.version5", 0), ("length", "long", "vim.version.version5", 0)]) +CreateDataType("vim.VirtualMachine.WipeResult", "VirtualMachineWipeResult", "vmodl.DynamicData", "vim.version.version8", [("diskId", "int", "vim.version.version8", 0), ("shrinkableDiskSpace", "long", "vim.version.version8", 0)]) +CreateDataType("vim.alarm.AlarmTriggeringAction", "AlarmTriggeringAction", "vim.alarm.AlarmAction", "vim.version.version1", [("action", "vim.action.Action", "vim.version.version1", 0), ("transitionSpecs", "vim.alarm.AlarmTriggeringAction.TransitionSpec[]", "vim.version.version5", F_OPTIONAL), ("green2yellow", "boolean", "vim.version.version1", 0), ("yellow2red", "boolean", "vim.version.version1", 0), ("red2yellow", "boolean", "vim.version.version1", 0), ("yellow2green", "boolean", "vim.version.version1", 0)]) +CreateDataType("vim.alarm.AlarmTriggeringAction.TransitionSpec", "AlarmTriggeringActionTransitionSpec", "vmodl.DynamicData", "vim.version.version5", [("startState", "vim.ManagedEntity.Status", "vim.version.version5", 0), ("finalState", "vim.ManagedEntity.Status", "vim.version.version5", 0), ("repeats", "boolean", "vim.version.version5", 0)]) +CreateDataType("vim.alarm.EventAlarmExpression", "EventAlarmExpression", "vim.alarm.AlarmExpression", "vim.version.version2", [("comparisons", "vim.alarm.EventAlarmExpression.Comparison[]", "vim.version.version5", F_OPTIONAL), ("eventType", "vmodl.TypeName", "vim.version.version2", 0), ("eventTypeId", "string", "vim.version.version2", F_OPTIONAL), ("objectType", "vmodl.TypeName", "vim.version.version5", F_OPTIONAL), ("status", "vim.ManagedEntity.Status", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.alarm.EventAlarmExpression.ComparisonOperator", "EventAlarmExpressionComparisonOperator", "vim.version.version5", ["equals", "notEqualTo", "startsWith", "doesNotStartWith", "endsWith", "doesNotEndWith"]) +CreateDataType("vim.alarm.EventAlarmExpression.Comparison", "EventAlarmExpressionComparison", "vmodl.DynamicData", "vim.version.version5", [("attributeName", "string", "vim.version.version5", 0), ("operator", "string", "vim.version.version5", 0), ("value", "string", "vim.version.version5", 0)]) +CreateDataType("vim.alarm.AlarmInfo", "AlarmInfo", "vim.alarm.AlarmSpec", "vim.version.version1", [("key", "string", "vim.version.version1", 0), ("alarm", "vim.alarm.Alarm", "vim.version.version1", 0), ("entity", "vim.ManagedEntity", "vim.version.version1", 0), ("lastModifiedTime", "vmodl.DateTime", "vim.version.version1", 0), ("lastModifiedUser", "string", "vim.version.version1", 0), ("creationEventId", "int", "vim.version.version1", 0)]) +CreateManagedType("vim.alarm.AlarmManager", "AlarmManager", "vmodl.ManagedObject", "vim.version.version1", [("defaultExpression", "vim.alarm.AlarmExpression[]", "vim.version.version1", F_OPTIONAL, "System.View"), ("description", "vim.alarm.AlarmDescription", "vim.version.version1", 0, "System.View")], [("create", "CreateAlarm", "vim.version.version1", (("entity", "vim.ManagedEntity", "vim.version.version1", 0, "Alarm.Create"),("spec", "vim.alarm.AlarmSpec", "vim.version.version1", 0, None),), (0, "vim.alarm.Alarm", "vim.alarm.Alarm"), None, ["vim.fault.InvalidName", "vim.fault.DuplicateName", ]), ("getAlarm", "GetAlarm", "vim.version.version1", (("entity", "vim.ManagedEntity", "vim.version.version1", F_OPTIONAL, None),), (F_OPTIONAL, "vim.alarm.Alarm[]", "vim.alarm.Alarm[]"), "System.View", None), ("getAlarmActionsEnabled", "AreAlarmActionsEnabled", "vim.version.version5", (("entity", "vim.ManagedEntity", "vim.version.version5", 0, "System.Read"),), (0, "boolean", "boolean"), None, None), ("setAlarmActionsEnabled", "EnableAlarmActions", "vim.version.version5", (("entity", "vim.ManagedEntity", "vim.version.version5", 0, "Alarm.DisableActions"),("enabled", "boolean", "vim.version.version5", 0, None),), (0, "void", "void"), None, None), ("getAlarmState", "GetAlarmState", "vim.version.version1", (("entity", "vim.ManagedEntity", "vim.version.version1", 0, "System.Read"),), (F_OPTIONAL, "vim.alarm.AlarmState[]", "vim.alarm.AlarmState[]"), None, None), ("acknowledgeAlarm", "AcknowledgeAlarm", "vim.version.version5", (("alarm", "vim.alarm.Alarm", "vim.version.version5", 0, "Alarm.Acknowledge"),("entity", "vim.ManagedEntity", "vim.version.version5", 0, "System.Read"),), (0, "void", "void"), None, None)]) +CreateDataType("vim.alarm.AlarmState", "AlarmState", "vmodl.DynamicData", "vim.version.version1", [("key", "string", "vim.version.version1", 0), ("entity", "vim.ManagedEntity", "vim.version.version1", 0), ("alarm", "vim.alarm.Alarm", "vim.version.version1", 0), ("overallStatus", "vim.ManagedEntity.Status", "vim.version.version1", 0), ("time", "vmodl.DateTime", "vim.version.version1", 0), ("acknowledged", "boolean", "vim.version.version5", F_OPTIONAL), ("acknowledgedByUser", "string", "vim.version.version5", F_OPTIONAL), ("acknowledgedTime", "vmodl.DateTime", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.cluster.DasVmConfigSpec", "ClusterDasVmConfigSpec", "vim.option.ArrayUpdateSpec", "vim.version.version1", [("info", "vim.cluster.DasVmConfigInfo", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.cluster.DrsVmConfigSpec", "ClusterDrsVmConfigSpec", "vim.option.ArrayUpdateSpec", "vim.version.version1", [("info", "vim.cluster.DrsVmConfigInfo", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.cluster.DpmHostConfigSpec", "ClusterDpmHostConfigSpec", "vim.option.ArrayUpdateSpec", "vim.version.version2", [("info", "vim.cluster.DpmHostConfigInfo", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.cluster.GroupSpec", "ClusterGroupSpec", "vim.option.ArrayUpdateSpec", "vim.version.version6", [("info", "vim.cluster.GroupInfo", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.cluster.DasAamHostInfo", "ClusterDasAamHostInfo", "vim.cluster.DasHostInfo", "vim.version.version5", [("hostDasState", "vim.cluster.DasAamNodeState[]", "vim.version.version5", F_OPTIONAL), ("primaryHosts", "string[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.cluster.FailoverHostAdmissionControlInfo", "ClusterFailoverHostAdmissionControlInfo", "vim.cluster.DasAdmissionControlInfo", "vim.version.version5", [("hostStatus", "vim.cluster.FailoverHostAdmissionControlInfo.HostStatus[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.cluster.FailoverHostAdmissionControlInfo.HostStatus", "ClusterFailoverHostAdmissionControlInfoHostStatus", "vmodl.DynamicData", "vim.version.version5", [("host", "vim.HostSystem", "vim.version.version5", 0), ("status", "vim.ManagedEntity.Status", "vim.version.version5", 0)]) +CreateDataType("vim.cluster.RuleInfo", "ClusterRuleInfo", "vmodl.DynamicData", "vim.version.version1", [("key", "int", "vim.version.version1", F_OPTIONAL), ("status", "vim.ManagedEntity.Status", "vim.version.version1", F_OPTIONAL), ("enabled", "boolean", "vim.version.version1", F_OPTIONAL), ("name", "string", "vim.version.version1", F_OPTIONAL), ("mandatory", "boolean", "vim.version.version6", F_OPTIONAL), ("userCreated", "boolean", "vim.version.version6", F_OPTIONAL), ("inCompliance", "boolean", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.cluster.RuleSpec", "ClusterRuleSpec", "vim.option.ArrayUpdateSpec", "vim.version.version1", [("info", "vim.cluster.RuleInfo", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.cluster.VmHostRuleInfo", "ClusterVmHostRuleInfo", "vim.cluster.RuleInfo", "vim.version.version6", [("vmGroupName", "string", "vim.version.version6", F_OPTIONAL), ("affineHostGroupName", "string", "vim.version.version6", F_OPTIONAL), ("antiAffineHostGroupName", "string", "vim.version.version6", F_OPTIONAL)]) +CreateManagedType("vim.dvs.DistributedVirtualPortgroup", "DistributedVirtualPortgroup", "vim.Network", "vim.version.version5", [("key", "string", "vim.version.version5", 0, None), ("config", "vim.dvs.DistributedVirtualPortgroup.ConfigInfo", "vim.version.version5", 0, None), ("portKeys", "string[]", "vim.version.version5", F_OPTIONAL, None)], [("reconfigure", "ReconfigureDVPortgroup_Task", "vim.version.version5", (("spec", "vim.dvs.DistributedVirtualPortgroup.ConfigSpec", "vim.version.version5", 0, None),), (0, "vim.Task", "void"), None, ["vim.fault.DvsFault", "vim.fault.ConcurrentAccess", "vim.fault.DuplicateName", "vim.fault.InvalidName", ]), ("rollback", "DVPortgroupRollback_Task", "vim.version.version8", (("entityBackup", "vim.dvs.EntityBackup.Config", "vim.version.version8", F_OPTIONAL, None),), (F_OPTIONAL, "vim.Task", "vim.dvs.DistributedVirtualPortgroup.ConfigSpec"), None, ["vim.fault.DvsFault", "vim.fault.RollbackFailure", ])]) +CreateEnumType("vim.dvs.DistributedVirtualPortgroup.PortgroupType", "DistributedVirtualPortgroupPortgroupType", "vim.version.version5", ["earlyBinding", "lateBinding", "ephemeral"]) +CreateDataType("vim.dvs.DistributedVirtualPortgroup.PortgroupPolicy", "DVPortgroupPolicy", "vmodl.DynamicData", "vim.version.version5", [("blockOverrideAllowed", "boolean", "vim.version.version5", 0), ("shapingOverrideAllowed", "boolean", "vim.version.version5", 0), ("vendorConfigOverrideAllowed", "boolean", "vim.version.version5", 0), ("livePortMovingAllowed", "boolean", "vim.version.version5", 0), ("portConfigResetAtDisconnect", "boolean", "vim.version.version5", 0), ("networkResourcePoolOverrideAllowed", "boolean", "vim.version.version7", F_OPTIONAL), ("trafficFilterOverrideAllowed", "boolean", "vim.version.version9", F_OPTIONAL)]) +CreateEnumType("vim.dvs.DistributedVirtualPortgroup.MetaTagName", "DistributedVirtualPortgroupMetaTagName", "vim.version.version5", ["dvsName", "portgroupName", "portIndex"]) +CreateDataType("vim.dvs.DistributedVirtualPortgroup.ConfigSpec", "DVPortgroupConfigSpec", "vmodl.DynamicData", "vim.version.version5", [("configVersion", "string", "vim.version.version5", F_OPTIONAL), ("name", "string", "vim.version.version5", F_OPTIONAL), ("numPorts", "int", "vim.version.version5", F_OPTIONAL), ("portNameFormat", "string", "vim.version.version5", F_OPTIONAL), ("defaultPortConfig", "vim.dvs.DistributedVirtualPort.Setting", "vim.version.version5", F_OPTIONAL), ("description", "string", "vim.version.version5", F_OPTIONAL), ("type", "string", "vim.version.version5", F_OPTIONAL), ("scope", "vim.ManagedEntity[]", "vim.version.version5", F_OPTIONAL), ("policy", "vim.dvs.DistributedVirtualPortgroup.PortgroupPolicy", "vim.version.version5", F_OPTIONAL), ("vendorSpecificConfig", "vim.dvs.KeyedOpaqueBlob[]", "vim.version.version5", F_OPTIONAL), ("autoExpand", "boolean", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.dvs.DistributedVirtualPortgroup.ConfigInfo", "DVPortgroupConfigInfo", "vmodl.DynamicData", "vim.version.version5", [("key", "string", "vim.version.version5", 0), ("name", "string", "vim.version.version5", 0), ("numPorts", "int", "vim.version.version5", 0), ("distributedVirtualSwitch", "vim.DistributedVirtualSwitch", "vim.version.version5", F_OPTIONAL), ("defaultPortConfig", "vim.dvs.DistributedVirtualPort.Setting", "vim.version.version5", F_OPTIONAL), ("description", "string", "vim.version.version5", F_OPTIONAL), ("type", "string", "vim.version.version5", 0), ("policy", "vim.dvs.DistributedVirtualPortgroup.PortgroupPolicy", "vim.version.version5", 0), ("portNameFormat", "string", "vim.version.version5", F_OPTIONAL), ("scope", "vim.ManagedEntity[]", "vim.version.version5", F_OPTIONAL), ("vendorSpecificConfig", "vim.dvs.KeyedOpaqueBlob[]", "vim.version.version5", F_OPTIONAL), ("configVersion", "string", "vim.version.version5", F_OPTIONAL), ("autoExpand", "boolean", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.event.AccountCreatedEvent", "AccountCreatedEvent", "vim.event.HostEvent", "vim.version.version1", [("spec", "vim.host.LocalAccountManager.AccountSpecification", "vim.version.version1", 0), ("group", "boolean", "vim.version.version1", 0)]) +CreateDataType("vim.event.AccountUpdatedEvent", "AccountUpdatedEvent", "vim.event.HostEvent", "vim.version.version1", [("spec", "vim.host.LocalAccountManager.AccountSpecification", "vim.version.version1", 0), ("group", "boolean", "vim.version.version1", 0)]) +CreateDataType("vim.event.ClusterComplianceCheckedEvent", "ClusterComplianceCheckedEvent", "vim.event.ClusterEvent", "vim.version.version5", [("profile", "vim.event.ProfileEventArgument", "vim.version.version5", 0)]) +CreateDataType("vim.event.VmFaultToleranceStateChangedEvent", "VmFaultToleranceStateChangedEvent", "vim.event.VmEvent", "vim.version.version5", [("oldState", "vim.VirtualMachine.FaultToleranceState", "vim.version.version5", 0), ("newState", "vim.VirtualMachine.FaultToleranceState", "vim.version.version5", 0)]) +CreateDataType("vim.event.HostEnableAdminFailedEvent", "HostEnableAdminFailedEvent", "vim.event.HostEvent", "vim.version.version2", [("permissions", "vim.AuthorizationManager.Permission[]", "vim.version.version2", 0)]) +CreateDataType("vim.event.DVPortgroupReconfiguredEvent", "DVPortgroupReconfiguredEvent", "vim.event.DVPortgroupEvent", "vim.version.version5", [("configSpec", "vim.dvs.DistributedVirtualPortgroup.ConfigSpec", "vim.version.version5", 0)]) +CreateDataType("vim.fault.ActiveDirectoryFault", "ActiveDirectoryFault", "vim.fault.VimFault", "vim.version.version6", [("errorCode", "int", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.fault.AlreadyExists", "AlreadyExists", "vim.fault.VimFault", "vim.version.version1", [("name", "string", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.fault.AlreadyUpgraded", "AlreadyUpgraded", "vim.fault.VimFault", "vim.version.version1", None) +CreateDataType("vim.fault.AnswerFileUpdateFailed", "AnswerFileUpdateFailed", "vim.fault.VimFault", "vim.version.version7", [("failure", "vim.fault.AnswerFileUpdateFailed.UpdateFailure[]", "vim.version.version7", 0)]) +CreateDataType("vim.fault.AnswerFileUpdateFailed.UpdateFailure", "AnswerFileUpdateFailure", "vmodl.DynamicData", "vim.version.version7", [("userInputPath", "vim.profile.ProfilePropertyPath", "vim.version.version7", 0), ("errMsg", "vmodl.LocalizableMessage", "vim.version.version7", 0)]) +CreateDataType("vim.fault.AuthMinimumAdminPermission", "AuthMinimumAdminPermission", "vim.fault.VimFault", "vim.version.version1", None) +CreateDataType("vim.fault.CannotAccessLocalSource", "CannotAccessLocalSource", "vim.fault.VimFault", "vim.version.version1", None) +CreateDataType("vim.fault.CannotAccessVmComponent", "CannotAccessVmComponent", "vim.fault.VmConfigFault", "vim.version.version1", None) +CreateDataType("vim.fault.CannotAccessVmConfig", "CannotAccessVmConfig", "vim.fault.CannotAccessVmComponent", "vim.version.version1", [("reason", "vmodl.MethodFault", "vim.version.version1", 0)]) +CreateDataType("vim.fault.CannotAccessVmDevice", "CannotAccessVmDevice", "vim.fault.CannotAccessVmComponent", "vim.version.version1", [("device", "string", "vim.version.version1", 0), ("backing", "string", "vim.version.version1", 0), ("connected", "boolean", "vim.version.version1", 0)]) +CreateDataType("vim.fault.CannotAccessVmDisk", "CannotAccessVmDisk", "vim.fault.CannotAccessVmDevice", "vim.version.version1", [("fault", "vmodl.MethodFault", "vim.version.version1", 0)]) +CreateDataType("vim.fault.CannotChangeDrsBehaviorForFtSecondary", "CannotChangeDrsBehaviorForFtSecondary", "vim.fault.VmFaultToleranceIssue", "vim.version.version6", [("vm", "vim.VirtualMachine", "vim.version.version6", 0), ("vmName", "string", "vim.version.version6", 0)]) +CreateDataType("vim.fault.CannotChangeHaSettingsForFtSecondary", "CannotChangeHaSettingsForFtSecondary", "vim.fault.VmFaultToleranceIssue", "vim.version.version6", [("vm", "vim.VirtualMachine", "vim.version.version6", 0), ("vmName", "string", "vim.version.version6", 0)]) +CreateDataType("vim.fault.CannotChangeVsanClusterUuid", "CannotChangeVsanClusterUuid", "vim.fault.VsanFault", "vim.version.version9", None) +CreateDataType("vim.fault.CannotChangeVsanNodeUuid", "CannotChangeVsanNodeUuid", "vim.fault.VsanFault", "vim.version.version9", None) +CreateDataType("vim.fault.CannotDisableSnapshot", "CannotDisableSnapshot", "vim.fault.VmConfigFault", "vim.version.version2", None) +CreateDataType("vim.fault.CannotDisconnectHostWithFaultToleranceVm", "CannotDisconnectHostWithFaultToleranceVm", "vim.fault.VimFault", "vim.version.version5", [("hostName", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.CannotMoveFaultToleranceVm", "CannotMoveFaultToleranceVm", "vim.fault.VimFault", "vim.version.version5", [("moveType", "string", "vim.version.version5", 0), ("vmName", "string", "vim.version.version5", 0)]) +CreateEnumType("vim.fault.CannotMoveFaultToleranceVm.MoveType", "CannotMoveFaultToleranceVmMoveType", "vim.version.version5", ["resourcePool", "cluster"]) +CreateDataType("vim.fault.CannotMoveHostWithFaultToleranceVm", "CannotMoveHostWithFaultToleranceVm", "vim.fault.VimFault", "vim.version.version5", None) +CreateDataType("vim.fault.CannotMoveVsanEnabledHost", "CannotMoveVsanEnabledHost", "vim.fault.VsanFault", "vim.version.version9", None) +CreateDataType("vim.fault.CannotPlaceWithoutPrerequisiteMoves", "CannotPlaceWithoutPrerequisiteMoves", "vim.fault.VimFault", "vim.version.version8", None) +CreateDataType("vim.fault.CannotReconfigureVsanWhenHaEnabled", "CannotReconfigureVsanWhenHaEnabled", "vim.fault.VsanFault", "vim.version.version9", None) +CreateDataType("vim.fault.CannotUseNetwork", "CannotUseNetwork", "vim.fault.VmConfigFault", "vim.version.version9", [("device", "string", "vim.version.version9", 0), ("backing", "string", "vim.version.version9", 0), ("connected", "boolean", "vim.version.version9", 0), ("reason", "string", "vim.version.version9", 0)]) +CreateEnumType("vim.fault.CannotUseNetwork.Reason", "CannotUseNetworkReason", "vim.version.version9", ["NetworkReservationNotSupported", "MismatchedNetworkPolicies", "MismatchedDvsVersionOrVendor", "VMotionToUnsupportedNetworkType"]) +CreateDataType("vim.fault.ConcurrentAccess", "ConcurrentAccess", "vim.fault.VimFault", "vim.version.version1", None) +CreateDataType("vim.fault.CpuHotPlugNotSupported", "CpuHotPlugNotSupported", "vim.fault.VmConfigFault", "vim.version.version5", None) +CreateDataType("vim.fault.CustomizationFault", "CustomizationFault", "vim.fault.VimFault", "vim.version.version1", None) +CreateDataType("vim.fault.CustomizationPending", "CustomizationPending", "vim.fault.CustomizationFault", "vim.version.version2", None) +CreateDataType("vim.fault.DasConfigFault", "DasConfigFault", "vim.fault.VimFault", "vim.version.version1", [("reason", "string", "vim.version.version5", F_OPTIONAL), ("output", "string", "vim.version.version5", F_OPTIONAL), ("event", "vim.event.Event[]", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.fault.DasConfigFault.DasConfigFaultReason", "DasConfigFaultDasConfigFaultReason", "vim.version.version5", ["HostNetworkMisconfiguration", "HostMisconfiguration", "InsufficientPrivileges", "NoPrimaryAgentAvailable", "Other", "NoDatastoresConfigured", "CreateConfigVvolFailed", "VSanNotSupportedOnHost"]) +CreateDataType("vim.fault.DeltaDiskFormatNotSupported", "DeltaDiskFormatNotSupported", "vim.fault.VmConfigFault", "vim.version.version7", [("datastore", "vim.Datastore[]", "vim.version.version7", F_OPTIONAL), ("deltaDiskFormat", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.DestinationVsanDisabled", "DestinationVsanDisabled", "vim.fault.CannotMoveVsanEnabledHost", "vim.version.version9", [("destinationCluster", "string", "vim.version.version9", 0)]) +CreateDataType("vim.fault.DomainNotFound", "DomainNotFound", "vim.fault.ActiveDirectoryFault", "vim.version.version6", [("domainName", "string", "vim.version.version6", 0)]) +CreateDataType("vim.fault.DrsDisabledOnVm", "DrsDisabledOnVm", "vim.fault.VimFault", "vim.version.version5", None) +CreateDataType("vim.fault.DuplicateName", "DuplicateName", "vim.fault.VimFault", "vim.version.version1", [("name", "string", "vim.version.version1", 0), ("object", "vmodl.ManagedObject", "vim.version.version1", 0)]) +CreateDataType("vim.fault.DuplicateVsanNetworkInterface", "DuplicateVsanNetworkInterface", "vim.fault.VsanFault", "vim.version.version9", [("device", "string", "vim.version.version9", 0)]) +CreateDataType("vim.fault.DvsFault", "DvsFault", "vim.fault.VimFault", "vim.version.version5", None) +CreateDataType("vim.fault.DvsNotAuthorized", "DvsNotAuthorized", "vim.fault.DvsFault", "vim.version.version5", [("sessionExtensionKey", "string", "vim.version.version5", F_OPTIONAL), ("dvsExtensionKey", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.fault.DvsOperationBulkFault", "DvsOperationBulkFault", "vim.fault.DvsFault", "vim.version.version5", [("hostFault", "vim.fault.DvsOperationBulkFault.FaultOnHost[]", "vim.version.version5", 0)]) +CreateDataType("vim.fault.DvsOperationBulkFault.FaultOnHost", "DvsOperationBulkFaultFaultOnHost", "vmodl.DynamicData", "vim.version.version5", [("host", "vim.HostSystem", "vim.version.version5", 0), ("fault", "vmodl.MethodFault", "vim.version.version5", 0)]) +CreateDataType("vim.fault.DvsScopeViolated", "DvsScopeViolated", "vim.fault.DvsFault", "vim.version.version5", [("scope", "vim.ManagedEntity[]", "vim.version.version5", 0), ("entity", "vim.ManagedEntity", "vim.version.version5", 0)]) +CreateDataType("vim.fault.EightHostLimitViolated", "EightHostLimitViolated", "vim.fault.VmConfigFault", "vim.version.version5", None) +CreateDataType("vim.fault.ExpiredAddonLicense", "ExpiredAddonLicense", "vim.fault.ExpiredFeatureLicense", "vim.version.version2", None) +CreateDataType("vim.fault.ExpiredEditionLicense", "ExpiredEditionLicense", "vim.fault.ExpiredFeatureLicense", "vim.version.version2", None) +CreateDataType("vim.fault.ExtendedFault", "ExtendedFault", "vim.fault.VimFault", "vim.version.version2", [("faultTypeId", "string", "vim.version.version2", 0), ("data", "vim.KeyValue[]", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.fault.FaultToleranceCannotEditMem", "FaultToleranceCannotEditMem", "vim.fault.VmConfigFault", "vim.version.version6", [("vmName", "string", "vim.version.version6", 0), ("vm", "vim.VirtualMachine", "vim.version.version6", 0)]) +CreateDataType("vim.fault.FaultToleranceNotLicensed", "FaultToleranceNotLicensed", "vim.fault.VmFaultToleranceIssue", "vim.version.version5", [("hostName", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.fault.FaultTolerancePrimaryPowerOnNotAttempted", "FaultTolerancePrimaryPowerOnNotAttempted", "vim.fault.VmFaultToleranceIssue", "vim.version.version5", [("secondaryVm", "vim.VirtualMachine", "vim.version.version5", 0), ("primaryVm", "vim.VirtualMachine", "vim.version.version5", 0)]) +CreateDataType("vim.fault.FaultToleranceVmNotDasProtected", "FaultToleranceVmNotDasProtected", "vim.fault.VimFault", "vim.version.version7", [("vm", "vim.VirtualMachine", "vim.version.version7", 0), ("vmName", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.FcoeFault", "FcoeFault", "vim.fault.VimFault", "vim.version.version7", None) +CreateDataType("vim.fault.FcoeFaultPnicHasNoPortSet", "FcoeFaultPnicHasNoPortSet", "vim.fault.FcoeFault", "vim.version.version7", [("nicDevice", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.FileFault", "FileFault", "vim.fault.VimFault", "vim.version.version1", [("file", "string", "vim.version.version1", 0)]) +CreateDataType("vim.fault.FileLocked", "FileLocked", "vim.fault.FileFault", "vim.version.version1", None) +CreateDataType("vim.fault.FileNameTooLong", "FileNameTooLong", "vim.fault.FileFault", "vim.version.version7", None) +CreateDataType("vim.fault.FileNotFound", "FileNotFound", "vim.fault.FileFault", "vim.version.version1", None) +CreateDataType("vim.fault.FileNotWritable", "FileNotWritable", "vim.fault.FileFault", "vim.version.version1", None) +CreateDataType("vim.fault.FileTooLarge", "FileTooLarge", "vim.fault.FileFault", "vim.version.version2", [("datastore", "string", "vim.version.version2", 0), ("fileSize", "long", "vim.version.version2", 0), ("maxFileSize", "long", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.fault.FtIssuesOnHost", "FtIssuesOnHost", "vim.fault.VmFaultToleranceIssue", "vim.version.version5", [("host", "vim.HostSystem", "vim.version.version5", 0), ("hostName", "string", "vim.version.version5", 0), ("errors", "vmodl.MethodFault[]", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.fault.FtIssuesOnHost.HostSelectionType", "FtIssuesOnHostHostSelectionType", "vim.version.version5", ["user", "vc", "drs"]) +CreateDataType("vim.fault.GenericDrsFault", "GenericDrsFault", "vim.fault.VimFault", "vim.version.version2", [("hostFaults", "vmodl.MethodFault[]", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.fault.GenericVmConfigFault", "GenericVmConfigFault", "vim.fault.VmConfigFault", "vim.version.version1", [("reason", "string", "vim.version.version1", 0)]) +CreateDataType("vim.fault.GuestOperationsFault", "GuestOperationsFault", "vim.fault.VimFault", "vim.version.version7", None) +CreateDataType("vim.fault.GuestOperationsUnavailable", "GuestOperationsUnavailable", "vim.fault.GuestOperationsFault", "vim.version.version7", None) +CreateDataType("vim.fault.GuestPermissionDenied", "GuestPermissionDenied", "vim.fault.GuestOperationsFault", "vim.version.version7", None) +CreateDataType("vim.fault.GuestProcessNotFound", "GuestProcessNotFound", "vim.fault.GuestOperationsFault", "vim.version.version7", [("pid", "long", "vim.version.version7", 0)]) +CreateDataType("vim.fault.HostConfigFault", "HostConfigFault", "vim.fault.VimFault", "vim.version.version1", None) +CreateDataType("vim.fault.HostConnectFault", "HostConnectFault", "vim.fault.VimFault", "vim.version.version1", None) +CreateDataType("vim.fault.HostInDomain", "HostInDomain", "vim.fault.HostConfigFault", "vim.version.version6", None) +CreateDataType("vim.fault.HostIncompatibleForFaultTolerance", "HostIncompatibleForFaultTolerance", "vim.fault.VmFaultToleranceIssue", "vim.version.version5", [("hostName", "string", "vim.version.version5", F_OPTIONAL), ("reason", "string", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.fault.HostIncompatibleForFaultTolerance.Reason", "HostIncompatibleForFaultToleranceReason", "vim.version.version5", ["product", "processor"]) +CreateDataType("vim.fault.HostIncompatibleForRecordReplay", "HostIncompatibleForRecordReplay", "vim.fault.VimFault", "vim.version.version5", [("hostName", "string", "vim.version.version5", F_OPTIONAL), ("reason", "string", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.fault.HostIncompatibleForRecordReplay.Reason", "HostIncompatibleForRecordReplayReason", "vim.version.version5", ["product", "processor"]) +CreateDataType("vim.fault.HostPowerOpFailed", "HostPowerOpFailed", "vim.fault.VimFault", "vim.version.version2", None) +CreateDataType("vim.fault.IORMNotSupportedHostOnDatastore", "IORMNotSupportedHostOnDatastore", "vim.fault.VimFault", "vim.version.version6", [("datastore", "vim.Datastore", "vim.version.version6", 0), ("datastoreName", "string", "vim.version.version6", 0), ("host", "vim.HostSystem[]", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.fault.ImportHostAddFailure", "ImportHostAddFailure", "vim.fault.DvsFault", "vim.version.version8", [("hostIp", "string[]", "vim.version.version8", 0)]) +CreateDataType("vim.fault.ImportOperationBulkFault", "ImportOperationBulkFault", "vim.fault.DvsFault", "vim.version.version8", [("importFaults", "vim.fault.ImportOperationBulkFault.FaultOnImport[]", "vim.version.version8", 0)]) +CreateDataType("vim.fault.ImportOperationBulkFault.FaultOnImport", "ImportOperationBulkFaultFaultOnImport", "vmodl.DynamicData", "vim.version.version8", [("entityType", "string", "vim.version.version8", F_OPTIONAL), ("key", "string", "vim.version.version8", F_OPTIONAL), ("fault", "vmodl.MethodFault", "vim.version.version8", 0)]) +CreateDataType("vim.fault.InaccessibleVFlashSource", "InaccessibleVFlashSource", "vim.fault.VimFault", "vim.version.version9", [("hostName", "string", "vim.version.version9", 0)]) +CreateDataType("vim.fault.IncompatibleHostForFtSecondary", "IncompatibleHostForFtSecondary", "vim.fault.VmFaultToleranceIssue", "vim.version.version5", [("host", "vim.HostSystem", "vim.version.version5", 0), ("error", "vmodl.MethodFault[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.fault.IncorrectFileType", "IncorrectFileType", "vim.fault.FileFault", "vim.version.version1", None) +CreateDataType("vim.fault.InsufficientResourcesFault", "InsufficientResourcesFault", "vim.fault.VimFault", "vim.version.version1", None) +CreateDataType("vim.fault.InsufficientStandbyResource", "InsufficientStandbyResource", "vim.fault.InsufficientResourcesFault", "vim.version.version5", None) +CreateDataType("vim.fault.InsufficientStorageSpace", "InsufficientStorageSpace", "vim.fault.InsufficientResourcesFault", "vim.version.version7", None) +CreateDataType("vim.fault.InsufficientVFlashResourcesFault", "InsufficientVFlashResourcesFault", "vim.fault.InsufficientResourcesFault", "vim.version.version9", [("freeSpace", "long", "vim.version.version9", 0), ("requestedSpace", "long", "vim.version.version9", 0)]) +CreateDataType("vim.fault.InvalidAffinitySettingFault", "InvalidAffinitySettingFault", "vim.fault.VimFault", "vim.version.version2", None) +CreateDataType("vim.fault.InvalidBmcRole", "InvalidBmcRole", "vim.fault.VimFault", "vim.version.version5", None) +CreateDataType("vim.fault.InvalidCAMServer", "InvalidCAMServer", "vim.fault.ActiveDirectoryFault", "vim.version.version7", [("camServer", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.InvalidDatastore", "InvalidDatastore", "vim.fault.VimFault", "vim.version.version1", [("datastore", "vim.Datastore", "vim.version.version1", F_OPTIONAL), ("name", "string", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.fault.InvalidDatastorePath", "InvalidDatastorePath", "vim.fault.InvalidDatastore", "vim.version.version1", [("datastorePath", "string", "vim.version.version1", 0)]) +CreateDataType("vim.fault.InvalidEvent", "InvalidEvent", "vim.fault.VimFault", "vim.version.version2", None) +CreateDataType("vim.fault.InvalidFolder", "InvalidFolder", "vim.fault.VimFault", "vim.version.version1", [("target", "vim.ManagedEntity", "vim.version.version1", 0)]) +CreateDataType("vim.fault.InvalidFormat", "InvalidFormat", "vim.fault.VmConfigFault", "vim.version.version1", None) +CreateDataType("vim.fault.InvalidGuestLogin", "InvalidGuestLogin", "vim.fault.GuestOperationsFault", "vim.version.version7", None) +CreateDataType("vim.fault.InvalidHostName", "InvalidHostName", "vim.fault.HostConfigFault", "vim.version.version6", None) +CreateDataType("vim.fault.InvalidIpfixConfig", "InvalidIpfixConfig", "vim.fault.DvsFault", "vim.version.version8", [("property", "vmodl.PropertyPath", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.fault.InvalidIpmiLoginInfo", "InvalidIpmiLoginInfo", "vim.fault.VimFault", "vim.version.version5", None) +CreateDataType("vim.fault.InvalidIpmiMacAddress", "InvalidIpmiMacAddress", "vim.fault.VimFault", "vim.version.version5", [("userProvidedMacAddress", "string", "vim.version.version5", 0), ("observedMacAddress", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.InvalidLicense", "InvalidLicense", "vim.fault.VimFault", "vim.version.version1", [("licenseContent", "string", "vim.version.version1", 0)]) +CreateDataType("vim.fault.InvalidLocale", "InvalidLocale", "vim.fault.VimFault", "vim.version.version1", None) +CreateDataType("vim.fault.InvalidLogin", "InvalidLogin", "vim.fault.VimFault", "vim.version.version1", None) +CreateDataType("vim.fault.InvalidName", "InvalidName", "vim.fault.VimFault", "vim.version.version1", [("name", "string", "vim.version.version1", 0), ("entity", "vim.ManagedEntity", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.fault.InvalidOperationOnSecondaryVm", "InvalidOperationOnSecondaryVm", "vim.fault.VmFaultToleranceIssue", "vim.version.version5", [("instanceUuid", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.InvalidPrivilege", "InvalidPrivilege", "vim.fault.VimFault", "vim.version.version1", [("privilege", "string", "vim.version.version1", 0)]) +CreateDataType("vim.fault.InvalidResourcePoolStructureFault", "InvalidResourcePoolStructureFault", "vim.fault.InsufficientResourcesFault", "vim.version.version1", None) +CreateDataType("vim.fault.InvalidSnapshotFormat", "InvalidSnapshotFormat", "vim.fault.InvalidFormat", "vim.version.version1", None) +CreateDataType("vim.fault.InvalidState", "InvalidState", "vim.fault.VimFault", "vim.version.version1", None) +CreateDataType("vim.fault.InvalidVmConfig", "InvalidVmConfig", "vim.fault.VmConfigFault", "vim.version.version1", [("property", "vmodl.PropertyPath", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.fault.IpHostnameGeneratorError", "IpHostnameGeneratorError", "vim.fault.CustomizationFault", "vim.version.version1", None) +CreateDataType("vim.fault.IscsiFault", "IscsiFault", "vim.fault.VimFault", "vim.version.version7", None) +CreateDataType("vim.fault.IscsiFaultInvalidVnic", "IscsiFaultInvalidVnic", "vim.fault.IscsiFault", "vim.version.version7", [("vnicDevice", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.IscsiFaultPnicInUse", "IscsiFaultPnicInUse", "vim.fault.IscsiFault", "vim.version.version7", [("pnicDevice", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.IscsiFaultVnicAlreadyBound", "IscsiFaultVnicAlreadyBound", "vim.fault.IscsiFault", "vim.version.version7", [("vnicDevice", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.IscsiFaultVnicHasActivePaths", "IscsiFaultVnicHasActivePaths", "vim.fault.IscsiFault", "vim.version.version7", [("vnicDevice", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.IscsiFaultVnicHasMultipleUplinks", "IscsiFaultVnicHasMultipleUplinks", "vim.fault.IscsiFault", "vim.version.version7", [("vnicDevice", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.IscsiFaultVnicHasNoUplinks", "IscsiFaultVnicHasNoUplinks", "vim.fault.IscsiFault", "vim.version.version7", [("vnicDevice", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.IscsiFaultVnicHasWrongUplink", "IscsiFaultVnicHasWrongUplink", "vim.fault.IscsiFault", "vim.version.version7", [("vnicDevice", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.IscsiFaultVnicInUse", "IscsiFaultVnicInUse", "vim.fault.IscsiFault", "vim.version.version7", [("vnicDevice", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.IscsiFaultVnicIsLastPath", "IscsiFaultVnicIsLastPath", "vim.fault.IscsiFault", "vim.version.version7", [("vnicDevice", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.IscsiFaultVnicNotBound", "IscsiFaultVnicNotBound", "vim.fault.IscsiFault", "vim.version.version7", [("vnicDevice", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.IscsiFaultVnicNotFound", "IscsiFaultVnicNotFound", "vim.fault.IscsiFault", "vim.version.version7", [("vnicDevice", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.LargeRDMNotSupportedOnDatastore", "LargeRDMNotSupportedOnDatastore", "vim.fault.VmConfigFault", "vim.version.version7", [("device", "string", "vim.version.version7", 0), ("datastore", "vim.Datastore", "vim.version.version7", 0), ("datastoreName", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.LicenseEntityNotFound", "LicenseEntityNotFound", "vim.fault.VimFault", "vim.version.version5", [("entityId", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.LicenseServerUnavailable", "LicenseServerUnavailable", "vim.fault.VimFault", "vim.version.version1", [("licenseServer", "string", "vim.version.version1", 0)]) +CreateDataType("vim.fault.LimitExceeded", "LimitExceeded", "vim.fault.VimFault", "vim.version.version5", [("property", "vmodl.PropertyPath", "vim.version.version5", F_OPTIONAL), ("limit", "int", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.fault.LinuxVolumeNotClean", "LinuxVolumeNotClean", "vim.fault.CustomizationFault", "vim.version.version1", None) +CreateDataType("vim.fault.LogBundlingFailed", "LogBundlingFailed", "vim.fault.VimFault", "vim.version.version1", None) +CreateDataType("vim.fault.MemoryHotPlugNotSupported", "MemoryHotPlugNotSupported", "vim.fault.VmConfigFault", "vim.version.version5", None) +CreateDataType("vim.fault.MigrationFault", "MigrationFault", "vim.fault.VimFault", "vim.version.version1", None) +CreateDataType("vim.fault.MigrationFeatureNotSupported", "MigrationFeatureNotSupported", "vim.fault.MigrationFault", "vim.version.version2", [("atSourceHost", "boolean", "vim.version.version2", 0), ("failedHostName", "string", "vim.version.version2", 0), ("failedHost", "vim.HostSystem", "vim.version.version2", 0)]) +CreateDataType("vim.fault.MigrationNotReady", "MigrationNotReady", "vim.fault.MigrationFault", "vim.version.version5", [("reason", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.MismatchedBundle", "MismatchedBundle", "vim.fault.VimFault", "vim.version.version2", [("bundleUuid", "string", "vim.version.version2", 0), ("hostUuid", "string", "vim.version.version2", 0), ("bundleBuildNumber", "int", "vim.version.version2", 0), ("hostBuildNumber", "int", "vim.version.version2", 0)]) +CreateDataType("vim.fault.MismatchedNetworkPolicies", "MismatchedNetworkPolicies", "vim.fault.MigrationFault", "vim.version.version1", [("device", "string", "vim.version.version1", 0), ("backing", "string", "vim.version.version1", 0), ("connected", "boolean", "vim.version.version1", 0)]) +CreateDataType("vim.fault.MismatchedVMotionNetworkNames", "MismatchedVMotionNetworkNames", "vim.fault.MigrationFault", "vim.version.version1", [("sourceNetwork", "string", "vim.version.version1", 0), ("destNetwork", "string", "vim.version.version1", 0)]) +CreateDataType("vim.fault.MissingBmcSupport", "MissingBmcSupport", "vim.fault.VimFault", "vim.version.version5", None) +CreateDataType("vim.fault.MissingLinuxCustResources", "MissingLinuxCustResources", "vim.fault.CustomizationFault", "vim.version.version1", None) +CreateDataType("vim.fault.MissingWindowsCustResources", "MissingWindowsCustResources", "vim.fault.CustomizationFault", "vim.version.version1", None) +CreateDataType("vim.fault.MksConnectionLimitReached", "MksConnectionLimitReached", "vim.fault.InvalidState", "vim.version.version7", [("connectionLimit", "int", "vim.version.version7", 0)]) +CreateDataType("vim.fault.MountError", "MountError", "vim.fault.CustomizationFault", "vim.version.version1", [("vm", "vim.VirtualMachine", "vim.version.version1", 0), ("diskIndex", "int", "vim.version.version1", 0)]) +CreateDataType("vim.fault.MultipleCertificatesVerifyFault", "MultipleCertificatesVerifyFault", "vim.fault.HostConnectFault", "vim.version.version5", [("thumbprintData", "vim.fault.MultipleCertificatesVerifyFault.ThumbprintData[]", "vim.version.version5", 0)]) +CreateDataType("vim.fault.MultipleCertificatesVerifyFault.ThumbprintData", "MultipleCertificatesVerifyFaultThumbprintData", "vmodl.DynamicData", "vim.version.version5", [("port", "int", "vim.version.version5", 0), ("thumbprint", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.NamespaceFull", "NamespaceFull", "vim.fault.VimFault", "vim.version.version8", [("name", "string", "vim.version.version8", 0), ("currentMaxSize", "long", "vim.version.version8", 0), ("requiredSize", "long", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.fault.NamespaceLimitReached", "NamespaceLimitReached", "vim.fault.VimFault", "vim.version.version8", [("limit", "int", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.fault.NamespaceWriteProtected", "NamespaceWriteProtected", "vim.fault.VimFault", "vim.version.version8", [("name", "string", "vim.version.version8", 0)]) +CreateDataType("vim.fault.NasConfigFault", "NasConfigFault", "vim.fault.HostConfigFault", "vim.version.version4", [("name", "string", "vim.version.version4", 0)]) +CreateDataType("vim.fault.NasConnectionLimitReached", "NasConnectionLimitReached", "vim.fault.NasConfigFault", "vim.version.version4", [("remoteHost", "string", "vim.version.version4", 0), ("remotePath", "string", "vim.version.version4", 0)]) +CreateDataType("vim.fault.NasSessionCredentialConflict", "NasSessionCredentialConflict", "vim.fault.NasConfigFault", "vim.version.version4", [("remoteHost", "string", "vim.version.version4", 0), ("remotePath", "string", "vim.version.version4", 0), ("userName", "string", "vim.version.version4", 0)]) +CreateDataType("vim.fault.NasVolumeNotMounted", "NasVolumeNotMounted", "vim.fault.NasConfigFault", "vim.version.version4", [("remoteHost", "string", "vim.version.version4", 0), ("remotePath", "string", "vim.version.version4", 0)]) +CreateDataType("vim.fault.NetworkCopyFault", "NetworkCopyFault", "vim.fault.FileFault", "vim.version.version1", None) +CreateDataType("vim.fault.NetworkDisruptedAndConfigRolledBack", "NetworkDisruptedAndConfigRolledBack", "vim.fault.VimFault", "vim.version.version8", [("host", "string", "vim.version.version8", 0)]) +CreateDataType("vim.fault.NetworkInaccessible", "NetworkInaccessible", "vim.fault.NasConfigFault", "vim.version.version4", None) +CreateDataType("vim.fault.NetworksMayNotBeTheSame", "NetworksMayNotBeTheSame", "vim.fault.MigrationFault", "vim.version.version2", [("name", "string", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.fault.NicSettingMismatch", "NicSettingMismatch", "vim.fault.CustomizationFault", "vim.version.version2", [("numberOfNicsInSpec", "int", "vim.version.version2", 0), ("numberOfNicsInVM", "int", "vim.version.version2", 0)]) +CreateDataType("vim.fault.NoActiveHostInCluster", "NoActiveHostInCluster", "vim.fault.InvalidState", "vim.version.version1", [("computeResource", "vim.ComputeResource", "vim.version.version1", 0)]) +CreateDataType("vim.fault.NoClientCertificate", "NoClientCertificate", "vim.fault.VimFault", "vim.version.version2", None) +CreateDataType("vim.fault.NoCompatibleDatastore", "NoCompatibleDatastore", "vim.fault.VimFault", "vim.version.version7", None) +CreateDataType("vim.fault.NoCompatibleHardAffinityHost", "NoCompatibleHardAffinityHost", "vim.fault.VmConfigFault", "vim.version.version6", [("vmName", "string", "vim.version.version6", 0)]) +CreateDataType("vim.fault.NoCompatibleHost", "NoCompatibleHost", "vim.fault.VimFault", "vim.version.version5", [("host", "vim.HostSystem[]", "vim.version.version5", F_OPTIONAL), ("error", "vmodl.MethodFault[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.fault.NoCompatibleHostWithAccessToDevice", "NoCompatibleHostWithAccessToDevice", "vim.fault.NoCompatibleHost", "vim.version.version6", None) +CreateDataType("vim.fault.NoCompatibleSoftAffinityHost", "NoCompatibleSoftAffinityHost", "vim.fault.VmConfigFault", "vim.version.version6", [("vmName", "string", "vim.version.version6", 0)]) +CreateDataType("vim.fault.NoConnectedDatastore", "NoConnectedDatastore", "vim.fault.VimFault", "vim.version.version7", None) +CreateDataType("vim.fault.NoDiskFound", "NoDiskFound", "vim.fault.VimFault", "vim.version.version1", None) +CreateDataType("vim.fault.NoDiskSpace", "NoDiskSpace", "vim.fault.FileFault", "vim.version.version1", [("datastore", "string", "vim.version.version1", 0)]) +CreateDataType("vim.fault.NoDisksToCustomize", "NoDisksToCustomize", "vim.fault.CustomizationFault", "vim.version.version1", None) +CreateDataType("vim.fault.NoGateway", "NoGateway", "vim.fault.HostConfigFault", "vim.version.version1", None) +CreateDataType("vim.fault.NoGuestHeartbeat", "NoGuestHeartbeat", "vim.fault.MigrationFault", "vim.version.version1", None) +CreateDataType("vim.fault.NoHost", "NoHost", "vim.fault.HostConnectFault", "vim.version.version1", [("name", "string", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.fault.NoHostSuitableForFtSecondary", "NoHostSuitableForFtSecondary", "vim.fault.VmFaultToleranceIssue", "vim.version.version5", [("vm", "vim.VirtualMachine", "vim.version.version5", 0), ("vmName", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.NoPeerHostFound", "NoPeerHostFound", "vim.fault.HostPowerOpFailed", "vim.version.version2", None) +CreateDataType("vim.fault.NoPermissionOnAD", "NoPermissionOnAD", "vim.fault.ActiveDirectoryFault", "vim.version.version6", None) +CreateDataType("vim.fault.NoPermissionOnHost", "NoPermissionOnHost", "vim.fault.HostConnectFault", "vim.version.version1", None) +CreateDataType("vim.fault.NoPermissionOnNasVolume", "NoPermissionOnNasVolume", "vim.fault.NasConfigFault", "vim.version.version4", [("userName", "string", "vim.version.version4", F_OPTIONAL)]) +CreateDataType("vim.fault.NoSubjectName", "NoSubjectName", "vim.fault.VimFault", "vim.version.version2", None) +CreateDataType("vim.fault.NoVirtualNic", "NoVirtualNic", "vim.fault.HostConfigFault", "vim.version.version1", None) +CreateDataType("vim.fault.NonADUserRequired", "NonADUserRequired", "vim.fault.ActiveDirectoryFault", "vim.version.version6", None) +CreateDataType("vim.fault.NonHomeRDMVMotionNotSupported", "NonHomeRDMVMotionNotSupported", "vim.fault.MigrationFeatureNotSupported", "vim.version.version2", [("device", "string", "vim.version.version2", 0)]) +CreateDataType("vim.fault.NotADirectory", "NotADirectory", "vim.fault.FileFault", "vim.version.version7", None) +CreateDataType("vim.fault.NotAFile", "NotAFile", "vim.fault.FileFault", "vim.version.version7", None) +CreateDataType("vim.fault.NotFound", "NotFound", "vim.fault.VimFault", "vim.version.version1", None) +CreateDataType("vim.fault.NotSupportedDeviceForFT", "NotSupportedDeviceForFT", "vim.fault.VmFaultToleranceIssue", "vim.version.version6", [("host", "vim.HostSystem", "vim.version.version6", 0), ("hostName", "string", "vim.version.version6", F_OPTIONAL), ("vm", "vim.VirtualMachine", "vim.version.version6", 0), ("vmName", "string", "vim.version.version6", F_OPTIONAL), ("deviceType", "string", "vim.version.version6", 0), ("deviceLabel", "string", "vim.version.version6", F_OPTIONAL)]) +CreateEnumType("vim.fault.NotSupportedDeviceForFT.DeviceType", "NotSupportedDeviceForFTDeviceType", "vim.version.version6", ["virtualVmxnet3", "paraVirtualSCSIController"]) +CreateDataType("vim.fault.NotSupportedHost", "NotSupportedHost", "vim.fault.HostConnectFault", "vim.version.version1", [("productName", "string", "vim.version.version1", F_OPTIONAL), ("productVersion", "string", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.fault.NotSupportedHostForVFlash", "NotSupportedHostForVFlash", "vim.fault.NotSupportedHost", "vim.version.version9", [("hostName", "string", "vim.version.version9", 0)]) +CreateDataType("vim.fault.NotSupportedHostForVsan", "NotSupportedHostForVsan", "vim.fault.NotSupportedHost", "vim.version.version9", [("hostName", "string", "vim.version.version9", 0)]) +CreateDataType("vim.fault.NotSupportedHostInCluster", "NotSupportedHostInCluster", "vim.fault.NotSupportedHost", "vim.version.version5", None) +CreateDataType("vim.fault.NotSupportedHostInDvs", "NotSupportedHostInDvs", "vim.fault.NotSupportedHost", "vim.version.version6", [("switchProductSpec", "vim.dvs.ProductSpec", "vim.version.version6", 0)]) +CreateDataType("vim.fault.NotSupportedHostInHACluster", "NotSupportedHostInHACluster", "vim.fault.NotSupportedHost", "vim.version.version7", [("hostName", "string", "vim.version.version7", 0), ("build", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.NumVirtualCpusExceedsLimit", "NumVirtualCpusExceedsLimit", "vim.fault.InsufficientResourcesFault", "vim.version.version6", [("maxSupportedVcpus", "int", "vim.version.version6", 0)]) +CreateDataType("vim.fault.NumVirtualCpusIncompatible", "NumVirtualCpusIncompatible", "vim.fault.VmConfigFault", "vim.version.version5", [("reason", "string", "vim.version.version5", 0), ("numCpu", "int", "vim.version.version5", 0)]) +CreateEnumType("vim.fault.NumVirtualCpusIncompatible.Reason", "NumVirtualCpusIncompatibleReason", "vim.version.version5", ["recordReplay", "faultTolerance"]) +CreateDataType("vim.fault.OperationDisabledByGuest", "OperationDisabledByGuest", "vim.fault.GuestOperationsFault", "vim.version.version7", None) +CreateDataType("vim.fault.OperationNotSupportedByGuest", "OperationNotSupportedByGuest", "vim.fault.GuestOperationsFault", "vim.version.version7", None) +CreateDataType("vim.fault.OutOfBounds", "OutOfBounds", "vim.fault.VimFault", "vim.version.version1", [("argumentName", "vmodl.PropertyPath", "vim.version.version1", 0)]) +CreateDataType("vim.fault.OvfConsumerPowerOnFault", "OvfConsumerPowerOnFault", "vim.fault.InvalidState", "vim.version.version7", [("extensionKey", "string", "vim.version.version7", 0), ("extensionName", "string", "vim.version.version7", 0), ("description", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.OvfConsumerValidationFault", "OvfConsumerValidationFault", "vim.fault.VmConfigFault", "vim.version.version7", [("extensionKey", "string", "vim.version.version7", 0), ("extensionName", "string", "vim.version.version7", 0), ("message", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.OvfFault", "OvfFault", "vim.fault.VimFault", "vim.version.version5", None) +CreateDataType("vim.fault.OvfImport", "OvfImport", "vim.fault.OvfFault", "vim.version.version5", None) +CreateDataType("vim.fault.OvfImportFailed", "OvfImportFailed", "vim.fault.OvfImport", "vim.version.version6", None) +CreateDataType("vim.fault.OvfInvalidPackage", "OvfInvalidPackage", "vim.fault.OvfFault", "vim.version.version5", [("lineNumber", "int", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfMappedOsId", "OvfMappedOsId", "vim.fault.OvfImport", "vim.version.version5", [("ovfId", "int", "vim.version.version5", 0), ("ovfDescription", "string", "vim.version.version5", 0), ("targetDescription", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfMissingHardware", "OvfMissingHardware", "vim.fault.OvfImport", "vim.version.version5", [("name", "string", "vim.version.version5", 0), ("resourceType", "int", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfNetworkMappingNotSupported", "OvfNetworkMappingNotSupported", "vim.fault.OvfImport", "vim.version.version8", None) +CreateDataType("vim.fault.OvfProperty", "OvfProperty", "vim.fault.OvfInvalidPackage", "vim.version.version5", [("type", "string", "vim.version.version5", 0), ("value", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfPropertyNetwork", "OvfPropertyNetwork", "vim.fault.OvfProperty", "vim.version.version5", None) +CreateDataType("vim.fault.OvfPropertyQualifier", "OvfPropertyQualifier", "vim.fault.OvfProperty", "vim.version.version5", [("qualifier", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfPropertyQualifierDuplicate", "OvfPropertyQualifierDuplicate", "vim.fault.OvfProperty", "vim.version.version5", [("qualifier", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfPropertyQualifierIgnored", "OvfPropertyQualifierIgnored", "vim.fault.OvfProperty", "vim.version.version5", [("qualifier", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfPropertyType", "OvfPropertyType", "vim.fault.OvfProperty", "vim.version.version5", None) +CreateDataType("vim.fault.OvfPropertyValue", "OvfPropertyValue", "vim.fault.OvfProperty", "vim.version.version5", None) +CreateDataType("vim.fault.OvfSystemFault", "OvfSystemFault", "vim.fault.OvfFault", "vim.version.version5", None) +CreateDataType("vim.fault.OvfToXmlUnsupportedElement", "OvfToXmlUnsupportedElement", "vim.fault.OvfSystemFault", "vim.version.version5", [("name", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.fault.OvfUnknownDevice", "OvfUnknownDevice", "vim.fault.OvfSystemFault", "vim.version.version5", [("device", "vim.vm.device.VirtualDevice", "vim.version.version5", F_OPTIONAL), ("vmName", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfUnknownEntity", "OvfUnknownEntity", "vim.fault.OvfSystemFault", "vim.version.version5", [("lineNumber", "int", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfUnsupportedDeviceBackingInfo", "OvfUnsupportedDeviceBackingInfo", "vim.fault.OvfSystemFault", "vim.version.version5", [("elementName", "string", "vim.version.version5", F_OPTIONAL), ("instanceId", "string", "vim.version.version5", F_OPTIONAL), ("deviceName", "string", "vim.version.version5", 0), ("backingName", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.fault.OvfUnsupportedDeviceBackingOption", "OvfUnsupportedDeviceBackingOption", "vim.fault.OvfSystemFault", "vim.version.version5", [("elementName", "string", "vim.version.version5", F_OPTIONAL), ("instanceId", "string", "vim.version.version5", F_OPTIONAL), ("deviceName", "string", "vim.version.version5", 0), ("backingName", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.fault.OvfUnsupportedDiskProvisioning", "OvfUnsupportedDiskProvisioning", "vim.fault.OvfImport", "vim.version.version6", [("diskProvisioning", "string", "vim.version.version6", 0), ("supportedDiskProvisioning", "string", "vim.version.version6", 0)]) +CreateDataType("vim.fault.OvfUnsupportedPackage", "OvfUnsupportedPackage", "vim.fault.OvfFault", "vim.version.version5", [("lineNumber", "int", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.fault.OvfUnsupportedSubType", "OvfUnsupportedSubType", "vim.fault.OvfUnsupportedPackage", "vim.version.version5", [("elementName", "string", "vim.version.version5", 0), ("instanceId", "string", "vim.version.version5", 0), ("deviceType", "int", "vim.version.version5", 0), ("deviceSubType", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfUnsupportedType", "OvfUnsupportedType", "vim.fault.OvfUnsupportedPackage", "vim.version.version5", [("name", "string", "vim.version.version5", 0), ("instanceId", "string", "vim.version.version5", 0), ("deviceType", "int", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfWrongNamespace", "OvfWrongNamespace", "vim.fault.OvfInvalidPackage", "vim.version.version5", [("namespaceName", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfXmlFormat", "OvfXmlFormat", "vim.fault.OvfInvalidPackage", "vim.version.version5", [("description", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.PatchBinariesNotFound", "PatchBinariesNotFound", "vim.fault.VimFault", "vim.version.version1", [("patchID", "string", "vim.version.version1", 0), ("binary", "string[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.fault.PatchMetadataInvalid", "PatchMetadataInvalid", "vim.fault.VimFault", "vim.version.version1", [("patchID", "string", "vim.version.version1", 0), ("metaData", "string[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.fault.PatchMetadataNotFound", "PatchMetadataNotFound", "vim.fault.PatchMetadataInvalid", "vim.version.version1", None) +CreateDataType("vim.fault.PatchNotApplicable", "PatchNotApplicable", "vim.fault.VimFault", "vim.version.version1", [("patchID", "string", "vim.version.version1", 0)]) +CreateDataType("vim.fault.PatchSuperseded", "PatchSuperseded", "vim.fault.PatchNotApplicable", "vim.version.version1", [("supersede", "string[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.fault.PlatformConfigFault", "PlatformConfigFault", "vim.fault.HostConfigFault", "vim.version.version1", [("text", "string", "vim.version.version1", 0)]) +CreateDataType("vim.fault.PowerOnFtSecondaryFailed", "PowerOnFtSecondaryFailed", "vim.fault.VmFaultToleranceIssue", "vim.version.version5", [("vm", "vim.VirtualMachine", "vim.version.version5", 0), ("vmName", "string", "vim.version.version5", 0), ("hostSelectionBy", "vim.fault.FtIssuesOnHost.HostSelectionType", "vim.version.version5", 0), ("hostErrors", "vmodl.MethodFault[]", "vim.version.version5", F_OPTIONAL), ("rootCause", "vmodl.MethodFault", "vim.version.version5", 0)]) +CreateDataType("vim.fault.ProfileUpdateFailed", "ProfileUpdateFailed", "vim.fault.VimFault", "vim.version.version5", [("failure", "vim.fault.ProfileUpdateFailed.UpdateFailure[]", "vim.version.version5", 0)]) +CreateDataType("vim.fault.ProfileUpdateFailed.UpdateFailure", "ProfileUpdateFailedUpdateFailure", "vmodl.DynamicData", "vim.version.version5", [("profilePath", "vim.profile.ProfilePropertyPath", "vim.version.version5", 0), ("errMsg", "vmodl.LocalizableMessage", "vim.version.version5", 0)]) +CreateDataType("vim.fault.QuestionPending", "QuestionPending", "vim.fault.InvalidState", "vim.version.version6", [("text", "string", "vim.version.version6", 0)]) +CreateDataType("vim.fault.RDMConversionNotSupported", "RDMConversionNotSupported", "vim.fault.MigrationFault", "vim.version.version5", [("device", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.RDMNotPreserved", "RDMNotPreserved", "vim.fault.MigrationFault", "vim.version.version1", [("device", "string", "vim.version.version1", 0)]) +CreateDataType("vim.fault.RDMNotSupportedOnDatastore", "RDMNotSupportedOnDatastore", "vim.fault.VmConfigFault", "vim.version.version2", [("device", "string", "vim.version.version2", 0), ("datastore", "vim.Datastore", "vim.version.version2", 0), ("datastoreName", "string", "vim.version.version2", 0)]) +CreateDataType("vim.fault.RDMPointsToInaccessibleDisk", "RDMPointsToInaccessibleDisk", "vim.fault.CannotAccessVmDisk", "vim.version.version1", None) +CreateDataType("vim.fault.ReadHostResourcePoolTreeFailed", "ReadHostResourcePoolTreeFailed", "vim.fault.HostConnectFault", "vim.version.version7", None) +CreateDataType("vim.fault.ReadOnlyDisksWithLegacyDestination", "ReadOnlyDisksWithLegacyDestination", "vim.fault.MigrationFault", "vim.version.version1", [("roDiskCount", "int", "vim.version.version1", 0), ("timeoutDanger", "boolean", "vim.version.version1", 0)]) +CreateDataType("vim.fault.RebootRequired", "RebootRequired", "vim.fault.VimFault", "vim.version.version1", [("patch", "string", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.fault.RecordReplayDisabled", "RecordReplayDisabled", "vim.fault.VimFault", "vim.version.version5", None) +CreateDataType("vim.fault.RemoveFailed", "RemoveFailed", "vim.fault.VimFault", "vim.version.version1", None) +CreateDataType("vim.fault.ReplicationFault", "ReplicationFault", "vim.fault.VimFault", "vim.version.version7", None) +CreateDataType("vim.fault.ReplicationIncompatibleWithFT", "ReplicationIncompatibleWithFT", "vim.fault.ReplicationFault", "vim.version.version7", None) +CreateDataType("vim.fault.ReplicationInvalidOptions", "ReplicationInvalidOptions", "vim.fault.ReplicationFault", "vim.version.version7", [("options", "string", "vim.version.version7", 0), ("entity", "vim.ManagedEntity", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.fault.ReplicationNotSupportedOnHost", "ReplicationNotSupportedOnHost", "vim.fault.ReplicationFault", "vim.version.version7", None) +CreateDataType("vim.fault.ReplicationVmFault", "ReplicationVmFault", "vim.fault.ReplicationFault", "vim.version.version7", [("reason", "string", "vim.version.version7", 0), ("state", "string", "vim.version.version7", F_OPTIONAL), ("instanceId", "string", "vim.version.version7", F_OPTIONAL), ("vm", "vim.VirtualMachine", "vim.version.version7", 0)]) +CreateEnumType("vim.fault.ReplicationVmFault.ReasonForFault", "ReplicationVmFaultReasonForFault", "vim.version.version7", ["notConfigured", "poweredOff", "suspended", "poweredOn", "offlineReplicating", "invalidState", "invalidInstanceId"]) +CreateDataType("vim.fault.ResourceInUse", "ResourceInUse", "vim.fault.VimFault", "vim.version.version1", [("type", "vmodl.TypeName", "vim.version.version1", F_OPTIONAL), ("name", "string", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.fault.ResourceNotAvailable", "ResourceNotAvailable", "vim.fault.VimFault", "vim.version.version5", [("containerType", "vmodl.TypeName", "vim.version.version5", F_OPTIONAL), ("containerName", "string", "vim.version.version5", F_OPTIONAL), ("type", "vmodl.TypeName", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.fault.RollbackFailure", "RollbackFailure", "vim.fault.DvsFault", "vim.version.version8", [("entityName", "string", "vim.version.version8", 0), ("entityType", "string", "vim.version.version8", 0)]) +CreateDataType("vim.fault.RuleViolation", "RuleViolation", "vim.fault.VmConfigFault", "vim.version.version1", [("host", "vim.HostSystem", "vim.version.version2", F_OPTIONAL), ("rule", "vim.cluster.RuleInfo", "vim.version.version5", 0)]) +CreateDataType("vim.fault.SSLDisabledFault", "SSLDisabledFault", "vim.fault.HostConnectFault", "vim.version.version5", None) +CreateDataType("vim.fault.SSLVerifyFault", "SSLVerifyFault", "vim.fault.HostConnectFault", "vim.version.version2", [("selfSigned", "boolean", "vim.version.version2", 0), ("thumbprint", "string", "vim.version.version2", 0)]) +CreateDataType("vim.fault.SSPIChallenge", "SSPIChallenge", "vim.fault.VimFault", "vim.version.version2", [("base64Token", "string", "vim.version.version2", 0)]) +CreateDataType("vim.fault.SecondaryVmAlreadyDisabled", "SecondaryVmAlreadyDisabled", "vim.fault.VmFaultToleranceIssue", "vim.version.version5", [("instanceUuid", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.SecondaryVmAlreadyEnabled", "SecondaryVmAlreadyEnabled", "vim.fault.VmFaultToleranceIssue", "vim.version.version5", [("instanceUuid", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.SecondaryVmAlreadyRegistered", "SecondaryVmAlreadyRegistered", "vim.fault.VmFaultToleranceIssue", "vim.version.version5", [("instanceUuid", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.SecondaryVmNotRegistered", "SecondaryVmNotRegistered", "vim.fault.VmFaultToleranceIssue", "vim.version.version5", [("instanceUuid", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.ShrinkDiskFault", "ShrinkDiskFault", "vim.fault.VimFault", "vim.version.version8", [("diskId", "int", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.fault.SnapshotCopyNotSupported", "SnapshotCopyNotSupported", "vim.fault.MigrationFault", "vim.version.version1", None) +CreateDataType("vim.fault.SnapshotFault", "SnapshotFault", "vim.fault.VimFault", "vim.version.version1", None) +CreateDataType("vim.fault.SnapshotIncompatibleDeviceInVm", "SnapshotIncompatibleDeviceInVm", "vim.fault.SnapshotFault", "vim.version.version1", [("fault", "vmodl.MethodFault", "vim.version.version1", 0)]) +CreateDataType("vim.fault.SnapshotLocked", "SnapshotLocked", "vim.fault.SnapshotFault", "vim.version.version2", None) +CreateDataType("vim.fault.SnapshotMoveFromNonHomeNotSupported", "SnapshotMoveFromNonHomeNotSupported", "vim.fault.SnapshotCopyNotSupported", "vim.version.version2", None) +CreateDataType("vim.fault.SnapshotMoveNotSupported", "SnapshotMoveNotSupported", "vim.fault.SnapshotCopyNotSupported", "vim.version.version2", None) +CreateDataType("vim.fault.SnapshotMoveToNonHomeNotSupported", "SnapshotMoveToNonHomeNotSupported", "vim.fault.SnapshotCopyNotSupported", "vim.version.version2", None) +CreateDataType("vim.fault.SnapshotNoChange", "SnapshotNoChange", "vim.fault.SnapshotFault", "vim.version.version2", None) +CreateDataType("vim.fault.SnapshotRevertIssue", "SnapshotRevertIssue", "vim.fault.MigrationFault", "vim.version.version1", [("snapshotName", "string", "vim.version.version1", F_OPTIONAL), ("event", "vim.event.Event[]", "vim.version.version1", F_OPTIONAL), ("errors", "boolean", "vim.version.version1", 0)]) +CreateDataType("vim.fault.SoftRuleVioCorrectionDisallowed", "SoftRuleVioCorrectionDisallowed", "vim.fault.VmConfigFault", "vim.version.version6", [("vmName", "string", "vim.version.version6", 0)]) +CreateDataType("vim.fault.SoftRuleVioCorrectionImpact", "SoftRuleVioCorrectionImpact", "vim.fault.VmConfigFault", "vim.version.version6", [("vmName", "string", "vim.version.version6", 0)]) +CreateDataType("vim.fault.SsdDiskNotAvailable", "SsdDiskNotAvailable", "vim.fault.VimFault", "vim.version.version9", [("devicePath", "string", "vim.version.version9", 0)]) +CreateDataType("vim.fault.StorageDrsCannotMoveDiskInMultiWriterMode", "StorageDrsCannotMoveDiskInMultiWriterMode", "vim.fault.VimFault", "vim.version.version8", None) +CreateDataType("vim.fault.StorageDrsCannotMoveFTVm", "StorageDrsCannotMoveFTVm", "vim.fault.VimFault", "vim.version.version8", None) +CreateDataType("vim.fault.StorageDrsCannotMoveIndependentDisk", "StorageDrsCannotMoveIndependentDisk", "vim.fault.VimFault", "vim.version.version8", None) +CreateDataType("vim.fault.StorageDrsCannotMoveManuallyPlacedSwapFile", "StorageDrsCannotMoveManuallyPlacedSwapFile", "vim.fault.VimFault", "vim.version.version8", None) +CreateDataType("vim.fault.StorageDrsCannotMoveManuallyPlacedVm", "StorageDrsCannotMoveManuallyPlacedVm", "vim.fault.VimFault", "vim.version.version8", None) +CreateDataType("vim.fault.StorageDrsCannotMoveSharedDisk", "StorageDrsCannotMoveSharedDisk", "vim.fault.VimFault", "vim.version.version8", None) +CreateDataType("vim.fault.StorageDrsCannotMoveTemplate", "StorageDrsCannotMoveTemplate", "vim.fault.VimFault", "vim.version.version8", None) +CreateDataType("vim.fault.StorageDrsCannotMoveVmInUserFolder", "StorageDrsCannotMoveVmInUserFolder", "vim.fault.VimFault", "vim.version.version8", None) +CreateDataType("vim.fault.StorageDrsCannotMoveVmWithMountedCDROM", "StorageDrsCannotMoveVmWithMountedCDROM", "vim.fault.VimFault", "vim.version.version8", None) +CreateDataType("vim.fault.StorageDrsCannotMoveVmWithNoFilesInLayout", "StorageDrsCannotMoveVmWithNoFilesInLayout", "vim.fault.VimFault", "vim.version.version8", None) +CreateDataType("vim.fault.StorageDrsDatacentersCannotShareDatastore", "StorageDrsDatacentersCannotShareDatastore", "vim.fault.VimFault", "vim.version.version9", None) +CreateDataType("vim.fault.StorageDrsDisabledOnVm", "StorageDrsDisabledOnVm", "vim.fault.VimFault", "vim.version.version7", None) +CreateDataType("vim.fault.StorageDrsIolbDisabledInternally", "StorageDrsIolbDisabledInternally", "vim.fault.VimFault", "vim.version.version7", None) +CreateDataType("vim.fault.StorageDrsUnableToMoveFiles", "StorageDrsUnableToMoveFiles", "vim.fault.VimFault", "vim.version.version8", None) +CreateDataType("vim.fault.StorageVMotionNotSupported", "StorageVMotionNotSupported", "vim.fault.MigrationFeatureNotSupported", "vim.version.version5", None) +CreateDataType("vim.fault.SuspendedRelocateNotSupported", "SuspendedRelocateNotSupported", "vim.fault.MigrationFault", "vim.version.version1", None) +CreateDataType("vim.fault.SwapDatastoreUnset", "SwapDatastoreUnset", "vim.fault.VimFault", "vim.version.version2", None) +CreateDataType("vim.fault.SwapPlacementOverrideNotSupported", "SwapPlacementOverrideNotSupported", "vim.fault.InvalidVmConfig", "vim.version.version2", None) +CreateDataType("vim.fault.SwitchIpUnset", "SwitchIpUnset", "vim.fault.DvsFault", "vim.version.version8", None) +CreateDataType("vim.fault.SwitchNotInUpgradeMode", "SwitchNotInUpgradeMode", "vim.fault.DvsFault", "vim.version.version5", None) +CreateDataType("vim.fault.TaskInProgress", "TaskInProgress", "vim.fault.VimFault", "vim.version.version1", [("task", "vim.Task", "vim.version.version1", 0)]) +CreateDataType("vim.fault.Timedout", "Timedout", "vim.fault.VimFault", "vim.version.version1", None) +CreateDataType("vim.fault.TooManyConcurrentNativeClones", "TooManyConcurrentNativeClones", "vim.fault.FileFault", "vim.version.version7", None) +CreateDataType("vim.fault.TooManyConsecutiveOverrides", "TooManyConsecutiveOverrides", "vim.fault.VimFault", "vim.version.version2", None) +CreateDataType("vim.fault.TooManyDevices", "TooManyDevices", "vim.fault.InvalidVmConfig", "vim.version.version1", None) +CreateDataType("vim.fault.TooManyDisksOnLegacyHost", "TooManyDisksOnLegacyHost", "vim.fault.MigrationFault", "vim.version.version2", [("diskCount", "int", "vim.version.version2", 0), ("timeoutDanger", "boolean", "vim.version.version2", 0)]) +CreateDataType("vim.fault.TooManyGuestLogons", "TooManyGuestLogons", "vim.fault.GuestOperationsFault", "vim.version.version7", None) +CreateDataType("vim.fault.TooManyHosts", "TooManyHosts", "vim.fault.HostConnectFault", "vim.version.version1", None) +CreateDataType("vim.fault.TooManyNativeCloneLevels", "TooManyNativeCloneLevels", "vim.fault.FileFault", "vim.version.version7", None) +CreateDataType("vim.fault.TooManyNativeClonesOnFile", "TooManyNativeClonesOnFile", "vim.fault.FileFault", "vim.version.version7", None) +CreateDataType("vim.fault.TooManySnapshotLevels", "TooManySnapshotLevels", "vim.fault.SnapshotFault", "vim.version.version1", None) +CreateDataType("vim.fault.ToolsAlreadyUpgraded", "ToolsAlreadyUpgraded", "vim.fault.VmToolsUpgradeFault", "vim.version.version5", None) +CreateDataType("vim.fault.ToolsAutoUpgradeNotSupported", "ToolsAutoUpgradeNotSupported", "vim.fault.VmToolsUpgradeFault", "vim.version.version5", None) +CreateDataType("vim.fault.ToolsImageCopyFailed", "ToolsImageCopyFailed", "vim.fault.VmToolsUpgradeFault", "vim.version.version8", None) +CreateDataType("vim.fault.ToolsImageNotAvailable", "ToolsImageNotAvailable", "vim.fault.VmToolsUpgradeFault", "vim.version.version5", None) +CreateDataType("vim.fault.ToolsImageSignatureCheckFailed", "ToolsImageSignatureCheckFailed", "vim.fault.VmToolsUpgradeFault", "vim.version.version5", None) +CreateDataType("vim.fault.ToolsInstallationInProgress", "ToolsInstallationInProgress", "vim.fault.MigrationFault", "vim.version.version5", None) +CreateDataType("vim.fault.ToolsUnavailable", "ToolsUnavailable", "vim.fault.VimFault", "vim.version.version1", None) +CreateDataType("vim.fault.ToolsUpgradeCancelled", "ToolsUpgradeCancelled", "vim.fault.VmToolsUpgradeFault", "vim.version.version5", None) +CreateDataType("vim.fault.UncommittedUndoableDisk", "UncommittedUndoableDisk", "vim.fault.MigrationFault", "vim.version.version1", None) +CreateDataType("vim.fault.UncustomizableGuest", "UncustomizableGuest", "vim.fault.CustomizationFault", "vim.version.version1", [("uncustomizableGuestOS", "string", "vim.version.version1", 0)]) +CreateDataType("vim.fault.UnexpectedCustomizationFault", "UnexpectedCustomizationFault", "vim.fault.CustomizationFault", "vim.version.version1", None) +CreateDataType("vim.fault.UnrecognizedHost", "UnrecognizedHost", "vim.fault.VimFault", "vim.version.version2", [("hostName", "string", "vim.version.version2", 0)]) +CreateDataType("vim.fault.UnsharedSwapVMotionNotSupported", "UnsharedSwapVMotionNotSupported", "vim.fault.MigrationFeatureNotSupported", "vim.version.version2", None) +CreateDataType("vim.fault.UnsupportedDatastore", "UnsupportedDatastore", "vim.fault.VmConfigFault", "vim.version.version1", [("datastore", "vim.Datastore", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.fault.UnsupportedGuest", "UnsupportedGuest", "vim.fault.InvalidVmConfig", "vim.version.version1", [("unsupportedGuestOS", "string", "vim.version.version1", 0)]) +CreateDataType("vim.fault.UnsupportedVimApiVersion", "UnsupportedVimApiVersion", "vim.fault.VimFault", "vim.version.version5", [("version", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.fault.UnsupportedVmxLocation", "UnsupportedVmxLocation", "vim.fault.VmConfigFault", "vim.version.version1", None) +CreateDataType("vim.fault.UserNotFound", "UserNotFound", "vim.fault.VimFault", "vim.version.version1", [("principal", "string", "vim.version.version1", 0), ("unresolved", "boolean", "vim.version.version1", 0)]) +CreateDataType("vim.fault.VAppConfigFault", "VAppConfigFault", "vim.fault.VimFault", "vim.version.version5", None) +CreateDataType("vim.fault.VAppNotRunning", "VAppNotRunning", "vim.fault.VmConfigFault", "vim.version.version5", None) +CreateDataType("vim.fault.VAppPropertyFault", "VAppPropertyFault", "vim.fault.VmConfigFault", "vim.version.version5", [("id", "string", "vim.version.version5", 0), ("category", "string", "vim.version.version5", 0), ("label", "string", "vim.version.version5", 0), ("type", "string", "vim.version.version5", 0), ("value", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.VAppTaskInProgress", "VAppTaskInProgress", "vim.fault.TaskInProgress", "vim.version.version5", None) +CreateDataType("vim.fault.VFlashModuleNotSupported", "VFlashModuleNotSupported", "vim.fault.VmConfigFault", "vim.version.version9", [("vmName", "string", "vim.version.version9", 0), ("moduleName", "string", "vim.version.version9", 0), ("reason", "string", "vim.version.version9", 0), ("hostName", "string", "vim.version.version9", 0)]) +CreateEnumType("vim.fault.VFlashModuleNotSupported.Reason", "VFlashModuleNotSupportedReason", "vim.version.version9", ["CacheModeNotSupported", "CacheConsistencyTypeNotSupported", "CacheBlockSizeNotSupported", "CacheReservationNotSupported", "DiskSizeNotSupported"]) +CreateDataType("vim.fault.VFlashModuleVersionIncompatible", "VFlashModuleVersionIncompatible", "vim.fault.VimFault", "vim.version.version9", [("moduleName", "string", "vim.version.version9", 0), ("vmRequestModuleVersion", "string", "vim.version.version9", 0), ("hostMinSupportedVerson", "string", "vim.version.version9", 0), ("hostModuleVersion", "string", "vim.version.version9", 0)]) +CreateDataType("vim.fault.VMotionAcrossNetworkNotSupported", "VMotionAcrossNetworkNotSupported", "vim.fault.MigrationFeatureNotSupported", "vim.version.version9", None) +CreateDataType("vim.fault.VMotionInterfaceIssue", "VMotionInterfaceIssue", "vim.fault.MigrationFault", "vim.version.version1", [("atSourceHost", "boolean", "vim.version.version1", 0), ("failedHost", "string", "vim.version.version1", 0), ("failedHostEntity", "vim.HostSystem", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.fault.VMotionLinkCapacityLow", "VMotionLinkCapacityLow", "vim.fault.VMotionInterfaceIssue", "vim.version.version1", [("network", "string", "vim.version.version1", 0)]) +CreateDataType("vim.fault.VMotionLinkDown", "VMotionLinkDown", "vim.fault.VMotionInterfaceIssue", "vim.version.version1", [("network", "string", "vim.version.version1", 0)]) +CreateDataType("vim.fault.VMotionNotConfigured", "VMotionNotConfigured", "vim.fault.VMotionInterfaceIssue", "vim.version.version1", None) +CreateDataType("vim.fault.VMotionNotLicensed", "VMotionNotLicensed", "vim.fault.VMotionInterfaceIssue", "vim.version.version1", None) +CreateDataType("vim.fault.VMotionNotSupported", "VMotionNotSupported", "vim.fault.VMotionInterfaceIssue", "vim.version.version1", None) +CreateDataType("vim.fault.VMotionProtocolIncompatible", "VMotionProtocolIncompatible", "vim.fault.MigrationFault", "vim.version.version1", None) +CreateDataType("vim.fault.VirtualHardwareCompatibilityIssue", "VirtualHardwareCompatibilityIssue", "vim.fault.VmConfigFault", "vim.version.version1", None) +CreateDataType("vim.fault.VirtualHardwareVersionNotSupported", "VirtualHardwareVersionNotSupported", "vim.fault.VirtualHardwareCompatibilityIssue", "vim.version.version1", [("hostName", "string", "vim.version.version2", 0), ("host", "vim.HostSystem", "vim.version.version2", 0)]) +CreateDataType("vim.fault.VmAlreadyExistsInDatacenter", "VmAlreadyExistsInDatacenter", "vim.fault.InvalidFolder", "vim.version.version5", [("host", "vim.HostSystem", "vim.version.version5", 0), ("hostname", "string", "vim.version.version5", 0), ("vm", "vim.VirtualMachine[]", "vim.version.version5", 0)]) +CreateDataType("vim.fault.VmFaultToleranceConfigIssue", "VmFaultToleranceConfigIssue", "vim.fault.VmFaultToleranceIssue", "vim.version.version5", [("reason", "string", "vim.version.version5", F_OPTIONAL), ("entityName", "string", "vim.version.version5", F_OPTIONAL), ("entity", "vim.ManagedEntity", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.fault.VmFaultToleranceConfigIssue.ReasonForIssue", "VmFaultToleranceConfigIssueReasonForIssue", "vim.version.version5", ["haNotEnabled", "moreThanOneSecondary", "recordReplayNotSupported", "replayNotSupported", "templateVm", "multipleVCPU", "hostInactive", "ftUnsupportedHardware", "ftUnsupportedProduct", "missingVMotionNic", "missingFTLoggingNic", "thinDisk", "verifySSLCertificateFlagNotSet", "hasSnapshots", "noConfig", "ftSecondaryVm", "hasLocalDisk", "esxAgentVm", "video3dEnabled", "hasUnsupportedDisk", "insufficientBandwidth", "hasNestedHVConfiguration", "hasVFlashConfiguration", "unsupportedProduct", "cpuHvUnsupported", "cpuHwmmuUnsupported", "cpuHvDisabled"]) +CreateDataType("vim.fault.VmFaultToleranceConfigIssueWrapper", "VmFaultToleranceConfigIssueWrapper", "vim.fault.VmFaultToleranceIssue", "vim.version.version6", [("entityName", "string", "vim.version.version6", F_OPTIONAL), ("entity", "vim.ManagedEntity", "vim.version.version6", F_OPTIONAL), ("error", "vmodl.MethodFault", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.fault.VmFaultToleranceInvalidFileBacking", "VmFaultToleranceInvalidFileBacking", "vim.fault.VmFaultToleranceIssue", "vim.version.version5", [("backingType", "string", "vim.version.version5", F_OPTIONAL), ("backingFilename", "string", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.fault.VmFaultToleranceInvalidFileBacking.DeviceType", "VmFaultToleranceInvalidFileBackingDeviceType", "vim.version.version5", ["virtualFloppy", "virtualCdrom", "virtualSerialPort", "virtualParallelPort", "virtualDisk"]) +CreateDataType("vim.fault.VmFaultToleranceTooManyVMsOnHost", "VmFaultToleranceTooManyVMsOnHost", "vim.fault.InsufficientResourcesFault", "vim.version.version6", [("hostName", "string", "vim.version.version6", F_OPTIONAL), ("maxNumFtVms", "int", "vim.version.version6", 0)]) +CreateDataType("vim.fault.VmPowerOnDisabled", "VmPowerOnDisabled", "vim.fault.InvalidState", "vim.version.version5", None) +CreateDataType("vim.fault.VmWwnConflict", "VmWwnConflict", "vim.fault.InvalidVmConfig", "vim.version.version2", [("vm", "vim.VirtualMachine", "vim.version.version2", F_OPTIONAL), ("host", "vim.HostSystem", "vim.version.version2", F_OPTIONAL), ("name", "string", "vim.version.version2", F_OPTIONAL), ("wwn", "long", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.fault.VmfsMountFault", "VmfsMountFault", "vim.fault.HostConfigFault", "vim.version.version5", [("uuid", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.VmotionInterfaceNotEnabled", "VmotionInterfaceNotEnabled", "vim.fault.HostPowerOpFailed", "vim.version.version2", None) +CreateDataType("vim.fault.VolumeEditorError", "VolumeEditorError", "vim.fault.CustomizationFault", "vim.version.version1", None) +CreateDataType("vim.fault.VsanClusterUuidMismatch", "VsanClusterUuidMismatch", "vim.fault.CannotMoveVsanEnabledHost", "vim.version.version9", [("hostClusterUuid", "string", "vim.version.version9", 0), ("destinationClusterUuid", "string", "vim.version.version9", 0)]) +CreateDataType("vim.fault.VsanDiskFault", "VsanDiskFault", "vim.fault.VsanFault", "vim.version.version9", [("device", "string", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.fault.VspanDestPortConflict", "VspanDestPortConflict", "vim.fault.DvsFault", "vim.version.version7", [("vspanSessionKey1", "string", "vim.version.version7", 0), ("vspanSessionKey2", "string", "vim.version.version7", 0), ("portKey", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.VspanPortConflict", "VspanPortConflict", "vim.fault.DvsFault", "vim.version.version7", [("vspanSessionKey1", "string", "vim.version.version7", 0), ("vspanSessionKey2", "string", "vim.version.version7", 0), ("portKey", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.VspanPortMoveFault", "VspanPortMoveFault", "vim.fault.DvsFault", "vim.version.version7", [("srcPortgroupName", "string", "vim.version.version7", 0), ("destPortgroupName", "string", "vim.version.version7", 0), ("portKey", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.VspanPortPromiscChangeFault", "VspanPortPromiscChangeFault", "vim.fault.DvsFault", "vim.version.version7", [("portKey", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.VspanPortgroupPromiscChangeFault", "VspanPortgroupPromiscChangeFault", "vim.fault.DvsFault", "vim.version.version7", [("portgroupName", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.VspanPortgroupTypeChangeFault", "VspanPortgroupTypeChangeFault", "vim.fault.DvsFault", "vim.version.version7", [("portgroupName", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.VspanPromiscuousPortNotSupported", "VspanPromiscuousPortNotSupported", "vim.fault.DvsFault", "vim.version.version7", [("vspanSessionKey", "string", "vim.version.version7", 0), ("portKey", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.VspanSameSessionPortConflict", "VspanSameSessionPortConflict", "vim.fault.DvsFault", "vim.version.version7", [("vspanSessionKey", "string", "vim.version.version7", 0), ("portKey", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.WakeOnLanNotSupported", "WakeOnLanNotSupported", "vim.fault.VirtualHardwareCompatibilityIssue", "vim.version.version2", None) +CreateDataType("vim.fault.WakeOnLanNotSupportedByVmotionNIC", "WakeOnLanNotSupportedByVmotionNIC", "vim.fault.HostPowerOpFailed", "vim.version.version2", None) +CreateDataType("vim.fault.WillLoseHAProtection", "WillLoseHAProtection", "vim.fault.MigrationFault", "vim.version.version7", [("resolution", "string", "vim.version.version7", 0)]) +CreateEnumType("vim.fault.WillLoseHAProtection.Resolution", "WillLoseHAProtectionResolution", "vim.version.version7", ["svmotion", "relocate"]) +CreateDataType("vim.fault.WillModifyConfigCpuRequirements", "WillModifyConfigCpuRequirements", "vim.fault.MigrationFault", "vim.version.version1", None) +CreateDataType("vim.fault.WillResetSnapshotDirectory", "WillResetSnapshotDirectory", "vim.fault.MigrationFault", "vim.version.version7", None) +CreateManagedType("vim.host.ActiveDirectoryAuthentication", "HostActiveDirectoryAuthentication", "vim.host.DirectoryStore", "vim.version.version6", None, [("joinDomain", "JoinDomain_Task", "vim.version.version6", (("domainName", "string", "vim.version.version6", 0, None),("userName", "string", "vim.version.version6", 0, None),("password", "string", "vim.version.version6", 0, None),), (0, "vim.Task", "void"), "Host.Config.AuthenticationStore", ["vim.fault.InvalidState", "vim.fault.HostConfigFault", "vim.fault.InvalidLogin", "vim.fault.ActiveDirectoryFault", "vim.fault.TaskInProgress", ]), ("joinDomainWithCAM", "JoinDomainWithCAM_Task", "vim.version.version7", (("domainName", "string", "vim.version.version7", 0, None),("camServer", "string", "vim.version.version7", 0, None),), (0, "vim.Task", "void"), "Host.Config.AuthenticationStore", ["vim.fault.InvalidState", "vim.fault.HostConfigFault", "vim.fault.ActiveDirectoryFault", "vim.fault.TaskInProgress", ]), ("importCertificateForCAM", "ImportCertificateForCAM_Task", "vim.version.version7", (("certPath", "string", "vim.version.version7", 0, None),("camServer", "string", "vim.version.version7", 0, None),), (0, "vim.Task", "void"), "Host.Config.AuthenticationStore", ["vim.fault.FileNotFound", "vim.fault.ActiveDirectoryFault", ]), ("leaveCurrentDomain", "LeaveCurrentDomain_Task", "vim.version.version6", (("force", "boolean", "vim.version.version6", 0, None),), (0, "vim.Task", "void"), "Host.Config.AuthenticationStore", ["vim.fault.InvalidState", "vim.fault.AuthMinimumAdminPermission", "vim.fault.ActiveDirectoryFault", "vim.fault.TaskInProgress", ])]) +CreateDataType("vim.host.ActiveDirectoryInfo", "HostActiveDirectoryInfo", "vim.host.DirectoryStoreInfo", "vim.version.version6", [("joinedDomain", "string", "vim.version.version6", F_OPTIONAL), ("trustedDomain", "string[]", "vim.version.version6", F_OPTIONAL), ("domainMembershipStatus", "string", "vim.version.version6", F_OPTIONAL)]) +CreateEnumType("vim.host.ActiveDirectoryInfo.DomainMembershipStatus", "HostActiveDirectoryInfoDomainMembershipStatus", "vim.version.version6", ["unknown", "ok", "noServers", "clientTrustBroken", "serverTrustBroken", "inconsistentTrust", "otherProblem"]) +CreateDataType("vim.host.BootDeviceInfo", "HostBootDeviceInfo", "vmodl.DynamicData", "vim.version.version2", [("bootDevices", "vim.host.BootDeviceSystem.BootDevice[]", "vim.version.version2", F_OPTIONAL), ("currentBootDeviceKey", "string", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.host.ConfigSpec", "HostConfigSpec", "vmodl.DynamicData", "vim.version.version5", [("nasDatastore", "vim.host.NasVolume.Config[]", "vim.version.version5", F_OPTIONAL), ("network", "vim.host.NetworkConfig", "vim.version.version5", F_OPTIONAL), ("nicTypeSelection", "vim.host.VirtualNicManager.NicTypeSelection[]", "vim.version.version5", F_OPTIONAL), ("service", "vim.host.ServiceConfig[]", "vim.version.version5", F_OPTIONAL), ("firewall", "vim.host.FirewallConfig", "vim.version.version5", F_OPTIONAL), ("option", "vim.option.OptionValue[]", "vim.version.version5", F_OPTIONAL), ("datastorePrincipal", "string", "vim.version.version5", F_OPTIONAL), ("datastorePrincipalPasswd", "string", "vim.version.version5", F_OPTIONAL), ("datetime", "vim.host.DateTimeConfig", "vim.version.version5", F_OPTIONAL), ("storageDevice", "vim.host.StorageDeviceInfo", "vim.version.version5", F_OPTIONAL), ("license", "vim.host.LicenseSpec", "vim.version.version5", F_OPTIONAL), ("security", "vim.host.SecuritySpec", "vim.version.version5", F_OPTIONAL), ("userAccount", "vim.host.LocalAccountManager.AccountSpecification[]", "vim.version.version5", F_OPTIONAL), ("usergroupAccount", "vim.host.LocalAccountManager.AccountSpecification[]", "vim.version.version5", F_OPTIONAL), ("memory", "vim.host.MemorySpec", "vim.version.version5", F_OPTIONAL), ("activeDirectory", "vim.host.ActiveDirectorySpec[]", "vim.version.version6", F_OPTIONAL), ("genericConfig", "vmodl.KeyAnyValue[]", "vim.version.version7", F_OPTIONAL)]) +CreateManagedType("vim.host.DatastoreSystem", "HostDatastoreSystem", "vmodl.ManagedObject", "vim.version.version1", [("datastore", "vim.Datastore[]", "vim.version.version1", F_OPTIONAL, "System.View"), ("capabilities", "vim.host.DatastoreSystem.Capabilities", "vim.version.version2", 0, None)], [("updateLocalSwapDatastore", "UpdateLocalSwapDatastore", "vim.version.version2", (("datastore", "vim.Datastore", "vim.version.version2", F_OPTIONAL, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.InaccessibleDatastore", "vim.fault.DatastoreNotWritableOnHost", ]), ("queryAvailableDisksForVmfs", "QueryAvailableDisksForVmfs", "vim.version.version1", (("datastore", "vim.Datastore", "vim.version.version1", F_OPTIONAL, None),), (F_OPTIONAL, "vim.host.ScsiDisk[]", "vim.host.ScsiDisk[]"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("queryVmfsDatastoreCreateOptions", "QueryVmfsDatastoreCreateOptions", "vim.version.version1", (("devicePath", "string", "vim.version.version1", 0, None),("vmfsMajorVersion", "int", "vim.version.version7", F_OPTIONAL, None),), (F_OPTIONAL, "vim.host.VmfsDatastoreOption[]", "vim.host.VmfsDatastoreOption[]"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("createVmfsDatastore", "CreateVmfsDatastore", "vim.version.version1", (("spec", "vim.host.VmfsDatastoreCreateSpec", "vim.version.version1", 0, None),), (0, "vim.Datastore", "vim.Datastore"), "Host.Config.Storage", ["vim.fault.DuplicateName", "vim.fault.HostConfigFault", ]), ("queryVmfsDatastoreExtendOptions", "QueryVmfsDatastoreExtendOptions", "vim.version.version1", (("datastore", "vim.Datastore", "vim.version.version1", 0, None),("devicePath", "string", "vim.version.version1", 0, None),("suppressExpandCandidates", "boolean", "vim.version.version5", F_OPTIONAL, None),), (F_OPTIONAL, "vim.host.VmfsDatastoreOption[]", "vim.host.VmfsDatastoreOption[]"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("queryVmfsDatastoreExpandOptions", "QueryVmfsDatastoreExpandOptions", "vim.version.version5", (("datastore", "vim.Datastore", "vim.version.version5", 0, None),), (F_OPTIONAL, "vim.host.VmfsDatastoreOption[]", "vim.host.VmfsDatastoreOption[]"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("extendVmfsDatastore", "ExtendVmfsDatastore", "vim.version.version1", (("datastore", "vim.Datastore", "vim.version.version1", 0, None),("spec", "vim.host.VmfsDatastoreExtendSpec", "vim.version.version1", 0, None),), (0, "vim.Datastore", "vim.Datastore"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("expandVmfsDatastore", "ExpandVmfsDatastore", "vim.version.version5", (("datastore", "vim.Datastore", "vim.version.version5", 0, None),("spec", "vim.host.VmfsDatastoreExpandSpec", "vim.version.version5", 0, None),), (0, "vim.Datastore", "vim.Datastore"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("createNasDatastore", "CreateNasDatastore", "vim.version.version1", (("spec", "vim.host.NasVolume.Specification", "vim.version.version1", 0, None),), (0, "vim.Datastore", "vim.Datastore"), "Host.Config.Storage", ["vim.fault.DuplicateName", "vim.fault.AlreadyExists", "vim.fault.HostConfigFault", ]), ("createLocalDatastore", "CreateLocalDatastore", "vim.version.version1", (("name", "string", "vim.version.version1", 0, None),("path", "string", "vim.version.version1", 0, None),), (0, "vim.Datastore", "vim.Datastore"), "Host.Config.Storage", ["vim.fault.DuplicateName", "vim.fault.HostConfigFault", "vim.fault.FileNotFound", "vim.fault.InvalidName", ]), ("removeDatastore", "RemoveDatastore", "vim.version.version1", (("datastore", "vim.Datastore", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", "vim.fault.ResourceInUse", ]), ("configureDatastorePrincipal", "ConfigureDatastorePrincipal", "vim.version.version1", (("userName", "string", "vim.version.version1", 0, None),("password", "string", "vim.version.version1", F_OPTIONAL, None),), (0, "void", "void"), "Host.Config.Maintenance", ["vim.fault.InvalidState", "vim.fault.HostConfigFault", ]), ("queryUnresolvedVmfsVolumes", "QueryUnresolvedVmfsVolumes", "vim.version.version5", (), (F_OPTIONAL, "vim.host.UnresolvedVmfsVolume[]", "vim.host.UnresolvedVmfsVolume[]"), "System.Read", None), ("resignatureUnresolvedVmfsVolume", "ResignatureUnresolvedVmfsVolume_Task", "vim.version.version5", (("resolutionSpec", "vim.host.UnresolvedVmfsResignatureSpec", "vim.version.version5", 0, None),), (F_OPTIONAL, "vim.Task", "vim.host.ResignatureRescanResult"), "Host.Config.Storage", ["vim.fault.VmfsAmbiguousMount", "vim.fault.HostConfigFault", ])]) +CreateDataType("vim.host.DatastoreSystem.Capabilities", "HostDatastoreSystemCapabilities", "vmodl.DynamicData", "vim.version.version2", [("nfsMountCreationRequired", "boolean", "vim.version.version2", 0), ("nfsMountCreationSupported", "boolean", "vim.version.version2", 0), ("localDatastoreSupported", "boolean", "vim.version.version2", 0), ("vmfsExtentExpansionSupported", "boolean", "vim.version.version5", 0)]) +CreateDataType("vim.host.VmfsDatastoreOption", "VmfsDatastoreOption", "vmodl.DynamicData", "vim.version.version1", [("info", "vim.host.VmfsDatastoreOption.Info", "vim.version.version1", 0), ("spec", "vim.host.VmfsDatastoreSpec", "vim.version.version1", 0)]) +CreateDataType("vim.host.VmfsDatastoreOption.Info", "VmfsDatastoreBaseOption", "vmodl.DynamicData", "vim.version.version1", [("layout", "vim.host.DiskPartitionInfo.Layout", "vim.version.version1", 0), ("partitionFormatChange", "boolean", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.host.VmfsDatastoreOption.SingleExtentInfo", "VmfsDatastoreSingleExtentOption", "vim.host.VmfsDatastoreOption.Info", "vim.version.version1", [("vmfsExtent", "vim.host.DiskPartitionInfo.BlockRange", "vim.version.version1", 0)]) +CreateDataType("vim.host.VmfsDatastoreOption.AllExtentInfo", "VmfsDatastoreAllExtentOption", "vim.host.VmfsDatastoreOption.SingleExtentInfo", "vim.version.version1", None) +CreateDataType("vim.host.VmfsDatastoreOption.MultipleExtentInfo", "VmfsDatastoreMultipleExtentOption", "vim.host.VmfsDatastoreOption.Info", "vim.version.version1", [("vmfsExtent", "vim.host.DiskPartitionInfo.BlockRange[]", "vim.version.version1", 0)]) +CreateDataType("vim.host.DateTimeInfo", "HostDateTimeInfo", "vmodl.DynamicData", "vim.version.version2", [("timeZone", "vim.host.DateTimeSystem.TimeZone", "vim.version.version2", 0), ("ntpConfig", "vim.host.NtpConfig", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.host.FirewallConfig", "HostFirewallConfig", "vmodl.DynamicData", "vim.version.version5", [("rule", "vim.host.FirewallConfig.RuleSetConfig[]", "vim.version.version5", F_OPTIONAL), ("defaultBlockingPolicy", "vim.host.FirewallInfo.DefaultPolicy", "vim.version.version5", 0)]) +CreateDataType("vim.host.FirewallConfig.RuleSetConfig", "HostFirewallConfigRuleSetConfig", "vmodl.DynamicData", "vim.version.version5", [("rulesetId", "string", "vim.version.version5", 0), ("enabled", "boolean", "vim.version.version5", 0), ("allowedHosts", "vim.host.Ruleset.IpList", "vim.version.version7", F_OPTIONAL)]) +CreateManagedType("vim.host.FirewallSystem", "HostFirewallSystem", "vim.ExtensibleManagedObject", "vim.version.version1", [("firewallInfo", "vim.host.FirewallInfo", "vim.version.version1", F_OPTIONAL, None)], [("updateDefaultPolicy", "UpdateDefaultPolicy", "vim.version.version1", (("defaultPolicy", "vim.host.FirewallInfo.DefaultPolicy", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.NetService", None), ("enableRuleset", "EnableRuleset", "vim.version.version1", (("id", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.NetService", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("disableRuleset", "DisableRuleset", "vim.version.version1", (("id", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.NetService", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("updateRuleset", "UpdateRuleset", "vim.version.version7", (("id", "string", "vim.version.version7", 0, None),("spec", "vim.host.Ruleset.RulesetSpec", "vim.version.version7", 0, None),), (0, "void", "void"), "Host.Config.NetService", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("refresh", "RefreshFirewall", "vim.version.version1", (), (0, "void", "void"), "Host.Config.NetService", None)]) +CreateDataType("vim.host.InternetScsiHba", "HostInternetScsiHba", "vim.host.HostBusAdapter", "vim.version.version1", [("isSoftwareBased", "boolean", "vim.version.version1", 0), ("canBeDisabled", "boolean", "vim.version.version7", F_OPTIONAL), ("networkBindingSupport", "vim.host.InternetScsiHba.NetworkBindingSupportType", "vim.version.version7", F_OPTIONAL), ("discoveryCapabilities", "vim.host.InternetScsiHba.DiscoveryCapabilities", "vim.version.version1", 0), ("discoveryProperties", "vim.host.InternetScsiHba.DiscoveryProperties", "vim.version.version1", 0), ("authenticationCapabilities", "vim.host.InternetScsiHba.AuthenticationCapabilities", "vim.version.version1", 0), ("authenticationProperties", "vim.host.InternetScsiHba.AuthenticationProperties", "vim.version.version1", 0), ("digestCapabilities", "vim.host.InternetScsiHba.DigestCapabilities", "vim.version.version5", F_OPTIONAL), ("digestProperties", "vim.host.InternetScsiHba.DigestProperties", "vim.version.version5", F_OPTIONAL), ("ipCapabilities", "vim.host.InternetScsiHba.IPCapabilities", "vim.version.version1", 0), ("ipProperties", "vim.host.InternetScsiHba.IPProperties", "vim.version.version1", 0), ("supportedAdvancedOptions", "vim.option.OptionDef[]", "vim.version.version5", F_OPTIONAL), ("advancedOptions", "vim.host.InternetScsiHba.ParamValue[]", "vim.version.version5", F_OPTIONAL), ("iScsiName", "string", "vim.version.version1", 0), ("iScsiAlias", "string", "vim.version.version1", F_OPTIONAL), ("configuredSendTarget", "vim.host.InternetScsiHba.SendTarget[]", "vim.version.version1", F_OPTIONAL), ("configuredStaticTarget", "vim.host.InternetScsiHba.StaticTarget[]", "vim.version.version1", F_OPTIONAL), ("maxSpeedMb", "int", "vim.version.version1", F_OPTIONAL), ("currentSpeedMb", "int", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.InternetScsiHba.ParamValue", "HostInternetScsiHbaParamValue", "vim.option.OptionValue", "vim.version.version5", [("isInherited", "boolean", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.InternetScsiHba.DiscoveryCapabilities", "HostInternetScsiHbaDiscoveryCapabilities", "vmodl.DynamicData", "vim.version.version1", [("iSnsDiscoverySettable", "boolean", "vim.version.version1", 0), ("slpDiscoverySettable", "boolean", "vim.version.version1", 0), ("staticTargetDiscoverySettable", "boolean", "vim.version.version1", 0), ("sendTargetsDiscoverySettable", "boolean", "vim.version.version1", 0)]) +CreateDataType("vim.host.InternetScsiHba.DiscoveryProperties", "HostInternetScsiHbaDiscoveryProperties", "vmodl.DynamicData", "vim.version.version1", [("iSnsDiscoveryEnabled", "boolean", "vim.version.version1", 0), ("iSnsDiscoveryMethod", "string", "vim.version.version1", F_OPTIONAL), ("iSnsHost", "string", "vim.version.version1", F_OPTIONAL), ("slpDiscoveryEnabled", "boolean", "vim.version.version1", 0), ("slpDiscoveryMethod", "string", "vim.version.version1", F_OPTIONAL), ("slpHost", "string", "vim.version.version1", F_OPTIONAL), ("staticTargetDiscoveryEnabled", "boolean", "vim.version.version1", 0), ("sendTargetsDiscoveryEnabled", "boolean", "vim.version.version1", 0)]) +CreateEnumType("vim.host.InternetScsiHba.DiscoveryProperties.ISnsDiscoveryMethod", "InternetScsiSnsDiscoveryMethod", "vim.version.version1", ["isnsStatic", "isnsDhcp", "isnsSlp"]) +CreateEnumType("vim.host.InternetScsiHba.DiscoveryProperties.SlpDiscoveryMethod", "SlpDiscoveryMethod", "vim.version.version1", ["slpDhcp", "slpAutoUnicast", "slpAutoMulticast", "slpManual"]) +CreateEnumType("vim.host.InternetScsiHba.ChapAuthenticationType", "HostInternetScsiHbaChapAuthenticationType", "vim.version.version5", ["chapProhibited", "chapDiscouraged", "chapPreferred", "chapRequired"]) +CreateDataType("vim.host.InternetScsiHba.AuthenticationCapabilities", "HostInternetScsiHbaAuthenticationCapabilities", "vmodl.DynamicData", "vim.version.version1", [("chapAuthSettable", "boolean", "vim.version.version1", 0), ("krb5AuthSettable", "boolean", "vim.version.version1", 0), ("srpAuthSettable", "boolean", "vim.version.version1", 0), ("spkmAuthSettable", "boolean", "vim.version.version1", 0), ("mutualChapSettable", "boolean", "vim.version.version5", F_OPTIONAL), ("targetChapSettable", "boolean", "vim.version.version5", F_OPTIONAL), ("targetMutualChapSettable", "boolean", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.InternetScsiHba.AuthenticationProperties", "HostInternetScsiHbaAuthenticationProperties", "vmodl.DynamicData", "vim.version.version1", [("chapAuthEnabled", "boolean", "vim.version.version1", 0), ("chapName", "string", "vim.version.version1", F_OPTIONAL), ("chapSecret", "string", "vim.version.version1", F_OPTIONAL), ("chapAuthenticationType", "string", "vim.version.version5", F_OPTIONAL), ("chapInherited", "boolean", "vim.version.version5", F_OPTIONAL), ("mutualChapName", "string", "vim.version.version5", F_OPTIONAL), ("mutualChapSecret", "string", "vim.version.version5", F_OPTIONAL), ("mutualChapAuthenticationType", "string", "vim.version.version5", F_OPTIONAL), ("mutualChapInherited", "boolean", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.host.InternetScsiHba.DigestType", "HostInternetScsiHbaDigestType", "vim.version.version5", ["digestProhibited", "digestDiscouraged", "digestPreferred", "digestRequired"]) +CreateDataType("vim.host.InternetScsiHba.DigestCapabilities", "HostInternetScsiHbaDigestCapabilities", "vmodl.DynamicData", "vim.version.version5", [("headerDigestSettable", "boolean", "vim.version.version5", F_OPTIONAL), ("dataDigestSettable", "boolean", "vim.version.version5", F_OPTIONAL), ("targetHeaderDigestSettable", "boolean", "vim.version.version5", F_OPTIONAL), ("targetDataDigestSettable", "boolean", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.InternetScsiHba.DigestProperties", "HostInternetScsiHbaDigestProperties", "vmodl.DynamicData", "vim.version.version5", [("headerDigestType", "string", "vim.version.version5", F_OPTIONAL), ("headerDigestInherited", "boolean", "vim.version.version5", F_OPTIONAL), ("dataDigestType", "string", "vim.version.version5", F_OPTIONAL), ("dataDigestInherited", "boolean", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.InternetScsiHba.IPCapabilities", "HostInternetScsiHbaIPCapabilities", "vmodl.DynamicData", "vim.version.version1", [("addressSettable", "boolean", "vim.version.version1", 0), ("ipConfigurationMethodSettable", "boolean", "vim.version.version1", 0), ("subnetMaskSettable", "boolean", "vim.version.version1", 0), ("defaultGatewaySettable", "boolean", "vim.version.version1", 0), ("primaryDnsServerAddressSettable", "boolean", "vim.version.version1", 0), ("alternateDnsServerAddressSettable", "boolean", "vim.version.version1", 0), ("ipv6Supported", "boolean", "vim.version.version5", F_OPTIONAL), ("arpRedirectSettable", "boolean", "vim.version.version5", F_OPTIONAL), ("mtuSettable", "boolean", "vim.version.version5", F_OPTIONAL), ("hostNameAsTargetAddress", "boolean", "vim.version.version5", F_OPTIONAL), ("nameAliasSettable", "boolean", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.host.InternetScsiHba.IPProperties", "HostInternetScsiHbaIPProperties", "vmodl.DynamicData", "vim.version.version1", [("mac", "string", "vim.version.version1", F_OPTIONAL), ("address", "string", "vim.version.version1", F_OPTIONAL), ("dhcpConfigurationEnabled", "boolean", "vim.version.version1", 0), ("subnetMask", "string", "vim.version.version1", F_OPTIONAL), ("defaultGateway", "string", "vim.version.version1", F_OPTIONAL), ("primaryDnsServerAddress", "string", "vim.version.version1", F_OPTIONAL), ("alternateDnsServerAddress", "string", "vim.version.version1", F_OPTIONAL), ("ipv6Address", "string", "vim.version.version5", F_OPTIONAL), ("ipv6SubnetMask", "string", "vim.version.version5", F_OPTIONAL), ("ipv6DefaultGateway", "string", "vim.version.version5", F_OPTIONAL), ("arpRedirectEnabled", "boolean", "vim.version.version5", F_OPTIONAL), ("mtu", "int", "vim.version.version5", F_OPTIONAL), ("jumboFramesEnabled", "boolean", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.InternetScsiHba.SendTarget", "HostInternetScsiHbaSendTarget", "vmodl.DynamicData", "vim.version.version1", [("address", "string", "vim.version.version1", 0), ("port", "int", "vim.version.version1", F_OPTIONAL), ("authenticationProperties", "vim.host.InternetScsiHba.AuthenticationProperties", "vim.version.version5", F_OPTIONAL), ("digestProperties", "vim.host.InternetScsiHba.DigestProperties", "vim.version.version5", F_OPTIONAL), ("supportedAdvancedOptions", "vim.option.OptionDef[]", "vim.version.version5", F_OPTIONAL), ("advancedOptions", "vim.host.InternetScsiHba.ParamValue[]", "vim.version.version5", F_OPTIONAL), ("parent", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.InternetScsiHba.StaticTarget", "HostInternetScsiHbaStaticTarget", "vmodl.DynamicData", "vim.version.version1", [("address", "string", "vim.version.version1", 0), ("port", "int", "vim.version.version1", F_OPTIONAL), ("iScsiName", "string", "vim.version.version1", 0), ("discoveryMethod", "string", "vim.version.version8", F_OPTIONAL), ("authenticationProperties", "vim.host.InternetScsiHba.AuthenticationProperties", "vim.version.version5", F_OPTIONAL), ("digestProperties", "vim.host.InternetScsiHba.DigestProperties", "vim.version.version5", F_OPTIONAL), ("supportedAdvancedOptions", "vim.option.OptionDef[]", "vim.version.version5", F_OPTIONAL), ("advancedOptions", "vim.host.InternetScsiHba.ParamValue[]", "vim.version.version5", F_OPTIONAL), ("parent", "string", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.host.InternetScsiHba.StaticTarget.TargetDiscoveryMethod", "HostInternetScsiHbaStaticTargetTargetDiscoveryMethod", "vim.version.version8", ["staticMethod", "sendTargetMethod", "slpMethod", "isnsMethod", "unknownMethod"]) +CreateDataType("vim.host.InternetScsiHba.TargetSet", "HostInternetScsiHbaTargetSet", "vmodl.DynamicData", "vim.version.version5", [("staticTargets", "vim.host.InternetScsiHba.StaticTarget[]", "vim.version.version5", F_OPTIONAL), ("sendTargets", "vim.host.InternetScsiHba.SendTarget[]", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.host.InternetScsiHba.NetworkBindingSupportType", "HostInternetScsiHbaNetworkBindingSupportType", "vim.version.version7", ["notsupported", "optional", "required"]) +CreateDataType("vim.host.NetworkConfig", "HostNetworkConfig", "vmodl.DynamicData", "vim.version.version1", [("vswitch", "vim.host.VirtualSwitch.Config[]", "vim.version.version1", F_OPTIONAL), ("proxySwitch", "vim.host.HostProxySwitch.Config[]", "vim.version.version5", F_OPTIONAL), ("portgroup", "vim.host.PortGroup.Config[]", "vim.version.version1", F_OPTIONAL), ("pnic", "vim.host.PhysicalNic.Config[]", "vim.version.version1", F_OPTIONAL), ("vnic", "vim.host.VirtualNic.Config[]", "vim.version.version1", F_OPTIONAL), ("consoleVnic", "vim.host.VirtualNic.Config[]", "vim.version.version1", F_OPTIONAL), ("dnsConfig", "vim.host.DnsConfig", "vim.version.version1", F_OPTIONAL), ("ipRouteConfig", "vim.host.IpRouteConfig", "vim.version.version1", F_OPTIONAL), ("consoleIpRouteConfig", "vim.host.IpRouteConfig", "vim.version.version1", F_OPTIONAL), ("routeTableConfig", "vim.host.IpRouteTableConfig", "vim.version.version5", F_OPTIONAL), ("dhcp", "vim.host.DhcpService.Config[]", "vim.version.version2", F_OPTIONAL), ("nat", "vim.host.NatService.Config[]", "vim.version.version2", F_OPTIONAL), ("ipV6Enabled", "boolean", "vim.version.version5", F_OPTIONAL), ("netStackSpec", "vim.host.NetworkConfig.NetStackSpec[]", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.host.NetworkConfig.Result", "HostNetworkConfigResult", "vmodl.DynamicData", "vim.version.version1", [("vnicDevice", "string[]", "vim.version.version1", F_OPTIONAL), ("consoleVnicDevice", "string[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.NetworkConfig.NetStackSpec", "HostNetworkConfigNetStackSpec", "vmodl.DynamicData", "vim.version.version9", [("netStackInstance", "vim.host.NetStackInstance", "vim.version.version9", 0), ("operation", "string", "vim.version.version9", F_OPTIONAL)]) +CreateManagedType("vim.host.NetworkSystem", "HostNetworkSystem", "vim.ExtensibleManagedObject", "vim.version.version1", [("capabilities", "vim.host.NetCapabilities", "vim.version.version1", F_OPTIONAL, None), ("networkInfo", "vim.host.NetworkInfo", "vim.version.version1", F_OPTIONAL, None), ("offloadCapabilities", "vim.host.NetOffloadCapabilities", "vim.version.version1", F_OPTIONAL, None), ("networkConfig", "vim.host.NetworkConfig", "vim.version.version1", F_OPTIONAL, None), ("dnsConfig", "vim.host.DnsConfig", "vim.version.version1", F_OPTIONAL, None), ("ipRouteConfig", "vim.host.IpRouteConfig", "vim.version.version1", F_OPTIONAL, None), ("consoleIpRouteConfig", "vim.host.IpRouteConfig", "vim.version.version1", F_OPTIONAL, None)], [("updateNetworkConfig", "UpdateNetworkConfig", "vim.version.version1", (("config", "vim.host.NetworkConfig", "vim.version.version1", 0, None),("changeMode", "string", "vim.version.version1", 0, None),), (0, "vim.host.NetworkConfig.Result", "vim.host.NetworkConfig.Result"), None, ["vim.fault.AlreadyExists", "vim.fault.NotFound", "vim.fault.HostConfigFault", "vim.fault.ResourceInUse", ]), ("updateDnsConfig", "UpdateDnsConfig", "vim.version.version1", (("config", "vim.host.DnsConfig", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Network", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("updateIpRouteConfig", "UpdateIpRouteConfig", "vim.version.version1", (("config", "vim.host.IpRouteConfig", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Network", ["vim.fault.HostConfigFault", "vim.fault.InvalidState", ]), ("updateConsoleIpRouteConfig", "UpdateConsoleIpRouteConfig", "vim.version.version1", (("config", "vim.host.IpRouteConfig", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Network", ["vim.fault.HostConfigFault", ]), ("updateIpRouteTableConfig", "UpdateIpRouteTableConfig", "vim.version.version5", (("config", "vim.host.IpRouteTableConfig", "vim.version.version5", 0, None),), (0, "void", "void"), "Host.Config.Network", ["vim.fault.HostConfigFault", ]), ("addVirtualSwitch", "AddVirtualSwitch", "vim.version.version1", (("vswitchName", "string", "vim.version.version1", 0, None),("spec", "vim.host.VirtualSwitch.Specification", "vim.version.version1", F_OPTIONAL, None),), (0, "void", "void"), "Host.Config.Network", ["vim.fault.AlreadyExists", "vim.fault.ResourceInUse", "vim.fault.HostConfigFault", ]), ("removeVirtualSwitch", "RemoveVirtualSwitch", "vim.version.version1", (("vswitchName", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Network", ["vim.fault.NotFound", "vim.fault.ResourceInUse", "vim.fault.HostConfigFault", ]), ("updateVirtualSwitch", "UpdateVirtualSwitch", "vim.version.version1", (("vswitchName", "string", "vim.version.version1", 0, None),("spec", "vim.host.VirtualSwitch.Specification", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Network", ["vim.fault.ResourceInUse", "vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("addPortGroup", "AddPortGroup", "vim.version.version1", (("portgrp", "vim.host.PortGroup.Specification", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Network", ["vim.fault.AlreadyExists", "vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("removePortGroup", "RemovePortGroup", "vim.version.version1", (("pgName", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Network", ["vim.fault.NotFound", "vim.fault.ResourceInUse", "vim.fault.HostConfigFault", ]), ("updatePortGroup", "UpdatePortGroup", "vim.version.version1", (("pgName", "string", "vim.version.version1", 0, None),("portgrp", "vim.host.PortGroup.Specification", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Network", ["vim.fault.AlreadyExists", "vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("updatePhysicalNicLinkSpeed", "UpdatePhysicalNicLinkSpeed", "vim.version.version1", (("device", "string", "vim.version.version1", 0, None),("linkSpeed", "vim.host.PhysicalNic.LinkSpeedDuplex", "vim.version.version1", F_OPTIONAL, None),), (0, "void", "void"), "Host.Config.Network", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("queryNetworkHint", "QueryNetworkHint", "vim.version.version1", (("device", "string[]", "vim.version.version1", F_OPTIONAL, None),), (F_OPTIONAL, "vim.host.PhysicalNic.NetworkHint[]", "vim.host.PhysicalNic.NetworkHint[]"), "System.Read", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("addVirtualNic", "AddVirtualNic", "vim.version.version1", (("portgroup", "string", "vim.version.version1", 0, None),("nic", "vim.host.VirtualNic.Specification", "vim.version.version1", 0, None),), (0, "string", "string"), None, ["vim.fault.AlreadyExists", "vim.fault.HostConfigFault", "vim.fault.InvalidState", ]), ("removeVirtualNic", "RemoveVirtualNic", "vim.version.version1", (("device", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Network", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("updateVirtualNic", "UpdateVirtualNic", "vim.version.version1", (("device", "string", "vim.version.version1", 0, None),("nic", "vim.host.VirtualNic.Specification", "vim.version.version1", 0, None),), (0, "void", "void"), None, ["vim.fault.NotFound", "vim.fault.HostConfigFault", "vim.fault.InvalidState", ]), ("addServiceConsoleVirtualNic", "AddServiceConsoleVirtualNic", "vim.version.version1", (("portgroup", "string", "vim.version.version1", 0, None),("nic", "vim.host.VirtualNic.Specification", "vim.version.version1", 0, None),), (0, "string", "string"), None, ["vim.fault.HostConfigFault", ]), ("removeServiceConsoleVirtualNic", "RemoveServiceConsoleVirtualNic", "vim.version.version1", (("device", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Network", ["vim.fault.NotFound", "vim.fault.ResourceInUse", "vim.fault.HostConfigFault", ]), ("updateServiceConsoleVirtualNic", "UpdateServiceConsoleVirtualNic", "vim.version.version1", (("device", "string", "vim.version.version1", 0, None),("nic", "vim.host.VirtualNic.Specification", "vim.version.version1", 0, None),), (0, "void", "void"), None, ["vim.fault.NotFound", "vim.fault.ResourceInUse", "vim.fault.HostConfigFault", ]), ("restartServiceConsoleVirtualNic", "RestartServiceConsoleVirtualNic", "vim.version.version1", (("device", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Network", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("refresh", "RefreshNetworkSystem", "vim.version.version1", (), (0, "void", "void"), "Host.Config.Network", None)]) +CreateDataType("vim.host.ScsiDisk", "HostScsiDisk", "vim.host.ScsiLun", "vim.version.version1", [("capacity", "vim.host.DiskDimensions.Lba", "vim.version.version1", 0), ("devicePath", "string", "vim.version.version1", 0), ("ssd", "boolean", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.host.ScsiDisk.Partition", "HostScsiDiskPartition", "vmodl.DynamicData", "vim.version.version1", [("diskName", "string", "vim.version.version1", 0), ("partition", "int", "vim.version.version1", 0)]) +CreateDataType("vim.host.SecuritySpec", "HostSecuritySpec", "vmodl.DynamicData", "vim.version.version5", [("adminPassword", "string", "vim.version.version5", F_OPTIONAL), ("removePermission", "vim.AuthorizationManager.Permission[]", "vim.version.version6", F_OPTIONAL), ("addPermission", "vim.AuthorizationManager.Permission[]", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.host.Summary", "HostListSummary", "vmodl.DynamicData", "vim.version.version1", [("host", "vim.HostSystem", "vim.version.version1", F_OPTIONAL), ("hardware", "vim.host.Summary.HardwareSummary", "vim.version.version1", F_OPTIONAL), ("runtime", "vim.host.RuntimeInfo", "vim.version.version1", F_OPTIONAL), ("config", "vim.host.Summary.ConfigSummary", "vim.version.version1", 0), ("quickStats", "vim.host.Summary.QuickStats", "vim.version.version1", 0), ("overallStatus", "vim.ManagedEntity.Status", "vim.version.version1", 0), ("rebootRequired", "boolean", "vim.version.version1", 0), ("customValue", "vim.CustomFieldsManager.Value[]", "vim.version.version1", F_OPTIONAL), ("managementServerIp", "string", "vim.version.version2", F_OPTIONAL), ("maxEVCModeKey", "string", "vim.version.version5", F_OPTIONAL), ("currentEVCModeKey", "string", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.Summary.HardwareSummary", "HostHardwareSummary", "vmodl.DynamicData", "vim.version.version1", [("vendor", "string", "vim.version.version1", 0), ("model", "string", "vim.version.version1", 0), ("uuid", "string", "vim.version.version1", 0), ("otherIdentifyingInfo", "vim.host.SystemIdentificationInfo[]", "vim.version.version2", F_OPTIONAL), ("memorySize", "long", "vim.version.version1", 0), ("cpuModel", "string", "vim.version.version1", 0), ("cpuMhz", "int", "vim.version.version1", 0), ("numCpuPkgs", "short", "vim.version.version1", 0), ("numCpuCores", "short", "vim.version.version1", 0), ("numCpuThreads", "short", "vim.version.version1", 0), ("numNics", "int", "vim.version.version1", 0), ("numHBAs", "int", "vim.version.version1", 0)]) +CreateDataType("vim.host.Summary.QuickStats", "HostListSummaryQuickStats", "vmodl.DynamicData", "vim.version.version1", [("overallCpuUsage", "int", "vim.version.version1", F_OPTIONAL), ("overallMemoryUsage", "int", "vim.version.version1", F_OPTIONAL), ("distributedCpuFairness", "int", "vim.version.version1", F_OPTIONAL), ("distributedMemoryFairness", "int", "vim.version.version1", F_OPTIONAL), ("uptime", "int", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.host.Summary.ConfigSummary", "HostConfigSummary", "vmodl.DynamicData", "vim.version.version1", [("name", "string", "vim.version.version1", 0), ("port", "int", "vim.version.version1", 0), ("sslThumbprint", "string", "vim.version.version5", F_OPTIONAL), ("product", "vim.AboutInfo", "vim.version.version1", F_OPTIONAL), ("vmotionEnabled", "boolean", "vim.version.version1", 0), ("faultToleranceEnabled", "boolean", "vim.version.version5", 0), ("featureVersion", "vim.host.FeatureVersionInfo[]", "vim.version.version6", F_OPTIONAL), ("agentVmDatastore", "vim.Datastore", "vim.version.version7", F_OPTIONAL), ("agentVmNetwork", "vim.Network", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.host.TpmBootSecurityOptionEventDetails", "HostTpmBootSecurityOptionEventDetails", "vim.host.TpmEventDetails", "vim.version.version8", [("bootSecurityOption", "string", "vim.version.version8", 0)]) +CreateDataType("vim.host.TpmCommandEventDetails", "HostTpmCommandEventDetails", "vim.host.TpmEventDetails", "vim.version.version8", [("commandLine", "string", "vim.version.version8", 0)]) +CreateDataType("vim.host.UnresolvedVmfsExtent", "HostUnresolvedVmfsExtent", "vmodl.DynamicData", "vim.version.version5", [("device", "vim.host.ScsiDisk.Partition", "vim.version.version5", 0), ("devicePath", "string", "vim.version.version5", 0), ("vmfsUuid", "string", "vim.version.version5", 0), ("isHeadExtent", "boolean", "vim.version.version5", 0), ("ordinal", "int", "vim.version.version5", 0), ("startBlock", "int", "vim.version.version5", 0), ("endBlock", "int", "vim.version.version5", 0), ("reason", "string", "vim.version.version5", 0)]) +CreateEnumType("vim.host.UnresolvedVmfsExtent.UnresolvedReason", "HostUnresolvedVmfsExtentUnresolvedReason", "vim.version.version5", ["diskIdMismatch", "uuidConflict"]) +CreateManagedType("vim.host.VFlashManager", "HostVFlashManager", "vmodl.ManagedObject", "vim.version.version9", [("vFlashConfigInfo", "vim.host.VFlashManager.VFlashConfigInfo", "vim.version.version9", F_OPTIONAL, None)], [("configureVFlashResourceEx", "ConfigureVFlashResourceEx_Task", "vim.version.version9", (("devicePath", "string[]", "vim.version.version9", F_OPTIONAL, None),), (F_OPTIONAL, "vim.Task", "vim.host.VFlashResourceConfigurationResult"), "Host.Config.Storage", ["vim.fault.HostConfigFault", ]), ("configureVFlashResource", "HostConfigureVFlashResource", "vim.version.version9", (("spec", "vim.host.VFlashManager.VFlashResourceConfigSpec", "vim.version.version9", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.HostConfigFault", "vim.fault.ResourceInUse", ]), ("removeVFlashResource", "HostRemoveVFlashResource", "vim.version.version9", (), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", "vim.fault.ResourceInUse", ]), ("configureHostVFlashCache", "HostConfigVFlashCache", "vim.version.version9", (("spec", "vim.host.VFlashManager.VFlashCacheConfigSpec", "vim.version.version9", 0, None),), (0, "void", "void"), "Host.Config.AdvancedConfig", ["vim.fault.HostConfigFault", "vim.fault.InaccessibleVFlashSource", "vim.fault.ResourceInUse", ]), ("getVFlashModuleDefaultConfig", "HostGetVFlashModuleDefaultConfig", "vim.version.version9", (("vFlashModule", "string", "vim.version.version9", 0, None),), (0, "vim.vm.device.VirtualDisk.VFlashCacheConfigInfo", "vim.vm.device.VirtualDisk.VFlashCacheConfigInfo"), "Host.Config.AdvancedConfig", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ])]) +CreateDataType("vim.host.VFlashManager.VFlashResourceConfigSpec", "HostVFlashManagerVFlashResourceConfigSpec", "vmodl.DynamicData", "vim.version.version9", [("vffsUuid", "string", "vim.version.version9", 0)]) +CreateDataType("vim.host.VFlashManager.VFlashResourceConfigInfo", "HostVFlashManagerVFlashResourceConfigInfo", "vmodl.DynamicData", "vim.version.version9", [("vffs", "vim.host.VffsVolume", "vim.version.version9", F_OPTIONAL), ("capacity", "long", "vim.version.version9", 0)]) +CreateDataType("vim.host.VFlashManager.VFlashResourceRunTimeInfo", "HostVFlashManagerVFlashResourceRunTimeInfo", "vmodl.DynamicData", "vim.version.version9", [("usage", "long", "vim.version.version9", 0), ("capacity", "long", "vim.version.version9", 0), ("accessible", "boolean", "vim.version.version9", 0), ("capacityForVmCache", "long", "vim.version.version9", 0), ("freeForVmCache", "long", "vim.version.version9", 0)]) +CreateDataType("vim.host.VFlashManager.VFlashCacheConfigSpec", "HostVFlashManagerVFlashCacheConfigSpec", "vmodl.DynamicData", "vim.version.version9", [("defaultVFlashModule", "string", "vim.version.version9", 0), ("swapCacheReservationInGB", "long", "vim.version.version9", 0)]) +CreateDataType("vim.host.VFlashManager.VFlashCacheConfigInfo", "HostVFlashManagerVFlashCacheConfigInfo", "vmodl.DynamicData", "vim.version.version9", [("vFlashModuleConfigOption", "vim.host.VFlashManager.VFlashCacheConfigInfo.VFlashModuleConfigOption[]", "vim.version.version9", F_OPTIONAL), ("defaultVFlashModule", "string", "vim.version.version9", F_OPTIONAL), ("swapCacheReservationInGB", "long", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.host.VFlashManager.VFlashCacheConfigInfo.VFlashModuleConfigOption", "HostVFlashManagerVFlashCacheConfigInfoVFlashModuleConfigOption", "vmodl.DynamicData", "vim.version.version9", [("vFlashModule", "string", "vim.version.version9", 0), ("vFlashModuleVersion", "string", "vim.version.version9", 0), ("minSupportedModuleVersion", "string", "vim.version.version9", 0), ("cacheConsistencyType", "vim.option.ChoiceOption", "vim.version.version9", 0), ("cacheMode", "vim.option.ChoiceOption", "vim.version.version9", 0), ("blockSizeInKBOption", "vim.option.LongOption", "vim.version.version9", 0), ("reservationInMBOption", "vim.option.LongOption", "vim.version.version9", 0), ("maxDiskSizeInKB", "long", "vim.version.version9", 0)]) +CreateDataType("vim.host.VFlashManager.VFlashConfigInfo", "HostVFlashManagerVFlashConfigInfo", "vmodl.DynamicData", "vim.version.version9", [("vFlashResourceConfigInfo", "vim.host.VFlashManager.VFlashResourceConfigInfo", "vim.version.version9", F_OPTIONAL), ("vFlashCacheConfigInfo", "vim.host.VFlashManager.VFlashCacheConfigInfo", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.host.VMotionInfo", "HostVMotionInfo", "vmodl.DynamicData", "vim.version.version1", [("netConfig", "vim.host.VMotionSystem.NetConfig", "vim.version.version1", F_OPTIONAL), ("ipConfig", "vim.host.IpConfig", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.VffsVolume", "HostVffsVolume", "vim.host.FileSystemVolume", "vim.version.version9", [("majorVersion", "int", "vim.version.version9", 0), ("version", "string", "vim.version.version9", 0), ("uuid", "string", "vim.version.version9", 0), ("extent", "vim.host.ScsiDisk.Partition[]", "vim.version.version9", 0)]) +CreateDataType("vim.host.VffsVolume.Specification", "HostVffsSpec", "vmodl.DynamicData", "vim.version.version9", [("devicePath", "string", "vim.version.version9", 0), ("partition", "vim.host.DiskPartitionInfo.Specification", "vim.version.version9", F_OPTIONAL), ("majorVersion", "int", "vim.version.version9", 0), ("volumeName", "string", "vim.version.version9", 0)]) +CreateDataType("vim.host.VmfsVolume", "HostVmfsVolume", "vim.host.FileSystemVolume", "vim.version.version1", [("blockSizeMb", "int", "vim.version.version1", 0), ("maxBlocks", "int", "vim.version.version1", 0), ("majorVersion", "int", "vim.version.version1", 0), ("version", "string", "vim.version.version1", 0), ("uuid", "string", "vim.version.version1", 0), ("extent", "vim.host.ScsiDisk.Partition[]", "vim.version.version1", 0), ("vmfsUpgradable", "boolean", "vim.version.version1", 0), ("forceMountedInfo", "vim.host.ForceMountedInfo", "vim.version.version5", F_OPTIONAL), ("ssd", "boolean", "vim.version.version7", F_OPTIONAL), ("local", "boolean", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.host.VmfsVolume.Specification", "HostVmfsSpec", "vmodl.DynamicData", "vim.version.version1", [("extent", "vim.host.ScsiDisk.Partition", "vim.version.version1", 0), ("blockSizeMb", "int", "vim.version.version1", F_OPTIONAL), ("majorVersion", "int", "vim.version.version1", 0), ("volumeName", "string", "vim.version.version1", 0)]) +CreateDataType("vim.option.BoolOption", "BoolOption", "vim.option.OptionType", "vim.version.version1", [("supported", "boolean", "vim.version.version1", 0), ("defaultValue", "boolean", "vim.version.version1", 0)]) +CreateDataType("vim.option.ChoiceOption", "ChoiceOption", "vim.option.OptionType", "vim.version.version1", [("choiceInfo", "vim.ElementDescription[]", "vim.version.version1", 0), ("defaultIndex", "int", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.option.FloatOption", "FloatOption", "vim.option.OptionType", "vim.version.version1", [("min", "float", "vim.version.version1", 0), ("max", "float", "vim.version.version1", 0), ("defaultValue", "float", "vim.version.version1", 0)]) +CreateDataType("vim.option.IntOption", "IntOption", "vim.option.OptionType", "vim.version.version1", [("min", "int", "vim.version.version1", 0), ("max", "int", "vim.version.version1", 0), ("defaultValue", "int", "vim.version.version1", 0)]) +CreateDataType("vim.option.LongOption", "LongOption", "vim.option.OptionType", "vim.version.version1", [("min", "long", "vim.version.version1", 0), ("max", "long", "vim.version.version1", 0), ("defaultValue", "long", "vim.version.version1", 0)]) +CreateManagedType("vim.profile.host.ProfileManager", "HostProfileManager", "vim.profile.ProfileManager", "vim.version.version5", None, [("applyHostConfiguration", "ApplyHostConfig_Task", "vim.version.version5", (("host", "vim.HostSystem", "vim.version.version5", 0, None),("configSpec", "vim.host.ConfigSpec", "vim.version.version5", 0, None),("userInput", "vim.profile.DeferredPolicyOptionParameter[]", "vim.version.version7", F_OPTIONAL, None),), (0, "vim.Task", "void"), None, ["vim.fault.InvalidState", "vim.fault.HostConfigFailed", ]), ("generateConfigTaskList", "GenerateConfigTaskList", "vim.version.version5", (("configSpec", "vim.host.ConfigSpec", "vim.version.version5", 0, None),("host", "vim.HostSystem", "vim.version.version5", 0, None),), (0, "vim.profile.host.ProfileManager.ConfigTaskList", "vim.profile.host.ProfileManager.ConfigTaskList"), "System.View", None), ("generateTaskList", "GenerateHostProfileTaskList_Task", "vim.version.version9", (("configSpec", "vim.host.ConfigSpec", "vim.version.version9", 0, None),("host", "vim.HostSystem", "vim.version.version9", 0, None),), (F_OPTIONAL, "vim.Task", "vim.profile.host.ProfileManager.ConfigTaskList"), "System.View", None), ("queryProfileMetadata", "QueryHostProfileMetadata", "vim.version.version5", (("profileName", "vmodl.TypeName[]", "vim.version.version5", F_OPTIONAL, None),("profile", "vim.profile.Profile", "vim.version.version7", F_OPTIONAL, None),), (F_OPTIONAL, "vim.profile.ProfileMetadata[]", "vim.profile.ProfileMetadata[]"), "System.View", None), ("queryProfileStructure", "QueryProfileStructure", "vim.version.version7", (("profile", "vim.profile.Profile", "vim.version.version7", F_OPTIONAL, None),), (0, "vim.profile.ProfileStructure", "vim.profile.ProfileStructure"), "System.View", None), ("createDefaultProfile", "CreateDefaultProfile", "vim.version.version5", (("profileType", "vmodl.TypeName", "vim.version.version5", 0, None),("profileTypeName", "string", "vim.version.version7", F_OPTIONAL, None),("profile", "vim.profile.Profile", "vim.version.version7", F_OPTIONAL, None),), (0, "vim.profile.ApplyProfile", "vim.profile.ApplyProfile"), "System.View", None), ("updateAnswerFile", "UpdateAnswerFile_Task", "vim.version.version7", (("host", "vim.HostSystem", "vim.version.version7", 0, None),("configSpec", "vim.profile.host.ProfileManager.AnswerFileCreateSpec", "vim.version.version7", 0, None),), (0, "vim.Task", "void"), "Profile.Edit", ["vim.fault.AnswerFileUpdateFailed", ]), ("retrieveAnswerFile", "RetrieveAnswerFile", "vim.version.version7", (("host", "vim.HostSystem", "vim.version.version7", 0, "Profile.Edit"),), (F_OPTIONAL, "vim.profile.host.AnswerFile", "vim.profile.host.AnswerFile"), None, None), ("retrieveAnswerFileForProfile", "RetrieveAnswerFileForProfile", "vim.version.version8", (("host", "vim.HostSystem", "vim.version.version8", 0, "Profile.Edit"),("applyProfile", "vim.profile.host.HostApplyProfile", "vim.version.version8", 0, None),), (F_OPTIONAL, "vim.profile.host.AnswerFile", "vim.profile.host.AnswerFile"), None, None), ("exportAnswerFile", "ExportAnswerFile_Task", "vim.version.version7", (("host", "vim.HostSystem", "vim.version.version7", 0, None),), (0, "vim.Task", "string"), "Profile.Export", None), ("checkAnswerFileStatus", "CheckAnswerFileStatus_Task", "vim.version.version7", (("host", "vim.HostSystem[]", "vim.version.version7", 0, None),), (F_OPTIONAL, "vim.Task", "vim.profile.host.AnswerFileStatusResult[]"), "System.View", None), ("queryAnswerFileStatus", "QueryAnswerFileStatus", "vim.version.version7", (("host", "vim.HostSystem[]", "vim.version.version7", 0, None),), (F_OPTIONAL, "vim.profile.host.AnswerFileStatusResult[]", "vim.profile.host.AnswerFileStatusResult[]"), "System.View", None)]) +CreateDataType("vim.profile.host.ProfileManager.ConfigTaskList", "HostProfileManagerConfigTaskList", "vmodl.DynamicData", "vim.version.version5", [("configSpec", "vim.host.ConfigSpec", "vim.version.version5", F_OPTIONAL), ("taskDescription", "vmodl.LocalizableMessage[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.profile.host.ProfileManager.AnswerFileCreateSpec", "AnswerFileCreateSpec", "vmodl.DynamicData", "vim.version.version7", None) +CreateDataType("vim.profile.host.ProfileManager.AnswerFileOptionsCreateSpec", "AnswerFileOptionsCreateSpec", "vim.profile.host.ProfileManager.AnswerFileCreateSpec", "vim.version.version7", [("userInput", "vim.profile.DeferredPolicyOptionParameter[]", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.profile.host.ProfileManager.AnswerFileSerializedCreateSpec", "AnswerFileSerializedCreateSpec", "vim.profile.host.ProfileManager.AnswerFileCreateSpec", "vim.version.version7", [("answerFileConfigString", "string", "vim.version.version7", 0)]) +CreateEnumType("vim.profile.host.ProfileManager.AnswerFileValidationResult.Status", "AnswerFileValidationResultStatus", "vim.version.version8", ["success", "needInput", "error"]) +CreateEnumType("vim.profile.host.ProfileManager.AnswerFileStatus", "HostProfileManagerAnswerFileStatus", "vim.version.version7", ["valid", "invalid", "unknown"]) +CreateDataType("vim.scheduler.ScheduledTaskInfo", "ScheduledTaskInfo", "vim.scheduler.ScheduledTaskSpec", "vim.version.version1", [("scheduledTask", "vim.scheduler.ScheduledTask", "vim.version.version1", 0), ("entity", "vim.ManagedEntity", "vim.version.version1", 0), ("lastModifiedTime", "vmodl.DateTime", "vim.version.version1", 0), ("lastModifiedUser", "string", "vim.version.version1", 0), ("nextRunTime", "vmodl.DateTime", "vim.version.version1", F_OPTIONAL), ("prevRunTime", "vmodl.DateTime", "vim.version.version1", F_OPTIONAL), ("state", "vim.TaskInfo.State", "vim.version.version1", 0), ("error", "vmodl.MethodFault", "vim.version.version1", F_OPTIONAL), ("result", "anyType", "vim.version.version1", F_OPTIONAL), ("progress", "int", "vim.version.version1", F_OPTIONAL), ("activeTask", "vim.Task", "vim.version.version1", F_OPTIONAL), ("taskObject", "vmodl.ManagedObject", "vim.version.version5", 0)]) +CreateDataType("vim.storageDrs.PodSelectionSpec", "StorageDrsPodSelectionSpec", "vmodl.DynamicData", "vim.version.version7", [("initialVmConfig", "vim.storageDrs.PodSelectionSpec.VmPodConfig[]", "vim.version.version7", F_OPTIONAL), ("storagePod", "vim.StoragePod", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.storageDrs.PodSelectionSpec.VmPodConfig", "VmPodConfigForPlacement", "vmodl.DynamicData", "vim.version.version7", [("storagePod", "vim.StoragePod", "vim.version.version7", 0), ("disk", "vim.storageDrs.PodSelectionSpec.DiskLocator[]", "vim.version.version7", F_OPTIONAL), ("vmConfig", "vim.storageDrs.VmConfigInfo", "vim.version.version7", F_OPTIONAL), ("interVmRule", "vim.cluster.RuleInfo[]", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.storageDrs.PodSelectionSpec.DiskLocator", "PodDiskLocator", "vmodl.DynamicData", "vim.version.version7", [("diskId", "int", "vim.version.version7", 0), ("diskMoveType", "string", "vim.version.version7", F_OPTIONAL), ("diskBackingInfo", "vim.vm.device.VirtualDevice.BackingInfo", "vim.version.version7", F_OPTIONAL), ("profile", "vim.vm.ProfileSpec[]", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.storageDrs.StoragePlacementSpec", "StoragePlacementSpec", "vmodl.DynamicData", "vim.version.version7", [("type", "string", "vim.version.version7", 0), ("priority", "vim.VirtualMachine.MovePriority", "vim.version.version7", F_OPTIONAL), ("vm", "vim.VirtualMachine", "vim.version.version7", F_OPTIONAL), ("podSelectionSpec", "vim.storageDrs.PodSelectionSpec", "vim.version.version7", 0), ("cloneSpec", "vim.vm.CloneSpec", "vim.version.version7", F_OPTIONAL), ("cloneName", "string", "vim.version.version7", F_OPTIONAL), ("configSpec", "vim.vm.ConfigSpec", "vim.version.version7", F_OPTIONAL), ("relocateSpec", "vim.vm.RelocateSpec", "vim.version.version7", F_OPTIONAL), ("resourcePool", "vim.ResourcePool", "vim.version.version7", F_OPTIONAL), ("host", "vim.HostSystem", "vim.version.version7", F_OPTIONAL), ("folder", "vim.Folder", "vim.version.version7", F_OPTIONAL), ("disallowPrerequisiteMoves", "boolean", "vim.version.version8", F_OPTIONAL), ("resourceLeaseDurationSec", "int", "vim.version.version8", F_OPTIONAL)]) +CreateEnumType("vim.storageDrs.StoragePlacementSpec.PlacementType", "StoragePlacementSpecPlacementType", "vim.version.version7", ["create", "reconfigure", "relocate", "clone"]) +CreateDataType("vim.storageDrs.VirtualDiskAntiAffinityRuleSpec", "VirtualDiskAntiAffinityRuleSpec", "vim.cluster.RuleInfo", "vim.version.version7", [("diskId", "int[]", "vim.version.version7", 0)]) +CreateDataType("vim.vApp.VAppConfigInfo", "VAppConfigInfo", "vim.vApp.VmConfigInfo", "vim.version.version5", [("entityConfig", "vim.vApp.EntityConfigInfo[]", "vim.version.version5", F_OPTIONAL), ("annotation", "string", "vim.version.version5", 0), ("instanceUuid", "string", "vim.version.version6", F_OPTIONAL), ("managedBy", "vim.ext.ManagedByInfo", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.vApp.VAppConfigSpec", "VAppConfigSpec", "vim.vApp.VmConfigSpec", "vim.version.version5", [("entityConfig", "vim.vApp.EntityConfigInfo[]", "vim.version.version5", F_OPTIONAL), ("annotation", "string", "vim.version.version5", F_OPTIONAL), ("instanceUuid", "string", "vim.version.version6", F_OPTIONAL), ("managedBy", "vim.ext.ManagedByInfo", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.vApp.VAppImportSpec", "VirtualAppImportSpec", "vim.ImportSpec", "vim.version.version5", [("name", "string", "vim.version.version5", 0), ("vAppConfigSpec", "vim.vApp.VAppConfigSpec", "vim.version.version5", 0), ("resourcePoolSpec", "vim.ResourceConfigSpec", "vim.version.version5", 0), ("child", "vim.ImportSpec[]", "vim.version.version5", F_OPTIONAL)]) +CreateManagedType("vim.view.ManagedObjectView", "ManagedObjectView", "vim.view.View", "vim.version.version2", [("view", "vmodl.ManagedObject[]", "vim.version.version2", F_OPTIONAL, None)], None) +CreateDataType("vim.vm.CdromInfo", "VirtualMachineCdromInfo", "vim.vm.TargetInfo", "vim.version.version1", None) +CreateDataType("vim.vm.ConfigTarget", "ConfigTarget", "vmodl.DynamicData", "vim.version.version1", [("numCpus", "int", "vim.version.version1", 0), ("numCpuCores", "int", "vim.version.version1", 0), ("numNumaNodes", "int", "vim.version.version1", 0), ("smcPresent", "boolean", "vim.version.version7", 0), ("datastore", "vim.vm.DatastoreInfo[]", "vim.version.version1", F_OPTIONAL), ("network", "vim.vm.NetworkInfo[]", "vim.version.version1", F_OPTIONAL), ("opaqueNetwork", "vim.vm.OpaqueNetworkInfo[]", "vim.version.version9", F_OPTIONAL), ("distributedVirtualPortgroup", "vim.dvs.DistributedVirtualPortgroupInfo[]", "vim.version.version5", F_OPTIONAL), ("distributedVirtualSwitch", "vim.dvs.DistributedVirtualSwitchInfo[]", "vim.version.version5", F_OPTIONAL), ("cdRom", "vim.vm.CdromInfo[]", "vim.version.version1", F_OPTIONAL), ("serial", "vim.vm.SerialInfo[]", "vim.version.version1", F_OPTIONAL), ("parallel", "vim.vm.ParallelInfo[]", "vim.version.version1", F_OPTIONAL), ("sound", "vim.vm.SoundInfo[]", "vim.version.version2", F_OPTIONAL), ("usb", "vim.vm.UsbInfo[]", "vim.version.version2", F_OPTIONAL), ("floppy", "vim.vm.FloppyInfo[]", "vim.version.version1", F_OPTIONAL), ("legacyNetworkInfo", "vim.vm.LegacyNetworkSwitchInfo[]", "vim.version.version1", F_OPTIONAL), ("scsiPassthrough", "vim.vm.ScsiPassthroughInfo[]", "vim.version.version1", F_OPTIONAL), ("scsiDisk", "vim.vm.ScsiDiskDeviceInfo[]", "vim.version.version1", F_OPTIONAL), ("ideDisk", "vim.vm.IdeDiskDeviceInfo[]", "vim.version.version1", F_OPTIONAL), ("maxMemMBOptimalPerf", "int", "vim.version.version1", 0), ("resourcePool", "vim.ResourcePool.RuntimeInfo", "vim.version.version1", F_OPTIONAL), ("autoVmotion", "boolean", "vim.version.version1", F_OPTIONAL), ("pciPassthrough", "vim.vm.PciPassthroughInfo[]", "vim.version.version5", F_OPTIONAL), ("sriov", "vim.vm.SriovInfo[]", "vim.version.version9", F_OPTIONAL), ("vFlashModule", "vim.vm.VFlashModuleInfo[]", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.vm.DefinedProfileSpec", "VirtualMachineDefinedProfileSpec", "vim.vm.ProfileSpec", "vim.version.version9", [("profileId", "string", "vim.version.version9", 0), ("profileData", "vim.vm.ProfileRawData", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.vm.DiskDeviceInfo", "VirtualMachineDiskDeviceInfo", "vim.vm.TargetInfo", "vim.version.version1", [("capacity", "long", "vim.version.version1", F_OPTIONAL), ("vm", "vim.VirtualMachine[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.vm.EmptyProfileSpec", "VirtualMachineEmptyProfileSpec", "vim.vm.ProfileSpec", "vim.version.version9", None) +CreateDataType("vim.vm.FloppyInfo", "VirtualMachineFloppyInfo", "vim.vm.TargetInfo", "vim.version.version1", None) +CreateDataType("vim.vm.IdeDiskDeviceInfo", "VirtualMachineIdeDiskDeviceInfo", "vim.vm.DiskDeviceInfo", "vim.version.version1", [("partitionTable", "vim.vm.IdeDiskDeviceInfo.PartitionInfo[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.vm.IdeDiskDeviceInfo.PartitionInfo", "VirtualMachineIdeDiskDevicePartitionInfo", "vmodl.DynamicData", "vim.version.version1", [("id", "int", "vim.version.version1", 0), ("capacity", "int", "vim.version.version1", 0)]) +CreateDataType("vim.vm.NetworkInfo", "VirtualMachineNetworkInfo", "vim.vm.TargetInfo", "vim.version.version1", [("network", "vim.Network.Summary", "vim.version.version1", 0)]) +CreateDataType("vim.vm.OpaqueNetworkInfo", "OpaqueNetworkTargetInfo", "vim.vm.TargetInfo", "vim.version.version9", [("network", "vim.OpaqueNetwork.Summary", "vim.version.version9", 0)]) +CreateDataType("vim.vm.ParallelInfo", "VirtualMachineParallelInfo", "vim.vm.TargetInfo", "vim.version.version1", None) +CreateDataType("vim.vm.PciPassthroughInfo", "VirtualMachinePciPassthroughInfo", "vim.vm.TargetInfo", "vim.version.version5", [("pciDevice", "vim.host.PciDevice", "vim.version.version5", 0), ("systemId", "string", "vim.version.version5", 0)]) +CreateDataType("vim.vm.RelocateSpec", "VirtualMachineRelocateSpec", "vmodl.DynamicData", "vim.version.version1", [("datastore", "vim.Datastore", "vim.version.version1", F_OPTIONAL), ("diskMoveType", "string", "vim.version.version5", F_OPTIONAL), ("pool", "vim.ResourcePool", "vim.version.version1", F_OPTIONAL), ("host", "vim.HostSystem", "vim.version.version1", F_OPTIONAL), ("disk", "vim.vm.RelocateSpec.DiskLocator[]", "vim.version.version1", F_OPTIONAL), ("transform", "vim.vm.RelocateSpec.Transformation", "vim.version.version1", F_OPTIONAL), ("deviceChange", "vim.vm.device.VirtualDeviceSpec[]", "vim.version.version9", F_OPTIONAL), ("profile", "vim.vm.ProfileSpec[]", "vim.version.version9", F_OPTIONAL)]) +CreateEnumType("vim.vm.RelocateSpec.Transformation", "VirtualMachineRelocateTransformation", "vim.version.version1", ["flat", "sparse"]) +CreateDataType("vim.vm.RelocateSpec.DiskLocator", "VirtualMachineRelocateSpecDiskLocator", "vmodl.DynamicData", "vim.version.version1", [("diskId", "int", "vim.version.version1", 0), ("datastore", "vim.Datastore", "vim.version.version1", 0), ("diskMoveType", "string", "vim.version.version5", F_OPTIONAL), ("diskBackingInfo", "vim.vm.device.VirtualDevice.BackingInfo", "vim.version.version7", F_OPTIONAL), ("profile", "vim.vm.ProfileSpec[]", "vim.version.version9", F_OPTIONAL)]) +CreateEnumType("vim.vm.RelocateSpec.DiskMoveOptions", "VirtualMachineRelocateDiskMoveOptions", "vim.version.version5", ["moveAllDiskBackingsAndAllowSharing", "moveAllDiskBackingsAndDisallowSharing", "moveChildMostDiskBacking", "createNewChildDiskBacking", "moveAllDiskBackingsAndConsolidate"]) +CreateDataType("vim.vm.RuntimeInfo", "VirtualMachineRuntimeInfo", "vmodl.DynamicData", "vim.version.version1", [("device", "vim.vm.DeviceRuntimeInfo[]", "vim.version.version6", F_OPTIONAL), ("host", "vim.HostSystem", "vim.version.version1", F_OPTIONAL), ("connectionState", "vim.VirtualMachine.ConnectionState", "vim.version.version1", 0), ("powerState", "vim.VirtualMachine.PowerState", "vim.version.version1", 0), ("faultToleranceState", "vim.VirtualMachine.FaultToleranceState", "vim.version.version5", 0), ("dasVmProtection", "vim.vm.RuntimeInfo.DasProtectionState", "vim.version.version7", F_OPTIONAL), ("toolsInstallerMounted", "boolean", "vim.version.version1", 0), ("suspendTime", "vmodl.DateTime", "vim.version.version1", F_OPTIONAL), ("bootTime", "vmodl.DateTime", "vim.version.version1", F_OPTIONAL), ("suspendInterval", "long", "vim.version.version1", F_OPTIONAL), ("question", "vim.vm.QuestionInfo", "vim.version.version1", F_OPTIONAL), ("memoryOverhead", "long", "vim.version.version1", F_OPTIONAL), ("maxCpuUsage", "int", "vim.version.version1", F_OPTIONAL), ("maxMemoryUsage", "int", "vim.version.version1", F_OPTIONAL), ("numMksConnections", "int", "vim.version.version1", 0), ("recordReplayState", "vim.VirtualMachine.RecordReplayState", "vim.version.version5", 0), ("cleanPowerOff", "boolean", "vim.version.version5", F_OPTIONAL), ("needSecondaryReason", "string", "vim.version.version5", F_OPTIONAL), ("onlineStandby", "boolean", "vim.version.version8", 0), ("minRequiredEVCModeKey", "string", "vim.version.version6", F_OPTIONAL), ("consolidationNeeded", "boolean", "vim.version.version7", 0), ("offlineFeatureRequirement", "vim.vm.FeatureRequirement[]", "vim.version.version8", F_OPTIONAL), ("featureRequirement", "vim.vm.FeatureRequirement[]", "vim.version.version8", F_OPTIONAL), ("featureMask", "vim.host.FeatureMask[]", "vim.version.version8", F_OPTIONAL), ("vFlashCacheAllocation", "long", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.vm.RuntimeInfo.DasProtectionState", "VirtualMachineRuntimeInfoDasProtectionState", "vmodl.DynamicData", "vim.version.version7", [("dasProtected", "boolean", "vim.version.version7", 0)]) +CreateDataType("vim.vm.ScsiDiskDeviceInfo", "VirtualMachineScsiDiskDeviceInfo", "vim.vm.DiskDeviceInfo", "vim.version.version1", [("disk", "vim.host.ScsiDisk", "vim.version.version1", F_OPTIONAL), ("transportHint", "string", "vim.version.version5", F_OPTIONAL), ("lunNumber", "int", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.vm.ScsiPassthroughInfo", "VirtualMachineScsiPassthroughInfo", "vim.vm.TargetInfo", "vim.version.version1", [("scsiClass", "string", "vim.version.version1", 0), ("vendor", "string", "vim.version.version1", 0), ("physicalUnitNumber", "int", "vim.version.version1", 0)]) +CreateEnumType("vim.vm.ScsiPassthroughInfo.ScsiClass", "VirtualMachineScsiPassthroughType", "vim.version.version1", ["disk", "tape", "printer", "processor", "worm", "cdrom", "scanner", "optical", "media", "com", "raid", "unknown"]) +CreateDataType("vim.vm.SerialInfo", "VirtualMachineSerialInfo", "vim.vm.TargetInfo", "vim.version.version1", None) +CreateDataType("vim.vm.SnapshotTree", "VirtualMachineSnapshotTree", "vmodl.DynamicData", "vim.version.version1", [("snapshot", "vim.vm.Snapshot", "vim.version.version1", 0), ("vm", "vim.VirtualMachine", "vim.version.version1", 0), ("name", "string", "vim.version.version1", 0), ("description", "string", "vim.version.version1", 0), ("id", "int", "vim.version.version5", 0), ("createTime", "vmodl.DateTime", "vim.version.version1", 0), ("state", "vim.VirtualMachine.PowerState", "vim.version.version1", 0), ("quiesced", "boolean", "vim.version.version1", 0), ("backupManifest", "string", "vim.version.version4", F_OPTIONAL), ("childSnapshotList", "vim.vm.SnapshotTree[]", "vim.version.version1", F_OPTIONAL), ("replaySupported", "boolean", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.vm.SoundInfo", "VirtualMachineSoundInfo", "vim.vm.TargetInfo", "vim.version.version2", None) +CreateDataType("vim.vm.SriovInfo", "VirtualMachineSriovInfo", "vim.vm.PciPassthroughInfo", "vim.version.version9", [("virtualFunction", "boolean", "vim.version.version9", 0), ("pnic", "string", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.vm.Summary", "VirtualMachineSummary", "vmodl.DynamicData", "vim.version.version1", [("vm", "vim.VirtualMachine", "vim.version.version1", F_OPTIONAL), ("runtime", "vim.vm.RuntimeInfo", "vim.version.version1", 0), ("guest", "vim.vm.Summary.GuestSummary", "vim.version.version1", F_OPTIONAL), ("config", "vim.vm.Summary.ConfigSummary", "vim.version.version1", 0), ("storage", "vim.vm.Summary.StorageSummary", "vim.version.version5", F_OPTIONAL), ("quickStats", "vim.vm.Summary.QuickStats", "vim.version.version1", 0), ("overallStatus", "vim.ManagedEntity.Status", "vim.version.version1", 0), ("customValue", "vim.CustomFieldsManager.Value[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.vm.Summary.ConfigSummary", "VirtualMachineConfigSummary", "vmodl.DynamicData", "vim.version.version1", [("name", "string", "vim.version.version1", 0), ("template", "boolean", "vim.version.version1", 0), ("vmPathName", "string", "vim.version.version1", 0), ("memorySizeMB", "int", "vim.version.version1", F_OPTIONAL), ("cpuReservation", "int", "vim.version.version1", F_OPTIONAL), ("memoryReservation", "int", "vim.version.version1", F_OPTIONAL), ("numCpu", "int", "vim.version.version1", F_OPTIONAL), ("numEthernetCards", "int", "vim.version.version1", F_OPTIONAL), ("numVirtualDisks", "int", "vim.version.version1", F_OPTIONAL), ("uuid", "string", "vim.version.version1", F_OPTIONAL), ("instanceUuid", "string", "vim.version.version5", F_OPTIONAL), ("guestId", "string", "vim.version.version1", F_OPTIONAL), ("guestFullName", "string", "vim.version.version1", F_OPTIONAL), ("annotation", "string", "vim.version.version1", F_OPTIONAL), ("product", "vim.vApp.ProductInfo", "vim.version.version5", F_OPTIONAL), ("installBootRequired", "boolean", "vim.version.version5", F_OPTIONAL), ("ftInfo", "vim.vm.FaultToleranceConfigInfo", "vim.version.version5", F_OPTIONAL), ("managedBy", "vim.ext.ManagedByInfo", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.vm.Summary.QuickStats", "VirtualMachineQuickStats", "vmodl.DynamicData", "vim.version.version1", [("overallCpuUsage", "int", "vim.version.version1", F_OPTIONAL), ("overallCpuDemand", "int", "vim.version.version5", F_OPTIONAL), ("guestMemoryUsage", "int", "vim.version.version1", F_OPTIONAL), ("hostMemoryUsage", "int", "vim.version.version1", F_OPTIONAL), ("guestHeartbeatStatus", "vim.ManagedEntity.Status", "vim.version.version1", 0), ("distributedCpuEntitlement", "int", "vim.version.version1", F_OPTIONAL), ("distributedMemoryEntitlement", "int", "vim.version.version1", F_OPTIONAL), ("staticCpuEntitlement", "int", "vim.version.version5", F_OPTIONAL), ("staticMemoryEntitlement", "int", "vim.version.version5", F_OPTIONAL), ("privateMemory", "int", "vim.version.version5", F_OPTIONAL), ("sharedMemory", "int", "vim.version.version5", F_OPTIONAL), ("swappedMemory", "int", "vim.version.version5", F_OPTIONAL), ("balloonedMemory", "int", "vim.version.version5", F_OPTIONAL), ("consumedOverheadMemory", "int", "vim.version.version5", F_OPTIONAL), ("ftLogBandwidth", "int", "vim.version.version5", F_OPTIONAL), ("ftSecondaryLatency", "int", "vim.version.version5", F_OPTIONAL), ("ftLatencyStatus", "vim.ManagedEntity.Status", "vim.version.version5", F_OPTIONAL), ("compressedMemory", "long", "vim.version.version6", F_OPTIONAL), ("uptimeSeconds", "int", "vim.version.version6", F_OPTIONAL), ("ssdSwappedMemory", "long", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.vm.Summary.GuestSummary", "VirtualMachineGuestSummary", "vmodl.DynamicData", "vim.version.version1", [("guestId", "string", "vim.version.version1", F_OPTIONAL), ("guestFullName", "string", "vim.version.version1", F_OPTIONAL), ("toolsStatus", "vim.vm.GuestInfo.ToolsStatus", "vim.version.version1", F_OPTIONAL), ("toolsVersionStatus", "string", "vim.version.version5", F_OPTIONAL), ("toolsVersionStatus2", "string", "vim.version.version7", F_OPTIONAL), ("toolsRunningStatus", "string", "vim.version.version5", F_OPTIONAL), ("hostName", "string", "vim.version.version1", F_OPTIONAL), ("ipAddress", "string", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.vm.Summary.StorageSummary", "VirtualMachineStorageSummary", "vmodl.DynamicData", "vim.version.version5", [("committed", "long", "vim.version.version5", 0), ("uncommitted", "long", "vim.version.version5", 0), ("unshared", "long", "vim.version.version5", 0), ("timestamp", "vmodl.DateTime", "vim.version.version5", 0)]) +CreateDataType("vim.vm.VFlashModuleInfo", "VirtualMachineVFlashModuleInfo", "vim.vm.TargetInfo", "vim.version.version9", [("vFlashModule", "vim.host.VFlashManager.VFlashCacheConfigInfo.VFlashModuleConfigOption", "vim.version.version9", 0)]) +CreateDataType("vim.vm.VmImportSpec", "VirtualMachineImportSpec", "vim.ImportSpec", "vim.version.version5", [("configSpec", "vim.vm.ConfigSpec", "vim.version.version5", 0), ("resPoolEntity", "vim.ResourcePool", "vim.version.version6", F_OPTIONAL)]) +CreateManagedType("vim.vm.check.ProvisioningChecker", "VirtualMachineProvisioningChecker", "vmodl.ManagedObject", "vim.version.version5", None, [("queryVMotionCompatibilityEx", "QueryVMotionCompatibilityEx_Task", "vim.version.version5", (("vm", "vim.VirtualMachine[]", "vim.version.version5", 0, None),("host", "vim.HostSystem[]", "vim.version.version5", 0, None),), (0, "vim.Task", "vim.vm.check.Result[]"), "System.View", None), ("checkMigrate", "CheckMigrate_Task", "vim.version.version5", (("vm", "vim.VirtualMachine", "vim.version.version5", 0, None),("host", "vim.HostSystem", "vim.version.version5", F_OPTIONAL, None),("pool", "vim.ResourcePool", "vim.version.version5", F_OPTIONAL, None),("state", "vim.VirtualMachine.PowerState", "vim.version.version5", F_OPTIONAL, None),("testType", "string[]", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.Task", "vim.vm.check.Result[]"), "System.View", ["vim.fault.InvalidState", ]), ("checkRelocate", "CheckRelocate_Task", "vim.version.version5", (("vm", "vim.VirtualMachine", "vim.version.version5", 0, None),("spec", "vim.vm.RelocateSpec", "vim.version.version5", 0, None),("testType", "string[]", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.Task", "vim.vm.check.Result[]"), "System.View", ["vim.fault.InvalidState", ])]) +CreateDataType("vim.vm.device.VirtualCdrom", "VirtualCdrom", "vim.vm.device.VirtualDevice", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualCdrom.IsoBackingInfo", "VirtualCdromIsoBackingInfo", "vim.vm.device.VirtualDevice.FileBackingInfo", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualCdrom.PassthroughBackingInfo", "VirtualCdromPassthroughBackingInfo", "vim.vm.device.VirtualDevice.DeviceBackingInfo", "vim.version.version1", [("exclusive", "boolean", "vim.version.version1", 0)]) +CreateDataType("vim.vm.device.VirtualCdrom.RemotePassthroughBackingInfo", "VirtualCdromRemotePassthroughBackingInfo", "vim.vm.device.VirtualDevice.RemoteDeviceBackingInfo", "vim.version.version1", [("exclusive", "boolean", "vim.version.version1", 0)]) +CreateDataType("vim.vm.device.VirtualCdrom.AtapiBackingInfo", "VirtualCdromAtapiBackingInfo", "vim.vm.device.VirtualDevice.DeviceBackingInfo", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualCdrom.RemoteAtapiBackingInfo", "VirtualCdromRemoteAtapiBackingInfo", "vim.vm.device.VirtualDevice.RemoteDeviceBackingInfo", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualCdromOption", "VirtualCdromOption", "vim.vm.device.VirtualDeviceOption", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualCdromOption.IsoBackingOption", "VirtualCdromIsoBackingOption", "vim.vm.device.VirtualDeviceOption.FileBackingOption", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualCdromOption.PassthroughBackingOption", "VirtualCdromPassthroughBackingOption", "vim.vm.device.VirtualDeviceOption.DeviceBackingOption", "vim.version.version1", [("exclusive", "vim.option.BoolOption", "vim.version.version1", 0)]) +CreateDataType("vim.vm.device.VirtualCdromOption.RemotePassthroughBackingOption", "VirtualCdromRemotePassthroughBackingOption", "vim.vm.device.VirtualDeviceOption.RemoteDeviceBackingOption", "vim.version.version1", [("exclusive", "vim.option.BoolOption", "vim.version.version1", 0)]) +CreateDataType("vim.vm.device.VirtualCdromOption.AtapiBackingOption", "VirtualCdromAtapiBackingOption", "vim.vm.device.VirtualDeviceOption.DeviceBackingOption", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualCdromOption.RemoteAtapiBackingOption", "VirtualCdromRemoteAtapiBackingOption", "vim.vm.device.VirtualDeviceOption.DeviceBackingOption", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualController", "VirtualController", "vim.vm.device.VirtualDevice", "vim.version.version1", [("busNumber", "int", "vim.version.version1", 0), ("device", "int[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.vm.device.VirtualControllerOption", "VirtualControllerOption", "vim.vm.device.VirtualDeviceOption", "vim.version.version1", [("devices", "vim.option.IntOption", "vim.version.version1", 0), ("supportedDevice", "vmodl.TypeName[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.vm.device.VirtualE1000", "VirtualE1000", "vim.vm.device.VirtualEthernetCard", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualE1000Option", "VirtualE1000Option", "vim.vm.device.VirtualEthernetCardOption", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualE1000e", "VirtualE1000e", "vim.vm.device.VirtualEthernetCard", "vim.version.version7", None) +CreateDataType("vim.vm.device.VirtualE1000eOption", "VirtualE1000eOption", "vim.vm.device.VirtualEthernetCardOption", "vim.version.version7", None) +CreateDataType("vim.vm.device.VirtualEnsoniq1371", "VirtualEnsoniq1371", "vim.vm.device.VirtualSoundCard", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualEnsoniq1371Option", "VirtualEnsoniq1371Option", "vim.vm.device.VirtualSoundCardOption", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualHdAudioCard", "VirtualHdAudioCard", "vim.vm.device.VirtualSoundCard", "vim.version.version7", None) +CreateDataType("vim.vm.device.VirtualHdAudioCardOption", "VirtualHdAudioCardOption", "vim.vm.device.VirtualSoundCardOption", "vim.version.version7", None) +CreateDataType("vim.vm.device.VirtualIDEController", "VirtualIDEController", "vim.vm.device.VirtualController", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualIDEControllerOption", "VirtualIDEControllerOption", "vim.vm.device.VirtualControllerOption", "vim.version.version1", [("numIDEDisks", "vim.option.IntOption", "vim.version.version1", 0), ("numIDECdroms", "vim.option.IntOption", "vim.version.version1", 0)]) +CreateDataType("vim.vm.device.VirtualPCIController", "VirtualPCIController", "vim.vm.device.VirtualController", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualPCIControllerOption", "VirtualPCIControllerOption", "vim.vm.device.VirtualControllerOption", "vim.version.version1", [("numSCSIControllers", "vim.option.IntOption", "vim.version.version1", 0), ("numEthernetCards", "vim.option.IntOption", "vim.version.version1", 0), ("numVideoCards", "vim.option.IntOption", "vim.version.version1", 0), ("numSoundCards", "vim.option.IntOption", "vim.version.version1", 0), ("numVmiRoms", "vim.option.IntOption", "vim.version.version2", 0), ("numVmciDevices", "vim.option.IntOption", "vim.version.version4", 0), ("numPCIPassthroughDevices", "vim.option.IntOption", "vim.version.version4", 0), ("numSasSCSIControllers", "vim.option.IntOption", "vim.version.version4", 0), ("numVmxnet3EthernetCards", "vim.option.IntOption", "vim.version.version4", 0), ("numParaVirtualSCSIControllers", "vim.option.IntOption", "vim.version.version4", 0), ("numSATAControllers", "vim.option.IntOption", "vim.version.version9", 0)]) +CreateDataType("vim.vm.device.VirtualPS2Controller", "VirtualPS2Controller", "vim.vm.device.VirtualController", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualPS2ControllerOption", "VirtualPS2ControllerOption", "vim.vm.device.VirtualControllerOption", "vim.version.version1", [("numKeyboards", "vim.option.IntOption", "vim.version.version1", 0), ("numPointingDevices", "vim.option.IntOption", "vim.version.version1", 0)]) +CreateDataType("vim.vm.device.VirtualSATAController", "VirtualSATAController", "vim.vm.device.VirtualController", "vim.version.version9", None) +CreateDataType("vim.vm.device.VirtualSATAControllerOption", "VirtualSATAControllerOption", "vim.vm.device.VirtualControllerOption", "vim.version.version9", [("numSATADisks", "vim.option.IntOption", "vim.version.version9", 0), ("numSATACdroms", "vim.option.IntOption", "vim.version.version9", 0)]) +CreateDataType("vim.vm.device.VirtualSCSIController", "VirtualSCSIController", "vim.vm.device.VirtualController", "vim.version.version1", [("hotAddRemove", "boolean", "vim.version.version1", F_OPTIONAL), ("sharedBus", "vim.vm.device.VirtualSCSIController.Sharing", "vim.version.version1", 0), ("scsiCtlrUnitNumber", "int", "vim.version.version1", F_OPTIONAL)]) +CreateEnumType("vim.vm.device.VirtualSCSIController.Sharing", "VirtualSCSISharing", "vim.version.version1", ["noSharing", "virtualSharing", "physicalSharing"]) +CreateDataType("vim.vm.device.VirtualSCSIControllerOption", "VirtualSCSIControllerOption", "vim.vm.device.VirtualControllerOption", "vim.version.version1", [("numSCSIDisks", "vim.option.IntOption", "vim.version.version1", 0), ("numSCSICdroms", "vim.option.IntOption", "vim.version.version1", 0), ("numSCSIPassthrough", "vim.option.IntOption", "vim.version.version1", 0), ("sharing", "vim.vm.device.VirtualSCSIController.Sharing[]", "vim.version.version1", 0), ("defaultSharedIndex", "int", "vim.version.version1", 0), ("hotAddRemove", "vim.option.BoolOption", "vim.version.version1", 0), ("scsiCtlrUnitNumber", "int", "vim.version.version1", 0)]) +CreateDataType("vim.vm.device.VirtualSIOController", "VirtualSIOController", "vim.vm.device.VirtualController", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualSIOControllerOption", "VirtualSIOControllerOption", "vim.vm.device.VirtualControllerOption", "vim.version.version1", [("numFloppyDrives", "vim.option.IntOption", "vim.version.version1", 0), ("numSerialPorts", "vim.option.IntOption", "vim.version.version1", 0), ("numParallelPorts", "vim.option.IntOption", "vim.version.version1", 0)]) +CreateDataType("vim.vm.device.VirtualSoundBlaster16", "VirtualSoundBlaster16", "vim.vm.device.VirtualSoundCard", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualSoundBlaster16Option", "VirtualSoundBlaster16Option", "vim.vm.device.VirtualSoundCardOption", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualUSBController", "VirtualUSBController", "vim.vm.device.VirtualController", "vim.version.version1", [("autoConnectDevices", "boolean", "vim.version.version1", F_OPTIONAL), ("ehciEnabled", "boolean", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.vm.device.VirtualUSBController.PciBusSlotInfo", "VirtualUSBControllerPciBusSlotInfo", "vim.vm.device.VirtualDevice.PciBusSlotInfo", "vim.version.version8", [("ehciPciSlotNumber", "int", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.vm.device.VirtualUSBControllerOption", "VirtualUSBControllerOption", "vim.vm.device.VirtualControllerOption", "vim.version.version1", [("autoConnectDevices", "vim.option.BoolOption", "vim.version.version1", 0), ("ehciSupported", "vim.option.BoolOption", "vim.version.version2", 0), ("supportedSpeeds", "string[]", "vim.version.version7", 0)]) +CreateDataType("vim.vm.device.VirtualUSBXHCIController", "VirtualUSBXHCIController", "vim.vm.device.VirtualController", "vim.version.version7", [("autoConnectDevices", "boolean", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.vm.device.VirtualUSBXHCIControllerOption", "VirtualUSBXHCIControllerOption", "vim.vm.device.VirtualControllerOption", "vim.version.version7", [("autoConnectDevices", "vim.option.BoolOption", "vim.version.version7", 0), ("supportedSpeeds", "string[]", "vim.version.version7", 0)]) +CreateDataType("vim.vm.device.VirtualVmxnet2Option", "VirtualVmxnet2Option", "vim.vm.device.VirtualVmxnetOption", "vim.version.version2", None) +CreateDataType("vim.vm.device.VirtualVmxnet3Option", "VirtualVmxnet3Option", "vim.vm.device.VirtualVmxnetOption", "vim.version.version4", None) +CreateManagedType("vim.ComputeResource", "ComputeResource", "vim.ManagedEntity", "vim.version.version1", [("resourcePool", "vim.ResourcePool", "vim.version.version1", F_OPTIONAL, "System.View"), ("host", "vim.HostSystem[]", "vim.version.version1", F_OPTIONAL, "System.View"), ("datastore", "vim.Datastore[]", "vim.version.version1", F_OPTIONAL, "System.View"), ("network", "vim.Network[]", "vim.version.version1", F_OPTIONAL, "System.View"), ("summary", "vim.ComputeResource.Summary", "vim.version.version1", 0, None), ("environmentBrowser", "vim.EnvironmentBrowser", "vim.version.version1", F_OPTIONAL, "System.View"), ("configurationEx", "vim.ComputeResource.ConfigInfo", "vim.version.version2", 0, None)], [("reconfigureEx", "ReconfigureComputeResource_Task", "vim.version.version2", (("spec", "vim.ComputeResource.ConfigSpec", "vim.version.version2", 0, None),("modify", "boolean", "vim.version.version2", 0, None),), (0, "vim.Task", "void"), "Host.Inventory.EditCluster", None)]) +CreateDataType("vim.ComputeResource.Summary", "ComputeResourceSummary", "vmodl.DynamicData", "vim.version.version1", [("totalCpu", "int", "vim.version.version1", 0), ("totalMemory", "long", "vim.version.version1", 0), ("numCpuCores", "short", "vim.version.version1", 0), ("numCpuThreads", "short", "vim.version.version1", 0), ("effectiveCpu", "int", "vim.version.version1", 0), ("effectiveMemory", "long", "vim.version.version1", 0), ("numHosts", "int", "vim.version.version1", 0), ("numEffectiveHosts", "int", "vim.version.version1", 0), ("overallStatus", "vim.ManagedEntity.Status", "vim.version.version1", 0)]) +CreateDataType("vim.ComputeResource.ConfigInfo", "ComputeResourceConfigInfo", "vmodl.DynamicData", "vim.version.version2", [("vmSwapPlacement", "string", "vim.version.version2", 0), ("spbmEnabled", "boolean", "vim.version.version7", F_OPTIONAL), ("defaultHardwareVersionKey", "string", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.ComputeResource.HostSPBMLicenseInfo", "ComputeResourceHostSPBMLicenseInfo", "vmodl.DynamicData", "vim.version.version7", [("host", "vim.HostSystem", "vim.version.version7", 0), ("licenseState", "vim.ComputeResource.HostSPBMLicenseInfo.HostSPBMLicenseState", "vim.version.version7", 0)]) +CreateEnumType("vim.ComputeResource.HostSPBMLicenseInfo.HostSPBMLicenseState", "ComputeResourceHostSPBMLicenseInfoHostSPBMLicenseState", "vim.version.version7", ["licensed", "unlicensed", "unknown"]) +CreateDataType("vim.ComputeResource.ConfigSpec", "ComputeResourceConfigSpec", "vmodl.DynamicData", "vim.version.version2", [("vmSwapPlacement", "string", "vim.version.version2", F_OPTIONAL), ("spbmEnabled", "boolean", "vim.version.version7", F_OPTIONAL), ("defaultHardwareVersionKey", "string", "vim.version.version8", F_OPTIONAL)]) +CreateManagedType("vim.Datacenter", "Datacenter", "vim.ManagedEntity", "vim.version.version1", [("vmFolder", "vim.Folder", "vim.version.version1", 0, "System.View"), ("hostFolder", "vim.Folder", "vim.version.version1", 0, "System.View"), ("datastoreFolder", "vim.Folder", "vim.version.version5", 0, "System.View"), ("networkFolder", "vim.Folder", "vim.version.version5", 0, "System.View"), ("datastore", "vim.Datastore[]", "vim.version.version1", F_OPTIONAL, None), ("network", "vim.Network[]", "vim.version.version1", F_OPTIONAL, None), ("configuration", "vim.Datacenter.ConfigInfo", "vim.version.version8", 0, "System.View")], [("queryConnectionInfo", "QueryConnectionInfo", "vim.version.version1", (("hostname", "string", "vim.version.version1", 0, None),("port", "int", "vim.version.version1", 0, None),("username", "string", "vim.version.version1", 0, None),("password", "string", "vim.version.version1", 0, None),("sslThumbprint", "string", "vim.version.version2", F_OPTIONAL, None),), (0, "vim.host.ConnectInfo", "vim.host.ConnectInfo"), "System.View", ["vim.fault.InvalidLogin", "vim.fault.HostConnectFault", ]), ("powerOnVm", "PowerOnMultiVM_Task", "vim.version.version2", (("vm", "vim.VirtualMachine[]", "vim.version.version2", 0, "VirtualMachine.Interact.PowerOn"),("option", "vim.option.OptionValue[]", "vim.version.version6", F_OPTIONAL, None),), (0, "vim.Task", "vim.cluster.PowerOnVmResult"), "System.View", None), ("queryConfigOptionDescriptor", "queryDatacenterConfigOptionDescriptor", "vim.version.version8", (), (F_OPTIONAL, "vim.vm.ConfigOptionDescriptor[]", "vim.vm.ConfigOptionDescriptor[]"), "System.View", None), ("reconfigure", "ReconfigureDatacenter_Task", "vim.version.version8", (("spec", "vim.Datacenter.ConfigSpec", "vim.version.version8", 0, None),("modify", "boolean", "vim.version.version8", 0, None),), (0, "vim.Task", "void"), "Datacenter.Reconfigure", None)]) +CreateDataType("vim.Datacenter.ConfigInfo", "DatacenterConfigInfo", "vmodl.DynamicData", "vim.version.version8", [("defaultHardwareVersionKey", "string", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.Datacenter.ConfigSpec", "DatacenterConfigSpec", "vmodl.DynamicData", "vim.version.version8", [("defaultHardwareVersionKey", "string", "vim.version.version8", F_OPTIONAL)]) +CreateManagedType("vim.Datastore", "Datastore", "vim.ManagedEntity", "vim.version.version1", [("info", "vim.Datastore.Info", "vim.version.version1", 0, None), ("summary", "vim.Datastore.Summary", "vim.version.version1", 0, None), ("host", "vim.Datastore.HostMount[]", "vim.version.version1", F_OPTIONAL, None), ("vm", "vim.VirtualMachine[]", "vim.version.version1", F_OPTIONAL, None), ("browser", "vim.host.DatastoreBrowser", "vim.version.version1", 0, None), ("capability", "vim.Datastore.Capability", "vim.version.version1", 0, None), ("iormConfiguration", "vim.StorageResourceManager.IORMConfigInfo", "vim.version.version6", F_OPTIONAL, None)], [("refresh", "RefreshDatastore", "vim.version.version1", (), (0, "void", "void"), "System.Read", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("refreshStorageInfo", "RefreshDatastoreStorageInfo", "vim.version.version5", (), (0, "void", "void"), "System.Read", None), ("updateVirtualMachineFiles", "UpdateVirtualMachineFiles_Task", "vim.version.version6", (("mountPathDatastoreMapping", "vim.Datastore.MountPathDatastorePair[]", "vim.version.version6", 0, None),), (0, "vim.Task", "vim.UpdateVirtualMachineFilesResult"), "Datastore.UpdateVirtualMachineFiles", ["vim.fault.ResourceInUse", "vim.fault.PlatformConfigFault", "vim.fault.TaskInProgress", "vim.fault.InvalidDatastore", ]), ("renameDatastore", "RenameDatastore", "vim.version.version1", (("newName", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "Datastore.Rename", ["vim.fault.DuplicateName", "vim.fault.InvalidName", ]), ("destroyDatastore", "DestroyDatastore", "vim.version.version1", (), (0, "void", "void"), "Datastore.Delete", ["vim.fault.ResourceInUse", ]), ("enterMaintenanceMode", "DatastoreEnterMaintenanceMode", "vim.version.version7", (), (0, "vim.storageDrs.StoragePlacementResult", "vim.storageDrs.StoragePlacementResult"), "Datastore.Config", ["vim.fault.InvalidState", ]), ("exitMaintenanceMode", "DatastoreExitMaintenanceMode_Task", "vim.version.version7", (), (0, "vim.Task", "void"), "Datastore.Config", ["vim.fault.InvalidState", ])]) +CreateEnumType("vim.Datastore.Accessible", "DatastoreAccessible", "vim.version.version5", ["True", "False"]) +CreateDataType("vim.Datastore.Summary", "DatastoreSummary", "vmodl.DynamicData", "vim.version.version1", [("datastore", "vim.Datastore", "vim.version.version1", F_OPTIONAL), ("name", "string", "vim.version.version1", 0), ("url", "string", "vim.version.version1", 0), ("capacity", "long", "vim.version.version1", 0), ("freeSpace", "long", "vim.version.version1", 0), ("uncommitted", "long", "vim.version.version5", F_OPTIONAL), ("accessible", "boolean", "vim.version.version1", 0), ("multipleHostAccess", "boolean", "vim.version.version1", F_OPTIONAL), ("type", "string", "vim.version.version1", 0), ("maintenanceMode", "string", "vim.version.version7", F_OPTIONAL)]) +CreateEnumType("vim.Datastore.Summary.MaintenanceModeState", "DatastoreSummaryMaintenanceModeState", "vim.version.version7", ["normal", "enteringMaintenance", "inMaintenance"]) +CreateDataType("vim.Datastore.Info", "DatastoreInfo", "vmodl.DynamicData", "vim.version.version1", [("name", "string", "vim.version.version1", 0), ("url", "string", "vim.version.version1", 0), ("freeSpace", "long", "vim.version.version1", 0), ("maxFileSize", "long", "vim.version.version1", 0), ("maxVirtualDiskCapacity", "long", "vim.version.version9", F_OPTIONAL), ("timestamp", "vmodl.DateTime", "vim.version.version5", F_OPTIONAL), ("containerId", "string", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.Datastore.Capability", "DatastoreCapability", "vmodl.DynamicData", "vim.version.version1", [("directoryHierarchySupported", "boolean", "vim.version.version1", 0), ("rawDiskMappingsSupported", "boolean", "vim.version.version1", 0), ("perFileThinProvisioningSupported", "boolean", "vim.version.version1", 0), ("storageIORMSupported", "boolean", "vim.version.version6", 0), ("nativeSnapshotSupported", "boolean", "vim.version.version8", 0), ("topLevelDirectoryCreateSupported", "boolean", "vim.version.version9", F_OPTIONAL), ("seSparseSupported", "boolean", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.Datastore.HostMount", "DatastoreHostMount", "vmodl.DynamicData", "vim.version.version1", [("key", "vim.HostSystem", "vim.version.version1", 0), ("mountInfo", "vim.host.MountInfo", "vim.version.version1", 0)]) +CreateDataType("vim.Datastore.MountPathDatastorePair", "DatastoreMountPathDatastorePair", "vmodl.DynamicData", "vim.version.version6", [("oldMountPath", "string", "vim.version.version6", 0), ("datastore", "vim.Datastore", "vim.version.version6", 0)]) +CreateManagedType("vim.DistributedVirtualSwitch", "DistributedVirtualSwitch", "vim.ManagedEntity", "vim.version.version5", [("uuid", "string", "vim.version.version5", 0, None), ("capability", "vim.DistributedVirtualSwitch.Capability", "vim.version.version5", 0, None), ("summary", "vim.DistributedVirtualSwitch.Summary", "vim.version.version5", 0, None), ("config", "vim.DistributedVirtualSwitch.ConfigInfo", "vim.version.version5", 0, None), ("networkResourcePool", "vim.dvs.NetworkResourcePool[]", "vim.version.version6", F_OPTIONAL, None), ("portgroup", "vim.dvs.DistributedVirtualPortgroup[]", "vim.version.version5", F_OPTIONAL, None), ("runtime", "vim.DistributedVirtualSwitch.RuntimeInfo", "vim.version.version8", F_OPTIONAL, None)], [("fetchPortKeys", "FetchDVPortKeys", "vim.version.version5", (("criteria", "vim.dvs.PortCriteria", "vim.version.version5", F_OPTIONAL, None),), (F_OPTIONAL, "string[]", "string[]"), "System.Read", None), ("fetchPorts", "FetchDVPorts", "vim.version.version5", (("criteria", "vim.dvs.PortCriteria", "vim.version.version5", F_OPTIONAL, None),), (F_OPTIONAL, "vim.dvs.DistributedVirtualPort[]", "vim.dvs.DistributedVirtualPort[]"), "System.Read", None), ("queryUsedVlanId", "QueryUsedVlanIdInDvs", "vim.version.version5", (), (F_OPTIONAL, "int[]", "int[]"), "System.Read", None), ("reconfigure", "ReconfigureDvs_Task", "vim.version.version5", (("spec", "vim.DistributedVirtualSwitch.ConfigSpec", "vim.version.version5", 0, None),), (0, "vim.Task", "void"), None, ["vim.fault.DvsFault", "vim.fault.ConcurrentAccess", "vim.fault.DuplicateName", "vim.fault.InvalidState", "vim.fault.InvalidName", "vim.fault.NotFound", "vim.fault.AlreadyExists", "vim.fault.LimitExceeded", "vim.fault.ResourceInUse", "vim.fault.ResourceNotAvailable", "vim.fault.DvsNotAuthorized", ]), ("performProductSpecOperation", "PerformDvsProductSpecOperation_Task", "vim.version.version5", (("operation", "string", "vim.version.version5", 0, None),("productSpec", "vim.dvs.ProductSpec", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.Task", "void"), "DVSwitch.Modify", ["vim.fault.TaskInProgress", "vim.fault.InvalidState", "vim.fault.DvsFault", ]), ("merge", "MergeDvs_Task", "vim.version.version5", (("dvs", "vim.DistributedVirtualSwitch", "vim.version.version5", 0, "DVSwitch.Delete"),), (0, "vim.Task", "void"), "DVSwitch.Modify", ["vim.fault.DvsFault", "vim.fault.NotFound", "vim.fault.ResourceInUse", "vim.fault.InvalidHostState", ]), ("addPortgroups", "AddDVPortgroup_Task", "vim.version.version5", (("spec", "vim.dvs.DistributedVirtualPortgroup.ConfigSpec[]", "vim.version.version5", 0, None),), (0, "vim.Task", "void"), "DVPortgroup.Create", ["vim.fault.DvsFault", "vim.fault.DuplicateName", "vim.fault.InvalidName", ]), ("movePort", "MoveDVPort_Task", "vim.version.version5", (("portKey", "string[]", "vim.version.version5", 0, None),("destinationPortgroupKey", "string", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.Task", "void"), "DVSwitch.Modify", ["vim.fault.DvsFault", "vim.fault.NotFound", "vim.fault.ConcurrentAccess", ]), ("updateCapability", "UpdateDvsCapability", "vim.version.version5", (("capability", "vim.DistributedVirtualSwitch.Capability", "vim.version.version5", 0, None),), (0, "void", "void"), "DVSwitch.Modify", ["vim.fault.DvsFault", ]), ("reconfigurePort", "ReconfigureDVPort_Task", "vim.version.version5", (("port", "vim.dvs.DistributedVirtualPort.ConfigSpec[]", "vim.version.version5", 0, None),), (0, "vim.Task", "void"), "DVSwitch.PortConfig", ["vim.fault.DvsFault", "vim.fault.NotFound", "vim.fault.ResourceInUse", "vim.fault.ConcurrentAccess", ]), ("refreshPortState", "RefreshDVPortState", "vim.version.version5", (("portKeys", "string[]", "vim.version.version5", F_OPTIONAL, None),), (0, "void", "void"), "System.Read", ["vim.fault.DvsFault", "vim.fault.NotFound", ]), ("rectifyHost", "RectifyDvsHost_Task", "vim.version.version5", (("hosts", "vim.HostSystem[]", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.Task", "void"), "System.Read", ["vim.fault.DvsFault", "vim.fault.NotFound", ]), ("updateNetworkResourcePool", "UpdateNetworkResourcePool", "vim.version.version6", (("configSpec", "vim.dvs.NetworkResourcePool.ConfigSpec[]", "vim.version.version6", 0, None),), (0, "void", "void"), "DVSwitch.ResourceManagement", ["vim.fault.DvsFault", "vim.fault.NotFound", "vim.fault.InvalidName", "vim.fault.ConcurrentAccess", ]), ("addNetworkResourcePool", "AddNetworkResourcePool", "vim.version.version7", (("configSpec", "vim.dvs.NetworkResourcePool.ConfigSpec[]", "vim.version.version7", 0, None),), (0, "void", "void"), "DVSwitch.ResourceManagement", ["vim.fault.DvsFault", "vim.fault.InvalidName", ]), ("removeNetworkResourcePool", "RemoveNetworkResourcePool", "vim.version.version7", (("key", "string[]", "vim.version.version7", 0, None),), (0, "void", "void"), "DVSwitch.ResourceManagement", ["vim.fault.DvsFault", "vim.fault.NotFound", "vim.fault.InvalidName", "vim.fault.ResourceInUse", ]), ("enableNetworkResourceManagement", "EnableNetworkResourceManagement", "vim.version.version6", (("enable", "boolean", "vim.version.version6", 0, None),), (0, "void", "void"), "DVSwitch.ResourceManagement", ["vim.fault.DvsFault", ]), ("rollback", "DVSRollback_Task", "vim.version.version8", (("entityBackup", "vim.dvs.EntityBackup.Config", "vim.version.version8", F_OPTIONAL, None),), (F_OPTIONAL, "vim.Task", "vim.DistributedVirtualSwitch.ConfigSpec"), None, ["vim.fault.DvsFault", "vim.fault.RollbackFailure", ]), ("addPortgroup", "CreateDVPortgroup_Task", "vim.version.version8", (("spec", "vim.dvs.DistributedVirtualPortgroup.ConfigSpec", "vim.version.version8", 0, None),), (0, "vim.Task", "vim.dvs.DistributedVirtualPortgroup"), "DVPortgroup.Create", ["vim.fault.DvsFault", "vim.fault.DuplicateName", "vim.fault.InvalidName", ]), ("updateHealthCheckConfig", "UpdateDVSHealthCheckConfig_Task", "vim.version.version8", (("healthCheckConfig", "vim.DistributedVirtualSwitch.HealthCheckConfig[]", "vim.version.version8", 0, None),), (0, "vim.Task", "void"), "DVSwitch.Modify", ["vim.fault.DvsFault", ]), ("lookupPortgroup", "LookupDvPortGroup", "vim.version.version8", (("portgroupKey", "string", "vim.version.version8", 0, None),), (F_OPTIONAL, "vim.dvs.DistributedVirtualPortgroup", "vim.dvs.DistributedVirtualPortgroup"), "System.Read", ["vim.fault.NotFound", ])]) +CreateEnumType("vim.DistributedVirtualSwitch.ProductSpecOperationType", "DistributedVirtualSwitchProductSpecOperationType", "vim.version.version5", ["preInstall", "upgrade", "notifyAvailableUpgrade", "proceedWithUpgrade", "updateBundleInfo"]) +CreateDataType("vim.DistributedVirtualSwitch.ContactInfo", "DVSContactInfo", "vmodl.DynamicData", "vim.version.version5", [("name", "string", "vim.version.version5", F_OPTIONAL), ("contact", "string", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.DistributedVirtualSwitch.NicTeamingPolicyMode", "DistributedVirtualSwitchNicTeamingPolicyMode", "vim.version.version6", ["loadbalance_ip", "loadbalance_srcmac", "loadbalance_srcid", "failover_explicit", "loadbalance_loadbased"]) +CreateDataType("vim.DistributedVirtualSwitch.NetworkResourceManagementCapability", "DVSNetworkResourceManagementCapability", "vmodl.DynamicData", "vim.version.version7", [("networkResourceManagementSupported", "boolean", "vim.version.version7", 0), ("networkResourcePoolHighShareValue", "int", "vim.version.version7", 0), ("qosSupported", "boolean", "vim.version.version7", 0), ("userDefinedNetworkResourcePoolsSupported", "boolean", "vim.version.version7", 0)]) +CreateDataType("vim.DistributedVirtualSwitch.RollbackCapability", "DVSRollbackCapability", "vmodl.DynamicData", "vim.version.version8", [("rollbackSupported", "boolean", "vim.version.version8", 0)]) +CreateDataType("vim.DistributedVirtualSwitch.BackupRestoreCapability", "DVSBackupRestoreCapability", "vmodl.DynamicData", "vim.version.version8", [("backupRestoreSupported", "boolean", "vim.version.version8", 0)]) +CreateDataType("vim.DistributedVirtualSwitch.FeatureCapability", "DVSFeatureCapability", "vmodl.DynamicData", "vim.version.version6", [("networkResourceManagementSupported", "boolean", "vim.version.version6", 0), ("vmDirectPathGen2Supported", "boolean", "vim.version.version6", 0), ("nicTeamingPolicy", "string[]", "vim.version.version6", F_OPTIONAL), ("networkResourcePoolHighShareValue", "int", "vim.version.version6", F_OPTIONAL), ("networkResourceManagementCapability", "vim.DistributedVirtualSwitch.NetworkResourceManagementCapability", "vim.version.version7", F_OPTIONAL), ("healthCheckCapability", "vim.DistributedVirtualSwitch.HealthCheckFeatureCapability", "vim.version.version8", F_OPTIONAL), ("rollbackCapability", "vim.DistributedVirtualSwitch.RollbackCapability", "vim.version.version8", F_OPTIONAL), ("backupRestoreCapability", "vim.DistributedVirtualSwitch.BackupRestoreCapability", "vim.version.version8", F_OPTIONAL), ("networkFilterSupported", "boolean", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.DistributedVirtualSwitch.HealthCheckFeatureCapability", "DVSHealthCheckCapability", "vmodl.DynamicData", "vim.version.version8", None) +CreateDataType("vim.DistributedVirtualSwitch.Capability", "DVSCapability", "vmodl.DynamicData", "vim.version.version5", [("dvsOperationSupported", "boolean", "vim.version.version5", F_OPTIONAL), ("dvPortGroupOperationSupported", "boolean", "vim.version.version5", F_OPTIONAL), ("dvPortOperationSupported", "boolean", "vim.version.version5", F_OPTIONAL), ("compatibleHostComponentProductInfo", "vim.dvs.HostProductSpec[]", "vim.version.version5", F_OPTIONAL), ("featuresSupported", "vim.DistributedVirtualSwitch.FeatureCapability", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.DistributedVirtualSwitch.Summary", "DVSSummary", "vmodl.DynamicData", "vim.version.version5", [("name", "string", "vim.version.version5", 0), ("uuid", "string", "vim.version.version5", 0), ("numPorts", "int", "vim.version.version5", 0), ("productInfo", "vim.dvs.ProductSpec", "vim.version.version5", F_OPTIONAL), ("hostMember", "vim.HostSystem[]", "vim.version.version5", F_OPTIONAL), ("vm", "vim.VirtualMachine[]", "vim.version.version5", F_OPTIONAL), ("host", "vim.HostSystem[]", "vim.version.version5", F_OPTIONAL), ("portgroupName", "string[]", "vim.version.version5", F_OPTIONAL), ("description", "string", "vim.version.version5", F_OPTIONAL), ("contact", "vim.DistributedVirtualSwitch.ContactInfo", "vim.version.version5", F_OPTIONAL), ("numHosts", "int", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.DistributedVirtualSwitch.SwitchPolicy", "DVSPolicy", "vmodl.DynamicData", "vim.version.version5", [("autoPreInstallAllowed", "boolean", "vim.version.version5", F_OPTIONAL), ("autoUpgradeAllowed", "boolean", "vim.version.version5", F_OPTIONAL), ("partialUpgradeAllowed", "boolean", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.DistributedVirtualSwitch.UplinkPortPolicy", "DVSUplinkPortPolicy", "vmodl.DynamicData", "vim.version.version5", None) +CreateDataType("vim.DistributedVirtualSwitch.NameArrayUplinkPortPolicy", "DVSNameArrayUplinkPortPolicy", "vim.DistributedVirtualSwitch.UplinkPortPolicy", "vim.version.version5", [("uplinkPortName", "string[]", "vim.version.version5", 0)]) +CreateDataType("vim.DistributedVirtualSwitch.ConfigSpec", "DVSConfigSpec", "vmodl.DynamicData", "vim.version.version5", [("configVersion", "string", "vim.version.version5", F_OPTIONAL), ("name", "string", "vim.version.version5", F_OPTIONAL), ("numStandalonePorts", "int", "vim.version.version5", F_OPTIONAL), ("maxPorts", "int", "vim.version.version5", F_OPTIONAL), ("uplinkPortPolicy", "vim.DistributedVirtualSwitch.UplinkPortPolicy", "vim.version.version5", F_OPTIONAL), ("uplinkPortgroup", "vim.dvs.DistributedVirtualPortgroup[]", "vim.version.version5", F_OPTIONAL), ("defaultPortConfig", "vim.dvs.DistributedVirtualPort.Setting", "vim.version.version5", F_OPTIONAL), ("host", "vim.dvs.HostMember.ConfigSpec[]", "vim.version.version5", F_OPTIONAL), ("extensionKey", "string", "vim.version.version5", F_OPTIONAL), ("description", "string", "vim.version.version5", F_OPTIONAL), ("policy", "vim.DistributedVirtualSwitch.SwitchPolicy", "vim.version.version5", F_OPTIONAL), ("vendorSpecificConfig", "vim.dvs.KeyedOpaqueBlob[]", "vim.version.version5", F_OPTIONAL), ("contact", "vim.DistributedVirtualSwitch.ContactInfo", "vim.version.version5", F_OPTIONAL), ("switchIpAddress", "string", "vim.version.version7", F_OPTIONAL), ("defaultProxySwitchMaxNumPorts", "int", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.DistributedVirtualSwitch.CreateSpec", "DVSCreateSpec", "vmodl.DynamicData", "vim.version.version5", [("configSpec", "vim.DistributedVirtualSwitch.ConfigSpec", "vim.version.version5", 0), ("productInfo", "vim.dvs.ProductSpec", "vim.version.version5", F_OPTIONAL), ("capability", "vim.DistributedVirtualSwitch.Capability", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.DistributedVirtualSwitch.ConfigInfo", "DVSConfigInfo", "vmodl.DynamicData", "vim.version.version5", [("uuid", "string", "vim.version.version5", 0), ("name", "string", "vim.version.version5", 0), ("numStandalonePorts", "int", "vim.version.version5", 0), ("numPorts", "int", "vim.version.version5", 0), ("maxPorts", "int", "vim.version.version5", 0), ("uplinkPortPolicy", "vim.DistributedVirtualSwitch.UplinkPortPolicy", "vim.version.version5", 0), ("uplinkPortgroup", "vim.dvs.DistributedVirtualPortgroup[]", "vim.version.version5", F_OPTIONAL), ("defaultPortConfig", "vim.dvs.DistributedVirtualPort.Setting", "vim.version.version5", 0), ("host", "vim.dvs.HostMember[]", "vim.version.version5", F_OPTIONAL), ("productInfo", "vim.dvs.ProductSpec", "vim.version.version5", 0), ("targetInfo", "vim.dvs.ProductSpec", "vim.version.version5", F_OPTIONAL), ("extensionKey", "string", "vim.version.version5", F_OPTIONAL), ("vendorSpecificConfig", "vim.dvs.KeyedOpaqueBlob[]", "vim.version.version5", F_OPTIONAL), ("policy", "vim.DistributedVirtualSwitch.SwitchPolicy", "vim.version.version5", F_OPTIONAL), ("description", "string", "vim.version.version5", F_OPTIONAL), ("configVersion", "string", "vim.version.version5", 0), ("contact", "vim.DistributedVirtualSwitch.ContactInfo", "vim.version.version5", 0), ("switchIpAddress", "string", "vim.version.version7", F_OPTIONAL), ("createTime", "vmodl.DateTime", "vim.version.version5", 0), ("networkResourceManagementEnabled", "boolean", "vim.version.version6", 0), ("defaultProxySwitchMaxNumPorts", "int", "vim.version.version8", F_OPTIONAL), ("healthCheckConfig", "vim.DistributedVirtualSwitch.HealthCheckConfig[]", "vim.version.version8", F_OPTIONAL)]) +CreateEnumType("vim.DistributedVirtualSwitch.HostInfrastructureTrafficClass", "DistributedVirtualSwitchHostInfrastructureTrafficClass", "vim.version.version9", ["management", "faultTolerance", "vmotion", "virtualMachine", "iSCSI", "nfs", "hbr", "vsan"]) +CreateDataType("vim.DistributedVirtualSwitch.HealthCheckConfig", "DVSHealthCheckConfig", "vmodl.DynamicData", "vim.version.version8", [("enable", "boolean", "vim.version.version8", F_OPTIONAL), ("interval", "int", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.DistributedVirtualSwitch.RuntimeInfo", "DVSRuntimeInfo", "vmodl.DynamicData", "vim.version.version8", [("hostMemberRuntime", "vim.dvs.HostMember.RuntimeInfo[]", "vim.version.version8", F_OPTIONAL)]) +CreateManagedType("vim.Folder", "Folder", "vim.ManagedEntity", "vim.version.version1", [("childType", "vmodl.TypeName[]", "vim.version.version1", F_OPTIONAL, "System.View"), ("childEntity", "vim.ManagedEntity[]", "vim.version.version1", F_OPTIONAL, "System.View")], [("createFolder", "CreateFolder", "vim.version.version1", (("name", "string", "vim.version.version1", 0, None),), (0, "vim.Folder", "vim.Folder"), "Folder.Create", ["vim.fault.DuplicateName", "vim.fault.InvalidName", ]), ("moveInto", "MoveIntoFolder_Task", "vim.version.version1", (("list", "vim.ManagedEntity[]", "vim.version.version1", 0, None),), (0, "vim.Task", "void"), None, ["vim.fault.DuplicateName", "vim.fault.InvalidFolder", "vim.fault.InvalidState", ]), ("createVm", "CreateVM_Task", "vim.version.version1", (("config", "vim.vm.ConfigSpec", "vim.version.version1", 0, None),("pool", "vim.ResourcePool", "vim.version.version1", 0, "Resource.AssignVMToPool"),("host", "vim.HostSystem", "vim.version.version1", F_OPTIONAL, None),), (0, "vim.Task", "vim.VirtualMachine"), "VirtualMachine.Inventory.Create", ["vim.fault.VmConfigFault", "vim.fault.FileFault", "vim.fault.OutOfBounds", "vim.fault.DuplicateName", "vim.fault.InvalidName", "vim.fault.InvalidDatastore", "vim.fault.InsufficientResourcesFault", "vim.fault.AlreadyExists", "vim.fault.InvalidState", ]), ("registerVm", "RegisterVM_Task", "vim.version.version1", (("path", "string", "vim.version.version1", 0, None),("name", "string", "vim.version.version1", F_OPTIONAL, None),("asTemplate", "boolean", "vim.version.version1", 0, None),("pool", "vim.ResourcePool", "vim.version.version1", F_OPTIONAL, "Resource.AssignVMToPool"),("host", "vim.HostSystem", "vim.version.version1", F_OPTIONAL, None),), (0, "vim.Task", "vim.VirtualMachine"), "VirtualMachine.Inventory.Register", ["vim.fault.OutOfBounds", "vim.fault.DuplicateName", "vim.fault.AlreadyExists", "vim.fault.InvalidDatastore", "vim.fault.NotFound", "vim.fault.InvalidName", "vim.fault.VmConfigFault", "vim.fault.InsufficientResourcesFault", "vim.fault.FileFault", "vim.fault.InvalidState", ]), ("createCluster", "CreateCluster", "vim.version.version1", (("name", "string", "vim.version.version1", 0, None),("spec", "vim.cluster.ConfigSpec", "vim.version.version1", 0, None),), (0, "vim.ClusterComputeResource", "vim.ClusterComputeResource"), "Host.Inventory.CreateCluster", ["vim.fault.DuplicateName", "vim.fault.InvalidName", ]), ("createClusterEx", "CreateClusterEx", "vim.version.version2", (("name", "string", "vim.version.version2", 0, None),("spec", "vim.cluster.ConfigSpecEx", "vim.version.version2", 0, None),), (0, "vim.ClusterComputeResource", "vim.ClusterComputeResource"), "Host.Inventory.CreateCluster", ["vim.fault.DuplicateName", "vim.fault.InvalidName", ]), ("addStandaloneHost", "AddStandaloneHost_Task", "vim.version.version1", (("spec", "vim.host.ConnectSpec", "vim.version.version1", 0, None),("compResSpec", "vim.ComputeResource.ConfigSpec", "vim.version.version2", F_OPTIONAL, None),("addConnected", "boolean", "vim.version.version1", 0, None),("license", "string", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.Task", "vim.ComputeResource"), "Host.Inventory.AddStandaloneHost", ["vim.fault.InvalidLogin", "vim.fault.HostConnectFault", "vim.fault.DuplicateName", ]), ("createDatacenter", "CreateDatacenter", "vim.version.version1", (("name", "string", "vim.version.version1", 0, None),), (0, "vim.Datacenter", "vim.Datacenter"), "Datacenter.Create", ["vim.fault.DuplicateName", "vim.fault.InvalidName", ]), ("unregisterAndDestroy", "UnregisterAndDestroy_Task", "vim.version.version1", (), (0, "vim.Task", "void"), "Folder.Delete", ["vim.fault.ConcurrentAccess", "vim.fault.InvalidState", ]), ("createDistributedVirtualSwitch", "CreateDVS_Task", "vim.version.version5", (("spec", "vim.DistributedVirtualSwitch.CreateSpec", "vim.version.version5", 0, None),), (0, "vim.Task", "vim.DistributedVirtualSwitch"), "DVSwitch.Create", ["vim.fault.DvsFault", "vim.fault.DuplicateName", "vim.fault.InvalidName", "vim.fault.NotFound", "vim.fault.DvsNotAuthorized", ]), ("createStoragePod", "CreateStoragePod", "vim.version.version7", (("name", "string", "vim.version.version7", 0, None),), (0, "vim.StoragePod", "vim.StoragePod"), "Folder.Create", ["vim.fault.DuplicateName", "vim.fault.InvalidName", ])]) +CreateManagedType("vim.HostSystem", "HostSystem", "vim.ManagedEntity", "vim.version.version1", [("runtime", "vim.host.RuntimeInfo", "vim.version.version1", 0, None), ("summary", "vim.host.Summary", "vim.version.version1", 0, None), ("hardware", "vim.host.HardwareInfo", "vim.version.version1", F_OPTIONAL, None), ("capability", "vim.host.Capability", "vim.version.version1", F_OPTIONAL, None), ("licensableResource", "vim.LicenseManager.LicensableResourceInfo", "vim.version.version7", 0, None), ("configManager", "vim.host.ConfigManager", "vim.version.version1", 0, None), ("config", "vim.host.ConfigInfo", "vim.version.version1", F_OPTIONAL, None), ("vm", "vim.VirtualMachine[]", "vim.version.version1", F_OPTIONAL, None), ("datastore", "vim.Datastore[]", "vim.version.version1", F_OPTIONAL, "System.View"), ("network", "vim.Network[]", "vim.version.version1", F_OPTIONAL, "System.View"), ("datastoreBrowser", "vim.host.DatastoreBrowser", "vim.version.version1", 0, "System.View"), ("systemResources", "vim.host.SystemResourceInfo", "vim.version.version1", F_OPTIONAL, None)], [("queryTpmAttestationReport", "QueryTpmAttestationReport", "vim.version.version8", (), (F_OPTIONAL, "vim.host.TpmAttestationReport", "vim.host.TpmAttestationReport"), "System.Read", None), ("queryConnectionInfo", "QueryHostConnectionInfo", "vim.version.version1", (), (0, "vim.host.ConnectInfo", "vim.host.ConnectInfo"), "System.Read", None), ("updateSystemResources", "UpdateSystemResources", "vim.version.version1", (("resourceInfo", "vim.host.SystemResourceInfo", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Resources", None), ("updateSystemSwapConfiguration", "UpdateSystemSwapConfiguration", "vim.version.version8", (("sysSwapConfig", "vim.host.SystemSwapConfiguration", "vim.version.version8", 0, None),), (0, "void", "void"), "Host.Config.Settings", None), ("reconnect", "ReconnectHost_Task", "vim.version.version1", (("cnxSpec", "vim.host.ConnectSpec", "vim.version.version1", F_OPTIONAL, None),("reconnectSpec", "vim.HostSystem.ReconnectSpec", "vim.version.version7", F_OPTIONAL, None),), (0, "vim.Task", "void"), "Host.Config.Connection", ["vim.fault.InvalidLogin", "vim.fault.InvalidState", "vim.fault.InvalidName", "vim.fault.HostConnectFault", ]), ("disconnect", "DisconnectHost_Task", "vim.version.version1", (), (0, "vim.Task", "void"), "Host.Config.Connection", None), ("enterMaintenanceMode", "EnterMaintenanceMode_Task", "vim.version.version1", (("timeout", "int", "vim.version.version1", 0, None),("evacuatePoweredOffVms", "boolean", "vim.version.version2", F_OPTIONAL, None),("maintenanceSpec", "vim.host.MaintenanceSpec", "vim.version.version9", F_OPTIONAL, None),), (0, "vim.Task", "void"), "Host.Config.Maintenance", ["vim.fault.InvalidState", "vim.fault.Timedout", ]), ("exitMaintenanceMode", "ExitMaintenanceMode_Task", "vim.version.version1", (("timeout", "int", "vim.version.version1", 0, None),), (0, "vim.Task", "void"), "Host.Config.Maintenance", ["vim.fault.InvalidState", "vim.fault.Timedout", ]), ("reboot", "RebootHost_Task", "vim.version.version1", (("force", "boolean", "vim.version.version1", 0, None),), (0, "vim.Task", "void"), "Host.Config.Maintenance", ["vim.fault.InvalidState", ]), ("shutdown", "ShutdownHost_Task", "vim.version.version1", (("force", "boolean", "vim.version.version1", 0, None),), (0, "vim.Task", "void"), "Host.Config.Maintenance", ["vim.fault.InvalidState", ]), ("enterStandbyMode", "PowerDownHostToStandBy_Task", "vim.version.version2", (("timeoutSec", "int", "vim.version.version2", 0, None),("evacuatePoweredOffVms", "boolean", "vim.version.version2", F_OPTIONAL, None),), (0, "vim.Task", "void"), "Host.Config.Maintenance", ["vim.fault.HostPowerOpFailed", "vim.fault.InvalidState", "vmodl.fault.NotSupported", "vim.fault.Timedout", "vmodl.fault.RequestCanceled", ]), ("exitStandbyMode", "PowerUpHostFromStandBy_Task", "vim.version.version2", (("timeoutSec", "int", "vim.version.version2", 0, None),), (0, "vim.Task", "void"), "Host.Config.Maintenance", ["vim.fault.HostPowerOpFailed", "vim.fault.InvalidState", "vmodl.fault.NotSupported", "vim.fault.Timedout", ]), ("queryOverhead", "QueryMemoryOverhead", "vim.version.version1", (("memorySize", "long", "vim.version.version1", 0, None),("videoRamSize", "int", "vim.version.version1", F_OPTIONAL, None),("numVcpus", "int", "vim.version.version1", 0, None),), (0, "long", "long"), "System.Read", None), ("queryOverheadEx", "QueryMemoryOverheadEx", "vim.version.version2", (("vmConfigInfo", "vim.vm.ConfigInfo", "vim.version.version2", 0, None),), (0, "long", "long"), "System.Read", None), ("reconfigureDAS", "ReconfigureHostForDAS_Task", "vim.version.version1", (), (0, "vim.Task", "void"), "Host.Config.Connection", ["vim.fault.DasConfigFault", ]), ("updateFlags", "UpdateFlags", "vim.version.version2", (("flagInfo", "vim.host.FlagInfo", "vim.version.version2", 0, None),), (0, "void", "void"), "Host.Config.Settings", None), ("enterLockdownMode", "EnterLockdownMode", "vim.version.version6", (), (0, "void", "void"), "Host.Config.Settings", ["vim.fault.HostConfigFault", ]), ("exitLockdownMode", "ExitLockdownMode", "vim.version.version6", (), (0, "void", "void"), "Host.Config.Settings", ["vim.fault.HostConfigFault", ]), ("acquireCimServicesTicket", "AcquireCimServicesTicket", "vim.version.version2", (), (0, "vim.HostServiceTicket", "vim.HostServiceTicket"), "Host.Cim.CimInteraction", None), ("updateIpmi", "UpdateIpmi", "vim.version.version5", (("ipmiInfo", "vim.host.IpmiInfo", "vim.version.version5", 0, None),), (0, "void", "void"), "Host.Config.Settings", ["vim.fault.InvalidIpmiLoginInfo", "vim.fault.InvalidIpmiMacAddress", ]), ("retrieveHardwareUptime", "RetrieveHardwareUptime", "vim.version.version6", (), (0, "long", "long"), "System.Read", None)]) +CreateEnumType("vim.HostSystem.ConnectionState", "HostSystemConnectionState", "vim.version.version1", ["connected", "notResponding", "disconnected"]) +CreateEnumType("vim.HostSystem.PowerState", "HostSystemPowerState", "vim.version.version2", ["poweredOn", "poweredOff", "standBy", "unknown"]) +CreateEnumType("vim.HostSystem.StandbyMode", "HostStandbyMode", "vim.version.version6", ["entering", "exiting", "in", "none"]) +CreateDataType("vim.HostSystem.ReconnectSpec", "HostSystemReconnectSpec", "vmodl.DynamicData", "vim.version.version7", [("syncState", "boolean", "vim.version.version7", F_OPTIONAL)]) +CreateManagedType("vim.ServiceInstance", "ServiceInstance", "vmodl.ManagedObject", "vim.version.version1", [("serverClock", "vmodl.DateTime", "vim.version.version1", 0, "System.View"), ("capability", "vim.Capability", "vim.version.version1", 0, "System.View"), ("content", "vim.ServiceInstanceContent", "vim.version.version1", 0, "System.Anonymous")], [("currentTime", "CurrentTime", "vim.version.version1", (), (0, "vmodl.DateTime", "vmodl.DateTime"), "System.View", None), ("retrieveContent", "RetrieveServiceContent", "vim.version.version1", (), (0, "vim.ServiceInstanceContent", "vim.ServiceInstanceContent"), "System.Anonymous", None), ("validateMigration", "ValidateMigration", "vim.version.version1", (("vm", "vim.VirtualMachine[]", "vim.version.version1", 0, None),("state", "vim.VirtualMachine.PowerState", "vim.version.version1", F_OPTIONAL, None),("testType", "string[]", "vim.version.version1", F_OPTIONAL, None),("pool", "vim.ResourcePool", "vim.version.version1", F_OPTIONAL, None),("host", "vim.HostSystem", "vim.version.version1", F_OPTIONAL, None),), (F_OPTIONAL, "vim.event.Event[]", "vim.event.Event[]"), "System.View", ["vim.fault.InvalidState", ]), ("queryVMotionCompatibility", "QueryVMotionCompatibility", "vim.version.version1", (("vm", "vim.VirtualMachine", "vim.version.version1", 0, None),("host", "vim.HostSystem[]", "vim.version.version1", 0, None),("compatibility", "string[]", "vim.version.version1", F_OPTIONAL, None),), (F_OPTIONAL, "vim.ServiceInstance.HostVMotionCompatibility[]", "vim.ServiceInstance.HostVMotionCompatibility[]"), "Resource.QueryVMotion", None), ("retrieveProductComponents", "RetrieveProductComponents", "vim.version.version2", (), (F_OPTIONAL, "vim.ServiceInstance.ProductComponentInfo[]", "vim.ServiceInstance.ProductComponentInfo[]"), "System.Anonymous", None)]) +CreateEnumType("vim.ServiceInstance.ValidateMigrationTestType", "ValidateMigrationTestType", "vim.version.version1", ["sourceTests", "compatibilityTests", "diskAccessibilityTests", "resourceTests"]) +CreateEnumType("vim.ServiceInstance.VMotionCompatibilityType", "VMotionCompatibilityType", "vim.version.version1", ["cpu", "software"]) +CreateDataType("vim.ServiceInstance.HostVMotionCompatibility", "HostVMotionCompatibility", "vmodl.DynamicData", "vim.version.version1", [("host", "vim.HostSystem", "vim.version.version1", 0), ("compatibility", "string[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.ServiceInstance.ProductComponentInfo", "ProductComponentInfo", "vmodl.DynamicData", "vim.version.version2", [("id", "string", "vim.version.version2", 0), ("name", "string", "vim.version.version2", 0), ("version", "string", "vim.version.version2", 0), ("release", "int", "vim.version.version2", 0)]) +CreateManagedType("vim.StoragePod", "StoragePod", "vim.Folder", "vim.version.version7", [("summary", "vim.StoragePod.Summary", "vim.version.version7", F_OPTIONAL, "System.View"), ("podStorageDrsEntry", "vim.StorageResourceManager.PodStorageDrsEntry", "vim.version.version7", F_OPTIONAL, "System.Read")], None) +CreateDataType("vim.StoragePod.Summary", "StoragePodSummary", "vmodl.DynamicData", "vim.version.version7", [("name", "string", "vim.version.version7", 0), ("capacity", "long", "vim.version.version7", 0), ("freeSpace", "long", "vim.version.version7", 0)]) +CreateDataType("vim.cluster.AffinityRuleSpec", "ClusterAffinityRuleSpec", "vim.cluster.RuleInfo", "vim.version.version1", [("vm", "vim.VirtualMachine[]", "vim.version.version1", 0)]) +CreateDataType("vim.cluster.AntiAffinityRuleSpec", "ClusterAntiAffinityRuleSpec", "vim.cluster.RuleInfo", "vim.version.version1", [("vm", "vim.VirtualMachine[]", "vim.version.version1", 0)]) +CreateDataType("vim.cluster.ConfigInfoEx", "ClusterConfigInfoEx", "vim.ComputeResource.ConfigInfo", "vim.version.version2", [("dasConfig", "vim.cluster.DasConfigInfo", "vim.version.version2", 0), ("dasVmConfig", "vim.cluster.DasVmConfigInfo[]", "vim.version.version2", F_OPTIONAL), ("drsConfig", "vim.cluster.DrsConfigInfo", "vim.version.version2", 0), ("drsVmConfig", "vim.cluster.DrsVmConfigInfo[]", "vim.version.version2", F_OPTIONAL), ("rule", "vim.cluster.RuleInfo[]", "vim.version.version2", F_OPTIONAL), ("dpmConfigInfo", "vim.cluster.DpmConfigInfo", "vim.version.version2", F_OPTIONAL), ("dpmHostConfig", "vim.cluster.DpmHostConfigInfo[]", "vim.version.version2", F_OPTIONAL), ("vsanConfigInfo", "vim.vsan.cluster.ConfigInfo", "vim.version.version9", F_OPTIONAL), ("vsanHostConfig", "vim.vsan.host.ConfigInfo[]", "vim.version.version9", F_OPTIONAL), ("group", "vim.cluster.GroupInfo[]", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.cluster.ConfigSpecEx", "ClusterConfigSpecEx", "vim.ComputeResource.ConfigSpec", "vim.version.version2", [("dasConfig", "vim.cluster.DasConfigInfo", "vim.version.version2", F_OPTIONAL), ("dasVmConfigSpec", "vim.cluster.DasVmConfigSpec[]", "vim.version.version2", F_OPTIONAL), ("drsConfig", "vim.cluster.DrsConfigInfo", "vim.version.version2", F_OPTIONAL), ("drsVmConfigSpec", "vim.cluster.DrsVmConfigSpec[]", "vim.version.version2", F_OPTIONAL), ("rulesSpec", "vim.cluster.RuleSpec[]", "vim.version.version2", F_OPTIONAL), ("dpmConfig", "vim.cluster.DpmConfigInfo", "vim.version.version2", F_OPTIONAL), ("dpmHostConfigSpec", "vim.cluster.DpmHostConfigSpec[]", "vim.version.version2", F_OPTIONAL), ("vsanConfig", "vim.vsan.cluster.ConfigInfo", "vim.version.version9", F_OPTIONAL), ("vsanHostConfigSpec", "vim.vsan.host.ConfigInfo[]", "vim.version.version9", F_OPTIONAL), ("groupSpec", "vim.cluster.GroupSpec[]", "vim.version.version6", F_OPTIONAL)]) +CreateManagedType("vim.dvs.DistributedVirtualSwitchManager", "DistributedVirtualSwitchManager", "vmodl.ManagedObject", "vim.version.version5", None, [("querySupportedSwitchSpec", "QueryAvailableDvsSpec", "vim.version.version5", (), (F_OPTIONAL, "vim.dvs.ProductSpec[]", "vim.dvs.ProductSpec[]"), "System.View", None), ("queryCompatibleHostForNewDvs", "QueryCompatibleHostForNewDvs", "vim.version.version5", (("container", "vim.ManagedEntity", "vim.version.version5", 0, None),("recursive", "boolean", "vim.version.version5", 0, None),("switchProductSpec", "vim.dvs.ProductSpec", "vim.version.version5", F_OPTIONAL, None),), (F_OPTIONAL, "vim.HostSystem[]", "vim.HostSystem[]"), "System.View", None), ("queryCompatibleHostForExistingDvs", "QueryCompatibleHostForExistingDvs", "vim.version.version5", (("container", "vim.ManagedEntity", "vim.version.version5", 0, None),("recursive", "boolean", "vim.version.version5", 0, None),("dvs", "vim.DistributedVirtualSwitch", "vim.version.version5", 0, None),), (F_OPTIONAL, "vim.HostSystem[]", "vim.HostSystem[]"), "System.View", None), ("queryCompatibleHostSpec", "QueryDvsCompatibleHostSpec", "vim.version.version5", (("switchProductSpec", "vim.dvs.ProductSpec", "vim.version.version5", F_OPTIONAL, None),), (F_OPTIONAL, "vim.dvs.HostProductSpec[]", "vim.dvs.HostProductSpec[]"), "System.View", None), ("queryFeatureCapability", "QueryDvsFeatureCapability", "vim.version.version6", (("switchProductSpec", "vim.dvs.ProductSpec", "vim.version.version6", F_OPTIONAL, None),), (F_OPTIONAL, "vim.DistributedVirtualSwitch.FeatureCapability", "vim.DistributedVirtualSwitch.FeatureCapability"), "System.View", None), ("querySwitchByUuid", "QueryDvsByUuid", "vim.version.version5", (("uuid", "string", "vim.version.version5", 0, None),), (F_OPTIONAL, "vim.DistributedVirtualSwitch", "vim.DistributedVirtualSwitch"), "System.View", ["vim.fault.NotFound", ]), ("queryDvsConfigTarget", "QueryDvsConfigTarget", "vim.version.version5", (("host", "vim.HostSystem", "vim.version.version5", F_OPTIONAL, None),("dvs", "vim.DistributedVirtualSwitch", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.dvs.DistributedVirtualSwitchManager.DvsConfigTarget", "vim.dvs.DistributedVirtualSwitchManager.DvsConfigTarget"), "System.View", None), ("checkCompatibility", "QueryDvsCheckCompatibility", "vim.version.version6", (("hostContainer", "vim.dvs.DistributedVirtualSwitchManager.HostContainer", "vim.version.version6", 0, None),("dvsProductSpec", "vim.dvs.DistributedVirtualSwitchManager.DvsProductSpec", "vim.version.version6", F_OPTIONAL, None),("hostFilterSpec", "vim.dvs.DistributedVirtualSwitchManager.HostDvsFilterSpec[]", "vim.version.version6", F_OPTIONAL, None),), (F_OPTIONAL, "vim.dvs.DistributedVirtualSwitchManager.CompatibilityResult[]", "vim.dvs.DistributedVirtualSwitchManager.CompatibilityResult[]"), "System.View", None), ("rectifyHost", "RectifyDvsOnHost_Task", "vim.version.version7", (("hosts", "vim.HostSystem[]", "vim.version.version7", 0, None),), (0, "vim.Task", "void"), "System.Read", ["vim.fault.DvsFault", ]), ("exportEntity", "DVSManagerExportEntity_Task", "vim.version.version8", (("selectionSet", "vim.SelectionSet[]", "vim.version.version8", 0, None),), (F_OPTIONAL, "vim.Task", "vim.dvs.EntityBackup.Config[]"), None, ["vim.fault.NotFound", "vim.fault.BackupBlobWriteFailure", ]), ("importEntity", "DVSManagerImportEntity_Task", "vim.version.version8", (("entityBackup", "vim.dvs.EntityBackup.Config[]", "vim.version.version8", 0, None),("importType", "string", "vim.version.version8", 0, None),), (0, "vim.Task", "vim.dvs.DistributedVirtualSwitchManager.ImportResult"), None, ["vim.fault.DvsFault", "vim.fault.NotFound", ]), ("lookupPortgroup", "DVSManagerLookupDvPortGroup", "vim.version.version8", (("switchUuid", "string", "vim.version.version8", 0, None),("portgroupKey", "string", "vim.version.version8", 0, None),), (F_OPTIONAL, "vim.dvs.DistributedVirtualPortgroup", "vim.dvs.DistributedVirtualPortgroup"), "System.View", ["vim.fault.NotFound", ])]) +CreateDataType("vim.dvs.DistributedVirtualSwitchManager.DvsConfigTarget", "DVSManagerDvsConfigTarget", "vmodl.DynamicData", "vim.version.version5", [("distributedVirtualPortgroup", "vim.dvs.DistributedVirtualPortgroupInfo[]", "vim.version.version5", F_OPTIONAL), ("distributedVirtualSwitch", "vim.dvs.DistributedVirtualSwitchInfo[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.dvs.DistributedVirtualSwitchManager.CompatibilityResult", "DistributedVirtualSwitchManagerCompatibilityResult", "vmodl.DynamicData", "vim.version.version6", [("host", "vim.HostSystem", "vim.version.version6", 0), ("error", "vmodl.MethodFault[]", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.dvs.DistributedVirtualSwitchManager.HostContainer", "DistributedVirtualSwitchManagerHostContainer", "vmodl.DynamicData", "vim.version.version6", [("container", "vim.ManagedEntity", "vim.version.version6", 0), ("recursive", "boolean", "vim.version.version6", 0)]) +CreateDataType("vim.dvs.DistributedVirtualSwitchManager.HostDvsFilterSpec", "DistributedVirtualSwitchManagerHostDvsFilterSpec", "vmodl.DynamicData", "vim.version.version6", [("inclusive", "boolean", "vim.version.version6", 0)]) +CreateDataType("vim.dvs.DistributedVirtualSwitchManager.HostArrayFilter", "DistributedVirtualSwitchManagerHostArrayFilter", "vim.dvs.DistributedVirtualSwitchManager.HostDvsFilterSpec", "vim.version.version6", [("host", "vim.HostSystem[]", "vim.version.version6", 0)]) +CreateDataType("vim.dvs.DistributedVirtualSwitchManager.HostContainerFilter", "DistributedVirtualSwitchManagerHostContainerFilter", "vim.dvs.DistributedVirtualSwitchManager.HostDvsFilterSpec", "vim.version.version6", [("hostContainer", "vim.dvs.DistributedVirtualSwitchManager.HostContainer", "vim.version.version6", 0)]) +CreateDataType("vim.dvs.DistributedVirtualSwitchManager.HostDvsMembershipFilter", "DistributedVirtualSwitchManagerHostDvsMembershipFilter", "vim.dvs.DistributedVirtualSwitchManager.HostDvsFilterSpec", "vim.version.version6", [("distributedVirtualSwitch", "vim.DistributedVirtualSwitch", "vim.version.version6", 0)]) +CreateDataType("vim.dvs.DistributedVirtualSwitchManager.DvsProductSpec", "DistributedVirtualSwitchManagerDvsProductSpec", "vmodl.DynamicData", "vim.version.version6", [("newSwitchProductSpec", "vim.dvs.ProductSpec", "vim.version.version6", F_OPTIONAL), ("distributedVirtualSwitch", "vim.DistributedVirtualSwitch", "vim.version.version6", F_OPTIONAL)]) +CreateDataType("vim.dvs.DistributedVirtualSwitchManager.ImportResult", "DistributedVirtualSwitchManagerImportResult", "vmodl.DynamicData", "vim.version.version8", [("distributedVirtualSwitch", "vim.DistributedVirtualSwitch[]", "vim.version.version8", F_OPTIONAL), ("distributedVirtualPortgroup", "vim.dvs.DistributedVirtualPortgroup[]", "vim.version.version8", F_OPTIONAL), ("importFault", "vim.fault.ImportOperationBulkFault.FaultOnImport[]", "vim.version.version8", F_OPTIONAL)]) +CreateManagedType("vim.dvs.VmwareDistributedVirtualSwitch", "VmwareDistributedVirtualSwitch", "vim.DistributedVirtualSwitch", "vim.version.version5", None, [("updateLacpGroupConfig", "UpdateDVSLacpGroupConfig_Task", "vim.version.version9", (("lacpGroupSpec", "vim.dvs.VmwareDistributedVirtualSwitch.LacpGroupSpec[]", "vim.version.version9", 0, None),), (0, "vim.Task", "void"), "DVSwitch.Modify", ["vim.fault.DvsFault", ])]) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.FeatureCapability", "VMwareDVSFeatureCapability", "vim.DistributedVirtualSwitch.FeatureCapability", "vim.version.version6", [("vspanSupported", "boolean", "vim.version.version7", F_OPTIONAL), ("lldpSupported", "boolean", "vim.version.version7", F_OPTIONAL), ("ipfixSupported", "boolean", "vim.version.version7", F_OPTIONAL), ("vspanCapability", "vim.dvs.VmwareDistributedVirtualSwitch.VspanFeatureCapability", "vim.version.version8", F_OPTIONAL), ("lacpCapability", "vim.dvs.VmwareDistributedVirtualSwitch.LacpFeatureCapability", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.LacpFeatureCapability", "VMwareDvsLacpCapability", "vmodl.DynamicData", "vim.version.version8", [("lacpSupported", "boolean", "vim.version.version8", F_OPTIONAL), ("multiLacpGroupSupported", "boolean", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.VmwareHealthCheckFeatureCapability", "VMwareDVSHealthCheckCapability", "vim.DistributedVirtualSwitch.HealthCheckFeatureCapability", "vim.version.version8", [("vlanMtuSupported", "boolean", "vim.version.version8", 0), ("teamingSupported", "boolean", "vim.version.version8", 0)]) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.VspanFeatureCapability", "VMwareDVSVspanCapability", "vmodl.DynamicData", "vim.version.version8", [("mixedDestSupported", "boolean", "vim.version.version8", 0), ("dvportSupported", "boolean", "vim.version.version8", 0), ("remoteSourceSupported", "boolean", "vim.version.version8", 0), ("remoteDestSupported", "boolean", "vim.version.version8", 0), ("encapRemoteSourceSupported", "boolean", "vim.version.version8", 0)]) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.VspanPorts", "VMwareVspanPort", "vmodl.DynamicData", "vim.version.version7", [("portKey", "string[]", "vim.version.version7", F_OPTIONAL), ("uplinkPortName", "string[]", "vim.version.version7", F_OPTIONAL), ("wildcardPortConnecteeType", "string[]", "vim.version.version7", F_OPTIONAL), ("vlans", "int[]", "vim.version.version8", F_OPTIONAL), ("ipAddress", "string[]", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.VspanSession", "VMwareVspanSession", "vmodl.DynamicData", "vim.version.version7", [("key", "string", "vim.version.version7", F_OPTIONAL), ("name", "string", "vim.version.version7", F_OPTIONAL), ("description", "string", "vim.version.version7", F_OPTIONAL), ("enabled", "boolean", "vim.version.version7", 0), ("sourcePortTransmitted", "vim.dvs.VmwareDistributedVirtualSwitch.VspanPorts", "vim.version.version7", F_OPTIONAL), ("sourcePortReceived", "vim.dvs.VmwareDistributedVirtualSwitch.VspanPorts", "vim.version.version7", F_OPTIONAL), ("destinationPort", "vim.dvs.VmwareDistributedVirtualSwitch.VspanPorts", "vim.version.version7", F_OPTIONAL), ("encapsulationVlanId", "int", "vim.version.version7", F_OPTIONAL), ("stripOriginalVlan", "boolean", "vim.version.version7", 0), ("mirroredPacketLength", "int", "vim.version.version7", F_OPTIONAL), ("normalTrafficAllowed", "boolean", "vim.version.version7", 0), ("sessionType", "string", "vim.version.version8", F_OPTIONAL), ("samplingRate", "int", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.IpfixConfig", "VMwareIpfixConfig", "vmodl.DynamicData", "vim.version.version7", [("collectorIpAddress", "string", "vim.version.version7", F_OPTIONAL), ("collectorPort", "int", "vim.version.version7", F_OPTIONAL), ("activeFlowTimeout", "int", "vim.version.version7", 0), ("idleFlowTimeout", "int", "vim.version.version7", 0), ("samplingRate", "int", "vim.version.version7", 0), ("internalFlowsOnly", "boolean", "vim.version.version7", 0)]) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.ConfigInfo", "VMwareDVSConfigInfo", "vim.DistributedVirtualSwitch.ConfigInfo", "vim.version.version5", [("vspanSession", "vim.dvs.VmwareDistributedVirtualSwitch.VspanSession[]", "vim.version.version7", F_OPTIONAL), ("pvlanConfig", "vim.dvs.VmwareDistributedVirtualSwitch.PvlanMapEntry[]", "vim.version.version5", F_OPTIONAL), ("maxMtu", "int", "vim.version.version5", 0), ("linkDiscoveryProtocolConfig", "vim.host.LinkDiscoveryProtocolConfig", "vim.version.version5", F_OPTIONAL), ("ipfixConfig", "vim.dvs.VmwareDistributedVirtualSwitch.IpfixConfig", "vim.version.version7", F_OPTIONAL), ("lacpGroupConfig", "vim.dvs.VmwareDistributedVirtualSwitch.LacpGroupConfig[]", "vim.version.version9", F_OPTIONAL), ("lacpApiVersion", "string", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.ConfigSpec", "VMwareDVSConfigSpec", "vim.DistributedVirtualSwitch.ConfigSpec", "vim.version.version5", [("pvlanConfigSpec", "vim.dvs.VmwareDistributedVirtualSwitch.PvlanConfigSpec[]", "vim.version.version5", F_OPTIONAL), ("vspanConfigSpec", "vim.dvs.VmwareDistributedVirtualSwitch.VspanConfigSpec[]", "vim.version.version7", F_OPTIONAL), ("maxMtu", "int", "vim.version.version5", F_OPTIONAL), ("linkDiscoveryProtocolConfig", "vim.host.LinkDiscoveryProtocolConfig", "vim.version.version5", F_OPTIONAL), ("ipfixConfig", "vim.dvs.VmwareDistributedVirtualSwitch.IpfixConfig", "vim.version.version7", F_OPTIONAL), ("lacpApiVersion", "string", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.UplinkPortOrderPolicy", "VMwareUplinkPortOrderPolicy", "vim.InheritablePolicy", "vim.version.version5", [("activeUplinkPort", "string[]", "vim.version.version5", F_OPTIONAL), ("standbyUplinkPort", "string[]", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.FailureCriteria", "DVSFailureCriteria", "vim.InheritablePolicy", "vim.version.version5", [("checkSpeed", "vim.StringPolicy", "vim.version.version5", F_OPTIONAL), ("speed", "vim.IntPolicy", "vim.version.version5", F_OPTIONAL), ("checkDuplex", "vim.BoolPolicy", "vim.version.version5", F_OPTIONAL), ("fullDuplex", "vim.BoolPolicy", "vim.version.version5", F_OPTIONAL), ("checkErrorPercent", "vim.BoolPolicy", "vim.version.version5", F_OPTIONAL), ("percentage", "vim.IntPolicy", "vim.version.version5", F_OPTIONAL), ("checkBeacon", "vim.BoolPolicy", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.UplinkPortTeamingPolicy", "VmwareUplinkPortTeamingPolicy", "vim.InheritablePolicy", "vim.version.version5", [("policy", "vim.StringPolicy", "vim.version.version5", F_OPTIONAL), ("reversePolicy", "vim.BoolPolicy", "vim.version.version5", F_OPTIONAL), ("notifySwitches", "vim.BoolPolicy", "vim.version.version5", F_OPTIONAL), ("rollingOrder", "vim.BoolPolicy", "vim.version.version5", F_OPTIONAL), ("failureCriteria", "vim.dvs.VmwareDistributedVirtualSwitch.FailureCriteria", "vim.version.version5", F_OPTIONAL), ("uplinkPortOrder", "vim.dvs.VmwareDistributedVirtualSwitch.UplinkPortOrderPolicy", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.VlanSpec", "VmwareDistributedVirtualSwitchVlanSpec", "vim.InheritablePolicy", "vim.version.version5", None) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.PvlanSpec", "VmwareDistributedVirtualSwitchPvlanSpec", "vim.dvs.VmwareDistributedVirtualSwitch.VlanSpec", "vim.version.version5", [("pvlanId", "int", "vim.version.version5", 0)]) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.VlanIdSpec", "VmwareDistributedVirtualSwitchVlanIdSpec", "vim.dvs.VmwareDistributedVirtualSwitch.VlanSpec", "vim.version.version5", [("vlanId", "int", "vim.version.version5", 0)]) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.TrunkVlanSpec", "VmwareDistributedVirtualSwitchTrunkVlanSpec", "vim.dvs.VmwareDistributedVirtualSwitch.VlanSpec", "vim.version.version5", [("vlanId", "vim.NumericRange[]", "vim.version.version5", 0)]) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.SecurityPolicy", "DVSSecurityPolicy", "vim.InheritablePolicy", "vim.version.version5", [("allowPromiscuous", "vim.BoolPolicy", "vim.version.version5", F_OPTIONAL), ("macChanges", "vim.BoolPolicy", "vim.version.version5", F_OPTIONAL), ("forgedTransmits", "vim.BoolPolicy", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.VmwarePortConfigPolicy", "VMwareDVSPortSetting", "vim.dvs.DistributedVirtualPort.Setting", "vim.version.version5", [("vlan", "vim.dvs.VmwareDistributedVirtualSwitch.VlanSpec", "vim.version.version5", F_OPTIONAL), ("qosTag", "vim.IntPolicy", "vim.version.version5", F_OPTIONAL), ("uplinkTeamingPolicy", "vim.dvs.VmwareDistributedVirtualSwitch.UplinkPortTeamingPolicy", "vim.version.version5", F_OPTIONAL), ("securityPolicy", "vim.dvs.VmwareDistributedVirtualSwitch.SecurityPolicy", "vim.version.version5", F_OPTIONAL), ("ipfixEnabled", "vim.BoolPolicy", "vim.version.version7", F_OPTIONAL), ("txUplink", "vim.BoolPolicy", "vim.version.version5", F_OPTIONAL), ("lacpPolicy", "vim.dvs.VmwareDistributedVirtualSwitch.UplinkLacpPolicy", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.VMwarePortgroupPolicy", "VMwareDVSPortgroupPolicy", "vim.dvs.DistributedVirtualPortgroup.PortgroupPolicy", "vim.version.version5", [("vlanOverrideAllowed", "boolean", "vim.version.version5", 0), ("uplinkTeamingOverrideAllowed", "boolean", "vim.version.version5", 0), ("securityPolicyOverrideAllowed", "boolean", "vim.version.version5", 0), ("ipfixOverrideAllowed", "boolean", "vim.version.version7", F_OPTIONAL)]) +CreateEnumType("vim.dvs.VmwareDistributedVirtualSwitch.PvlanPortType", "VmwareDistributedVirtualSwitchPvlanPortType", "vim.version.version5", ["promiscuous", "isolated", "community"]) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.PvlanConfigSpec", "VMwareDVSPvlanConfigSpec", "vmodl.DynamicData", "vim.version.version5", [("pvlanEntry", "vim.dvs.VmwareDistributedVirtualSwitch.PvlanMapEntry", "vim.version.version5", 0), ("operation", "string", "vim.version.version5", 0)]) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.PvlanMapEntry", "VMwareDVSPvlanMapEntry", "vmodl.DynamicData", "vim.version.version5", [("primaryVlanId", "int", "vim.version.version5", 0), ("secondaryVlanId", "int", "vim.version.version5", 0), ("pvlanType", "string", "vim.version.version5", 0)]) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.VspanConfigSpec", "VMwareDVSVspanConfigSpec", "vmodl.DynamicData", "vim.version.version7", [("vspanSession", "vim.dvs.VmwareDistributedVirtualSwitch.VspanSession", "vim.version.version7", 0), ("operation", "string", "vim.version.version7", 0)]) +CreateEnumType("vim.dvs.VmwareDistributedVirtualSwitch.VspanSessionType", "VMwareDVSVspanSessionType", "vim.version.version8", ["mixedDestMirror", "dvPortMirror", "remoteMirrorSource", "remoteMirrorDest", "encapsulatedRemoteMirrorSource"]) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.VmwareHealthCheckConfig", "VMwareDVSHealthCheckConfig", "vim.DistributedVirtualSwitch.HealthCheckConfig", "vim.version.version8", None) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.VlanMtuHealthCheckConfig", "VMwareDVSVlanMtuHealthCheckConfig", "vim.dvs.VmwareDistributedVirtualSwitch.VmwareHealthCheckConfig", "vim.version.version8", None) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.TeamingHealthCheckConfig", "VMwareDVSTeamingHealthCheckConfig", "vim.dvs.VmwareDistributedVirtualSwitch.VmwareHealthCheckConfig", "vim.version.version8", None) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.VlanHealthCheckResult", "VMwareDVSVlanHealthCheckResult", "vim.dvs.HostMember.UplinkHealthCheckResult", "vim.version.version8", [("trunkedVlan", "vim.NumericRange[]", "vim.version.version8", F_OPTIONAL), ("untrunkedVlan", "vim.NumericRange[]", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.MtuHealthCheckResult", "VMwareDVSMtuHealthCheckResult", "vim.dvs.HostMember.UplinkHealthCheckResult", "vim.version.version8", [("mtuMismatch", "boolean", "vim.version.version8", 0), ("vlanSupportSwitchMtu", "vim.NumericRange[]", "vim.version.version8", F_OPTIONAL), ("vlanNotSupportSwitchMtu", "vim.NumericRange[]", "vim.version.version8", F_OPTIONAL)]) +CreateEnumType("vim.dvs.VmwareDistributedVirtualSwitch.TeamingMatchStatus", "VMwareDVSTeamingMatchStatus", "vim.version.version8", ["iphashMatch", "nonIphashMatch", "iphashMismatch", "nonIphashMismatch"]) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.TeamingHealthCheckResult", "VMwareDVSTeamingHealthCheckResult", "vim.dvs.HostMember.HealthCheckResult", "vim.version.version8", [("teamingStatus", "string", "vim.version.version8", 0)]) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.UplinkLacpPolicy", "VMwareUplinkLacpPolicy", "vim.InheritablePolicy", "vim.version.version8", [("enable", "vim.BoolPolicy", "vim.version.version8", F_OPTIONAL), ("mode", "vim.StringPolicy", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.LacpGroupConfig", "VMwareDvsLacpGroupConfig", "vmodl.DynamicData", "vim.version.version9", [("key", "string", "vim.version.version9", F_OPTIONAL), ("name", "string", "vim.version.version9", F_OPTIONAL), ("mode", "string", "vim.version.version9", F_OPTIONAL), ("uplinkNum", "int", "vim.version.version9", F_OPTIONAL), ("loadbalanceAlgorithm", "string", "vim.version.version9", F_OPTIONAL), ("vlan", "vim.dvs.VmwareDistributedVirtualSwitch.LagVlanConfig", "vim.version.version9", F_OPTIONAL), ("ipfix", "vim.dvs.VmwareDistributedVirtualSwitch.LagIpfixConfig", "vim.version.version9", F_OPTIONAL), ("uplinkName", "string[]", "vim.version.version9", F_OPTIONAL), ("uplinkPortKey", "string[]", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.LagVlanConfig", "VMwareDvsLagVlanConfig", "vmodl.DynamicData", "vim.version.version9", [("vlanId", "vim.NumericRange[]", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.LagIpfixConfig", "VMwareDvsLagIpfixConfig", "vmodl.DynamicData", "vim.version.version9", [("ipfixEnabled", "boolean", "vim.version.version9", F_OPTIONAL)]) +CreateEnumType("vim.dvs.VmwareDistributedVirtualSwitch.UplinkLacpMode", "VMwareUplinkLacpMode", "vim.version.version8", ["active", "passive"]) +CreateDataType("vim.dvs.VmwareDistributedVirtualSwitch.LacpGroupSpec", "VMwareDvsLacpGroupSpec", "vmodl.DynamicData", "vim.version.version9", [("lacpGroupConfig", "vim.dvs.VmwareDistributedVirtualSwitch.LacpGroupConfig", "vim.version.version9", 0), ("operation", "string", "vim.version.version9", 0)]) +CreateEnumType("vim.dvs.VmwareDistributedVirtualSwitch.LacpLoadBalanceAlgorithm", "VMwareDvsLacpLoadBalanceAlgorithm", "vim.version.version9", ["srcMac", "destMac", "srcDestMac", "destIpVlan", "srcIpVlan", "srcDestIpVlan", "destTcpUdpPort", "srcTcpUdpPort", "srcDestTcpUdpPort", "destIpTcpUdpPort", "srcIpTcpUdpPort", "srcDestIpTcpUdpPort", "destIpTcpUdpPortVlan", "srcIpTcpUdpPortVlan", "srcDestIpTcpUdpPortVlan", "destIp", "srcIp", "srcDestIp", "vlan", "srcPortId"]) +CreateEnumType("vim.dvs.VmwareDistributedVirtualSwitch.LacpApiVersion", "VMwareDvsLacpApiVersion", "vim.version.version9", ["singleLag", "multipleLag"]) +CreateDataType("vim.event.DvsReconfiguredEvent", "DvsReconfiguredEvent", "vim.event.DvsEvent", "vim.version.version5", [("configSpec", "vim.DistributedVirtualSwitch.ConfigSpec", "vim.version.version5", 0)]) +CreateDataType("vim.fault.AdminDisabled", "AdminDisabled", "vim.fault.HostConfigFault", "vim.version.version2", None) +CreateDataType("vim.fault.AdminNotDisabled", "AdminNotDisabled", "vim.fault.HostConfigFault", "vim.version.version2", None) +CreateDataType("vim.fault.AffinityConfigured", "AffinityConfigured", "vim.fault.MigrationFault", "vim.version.version1", [("configuredAffinity", "string[]", "vim.version.version1", 0)]) +CreateEnumType("vim.fault.AffinityConfigured.Affinity", "AffinityType", "vim.version.version1", ["memory", "cpu"]) +CreateDataType("vim.fault.AgentInstallFailed", "AgentInstallFailed", "vim.fault.HostConnectFault", "vim.version.version1", [("reason", "string", "vim.version.version5", F_OPTIONAL), ("statusCode", "int", "vim.version.version5", F_OPTIONAL), ("installerOutput", "string", "vim.version.version5", F_OPTIONAL)]) +CreateEnumType("vim.fault.AgentInstallFailed.Reason", "AgentInstallFailedReason", "vim.version.version5", ["NotEnoughSpaceOnDevice", "PrepareToUpgradeFailed", "AgentNotRunning", "AgentNotReachable", "InstallTimedout", "SignatureVerificationFailed", "AgentUploadFailed", "AgentUploadTimedout", "UnknownInstallerError"]) +CreateDataType("vim.fault.AlreadyBeingManaged", "AlreadyBeingManaged", "vim.fault.HostConnectFault", "vim.version.version1", [("ipAddress", "string", "vim.version.version1", 0)]) +CreateDataType("vim.fault.AlreadyConnected", "AlreadyConnected", "vim.fault.HostConnectFault", "vim.version.version1", [("name", "string", "vim.version.version1", 0)]) +CreateDataType("vim.fault.ApplicationQuiesceFault", "ApplicationQuiesceFault", "vim.fault.SnapshotFault", "vim.version.version1", None) +CreateDataType("vim.fault.BackupBlobReadFailure", "BackupBlobReadFailure", "vim.fault.DvsFault", "vim.version.version8", [("entityName", "string", "vim.version.version8", 0), ("entityType", "string", "vim.version.version8", 0), ("fault", "vmodl.MethodFault", "vim.version.version8", 0)]) +CreateDataType("vim.fault.BackupBlobWriteFailure", "BackupBlobWriteFailure", "vim.fault.DvsFault", "vim.version.version8", [("entityName", "string", "vim.version.version8", 0), ("entityType", "string", "vim.version.version8", 0), ("fault", "vmodl.MethodFault", "vim.version.version8", 0)]) +CreateDataType("vim.fault.BlockedByFirewall", "BlockedByFirewall", "vim.fault.HostConfigFault", "vim.version.version6", None) +CreateDataType("vim.fault.CAMServerRefusedConnection", "CAMServerRefusedConnection", "vim.fault.InvalidCAMServer", "vim.version.version7", None) +CreateDataType("vim.fault.CannotAccessFile", "CannotAccessFile", "vim.fault.FileFault", "vim.version.version1", None) +CreateDataType("vim.fault.CannotAccessNetwork", "CannotAccessNetwork", "vim.fault.CannotAccessVmDevice", "vim.version.version1", None) +CreateDataType("vim.fault.CannotAddHostWithFTVmAsStandalone", "CannotAddHostWithFTVmAsStandalone", "vim.fault.HostConnectFault", "vim.version.version5", None) +CreateDataType("vim.fault.CannotAddHostWithFTVmToDifferentCluster", "CannotAddHostWithFTVmToDifferentCluster", "vim.fault.HostConnectFault", "vim.version.version5", None) +CreateDataType("vim.fault.CannotAddHostWithFTVmToNonHACluster", "CannotAddHostWithFTVmToNonHACluster", "vim.fault.HostConnectFault", "vim.version.version5", None) +CreateDataType("vim.fault.CannotCreateFile", "CannotCreateFile", "vim.fault.FileFault", "vim.version.version2", None) +CreateDataType("vim.fault.CannotDecryptPasswords", "CannotDecryptPasswords", "vim.fault.CustomizationFault", "vim.version.version1", None) +CreateDataType("vim.fault.CannotDeleteFile", "CannotDeleteFile", "vim.fault.FileFault", "vim.version.version1", None) +CreateDataType("vim.fault.CannotModifyConfigCpuRequirements", "CannotModifyConfigCpuRequirements", "vim.fault.MigrationFault", "vim.version.version1", None) +CreateDataType("vim.fault.CannotMoveVmWithDeltaDisk", "CannotMoveVmWithDeltaDisk", "vim.fault.MigrationFault", "vim.version.version7", [("device", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.CannotMoveVmWithNativeDeltaDisk", "CannotMoveVmWithNativeDeltaDisk", "vim.fault.MigrationFault", "vim.version.version7", None) +CreateDataType("vim.fault.CannotPowerOffVmInCluster", "CannotPowerOffVmInCluster", "vim.fault.InvalidState", "vim.version.version7", [("operation", "string", "vim.version.version7", 0), ("vm", "vim.VirtualMachine", "vim.version.version7", 0), ("vmName", "string", "vim.version.version7", 0)]) +CreateEnumType("vim.fault.CannotPowerOffVmInCluster.Operation", "CannotPowerOffVmInClusterOperation", "vim.version.version7", ["suspend", "powerOff", "guestShutdown", "guestSuspend"]) +CreateDataType("vim.fault.ClockSkew", "ClockSkew", "vim.fault.HostConfigFault", "vim.version.version6", None) +CreateDataType("vim.fault.CloneFromSnapshotNotSupported", "CloneFromSnapshotNotSupported", "vim.fault.MigrationFault", "vim.version.version5", None) +CreateDataType("vim.fault.CollectorAddressUnset", "CollectorAddressUnset", "vim.fault.DvsFault", "vim.version.version8", None) +CreateDataType("vim.fault.ConflictingConfiguration", "ConflictingConfiguration", "vim.fault.DvsFault", "vim.version.version9", [("configInConflict", "vim.fault.ConflictingConfiguration.Config[]", "vim.version.version9", 0)]) +CreateDataType("vim.fault.ConflictingConfiguration.Config", "ConflictingConfigurationConfig", "vmodl.DynamicData", "vim.version.version9", [("entity", "vim.ManagedEntity", "vim.version.version9", F_OPTIONAL), ("propertyPath", "string", "vim.version.version9", 0)]) +CreateDataType("vim.fault.CpuIncompatible", "CpuIncompatible", "vim.fault.VirtualHardwareCompatibilityIssue", "vim.version.version1", [("level", "int", "vim.version.version1", 0), ("registerName", "string", "vim.version.version1", 0), ("registerBits", "string", "vim.version.version2", F_OPTIONAL), ("desiredBits", "string", "vim.version.version2", F_OPTIONAL), ("host", "vim.HostSystem", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.fault.CpuIncompatible1ECX", "CpuIncompatible1ECX", "vim.fault.CpuIncompatible", "vim.version.version2", [("sse3", "boolean", "vim.version.version2", 0), ("pclmulqdq", "boolean", "vim.version.version7", 0), ("ssse3", "boolean", "vim.version.version2", 0), ("sse41", "boolean", "vim.version.version2", 0), ("sse42", "boolean", "vim.version.version2", 0), ("aes", "boolean", "vim.version.version7", 0), ("other", "boolean", "vim.version.version2", 0), ("otherOnly", "boolean", "vim.version.version2", 0)]) +CreateDataType("vim.fault.CpuIncompatible81EDX", "CpuIncompatible81EDX", "vim.fault.CpuIncompatible", "vim.version.version2", [("nx", "boolean", "vim.version.version2", 0), ("ffxsr", "boolean", "vim.version.version2", 0), ("rdtscp", "boolean", "vim.version.version2", 0), ("lm", "boolean", "vim.version.version2", 0), ("other", "boolean", "vim.version.version2", 0), ("otherOnly", "boolean", "vim.version.version2", 0)]) +CreateDataType("vim.fault.DatacenterMismatch", "DatacenterMismatch", "vim.fault.MigrationFault", "vim.version.version1", [("invalidArgument", "vim.fault.DatacenterMismatch.Argument[]", "vim.version.version1", 0), ("expectedDatacenter", "vim.Datacenter", "vim.version.version1", 0)]) +CreateDataType("vim.fault.DatacenterMismatch.Argument", "DatacenterMismatchArgument", "vmodl.DynamicData", "vim.version.version1", [("entity", "vim.ManagedEntity", "vim.version.version1", 0), ("inputDatacenter", "vim.Datacenter", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.fault.DatastoreNotWritableOnHost", "DatastoreNotWritableOnHost", "vim.fault.InvalidDatastore", "vim.version.version1", [("host", "vim.HostSystem", "vim.version.version1", 0)]) +CreateDataType("vim.fault.DestinationSwitchFull", "DestinationSwitchFull", "vim.fault.CannotAccessNetwork", "vim.version.version1", None) +CreateDataType("vim.fault.DeviceNotSupported", "DeviceNotSupported", "vim.fault.VirtualHardwareCompatibilityIssue", "vim.version.version1", [("device", "string", "vim.version.version1", 0), ("reason", "string", "vim.version.version2", F_OPTIONAL)]) +CreateEnumType("vim.fault.DeviceNotSupported.Reason", "DeviceNotSupportedReason", "vim.version.version2", ["host", "guest"]) +CreateDataType("vim.fault.DirectoryNotEmpty", "DirectoryNotEmpty", "vim.fault.FileFault", "vim.version.version7", None) +CreateDataType("vim.fault.DisableAdminNotSupported", "DisableAdminNotSupported", "vim.fault.HostConfigFault", "vim.version.version2", None) +CreateDataType("vim.fault.DisallowedMigrationDeviceAttached", "DisallowedMigrationDeviceAttached", "vim.fault.MigrationFault", "vim.version.version1", [("fault", "vmodl.MethodFault", "vim.version.version1", 0)]) +CreateDataType("vim.fault.DiskHasPartitions", "DiskHasPartitions", "vim.fault.VsanDiskFault", "vim.version.version9", None) +CreateDataType("vim.fault.DiskIsLastRemainingNonSSD", "DiskIsLastRemainingNonSSD", "vim.fault.VsanDiskFault", "vim.version.version9", None) +CreateDataType("vim.fault.DiskIsNonLocal", "DiskIsNonLocal", "vim.fault.VsanDiskFault", "vim.version.version9", None) +CreateDataType("vim.fault.DiskIsUSB", "DiskIsUSB", "vim.fault.VsanDiskFault", "vim.version.version9", None) +CreateDataType("vim.fault.DiskMoveTypeNotSupported", "DiskMoveTypeNotSupported", "vim.fault.MigrationFault", "vim.version.version5", None) +CreateDataType("vim.fault.DiskNotSupported", "DiskNotSupported", "vim.fault.VirtualHardwareCompatibilityIssue", "vim.version.version1", [("disk", "int", "vim.version.version1", 0)]) +CreateDataType("vim.fault.DiskTooSmall", "DiskTooSmall", "vim.fault.VsanDiskFault", "vim.version.version9", None) +CreateDataType("vim.fault.DrsVmotionIncompatibleFault", "DrsVmotionIncompatibleFault", "vim.fault.VirtualHardwareCompatibilityIssue", "vim.version.version5", [("host", "vim.HostSystem", "vim.version.version5", 0)]) +CreateDataType("vim.fault.DuplicateDisks", "DuplicateDisks", "vim.fault.VsanDiskFault", "vim.version.version9", None) +CreateDataType("vim.fault.DvsApplyOperationFault", "DvsApplyOperationFault", "vim.fault.DvsFault", "vim.version.version8", [("objectFault", "vim.fault.DvsApplyOperationFault.FaultOnObject[]", "vim.version.version8", 0)]) +CreateDataType("vim.fault.DvsApplyOperationFault.FaultOnObject", "DvsApplyOperationFaultFaultOnObject", "vmodl.DynamicData", "vim.version.version8", [("objectId", "string", "vim.version.version8", 0), ("type", "vmodl.TypeName", "vim.version.version8", 0), ("fault", "vmodl.MethodFault", "vim.version.version8", 0)]) +CreateDataType("vim.fault.EVCAdmissionFailed", "EVCAdmissionFailed", "vim.fault.NotSupportedHostInCluster", "vim.version.version5", [("faults", "vmodl.MethodFault[]", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.fault.EVCAdmissionFailedCPUFeaturesForMode", "EVCAdmissionFailedCPUFeaturesForMode", "vim.fault.EVCAdmissionFailed", "vim.version.version5", [("currentEVCModeKey", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.EVCAdmissionFailedCPUModel", "EVCAdmissionFailedCPUModel", "vim.fault.EVCAdmissionFailed", "vim.version.version5", None) +CreateDataType("vim.fault.EVCAdmissionFailedCPUModelForMode", "EVCAdmissionFailedCPUModelForMode", "vim.fault.EVCAdmissionFailed", "vim.version.version5", [("currentEVCModeKey", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.EVCAdmissionFailedCPUVendor", "EVCAdmissionFailedCPUVendor", "vim.fault.EVCAdmissionFailed", "vim.version.version5", [("clusterCPUVendor", "string", "vim.version.version5", 0), ("hostCPUVendor", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.EVCAdmissionFailedCPUVendorUnknown", "EVCAdmissionFailedCPUVendorUnknown", "vim.fault.EVCAdmissionFailed", "vim.version.version5", None) +CreateDataType("vim.fault.EVCAdmissionFailedHostDisconnected", "EVCAdmissionFailedHostDisconnected", "vim.fault.EVCAdmissionFailed", "vim.version.version5", None) +CreateDataType("vim.fault.EVCAdmissionFailedHostSoftware", "EVCAdmissionFailedHostSoftware", "vim.fault.EVCAdmissionFailed", "vim.version.version5", None) +CreateDataType("vim.fault.EVCAdmissionFailedHostSoftwareForMode", "EVCAdmissionFailedHostSoftwareForMode", "vim.fault.EVCAdmissionFailed", "vim.version.version5", None) +CreateDataType("vim.fault.EVCAdmissionFailedVmActive", "EVCAdmissionFailedVmActive", "vim.fault.EVCAdmissionFailed", "vim.version.version5", None) +CreateDataType("vim.fault.FailToEnableSPBM", "FailToEnableSPBM", "vmodl.fault.NotEnoughLicenses", "vim.version.version7", [("cs", "vim.ComputeResource", "vim.version.version7", 0), ("csName", "string", "vim.version.version7", 0), ("hostLicenseStates", "vim.ComputeResource.HostSPBMLicenseInfo[]", "vim.version.version7", 0)]) +CreateDataType("vim.fault.FaultToleranceAntiAffinityViolated", "FaultToleranceAntiAffinityViolated", "vim.fault.MigrationFault", "vim.version.version5", [("hostName", "string", "vim.version.version5", 0), ("host", "vim.HostSystem", "vim.version.version5", 0)]) +CreateDataType("vim.fault.FaultToleranceCpuIncompatible", "FaultToleranceCpuIncompatible", "vim.fault.CpuIncompatible", "vim.version.version5", [("model", "boolean", "vim.version.version5", 0), ("family", "boolean", "vim.version.version5", 0), ("stepping", "boolean", "vim.version.version5", 0)]) +CreateDataType("vim.fault.FaultToleranceNeedsThickDisk", "FaultToleranceNeedsThickDisk", "vim.fault.MigrationFault", "vim.version.version6", [("vmName", "string", "vim.version.version6", 0)]) +CreateDataType("vim.fault.FaultToleranceNotSameBuild", "FaultToleranceNotSameBuild", "vim.fault.MigrationFault", "vim.version.version5", [("build", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.FeatureRequirementsNotMet", "FeatureRequirementsNotMet", "vim.fault.VirtualHardwareCompatibilityIssue", "vim.version.version8", [("featureRequirement", "vim.vm.FeatureRequirement[]", "vim.version.version8", F_OPTIONAL), ("vm", "vim.VirtualMachine", "vim.version.version8", F_OPTIONAL), ("host", "vim.HostSystem", "vim.version.version8", F_OPTIONAL)]) +CreateDataType("vim.fault.FileAlreadyExists", "FileAlreadyExists", "vim.fault.FileFault", "vim.version.version1", None) +CreateDataType("vim.fault.FileBackedPortNotSupported", "FileBackedPortNotSupported", "vim.fault.DeviceNotSupported", "vim.version.version2", None) +CreateDataType("vim.fault.FilesystemQuiesceFault", "FilesystemQuiesceFault", "vim.fault.SnapshotFault", "vim.version.version1", None) +CreateDataType("vim.fault.FullStorageVMotionNotSupported", "FullStorageVMotionNotSupported", "vim.fault.MigrationFeatureNotSupported", "vim.version.version2", None) +CreateDataType("vim.fault.GuestAuthenticationChallenge", "GuestAuthenticationChallenge", "vim.fault.GuestOperationsFault", "vim.version.version7", [("serverChallenge", "vim.vm.guest.GuestAuthentication", "vim.version.version7", 0), ("sessionID", "long", "vim.version.version7", 0)]) +CreateDataType("vim.fault.GuestComponentsOutOfDate", "GuestComponentsOutOfDate", "vim.fault.GuestOperationsFault", "vim.version.version7", None) +CreateDataType("vim.fault.HAErrorsAtDest", "HAErrorsAtDest", "vim.fault.MigrationFault", "vim.version.version2", None) +CreateDataType("vim.fault.HostConfigFailed", "HostConfigFailed", "vim.fault.HostConfigFault", "vim.version.version5", [("failure", "vmodl.MethodFault[]", "vim.version.version5", 0)]) +CreateDataType("vim.fault.HotSnapshotMoveNotSupported", "HotSnapshotMoveNotSupported", "vim.fault.SnapshotCopyNotSupported", "vim.version.version2", None) +CreateDataType("vim.fault.IDEDiskNotSupported", "IDEDiskNotSupported", "vim.fault.DiskNotSupported", "vim.version.version1", None) +CreateDataType("vim.fault.InaccessibleDatastore", "InaccessibleDatastore", "vim.fault.InvalidDatastore", "vim.version.version1", [("detail", "string", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.fault.IncompatibleDefaultDevice", "IncompatibleDefaultDevice", "vim.fault.MigrationFault", "vim.version.version2", [("device", "string", "vim.version.version2", 0)]) +CreateDataType("vim.fault.IndependentDiskVMotionNotSupported", "IndependentDiskVMotionNotSupported", "vim.fault.MigrationFeatureNotSupported", "vim.version.version2", None) +CreateDataType("vim.fault.InsufficientAgentVmsDeployed", "InsufficientAgentVmsDeployed", "vim.fault.InsufficientResourcesFault", "vim.version.version7", [("hostName", "string", "vim.version.version7", 0), ("requiredNumAgentVms", "int", "vim.version.version7", 0), ("currentNumAgentVms", "int", "vim.version.version7", 0)]) +CreateDataType("vim.fault.InsufficientCpuResourcesFault", "InsufficientCpuResourcesFault", "vim.fault.InsufficientResourcesFault", "vim.version.version1", [("unreserved", "long", "vim.version.version1", 0), ("requested", "long", "vim.version.version1", 0)]) +CreateDataType("vim.fault.InsufficientDisks", "InsufficientDisks", "vim.fault.VsanDiskFault", "vim.version.version9", None) +CreateDataType("vim.fault.InsufficientFailoverResourcesFault", "InsufficientFailoverResourcesFault", "vim.fault.InsufficientResourcesFault", "vim.version.version1", None) +CreateDataType("vim.fault.InsufficientHostCapacityFault", "InsufficientHostCapacityFault", "vim.fault.InsufficientResourcesFault", "vim.version.version1", [("host", "vim.HostSystem", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.fault.InsufficientHostCpuCapacityFault", "InsufficientHostCpuCapacityFault", "vim.fault.InsufficientHostCapacityFault", "vim.version.version5", [("unreserved", "long", "vim.version.version5", 0), ("requested", "long", "vim.version.version5", 0)]) +CreateDataType("vim.fault.InsufficientHostMemoryCapacityFault", "InsufficientHostMemoryCapacityFault", "vim.fault.InsufficientHostCapacityFault", "vim.version.version5", [("unreserved", "long", "vim.version.version5", 0), ("requested", "long", "vim.version.version5", 0)]) +CreateDataType("vim.fault.InsufficientMemoryResourcesFault", "InsufficientMemoryResourcesFault", "vim.fault.InsufficientResourcesFault", "vim.version.version1", [("unreserved", "long", "vim.version.version1", 0), ("requested", "long", "vim.version.version1", 0)]) +CreateDataType("vim.fault.InsufficientPerCpuCapacity", "InsufficientPerCpuCapacity", "vim.fault.InsufficientHostCapacityFault", "vim.version.version2", None) +CreateDataType("vim.fault.InsufficientStandbyCpuResource", "InsufficientStandbyCpuResource", "vim.fault.InsufficientStandbyResource", "vim.version.version5", [("available", "long", "vim.version.version5", 0), ("requested", "long", "vim.version.version5", 0)]) +CreateDataType("vim.fault.InsufficientStandbyMemoryResource", "InsufficientStandbyMemoryResource", "vim.fault.InsufficientStandbyResource", "vim.version.version5", [("available", "long", "vim.version.version5", 0), ("requested", "long", "vim.version.version5", 0)]) +CreateDataType("vim.fault.InvalidBundle", "InvalidBundle", "vim.fault.PlatformConfigFault", "vim.version.version2", None) +CreateDataType("vim.fault.InvalidCAMCertificate", "InvalidCAMCertificate", "vim.fault.InvalidCAMServer", "vim.version.version7", None) +CreateDataType("vim.fault.InvalidClientCertificate", "InvalidClientCertificate", "vim.fault.InvalidLogin", "vim.version.version3", None) +CreateDataType("vim.fault.InvalidDatastoreState", "InvalidDatastoreState", "vim.fault.InvalidState", "vim.version.version7", [("datastoreName", "string", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.fault.InvalidDeviceSpec", "InvalidDeviceSpec", "vim.fault.InvalidVmConfig", "vim.version.version1", [("deviceIndex", "int", "vim.version.version1", 0)]) +CreateDataType("vim.fault.InvalidDiskFormat", "InvalidDiskFormat", "vim.fault.InvalidFormat", "vim.version.version1", None) +CreateDataType("vim.fault.InvalidHostState", "InvalidHostState", "vim.fault.InvalidState", "vim.version.version2", [("host", "vim.HostSystem", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.fault.InvalidNasCredentials", "InvalidNasCredentials", "vim.fault.NasConfigFault", "vim.version.version4", [("userName", "string", "vim.version.version4", 0)]) +CreateDataType("vim.fault.InvalidNetworkInType", "InvalidNetworkInType", "vim.fault.VAppPropertyFault", "vim.version.version5", None) +CreateDataType("vim.fault.InvalidNetworkResource", "InvalidNetworkResource", "vim.fault.NasConfigFault", "vim.version.version4", [("remoteHost", "string", "vim.version.version4", 0), ("remotePath", "string", "vim.version.version4", 0)]) +CreateDataType("vim.fault.InvalidPowerState", "InvalidPowerState", "vim.fault.InvalidState", "vim.version.version1", [("requestedState", "vim.VirtualMachine.PowerState", "vim.version.version1", F_OPTIONAL), ("existingState", "vim.VirtualMachine.PowerState", "vim.version.version1", 0)]) +CreateDataType("vim.fault.InvalidPropertyType", "InvalidPropertyType", "vim.fault.VAppPropertyFault", "vim.version.version5", None) +CreateDataType("vim.fault.InvalidPropertyValue", "InvalidPropertyValue", "vim.fault.VAppPropertyFault", "vim.version.version5", None) +CreateDataType("vim.fault.LargeRDMConversionNotSupported", "LargeRDMConversionNotSupported", "vim.fault.MigrationFault", "vim.version.version7", [("device", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.LegacyNetworkInterfaceInUse", "LegacyNetworkInterfaceInUse", "vim.fault.CannotAccessNetwork", "vim.version.version1", None) +CreateDataType("vim.fault.MaintenanceModeFileMove", "MaintenanceModeFileMove", "vim.fault.MigrationFault", "vim.version.version2", None) +CreateDataType("vim.fault.MemorySizeNotRecommended", "MemorySizeNotRecommended", "vim.fault.VirtualHardwareCompatibilityIssue", "vim.version.version2", [("memorySizeMB", "int", "vim.version.version2", 0), ("minMemorySizeMB", "int", "vim.version.version2", 0), ("maxMemorySizeMB", "int", "vim.version.version2", 0)]) +CreateDataType("vim.fault.MemorySizeNotSupported", "MemorySizeNotSupported", "vim.fault.VirtualHardwareCompatibilityIssue", "vim.version.version2", [("memorySizeMB", "int", "vim.version.version2", 0), ("minMemorySizeMB", "int", "vim.version.version2", 0), ("maxMemorySizeMB", "int", "vim.version.version2", 0)]) +CreateDataType("vim.fault.MemorySizeNotSupportedByDatastore", "MemorySizeNotSupportedByDatastore", "vim.fault.VirtualHardwareCompatibilityIssue", "vim.version.version7", [("datastore", "vim.Datastore", "vim.version.version7", 0), ("memorySizeMB", "int", "vim.version.version7", 0), ("maxMemorySizeMB", "int", "vim.version.version7", 0)]) +CreateDataType("vim.fault.MemorySnapshotOnIndependentDisk", "MemorySnapshotOnIndependentDisk", "vim.fault.SnapshotFault", "vim.version.version1", None) +CreateDataType("vim.fault.MigrationDisabled", "MigrationDisabled", "vim.fault.MigrationFault", "vim.version.version5", None) +CreateDataType("vim.fault.MissingController", "MissingController", "vim.fault.InvalidDeviceSpec", "vim.version.version1", None) +CreateDataType("vim.fault.MissingIpPool", "MissingIpPool", "vim.fault.VAppPropertyFault", "vim.version.version7", None) +CreateDataType("vim.fault.MissingNetworkIpConfig", "MissingNetworkIpConfig", "vim.fault.VAppPropertyFault", "vim.version.version5", None) +CreateDataType("vim.fault.MissingPowerOffConfiguration", "MissingPowerOffConfiguration", "vim.fault.VAppConfigFault", "vim.version.version5", None) +CreateDataType("vim.fault.MissingPowerOnConfiguration", "MissingPowerOnConfiguration", "vim.fault.VAppConfigFault", "vim.version.version5", None) +CreateDataType("vim.fault.MultipleSnapshotsNotSupported", "MultipleSnapshotsNotSupported", "vim.fault.SnapshotFault", "vim.version.version1", None) +CreateDataType("vim.fault.NoAvailableIp", "NoAvailableIp", "vim.fault.VAppPropertyFault", "vim.version.version5", [("network", "vim.Network", "vim.version.version5", 0)]) +CreateDataType("vim.fault.NoVcManagedIpConfigured", "NoVcManagedIpConfigured", "vim.fault.VAppPropertyFault", "vim.version.version5", None) +CreateDataType("vim.fault.NoVmInVApp", "NoVmInVApp", "vim.fault.VAppConfigFault", "vim.version.version5", None) +CreateDataType("vim.fault.NonPersistentDisksNotSupported", "NonPersistentDisksNotSupported", "vim.fault.DeviceNotSupported", "vim.version.version2", None) +CreateDataType("vim.fault.NonVmwareOuiMacNotSupportedHost", "NonVmwareOuiMacNotSupportedHost", "vim.fault.NotSupportedHost", "vim.version.version8", [("hostName", "string", "vim.version.version8", 0)]) +CreateDataType("vim.fault.NotEnoughCpus", "NotEnoughCpus", "vim.fault.VirtualHardwareCompatibilityIssue", "vim.version.version1", [("numCpuDest", "int", "vim.version.version1", 0), ("numCpuVm", "int", "vim.version.version1", 0)]) +CreateDataType("vim.fault.NotEnoughLogicalCpus", "NotEnoughLogicalCpus", "vim.fault.NotEnoughCpus", "vim.version.version1", [("host", "vim.HostSystem", "vim.version.version2", F_OPTIONAL)]) +CreateDataType("vim.fault.NotUserConfigurableProperty", "NotUserConfigurableProperty", "vim.fault.VAppPropertyFault", "vim.version.version5", None) +CreateDataType("vim.fault.NumVirtualCoresPerSocketNotSupported", "NumVirtualCoresPerSocketNotSupported", "vim.fault.VirtualHardwareCompatibilityIssue", "vim.version.version7", [("maxSupportedCoresPerSocketDest", "int", "vim.version.version7", 0), ("numCoresPerSocketVm", "int", "vim.version.version7", 0)]) +CreateDataType("vim.fault.NumVirtualCpusNotSupported", "NumVirtualCpusNotSupported", "vim.fault.VirtualHardwareCompatibilityIssue", "vim.version.version1", [("maxSupportedVcpusDest", "int", "vim.version.version1", 0), ("numCpuVm", "int", "vim.version.version1", 0)]) +CreateDataType("vim.fault.OvfAttribute", "OvfAttribute", "vim.fault.OvfInvalidPackage", "vim.version.version5", [("elementName", "string", "vim.version.version5", 0), ("attributeName", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfConstraint", "OvfConstraint", "vim.fault.OvfInvalidPackage", "vim.version.version6", [("name", "string", "vim.version.version6", 0)]) +CreateDataType("vim.fault.OvfConsumerCallbackFault", "OvfConsumerCallbackFault", "vim.fault.OvfFault", "vim.version.version7", [("extensionKey", "string", "vim.version.version7", 0), ("extensionName", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.OvfConsumerCommunicationError", "OvfConsumerCommunicationError", "vim.fault.OvfConsumerCallbackFault", "vim.version.version7", [("description", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.OvfConsumerFault", "OvfConsumerFault", "vim.fault.OvfConsumerCallbackFault", "vim.version.version7", [("errorKey", "string", "vim.version.version7", 0), ("message", "string", "vim.version.version7", 0), ("params", "vim.KeyValue[]", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.fault.OvfConsumerInvalidSection", "OvfConsumerInvalidSection", "vim.fault.OvfConsumerCallbackFault", "vim.version.version7", [("lineNumber", "int", "vim.version.version7", 0), ("description", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.OvfConsumerUndeclaredSection", "OvfConsumerUndeclaredSection", "vim.fault.OvfConsumerCallbackFault", "vim.version.version7", [("qualifiedSectionType", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.OvfConsumerUndefinedPrefix", "OvfConsumerUndefinedPrefix", "vim.fault.OvfConsumerCallbackFault", "vim.version.version7", [("prefix", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.OvfCpuCompatibility", "OvfCpuCompatibility", "vim.fault.OvfImport", "vim.version.version7", [("registerName", "string", "vim.version.version7", 0), ("level", "int", "vim.version.version7", 0), ("registerValue", "string", "vim.version.version7", 0), ("desiredRegisterValue", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.OvfCpuCompatibilityCheckNotSupported", "OvfCpuCompatibilityCheckNotSupported", "vim.fault.OvfImport", "vim.version.version7", None) +CreateDataType("vim.fault.OvfDiskMappingNotFound", "OvfDiskMappingNotFound", "vim.fault.OvfSystemFault", "vim.version.version5", [("diskName", "string", "vim.version.version5", 0), ("vmName", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfDiskOrderConstraint", "OvfDiskOrderConstraint", "vim.fault.OvfConstraint", "vim.version.version6", None) +CreateDataType("vim.fault.OvfElement", "OvfElement", "vim.fault.OvfInvalidPackage", "vim.version.version5", [("name", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfElementInvalidValue", "OvfElementInvalidValue", "vim.fault.OvfElement", "vim.version.version5", [("value", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfExport", "OvfExport", "vim.fault.OvfFault", "vim.version.version5", None) +CreateDataType("vim.fault.OvfExportFailed", "OvfExportFailed", "vim.fault.OvfExport", "vim.version.version6", None) +CreateDataType("vim.fault.OvfHardwareCheck", "OvfHardwareCheck", "vim.fault.OvfImport", "vim.version.version5", None) +CreateDataType("vim.fault.OvfHardwareExport", "OvfHardwareExport", "vim.fault.OvfExport", "vim.version.version5", [("device", "vim.vm.device.VirtualDevice", "vim.version.version5", F_OPTIONAL), ("vmPath", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfHostResourceConstraint", "OvfHostResourceConstraint", "vim.fault.OvfConstraint", "vim.version.version6", [("value", "string", "vim.version.version6", 0)]) +CreateDataType("vim.fault.OvfHostValueNotParsed", "OvfHostValueNotParsed", "vim.fault.OvfSystemFault", "vim.version.version5", [("property", "string", "vim.version.version5", 0), ("value", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfInternalError", "OvfInternalError", "vim.fault.OvfSystemFault", "vim.version.version6", None) +CreateDataType("vim.fault.OvfInvalidValue", "OvfInvalidValue", "vim.fault.OvfAttribute", "vim.version.version5", [("value", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfInvalidValueConfiguration", "OvfInvalidValueConfiguration", "vim.fault.OvfInvalidValue", "vim.version.version5", None) +CreateDataType("vim.fault.OvfInvalidValueEmpty", "OvfInvalidValueEmpty", "vim.fault.OvfInvalidValue", "vim.version.version5", None) +CreateDataType("vim.fault.OvfInvalidValueFormatMalformed", "OvfInvalidValueFormatMalformed", "vim.fault.OvfInvalidValue", "vim.version.version5", None) +CreateDataType("vim.fault.OvfInvalidValueReference", "OvfInvalidValueReference", "vim.fault.OvfInvalidValue", "vim.version.version5", None) +CreateDataType("vim.fault.OvfInvalidVmName", "OvfInvalidVmName", "vim.fault.OvfUnsupportedPackage", "vim.version.version5", [("name", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfMissingAttribute", "OvfMissingAttribute", "vim.fault.OvfAttribute", "vim.version.version5", None) +CreateDataType("vim.fault.OvfMissingElement", "OvfMissingElement", "vim.fault.OvfElement", "vim.version.version5", None) +CreateDataType("vim.fault.OvfMissingElementNormalBoundary", "OvfMissingElementNormalBoundary", "vim.fault.OvfMissingElement", "vim.version.version5", [("boundary", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfNoHostNic", "OvfNoHostNic", "vim.fault.OvfUnsupportedPackage", "vim.version.version5", None) +CreateDataType("vim.fault.OvfNoSupportedHardwareFamily", "OvfNoSupportedHardwareFamily", "vim.fault.OvfUnsupportedPackage", "vim.version.version5", [("version", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfPropertyExport", "OvfPropertyExport", "vim.fault.OvfExport", "vim.version.version5", [("type", "string", "vim.version.version5", 0), ("value", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfPropertyNetworkExport", "OvfPropertyNetworkExport", "vim.fault.OvfExport", "vim.version.version7", [("network", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.OvfUnableToExportDisk", "OvfUnableToExportDisk", "vim.fault.OvfHardwareExport", "vim.version.version5", [("diskName", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfUnexpectedElement", "OvfUnexpectedElement", "vim.fault.OvfElement", "vim.version.version5", None) +CreateDataType("vim.fault.OvfUnknownDeviceBacking", "OvfUnknownDeviceBacking", "vim.fault.OvfHardwareExport", "vim.version.version5", [("backing", "vim.vm.device.VirtualDevice.BackingInfo", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfUnsupportedAttribute", "OvfUnsupportedAttribute", "vim.fault.OvfUnsupportedPackage", "vim.version.version5", [("elementName", "string", "vim.version.version5", 0), ("attributeName", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfUnsupportedAttributeValue", "OvfUnsupportedAttributeValue", "vim.fault.OvfUnsupportedAttribute", "vim.version.version5", [("value", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfUnsupportedDeviceExport", "OvfUnsupportedDeviceExport", "vim.fault.OvfHardwareExport", "vim.version.version5", None) +CreateDataType("vim.fault.OvfUnsupportedElement", "OvfUnsupportedElement", "vim.fault.OvfUnsupportedPackage", "vim.version.version5", [("name", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfUnsupportedElementValue", "OvfUnsupportedElementValue", "vim.fault.OvfUnsupportedElement", "vim.version.version5", [("value", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfUnsupportedSection", "OvfUnsupportedSection", "vim.fault.OvfUnsupportedElement", "vim.version.version5", [("info", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfWrongElement", "OvfWrongElement", "vim.fault.OvfElement", "vim.version.version5", None) +CreateDataType("vim.fault.PatchAlreadyInstalled", "PatchAlreadyInstalled", "vim.fault.PatchNotApplicable", "vim.version.version1", None) +CreateDataType("vim.fault.PatchInstallFailed", "PatchInstallFailed", "vim.fault.PlatformConfigFault", "vim.version.version1", [("rolledBack", "boolean", "vim.version.version1", 0)]) +CreateDataType("vim.fault.PatchIntegrityError", "PatchIntegrityError", "vim.fault.PlatformConfigFault", "vim.version.version1", None) +CreateDataType("vim.fault.PatchMetadataCorrupted", "PatchMetadataCorrupted", "vim.fault.PatchMetadataInvalid", "vim.version.version1", None) +CreateDataType("vim.fault.PatchMissingDependencies", "PatchMissingDependencies", "vim.fault.PatchNotApplicable", "vim.version.version1", [("prerequisitePatch", "string[]", "vim.version.version1", F_OPTIONAL), ("prerequisiteLib", "string[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.fault.PowerOnFtSecondaryTimedout", "PowerOnFtSecondaryTimedout", "vim.fault.Timedout", "vim.version.version5", [("vm", "vim.VirtualMachine", "vim.version.version5", 0), ("vmName", "string", "vim.version.version5", 0), ("timeout", "int", "vim.version.version5", 0)]) +CreateDataType("vim.fault.QuiesceDatastoreIOForHAFailed", "QuiesceDatastoreIOForHAFailed", "vim.fault.ResourceInUse", "vim.version.version7", [("host", "vim.HostSystem", "vim.version.version7", 0), ("hostName", "string", "vim.version.version7", 0), ("ds", "vim.Datastore", "vim.version.version7", 0), ("dsName", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.RDMNotSupported", "RDMNotSupported", "vim.fault.DeviceNotSupported", "vim.version.version1", None) +CreateDataType("vim.fault.RawDiskNotSupported", "RawDiskNotSupported", "vim.fault.DeviceNotSupported", "vim.version.version1", None) +CreateDataType("vim.fault.RemoteDeviceNotSupported", "RemoteDeviceNotSupported", "vim.fault.DeviceNotSupported", "vim.version.version1", None) +CreateDataType("vim.fault.ReplicationConfigFault", "ReplicationConfigFault", "vim.fault.ReplicationFault", "vim.version.version7", None) +CreateDataType("vim.fault.ReplicationDiskConfigFault", "ReplicationDiskConfigFault", "vim.fault.ReplicationConfigFault", "vim.version.version7", [("reason", "string", "vim.version.version7", F_OPTIONAL), ("vmRef", "vim.VirtualMachine", "vim.version.version7", F_OPTIONAL), ("key", "int", "vim.version.version7", F_OPTIONAL)]) +CreateEnumType("vim.fault.ReplicationDiskConfigFault.ReasonForFault", "ReplicationDiskConfigFaultReasonForFault", "vim.version.version7", ["diskNotFound", "diskTypeNotSupported", "invalidDiskKey", "invalidDiskReplicationId", "duplicateDiskReplicationId", "invalidPersistentFilePath", "reconfigureDiskReplicationIdNotAllowed"]) +CreateDataType("vim.fault.ReplicationVmConfigFault", "ReplicationVmConfigFault", "vim.fault.ReplicationConfigFault", "vim.version.version7", [("reason", "string", "vim.version.version7", F_OPTIONAL), ("vmRef", "vim.VirtualMachine", "vim.version.version7", F_OPTIONAL)]) +CreateEnumType("vim.fault.ReplicationVmConfigFault.ReasonForFault", "ReplicationVmConfigFaultReasonForFault", "vim.version.version7", ["incompatibleHwVersion", "invalidVmReplicationId", "invalidGenerationNumber", "outOfBoundsRpoValue", "invalidDestinationIpAddress", "invalidDestinationPort", "invalidExtraVmOptions", "staleGenerationNumber", "reconfigureVmReplicationIdNotAllowed", "cannotRetrieveVmReplicationConfiguration", "replicationAlreadyEnabled", "invalidPriorConfiguration", "replicationNotEnabled", "replicationConfigurationFailed"]) +CreateDataType("vim.fault.SharedBusControllerNotSupported", "SharedBusControllerNotSupported", "vim.fault.DeviceNotSupported", "vim.version.version1", None) +CreateDataType("vim.fault.SnapshotCloneNotSupported", "SnapshotCloneNotSupported", "vim.fault.SnapshotCopyNotSupported", "vim.version.version2", None) +CreateDataType("vim.fault.SnapshotDisabled", "SnapshotDisabled", "vim.fault.SnapshotFault", "vim.version.version2", None) +CreateDataType("vim.fault.StorageVmotionIncompatible", "StorageVmotionIncompatible", "vim.fault.VirtualHardwareCompatibilityIssue", "vim.version.version7", [("datastore", "vim.Datastore", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.fault.SwapDatastoreNotWritableOnHost", "SwapDatastoreNotWritableOnHost", "vim.fault.DatastoreNotWritableOnHost", "vim.version.version2", None) +CreateDataType("vim.fault.UnSupportedDatastoreForVFlash", "UnSupportedDatastoreForVFlash", "vim.fault.UnsupportedDatastore", "vim.version.version9", [("datastoreName", "string", "vim.version.version9", 0), ("type", "string", "vim.version.version9", 0)]) +CreateDataType("vim.fault.UnconfiguredPropertyValue", "UnconfiguredPropertyValue", "vim.fault.InvalidPropertyValue", "vim.version.version5", None) +CreateDataType("vim.fault.VMINotSupported", "VMINotSupported", "vim.fault.DeviceNotSupported", "vim.version.version2", None) +CreateDataType("vim.fault.VMOnConflictDVPort", "VMOnConflictDVPort", "vim.fault.CannotAccessNetwork", "vim.version.version5", None) +CreateDataType("vim.fault.VMOnVirtualIntranet", "VMOnVirtualIntranet", "vim.fault.CannotAccessNetwork", "vim.version.version1", None) +CreateDataType("vim.fault.VirtualDiskModeNotSupported", "VirtualDiskModeNotSupported", "vim.fault.DeviceNotSupported", "vim.version.version6", [("mode", "string", "vim.version.version6", 0)]) +CreateDataType("vim.fault.VirtualEthernetCardNotSupported", "VirtualEthernetCardNotSupported", "vim.fault.DeviceNotSupported", "vim.version.version2", None) +CreateDataType("vim.fault.VmfsAlreadyMounted", "VmfsAlreadyMounted", "vim.fault.VmfsMountFault", "vim.version.version5", None) +CreateDataType("vim.fault.VmfsAmbiguousMount", "VmfsAmbiguousMount", "vim.fault.VmfsMountFault", "vim.version.version5", None) +CreateDataType("vim.host.ConfigInfo", "HostConfigInfo", "vmodl.DynamicData", "vim.version.version1", [("host", "vim.HostSystem", "vim.version.version1", 0), ("product", "vim.AboutInfo", "vim.version.version1", 0), ("hyperThread", "vim.host.CpuSchedulerSystem.HyperThreadScheduleInfo", "vim.version.version1", F_OPTIONAL), ("consoleReservation", "vim.host.MemoryManagerSystem.ServiceConsoleReservationInfo", "vim.version.version1", F_OPTIONAL), ("virtualMachineReservation", "vim.host.MemoryManagerSystem.VirtualMachineReservationInfo", "vim.version.version2", F_OPTIONAL), ("storageDevice", "vim.host.StorageDeviceInfo", "vim.version.version1", F_OPTIONAL), ("multipathState", "vim.host.MultipathStateInfo", "vim.version.version5", F_OPTIONAL), ("fileSystemVolume", "vim.host.FileSystemVolumeInfo", "vim.version.version1", F_OPTIONAL), ("systemFile", "string[]", "vim.version.version6", F_OPTIONAL), ("network", "vim.host.NetworkInfo", "vim.version.version1", F_OPTIONAL), ("vmotion", "vim.host.VMotionInfo", "vim.version.version1", F_OPTIONAL), ("virtualNicManagerInfo", "vim.host.VirtualNicManagerInfo", "vim.version.version5", F_OPTIONAL), ("capabilities", "vim.host.NetCapabilities", "vim.version.version1", F_OPTIONAL), ("datastoreCapabilities", "vim.host.DatastoreSystem.Capabilities", "vim.version.version2", F_OPTIONAL), ("offloadCapabilities", "vim.host.NetOffloadCapabilities", "vim.version.version1", F_OPTIONAL), ("service", "vim.host.ServiceInfo", "vim.version.version1", F_OPTIONAL), ("firewall", "vim.host.FirewallInfo", "vim.version.version1", F_OPTIONAL), ("autoStart", "vim.host.AutoStartManager.Config", "vim.version.version1", F_OPTIONAL), ("activeDiagnosticPartition", "vim.host.DiagnosticPartition", "vim.version.version1", F_OPTIONAL), ("option", "vim.option.OptionValue[]", "vim.version.version1", F_OPTIONAL), ("optionDef", "vim.option.OptionDef[]", "vim.version.version1", F_OPTIONAL), ("datastorePrincipal", "string", "vim.version.version1", F_OPTIONAL), ("localSwapDatastore", "vim.Datastore", "vim.version.version2", F_OPTIONAL), ("systemSwapConfiguration", "vim.host.SystemSwapConfiguration", "vim.version.version8", F_OPTIONAL), ("systemResources", "vim.host.SystemResourceInfo", "vim.version.version1", F_OPTIONAL), ("dateTimeInfo", "vim.host.DateTimeInfo", "vim.version.version2", F_OPTIONAL), ("flags", "vim.host.FlagInfo", "vim.version.version2", F_OPTIONAL), ("adminDisabled", "boolean", "vim.version.version2", F_OPTIONAL), ("ipmi", "vim.host.IpmiInfo", "vim.version.version5", F_OPTIONAL), ("sslThumbprintInfo", "vim.host.SslThumbprintInfo", "vim.version.version5", F_OPTIONAL), ("sslThumbprintData", "vim.host.SslThumbprintInfo[]", "vim.version.version7", F_OPTIONAL), ("certificate", "byte[]", "vim.version.version7", F_OPTIONAL), ("pciPassthruInfo", "vim.host.PciPassthruInfo[]", "vim.version.version5", F_OPTIONAL), ("authenticationManagerInfo", "vim.host.AuthenticationManagerInfo", "vim.version.version6", F_OPTIONAL), ("featureVersion", "vim.host.FeatureVersionInfo[]", "vim.version.version6", F_OPTIONAL), ("powerSystemCapability", "vim.host.PowerSystem.Capability", "vim.version.version6", F_OPTIONAL), ("powerSystemInfo", "vim.host.PowerSystem.Info", "vim.version.version6", F_OPTIONAL), ("cacheConfigurationInfo", "vim.host.CacheConfigurationManager.CacheConfigurationInfo[]", "vim.version.version7", F_OPTIONAL), ("wakeOnLanCapable", "boolean", "vim.version.version7", F_OPTIONAL), ("featureCapability", "vim.host.FeatureCapability[]", "vim.version.version8", F_OPTIONAL), ("maskedFeatureCapability", "vim.host.FeatureCapability[]", "vim.version.version8", F_OPTIONAL), ("vFlashConfigInfo", "vim.host.VFlashManager.VFlashConfigInfo", "vim.version.version9", F_OPTIONAL), ("vsanHostConfig", "vim.vsan.host.ConfigInfo", "vim.version.version9", F_OPTIONAL), ("graphicsInfo", "vim.host.GraphicsInfo[]", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.host.ConnectInfo", "HostConnectInfo", "vmodl.DynamicData", "vim.version.version1", [("serverIp", "string", "vim.version.version1", F_OPTIONAL), ("inDasCluster", "boolean", "vim.version.version7", F_OPTIONAL), ("host", "vim.host.Summary", "vim.version.version1", 0), ("vm", "vim.vm.Summary[]", "vim.version.version1", F_OPTIONAL), ("vimAccountNameRequired", "boolean", "vim.version.version1", F_OPTIONAL), ("clusterSupported", "boolean", "vim.version.version1", F_OPTIONAL), ("network", "vim.host.ConnectInfo.NetworkInfo[]", "vim.version.version1", F_OPTIONAL), ("datastore", "vim.host.ConnectInfo.DatastoreInfo[]", "vim.version.version1", F_OPTIONAL), ("license", "vim.host.ConnectInfo.LicenseInfo", "vim.version.version5", F_OPTIONAL)]) +CreateDataType("vim.host.ConnectInfo.NetworkInfo", "HostConnectInfoNetworkInfo", "vmodl.DynamicData", "vim.version.version1", [("summary", "vim.Network.Summary", "vim.version.version1", 0)]) +CreateDataType("vim.host.ConnectInfo.NewNetworkInfo", "HostNewNetworkConnectInfo", "vim.host.ConnectInfo.NetworkInfo", "vim.version.version1", None) +CreateDataType("vim.host.ConnectInfo.DatastoreInfo", "HostDatastoreConnectInfo", "vmodl.DynamicData", "vim.version.version1", [("summary", "vim.Datastore.Summary", "vim.version.version1", 0)]) +CreateDataType("vim.host.ConnectInfo.DatastoreExistsInfo", "HostDatastoreExistsConnectInfo", "vim.host.ConnectInfo.DatastoreInfo", "vim.version.version1", [("newDatastoreName", "string", "vim.version.version1", 0)]) +CreateDataType("vim.host.ConnectInfo.DatastoreNameConflictInfo", "HostDatastoreNameConflictConnectInfo", "vim.host.ConnectInfo.DatastoreInfo", "vim.version.version1", [("newDatastoreName", "string", "vim.version.version1", 0)]) +CreateDataType("vim.host.ConnectInfo.LicenseInfo", "HostLicenseConnectInfo", "vmodl.DynamicData", "vim.version.version5", [("license", "vim.LicenseManager.LicenseInfo", "vim.version.version5", 0), ("evaluation", "vim.LicenseManager.EvaluationInfo", "vim.version.version5", 0), ("resource", "vim.LicenseManager.LicensableResourceInfo", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.host.VmfsDatastoreInfo", "VmfsDatastoreInfo", "vim.Datastore.Info", "vim.version.version1", [("maxPhysicalRDMFileSize", "long", "vim.version.version8", 0), ("maxVirtualRDMFileSize", "long", "vim.version.version8", 0), ("vmfs", "vim.host.VmfsVolume", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.NasDatastoreInfo", "NasDatastoreInfo", "vim.Datastore.Info", "vim.version.version1", [("nas", "vim.host.NasVolume", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.LocalDatastoreInfo", "LocalDatastoreInfo", "vim.Datastore.Info", "vim.version.version1", [("path", "string", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.VmfsDatastoreCreateSpec", "VmfsDatastoreCreateSpec", "vim.host.VmfsDatastoreSpec", "vim.version.version1", [("partition", "vim.host.DiskPartitionInfo.Specification", "vim.version.version1", 0), ("vmfs", "vim.host.VmfsVolume.Specification", "vim.version.version1", 0), ("extent", "vim.host.ScsiDisk.Partition[]", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.VmfsDatastoreExtendSpec", "VmfsDatastoreExtendSpec", "vim.host.VmfsDatastoreSpec", "vim.version.version1", [("partition", "vim.host.DiskPartitionInfo.Specification", "vim.version.version1", 0), ("extent", "vim.host.ScsiDisk.Partition[]", "vim.version.version1", 0)]) +CreateDataType("vim.host.VmfsDatastoreExpandSpec", "VmfsDatastoreExpandSpec", "vim.host.VmfsDatastoreSpec", "vim.version.version5", [("partition", "vim.host.DiskPartitionInfo.Specification", "vim.version.version5", 0), ("extent", "vim.host.ScsiDisk.Partition", "vim.version.version5", 0)]) +CreateDataType("vim.host.DiagnosticPartition", "HostDiagnosticPartition", "vmodl.DynamicData", "vim.version.version1", [("storageType", "string", "vim.version.version1", 0), ("diagnosticType", "string", "vim.version.version1", 0), ("slots", "int", "vim.version.version1", 0), ("id", "vim.host.ScsiDisk.Partition", "vim.version.version1", 0)]) +CreateEnumType("vim.host.DiagnosticPartition.StorageType", "DiagnosticPartitionStorageType", "vim.version.version1", ["directAttached", "networkAttached"]) +CreateEnumType("vim.host.DiagnosticPartition.DiagnosticType", "DiagnosticPartitionType", "vim.version.version1", ["singleHost", "multiHost"]) +CreateDataType("vim.host.DiagnosticPartition.CreateOption", "HostDiagnosticPartitionCreateOption", "vmodl.DynamicData", "vim.version.version1", [("storageType", "string", "vim.version.version1", 0), ("diagnosticType", "string", "vim.version.version1", 0), ("disk", "vim.host.ScsiDisk", "vim.version.version1", 0)]) +CreateDataType("vim.host.DiagnosticPartition.CreateSpec", "HostDiagnosticPartitionCreateSpec", "vmodl.DynamicData", "vim.version.version1", [("storageType", "string", "vim.version.version1", 0), ("diagnosticType", "string", "vim.version.version1", 0), ("id", "vim.host.ScsiDisk.Partition", "vim.version.version1", 0), ("partition", "vim.host.DiskPartitionInfo.Specification", "vim.version.version1", 0), ("active", "boolean", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.host.DiagnosticPartition.CreateDescription", "HostDiagnosticPartitionCreateDescription", "vmodl.DynamicData", "vim.version.version1", [("layout", "vim.host.DiskPartitionInfo.Layout", "vim.version.version1", 0), ("diskUuid", "string", "vim.version.version1", 0), ("spec", "vim.host.DiagnosticPartition.CreateSpec", "vim.version.version1", 0)]) +CreateDataType("vim.host.RuntimeInfo", "HostRuntimeInfo", "vmodl.DynamicData", "vim.version.version1", [("connectionState", "vim.HostSystem.ConnectionState", "vim.version.version1", 0), ("powerState", "vim.HostSystem.PowerState", "vim.version.version2", 0), ("standbyMode", "string", "vim.version.version6", F_OPTIONAL), ("inMaintenanceMode", "boolean", "vim.version.version1", 0), ("bootTime", "vmodl.DateTime", "vim.version.version1", F_OPTIONAL), ("healthSystemRuntime", "vim.host.HealthStatusSystem.Runtime", "vim.version.version2", F_OPTIONAL), ("dasHostState", "vim.cluster.DasFdmHostState", "vim.version.version7", F_OPTIONAL), ("tpmPcrValues", "vim.host.TpmDigestInfo[]", "vim.version.version5", F_OPTIONAL), ("vsanRuntimeInfo", "vim.vsan.host.VsanRuntimeInfo", "vim.version.version9", F_OPTIONAL), ("networkRuntimeInfo", "vim.host.RuntimeInfo.NetworkRuntimeInfo", "vim.version.version9", F_OPTIONAL), ("vFlashResourceRuntimeInfo", "vim.host.VFlashManager.VFlashResourceRunTimeInfo", "vim.version.version9", F_OPTIONAL), ("hostMaxVirtualDiskCapacity", "long", "vim.version.version9", F_OPTIONAL)]) +CreateDataType("vim.host.RuntimeInfo.NetStackInstanceRuntimeInfo", "HostRuntimeInfoNetStackInstanceRuntimeInfo", "vmodl.DynamicData", "vim.version.version9", [("netStackInstanceKey", "string", "vim.version.version9", 0), ("state", "string", "vim.version.version9", F_OPTIONAL), ("vmknicKeys", "string[]", "vim.version.version9", F_OPTIONAL), ("maxNumberOfConnections", "int", "vim.version.version9", F_OPTIONAL), ("currentIpV6Enabled", "boolean", "vim.version.version9", F_OPTIONAL)]) +CreateEnumType("vim.host.RuntimeInfo.NetStackInstanceRuntimeInfo.State", "HostRuntimeInfoNetStackInstanceRuntimeInfoState", "vim.version.version9", ["inactive", "active", "deactivating", "activating"]) +CreateDataType("vim.host.RuntimeInfo.NetworkRuntimeInfo", "HostRuntimeInfoNetworkRuntimeInfo", "vmodl.DynamicData", "vim.version.version9", [("netStackInstanceRuntimeInfo", "vim.host.RuntimeInfo.NetStackInstanceRuntimeInfo[]", "vim.version.version9", F_OPTIONAL)]) +CreateManagedType("vim.host.StorageSystem", "HostStorageSystem", "vim.ExtensibleManagedObject", "vim.version.version1", [("storageDeviceInfo", "vim.host.StorageDeviceInfo", "vim.version.version1", F_OPTIONAL, None), ("fileSystemVolumeInfo", "vim.host.FileSystemVolumeInfo", "vim.version.version1", 0, None), ("systemFile", "string[]", "vim.version.version6", F_OPTIONAL, None), ("multipathStateInfo", "vim.host.MultipathStateInfo", "vim.version.version5", F_OPTIONAL, None)], [("retrieveDiskPartitionInfo", "RetrieveDiskPartitionInfo", "vim.version.version1", (("devicePath", "string[]", "vim.version.version1", 0, None),), (F_OPTIONAL, "vim.host.DiskPartitionInfo[]", "vim.host.DiskPartitionInfo[]"), "System.Read", None), ("computeDiskPartitionInfo", "ComputeDiskPartitionInfo", "vim.version.version1", (("devicePath", "string", "vim.version.version1", 0, None),("layout", "vim.host.DiskPartitionInfo.Layout", "vim.version.version1", 0, None),("partitionFormat", "string", "vim.version.version7", F_OPTIONAL, None),), (0, "vim.host.DiskPartitionInfo", "vim.host.DiskPartitionInfo"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("computeDiskPartitionInfoForResize", "ComputeDiskPartitionInfoForResize", "vim.version.version5", (("partition", "vim.host.ScsiDisk.Partition", "vim.version.version5", 0, None),("blockRange", "vim.host.DiskPartitionInfo.BlockRange", "vim.version.version5", 0, None),("partitionFormat", "string", "vim.version.version7", F_OPTIONAL, None),), (0, "vim.host.DiskPartitionInfo", "vim.host.DiskPartitionInfo"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("updateDiskPartitions", "UpdateDiskPartitions", "vim.version.version1", (("devicePath", "string", "vim.version.version1", 0, None),("spec", "vim.host.DiskPartitionInfo.Specification", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("formatVmfs", "FormatVmfs", "vim.version.version1", (("createSpec", "vim.host.VmfsVolume.Specification", "vim.version.version1", 0, None),), (0, "vim.host.VmfsVolume", "vim.host.VmfsVolume"), "Host.Config.Storage", ["vim.fault.AlreadyExists", "vim.fault.HostConfigFault", ]), ("mountVmfsVolume", "MountVmfsVolume", "vim.version.version7", (("vmfsUuid", "string", "vim.version.version7", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.InvalidState", "vim.fault.HostConfigFault", "vim.fault.ResourceInUse", ]), ("unmountVmfsVolume", "UnmountVmfsVolume", "vim.version.version7", (("vmfsUuid", "string", "vim.version.version7", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.InvalidState", "vim.fault.HostConfigFault", "vim.fault.ResourceInUse", ]), ("deleteVmfsVolumeState", "DeleteVmfsVolumeState", "vim.version.version7", (("vmfsUuid", "string", "vim.version.version7", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.HostConfigFault", ]), ("rescanVmfs", "RescanVmfs", "vim.version.version1", (), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.HostConfigFault", ]), ("attachVmfsExtent", "AttachVmfsExtent", "vim.version.version1", (("vmfsPath", "string", "vim.version.version1", 0, None),("extent", "vim.host.ScsiDisk.Partition", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("expandVmfsExtent", "ExpandVmfsExtent", "vim.version.version5", (("vmfsPath", "string", "vim.version.version5", 0, None),("extent", "vim.host.ScsiDisk.Partition", "vim.version.version5", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("upgradeVmfs", "UpgradeVmfs", "vim.version.version1", (("vmfsPath", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("upgradeVmLayout", "UpgradeVmLayout", "vim.version.version1", (), (0, "void", "void"), "Host.Config.Storage", None), ("queryUnresolvedVmfsVolume", "QueryUnresolvedVmfsVolume", "vim.version.version5", (), (F_OPTIONAL, "vim.host.UnresolvedVmfsVolume[]", "vim.host.UnresolvedVmfsVolume[]"), "System.Read", None), ("resolveMultipleUnresolvedVmfsVolumes", "ResolveMultipleUnresolvedVmfsVolumes", "vim.version.version5", (("resolutionSpec", "vim.host.UnresolvedVmfsResolutionSpec[]", "vim.version.version5", 0, None),), (F_OPTIONAL, "vim.host.UnresolvedVmfsResolutionResult[]", "vim.host.UnresolvedVmfsResolutionResult[]"), "Host.Config.Storage", ["vim.fault.HostConfigFault", ]), ("resolveMultipleUnresolvedVmfsVolumesEx", "ResolveMultipleUnresolvedVmfsVolumesEx_Task", "vim.version.version9", (("resolutionSpec", "vim.host.UnresolvedVmfsResolutionSpec[]", "vim.version.version9", 0, None),), (F_OPTIONAL, "vim.Task", "vim.host.UnresolvedVmfsResolutionResult[]"), "Host.Config.Storage", ["vim.fault.HostConfigFault", ]), ("unmountForceMountedVmfsVolume", "UnmountForceMountedVmfsVolume", "vim.version.version5", (("vmfsUuid", "string", "vim.version.version5", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("rescanHba", "RescanHba", "vim.version.version1", (("hbaDevice", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("rescanAllHba", "RescanAllHba", "vim.version.version1", (), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.HostConfigFault", ]), ("updateSoftwareInternetScsiEnabled", "UpdateSoftwareInternetScsiEnabled", "vim.version.version1", (("enabled", "boolean", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.HostConfigFault", ]), ("updateInternetScsiDiscoveryProperties", "UpdateInternetScsiDiscoveryProperties", "vim.version.version1", (("iScsiHbaDevice", "string", "vim.version.version1", 0, None),("discoveryProperties", "vim.host.InternetScsiHba.DiscoveryProperties", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("updateInternetScsiAuthenticationProperties", "UpdateInternetScsiAuthenticationProperties", "vim.version.version1", (("iScsiHbaDevice", "string", "vim.version.version1", 0, None),("authenticationProperties", "vim.host.InternetScsiHba.AuthenticationProperties", "vim.version.version1", 0, None),("targetSet", "vim.host.InternetScsiHba.TargetSet", "vim.version.version5", F_OPTIONAL, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("updateInternetScsiDigestProperties", "UpdateInternetScsiDigestProperties", "vim.version.version5", (("iScsiHbaDevice", "string", "vim.version.version5", 0, None),("targetSet", "vim.host.InternetScsiHba.TargetSet", "vim.version.version5", F_OPTIONAL, None),("digestProperties", "vim.host.InternetScsiHba.DigestProperties", "vim.version.version5", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("updateInternetScsiAdvancedOptions", "UpdateInternetScsiAdvancedOptions", "vim.version.version5", (("iScsiHbaDevice", "string", "vim.version.version5", 0, None),("targetSet", "vim.host.InternetScsiHba.TargetSet", "vim.version.version5", F_OPTIONAL, None),("options", "vim.host.InternetScsiHba.ParamValue[]", "vim.version.version5", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("updateInternetScsiIPProperties", "UpdateInternetScsiIPProperties", "vim.version.version1", (("iScsiHbaDevice", "string", "vim.version.version1", 0, None),("ipProperties", "vim.host.InternetScsiHba.IPProperties", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("updateInternetScsiName", "UpdateInternetScsiName", "vim.version.version1", (("iScsiHbaDevice", "string", "vim.version.version1", 0, None),("iScsiName", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("updateInternetScsiAlias", "UpdateInternetScsiAlias", "vim.version.version1", (("iScsiHbaDevice", "string", "vim.version.version1", 0, None),("iScsiAlias", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("addInternetScsiSendTargets", "AddInternetScsiSendTargets", "vim.version.version1", (("iScsiHbaDevice", "string", "vim.version.version1", 0, None),("targets", "vim.host.InternetScsiHba.SendTarget[]", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("removeInternetScsiSendTargets", "RemoveInternetScsiSendTargets", "vim.version.version1", (("iScsiHbaDevice", "string", "vim.version.version1", 0, None),("targets", "vim.host.InternetScsiHba.SendTarget[]", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("addInternetScsiStaticTargets", "AddInternetScsiStaticTargets", "vim.version.version1", (("iScsiHbaDevice", "string", "vim.version.version1", 0, None),("targets", "vim.host.InternetScsiHba.StaticTarget[]", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("removeInternetScsiStaticTargets", "RemoveInternetScsiStaticTargets", "vim.version.version1", (("iScsiHbaDevice", "string", "vim.version.version1", 0, None),("targets", "vim.host.InternetScsiHba.StaticTarget[]", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("enableMultipathPath", "EnableMultipathPath", "vim.version.version1", (("pathName", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("disableMultipathPath", "DisableMultipathPath", "vim.version.version1", (("pathName", "string", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("setMultipathLunPolicy", "SetMultipathLunPolicy", "vim.version.version1", (("lunId", "string", "vim.version.version1", 0, None),("policy", "vim.host.MultipathInfo.LogicalUnitPolicy", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("queryPathSelectionPolicyOptions", "QueryPathSelectionPolicyOptions", "vim.version.version5", (), (F_OPTIONAL, "vim.host.PathSelectionPolicyOption[]", "vim.host.PathSelectionPolicyOption[]"), "System.Read", ["vim.fault.HostConfigFault", ]), ("queryStorageArrayTypePolicyOptions", "QueryStorageArrayTypePolicyOptions", "vim.version.version5", (), (F_OPTIONAL, "vim.host.StorageArrayTypePolicyOption[]", "vim.host.StorageArrayTypePolicyOption[]"), "System.Read", ["vim.fault.HostConfigFault", ]), ("updateScsiLunDisplayName", "UpdateScsiLunDisplayName", "vim.version.version5", (("lunUuid", "string", "vim.version.version5", 0, None),("displayName", "string", "vim.version.version5", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", "vim.fault.InvalidName", "vim.fault.DuplicateName", ]), ("detachScsiLun", "DetachScsiLun", "vim.version.version7", (("lunUuid", "string", "vim.version.version7", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", "vim.fault.InvalidState", "vim.fault.ResourceInUse", ]), ("deleteScsiLunState", "DeleteScsiLunState", "vim.version.version7", (("lunCanonicalName", "string", "vim.version.version7", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.HostConfigFault", ]), ("attachScsiLun", "AttachScsiLun", "vim.version.version7", (("lunUuid", "string", "vim.version.version7", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", "vim.fault.InvalidState", ]), ("refresh", "RefreshStorageSystem", "vim.version.version1", (), (0, "void", "void"), "Host.Config.Storage", None), ("discoverFcoeHbas", "DiscoverFcoeHbas", "vim.version.version7", (("fcoeSpec", "vim.host.FcoeConfig.FcoeSpecification", "vim.version.version7", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.FcoeFaultPnicHasNoPortSet", "vim.fault.HostConfigFault", "vim.fault.NotFound", ]), ("markForRemoval", "MarkForRemoval", "vim.version.version7", (("hbaName", "string", "vim.version.version7", 0, None),("remove", "boolean", "vim.version.version7", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("formatVffs", "FormatVffs", "vim.version.version9", (("createSpec", "vim.host.VffsVolume.Specification", "vim.version.version9", 0, None),), (0, "vim.host.VffsVolume", "vim.host.VffsVolume"), "Host.Config.Storage", ["vim.fault.AlreadyExists", "vim.fault.HostConfigFault", "vim.fault.ResourceInUse", ]), ("extendVffs", "ExtendVffs", "vim.version.version9", (("vffsPath", "string", "vim.version.version9", 0, None),("devicePath", "string", "vim.version.version9", 0, None),("spec", "vim.host.DiskPartitionInfo.Specification", "vim.version.version9", F_OPTIONAL, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", "vim.fault.ResourceInUse", ]), ("destroyVffs", "DestroyVffs", "vim.version.version9", (("vffsPath", "string", "vim.version.version9", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", "vim.fault.ResourceInUse", ]), ("mountVffsVolume", "MountVffsVolume", "vim.version.version9", (("vffsUuid", "string", "vim.version.version9", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.InvalidState", "vim.fault.HostConfigFault", "vim.fault.ResourceInUse", ]), ("unmountVffsVolume", "UnmountVffsVolume", "vim.version.version9", (("vffsUuid", "string", "vim.version.version9", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.InvalidState", "vim.fault.HostConfigFault", "vim.fault.ResourceInUse", ]), ("deleteVffsVolumeState", "DeleteVffsVolumeState", "vim.version.version9", (("vffsUuid", "string", "vim.version.version9", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.HostConfigFault", ]), ("rescanVffs", "RescanVffs", "vim.version.version9", (), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.HostConfigFault", ]), ("queryAvailableSsds", "QueryAvailableSsds", "vim.version.version9", (("vffsPath", "string", "vim.version.version9", F_OPTIONAL, None),), (F_OPTIONAL, "vim.host.ScsiDisk[]", "vim.host.ScsiDisk[]"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ])]) +CreateEnumType("vim.host.VMotionManager.VMotionType", "HostVMotionManagerVMotionType", "vim.version.version5", ["vmotion", "fast_suspend_resume", "fault_tolerance", "disks_only", "memory_mirror"]) +CreateManagedType("vim.view.ContainerView", "ContainerView", "vim.view.ManagedObjectView", "vim.version.version2", [("container", "vim.ManagedEntity", "vim.version.version2", 0, None), ("type", "vmodl.TypeName[]", "vim.version.version2", F_OPTIONAL, None), ("recursive", "boolean", "vim.version.version2", 0, None)], None) +CreateManagedType("vim.view.InventoryView", "InventoryView", "vim.view.ManagedObjectView", "vim.version.version2", None, [("openFolder", "OpenInventoryViewFolder", "vim.version.version2", (("entity", "vim.ManagedEntity[]", "vim.version.version2", 0, "System.View"),), (F_OPTIONAL, "vim.ManagedEntity[]", "vim.ManagedEntity[]"), None, None), ("closeFolder", "CloseInventoryViewFolder", "vim.version.version2", (("entity", "vim.ManagedEntity[]", "vim.version.version2", 0, "System.View"),), (F_OPTIONAL, "vim.ManagedEntity[]", "vim.ManagedEntity[]"), None, None)]) +CreateManagedType("vim.view.ListView", "ListView", "vim.view.ManagedObjectView", "vim.version.version2", None, [("modify", "ModifyListView", "vim.version.version2", (("add", "vmodl.ManagedObject[]", "vim.version.version2", F_OPTIONAL, "System.View"),("remove", "vmodl.ManagedObject[]", "vim.version.version2", F_OPTIONAL, "System.View"),), (F_OPTIONAL, "vmodl.ManagedObject[]", "vmodl.ManagedObject[]"), None, None), ("reset", "ResetListView", "vim.version.version2", (("obj", "vmodl.ManagedObject[]", "vim.version.version2", F_OPTIONAL, "System.View"),), (F_OPTIONAL, "vmodl.ManagedObject[]", "vmodl.ManagedObject[]"), None, None), ("resetFromView", "ResetListViewFromView", "vim.version.version2", (("view", "vim.view.View", "vim.version.version2", 0, None),), (0, "void", "void"), None, None)]) +CreateDataType("vim.vm.DatastoreInfo", "VirtualMachineDatastoreInfo", "vim.vm.TargetInfo", "vim.version.version1", [("datastore", "vim.Datastore.Summary", "vim.version.version1", 0), ("capability", "vim.Datastore.Capability", "vim.version.version1", 0), ("maxFileSize", "long", "vim.version.version1", 0), ("maxVirtualDiskCapacity", "long", "vim.version.version9", F_OPTIONAL), ("mode", "string", "vim.version.version1", 0), ("vStorageSupport", "string", "vim.version.version7", F_OPTIONAL)]) +CreateDataType("vim.vm.device.ParaVirtualSCSIController", "ParaVirtualSCSIController", "vim.vm.device.VirtualSCSIController", "vim.version.version4", None) +CreateDataType("vim.vm.device.ParaVirtualSCSIControllerOption", "ParaVirtualSCSIControllerOption", "vim.vm.device.VirtualSCSIControllerOption", "vim.version.version4", None) +CreateDataType("vim.vm.device.VirtualAHCIController", "VirtualAHCIController", "vim.vm.device.VirtualSATAController", "vim.version.version9", None) +CreateDataType("vim.vm.device.VirtualAHCIControllerOption", "VirtualAHCIControllerOption", "vim.vm.device.VirtualSATAControllerOption", "vim.version.version9", None) +CreateDataType("vim.vm.device.VirtualBusLogicController", "VirtualBusLogicController", "vim.vm.device.VirtualSCSIController", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualBusLogicControllerOption", "VirtualBusLogicControllerOption", "vim.vm.device.VirtualSCSIControllerOption", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualLsiLogicController", "VirtualLsiLogicController", "vim.vm.device.VirtualSCSIController", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualLsiLogicControllerOption", "VirtualLsiLogicControllerOption", "vim.vm.device.VirtualSCSIControllerOption", "vim.version.version1", None) +CreateDataType("vim.vm.device.VirtualLsiLogicSASController", "VirtualLsiLogicSASController", "vim.vm.device.VirtualSCSIController", "vim.version.version4", None) +CreateDataType("vim.vm.device.VirtualLsiLogicSASControllerOption", "VirtualLsiLogicSASControllerOption", "vim.vm.device.VirtualSCSIControllerOption", "vim.version.version4", None) +CreateManagedType("vim.ClusterComputeResource", "ClusterComputeResource", "vim.ComputeResource", "vim.version.version1", [("configuration", "vim.cluster.ConfigInfo", "vim.version.version1", 0, None), ("recommendation", "vim.cluster.Recommendation[]", "vim.version.version2", F_OPTIONAL, "System.Read"), ("drsRecommendation", "vim.cluster.DrsRecommendation[]", "vim.version.version1", F_OPTIONAL, None), ("migrationHistory", "vim.cluster.DrsMigration[]", "vim.version.version1", F_OPTIONAL, None), ("actionHistory", "vim.cluster.ActionHistory[]", "vim.version.version2", F_OPTIONAL, None), ("drsFault", "vim.cluster.DrsFaults[]", "vim.version.version5", F_OPTIONAL, "System.Read")], [("reconfigure", "ReconfigureCluster_Task", "vim.version.version1", (("spec", "vim.cluster.ConfigSpec", "vim.version.version1", 0, None),("modify", "boolean", "vim.version.version1", 0, None),), (0, "vim.Task", "void"), "Host.Inventory.EditCluster", None), ("applyRecommendation", "ApplyRecommendation", "vim.version.version1", (("key", "string", "vim.version.version1", 0, None),), (0, "void", "void"), None, None), ("cancelRecommendation", "CancelRecommendation", "vim.version.version6", (("key", "string", "vim.version.version6", 0, None),), (0, "void", "void"), "System.Read", None), ("recommendHostsForVm", "RecommendHostsForVm", "vim.version.version1", (("vm", "vim.VirtualMachine", "vim.version.version1", 0, None),("pool", "vim.ResourcePool", "vim.version.version1", F_OPTIONAL, None),), (F_OPTIONAL, "vim.cluster.HostRecommendation[]", "vim.cluster.HostRecommendation[]"), "System.Read", None), ("addHost", "AddHost_Task", "vim.version.version1", (("spec", "vim.host.ConnectSpec", "vim.version.version1", 0, None),("asConnected", "boolean", "vim.version.version1", 0, None),("resourcePool", "vim.ResourcePool", "vim.version.version1", F_OPTIONAL, "Resource.AssignVMToPool"),("license", "string", "vim.version.version5", F_OPTIONAL, None),), (0, "vim.Task", "vim.HostSystem"), "Host.Inventory.AddHostToCluster", ["vim.fault.InvalidLogin", "vim.fault.HostConnectFault", "vim.fault.DuplicateName", ]), ("moveInto", "MoveInto_Task", "vim.version.version1", (("host", "vim.HostSystem[]", "vim.version.version1", 0, "Host.Inventory.MoveHost"),), (0, "vim.Task", "void"), "Host.Inventory.EditCluster", ["vim.fault.DuplicateName", "vim.fault.TooManyHosts", "vim.fault.InvalidState", ]), ("moveHostInto", "MoveHostInto_Task", "vim.version.version1", (("host", "vim.HostSystem", "vim.version.version1", 0, "Host.Inventory.MoveHost"),("resourcePool", "vim.ResourcePool", "vim.version.version1", F_OPTIONAL, None),), (0, "vim.Task", "void"), "Host.Inventory.EditCluster", ["vim.fault.TooManyHosts", "vim.fault.InvalidState", ]), ("refreshRecommendation", "RefreshRecommendation", "vim.version.version2", (), (0, "void", "void"), "Host.Inventory.EditCluster", None), ("retrieveDasAdvancedRuntimeInfo", "RetrieveDasAdvancedRuntimeInfo", "vim.version.version5", (), (F_OPTIONAL, "vim.cluster.DasAdvancedRuntimeInfo", "vim.cluster.DasAdvancedRuntimeInfo"), "System.Read", None), ("enterMaintenanceMode", "ClusterEnterMaintenanceMode", "vim.version.version7", (("host", "vim.HostSystem[]", "vim.version.version7", 0, "Host.Config.Maintenance"),("option", "vim.option.OptionValue[]", "vim.version.version7", F_OPTIONAL, None),), (0, "vim.cluster.EnterMaintenanceResult", "vim.cluster.EnterMaintenanceResult"), "System.View", None)]) +CreateDataType("vim.ClusterComputeResource.Summary", "ClusterComputeResourceSummary", "vim.ComputeResource.Summary", "vim.version.version1", [("currentFailoverLevel", "int", "vim.version.version1", 0), ("admissionControlInfo", "vim.cluster.DasAdmissionControlInfo", "vim.version.version5", F_OPTIONAL), ("numVmotions", "int", "vim.version.version1", 0), ("targetBalance", "int", "vim.version.version5", F_OPTIONAL), ("currentBalance", "int", "vim.version.version5", F_OPTIONAL), ("currentEVCModeKey", "string", "vim.version.version5", F_OPTIONAL), ("dasData", "vim.cluster.DasData", "vim.version.version7", F_OPTIONAL)]) +CreateEnumType("vim.dvs.HostDistributedVirtualSwitchManager.NetworkResourcePoolKey", "HostDistributedVirtualSwitchManagerNetworkResourcePoolKey", "vim.version.version6", ["faultTolerance", "hbr", "iSCSI", "management", "nfs", "virtualMachine", "vmotion", "vsan"]) +CreateEnumType("vim.dvs.HostDistributedVirtualSwitchManager.FetchPortOption", "HostDistributedVirtualSwitchManagerFetchPortOption", "vim.version.version7", ["runtimeInfoOnly", "statsOnly", "stateBlobOnly"]) +CreateDataType("vim.fault.ConnectedIso", "ConnectedIso", "vim.fault.OvfExport", "vim.version.version5", [("cdrom", "vim.vm.device.VirtualCdrom", "vim.version.version5", 0), ("filename", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.CpuCompatibilityUnknown", "CpuCompatibilityUnknown", "vim.fault.CpuIncompatible", "vim.version.version1", None) +CreateDataType("vim.fault.DeviceBackingNotSupported", "DeviceBackingNotSupported", "vim.fault.DeviceNotSupported", "vim.version.version2", [("backing", "string", "vim.version.version2", 0)]) +CreateDataType("vim.fault.DeviceControllerNotSupported", "DeviceControllerNotSupported", "vim.fault.DeviceNotSupported", "vim.version.version2", [("controller", "string", "vim.version.version2", 0)]) +CreateDataType("vim.fault.DeviceHotPlugNotSupported", "DeviceHotPlugNotSupported", "vim.fault.InvalidDeviceSpec", "vim.version.version4", None) +CreateDataType("vim.fault.DeviceNotFound", "DeviceNotFound", "vim.fault.InvalidDeviceSpec", "vim.version.version1", None) +CreateDataType("vim.fault.DeviceUnsupportedForVmPlatform", "DeviceUnsupportedForVmPlatform", "vim.fault.InvalidDeviceSpec", "vim.version.version4", None) +CreateDataType("vim.fault.DeviceUnsupportedForVmVersion", "DeviceUnsupportedForVmVersion", "vim.fault.InvalidDeviceSpec", "vim.version.version4", [("currentVersion", "string", "vim.version.version4", 0), ("expectedVersion", "string", "vim.version.version4", 0)]) +CreateDataType("vim.fault.DisallowedDiskModeChange", "DisallowedDiskModeChange", "vim.fault.InvalidDeviceSpec", "vim.version.version1", None) +CreateDataType("vim.fault.InvalidController", "InvalidController", "vim.fault.InvalidDeviceSpec", "vim.version.version1", [("controllerKey", "int", "vim.version.version1", 0)]) +CreateDataType("vim.fault.InvalidDeviceBacking", "InvalidDeviceBacking", "vim.fault.InvalidDeviceSpec", "vim.version.version1", None) +CreateDataType("vim.fault.InvalidDeviceOperation", "InvalidDeviceOperation", "vim.fault.InvalidDeviceSpec", "vim.version.version1", [("badOp", "vim.vm.device.VirtualDeviceSpec.Operation", "vim.version.version1", F_OPTIONAL), ("badFileOp", "vim.vm.device.VirtualDeviceSpec.FileOperation", "vim.version.version1", F_OPTIONAL)]) +CreateDataType("vim.fault.InvalidHostConnectionState", "InvalidHostConnectionState", "vim.fault.InvalidHostState", "vim.version.version8", None) +CreateDataType("vim.fault.OvfConnectedDevice", "OvfConnectedDevice", "vim.fault.OvfHardwareExport", "vim.version.version5", None) +CreateDataType("vim.fault.OvfConnectedDeviceFloppy", "OvfConnectedDeviceFloppy", "vim.fault.OvfConnectedDevice", "vim.version.version5", [("filename", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfConnectedDeviceIso", "OvfConnectedDeviceIso", "vim.fault.OvfConnectedDevice", "vim.version.version5", [("filename", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfDuplicateElement", "OvfDuplicateElement", "vim.fault.OvfElement", "vim.version.version5", None) +CreateDataType("vim.fault.OvfDuplicatedElementBoundary", "OvfDuplicatedElementBoundary", "vim.fault.OvfElement", "vim.version.version5", [("boundary", "string", "vim.version.version5", 0)]) +CreateDataType("vim.fault.OvfDuplicatedPropertyIdExport", "OvfDuplicatedPropertyIdExport", "vim.fault.OvfExport", "vim.version.version7", [("fqid", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.OvfDuplicatedPropertyIdImport", "OvfDuplicatedPropertyIdImport", "vim.fault.OvfExport", "vim.version.version7", None) +CreateDataType("vim.fault.OvfNoSpaceOnController", "OvfNoSpaceOnController", "vim.fault.OvfUnsupportedElement", "vim.version.version7", [("parent", "string", "vim.version.version7", 0)]) +CreateDataType("vim.fault.PhysCompatRDMNotSupported", "PhysCompatRDMNotSupported", "vim.fault.RDMNotSupported", "vim.version.version1", None) +CreateDataType("vim.fault.UnusedVirtualDiskBlocksNotScrubbed", "UnusedVirtualDiskBlocksNotScrubbed", "vim.fault.DeviceBackingNotSupported", "vim.version.version5", None) +CreateDataType("vim.fault.VirtualDiskBlocksNotFullyProvisioned", "VirtualDiskBlocksNotFullyProvisioned", "vim.fault.DeviceBackingNotSupported", "vim.version.version5", None) +CreateManagedType("vim.host.DiagnosticSystem", "HostDiagnosticSystem", "vmodl.ManagedObject", "vim.version.version1", [("activePartition", "vim.host.DiagnosticPartition", "vim.version.version1", F_OPTIONAL, None)], [("queryAvailablePartition", "QueryAvailablePartition", "vim.version.version1", (), (F_OPTIONAL, "vim.host.DiagnosticPartition[]", "vim.host.DiagnosticPartition[]"), "Host.Config.Storage", ["vim.fault.HostConfigFault", ]), ("selectActivePartition", "SelectActivePartition", "vim.version.version1", (("partition", "vim.host.ScsiDisk.Partition", "vim.version.version1", F_OPTIONAL, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("queryPartitionCreateOptions", "QueryPartitionCreateOptions", "vim.version.version1", (("storageType", "string", "vim.version.version1", 0, None),("diagnosticType", "string", "vim.version.version1", 0, None),), (F_OPTIONAL, "vim.host.DiagnosticPartition.CreateOption[]", "vim.host.DiagnosticPartition.CreateOption[]"), "Host.Config.Storage", ["vim.fault.HostConfigFault", ]), ("queryPartitionCreateDesc", "QueryPartitionCreateDesc", "vim.version.version1", (("diskUuid", "string", "vim.version.version1", 0, None),("diagnosticType", "string", "vim.version.version1", 0, None),), (0, "vim.host.DiagnosticPartition.CreateDescription", "vim.host.DiagnosticPartition.CreateDescription"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ]), ("createDiagnosticPartition", "CreateDiagnosticPartition", "vim.version.version1", (("spec", "vim.host.DiagnosticPartition.CreateSpec", "vim.version.version1", 0, None),), (0, "void", "void"), "Host.Config.Storage", ["vim.fault.NotFound", "vim.fault.HostConfigFault", ])]) +CreateDataType("vim.fault.DVPortNotSupported", "DVPortNotSupported", "vim.fault.DeviceBackingNotSupported", "vim.version.version6", None) diff --git a/pyVmomi/SoapAdapter.py b/pyVmomi/SoapAdapter.py new file mode 100644 index 0000000..1e3e670 --- /dev/null +++ b/pyVmomi/SoapAdapter.py @@ -0,0 +1,1490 @@ +# VMware vSphere Python SDK +# Copyright (c) 2008-2013 VMware, Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import httplib +import sys +import os +import time +import socket +import subprocess +import thread +import urlparse +from datetime import datetime +from xml.parsers.expat import ParserCreate +# We have our own escape functionality. +# from xml.sax.saxutils import escape +from cStringIO import StringIO +from VmomiSupport import * +from StubAdapterAccessorImpl import StubAdapterAccessorMixin +import Iso8601 +import base64 +from xml.parsers.expat import ExpatError +import copy +import contextlib + +try: + USERWORLD = os.uname()[0] == 'VMkernel' +except: + USERWORLD = False + +# Timeout value used for idle connections in client connection pool. +# Default value is 900 seconds (15 minutes). +CONNECTION_POOL_IDLE_TIMEOUT_SEC = 900 + +NS_SEP = " " + +XML_ENCODING = 'UTF-8' +XML_HEADER = '' % XML_ENCODING + +XMLNS_SOAPENC = "http://schemas.xmlsoap.org/soap/encoding/" +XMLNS_SOAPENV = "http://schemas.xmlsoap.org/soap/envelope/" + +XSI_TYPE = XMLNS_XSI + NS_SEP + u'type' + +# Note: Must make a copy to use the SOAP_NSMAP +# TODO: Change to frozendict, if available +SOAP_NSMAP = { XMLNS_SOAPENC: 'soapenc', XMLNS_SOAPENV: 'soapenv', + XMLNS_XSI: 'xsi', XMLNS_XSD: 'xsd' } + +SOAP_ENVELOPE_TAG="%s:Envelope" % SOAP_NSMAP[XMLNS_SOAPENV] +SOAP_HEADER_TAG="%s:Header" % SOAP_NSMAP[XMLNS_SOAPENV] +SOAP_FAULT_TAG="%s:Fault" % SOAP_NSMAP[XMLNS_SOAPENV] +SOAP_BODY_TAG="%s:Body" % SOAP_NSMAP[XMLNS_SOAPENV] + +SOAP_ENVELOPE_START = '<%s ' % SOAP_ENVELOPE_TAG + \ + ' '.join(['xmlns:' + prefix + '="' + urn + '"' \ + for urn, prefix in SOAP_NSMAP.iteritems()]) + \ + '>\n' +SOAP_ENVELOPE_END = "\n" % (SOAP_ENVELOPE_TAG) +SOAP_HEADER_START="<%s>" % SOAP_HEADER_TAG +SOAP_HEADER_END="" % SOAP_HEADER_TAG +SOAP_BODY_START="<%s>" % SOAP_BODY_TAG +SOAP_BODY_END="" % SOAP_BODY_TAG +SOAP_START = SOAP_ENVELOPE_START + SOAP_BODY_START + '\n' +SOAP_END = '\n' + SOAP_BODY_END + SOAP_ENVELOPE_END + +WSSE_PREFIX="wsse" +WSSE_HEADER_TAG="%s:Security" % WSSE_PREFIX +WSSE_NS_URL="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd" +WSSE_NS='xmlns:%s="%s"' % (WSSE_PREFIX, WSSE_NS_URL) +WSSE_HEADER_START="<%s %s>" % (WSSE_HEADER_TAG, WSSE_NS) +WSSE_HEADER_END="" % WSSE_HEADER_TAG + +## MethodFault type +MethodFault = GetVmodlType("vmodl.MethodFault") +## Localized MethodFault type +LocalizedMethodFault = GetVmodlType("vmodl.LocalizedMethodFault") + +## Escape <, >, & +def XmlEscape(xmlStr): + escaped = xmlStr.replace("&", "&").replace(">", ">").replace("<", "<") + return escaped + +## Get the start tag, end tag, and text handlers of a class +def GetHandlers(obj): + return (obj.StartElementHandler, + obj.EndElementHandler, + obj.CharacterDataHandler, + obj.StartNamespaceDeclHandler, + obj.EndNamespaceDeclHandler) + +## Set the start tag, end tag, and text handlers of a parser +def SetHandlers(obj, handlers): + (obj.StartElementHandler, + obj.EndElementHandler, + obj.CharacterDataHandler, + obj.StartNamespaceDeclHandler, + obj.EndNamespaceDeclHandler) = handlers + +## Serialize an object +# +# This function assumes CheckField(info, val) was already called +# @param val the value to serialize +# @param info the field +# @param version the version +# @param nsMap a dict of xml ns -> prefix +# @return the serialized object as a string +def Serialize(val, info=None, version=None, nsMap=None, encoding=None): + if version is None: + try: + if isinstance(val, list): + itemType = val.Item + version = itemType._version + else: + if val is None: + # neither val nor version is given + return '' + # Pick up the version from val + version = val._version + except AttributeError: + version = BASE_VERSION + if info is None: + info = Object(name="object", type=object, version=version, flags=0) + + writer = StringIO() + SoapSerializer(writer, version, nsMap, encoding).Serialize(val, info) + return writer.getvalue() + +## Serialize fault detail +# +# Serializes a fault as the content of the detail element in a +# soapenv:Fault (i.e. without a LocalizedMethodFault wrapper). +# +# This function assumes CheckField(info, val) was already called +# @param val the value to serialize +# @param info the field +# @param version the version +# @param nsMap a dict of xml ns -> prefix +# @return the serialized object as a string +def SerializeFaultDetail(val, info=None, version=None, nsMap=None, encoding=None): + if version is None: + try: + if not isinstance(val, MethodFault): + raise TypeError('%s is not a MethodFault' % str(val)) + version = val._version + except AttributeError: + version = BASE_VERSION + if info is None: + info = Object(name="object", type=object, version=version, flags=0) + + writer = StringIO() + SoapSerializer(writer, version, nsMap, encoding).SerializeFaultDetail(val, info) + return writer.getvalue() + +## SOAP serializer +# +class SoapSerializer: + """ SoapSerializer """ + ## Serializer constructor + # + # @param writer File writer + # @param version the version + # @param nsMap a dict of xml ns -> prefix + def __init__(self, writer, version, nsMap, encoding): + """ Constructor """ + self.writer = writer + self.version = version + self.nsMap = nsMap and nsMap or {} + self.encoding = encoding and encoding or XML_ENCODING + for ns, prefix in self.nsMap.iteritems(): + if prefix == '': + self.defaultNS = ns + break + else: + self.defaultNS = '' + + # Additional attr for outermost tag + self.outermostAttrs = '' + + # Fill in required xmlns, if not defined + for nsPrefix, ns, attrName in [('xsi', XMLNS_XSI, 'xsiPrefix'), + ('xsd', XMLNS_XSD, 'xsdPrefix')]: + prefix = self.nsMap.get(ns) + if not prefix: + prefix = nsPrefix + self.outermostAttrs += ' xmlns:%s="%s"' % (prefix, ns) + self.nsMap = self.nsMap.copy() + self.nsMap[ns] = prefix + setattr(self, attrName, prefix + ":") + + + ## Serialize an object + # + # This function assumes CheckField(info, val) was already called + # @param val the value to serialize + # @param info the field + def Serialize(self, val, info): + """ Serialize an object """ + self._Serialize(val, info, self.defaultNS) + + ## Serialize fault detail + # + # Serializes a fault as the content of the detail element in a + # soapenv:Fault (i.e. without a LocalizedMethodFault wrapper). + # + # This function assumes CheckField(info, val) was already called + # @param val the value to serialize + # @param info the field + def SerializeFaultDetail(self, val, info): + """ Serialize an object """ + self._SerializeDataObject(val, info, '', self.defaultNS) + + def _NSPrefix(self, ns): + """ Get xml ns prefix. self.nsMap must be set """ + if ns == self.defaultNS: + return '' + prefix = self.nsMap[ns] + return prefix and prefix + ':' or '' + + def _QName(self, typ, defNS): + """ Get fully qualified wsdl name (prefix:name) """ + attr = '' + ns, name = GetQualifiedWsdlName(typ) + if ns == defNS: + prefix = '' + else: + try: + prefix = self.nsMap[ns] + except KeyError: + # We have not seen this ns before + prefix = ns.split(':', 1)[-1] + attr = ' xmlns:%s="%s"' % (prefix, ns) + return attr, prefix and prefix + ':' + name or name + + ## Serialize an object (internal) + # + # @param val the value to serialize + # @param info the field + # @param defNS the default namespace + def _Serialize(self, val, info, defNS): + """ Serialize an object """ + if not IsChildVersion(self.version, info.version): + return + + if val is None: + if info.flags & F_OPTIONAL: + return + else: + raise TypeError('Field "%s" is not optional' % info.name) + elif isinstance(val, list) and len(val) == 0: + if info.type is object: + # Make sure an empty array assigned to Any is typed + if not isinstance(val, Array): + raise TypeError('Field "%s": Cannot assign empty native python array to an Any' % info.name) + elif info.flags & F_OPTIONAL: + # Skip optional non-Any + return + else: + raise TypeError('Field "%s" is not optional' % info.name) + + if self.outermostAttrs: + attr = self.outermostAttrs + self.outermostAttrs = None + else: + attr = '' + currDefNS = defNS + # Emit default ns if tag ns is not the same + currTagNS = GetWsdlNamespace(info.version) + if currTagNS != defNS: + attr += ' xmlns="%s"' % currTagNS + currDefNS = currTagNS + + if isinstance(val, DataObject): + if isinstance(val, MethodFault): + newVal = LocalizedMethodFault(fault=val, localizedMessage=val.msg) + if info.type is object: + faultType = object + else: + faultType = LocalizedMethodFault + newInfo = Object(name=info.name, type=faultType, + version=info.version, flags=info.flags) + self._SerializeDataObject(newVal, newInfo, attr, currDefNS) + else: + self._SerializeDataObject(val, info, attr, currDefNS) + elif isinstance(val, ManagedObject): + if info.type is object: + nsattr, qName = self._QName(ManagedObject, currDefNS) + attr += '%s %stype="%s"' % (nsattr, self.xsiPrefix, qName) + if val._serverGuid is not None: + attr += ' serverGuid="%s"' % (val._serverGuid) + # val in vim type attr is not namespace qualified + # TODO: Add a new "typens" attr? + ns, name = GetQualifiedWsdlName(Type(val)) + attr += ' type="%s"' % (name) + self.writer.write('<%s%s>%s' % (info.name, attr, + val._moId.encode(self.encoding), + info.name)) + elif isinstance(val, list): + if info.type is object: + itemType = val.Item + if (itemType is ManagedMethod or itemType is PropertyPath + or itemType is type): + tag = 'string' + typ = GetVmodlType("string[]") + elif issubclass(itemType, ManagedObject): + tag = 'ManagedObjectReference' + typ = ManagedObject.Array + else: + tag = GetWsdlName(itemType) + typ = Type(val) + nsattr, qName = self._QName(typ, currDefNS) + + # For WSDL, since we set tag of ManagedObjects to ManagedObjectReferences, + # the name of its array should be ArrayOfManagedObjectReference + if qName.endswith("ArrayOfManagedObject"): + qName += "Reference" + + attr += '%s %stype="%s"' % (nsattr, self.xsiPrefix, qName) + self.writer.write('<%s%s>' % (info.name, attr)) + + itemInfo = Object(name=tag, type=itemType, + version=info.version, flags=info.flags) + for it in val: + self._Serialize(it, itemInfo, currDefNS) + self.writer.write('' % info.name) + else: + itemType = info.type.Item + itemInfo = Object(name=info.name, type=itemType, + version=info.version, flags=info.flags) + for it in val: + self._Serialize(it, itemInfo, defNS) + elif isinstance(val, type) or isinstance(val, type(Exception)): + if info.type is object: + attr += ' %stype="%sstring"' % (self.xsiPrefix, self.xsdPrefix) + self.writer.write('<%s%s>%s' % + (info.name, attr, GetWsdlName(val), info.name)) + elif isinstance(val, ManagedMethod): + if info.type is object: + attr += ' %stype="%sstring"' % (self.xsiPrefix, self.xsdPrefix) + self.writer.write('<%s%s>%s' % + (info.name, attr, val.info.wsdlName, info.name)) + elif isinstance(val, datetime): + if info.type is object: + nsattr, qName = self._QName(Type(val), currDefNS) + attr += '%s %stype="%s"' % (nsattr, self.xsiPrefix, qName) + result = Iso8601.ISO8601Format(val) + self.writer.write('<%s%s>%s' % (info.name, attr, result, + info.name)) + elif isinstance(val, binary): + if info.type is object: + nsattr, qName = self._QName(Type(val), currDefNS) + attr += '%s %stype="%s"' % (nsattr, self.xsiPrefix, qName) + result = base64.b64encode(val) + self.writer.write('<%s%s>%s' % (info.name, attr, result, + info.name)) + elif isinstance(val, bool): + if info.type is object: + nsattr, qName = self._QName(Type(val), currDefNS) + attr += '%s %stype="%s"' % (nsattr, self.xsiPrefix, qName) + result = val and "true" or "false" + self.writer.write('<%s%s>%s' % (info.name, attr, result, + info.name)) + else: + if info.type is object: + if isinstance(val, PropertyPath): + attr += ' %stype="%sstring"' % (self.xsiPrefix, self.xsdPrefix) + else: + nsattr, qName = self._QName(Type(val), currDefNS) + attr += '%s %stype="%s"' % (nsattr, self.xsiPrefix, qName) + if not isinstance(val, unicode): + # Use UTF-8 rather than self.encoding. self.encoding is for + # output of serializer, while 'val' is our input. And regardless + # of what our output is, our input should be always UTF-8. Yes, + # it means that if you emit output in other encoding than UTF-8, + # you cannot serialize it again once more. That's feature, not + # a bug. + val = str(val).decode('UTF-8') + result = XmlEscape(val) + self.writer.write('<%s%s>%s' % (info.name, attr, + result.encode(self.encoding), + info.name)) + + ## Serialize a a data object (internal) + # + # @param val the value to serialize + # @param info the field + # @param attr attributes to serialized in the outermost elementt + # @param currDefNS the current default namespace + def _SerializeDataObject(self, val, info, attr, currDefNS): + if info.flags & F_LINK: + # Attribute is a link and Object is present instead of its key. + # We need to serialize just the key and not the entire object + self._Serialize(val.key, info, currDefNS) + return + dynType = GetCompatibleType(Type(val), self.version) + if dynType != info.type: + nsattr, qName = self._QName(dynType, currDefNS) + attr += '%s %stype="%s"' % (nsattr, self.xsiPrefix, qName) + self.writer.write('<%s%s>' % (info.name, attr)) + if dynType is LocalizedMethodFault: + # Serialize a MethodFault as LocalizedMethodFault on wire + # See PR 670229 + for prop in val._GetPropertyList(): + propVal = getattr(val, prop.name) + if prop.name == 'fault': + propVal = copy.copy(propVal) + propVal.msg = None + self._SerializeDataObject(propVal, prop, '', currDefNS) + else: + self._Serialize(propVal, prop, currDefNS) + else: + for prop in val._GetPropertyList(): + self._Serialize(getattr(val, prop.name), prop, currDefNS) + + self.writer.write('' % info.name) + + +## Deserialize an object from a file or string +# +# This function will deserialize one top-level XML node. +# @param data the data to deserialize (a file object or string) +# @param resultType expected result type +# @param stub stub for moRef deserialization +# @return the deserialized object +def Deserialize(data, resultType=object, stub=None): + parser = ParserCreate(namespace_separator=NS_SEP) + ds = SoapDeserializer(stub) + ds.Deserialize(parser, resultType) + if isinstance(data, str): + parser.Parse(data) + else: + parser.ParseFile(data) + return ds.GetResult() + + +## Expat deserializer namespace handler +class ExpatDeserializerNSHandlers: + def __init__(self, nsMap=None): + # nsMap is a dict of ns prefix to a stack (list) of namespaces + # The last element of the stack is current namespace + if not nsMap: + nsMap = {} + self.nsMap = nsMap + + ## Get current default ns + def GetCurrDefNS(self): + namespaces = self.nsMap.get(None) + if namespaces: + ns = namespaces[-1] + else: + ns = "" + return ns + + ## Get namespace and wsdl name from tag + def GetNSAndWsdlname(self, tag): + """ Map prefix:name tag into ns, name """ + idx = tag.find(":") + if idx >= 0: + prefix, name = tag[:idx], tag[idx + 1:] + else: + prefix, name = None, tag + # Map prefix to ns + ns = self.nsMap[prefix][-1] + return ns, name + + ## Handle namespace begin + def StartNamespaceDeclHandler(self, prefix, uri): + namespaces = self.nsMap.get(prefix) + if namespaces: + namespaces.append(uri) + else: + self.nsMap[prefix] = [uri] + + ## Handle namespace end + def EndNamespaceDeclHandler(self, prefix): + self.nsMap[prefix].pop() + + +## SOAP -> Python Deserializer +class SoapDeserializer(ExpatDeserializerNSHandlers): + ## Constructor + # + # @param self self + # @param stub Stub adapter to use for deserializing moRefs + def __init__(self, stub=None, version=None): + ExpatDeserializerNSHandlers.__init__(self) + self.stub = stub + if version: + self.version = version + elif self.stub: + self.version = self.stub.version + else: + self.version = None + self.result = None + + ## Deserialize a SOAP object + # + # @param self self + # @param parser an expat parser + # @param resultType the static type of the result + # @param isFault true if the response is a fault response + # @param nsMap a dict of prefix -> [xml ns stack] + # @return the deserialized object + def Deserialize(self, parser, resultType=object, isFault=False, nsMap=None): + self.isFault = isFault + self.parser = parser + self.origHandlers = GetHandlers(parser) + SetHandlers(parser, GetHandlers(self)) + self.resultType = resultType + self.stack = [] + self.data = "" + self.serverGuid = None + if issubclass(resultType, list): + self.result = resultType() + else: + self.result = None + if not nsMap: + nsMap = {} + self.nsMap = nsMap + + ## Get the result of deserialization + # The links will not be resolved. User needs to explicitly resolve them + # using LinkResolver. + def GetResult(self): + return self.result + + def SplitTag(self, tag): + """ Split tag into ns, name """ + idx = tag.find(NS_SEP) + if idx >= 0: + return tag[:idx], tag[idx + 1:] + else: + return "", tag + + def LookupWsdlType(self, ns, name, allowManagedObjectReference=False): + """ Lookup wsdl type. Handle special case for some vmodl version """ + try: + return GetWsdlType(ns, name) + except KeyError: + if allowManagedObjectReference: + if name.endswith('ManagedObjectReference') and ns == XMLNS_VMODL_BASE: + return GetWsdlType(ns, name[:-len('Reference')]) + # WARNING!!! This is a temporary hack to get around server not + # honoring @service tag (see bug 521744). Once it is fix, I am + # going to back out this change + if name.endswith('ManagedObjectReference') and allowManagedObjectReference: + return GetWsdlType(XMLNS_VMODL_BASE, name[:-len('Reference')]) + return GuessWsdlType(name) + + ## Handle an opening XML tag + def StartElementHandler(self, tag, attr): + self.data = "" + self.serverGuid = None + deserializeAsLocalizedMethodFault = True + if not self.stack: + if self.isFault: + ns, name = self.SplitTag(tag) + objType = self.LookupWsdlType(ns, name[:-5]) + # Only top level soap fault should be deserialized as method fault + deserializeAsLocalizedMethodFault = False + else: + objType = self.resultType + elif isinstance(self.stack[-1], list): + objType = self.stack[-1].Item + elif isinstance(self.stack[-1], DataObject): + # TODO: Check ns matches DataObject's namespace + ns, name = self.SplitTag(tag) + objType = self.stack[-1]._GetPropertyInfo(name).type + + # LocalizedMethodFault tag should be deserialized as method fault + if name == "fault" and isinstance(self.stack[-1], LocalizedMethodFault): + deserializeAsLocalizedMethodFault = False + else: + raise TypeError("Invalid type for tag %s" % tag) + + xsiType = attr.get(XSI_TYPE) + if xsiType: + # Ignore dynamic type for TypeName, MethodName, PropertyPath + # @bug 150459 + if not (objType is type or objType is ManagedMethod or \ + objType is PropertyPath): + ns, name = self.GetNSAndWsdlname(xsiType) + dynType = self.LookupWsdlType(ns, name, allowManagedObjectReference=True) + # TODO: Should be something like... + # dynType must be narrower than objType, except for + # ManagedObjectReference + if not (issubclass(dynType, list) and issubclass(objType, list)): + objType = dynType + else: + if issubclass(objType, list): + objType = objType.Item + + if self.version: + objType = GetCompatibleType(objType, self.version) + if issubclass(objType, ManagedObject): + typeAttr = attr[u'type'] + # val in vim type attr is not namespace qualified + # However, this doesn't hurt to strip out namespace + # TODO: Get the ns from "typens" attr? + ns, name = self.GetNSAndWsdlname(typeAttr) + if u'serverGuid' in attr: + self.serverGuid = attr[u'serverGuid'] + self.stack.append(GuessWsdlType(name)) + elif issubclass(objType, DataObject) or issubclass(objType, list): + if deserializeAsLocalizedMethodFault and issubclass(objType, Exception): + objType = LocalizedMethodFault + self.stack.append(objType()) + else: + self.stack.append(objType) + + ## Handle a closing XML tag + def EndElementHandler(self, tag): + try: + obj = self.stack.pop() + except IndexError: + SetHandlers(self.parser, self.origHandlers) + handler = self.parser.EndElementHandler + del self.parser, self.origHandlers, self.stack, self.resultType + if handler: + return handler(tag) + return + + data = self.data + if isinstance(obj, type) or isinstance(obj, type(Exception)): + if obj is type: + if data is None or data == '': + obj = None + else: + try: + # val in type val is not namespace qualified + # However, this doesn't hurt to strip out namespace + ns, name = self.GetNSAndWsdlname(data) + obj = GuessWsdlType(name) + except KeyError: + raise TypeError(data) + elif obj is ManagedMethod: + # val in Method val is not namespace qualified + # However, this doesn't hurt to strip out namespace + ns, name = self.GetNSAndWsdlname(data) + obj = GuessWsdlMethod(name) + elif obj is bool: + if data == "0" or data.lower() == "false": + obj = bool(False) + elif data == "1" or data.lower() == "true": + obj = bool(True) + else: + raise TypeError(data) + elif obj is binary: + # Raise type error if decode failed + obj = obj(base64.b64decode(data)) + elif obj is str: + try: + obj = str(data) + except UnicodeError: + obj = data + elif obj is datetime: + obj = Iso8601.ParseISO8601(data) + if not obj: + raise TypeError(data) + # issubclass is very expensive. Test last + elif issubclass(obj, ManagedObject): + obj = obj(data, self.stub, self.serverGuid) + elif issubclass(obj, Enum): + obj = getattr(obj, data) + else: + obj = obj(data) + elif isinstance(obj, LocalizedMethodFault): + obj.fault.msg = obj.localizedMessage + obj = obj.fault + + if self.stack: + top = self.stack[-1] + if isinstance(top, list): + top.append(obj) + elif isinstance(top, DataObject): + ns, name = self.SplitTag(tag) + info = top._GetPropertyInfo(name) + + if not isinstance(obj, list) and issubclass(info.type, list): + getattr(top, info.name).append(obj) + else: + setattr(top, info.name, obj) + else: + ns, name = self.SplitTag(tag) + setattr(top, name, obj) + else: + if not isinstance(obj, list) and issubclass(self.resultType, list): + self.result.append(obj) + else: + self.result = obj + SetHandlers(self.parser, self.origHandlers) + del self.parser, self.origHandlers, self.stack, self.resultType + + ## Handle text data + def CharacterDataHandler(self, data): + self.data += data + + +## SOAP Response Deserializer class +class SoapResponseDeserializer(ExpatDeserializerNSHandlers): + ## Constructor + # + # @param self self + # @param stub Stub adapter to use for deserializing moRefs + def __init__(self, stub): + ExpatDeserializerNSHandlers.__init__(self) + self.stub = stub + self.deser = SoapDeserializer(stub) + self.soapFaultTag = XMLNS_SOAPENV + NS_SEP + "Fault" + + ## Deserialize a SOAP response + # + # @param self self + # @param response the response (a file object or a string) + # @param resultType expected result type + # @param nsMap a dict of prefix -> [xml ns stack] + # @return the deserialized object + def Deserialize(self, response, resultType, nsMap=None): + self.resultType = resultType + self.stack = [] + self.msg = "" + self.deser.result = None + self.isFault = False + self.parser = ParserCreate(namespace_separator=NS_SEP) + try: # buffer_text only in python >= 2.3 + self.parser.buffer_text = True + except AttributeError: + pass + if not nsMap: + nsMap = {} + self.nsMap = nsMap + SetHandlers(self.parser, GetHandlers(self)) + if isinstance(response, str): + self.parser.Parse(response) + else: + self.parser.ParseFile(response) + result = self.deser.GetResult() + if self.isFault: + if result is None: + result = GetVmodlType("vmodl.RuntimeFault")() + result.msg = self.msg + del self.resultType, self.stack, self.parser, self.msg, self.data, self.nsMap + return result + + ## Handle an opening XML tag + def StartElementHandler(self, tag, attr): + self.data = "" + if tag == self.soapFaultTag: + self.isFault = True + elif self.isFault and tag == "detail": + self.deser.Deserialize(self.parser, object, True, self.nsMap) + elif tag.endswith("Response"): + self.deser.Deserialize(self.parser, self.resultType, False, self.nsMap) + + ## Handle text data + def CharacterDataHandler(self, data): + self.data += data + + ## Handle a closing XML tag + def EndElementHandler(self, tag): + if self.isFault and tag == "faultstring": + try: + self.msg = str(self.data) + except UnicodeError: + self.msg = self.data + +## Base class that implements common functionality for stub adapters. +## Method that must be provided by the implementation class: +## -- InvokeMethod(ManagedObject mo, Object methodInfo, Object[] args) +class StubAdapterBase(StubAdapterAccessorMixin): + def __init__(self, version): + StubAdapterAccessorMixin.__init__(self) + self.ComputeVersionInfo(version) + + ## Compute the version information for the specified namespace + # + # @param ns the namespace + def ComputeVersionInfo(self, version): + versionNS = GetVersionNamespace(version) + if versionNS.find("/") >= 0: + self.versionId = '"urn:%s"' % versionNS + else: + self.versionId = '' + self.version = version + +## Base class that implements common functionality for SOAP-based stub adapters. +## Method that must be provided by the implementation class: +## -- InvokeMethod(ManagedObject mo, Object methodInfo, Object[] args) +class SoapStubAdapterBase(StubAdapterBase): + ## Serialize a VMOMI request to SOAP + # + # @param version API version + # @param mo the 'this' + # @param info method info + # @param args method arguments + # @return the serialized request + def SerializeRequest(self, mo, info, args): + if not IsChildVersion(self.version, info.version): + raise GetVmodlType("vmodl.fault.MethodNotFound")(receiver=mo, + method=info.name) + nsMap = SOAP_NSMAP.copy() + defaultNS = GetWsdlNamespace(self.version) + nsMap[defaultNS] = '' + + # Add xml header and soap envelope + result = [XML_HEADER, '\n', SOAP_ENVELOPE_START] + + # Add request context and samlToken to soap header, if exists + reqContexts = GetRequestContext() + samlToken = getattr(self, 'samlToken', None) + + if reqContexts or samlToken: + result.append(SOAP_HEADER_START) + for key, val in reqContexts.iteritems(): + # Note: Support req context of string type only + if not isinstance(val, basestring): + raise TypeError("Request context key (%s) has non-string value (%s) of %s" % (key, val, type(val))) + ret = Serialize(val, + Object(name=key, type=str, version=self.version), + self.version, + nsMap) + result.append(ret) + if samlToken: + result.append('%s %s %s' % (WSSE_HEADER_START, + samlToken, + WSSE_HEADER_END)) + result.append(SOAP_HEADER_END) + result.append('\n') + + # Serialize soap body + result.extend([SOAP_BODY_START, + '<%s xmlns="%s">' % (info.wsdlName, defaultNS), + Serialize(mo, Object(name="_this", type=ManagedObject, + version=self.version), + self.version, nsMap)]) + + # Serialize soap request parameters + for (param, arg) in zip(info.params, args): + result.append(Serialize(arg, param, self.version, nsMap)) + result.extend(['' % info.wsdlName, SOAP_BODY_END, SOAP_ENVELOPE_END]) + return ''.join(result) + +## Subclass of HTTPConnection that connects over a Unix domain socket +## instead of a TCP port. The path of the socket is passed in place of +## the hostname. Fairly gross but does the job. +class UnixSocketConnection(httplib.HTTPConnection): + # The HTTPConnection ctor expects a single argument, which it interprets + # as the host to connect to; for UnixSocketConnection, we instead interpret + # the parameter as the filesystem path of the Unix domain socket. + def __init__(self, path): + # Pass '' as the host to HTTPConnection; it doesn't really matter + # what we pass (since we've overridden the connect method) as long + # as it's a valid string. + httplib.HTTPConnection.__init__(self, '') + self.path = path + + def connect(self): + # Hijack the connect method of HTTPConnection to connect to the + # specified Unix domain socket instead. Obey the same contract + # as HTTPConnection.connect, which puts the socket in self.sock. + sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) + sock.connect(self.path) + self.sock = sock + +try: + # The ssl module is not available in python versions less than 2.6 + SSL_THUMBPRINTS_SUPPORTED = True + + import ssl + import hashlib + + def _VerifyThumbprint(thumbprint, connection): + '''If there is a thumbprint, connect to the server and verify that the + SSL certificate matches the given thumbprint. An exception is thrown + if there is a mismatch.''' + if thumbprint and isinstance(connection, httplib.HTTPSConnection): + if not connection.sock: + connection.connect() + derCert = connection.sock.getpeercert(True) + sha1 = hashlib.sha1() + sha1.update(derCert) + sha1Digest = sha1.hexdigest().lower() + if sha1Digest != thumbprint: + raise Exception("Server has wrong SHA1 thumbprint: %s " + "(required) != %s (server)" % ( + thumbprint, sha1Digest)) + + # Function used to wrap sockets with SSL + _SocketWrapper = ssl.wrap_socket + +except ImportError: + SSL_THUMBPRINTS_SUPPORTED = False + + def _VerifyThumbprint(thumbprint, connection): + if thumbprint and isinstance(connection, httplib.HTTPSConnection): + raise Exception( + "Thumbprint verification not supported on python < 2.6") + + def _SocketWrapper(rawSocket, keyfile, certfile, *args, **kwargs): + wrappedSocket = socket.ssl(rawSocket, keyfile, certfile) + return httplib.FakeSocket(rawSocket, wrappedSocket) + +## Internal version of https connection +# +# Support ssl.wrap_socket params which are missing from httplib +# HTTPSConnection (e.g. ca_certs) +# Note: Only works iff the ssl params are passing in as kwargs +class _HTTPSConnection(httplib.HTTPSConnection): + def __init__(self, *args, **kwargs): + # Extract ssl.wrap_socket param unknown to httplib.HTTPConnection, + # and push back the params in connect() + self._sslArgs = {} + tmpKwargs = kwargs.copy() + for key in ["server_side", "cert_reqs", "ssl_version", "ca_certs", + "do_handshake_on_connect", "suppress_ragged_eofs", + "ciphers"]: + if key in tmpKwargs: + self._sslArgs[key] = tmpKwargs.pop(key) + httplib.HTTPSConnection.__init__(self, *args, **tmpKwargs) + + ## Override connect to allow us to pass in additional ssl paramters to + # ssl.wrap_socket (e.g. cert_reqs, ca_certs for ca cert verification) + def connect(self): + if len(self._sslArgs) == 0: + # No override + httplib.HTTPSConnection.connect(self) + return + + # Big hack. We have to copy and paste the httplib connect fn for + # each python version in order to handle extra ssl paramters. Yuk! + if hasattr(self, "source_address"): + # Python 2.7 + sock = socket.create_connection((self.host, self.port), + self.timeout, self.source_address) + if self._tunnel_host: + self.sock = sock + self._tunnel() + self.sock = ssl.wrap_socket(sock, self.key_file, self.cert_file, **self._sslArgs) + elif hasattr(self, "timeout"): + # Python 2.6 + sock = socket.create_connection((self.host, self.port), self.timeout) + self.sock = ssl.wrap_socket(sock, self.key_file, self.cert_file, **self._sslArgs) + else: + # Unknown python version. Do nothing + httplib.HTTPSConnection.connect(self) + return + + # TODO: Additional verification of peer cert if needed + #cert_reqs = self._sslArgs.get("cert_reqs", ssl.CERT_NONE) + #ca_certs = self._sslArgs.get("ca_certs", None) + #if cert_reqs != ssl.CERT_NONE and ca_certs: + # if hasattr(self.sock, "getpeercert"): + # # TODO: verify peer cert + # dercert = self.sock.getpeercert(False) + # # pemcert = ssl.DER_cert_to_PEM_cert(dercert) + +## Stand-in for the HTTPSConnection class that will connect to a proxy and +## issue a CONNECT command to start an SSL tunnel. +class SSLTunnelConnection(object): + # @param proxyPath The path to pass to the CONNECT command. + def __init__(self, proxyPath): + self.proxyPath = proxyPath + + # Connects to a proxy server and initiates a tunnel to the destination + # specified by proxyPath. If successful, a new HTTPSConnection is returned. + # + # @param path The destination URL path. + # @param key_file The SSL key file to use when wrapping the socket. + # @param cert_file The SSL certificate file to use when wrapping the socket. + # @param kwargs In case caller passed in extra parameters not handled by + # SSLTunnelConnection + def __call__(self, path, key_file=None, cert_file=None, **kwargs): + # Don't pass any keyword args that HTTPConnection won't understand. + for arg in kwargs.keys(): + if arg not in ("port", "strict", "timeout", "source_address"): + del kwargs[arg] + tunnel = httplib.HTTPConnection(path, **kwargs) + tunnel.request('CONNECT', self.proxyPath) + resp = tunnel.getresponse() + tunnelSocket = resp.fp + if resp.status != 200: + raise httplib.HTTPException("%d %s" % (resp.status, resp.reason)) + retval = httplib.HTTPSConnection(path) + retval.sock = _SocketWrapper(tunnelSocket, + keyfile=key_file, certfile=cert_file) + return retval + + +class GzipReader: + GZIP = 1 + DEFLATE = 2 + + def __init__(self, rfile, encoding=GZIP, readChunkSize=512): + self.rfile = rfile + self.chunks = [] + self.bufSize = 0 # Remaining buffer + assert(encoding in (GzipReader.GZIP, GzipReader.DEFLATE)) + self.encoding = encoding + self.unzip = None + self.readChunkSize = readChunkSize + + def _CreateUnzip(self, firstChunk): + import zlib + if self.encoding == GzipReader.GZIP: + wbits = zlib.MAX_WBITS + 16 + elif self.encoding == GzipReader.DEFLATE: + # Sniff out real deflate format + chunkLen = len(firstChunk) + # Assume raw deflate + wbits = -zlib.MAX_WBITS + if firstChunk[:3] == ['\x1f', '\x8b', '\x08']: + # gzip: Apache mod_deflate will send gzip. Yurk! + wbits = zlib.MAX_WBITS + 16 + elif chunkLen >= 2: + b0 = ord(firstChunk[0]) + b1 = ord(firstChunk[1]) + if (b0 & 0xf) == 8 and (((b0 * 256 + b1)) % 31) == 0: + # zlib deflate + wbits = min(((b0 & 0xf0) >> 4) + 8, zlib.MAX_WBITS) + else: + assert(False) + self.unzip = zlib.decompressobj(wbits) + return self.unzip + + def read(self, bytes=-1): + chunks = self.chunks + bufSize = self.bufSize + + while bufSize < bytes or bytes == -1: + # Read and decompress + chunk = self.rfile.read(self.readChunkSize) + + if self.unzip == None: + self._CreateUnzip(chunk) + + if chunk: + inflatedChunk = self.unzip.decompress(chunk) + bufSize += len(inflatedChunk) + chunks.append(inflatedChunk) + else: + # Returns whatever we have + break + + if bufSize <= bytes or bytes == -1: + leftoverBytes = 0 + leftoverChunks = [] + else: + leftoverBytes = bufSize - bytes + # Adjust last chunk to hold only the left over bytes + lastChunk = chunks.pop() + chunks.append(lastChunk[:-leftoverBytes]) + leftoverChunks = [lastChunk[-leftoverBytes:]] + + self.chunks = leftoverChunks + self.bufSize = leftoverBytes + + buf = "".join(chunks) + return buf + +## SOAP stub adapter object +class SoapStubAdapter(SoapStubAdapterBase): + ## Constructor + # + # The endpoint can be specified individually as either a host/port + # combination, or with a URL (using a url= keyword). + # + # @param self self + # @param host host + # @param port port (pass negative port number for no SSL) + # @param **** Deprecated. Please use version instead **** ns API namespace + # @param path location of SOAP VMOMI service + # @param url URL (overrides host, port, path if set) + # @param sock unix domain socket path (overrides host, port, url if set) + # @param poolSize size of HTTP connection pool + # @param certKeyFile The path to the PEM-encoded SSL private key file. + # @param certFile The path to the PEM-encoded SSL certificate file. + # @param httpProxyHost The host name of the proxy server. + # @param httpProxyPort The proxy server port. + # @param sslProxyPath Path to use when tunneling through VC's reverse proxy. + # @param thumbprint The SHA1 thumbprint of the server's SSL certificate. + # Some use a thumbprint of the form xx:xx:xx..:xx. We ignore the ":" + # characters. If set to None, any thumbprint is accepted. + # @param cacertsFile CA certificates file in PEM format + # @param version API version + # @param connectionPoolTimeout Timeout in secs for idle connections in client pool. Use -1 to disable any timeout. + # @param samlToken SAML Token that should be used in SOAP security header for login + def __init__(self, host='localhost', port=443, ns=None, path='/sdk', + url=None, sock=None, poolSize=5, + certFile=None, certKeyFile=None, + httpProxyHost=None, httpProxyPort=80, sslProxyPath=None, + thumbprint=None, cacertsFile=None, version=None, + acceptCompressedResponses=True, + connectionPoolTimeout=CONNECTION_POOL_IDLE_TIMEOUT_SEC, + samlToken=None): + if ns: + assert(version is None) + version = versionMap[ns] + elif not version: + version = 'vim.version.version1' + SoapStubAdapterBase.__init__(self, version=version) + self.cookie = "" + if sock: + self.scheme = UnixSocketConnection + # Store sock in the host member variable because that's where + # the UnixSocketConnection ctor expects to find it -- see above + self.host = sock + elif url: + scheme, self.host, urlpath = urlparse.urlparse(url)[:3] + # Only use the URL path if it's sensible, otherwise use the path + # keyword argument as passed in. + if urlpath not in ('', '/'): + path = urlpath + self.scheme = scheme == "http" and httplib.HTTPConnection \ + or scheme == "https" and _HTTPSConnection + else: + port, self.scheme = port < 0 and (-port, httplib.HTTPConnection) \ + or (port, _HTTPSConnection) + if host.find(':') != -1: # is IPv6? + host = '[' + host + ']' + self.host = '%s:%d' % (host, port) + + self.path = path + if thumbprint: + self.thumbprint = thumbprint.replace(":", "").lower() + if len(self.thumbprint) != 40: + raise Exception("Invalid SHA1 thumbprint -- %s" % thumbprint) + else: + self.thumbprint = None + + if sslProxyPath: + self.scheme = SSLTunnelConnection(sslProxyPath) + elif httpProxyHost: + if self.scheme == _HTTPSConnection: + self.scheme = SSLTunnelConnection(self.host) + else: + if url: + self.path = url + else: + self.path = "http://%s/%s" % (self.host, path) + # Swap the actual host with the proxy. + self.host = "%s:%d" % (httpProxyHost, httpProxyPort) + self.poolSize = poolSize + self.pool = [] + self.connectionPoolTimeout = connectionPoolTimeout + self.lock = thread.allocate_lock() + self.schemeArgs = {} + if certKeyFile: + self.schemeArgs['key_file'] = certKeyFile + if certFile: + self.schemeArgs['cert_file'] = certFile + if cacertsFile: + self.schemeArgs['ca_certs'] = cacertsFile + self.schemeArgs['cert_reqs'] = ssl.CERT_REQUIRED + self.samlToken = samlToken + self.requestModifierList = [] + self._acceptCompressedResponses = acceptCompressedResponses + + + # Context modifier used to modify the SOAP request. + # @param func The func that takes in the serialized message and modifies the + # the request. The func is appended to the requestModifierList and then + # popped after the request is modified. + @contextlib.contextmanager + def requestModifier(self, func): + self.requestModifierList.append(func) + try: + yield + finally: + self.requestModifierList.pop() + ## Invoke a managed method + # + # @param self self + # @param mo the 'this' + # @param info method info + # @param args arguments + # @param outerStub If not-None, this should be a reference to the wrapping + # stub adapter. Any ManagedObject references returned from this method + # will have outerStub in their _stub field. Note that this also changes + # the return type to a tuple containing the HTTP status and the + # deserialized object so that it's easier to distinguish an API error from + # a connection error. + def InvokeMethod(self, mo, info, args, outerStub=None): + if outerStub is None: + outerStub = self + + headers = {'Cookie' : self.cookie, + 'SOAPAction' : self.versionId, + 'Content-Type' : 'text/xml; charset=%s' % XML_ENCODING} + if self._acceptCompressedResponses: + headers['Accept-Encoding'] = 'gzip, deflate' + req = self.SerializeRequest(mo, info, args) + for modifier in self.requestModifierList: + req = modifier(req) + conn = self.GetConnection() + try: + conn.request('POST', self.path, req, headers) + resp = conn.getresponse() + except (socket.error, httplib.HTTPException): + # The server is probably sick, drop all of the cached connections. + self.DropConnections() + raise + cookie = resp.getheader('set-cookie') + status = resp.status + + if cookie: + self.cookie = cookie + if status == 200 or status == 500: + try: + fd = resp + encoding = resp.getheader('Content-Encoding', 'identity').lower() + if encoding == 'gzip': + fd = GzipReader(resp, encoding=GzipReader.GZIP) + elif encoding == 'deflate': + fd = GzipReader(resp, encoding=GzipReader.DEFLATE) + obj = SoapResponseDeserializer(outerStub).Deserialize(fd, info.result) + except: + conn.close() + # The server might be sick, drop all of the cached connections. + self.DropConnections() + raise + else: + resp.read() + self.ReturnConnection(conn) + if outerStub != self: + return (status, obj) + if status == 200: + return obj + else: + raise obj # pylint: disable-msg=E0702 + else: + conn.close() + raise httplib.HTTPException("%d %s" % (resp.status, resp.reason)) + + ## Clean up connection pool to throw away idle timed-out connections + # SoapStubAdapter lock must be acquired before this method is called. + def _CloseIdleConnections(self): + if self.connectionPoolTimeout >= 0: + currentTime = time.time() + idleConnections = [] + for conn, lastAccessTime in self.pool: + idleTime = currentTime - lastAccessTime + if idleTime >= self.connectionPoolTimeout: + i = self.pool.index((conn, lastAccessTime)) + idleConnections = self.pool[i:] + self.pool = self.pool[:i] + break + + for conn, _ in idleConnections: + conn.close() + + ## Get a HTTP connection from the pool + def GetConnection(self): + self.lock.acquire() + self._CloseIdleConnections() + if self.pool: + result, _ = self.pool.pop(0) + self.lock.release() + else: + self.lock.release() + result = self.scheme(self.host, **self.schemeArgs) + + # Always disable NAGLE algorithm + # + # Python httplib (2.6 and below) is splitting a http request into 2 + # packets (header and body). It first send the header, but will not + # send the body until it receives the ack (for header) from server + # [NAGLE at work]. The delayed ack time on ESX is around 40 - 100 ms + # (depends on version) and can go up to 200 ms. This effectively slow + # down each pyVmomi call by the same amount of time. + # + # Disable NAGLE on client will force both header and body packets to + # get out immediately, and eliminated the delay + # + # This bug is fixed in python 2.7, however, only if the request + # body is a string (which is true for now) + if sys.version_info[:2] < (2,7): + self.DisableNagle(result) + + _VerifyThumbprint(self.thumbprint, result) + + return result + + ## Drop all cached connections to the server. + def DropConnections(self): + self.lock.acquire() + oldConnections = self.pool + self.pool = [] + self.lock.release() + for conn, _ in oldConnections: + conn.close() + + ## Return a HTTP connection to the pool + def ReturnConnection(self, conn): + self.lock.acquire() + self._CloseIdleConnections() + if len(self.pool) < self.poolSize: + self.pool.insert(0, (conn, time.time())) + self.lock.release() + else: + self.lock.release() + conn.close() + + ## Disable nagle on a http connections + def DisableNagle(self, conn): + # Override connections' connect function to force disable NAGLE + if self.scheme != UnixSocketConnection and getattr(conn, "connect"): + orgConnect = conn.connect + def ConnectDisableNagle(*args, **kwargs): + orgConnect(*args, **kwargs) + sock = getattr(conn, "sock") + if sock: + try: + sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) + except Exception: + pass + conn.connect = ConnectDisableNagle + + +HEADER_SECTION_END = '\r\n\r\n' + +## Parse an HTTP response into its headers and body +def ParseHttpResponse(httpResponse): + headerEnd = httpResponse.find(HEADER_SECTION_END) + if headerEnd == -1: + return ('', '') + headerEnd += len(HEADER_SECTION_END); + headerText = httpResponse[:headerEnd] + bodyText = httpResponse[headerEnd:] + return (headerText, bodyText) + + +## SOAP-over-stdio stub adapter object +class SoapCmdStubAdapter(SoapStubAdapterBase): + ## Constructor + # + # @param self self + # @param cmd command to execute + # @param ns API namespace + def __init__(self, cmd, version='vim.version.version1'): + SoapStubAdapterBase.__init__(self, version=version) + self.cmd = cmd + self.systemError = GetVmodlType('vmodl.fault.SystemError') + + ## Invoke a managed method + # + # @param self self + # @param mo the 'this' + # @param info method info + # @param args arguments + def InvokeMethod(self, mo, info, args): + argv = self.cmd.split() + req = self.SerializeRequest(mo, info, args) + env = dict(os.environ) + env['REQUEST_METHOD'] = 'POST' + env['CONTENT_LENGTH'] = str(len(req)) + env['HTTP_SOAPACTION'] = self.versionId[1:-1] + p = subprocess.Popen(argv, + stdin=subprocess.PIPE, + stdout=subprocess.PIPE, + stderr=subprocess.PIPE, + env=env) + (outText, errText) = p.communicate(req) + if p.returncode < 0: + # Process died with a signal + errText = "Process terminated with signal %d\n%s" % (-p.returncode, errText) + raise self.systemError(msg=errText, reason=errText) + + try: + (responseHeaders, responseBody) = ParseHttpResponse(outText) + obj = SoapResponseDeserializer(self).Deserialize(responseBody, info.result) + except: + errText = "Failure parsing SOAP response (%s)\n%s" % (outText, errText) + raise self.systemError(msg=errText, reason=errText) + + if p.returncode == 0: + return obj + elif obj is None: + raise self.systemError(msg=errText, reason=errText) + else: + raise obj # pylint: disable-msg=E0702 + + +class SessionOrientedStub(StubAdapterBase): + '''A session-oriented stub adapter that will relogin to the destination if a + session-oriented exception is thrown. + + + Here's an example. First, we setup the communication substrate: + + >>> soapStub = SoapStubAdapter(host="192.168.1.2", ns="vim25/5.0") + + Create a SessionOrientedStub that uses the stub we just created for talking + to the server: + + >>> from pyVim.connect import VimSessionOrientedStub + >>> sessionStub = VimSessionOrientedStub( + ... soapStub, + ... VimSessionOrientedStub.makeUserLoginMethod("root", "vmware")) + + Perform some privileged operations without needing to explicitly login: + + >>> si = Vim.ServiceInstance("ServiceInstance", sessionStub) + >>> si.content.sessionManager.sessionList + >>> si.content.sessionManager.Logout() + >>> si.content.sessionManager.sessionList + ''' + + STATE_UNAUTHENTICATED = 0 + STATE_AUTHENTICATED = 1 + + SESSION_EXCEPTIONS = tuple() + + def __init__(self, soapStub, loginMethod, retryDelay=0.1, retryCount=4): + '''Construct a SessionOrientedStub. + + The stub starts off in the "unauthenticated" state, so it will call the + loginMethod on the first invocation of a method. If a communication error + is encountered, the stub will wait for retryDelay seconds and then try to + call the method again. If the server throws an exception that is in the + SESSION_EXCEPTIONS tuple, it will be caught and the stub will transition + back into the "unauthenticated" state so that another login will be + performed. + + @param soapStub The communication substrate. + @param loginMethod A function that takes a single parameter, soapStub, and + performs the necessary operations to authenticate with the server. + @param retryDelay The amount of time to sleep before retrying after a + communication error. + @param retryCount The number of times to retry connecting to the server. + ''' + assert callable(loginMethod) + assert retryCount >= 0 + + self.lock = threading.Lock() + self.soapStub = soapStub + self.version = soapStub.version + self.state = self.STATE_UNAUTHENTICATED + + self.loginMethod = loginMethod + self.retryDelay = retryDelay + self.retryCount = retryCount + + def InvokeMethod(self, mo, info, args): + retriesLeft = self.retryCount + while retriesLeft > 0: + try: + if self.state == self.STATE_UNAUTHENTICATED: + try: + self.lock.acquire() + if self.state == self.STATE_UNAUTHENTICATED: + self.loginMethod(self.soapStub) + self.state = self.STATE_AUTHENTICATED + finally: + self.lock.release() + + status, obj = self.soapStub.InvokeMethod(mo, info, args, self) + except (socket.error, httplib.HTTPException, ExpatError): + if self.retryDelay and retriesLeft: + time.sleep(self.retryDelay) + retriesLeft -= 1 + continue + + if status == 200: + # Normal return from the server, return the object to the caller. + return obj + + # An exceptional return from the server + if isinstance(obj, self.SESSION_EXCEPTIONS): + # Our session might've timed out, change our state and retry. + self.lock.acquire() + if self.state == self.STATE_AUTHENTICATED: + self.state = self.STATE_UNAUTHENTICATED + self.lock.release() + else: + # It's an exception from the method that was called, send it up. + raise obj + + # Raise any socket/httplib errors caught above. + raise diff --git a/pyVmomi/StubAdapterAccessorImpl.py b/pyVmomi/StubAdapterAccessorImpl.py new file mode 100644 index 0000000..a34bc8c --- /dev/null +++ b/pyVmomi/StubAdapterAccessorImpl.py @@ -0,0 +1,41 @@ +# VMware vSphere Python SDK +# Copyright (c) 2008-2013 VMware, Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from VmomiSupport import GetVmodlType + +class StubAdapterAccessorMixin: + def __init__(self): + self._pc = None + self._pcType = GetVmodlType("vmodl.query.PropertyCollector") + self._siType = GetVmodlType("vim.ServiceInstance") + + ## Retrieve a managed property + # + # @param self self + # @param mo managed object + # @param info property info + def InvokeAccessor(self, mo, info): + filterSpec = self._pcType.FilterSpec( + objectSet=[self._pcType.ObjectSpec(obj=mo, skip=False)], + propSet=[self._pcType.PropertySpec(all=False, type=mo.__class__, + pathSet=[info.name])], + ) + ## Cache the property collector if it isn't already + # No need to lock _pc since multiple instances of PropertyCollector on + # the client will talk to the same instance on the server. + if not self._pc: + si = self._siType("ServiceInstance", self) + self._pc = si.RetrieveContent().propertyCollector + return self._pc.RetrieveContents([filterSpec])[0].propSet[0].val diff --git a/pyVmomi/Version.py b/pyVmomi/Version.py new file mode 100644 index 0000000..2a6971b --- /dev/null +++ b/pyVmomi/Version.py @@ -0,0 +1,36 @@ +# VMware vSphere Python SDK +# Copyright (c) 2008-2013 VMware, Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from VmomiSupport import nsMap, versionMap, versionIdMap, serviceNsMap, parentMap + +## Add an API version +def AddVersion(version, ns, versionId='', isLegacy=0, serviceNs=''): + if not ns: + ns = serviceNs + if not (version in parentMap): + nsMap[version] = ns + if len(versionId) > 0: + versionMap[ns + '/' + versionId] = version + if isLegacy or ns is "": + versionMap[ns] = version + versionIdMap[version] = versionId + if not serviceNs: + serviceNs = ns + serviceNsMap[version] = serviceNs + parentMap[version] = {} + +## Check if a version is a child of another +def IsChildVersion(child, parent): + return child == parent or parent in parentMap[child] diff --git a/pyVmomi/VmomiSupport.py b/pyVmomi/VmomiSupport.py new file mode 100644 index 0000000..73912bc --- /dev/null +++ b/pyVmomi/VmomiSupport.py @@ -0,0 +1,1630 @@ +# VMware vSphere Python SDK +# Copyright (c) 2008-2013 VMware, Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +## VMOMI support code +from __future__ import with_statement # 2.5 only + +from datetime import datetime +import Iso8601 +import base64 +import threading +NoneType = type(None) +try: + from pyVmomiSettings import allowGetSet + _allowGetSet = allowGetSet +except: + _allowGetSet = True + +try: + from pyVmomiSettings import allowCapitalizedNames + _allowCapitalizedNames = allowCapitalizedNames +except: + _allowCapitalizedNames = True + +(F_LINK, + F_LINKABLE, + F_OPTIONAL) = [ 1< len(info.params): + s = "s"*(len(info.params)!=1) + raise TypeError("%s() takes at most %d argument%s (%d given)" % + (Capitalize(info.name), len(info.params), s, len(posargs))) + args = list(posargs) + [None] * (len(info.params) - len(posargs)) + if len(kwargs) > 0: + paramNames = [param.name for param in info.params] + for (k, v) in kwargs.items(): + try: + idx = paramNames.index(k) + except ValueError: + raise TypeError("%s() got an unexpected keyword argument '%s'" % + (Capitalize(info.name), k)) + if idx < len(posargs): + raise TypeError("%s() got multiple values for keyword argument '%s'" % + (Capitalize(info.name), k)) + args[idx] = v + map(CheckField, info.params, args) + return self._stub.InvokeMethod(self, info, args) + _InvokeMethod = staticmethod(_InvokeMethod) + + ## Invoke a managed property accessor + # + # @param info property info + # @param self self + def _InvokeAccessor(info, self): + return self._stub.InvokeAccessor(self, info) + _InvokeAccessor = staticmethod(_InvokeAccessor) + + ## Get the ID of a managed object + def _GetMoId(self): + return self._moId + + ## Get the serverGuid of a managed object + def _GetServerGuid(self): + return self._serverGuid + + ## Get the stub of a managed object + def _GetStub(self): + return self._stub + + ## Get a list of all properties of this type and base types + # + # @param cls The managed object type + def _GetPropertyList(cls, includeBaseClassProps=True): + if not includeBaseClassProps: + return cls._propList + prop = {} + result = [] + while cls != ManagedObject: + # Iterate through props, add info for prop not found in derived class + result = [info for info in cls._propList + if prop.setdefault(info.name, cls) == cls] + result + cls = cls.__bases__[0] + return result + _GetPropertyList = classmethod(_GetPropertyList) + + ## Get a list of all methods of this type and base types + # + # @param cls The managed object type + def _GetMethodList(cls): + meth = {} + result = [] + while cls != ManagedObject: + # Iterate through methods, add info for method not found in derived class + result = [info for info in cls._methodInfo.values() + if meth.setdefault(info.name, cls) == cls] + result + cls = cls.__bases__[0] + return result + _GetMethodList = classmethod(_GetMethodList) + + ## Lookup a method for a given managed object type + # + # @param type the type + # @param name the name of the property + def _GetMethodInfo(type, name): + while hasattr(type, "_methodInfo"): + try: + return type._methodInfo[name] + except KeyError: + type = type.__bases__[0] + raise AttributeError(name) + _GetMethodInfo = classmethod(_GetMethodInfo) + + def __setattr__(self,*args): + if self._stub is not None: + raise Exception("Managed object attributes are read-only") + else: + object.__setattr__(self,*args) + __delattr__ = __setattr__ + + if _allowGetSet == True: + def __getattr__(self, name): + if name.startswith("Get"): + return lambda : getattr(self, name[3].lower() + name[4:]) + elif name.startswith("Set"): + return lambda val: setattr(self, name[3].lower() + name[4:], val) + raise AttributeError(name) + + ## The equality test of ManagedObject is for client side only and might + # not be appropriate for server side objects. The server side object has + # to override this function if it has a different equality logic + def __eq__(self, other): + if other is None: + return False + else: + return self._moId == other._moId and \ + self.__class__ == other.__class__ and \ + self._serverGuid == other._serverGuid + + def __hash__(self): + return str(self).__hash__() + + __str__ = __repr__ = FormatObject + _GetPropertyInfo = classmethod(GetPropertyInfo) + +## VMOMI Data Object class +class DataObject(Base): + _wsdlName = "DataObject" + _propInfo = {} + _propList = [] + _version = BASE_VERSION + + ## Constructor + # + # @param info property info + # @param ... keyword arguments indicate properties + def __init__(self, **kwargs): + for info in self._GetPropertyList(): + if issubclass(info.type, list): + SetAttr(self, info.name, info.type()) + elif info.flags & F_OPTIONAL: + SetAttr(self, info.name, None) + elif info.type is bool: + SetAttr(self, info.name, False) + elif issubclass(info.type, Enum): + SetAttr(self, info.name, None) + elif issubclass(info.type, str): + SetAttr(self, info.name, "") + elif info.type is long or \ + issubclass(info.type, int) or \ + issubclass(info.type, float): + # Take care of byte, short, int, long, float and double + SetAttr(self, info.name, info.type(0)) + else: + SetAttr(self, info.name, None) + for (k, v) in kwargs.items(): + setattr(self, k, v) + + ## Get a list of all properties of this type and base types + # + # @param cls the data object type + def _GetPropertyList(cls, includeBaseClassProps=True): + if not includeBaseClassProps: + return cls._propList + prop = {} + result = [] + while cls != DataObject: + # Iterate through props, add info for prop not found in derived class + result = [info for info in cls._propList + if prop.setdefault(info.name, cls) == cls] + result + cls = cls.__bases__[0] + return result + _GetPropertyList = classmethod(_GetPropertyList) + + def __setattr__(self, name, val): + CheckField(self._GetPropertyInfo(name), val) + SetAttr(self, name, val) + + if _allowGetSet == True: + def __getattr__(self, name): + if name.startswith("Get"): + return lambda : getattr(self, name[3].lower() + name[4:]) + elif name.startswith("Set"): + return lambda val: setattr(self, name[3].lower() + name[4:], val) + raise AttributeError(name) + + _GetPropertyInfo = classmethod(GetPropertyInfo) + __str__ = __repr__ = FormatObject + +## Base class for enum types +class Enum(str): pass + +## Base class for array types +class Array(list): + __str__ = __repr__ = FormatObject + +## Class for curried function objects +# +# Instances of this class are curried python function objects. +# If g = Curry(f, a1,...,an), then g(b1,...,bm) = f(a1,...,an, b1,...,bm) +class Curry(object): + ## Constructor + # + # @param self self + # @param f the function object + # @param args arguments to fix + def __init__(self, f, *args): + self.f = f + self.args = args + + def __call__(self, *args, **kwargs): + args = self.args + args + return self.f(*args, **kwargs) + + def __get__(self, obj, type): + if obj: + # curried methods will receive 'self' *after* any fixed arguments + return lambda *args, **kwargs: \ + self.f(*(self.args + (obj,) + args), **kwargs) + return self + +## Class for managed object methods +class ManagedMethod(Curry): + ## Constructor + # + # @param self self + # @param info method info + def __init__(self, info): + Curry.__init__(self, ManagedObject._InvokeMethod, info) + self.info = info + +## Create the vmodl.MethodFault type +# +# This type must be generated dynamically because it inherits from +# vmodl.DynamicData, which is created dynamically by the emitted code. +# +# @return the new type +def CreateAndLoadMethodFaultType(): + with _lazyLock: + props = [["msg", "string", BASE_VERSION, F_OPTIONAL], + ["faultCause", "vmodl.MethodFault", "vmodl.version.version1", F_OPTIONAL], + ["faultMessage", "vmodl.LocalizableMessage[]", "vmodl.version.version1", F_OPTIONAL]] + propInfo = {} + propList = [ LazyObject(name=p[0], typeName=p[1], version=p[2], flags=p[3]) + for p in props ] + dic = {"_wsdlName" : "MethodFault", "_propInfo" : propInfo, + "_propList" : propList, "_version" : BASE_VERSION} + for info in propList: + propInfo[info.name] = info + name = "vmodl.MethodFault" + CreateDataType("vmodl.MethodFault", "MethodFault", "vmodl.DynamicData", BASE_VERSION, props) + return _AddType(type(Exception)(name, + (GetWsdlType(XMLNS_VMODL_BASE, "DynamicData"), Exception), + dic)) + +# If the name of nested class of vmodl type is same as one of the nested classes +# of its parent, then we have to replace it. Else it won't be possible to intercept +# it with LazyType class +# @param vmodl type +# @param parent of the vmodl type +# @return vmodl type +def _CheckNestedClasses(typ, parent): + with _lazyLock: + vmodlName = typ.__name__ + nestedClasses = _dependencyMap.get(vmodlName, []) + for nestedClass in nestedClasses: + if hasattr(parent, nestedClass): + setattr(typ, nestedClass, GetVmodlType(vmodlName + "." + nestedClass)) + return typ + +## Create and Load a data object type at once +# +# @param vmodlName the VMODL name of the type +# @param wsdlName the WSDL name of the type +# @param parent the VMODL name of the parent type +# @param version the version of the type +# @param props properties of the type +# @return vmodl type +def CreateAndLoadDataType(vmodlName, wsdlName, parent, version, props): + CreateDataType(vmodlName, wsdlName, parent, version, props) + return LoadDataType(vmodlName, wsdlName, parent, version, props) + +## Create a data object type +# +# @param vmodlName the VMODL name of the type +# @param wsdlName the WSDL name of the type +# @param parent the VMODL name of the parent type +# @param version the version of the type +# @param props properties of the type +def CreateDataType(vmodlName, wsdlName, parent, version, props): + with _lazyLock: + dic = [vmodlName, wsdlName, parent, version, props] + names = vmodlName.split(".") + if _allowCapitalizedNames: + vmodlName = ".".join(name[0].lower() + name[1:] for name in names) + _AddToDependencyMap(names) + typeNs = GetWsdlNamespace(version) + + _dataDefMap[vmodlName] = dic + _wsdlDefMap[(typeNs, wsdlName)] = dic + _wsdlTypeMapNSs.add(typeNs) + +## Load a data object type +# This function also loads the parent of the type if it's not loaded yet +# +# @param vmodlName the VMODL name of the type +# @param wsdlName the WSDL name of the type +# @param parent the VMODL name of the parent type +# @param version the version of the type +# @param props properties of the type +# @return the new data object type +def LoadDataType(vmodlName, wsdlName, parent, version, props): + with _lazyLock: + # Empty lists are saved as None in globals maps as it is much more memory + # efficient. PythonStubEmitter files emit empty lists as None. + if props is None: + props = [] + propInfo = {} + propList = [] + for p in props: + # DataObject Property does not contain the privilege for emitted types. + # However, DynamicTypeConstructor from DynamicTypeManagerHelper.py creates + # DataTypes with properties containing privilege id. + name, typeName, propVersion, flags = p[:4] + if flags & F_LINK: + if typeName.endswith("[]"): + linkType = "Link[]" + else: + linkType = "Link" + obj = LazyObject(name=name, typeName=linkType, version=propVersion, + flags=flags, expectedType=typeName) + else: + obj = LazyObject(name=name, typeName=typeName, version=propVersion, + flags=flags) + propList.append(obj) + dic = {"_wsdlName" : wsdlName, "_propInfo" : propInfo, + "_propList" : propList, "_version" : version} + for info in propList: + propInfo[info.name] = info + name = vmodlName + parent = GetVmodlType(parent) + result = _AddType(LazyType(name, (parent,), dic)) + + # MethodFault and RuntimeFault are builtin types, but MethodFault extends + # DynamicData, which is (erroneously?) an emitted type, so we can't create + # MethodFault and RuntimeFault until we have loaded DynamicData + if wsdlName == "DynamicData": + CreateAndLoadMethodFaultType() + CreateAndLoadDataType("vmodl.RuntimeFault", "RuntimeFault", + "vmodl.MethodFault", BASE_VERSION, []) + # Strictly speaking LocalizedMethodFault is not a data object type + # (it can't be used in VMODL) But it can be treated as a data object for + # (de)serialization purpose + CreateAndLoadDataType("vmodl.LocalizedMethodFault", "LocalizedMethodFault", + "vmodl.MethodFault", BASE_VERSION, + [("fault", "vmodl.MethodFault", BASE_VERSION, 0), + ("localizedMessage", "string", BASE_VERSION, F_OPTIONAL), + ]) + + return _CheckNestedClasses(result, parent) + +## Create and Load a managed object type at once +# +# @param vmodlName the VMODL name of the type +# @param wsdlName the WSDL name of the type +# @param parent the VMODL name of the parent type +# @param version the version of the type +# @param props properties of the type +# @param methods methods of the type +# @return vmodl type +def CreateAndLoadManagedType(vmodlName, wsdlName, parent, version, props, methods): + CreateManagedType(vmodlName, wsdlName, parent, version, props, methods) + return LoadManagedType(vmodlName, wsdlName, parent, version, props, methods) + +## Create a managed object type +# +# @param vmodlName the VMODL name of the type +# @param wsdlName the WSDL name of the type +# @param parent the VMODL name of the parent type +# @param version the version of the type +# @param props properties of the type +# @param methods methods of the type +def CreateManagedType(vmodlName, wsdlName, parent, version, props, methods): + with _lazyLock: + dic = [vmodlName, wsdlName, parent, version, props, methods] + names = vmodlName.split(".") + if _allowCapitalizedNames: + vmodlName = ".".join(name[0].lower() + name[1:] for name in names) + + _AddToDependencyMap(names) + typeNs = GetWsdlNamespace(version) + + if methods: + for meth in methods: + _SetWsdlMethod(typeNs, meth[1], dic) + + _managedDefMap[vmodlName] = dic + _wsdlDefMap[(typeNs, wsdlName)] = dic + _wsdlTypeMapNSs.add(typeNs) + +## Load a managed object type +# This function also loads the parent of the type if it's not loaded yet +# +# @param vmodlName the VMODL name of the type +# @param wsdlName the WSDL name of the type +# @param parent the VMODL name of the parent type +# @param version the version of the type +# @param props properties of the type +# @param methods methods of the type +# @return the new managed object type +def LoadManagedType(vmodlName, wsdlName, parent, version, props, methods): + with _lazyLock: + # Empty lists are saved as None in globals maps as it is much more memory + # efficient. PythonStubEmitter files emit empty lists as None. + if props is None: + props = [] + if methods is None: + methods = [] + parent = GetVmodlType(parent) + propInfo = {} + methodInfo = {} + propList = [LazyObject(name=p[0], typeName=p[1], version=p[2], flags=p[3], + privId=p[4]) for p in props] + dic = {"_wsdlName" : wsdlName, "_propInfo" : propInfo, + "_propList" : propList, + "_methodInfo" : methodInfo, "_version" : version} + for info in propList: + propInfo[info.name] = info + getter = Curry(ManagedObject._InvokeAccessor, info) + dic[info.name] = property(getter) + for (mVmodl, mWsdl, mVersion, mParams, mResult, mPrivilege, mFaults) in methods: + if mFaults is None: + mFaults = [] + mName = Capitalize(mVmodl) + isTask = False + if mName.endswith("_Task"): + mName = mName[:-5] + isTask = True + params = tuple([LazyObject(name=p[0], typeName=p[1], version=p[2], flags=p[3], + privId=p[4]) for p in mParams]) + info = LazyObject(name=mName, typeName=vmodlName, wsdlName=mWsdl, + version=mVersion, params=params, isTask=isTask, + resultFlags=mResult[0], resultName=mResult[1], + methodResultName=mResult[2], privId=mPrivilege, faults=mFaults) + methodInfo[mName] = info + mm = ManagedMethod(info) + ns = GetWsdlNamespace(info.version) + method = _SetWsdlMethod(ns, info.wsdlName, mm) + if method != mm: + raise RuntimeError( + "Duplicate wsdl method %s %s (new class %s vs existing %s)" % \ + (ns, info.wsdlName, mm.info.type, method.info.type)) + dic[mWsdl] = mm + dic[mName] = mm + name = vmodlName + result = _AddType(LazyType(name, (parent,) , dic)) + + return _CheckNestedClasses(result, parent) + +## Create an enum type +# +# @param vmodlName the VMODL name of the type +# @param wsdlName the WSDL name of the type +# @param version the version of the type +# @param values enum values +# @return vmodl type +def CreateAndLoadEnumType(vmodlName, wsdlName, version, values): + CreateEnumType(vmodlName, wsdlName, version, values) + return LoadEnumType(vmodlName, wsdlName, version, values) + +## Create an enum type +# +# @param vmodlName the VMODL name of the type +# @param wsdlName the WSDL name of the type +# @param version the version of the type +# @param values enum values +def CreateEnumType(vmodlName, wsdlName, version, values): + with _lazyLock: + dic = [vmodlName, wsdlName, version, values] + names = vmodlName.split(".") + if _allowCapitalizedNames: + vmodlName = ".".join(name[0].lower() + name[1:] for name in names) + + _AddToDependencyMap(names) + typeNs = GetWsdlNamespace(version) + + _enumDefMap[vmodlName] = dic + _wsdlDefMap[(typeNs, wsdlName)] = dic + _wsdlTypeMapNSs.add(typeNs) + +## Load an enum type +# +# @param vmodlName the VMODL name of the type +# @param wsdlName the WSDL name of the type +# @param version the version of the type +# @param values enum values +# @return the new enum type +def LoadEnumType(vmodlName, wsdlName, version, values): + with _lazyLock: + name = vmodlName + # Enum type cannot have nested classes. So, creating normal type + # instead of LazyType + result = type(name, (Enum,), + {"_wsdlName" : wsdlName, "_version" : version}) + result.values = map(result, values) + for value in result.values: + setattr(result, value, value) + return _AddType(result) + +## Create an array type +# +# @param itemType the item type +# @return the new array type +def CreateArrayType(itemType): + return type("%s[]" % itemType.__name__, (Array,), {'Item' : itemType}) + +## Add a new type to the type maps, create array constructors +# Note: Must be holding the _lazyLock, or in main init path +# +# @param type the type object +# @return type +def _AddType(type): + """ Note: Must be holding the _lazyLock, or in main init path """ + type.Array = CreateArrayType(type) + + typeNS = GetWsdlNamespace(type._version) + newType = _SetWsdlType(typeNS, type._wsdlName, type) + if newType != type: + raise RuntimeError("Duplicate wsdl type %s (already in typemap)" % (type._wsdlName)) + + return type + +## Check that a value matches a given type, and annotate if neccesary +# +# @param info object containing of expected type +# @param val object to check +# @throw TypeError if the value does not match the type +def CheckField(info, val): + with _lazyLock: + valType = Type(val) + if val is None or (isinstance(val, list) and len(val) == 0): + # If type of the property is an Any. We should allow this to have + # unset items + if not (info.flags & F_OPTIONAL) and info.type is not object: + raise TypeError('Required field "%s" not provided (not @optional)' % info.name) + return + elif info.type is object: + try: + GetQualifiedWsdlName(valType) + return + except KeyError: + raise TypeError('Unknown type for %s' % info.type.__name__) + elif isinstance(val, info.type): + return + elif issubclass(info.type, list): + # Checking the values of VMOMI array types is surprisingly complicated.... + if isinstance(val, Array): + # 1. We've got a PyVmomi Array object, which is effectively a typed list; + # verify that the type of the Array is a subclass of the expected type. + if issubclass(valType.Item, info.type.Item): + return + elif info.flags & F_LINK: + # Allow objects of expected type to be assigned to links + if issubclass(valType, GetVmodlType(info.expectedType)): + return + elif val: + # 2. We've got a non-empty Python list object, which is untyped; + # walk the list and make sure that each element is a subclass + # of the expected type. + + # Masking out F_OPTIONAL part of flags since we are checking for + # each element of the list + flags = info.flags & (F_LINKABLE | F_LINK) + if flags & F_LINK: + if info.expectedType.endswith('[]'): + expectedType = info.expectedType[:-2] + else: + expectedType = info.expectedType + itemInfo = Object(type=info.type.Item, name=info.name, flags=flags, + expectedType=expectedType) + else: + itemInfo = Object(type=info.type.Item, name=info.name, flags=flags) + for it in val: + CheckField(itemInfo, it) + return + else: + # 3. We've got None or an empty Python list object; + # no checking required, since the result will be an empty array. + return + elif info.type is type and valType is type(Exception) \ + or issubclass(info.type, int) and issubclass(valType, int) \ + or issubclass(info.type, long) and (issubclass(valType, int) or \ + issubclass(valType, long)) \ + or issubclass(info.type, float) and issubclass(valType, float) \ + or issubclass(info.type, basestring) and issubclass(valType, basestring): + return + elif issubclass(info.type, Link): + # Allow object of expected type to be assigned to link + if issubclass(valType, GetVmodlType(info.expectedType)): + return + raise TypeError('For "%s" expected type %s, but got %s' + % (info.name, info.type.__name__, valType.__name__)) + +## Finalize a created type +# +# @param type a created type +def FinalizeType(type): + if issubclass(type, DataObject): + for info in type._propList: + info.type = GetVmodlType(info.type) + elif issubclass(type, ManagedObject): + for info in type._propInfo.values(): + info.type = GetVmodlType(info.type) + for info in type._methodInfo.values(): + info.result = GetVmodlType(info.result) + info.methodResult = GetVmodlType(info.methodResult) + info.type = GetVmodlType(info.type) + for param in info.params: + param.type = GetVmodlType(param.type) + +## Get the type of an object, for both new and old-style classes +def Type(obj): + try: + return obj.__class__ + except AttributeError: + return type(obj) + +## Set a WSDL type with wsdl namespace and wsdl name +# Internal to VmomiSupport +# +# Note: Must be holding the _lazyLock, or in main init path +def _SetWsdlType(ns, wsdlName, typ): + """ + Set a WSDL type with wsdl namespace and wsdl name. + Returns added type / existing type if (ns, wsdlName) already in the map + + Note: Must be holding the _lazyLock, or in main init path + """ + return _wsdlTypeMap.setdefault((ns, wsdlName), typ) + +## Lookup a WSDL type from wsdl namespace and wsdl name +# @param ns XML namespace +# @param name wsdl name +# @return type if found else throws KeyError +def GetWsdlType(ns, name): + if ns is None or name is None: + raise KeyError("%s %s" % (ns, name)) + + with _lazyLock: + # Check if the type is loaded in the map + typ = _wsdlTypeMap.get( (ns, name) ) + if typ: + return typ + # It is an array type, get the actual type and return the array + elif name.startswith("ArrayOf"): + try: + return GetWsdlType(ns, name[7:]).Array + except KeyError: + raise KeyError("%s %s" % (ns, name)) + else: + # Type is not loaded yet, load it + typ = _LoadVmodlType(_wsdlDefMap[(ns, name)][0]) + if typ: + return typ + + raise KeyError("%s %s" % (ns, name)) + +## Guess the type from wsdlname with no ns +# WARNING! This should not be used in general, as there is no guarantee for +# the correctness of the guessing type +# @param name wsdl name +# @return type if found in any one of the name spaces else throws KeyError +def GuessWsdlType(name): + with _lazyLock: + # Because the types are lazily loaded, if some name is present + # in multiple namespaces, we will load the first type that we + # encounter and return it. + for ns in _wsdlTypeMapNSs: + try: + return GetWsdlType(ns, name) + except KeyError: + pass + raise KeyError(name) + +## Return a map that contains all the wsdl types +# This function is rarely used +# By calling GetWsdlType on all wsdl names, we will +# make sure that the types are loaded before returning +# the iterator +# @return iterator to the wsdl type map +def GetWsdlTypes(): + with _lazyLock: + for ns, name in _wsdlDefMap: + GetWsdlType(ns, name) + return _wsdlTypeMap.itervalues() + +## Get the qualified XML schema name (ns, name) of a type +def GetQualifiedWsdlName(type): + with _lazyLock: + wsdlNSAndName = _wsdlNameMap.get(type) + if wsdlNSAndName: + return wsdlNSAndName + else: + if issubclass(type, list): + ns = GetWsdlNamespace(type.Item._version) + return (ns, "ArrayOf" + Capitalize(type.Item._wsdlName)) + else: + ns = GetWsdlNamespace(type._version) + return (ns, type._wsdlName) + +## Get the WSDL of a type +def GetWsdlName(type): + return GetQualifiedWsdlName(type)[-1] + +## Capitalize a string +def Capitalize(str): + if str: + return str[0].upper() + str[1:] + return str + +## Uncapitalize a string +def Uncapitalize(str): + if str: + return str[0].lower() + str[1:] + return str + +## To uncapitalize the entire vmodl name +# pyVmomi used to map Java package names to capitalized Python module names, +# but now maps the Java package names unchanged to Python module names. +# This function is needed to support the legacy name mapping. +def UncapitalizeVmodlName(str): + if str: + return ".".join(name[0].lower() + name[1:] for name in str.split(".")) + return str + +## Add a parent version +def AddVersionParent(version, parent): + parentMap[version][parent] = True + +## Get version namespace from version +def GetVersionNamespace(version): + """ Get version namespace from version """ + ns = nsMap[version] + if not ns: + ns = serviceNsMap[version] + versionId = versionIdMap[version] + if not versionId: + namespace = ns + else: + namespace = '%s/%s' % (ns, versionId) + return namespace + +## Get version from the version uri +def GetVersionFromVersionUri(version): + return versionMap[version.rsplit(":", 1)[-1]] + +## Get wsdl namespace from version +def GetWsdlNamespace(version): + """ Get wsdl namespace from version """ + return "urn:" + serviceNsMap[version] + +## Get all the versions for the service with specified namespace (partially) ordered +## by compatibility (i.e. any version in the list that is compatible with some version +## v in the list will preceed v) +# @param namespace XML namespace identifying a service +# @return returns all the versions for the service with specified namespace (partially) +# ordered by compatibility +# +# NOTE: For this function, we use 'namespace' as a representation of 'service'. While +# this works for most services, for compatibility reasons, the core and query +# services share the 'vim25' namespace with the vim service. Fortunately, this +# shouldn't be an issue in practice, as the implementations of the vim +# service (vpxd and hostd) don't currently advertise that they support any +# versions of the core or query services, and we don't expect that they ever will. +# This function assumes that all other namespaces identify a unique service. +def GetServiceVersions(namespace): + """ + Get all the versions for the service with specified namespace (partially) ordered + by compatibility (i.e. any version in the list that is compatible with some version + v in the list will preceed v) + """ + versions = dict((v, True) for (v, n) in serviceNsMap.iteritems() if n == namespace) + mappings = {} + for v in versions.iterkeys(): + mappings[v] = set(parent for parent in parentMap[v].iterkeys() + if parent != v and versions.has_key(parent)) + res = [] + while True: + el = [ k for (k, v) in mappings.iteritems() if len(v) == 0 ] + if len(el) == 0: + return res + el.sort() + for k in el: + res.insert(0, k) + del mappings[k] + for values in mappings.itervalues(): + values.discard(k) + + +## Set a WSDL method with wsdl namespace and wsdl name +# Internal to VmomiSupport +# Note: Must be holding the _lazyLock +# +# @param ns XML namespace +# @param wsdlName wsdl name +# @param inputMM managed method object or info to load it (it points to +# list object that points to the type info which holds +# this managed method's information) +# @return returns added method or exising method if (ns, wsdlName) +# is already in the map. It throws a runtime error if +# trying to set two type info list's to the same (ns, wsdlName) +def _SetWsdlMethod(ns, wsdlName, inputMM): + """ + Set a WSDL method with wsdl namespace and wsdl name + Returns added method / existing method if (ns, wsdlName) already in the map + + Note: Must be holding the _lazyLock + """ + _wsdlMethodNSs.add(ns) + curMM = _wsdlMethodMap.get( (ns, wsdlName) ) + # if inputMM is a list + if isinstance(inputMM, list): + if curMM is None: + _wsdlMethodMap[(ns, wsdlName)] = inputMM + return inputMM + elif isinstance(curMM, list): + raise RuntimeError( + "Duplicate wsdl method %s %s (new class %s vs existing %s)" % \ + (ns, wsdlName, inputMM[0], curMM[0])) + else: + return curMM + # if inputMM is a ManagedMethod + else: + if curMM is None or isinstance(curMM, list): + _wsdlMethodMap[(ns, wsdlName)] = inputMM + return inputMM + else: + return curMM + +## Get wsdl method from ns, wsdlName +# @param ns XML namespace +# @param wsdlName wsdl name +# @return managed method object or throws a KeyError +def GetWsdlMethod(ns, wsdlName): + """ Get wsdl method from ns, wsdlName """ + with _lazyLock: + method = _wsdlMethodMap[(ns, wsdlName)] + if isinstance(method, ManagedMethod): + # The type corresponding to the method is loaded, + # just return the method object + return method + elif method: + # The type is not loaded, the map contains the info + # to load the type. Load the actual type and + # return the method object + LoadManagedType(*method) + return _wsdlMethodMap[(ns, wsdlName)] + else: + raise KeyError("%s %s" % (ns, name)) + +## Guess the method from wsdlname with no ns +# WARNING! This should not be used in general, as there is no guarantee for +# the correctness of the guessing method +# @param name wsdl name +# @return managed method object if found in any namespace else throws +# KeyError +def GuessWsdlMethod(name): + with _lazyLock: + for ns in _wsdlMethodNSs: + try: + return GetWsdlMethod(ns, name) + except KeyError: + pass + raise KeyError(name) + +## Widen a type to one supported in a given version +def GetCompatibleType(type, version): + # Type can be widened if it has the attribute "_version" (which implies it + # is either a DataObject or ManagedObject) + if hasattr(type, "_version"): + while not IsChildVersion(version, type._version): + type = type.__bases__[0] + return type + +## Invert an injective mapping +def InverseMap(map): + return dict([ (v, k) for (k, v) in map.iteritems() ]) + +types = Object() +nsMap = {} +versionIdMap = {} +versionMap = {} +serviceNsMap = { BASE_VERSION : XMLNS_VMODL_BASE.split(":")[-1] } +parentMap = {} + +from Version import AddVersion, IsChildVersion + +if not isinstance(bool, type): # bool not a type in python <= 2.2 + bool = type("bool", (int,), + {"__new__": lambda cls, val=0: int.__new__(cls, val and 1 or 0)}) +byte = type("byte", (int,), {}) +short = type("short", (int,), {}) +double = type("double", (float,), {}) +URI = type("URI", (str,), {}) +binary = type("binary", (str,), {}) +PropertyPath = type("PropertyPath", (unicode,), {}) + +# _wsdlTypeMapNSs store namespaces added to _wsdlTypeMap in _SetWsdlType +_wsdlTypeMapNSs = set() +_wsdlTypeMap = { + # Note: xsd has no void type. This is a hack from before. Can be removed? + (XMLNS_XSD, 'void') : NoneType, + (XMLNS_XSD, 'anyType') : object, + (XMLNS_XSD, 'boolean') : bool, + (XMLNS_XSD, 'byte') : byte, + (XMLNS_XSD, 'short') : short, + (XMLNS_XSD, 'int') : int, + (XMLNS_XSD, 'long') : long, + (XMLNS_XSD, 'float') : float, + (XMLNS_XSD, 'double') : double, + (XMLNS_XSD, 'string') : str, + (XMLNS_XSD, 'anyURI') : URI, + (XMLNS_XSD, 'base64Binary') : binary, + (XMLNS_XSD, 'dateTime') : datetime, + (XMLNS_XSD, 'Link') : Link, + (XMLNS_VMODL_BASE, 'TypeName') : type, + (XMLNS_VMODL_BASE, 'MethodName') : ManagedMethod, + (XMLNS_VMODL_BASE, 'PropertyPath') : PropertyPath +} +_wsdlNameMap = InverseMap(_wsdlTypeMap) + +for ((ns, name), typ) in _wsdlTypeMap.items(): + if typ is not NoneType: + setattr(types, typ.__name__, typ) + _wsdlTypeMapNSs.add(ns) + arrayType = CreateArrayType(typ) + setattr(types, Capitalize(typ.__name__) + "Array", arrayType) + arrayName = "ArrayOf" + Capitalize(name) + arrayNS = XMLNS_VMODL_BASE + _SetWsdlType(arrayNS, arrayName, arrayType) + _wsdlNameMap[arrayType] = (arrayNS, arrayName) +del name, typ + +# unicode is mapped to wsdl name 'string' (Cannot put in wsdlTypeMap or name +# collision with non-unicode string) +_wsdlNameMap[unicode] = (XMLNS_XSD, 'string') +_wsdlNameMap[CreateArrayType(unicode)] = (XMLNS_VMODL_BASE, 'ArrayOfString') + +# _wsdlMethodNSs store namespaces added to _wsdlMethodMap in _SetWsdlMethod +_wsdlMethodNSs = set() +_wsdlMethodMap = {} + +# Registering the classes defined in VmomiSupport in the definition maps +CreateManagedType(ManagedObject.__name__, ManagedObject._wsdlName, None, + ManagedObject._version, [], []) +_AddType(ManagedObject) +setattr(types, ManagedObject.__name__, ManagedObject) + +CreateDataType(DataObject.__name__, DataObject._wsdlName, None, + DataObject._version, []) +_AddType(DataObject) +setattr(types, DataObject.__name__, DataObject) + +## Vmodl types +vmodlTypes = { + # Note: xsd has no void type. This is a hack from before. Can be removed? + "void" : GetWsdlType(XMLNS_XSD, 'void'), + "anyType": GetWsdlType(XMLNS_XSD, 'anyType'), + "string" : GetWsdlType(XMLNS_XSD, 'string'), + "bool" : GetWsdlType(XMLNS_XSD, 'boolean'), + "boolean": GetWsdlType(XMLNS_XSD, 'boolean'), + "byte" : GetWsdlType(XMLNS_XSD, 'byte'), + "short" : GetWsdlType(XMLNS_XSD, 'short'), + "int" : GetWsdlType(XMLNS_XSD, 'int'), + "long" : GetWsdlType(XMLNS_XSD, 'long'), + "float" : GetWsdlType(XMLNS_XSD, 'float'), + "double" : GetWsdlType(XMLNS_XSD, 'double'), + "Link" : GetWsdlType(XMLNS_XSD, 'Link'), + "vmodl.URI" : GetWsdlType(XMLNS_XSD, 'anyURI'), + "vmodl.Binary" : GetWsdlType(XMLNS_XSD, 'base64Binary'), + "vmodl.DateTime" : GetWsdlType(XMLNS_XSD, 'dateTime'), + "vmodl.TypeName" : GetWsdlType(XMLNS_VMODL_BASE, 'TypeName'), + "vmodl.MethodName" : GetWsdlType(XMLNS_VMODL_BASE, 'MethodName'), + "vmodl.DataObject" : GetWsdlType(XMLNS_VMODL_BASE, 'DataObject'), + "vmodl.ManagedObject" : GetWsdlType(XMLNS_VMODL_BASE, 'ManagedObject'), + "vmodl.PropertyPath" : GetWsdlType(XMLNS_VMODL_BASE, 'PropertyPath'), +} +vmodlNames = {} + +## Add array type into special names +for name, typ in vmodlTypes.copy().iteritems(): + if typ is not NoneType: + try: + arrayType = typ.Array + except AttributeError: + wsdlName = GetWsdlName(typ) + arrayNS = XMLNS_VMODL_BASE + arrayType = GetWsdlType(arrayNS, "ArrayOf" + Capitalize(wsdlName)) + arrayName = name + "[]" + vmodlTypes[arrayName] = arrayType + + # Set type to vmodl name map + vmodlNames[typ] = name + vmodlNames[arrayType] = arrayName +del name, typ + + +## Get type from vmodl name +# +# @param name vmodl name +# @return vmodl type +def GetVmodlType(name): + """ Get type from vmodl name """ + + # If the input is already a type, just return + if isinstance(name, type): + return name + + # Try to get type from vmodl type names table + typ = vmodlTypes.get(name) + if typ: + return typ + + # Else get the type from the _wsdlTypeMap + isArray = name.endswith("[]") + if isArray: + name = name[:-2] + ns, wsdlName = _GetWsdlInfo(name) + try: + typ = GetWsdlType(ns, wsdlName) + except KeyError: + raise KeyError(name) + if typ: + return isArray and typ.Array or typ + else: + raise KeyError(name) + +## Get VMODL type name from type +# +# @param typ vmodl type +# @return vmodl name +def GetVmodlName(typ): + """ Get vmodl type name from type """ + try: + return vmodlNames[typ] + except KeyError: + return typ.__name__ + +## Get Wsdl type name from Python type name +# +# @param pythonTypeName Python type name +# @return wsdl type name +def GetWsdlTypeName(pythonTypeName): + try: + typ = GetVmodlType(pythonTypeName) + except KeyError: + raise NameError('No type found with name ' + pythonTypeName) + return GetWsdlName(typ) + +## Get Wsdl method name from Python method name +# +# @param pythonTypeName Python type name +# @param pythonMethodName Python method name +# @return wsdl method name +def GetWsdlMethodName(pythonTypeName, pythonMethodName): + try: + typ = GetVmodlType(pythonTypeName) + _, _, _, _, _, methods = _wsdlDefMap[GetQualifiedWsdlName(typ)] + except KeyError: + raise NameError('No type found with name ' + pythonTypeName) + uncapPythonMethodName = Uncapitalize(pythonMethodName) + for method in methods: + mVmodl, mWsdl, _, _, _, _, _ = method + if mVmodl == uncapPythonMethodName or mVmodl == pythonMethodName: + return mWsdl + raise NameError('No method found with name ' + pythonMethodName) + +## Get Python type name from Wsdl type name +# +# @param ns wsdl namespace +# @param wsdlTypeName wsdl type name +# @return python type name +def GetPythonTypeName(wsdlTypeName, ns): + try: + typ = GetWsdlType(ns, wsdlTypeName) + except KeyError: + raise NameError('No type found with namespace %s and name %s' % (ns, wsdlTypeName)) + return GetVmodlName(typ) + +## Get Python method name from Wsdl method name +# +# @param ns wsdl namespace +# @param wsdlTypeName wsdl type name +# @param wsdlMethodName wsdl method name +# @return python method name +def GetPythonMethodName(wsdlTypeName, ns, wsdlMethodName): + try: + _, _, _, _, _, methods = _wsdlDefMap[(ns, wsdlTypeName)] + except KeyError: + raise NameError('No type found with namespace %s and name %s' % (ns, wsdlTypeName)) + for method in methods: + mVmodl, mWsdl, _, _, _, _, _ = method + if mWsdl == wsdlMethodName: + return Capitalize(mVmodl) + raise NameError('No method found with name ' + wsdlMethodName) + +## String only dictionary: same as dict, except it only accept string as value +# +class StringDict(dict): + """ + String only dictionary: same as dict, except it only accept string as value + + dict in python is kind of strange. U cannot just override __setitem__, as + __init__, update, and setdefault all bypass __setitem__. When override, + we have to override all three together + """ + def __init__(self, *args, **kwargs): + dict.__init__(self) + self.update(*args, **kwargs) + + # Same as dict setdefault, except this will call through our __setitem__ + def update(self, *args, **kwargs): + for k, v in dict(*args, **kwargs).iteritems(): + self[k] = v + + # Same as dict setdefault, except this will call through our __setitem__ + def setdefault(self, key, val=None): + if key in self: + return self[key] + else: + self[key] = val + return val + + def __setitem__(self, key, val): + """x.__setitem__(i, y) <==> x[i]=y, where y must be a string""" + if not isinstance(val, basestring): + raise TypeError("key %s has non-string value %s of %s" % + (key, val, type(val))) + return dict.__setitem__(self, key, val) + +## Retrieves the actual vmodl name from type dictionaries +# +# Note: Must be holding the _lazyLock +# @param name upcapitalized vmodl name +# @return vmodl name +def _GetActualName(name): + """ Note: Must be holding the _lazyLock """ + if _allowCapitalizedNames: + name = UncapitalizeVmodlName(name) + for defMap in _dataDefMap, _managedDefMap, _enumDefMap: + dic = defMap.get(name) + if dic: + return dic[0] + return None + +## Retrieves the actual wsdl name from type dictionaries +# +# @param name upcapitalized vmodl name +# @return (wsdl namespace, wsdl name) +def _GetWsdlInfo(name): + if _allowCapitalizedNames: + name = UncapitalizeVmodlName(name) + + with _lazyLock: + # For data and managed objects, emitter puts version in field #3 and in + # enum objects, it is in field #2. So, have to handle them differently + for defMap in _dataDefMap, _managedDefMap: + dic = defMap.get(name) + if dic: + return GetWsdlNamespace(dic[3]), dic[1] + + dic = _enumDefMap.get(name) + if dic: + return GetWsdlNamespace(dic[2]), dic[1] + return None, None + +## Checks if the definition exists for a vmodl name +# +# @param name vmodl name +# @return True if name exists, False otherwise +def TypeDefExists(name): + # Check if is one of the primitive types + typ = vmodlTypes.get(name) + if typ: + return True + + # Check if it's type definition is loaded in the dictionaries + if name.endswith("[]"): + name = name[:-2] + + with _lazyLock: + actualName = _GetActualName(name) + return actualName is not None + +# Thread local for req context +_threadLocalContext = threading.local() + +# Get the RequestContext for the current thread +# +def GetRequestContext(): + """ Get the RequestContext for the current thread """ + global _threadLocalContext + return _threadLocalContext.__dict__.setdefault('reqCtx', StringDict()) + +# Get the Http context for the current thread +# +def GetHttpContext(): + """ Get the Http context for the current thread """ + global _threadLocalContext + return _threadLocalContext.__dict__.setdefault('httpCtx', dict()) + +## Class that resolves links +class LinkResolver: + ## Constructor + # + # @param self self + # @param scope DataObject to be used against for resolving links + def __init__(self, scope): + self.linkables = {} + self._VisitDataObject(scope) + + ## Visit a DataObject and add it to linkable if it is one. Also + # visit its properties that are DataObjects + # + # @param self self + # @param obj DataObject to be visited + def _VisitDataObject(self, obj): + if isinstance(obj, DataObject): + for prop in obj._GetPropertyList(): + if issubclass(prop.type, list): + for dataObj in getattr(obj, prop.name): + if (prop.flags & F_LINKABLE): + self._AddLinkable(dataObj) + self._VisitDataObject(dataObj) + else: + dataObj = getattr(obj, prop.name) + if (prop.flags & F_LINKABLE): + self._AddLinkable(dataObj) + self._VisitDataObject(dataObj) + elif isinstance(obj, list): + for dataObj in obj: + self._VisitDataObject(dataObj) + + ## Adds a DataObject to linkable dictionary using its key + # + # @param self self + # @param obj DataObject to be added to linkable + def _AddLinkable(self, obj): + key = getattr(obj, "key") + if key and key != '': + if self.linkables.has_key(key): + #duplicate key present + raise AttributeError(key) + else: + self.linkables[key] = obj + else: + #empty key + raise AttributeError(key) + + ## Resolves a key by looking up linkable dictionary + # + # @param self self + # @param key Key to be resolved + def ResolveLink(self, key): + val = self.linkables[key] + return val + + ## Resolves a list of keys by resolving each key + # + # @param self self + # @param keys keys to be resolved + def ResolveLinks(self, keys): + val = [self.linkables[k] for k in keys] + return val + +## Resolves a link key using the object provided as its scope by creating a +# link resolver object +# +# @param key Key to be resolved +# @param obj DataObject to be used against for resolving links +def ResolveLink(key, obj): + if obj is None: + return None + linkResolver = LinkResolver(obj) + return linkResolver.ResolveLink(key) + +## Resolves a list of link keys using the object provided as its scope by creating a +# link resolver object +# +# @param keys keys to be resolved +# @param obj DataObject to be used against for resolving links +def ResolveLinks(keys, obj): + if obj is None: + return None + linkResolver = LinkResolver(obj) + return linkResolver.ResolveLinks(keys) diff --git a/pyVmomi/__init__.py b/pyVmomi/__init__.py new file mode 100644 index 0000000..b265718 --- /dev/null +++ b/pyVmomi/__init__.py @@ -0,0 +1,227 @@ +# VMware vSphere Python SDK +# Copyright (c) 2008-2013 VMware, Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +# In VmomiSupport, to support dynamic type loading, all the data types are +# wrapped around using a meta type which can intercept attribute access and +# load the necessary nested classes. This can be implemented only in python 2.5 +# version or more. +import sys +if sys.version_info < (2,5): + sys.stderr.write("You need Python 2.5 or later to import pyVmomi module\n") + sys.exit(1) + +import VmomiSupport +import CoreTypes +try: + import ReflectTypes +except ImportError: + pass +try: + import ServerObjects +except ImportError: + pass +try: + import InternalServerObjects +except ImportError: + pass + +# Import all the known product-specific types +# XXX: Make this search the package for types? +try: + import DrObjects +except ImportError: + pass + +try: + import DrextObjects +except ImportError: + pass + +try: + import HbrReplicaTypes +except ImportError: + pass +try: + import HmsObjects +except ImportError: + pass +try: + import HostdObjects +except ImportError: + pass +try: + import VpxObjects +except ImportError: + pass +try: + import VorbTypes +except ImportError: + pass +try: + import DodoTypes +except ImportError: + pass +try: + import VmwauthproxyTypes +except ImportError: + pass +try: + import DmsTypes +except ImportError: + pass +try: + import OmsTypes +except ImportError: + pass +try: + import HmoTypes +except ImportError: + pass +try: + import CimsfccTypes +except ImportError: + pass +try: + import TaskupdaterTypes +except ImportError: + pass +try: + import ImgFactTypes +except ImportError: + pass + +try: + import VpxapiTypes +except ImportError: + pass +try: + import CsiObjects +except ImportError: + pass + +try: + import HostdTypes +except ImportError: + pass + +try: + import TaggingObjects +except ImportError: + pass + +try: + import NfcTypes +except ImportError: + pass + +try: + import SmsObjects +except ImportError: + pass + +try: + import SpsObjects +except ImportError: + pass + +try: + import DataserviceObjects +except ImportError: + pass + +# Start of update manager specific types +try: + import IntegrityObjects +except ImportError: + pass + +try: + import SysimageObjects +except ImportError: + pass +# End of update manager specific types + +try: + import RbdTypes +except ImportError: + pass + +# Import Profile based management specific VMODL +try: + import PbmObjects +except ImportError: + pass + +try: + import CisLicenseTypes +except ImportError: + pass + +try: + import TestTypes +except ImportError: + pass + +try: + import SsoTypes +except ImportError: + pass + +try: + import CisCmTypes +except ImportError: + pass + +try: + import DataserviceTypes +except ImportError: + pass + + +# All data object types and fault types have DynamicData as an ancestor +# As well load it proactively. +# Note: This should be done before importing SoapAdapter as it uses +# some fault types +VmomiSupport.GetVmodlType("vmodl.DynamicData") + +from SoapAdapter import SoapStubAdapter, StubAdapterBase, SoapCmdStubAdapter, \ + SessionOrientedStub + +types = VmomiSupport.types + +# This will allow files to use Create** functions +# directly from pyVmomi +CreateEnumType = VmomiSupport.CreateEnumType +CreateDataType = VmomiSupport.CreateDataType +CreateManagedType = VmomiSupport.CreateManagedType + +# For all the top level names, creating a LazyModule object +# in the global namespace of pyVmomi. Files can just import the +# top level namespace and we will figure out what to load and when +# Examples: +# ALLOWED: from pyVmomi import vim +# NOT ALLOWED: from pyVmomi import vim.host +_globals = globals() +for name in VmomiSupport._topLevelNames: + upperCaseName = VmomiSupport.Capitalize(name) + obj = VmomiSupport.LazyModule(name) + _globals[name] = obj + if VmomiSupport._allowCapitalizedNames: + _globals[upperCaseName] = obj + if not hasattr(VmomiSupport.types, name): + setattr(VmomiSupport.types, name, obj) + if VmomiSupport._allowCapitalizedNames: + setattr(VmomiSupport.types, upperCaseName, obj) +del _globals diff --git a/pyVmomi/pyVmomiSettings.py b/pyVmomi/pyVmomiSettings.py new file mode 100644 index 0000000..281f3df --- /dev/null +++ b/pyVmomi/pyVmomiSettings.py @@ -0,0 +1,17 @@ +# VMware vSphere Python SDK +# Copyright (c) 2008-2013 VMware, Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +allowGetSet = False +allowCapitalizedNames = False diff --git a/pyvmomi.egg-info/.gitignore b/pyvmomi.egg-info/.gitignore new file mode 100644 index 0000000..8ec4d33 --- /dev/null +++ b/pyvmomi.egg-info/.gitignore @@ -0,0 +1,4 @@ +PKG-INFO +sources.txt +dependency_links.txt +zip-safe diff --git a/pyvmomi.egg-info/top_level.txt b/pyvmomi.egg-info/top_level.txt new file mode 100644 index 0000000..8aa2816 --- /dev/null +++ b/pyvmomi.egg-info/top_level.txt @@ -0,0 +1,2 @@ +pyVim +pyVmomi diff --git a/sample/getallvms.py b/sample/getallvms.py new file mode 100644 index 0000000..3d19b5b --- /dev/null +++ b/sample/getallvms.py @@ -0,0 +1,110 @@ +#!/usr/bin/python +# VMware vSphere Python SDK +# Copyright (c) 2008-2013 VMware, Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +Python program for listing the vms on an ESX / vCenter host +""" + +from optparse import OptionParser, make_option +from pyVim.connect import SmartConnect, Disconnect +from pyVmomi import vmodl +import sys +import atexit + +def GetOptions(): + """ + Supports the command-line arguments listed below. + """ + + _CMD_OPTIONS_LIST = [ + make_option("-h", "--host", + help="remote host to connect to"), + make_option("-o", "--port", + default=443, + help="Port"), + make_option("-u", "--user", + default="root", + help="User name to use when connecting to host"), + make_option("-p", "--password", + help="Password to use when connecting to host"), + make_option("-?", "--help", action="store_true", + help="Help"), + ] + _STR_USAGE = "%prog [options]" + + parser = OptionParser(option_list=_CMD_OPTIONS_LIST, + usage=_STR_USAGE, + add_help_option=False) + (options, _) = parser.parse_args() + + return options + +def PrintVmInfo(vm): + """ + Print information for a particular virtual machine. + """ + + summary = vm.summary + print "Name : ", summary.config.name + print "Path : ", summary.config.vmPathName + print "Guest : ", summary.config.guestFullName + annotation = summary.config.annotation + if annotation != None and annotation != "": + print "Annotation : ", annotation + print "State : ", summary.runtime.powerState + if summary.guest != None: + ip = summary.guest.ipAddress + if ip != None and ip != "": + print "IP : ", ip + if summary.runtime.question != None: + print "Question : ", summary.runtime.question.text + print "" + +def main(): + """ + Simple command-line program for listing the virtual machines on a system. + """ + + options = GetOptions() + try: + si = SmartConnect(host=options.host, + user=options.user, + pwd=options.password, + port=int(options.port)) + if not si: + print "Could not connect to the specified host" + return -1 + + atexit.register(Disconnect, si) + + content = si.RetrieveContent() + datacenter = content.rootFolder.childEntity[0] + vmFolder = datacenter.vmFolder + vmList = vmFolder.childEntity + for vm in vmList: + PrintVmInfo(vm) + except vmodl.MethodFault, e: + print "Caught vmodl fault : " + e.msg + return -1 + except Exception, e: + print "Caught exception : " + str(e) + return -1 + + return 0 + +# Start program +if __name__ == "__main__": + main() diff --git a/sample/poweronvm.py b/sample/poweronvm.py new file mode 100755 index 0000000..854b653 --- /dev/null +++ b/sample/poweronvm.py @@ -0,0 +1,154 @@ +#!/usr/bin/python +# +# VMware vSphere Python SDK +# Copyright (c) 2008-2013 VMware, Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +""" +Python program for powering on vms on a host on which hostd is running +""" + +from optparse import OptionParser, make_option +from pyVim.connect import SmartConnect, Disconnect +from pyVmomi import vim, vmodl +import sys +import atexit + +def GetOptions(): + """ + Supports the command-line arguments listed below. + """ + + _CMD_OPTIONS_LIST = [ + make_option("-h", "--host", + help="remote host to connect to"), + make_option("-o", "--port", + default=443, + help="Port"), + make_option("-u", "--user", + default="root", + help="User name to use when connecting to host"), + make_option("-p", "--password", + help="Password to use when connecting to host"), + make_option("-v", "--vmname", default=[], action="append", + help="Name of the Virtual Machine to power on"), + make_option("-?", "--help", action="store_true", + help="Help"), + ] + _STR_USAGE = "%prog [options]" + + parser = OptionParser(option_list=_CMD_OPTIONS_LIST, + usage=_STR_USAGE, + add_help_option=False) + (options, _) = parser.parse_args() + return options + +def WaitForTasks(tasks, si): + """ + Given the service instance si and tasks, it returns after all the + tasks are complete + """ + + pc = si.content.propertyCollector + + taskList = [str(task) for task in tasks] + + # Create filter + objSpecs = [vmodl.query.PropertyCollector.ObjectSpec(obj=task) + for task in tasks] + propSpec = vmodl.query.PropertyCollector.PropertySpec(type=vim.Task, + pathSet=[], all=True) + filterSpec = vmodl.query.PropertyCollector.FilterSpec() + filterSpec.objectSet = objSpecs + filterSpec.propSet = [propSpec] + filter = pc.CreateFilter(filterSpec, True) + + try: + version, state = None, None + + # Loop looking for updates till the state moves to a completed state. + while len(taskList): + update = pc.WaitForUpdates(version) + for filterSet in update.filterSet: + for objSet in filterSet.objectSet: + task = objSet.obj + for change in objSet.changeSet: + if change.name == 'info': + state = change.val.state + elif change.name == 'info.state': + state = change.val + else: + continue + + if not str(task) in taskList: + continue + + if state == vim.TaskInfo.State.success: + # Remove task from taskList + taskList.remove(str(task)) + elif state == vim.TaskInfo.State.error: + raise task.info.error + # Move to next version + version = update.version + finally: + if filter: + filter.Destroy() + +# Start program +def main(): + """ + Simple command-line program for powering on virtual machines on a system. + """ + + options = GetOptions() + try: + vmnames = options.vmname + if not len(vmnames): + print "No virtual machine specified for poweron" + sys.exit() + + si = SmartConnect(host=options.host, + user=options.user, + pwd=options.password, + port=int(options.port)) + if not si: + print "Cannot connect to Host" + sys.exit() + + atexit.register(Disconnect, si) + + # Retreive the list of Virtual Machines from the invetory objects + # under the rootFolder + content = si.content + objView = content.viewManager.CreateContainerView(content.rootFolder, + [vim.VirtualMachine], + True) + vmList = objView.view + objView.Destroy() + + # Find the vm and power it on + tasks = [vm.PowerOn() for vm in vmList if vm.name in vmnames] + + # Wait for power on to complete + WaitForTasks(tasks, si) + + print "Virtual Machine(s) have been powered on successfully" + except vmodl.MethodFault, e: + print "Caught vmodl fault : " + e.msg + except Exception, e: + print "Caught Exception : " + str(e) + +# Start program +if __name__ == "__main__": + main() diff --git a/setup.py b/setup.py new file mode 100644 index 0000000..cf609bf --- /dev/null +++ b/setup.py @@ -0,0 +1,42 @@ +# VMware vSphere Python SDK +# Copyright (c) 2009-2013 VMware, Inc. All Rights Reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from setuptools import setup +import os + +def read(fname): + return open(os.path.join(os.path.dirname(__file__), fname)).read() + +setup( + name='pyvmomi', + version='5.1.0', + description='VMware vSphere Python SDK', + author='VMware, Inc.', + author_email='jhu@vmware.com', + url='https://github.com/vmware/pyvmomi', + packages=['pyVmomi', 'pyVim'], + license='Apache', + long_description=read('README.md'), + classifiers=[ + "License :: OSI Approved :: Apache Software License", + "Development Status :: 4 - Beta", + "Environment :: No Input/Output (Daemon)", + "Intended Audience :: Information Technology", + "Intended Audience :: System Administrators", + "Topic :: Software Development :: Libraries :: Python Modules", + "Topic :: System :: Distributed Computing" + ], + zip_safe=True +)