pyVmomi reStructured Text Documentation

This external documentation for pyVmomi was generated using Googly Docs
(aka Google Standard Documentation) which renders very cleanly in
GitHub. Internal documentation for a class should be done in Sphinx
format because tools like pyCharm and Eclipse can use that documentation
as a hint for code completion.

Note: External docs as Googly Docs, internal docs as Sphinx.

Closes bug#15

docs/vim/AboutInfo.rst

@@ -0,0 +1,65 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _vmodl.DynamicData: ../vmodl/DynamicData.rst
+
+
+vim.AboutInfo
+=============
+  This data object type describes system information including the name, type, version, and build number.
+:extends: vmodl.DynamicData_
+
+Attributes:
+    name (`str`_):
+
+       Short form of the product name.
+    fullName (`str`_):
+
+       The complete product name, including the version information.
+    vendor (`str`_):
+
+       Name of the vendor of this product.
+    version (`str`_):
+
+       Dot-separated version string. For example, "1.2".
+    build (`str`_):
+
+       Build string for the server on which this call is made. For example, x.y.z-num. This string does not apply to the API.
+    localeVersion (`str`_, optional):
+
+       Version of the message catalog for the current session's locale.
+    localeBuild (`str`_, optional):
+
+       Build number for the current session's locale. Typically, this is a small number reflecting a localization change from the normal product build.
+    osType (`str`_):
+
+       Operating system type and architecture.Examples of values are:
+        * "win32-x86" - For x86-based Windows systems.
+        * "linux-x86" - For x86-based Linux systems.
+        * "vmnix-x86" - For the x86 ESX Server microkernel.
+        * 
+    productLineId (`str`_):
+
+       The product ID is a unique identifier for a product line.Examples of values are:
+        * "gsx" - For the VMware Server product.
+        * "esx" - For the ESX product.
+        * "embeddedEsx" - For the ESXi product.
+        * "vpx" - For the VirtualCenter product.
+        * 
+    apiType (`str`_):
+
+       Indicates whether or not the service instance represents a standalone host. If the service instance represents a standalone host, then the physical inventory for that service instance is fixed to that single host. VirtualCenter server provides additional features over single hosts. For example, VirtualCenter offers multi-host management.Examples of values are:
+        * "VirtualCenter" - For a VirtualCenter instance.
+        * "HostAgent" - For host agent on an ESX Server or VMware Server host.
+        * 
+    apiVersion (`str`_):
+
+       The version of the API as a dot-separated string. For example, "1.0.0".
+    instanceUuid (`str`_, optional):
+
+       A globally unique identifier associated with this service instance.
+    licenseProductName (`str`_, optional):
+
+       The license product name
+    licenseProductVersion (`str`_, optional):
+
+       The license product version

docs/vim/AuthorizationDescription.rst

@@ -0,0 +1,17 @@
+.. _vmodl.DynamicData: ../vmodl/DynamicData.rst
+
+.. _vim.ElementDescription: ../vim/ElementDescription.rst
+
+
+vim.AuthorizationDescription
+============================
+  Static strings for authorization.
+:extends: vmodl.DynamicData_
+
+Attributes:
+    privilege (`vim.ElementDescription`_):
+
+       Description of the privilege.
+    privilegeGroup (`vim.ElementDescription`_):
+
+       Description of a category of similar privileges, grouped together for convenience.

docs/vim/AuthorizationManager.rst

@@ -0,0 +1,500 @@
+.. _int: https://docs.python.org/2/library/stdtypes.html
+
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _vim.Task: ../vim/Task.rst
+
+.. _effectiveRole: ../vim/ManagedEntity.rst#effectiveRole
+
+.. _vSphere API 5.5: ../vim/version.rst#vimversionversion9
+
+.. _vSphere API 5.0: ../vim/version.rst#vimversionversion7
+
+.. _vim.ManagedEntity: ../vim/ManagedEntity.rst
+
+.. _vim.fault.NotFound: ../vim/fault/NotFound.rst
+
+.. _vim.fault.InvalidName: ../vim/fault/InvalidName.rst
+
+.. _vim.fault.UserNotFound: ../vim/fault/UserNotFound.rst
+
+.. _vim.fault.RemoveFailed: ../vim/fault/RemoveFailed.rst
+
+.. _vim.fault.NoPermission: ../vim/fault/NoPermission.rst
+
+.. _vim.fault.AlreadyExists: ../vim/fault/AlreadyExists.rst
+
+.. _vmodl.fault.InvalidArgument: ../vmodl/fault/InvalidArgument.rst
+
+.. _vim.AuthorizationDescription: ../vim/AuthorizationDescription.rst
+
+.. _vim.AuthorizationManager.Role: ../vim/AuthorizationManager/Role.rst
+
+.. _vmodl.fault.ManagedObjectNotFound: ../vmodl/fault/ManagedObjectNotFound.rst
+
+.. _vim.AuthorizationManager.Privilege: ../vim/AuthorizationManager/Privilege.rst
+
+.. _vim.AuthorizationManager.Permission: ../vim/AuthorizationManager/Permission.rst
+
+.. _vim.fault.AuthMinimumAdminPermission: ../vim/fault/AuthMinimumAdminPermission.rst
+
+.. _vim.AuthorizationManager.EntityPrivilege: ../vim/AuthorizationManager/EntityPrivilege.rst
+
+
+vim.AuthorizationManager
+========================
+  This managed object provides operations to query and update roles and permissions.Privilegesare the basic individual rights required to perform operations. They are statically defined and never change for a single version of a product. Examples of privileges arePower on a virtual machineorConfigure a host.Rolesare aggregations of privileges, used for convenience. For user-defined roles, the system-defined privileges, "System.Anonymous", "System.View", and "System.Read" are always present.Permissionsare the actual access-control rules. A permission is defined on a ManagedEntity and specifies the user or group (principal) to which the rule applies. The role specifies the privileges to apply, and the propagate flag specifies whether or not the rule applies to sub-objects of the managed entity.A ManagedEntity may have multiple permissions, but may have only one permission per user or group. If, when logging in, a user has both a user permission and a group permission (as a group member) for the same entity, then the user-specific permission takes precedent. If there is no user-specific permission, but two or more group permissions are present, and the user is a member of the groups, then the privileges are the union of the specified roles.Managed entities may be collected together into acomplex entityfor the purpose of applying permissions consistently. Complex entities may have a Datacenter, ComputeResource, or ClusterComputeResource as a parent, with other child managed objects as additional parts of the complex entity:
+   * A Datacenter's child objects are the root virtual machine and host Folders.
+   * A ComputeResource's child objects are the root ResourcePool and HostSystem.
+   * A ClusterComputeResource has only the root ResourcePool as a child object.
+   * Child objects in a complex entity are forced to inherit permissions from the parent object. When query operations are used to discover permissions on child objects of complex entities, different results may be returned for the owner of the permission. In some cases, the child object of the complex entity is returned as the object that defines the permission, and in other cases, the parent from which the permission is propagated is returned as the object that defines the permission. In both cases, the information about the owner of the permission is correct, since the entities within a complex entity are considered equivalent. Permissions defined on complex entities are always applicable on the child entities, regardless of the propagation flag, but may only be defined or modified on the parent object.
+   * In a group of fault-tolerance (FT) protected VirtualMachines, the secondary VirtualMachines are forced to inherit permissions from the primary VirtualMachine. Queries to discover permissions on FT secondary VMs always return the primary VM as the object that defines the permissions. Permissions defined on an FT primary VM are always applicable on its secondary VMs, but can only be defined or modified on the primary VM.
+
+
+
+
+Attributes
+----------
+    privilegeList (`vim.AuthorizationManager.Privilege`_):
+      privilege: System.View
+       The list of system-defined privileges.
+    roleList (`vim.AuthorizationManager.Role`_):
+      privilege: System.View
+       The currently defined roles in the system, including static system-defined roles.
+    description (`vim.AuthorizationDescription`_):
+      privilege: System.View
+       Static, descriptive strings for system roles and privileges.
+
+
+Methods
+-------
+
+
+AddAuthorizationRole(name, privIds):
+   Adds a new role. This method will add a user-defined role with given list of privileges and three system-defined privileges, "System.Anonymous", "System.View", and "System.Read".
+
+
+  Privilege:
+               Authorization.ModifyRoles
+
+
+
+  Args:
+    name (`str`_):
+       Name of the new role.
+
+
+    privIds (`str`_, optional):
+       List of privileges to assign to the role.
+
+
+
+
+  Returns:
+    `int`_:
+         The roleId assigned to the new role.
+
+  Raises:
+
+    `vim.fault.AlreadyExists`_: 
+       if a role with the given name already exists.
+
+    `vim.fault.InvalidName`_: 
+       if the role name is empty.
+
+    `vmodl.fault.InvalidArgument`_: 
+       if privIds contains an unknown privilege.
+
+
+RemoveAuthorizationRole(roleId, failIfUsed):
+   Removes a role.
+
+
+  Privilege:
+               Authorization.ModifyRoles
+
+
+
+  Args:
+    roleId (`int`_):
+
+
+    failIfUsed (`bool`_):
+       If true, prevents the role from being removed if any permissions are using it.
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vim.fault.NotFound`_: 
+       if the role does not exist.
+
+    `vim.fault.RemoveFailed`_: 
+       if failIfUsed is true and the role has permissions.
+
+    `vmodl.fault.InvalidArgument`_: 
+       if the role is a system role, meaning it cannot be changed.
+
+
+UpdateAuthorizationRole(roleId, newName, privIds):
+   Updates a role's name or privileges. If the new set of privileges are assigned to the role, the system-defined privileges, "System.Anonymous", "System.View", and "System.Read" will be assigned to the role too.
+
+
+  Privilege:
+               Authorization.ModifyRoles
+
+
+
+  Args:
+    roleId (`int`_):
+       The ID of the role that is updated.
+
+
+    newName (`str`_):
+       The new name for the role.
+
+
+    privIds (`str`_, optional):
+       The new set of privileges to assign to the role.
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vim.fault.NotFound`_: 
+       if the role does not exist, or if a privilege in the list cannot be found.
+
+    `vim.fault.InvalidName`_: 
+       if the new role name is empty.
+
+    `vim.fault.AlreadyExists`_: 
+       if another role with the given name already exists.
+
+    `vmodl.fault.InvalidArgument`_: 
+       if the role is a system role, meaning it cannot be changed.
+
+    `vim.fault.NoPermission`_: 
+       if current session does not have any privilege that being updated in the new role or "Authorization.ModifyRoles" privilege on the root folder.
+
+
+MergePermissions(srcRoleId, dstRoleId):
+   Reassigns all permissions of a role to another role.
+
+
+  Privilege:
+               Authorization.ReassignRolePermissions
+
+
+
+  Args:
+    srcRoleId (`int`_):
+       The ID of the source role providing the permissions which are changing.
+
+
+    dstRoleId (`int`_):
+       The ID of the destination role to which the permissions are reassigned.
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vim.fault.NotFound`_: 
+       if either the source or destination role does not exist.
+
+    `vim.fault.AuthMinimumAdminPermission`_: 
+       if srcRoleId is the Administrator role, meaning that applying the change would leave the system with no Administrator permission on the root node.
+
+    `vmodl.fault.InvalidArgument`_: 
+       if dstRoleId is the View or Anonymous role or if both role IDs are the same.
+
+    `vim.fault.NoPermission`_: 
+       if current session does not have any privilege in the source or destination role or "Authorization.ReassignRolePermissions" privilege on the root folder.
+
+
+RetrieveRolePermissions(roleId):
+   Finds all the permissions that use a particular role. The result is restricted to managed entities that are visible to the user making the call.
+
+
+  Privilege:
+               System.View
+
+
+
+  Args:
+    roleId (`int`_):
+
+
+
+
+  Returns:
+    `vim.AuthorizationManager.Permission`_:
+         
+
+  Raises:
+
+    `vim.fault.NotFound`_: 
+       if the role does not exist.
+
+
+RetrieveEntityPermissions(entity, inherited):
+   Gets permissions defined on or effective on a managed entity. This returns the actual permission objects defined in the system for all users and groups relative to the managed entity. The inherited flag specifies whether or not to include permissions defined by the parents of this entity that propagate to this entity.For complex entities, the entity reported as defining the permission may be either the parent or a child entity belonging to the complex entity.The purpose of this method is to discover permissions for administration purposes, not to determine the current permissions. The current user's permissions are found on the `effectiveRole`_ property of the user's ManagedEntity.
+
+
+  Privilege:
+
+
+
+  Args:
+    entity (`vim.ManagedEntity`_):
+
+
+    inherited (`bool`_):
+       Whether or not to include propagating permissions defined by parent entities.
+
+
+
+
+  Returns:
+    `vim.AuthorizationManager.Permission`_:
+         
+
+  Raises:
+
+    `vmodl.fault.ManagedObjectNotFound`_: 
+       if the entity does not exist.
+
+
+RetrieveAllPermissions():
+   Finds all permissions defined in the system. The result is restricted to the managed entities visible to the user making the call.
+
+
+  Privilege:
+               System.View
+
+
+
+  Args:
+
+
+  Returns:
+    `vim.AuthorizationManager.Permission`_:
+         
+
+
+SetEntityPermissions(entity, permission):
+   Defines one or more permission rules on an entity or updates rules if already present for the given user or group on the entity.If a permission is specified multiple times for the same user or group, then the last permission specified takes effect.The operation is applied transactionally per permission and is applied to the entity following the order of the elements in the permission array argument. This means that if a failure occurs, the method terminates at that point in the permission array with an exception, leaving at least one and as many as all permissions unapplied.This will fail with an InvalidArgument fault if called on: the direct child folders of a datacenter managed object, the root resource pool of a ComputeResource or ClusterComputeResource, or a HostSystem that is part of a ComputeResource (Stand-alone Host). These objects always have the same permissions as their parent.This will fail with an InvalidArgument fault if called on a fault-tolerance (FT) secondary VirtualMachine. Such a VirtualMachine always has the same permissions as its FT primary VirtualMachine.
+
+
+  Privilege:
+
+
+
+  Args:
+    entity (`vim.ManagedEntity`_):
+       The entity on which to set permissions.
+
+
+    permission (`vim.AuthorizationManager.Permission`_, optional):
+       An array of specifications for permissions on the entity.
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vim.fault.UserNotFound`_: 
+       if a given user or group does not exist.
+
+    `vim.fault.NotFound`_: 
+       if a permission's roleId is not valid.
+
+    `vim.fault.AuthMinimumAdminPermission`_: 
+       if this change would leave the system with no Administrator permission on the root node, or it would grant further permission to a user or group who already has Administrator permission on the root node.
+
+    `vmodl.fault.ManagedObjectNotFound`_: 
+       if the given entity does not exist.
+
+    `vmodl.fault.InvalidArgument`_: 
+       if one of the new role IDs is the View or Anonymous role, or the entity does not support assigning permissions.
+
+    `vim.fault.NoPermission`_: 
+       if current session does not have any privilege in any permission that being set or "Authorization.ModifyPermissions" privilege on the entity.
+
+
+ResetEntityPermissions(entity, permission):
+   Update the entire set of permissions defined on an entity. Any existing permissions on the entity are removed and replaced with the provided set.If a permission is specified multiple times for the same user or group, the last permission specified takes effect.The operation is transactional per permission and could partially fail. The updates are performed in the order of the permission array argument. The first failed update will abort the operation and throw the appropriate exception. When the operation aborts, any permissions that have not yet been removed are left in their original state.After updates are applied, original permissions that are not in the new set are removed. A failure to remove a permission, such as a violation of the minimum administrator permission rule, will abort the operation and could leave remaining original permissions still effective on the entity.This will fail with an InvalidArgument fault if called on: the direct child folders of a datacenter managed object, the root resource pool of a ComputeResource or ClusterComputeResource, or a HostSystem that is part of a ComputeResource (Stand-alone Host). These objects always have the same permissions as their parent.This will fail with an InvalidArgument fault if called on a fault-tolerance (FT) secondary VirtualMachine. Such a VirtualMachine always has the same permissions as its FT primary VirtualMachine.
+
+
+  Privilege:
+
+
+
+  Args:
+    entity (`vim.ManagedEntity`_):
+       The entity on which permissions are updated.
+
+
+    permission (`vim.AuthorizationManager.Permission`_, optional):
+       The list of Permission objects that define the new rules for access to the entity and potentially entities below it. If the list is empty, all permissions on the entity are removed.
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vim.fault.UserNotFound`_: 
+       if one of the given users or groups does not exist.
+
+    `vim.fault.NotFound`_: 
+       if a permission for this entity and user or group does not exist.
+
+    `vim.fault.AuthMinimumAdminPermission`_: 
+       if this change would leave the system with no Administrator permission on the root node, or it would grant further permission to a user or group who already has Administrator permission on the root node.
+
+    `vmodl.fault.ManagedObjectNotFound`_: 
+       if the given entity does not exist.
+
+    `vmodl.fault.InvalidArgument`_: 
+       if one of the new role IDs is the View or Anonymous role, or the entity does not support assigning permissions.
+
+    `vim.fault.NoPermission`_: 
+       if current session does not have any privilege in the updated permission or "Authorization.ModifyPermissions" privilege on the entity.
+
+
+RemoveEntityPermission(entity, user, isGroup):
+   Removes a permission rule from an entity.This will fail with an InvalidArgument fault if called on: the direct child folders of a datacenter managed object, the root resource pool of a ComputeResource or ClusterComputeResource, or a HostSystem that is part of a ComputeResource (Stand-alone Host). These objects always have the same permissions as their parent.This will fail with an InvalidArgument fault if called on a fault-tolerance (FT) secondary VirtualMachine. Such a VirtualMachine always has the same permissions as its FT primary VirtualMachine.
+
+
+  Privilege:
+
+
+
+  Args:
+    entity (`vim.ManagedEntity`_):
+       Entity on which a permission is removed.
+
+
+    user (`str`_):
+       User or group for which the permission is defined.
+
+
+    isGroup (`bool`_):
+       True, if user refers to a group name; false, for a user name.
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vim.fault.NotFound`_: 
+       if a permission for this entity and user or group does not exist.
+
+    `vim.fault.AuthMinimumAdminPermission`_: 
+       if this change would leave the system with no Administrator permission on the root node.
+
+    `vmodl.fault.InvalidArgument`_: 
+       if one of the new role IDs is the View or Anonymous role, or the entity does not support removing permissions.
+
+    `vim.fault.NoPermission`_: 
+       if current session does not have any privilege in the permission to be removed or "Authorization.ModifyPermissions" privilege on the entity.
+
+
+HasPrivilegeOnEntity(entity, sessionId, privId):
+   Check whether a session holds a set of privileges on a managed entity.If the session does not exist, false is returned for all privileges.
+  since: `vSphere API 5.0`_
+
+
+  Privilege:
+               System.View
+
+
+
+  Args:
+    entity (`vim.ManagedEntity`_):
+       The entity on which the privileges are checked.
+
+
+    sessionId (`str`_):
+       The session ID to check privileges for. A sesssion ID can be obtained from `key`_ .
+
+
+    privId (`str`_, optional):
+       The array of privilege IDs to check.
+
+
+
+
+  Returns:
+    `bool`_:
+         a boolean value for each privilege indicating whether the session holds the privilege.
+
+  Raises:
+
+    `vmodl.fault.ManagedObjectNotFound`_: 
+       if the given entity does not exist.
+
+
+HasPrivilegeOnEntities(entity, sessionId, privId):
+   Check whether a session holds a set of privileges on a set of managed entities.If the session does not exist, false is returned for all privileges of all the entities.
+  since: `vSphere API 5.5`_
+
+
+  Privilege:
+               System.View
+
+
+
+  Args:
+    entity (`vim.ManagedEntity`_):
+       The set of entities on which the privileges are checked.
+
+
+    sessionId (`str`_):
+       The session ID to check privileges for. A sesssion ID can be obtained from `key`_ .
+
+
+    privId (`str`_, optional):
+       The array of privilege IDs to check.
+
+
+
+
+  Returns:
+    `vim.AuthorizationManager.EntityPrivilege`_:
+         The privilege check result.
+
+  Raises:
+
+    `vmodl.fault.ManagedObjectNotFound`_: 
+       if a given entity does not exist.
+
+

docs/vim/AuthorizationManager/EntityPrivilege.rst

@@ -0,0 +1,22 @@
+.. _vSphere API 5.5: ../../vim/version.rst#vimversionversion9
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+.. _vim.ManagedEntity: ../../vim/ManagedEntity.rst
+
+.. _vim.AuthorizationManager.PrivilegeAvailability: ../../vim/AuthorizationManager/PrivilegeAvailability.rst
+
+
+vim.AuthorizationManager.EntityPrivilege
+========================================
+  This class defines whether a set of privileges are granted for a managed entity.
+:extends: vmodl.DynamicData_
+:since: `vSphere API 5.5`_
+
+Attributes:
+    entity (`vim.ManagedEntity`_):
+
+       The entity on which the privileges are checked.
+    privAvailability (`vim.AuthorizationManager.PrivilegeAvailability`_):
+
+       whether a set of privileges are granted for the managed entity.

docs/vim/AuthorizationManager/Permission.rst

@@ -0,0 +1,32 @@
+.. _int: https://docs.python.org/2/library/stdtypes.html
+
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+.. _vim.ManagedEntity: ../../vim/ManagedEntity.rst
+
+
+vim.AuthorizationManager.Permission
+===================================
+  This data object type provides assignment of some role access to a principal on a specific entity. A ManagedEntity is limited to one permission per principal.
+:extends: vmodl.DynamicData_
+
+Attributes:
+    entity (`vim.ManagedEntity`_, optional):
+
+       Managed entity the permission is defined on. Left unset when calling setPermissions or resetPermissions, but present for the results of permission queries.
+    principal (`str`_):
+
+       User or group receiving access in the form of "login" for local or "DOMAIN\login" for users in a Windows domain.
+    group (`bool`_):
+
+       Whether principal refers to a user or a group. True for a group and false for a user.
+    roleId (`int`_):
+
+       Reference to the role providing the access.
+    propagate (`bool`_):
+
+       Whether or not this permission propagates down the hierarchy to sub-entities.

docs/vim/AuthorizationManager/Privilege.rst

@@ -0,0 +1,27 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+.. _AuthorizationDescription: ../../vim/AuthorizationDescription.rst
+
+
+vim.AuthorizationManager.Privilege
+==================================
+  This data object type provides access to some aspect of the system. Privileges are generally independent. This means a user with a privilege usually can perform an associated set of actions without needing any additional supporting privileges.Within each product version, privileges do not change. See `AuthorizationDescription`_ for detailed information on the privileges defined by the system.
+:extends: vmodl.DynamicData_
+
+Attributes:
+    privId (`str`_):
+
+       Unique identifier.
+    onParent (`bool`_):
+
+       Determines whether or not the privilege is applied on the parent entity.
+    name (`str`_):
+
+       Privilege name.
+    privGroupName (`str`_):
+
+       Group name.

docs/vim/AuthorizationManager/PrivilegeAvailability.rst

@@ -0,0 +1,22 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _vSphere API 5.5: ../../vim/version.rst#vimversionversion9
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+
+vim.AuthorizationManager.PrivilegeAvailability
+==============================================
+  This class defines whether a specific privilege is granted.
+:extends: vmodl.DynamicData_
+:since: `vSphere API 5.5`_
+
+Attributes:
+    privId (`str`_):
+
+       The privilege ID.
+    isGranted (`bool`_):
+
+       True if the privilege is granted.

docs/vim/AuthorizationManager/Role.rst

@@ -0,0 +1,32 @@
+.. _int: https://docs.python.org/2/library/stdtypes.html
+
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _vim.Description: ../../vim/Description.rst
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+
+vim.AuthorizationManager.Role
+=============================
+  This data object type specifies a collection of privileges used to grant access to users on managed entities.
+:extends: vmodl.DynamicData_
+
+Attributes:
+    roleId (`int`_):
+
+       Unique role identifier.
+    system (`bool`_):
+
+       Whether or not the role is system-defined. System-defined roles cannot be changed.
+    name (`str`_):
+
+       System-defined or user-defined role name.
+    info (`vim.Description`_):
+
+       Displayable role information.
+    privilege (`str`_, optional):
+
+       Privileges provided by this role, by privilege identifier.

docs/vim/BoolPolicy.rst

@@ -0,0 +1,17 @@
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _vSphere API 4.0: ../vim/version.rst#vimversionversion5
+
+.. _vim.InheritablePolicy: ../vim/InheritablePolicy.rst
+
+
+vim.BoolPolicy
+==============
+  The boolean type of setting or configuration that may get an inherited value.
+:extends: vim.InheritablePolicy_
+:since: `vSphere API 4.0`_
+
+Attributes:
+    value (`bool`_, optional):
+
+       The boolean value that is either set or inherited.

docs/vim/Capability.rst

@@ -0,0 +1,32 @@
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _CloneVM: ../vim/VirtualMachine.rst#clone
+
+.. _vim.EVCMode: ../vim/EVCMode.rst
+
+.. _NotSupported: ../vmodl/fault/NotSupported.rst
+
+.. _vmodl.DynamicData: ../vmodl/DynamicData.rst
+
+
+vim.Capability
+==============
+  A particular product may or may not support certain features. This data object indicates whether or not a service instance implements these features. This data object type indicates the circumstances under which an operation throws a `NotSupported`_ fault.Support for some features is indicated by the presence or absence of the manager object from the service instance. For example, the AlarmManager manager object indicates collecting alarms is supported. Other features indicate whether or not a given operation on an object throws a `NotSupported`_ fault.Some capabilities depend on the host or virtual machine version. These are specified by using the vim.host.Capability and vim.vm.Capability objects.
+:extends: vmodl.DynamicData_
+
+Attributes:
+    provisioningSupported (`bool`_):
+
+       Indicates whether or not the service instance supports provisioning. For example, the `CloneVM`_ operation.
+    multiHostSupported (`bool`_):
+
+       Indicates whether or not the service instance supports multiple hosts.
+    userShellAccessSupported (`bool`_):
+
+       Flag indicating whether host user accounts should have the option to be granted shell access
+    supportedEVCMode (`vim.EVCMode`_, optional):
+
+       All supported Enhanced VMotion Compatibility modes.
+    networkBackupAndRestoreSupported (`bool`_, optional):
+
+       Indicates whether network backup and restore feature is supported.

docs/vim/ClusterComputeResource.rst

@@ -0,0 +1,438 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _vim.Task: ../vim/Task.rst
+
+.. _VI API 2.5: ../vim/version.rst#vimversionversion2
+
+.. _recommendation: ../vim/ClusterComputeResource.rst#recommendation
+
+.. _vim.HostSystem: ../vim/HostSystem.rst
+
+.. _MigrateVM_Task: ../vim/VirtualMachine.rst#migrate
+
+.. _vSphere API 5.0: ../vim/version.rst#vimversionversion7
+
+.. _vSphere API 4.0: ../vim/version.rst#vimversionversion5
+
+.. _vSphere API 4.1: ../vim/version.rst#vimversionversion6
+
+.. _vim.fault.NoHost: ../vim/fault/NoHost.rst
+
+.. _vim.ResourcePool: ../vim/ResourcePool.rst
+
+.. _vim.VirtualMachine: ../vim/VirtualMachine.rst
+
+.. _vim.ComputeResource: ../vim/ComputeResource.rst
+
+.. _vim.host.ConnectSpec: ../vim/host/ConnectSpec.rst
+
+.. _vim.cluster.DrsFaults: ../vim/cluster/DrsFaults.rst
+
+.. _vim.option.OptionValue: ../vim/option/OptionValue.rst
+
+.. _vim.fault.TooManyHosts: ../vim/fault/TooManyHosts.rst
+
+.. _vim.cluster.ConfigInfo: ../vim/cluster/ConfigInfo.rst
+
+.. _vim.fault.InvalidState: ../vim/fault/InvalidState.rst
+
+.. _vim.cluster.ConfigSpec: ../vim/cluster/ConfigSpec.rst
+
+.. _vim.fault.InvalidLogin: ../vim/fault/InvalidLogin.rst
+
+.. _vim.fault.DuplicateName: ../vim/fault/DuplicateName.rst
+
+.. _vim.cluster.DrsMigration: ../vim/cluster/DrsMigration.rst
+
+.. _vmodl.fault.NotSupported: ../vmodl/fault/NotSupported.rst
+
+.. _vim.fault.SSLVerifyFault: ../vim/fault/SSLVerifyFault.rst
+
+.. _vim.cluster.ActionHistory: ../vim/cluster/ActionHistory.rst
+
+.. _vim.cluster.Recommendation: ../vim/cluster/Recommendation.rst
+
+.. _vim.fault.AlreadyConnected: ../vim/fault/AlreadyConnected.rst
+
+.. _vim.fault.NotSupportedHost: ../vim/fault/NotSupportedHost.rst
+
+.. _vim.fault.HostConnectFault: ../vim/fault/HostConnectFault.rst
+
+.. _vmodl.fault.InvalidArgument: ../vmodl/fault/InvalidArgument.rst
+
+.. _vim.fault.AgentInstallFailed: ../vim/fault/AgentInstallFailed.rst
+
+.. _vim.fault.AlreadyBeingManaged: ../vim/fault/AlreadyBeingManaged.rst
+
+.. _vim.cluster.DrsRecommendation: ../vim/cluster/DrsRecommendation.rst
+
+.. _vmodl.fault.NotEnoughLicenses: ../vmodl/fault/NotEnoughLicenses.rst
+
+.. _vim.cluster.HostRecommendation: ../vim/cluster/HostRecommendation.rst
+
+.. _vim.cluster.DasAdvancedRuntimeInfo: ../vim/cluster/DasAdvancedRuntimeInfo.rst
+
+.. _vim.cluster.EnterMaintenanceResult: ../vim/cluster/EnterMaintenanceResult.rst
+
+.. _vim.fault.DisallowedOperationOnFailoverHost: ../vim/fault/DisallowedOperationOnFailoverHost.rst
+
+.. _vim.fault.CannotDisableDrsOnClustersWithVApps: ../vim/fault/CannotDisableDrsOnClustersWithVApps.rst
+
+
+vim.ClusterComputeResource
+==========================
+  The `ClusterComputeResource`_ data object aggregates the compute resources of associated `HostSystem`_ objects into a single compute resource for use by virtual machines. The cluster services such as HA (High Availability), DRS (Distributed Resource Scheduling), and EVC (Enhanced vMotion Compatibility), enhance the utility of this single compute resource.Use the `Folder`_ . `CreateClusterEx`_ method to create an instance of this object.
+
+
+:extends: vim.ComputeResource_
+
+
+Attributes
+----------
+    configuration (`vim.cluster.ConfigInfo`_):
+       Configuration of the cluster.
+    recommendation (`vim.cluster.Recommendation`_):
+      privilege: System.Read
+       List of recommended actions for the cluster. It is possible that the current set of recommendations may be empty, either due to not having any running dynamic recommendation generation module, or since there may be no recommended actions at this time.
+    drsRecommendation (`vim.cluster.DrsRecommendation`_):
+       If DRS is enabled, this returns the set of recommended migrations from the DRS module. The current set of recommendations may be empty, since there may be no recommended migrations at this time, or it is possible that DRS is not enabled.
+    migrationHistory (`vim.cluster.DrsMigration`_):
+       The set of migration decisions that have recently been performed.This list is populated only when DRS is in automatic mode.
+    actionHistory (`vim.cluster.ActionHistory`_):
+       The set of actions that have been performed recently.
+    drsFault (`vim.cluster.DrsFaults`_):
+      privilege: System.Read
+       A collection of the DRS faults generated in the last DRS invocation. Each element of the collection is the set of faults generated in one recommendation. DRS faults are generated when DRS tries to make recommendations for rule enforcement, power management, etc., and indexed in a tree structure with reason for recommendations and VM to migrate (optional) as the index keys. In releases after vSphere API 5.0, vSphere Servers might not generate property collector update notifications for this property. To obtain the latest value of the property, you can use PropertyCollector methods RetrievePropertiesEx or WaitForUpdatesEx. If you use the PropertyCollector.WaitForUpdatesEx method, specify an empty string for the version parameter. Any other version value will not produce any property values as no updates are generated.
+
+
+Methods
+-------
+
+
+ReconfigureCluster(spec, modify):
+   Reconfigures a cluster.
+
+
+  Privilege:
+               Host.Inventory.EditCluster
+
+
+
+  Args:
+    spec (`vim.cluster.ConfigSpec`_):
+       A set of configuration changes to apply to the cluster. The specification can be a complete set of changes or a partial set of changes, applied incrementally.
+
+
+    modify (`bool`_):
+       Flag to specify whether the specification ("spec") should be applied incrementally. If "modify" is false and the operation succeeds, then the configuration of the cluster matches the specification exactly; in this case any unset portions of the specification will result in unset or default portions of the configuration.
+
+
+
+
+  Returns:
+     `vim.Task`_:
+         
+
+  Raises:
+
+    `vim.fault.CannotDisableDrsOnClustersWithVApps`_: 
+       If DRS is being disabled and the cluster contains one or more vApps.
+
+
+ApplyRecommendation(key):
+   Applies a recommendation from the drsRecommendation or the recommendation list. Each recommendation can be applied only once.resource.applyRecommendation privilege is required if the recommendation is DRS migration or power management recommendations.
+
+
+  Privilege:
+               dynamic
+
+
+
+  Args:
+    key (`str`_):
+       The key field of the DrsRecommendation or Recommendation.
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vmodl.fault.InvalidArgument`_: 
+       If the specified key refers to a non-existent or an already executed recommendation.
+
+
+CancelRecommendation(key):
+   Cancels a recommendation. Currently only initial placement recommendations can be cancelled. Migration or power management recommendations cannot.
+  since: `vSphere API 4.1`_
+
+
+  Privilege:
+               System.Read
+
+
+
+  Args:
+    key (`str`_):
+       The key field of the Recommendation.
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vmodl.fault.InvalidArgument`_: 
+       If the specified key refers to a non-existent or an already executed recommendation.
+
+
+RecommendHostsForVm(vm, pool):
+   Gets a recommendation for where to power on, resume, revert from powered-off state to powered on state, or to migrate a specific virtual machine. If no host is found, an empty list is returned.The type of operation is implied by the state of the virtual machine. Returned hosts are intended for power-on or resume if the virtual machine is powered-off or suspended. However, if the virtual machine is powered-on, the request is assumed to be for migrating a virtual machine into a DRS enabled cluster. In that case, the ResourcePool argument should be specified and the ResourcePool and the virtual machine cannot be in the same cluster.
+
+
+  Privilege:
+               System.Read
+
+
+
+  Args:
+    vm (`vim.VirtualMachine`_):
+       Specifies the virtual machine for which the user is requesting a recommendations.
+
+
+    pool (`vim.ResourcePool`_, optional):
+       Specifies the ResourcePool into which the virtual machine is to be migrated. If the virtual machine is powered-on, this argument must be specified and it is relevant only when the virtual machine is powered-on. This ResourcePool cannot be in the same cluster as the virtual machine.
+
+
+
+
+  Returns:
+    `vim.cluster.HostRecommendation`_:
+         An array of HostRecommendation ordered by their rating.
+
+  Raises:
+
+    `vmodl.fault.NotSupported`_: 
+       if DRS is not enabled.
+
+    `vmodl.fault.InvalidArgument`_: 
+       if the virtual machine is powered on and the optional ResourcePool argument is either not specified or is in the same cluster as the virtual machine.
+
+
+AddHost(spec, asConnected, resourcePool, license):
+   Adds a host to the cluster. The hostname must be either an IP address, such as 192.168.0.1, or a DNS resolvable name. DNS names may be fully qualified names, such as host1.domain1.com, or a short name such as host1, providing host1 resolves to host1.domain1.com. The system uses DNS to resolve short names to fully qualified names. If the cluster supports nested resource pools and the user specifies the optional ResourcePool argument, then the host's root resource pool becomes the specified resource pool. The stand-alone host resource hierarchy is imported into the new nested resource pool.If the cluster does not support nested resource pools, then the stand-alone host resource hierarchy is discarded and all virtual machines on the host are put under the cluster's root resource pool.In addition to the Host.Inventory.AddHostToCluster and Resource.AssignVMToPool privileges, it requires System.View privilege on the VM folder that the VMs of the host will be placed on.
+
+
+  Privilege:
+               Host.Inventory.AddHostToCluster
+
+
+
+  Args:
+    spec (`vim.host.ConnectSpec`_):
+       Specifies the host name, port, and password for the host to be added.
+
+
+    asConnected (`bool`_):
+       Flag to specify whether or not the host should be connected immediately after it is added. The host will not be added if a connection attempt is made and fails.
+
+
+    resourcePool (`vim.ResourcePool`_, optional):
+       the resource pool for the root resource pool from the host.
+
+
+    license (`str`_, optional, since `vSphere API 4.0`_ ):
+       Provide a licenseKey or licenseKeyType. See `LicenseManager`_ 
+
+
+
+
+  Returns:
+     `vim.Task`_:
+         the newly added HostSystem.
+
+  Raises:
+
+    `vim.fault.InvalidLogin`_: 
+       if "asConnected" is specified but authentication with the new host fails.
+
+    `vim.fault.HostConnectFault`_: 
+       if an error occurred when connecting to a host. Typically, a more specific subclass, such as AlreadyBeingManaged, is thrown.
+
+    `vim.fault.DuplicateName`_: 
+       if another host in the same cluster has the name.
+
+    `vim.fault.AlreadyBeingManaged`_: 
+       if the host is already being managed by a VirtualCenter server.
+
+    `vmodl.fault.NotEnoughLicenses`_: 
+       if no licenses are available to add this host.
+
+    `vim.fault.NoHost`_: 
+       if the host cannot be contacted.
+
+    `vim.fault.NotSupportedHost`_: 
+       if the host is running a software version that does not support clustering features. It may still be possible to add the host as a stand-alone host.
+
+    `vim.fault.TooManyHosts`_: 
+       if no additional hosts can be added to the cluster.
+
+    `vim.fault.AgentInstallFailed`_: 
+       if there is an error installing the VirtualCenter agent on the host.
+
+    `vim.fault.AlreadyConnected`_: 
+       if asConnected is true and the host is already connected to VirtualCenter.
+
+    `vim.fault.SSLVerifyFault`_: 
+       if the host certificate could not be authenticated
+
+
+MoveInto(host):
+   Moves an existing host into a cluster. The host must be part of the same datacenter, and if the host is part of a cluster, the host must be in maintenance mode.If the host is part of a stand-alone ComputeResource, then the stand-alone ComputeResource is removed as part of this operation.All virtual machines associated with a host, regardless of whether or not they are running, are moved with the host into the cluster. If there are virtual machines that should not be moved, then migrate those virtual machines off the host before initiating this operation.For stand-alone hosts, the host resource pool hierarchy is discarded in this call. To preserve a host resource pools from a stand-alone host, call moveHostInt, specifying an optional resource pool. This operation is transactional only with respect to each individual host. Hosts in the set are moved sequentially and are committed, one at a time. If a failure is detected, then the method terminates with an exception. Since hosts are moved one at a time, if this operation fails while in the process of moving multiple hosts, some hosts are left unmoved.In addition to the privileges mentioned, the user must also hold Host.Inventory.EditCluster on the host's source ComputeResource object.
+
+
+  Privilege:
+               Host.Inventory.EditCluster
+
+
+
+  Args:
+    host (`vim.HostSystem`_):
+       The list of hosts to move into the cluster.
+
+
+
+
+  Returns:
+     `vim.Task`_:
+         
+
+  Raises:
+
+    `vim.fault.DuplicateName`_: 
+       if the host is already in the cluster
+
+    `vim.fault.TooManyHosts`_: 
+       if no additional hosts can be added to the cluster.
+
+    `vim.fault.InvalidState`_: 
+       if a host is already part of a cluster and is not in maintenance mode.
+
+    `vmodl.fault.InvalidArgument`_: 
+       if one of the hosts is not part of the same datacenter as the cluster.
+
+    `vim.fault.DisallowedOperationOnFailoverHost`_: 
+       if the host is being moved from a cluster and was configured as a failover host in that cluster. See `ClusterFailoverHostAdmissionControlPolicy`_ .
+
+
+MoveHostInto(host, resourcePool):
+   Moves an existing host into a cluster. The host must be part of the same datacenter, and if the host is part of a cluster, the host must be in maintenance mode.If the host is a stand-alone host, the stand-alone ComputeResource is removed as part of this operation.All virtual machines associated with the host, regardless of whether or not they are running, are moved with the host into the cluster. If there are virtual machines that should not be moved, then migrate those virtual machines off the host before initiating this operation.If the host is a stand-alone host, the cluster supports nested resource pools, and the user specifies the optional resourcePool argument, then the stand-alone host's root resource pool becomes the specified resource pool and the stand-alone host resource hierarchy is imported into the new nested resource pool. If the cluster does not support nested resource pools or the resourcePool argument is not specified, then the stand-alone host resource hierarchy is ignored.
+
+
+  Privilege:
+               Host.Inventory.EditCluster
+
+
+
+  Args:
+    host (`vim.HostSystem`_):
+       The list of hosts to move into the cluster.
+
+
+    resourcePool (`vim.ResourcePool`_, optional):
+       The resource pool to match the root resource pool of stand-alone hosts. This argument has no effect if the host is part of a cluster.
+
+
+
+
+  Returns:
+     `vim.Task`_:
+         
+
+  Raises:
+
+    `vim.fault.TooManyHosts`_: 
+       if no additional hosts can be added to the cluster.
+
+    `vim.fault.InvalidState`_: 
+       if a host is already part of a cluster and is not in maintenance mode.
+
+    `vmodl.fault.InvalidArgument`_: 
+       if the host is not a part of the same datacenter as the cluster or if the specified resource pool is not part of the cluster or if the source and destination clusters are the same.
+
+
+RefreshRecommendation():
+   Make DRS invoke again and return a new list of recommendations. Concurrent "refresh" requests may be combined together and trigger only one DRS invocation.The recommendations generated is stored at `recommendation`_ .
+  since: `VI API 2.5`_
+
+
+  Privilege:
+               Host.Inventory.EditCluster
+
+
+
+  Args:
+
+
+  Returns:
+    None
+         
+
+
+RetrieveDasAdvancedRuntimeInfo():
+   Retrieve DAS advanced runtime info for this cluster.
+  since: `vSphere API 4.0`_
+
+
+  Privilege:
+               System.Read
+
+
+
+  Args:
+
+
+  Returns:
+    `vim.cluster.DasAdvancedRuntimeInfo`_:
+         
+
+
+ClusterEnterMaintenanceMode(host, option):
+   The API takes a list of hosts in the cluster as input, and returns a list of hosts in "ClusterMaintenanceResult" that the server can successfully evacuate given the existing constraints in the cluster, such as HA, FT, Vmotion compatibility, reservations, affinity rules, etc. The client is allowed to pass all hosts in the cluster to the API, even though all of them cannot enter maintenance mode at the same time. The list returned from the API contains the largest number of hosts that the server can evacuate simultaneously. The client can then request to enter each host in the returned list into maintenance mode. The client can specify an integer "DemandCapacityRatioTarget" option in the "option" parameter. The allowed values of the option range from 40 to 200, and the default value is 100. This option controls how much resource overcommitment the server should make in consolidating the VMs onto fewer hosts. A value of 100 means the server will keep the same amount of powered-on capacity as the current VM demands. A value less than 100 means undercommitted resources. A value greater than 100 means overcommitted resources. The hosts are recommended based on the inventory at the time of the API invocation. It is not guaranteed that the actual enter-maintenance tasks on the hosts will succeed, if the inventory changes after the API returns, or if vmotions fail due to unexpected conditions. For possible exceptions thrown by the necessary relocate operations, see `MigrateVM_Task`_ .
+  since: `vSphere API 5.0`_
+
+
+  Privilege:
+               System.View
+
+
+
+  Args:
+    host (`vim.HostSystem`_):
+       The array of hosts to put into maintenance mode.
+
+
+    option (`vim.option.OptionValue`_, optional):
+       An array of `OptionValue`_ options for this query. The specified options override the advanced options in `ClusterDrsConfigInfo`_ .
+
+
+
+
+  Returns:
+    `vim.cluster.EnterMaintenanceResult`_:
+         A `ClusterEnterMaintenanceResult`_ object, which consists of an array of recommendations for hosts that can be evacuated and an array of faults for hosts that cannot be evacuated.
+
+  Raises:
+
+    `vmodl.fault.InvalidArgument`_: 
+       for unknown option keys or bad values.
+
+

docs/vim/ClusterComputeResource/Summary.rst

@@ -0,0 +1,46 @@
+.. _int: https://docs.python.org/2/library/stdtypes.html
+
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _supportedEVCMode: ../../vim/Capability.rst#supportedEVCMode
+
+.. _vim.cluster.DasData: ../../vim/cluster/DasData.rst
+
+.. _ClusterComputeResource: ../../vim/ClusterComputeResource.rst
+
+.. _vim.ComputeResource.Summary: ../../vim/ComputeResource/Summary.rst
+
+.. _ClusterComputeResourceSummary: ../../vim/ClusterComputeResource/Summary.rst
+
+.. _ClusterDasAdmissionControlPolicy: ../../vim/cluster/DasAdmissionControlPolicy.rst
+
+.. _vim.cluster.DasAdmissionControlInfo: ../../vim/cluster/DasAdmissionControlInfo.rst
+
+
+vim.ClusterComputeResource.Summary
+==================================
+  The `ClusterComputeResourceSummary`_ data object encapsulates runtime properties of a `ClusterComputeResource`_ .
+:extends: vim.ComputeResource.Summary_
+
+Attributes:
+    currentFailoverLevel (`int`_):
+
+       Current failover level. This is the number of physical host failures that can be tolerated without impacting the ability to satisfy the minimums for all running virtual machines. This represents the current value, as opposed to desired value configured by the user.
+    admissionControlInfo (`vim.cluster.DasAdmissionControlInfo`_, optional):
+
+       Information about the current amount of resources available for a vSphere HA cluster. The actual type of admissionControlInfo will depend on what kind of `ClusterDasAdmissionControlPolicy`_ was used to configure the cluster.
+    numVmotions (`int`_):
+
+       Total number of migrations with VMotion that have been done internal to this cluster.
+    targetBalance (`int`_, optional):
+
+       The target balance, in terms of standard deviation, for a DRS cluster. Units are thousandths. For example, 12 represents 0.012.
+    currentBalance (`int`_, optional):
+
+       The current balance, in terms of standard deviation, for a DRS cluster. Units are thousandths. For example, 12 represents 0.012.
+    currentEVCModeKey (`str`_, optional):
+
+       The Enhanced VMotion Compatibility mode that is currently in effect for all hosts in this cluster; unset if no EVC mode is active.See `supportedEVCMode`_ 
+    dasData (`vim.cluster.DasData`_, optional):
+
+       Data pertaining to DAS.

docs/vim/ComputeResource.rst

@@ -0,0 +1,95 @@
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _vim.Task: ../vim/Task.rst
+
+.. _VI API 2.5: ../vim/version.rst#vimversionversion2
+
+.. _vim.Network: ../vim/Network.rst
+
+.. _vim.Datastore: ../vim/Datastore.rst
+
+.. _vim.HostSystem: ../vim/HostSystem.rst
+
+.. _vim.ResourcePool: ../vim/ResourcePool.rst
+
+.. _vim.ManagedEntity: ../vim/ManagedEntity.rst
+
+.. _ClusterConfigInfoEx: ../vim/cluster/ConfigInfoEx.rst
+
+.. _vim.EnvironmentBrowser: ../vim/EnvironmentBrowser.rst
+
+.. _vim.ComputeResource.Summary: ../vim/ComputeResource/Summary.rst
+
+.. _vim.ComputeResource.ConfigInfo: ../vim/ComputeResource/ConfigInfo.rst
+
+.. _vim.ComputeResource.ConfigSpec: ../vim/ComputeResource/ConfigSpec.rst
+
+.. _vim.fault.CannotDisableDrsOnClustersWithVApps: ../vim/fault/CannotDisableDrsOnClustersWithVApps.rst
+
+
+vim.ComputeResource
+===================
+  Represents a set of physical compute resources for a set of virtual machines.The base type `ComputeResource`_ , when instantiated by calling `AddStandaloneHost_Task`_ , represents a single host. The subclass `ClusterComputeResource`_ represents a cluster of hosts and adds distributed management features such as availability and resource scheduling.A `ComputeResource`_ always has a root `ResourcePool`_ associated with it. Certain types of clusters such as those with VMware DRS enabled and standalone hosts (ESX Server 3) support the creation of `ResourcePool`_ hierarchies.
+
+
+:extends: vim.ManagedEntity_
+
+
+Attributes
+----------
+    resourcePool (`vim.ResourcePool`_):
+      privilege: System.View
+       Reference to root resource pool.
+    host (`vim.HostSystem`_):
+      privilege: System.View
+       List of hosts that are part of this compute resource. If the compute resource is a standalone type, then this list contains just one element.
+    datastore (`vim.Datastore`_):
+      privilege: System.View
+       The datastore property is the subset of datastore objects in the datacenter available in this ComputeResource.This property is computed as the aggregate set of datastores available from all the hosts that are part of this compute resource.
+    network (`vim.Network`_):
+      privilege: System.View
+       The subset of network objects available in the datacenter that is available in this ComputeResource.This property is computed as the aggregate set of networks available from all the hosts that are part of this compute resource.
+    summary (`vim.ComputeResource.Summary`_):
+       Basic runtime information about a compute resource. This information is used on summary screens and in list views.
+    environmentBrowser (`vim.EnvironmentBrowser`_):
+      privilege: System.View
+       The environment browser object that identifies the environments that are supported on this compute resource.
+    configurationEx (`vim.ComputeResource.ConfigInfo`_):
+       Configuration of the compute resource; applies to both standalone hosts and clusters. For a cluster this property will return a `ClusterConfigInfoEx`_ object.
+
+
+Methods
+-------
+
+
+ReconfigureComputeResource(spec, modify):
+   Change the compute resource configuration.
+  since: `VI API 2.5`_
+
+
+  Privilege:
+               Host.Inventory.EditCluster
+
+
+
+  Args:
+    spec (`vim.ComputeResource.ConfigSpec`_):
+       A set of configuration changes to apply to the compute resource. The specification can be a complete set of changes or a partial set of changes, applied incrementally. When invoking reconfigureEx on a cluster, this argument may be a `ClusterConfigSpecEx`_ object.
+
+
+    modify (`bool`_):
+       Flag to specify whether the specification ("spec") should be applied incrementally. If "modify" is false and the operation succeeds, then the configuration of the cluster matches the specification exactly; in this case any unset portions of the specification will result in unset or default portions of the configuration.
+
+
+
+
+  Returns:
+     `vim.Task`_:
+         
+
+  Raises:
+
+    `vim.fault.CannotDisableDrsOnClustersWithVApps`_: 
+       If DRS is being disabled and the cluster contains one or more vApps.
+
+

docs/vim/ComputeResource/ConfigInfo.rst

@@ -0,0 +1,41 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _VI API 2.5: ../../vim/version.rst#vimversionversion2
+
+.. _swapPlacement: ../../vim/vm/ConfigInfo.rst#swapPlacement
+
+.. _perVmSwapFiles: ../../vim/host/Capability.rst#perVmSwapFiles
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+.. _environmentBrowser: ../../vim/ComputeResource.rst#environmentBrowser
+
+.. _defaultConfigOption: ../../vim/vm/ConfigOptionDescriptor.rst#defaultConfigOption
+
+.. _VirtualMachineConfigInfoSwapPlacementType: ../../vim/vm/ConfigInfo/SwapPlacementType.rst
+
+
+vim.ComputeResource.ConfigInfo
+==============================
+  Configuration of the compute resource; applies to both standalone hosts and clusters.
+:extends: vmodl.DynamicData_
+:since: `VI API 2.5`_
+
+Attributes:
+    vmSwapPlacement (`str`_):
+
+       Swapfile placement policy for virtual machines within this compute resource. Any policy except for "inherit" is a valid value for this property; the default is "vmDirectory". This setting will be honored for each virtual machine within the compute resource for which the following is true:
+        * The virtual machine is executing on a host that has the
+        * `perVmSwapFiles`_
+        * capability.
+        * The virtual machine configuration's
+        * `swapPlacement`_
+        * property is set to "inherit".See `VirtualMachineConfigInfoSwapPlacementType`_ 
+    spbmEnabled (`bool`_, optional):
+
+       Flag indicating whether or not the SPBM(Storage Policy Based Management) feature is enabled on this compute resource
+    defaultHardwareVersionKey (`str`_, optional):
+
+       Key for Default Hardware Version used on this compute resource in the format of `key`_ . This field affects `defaultConfigOption`_ returned by `environmentBrowser`_ of this object and all its children with this field unset.

docs/vim/ComputeResource/ConfigSpec.rst

@@ -0,0 +1,31 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _VI API 2.5: ../../vim/version.rst#vimversionversion2
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+.. _environmentBrowser: ../../vim/ComputeResource.rst#environmentBrowser
+
+.. _defaultConfigOption: ../../vim/vm/ConfigOptionDescriptor.rst#defaultConfigOption
+
+.. _VirtualMachineConfigInfoSwapPlacementType: ../../vim/vm/ConfigInfo/SwapPlacementType.rst
+
+
+vim.ComputeResource.ConfigSpec
+==============================
+  Changes to apply to the compute resource configuration.
+:extends: vmodl.DynamicData_
+:since: `VI API 2.5`_
+
+Attributes:
+    vmSwapPlacement (`str`_, optional):
+
+       New setting for the swapfile placement policy. Any change to this policy will affect virtual machines that subsequently power on or resume from a suspended state in this compute resource, or that migrate to a host in this compute resource while powered on; virtual machines that are currently powered on in this compute resource will not yet be affected.See `VirtualMachineConfigInfoSwapPlacementType`_ 
+    spbmEnabled (`bool`_, optional):
+
+       Flag indicating whether or not the SPBM(Storage Policy Based Management) feature is enabled on this compute resource
+    defaultHardwareVersionKey (`str`_, optional):
+
+       Key for Default Hardware Version to be used on this compute resource in the format of `key`_ . Setting this field affects `defaultConfigOption`_ returned by `environmentBrowser`_ of this object and all its children with this field unset.

docs/vim/ComputeResource/HostSPBMLicenseInfo.rst

@@ -0,0 +1,22 @@
+.. _vim.HostSystem: ../../vim/HostSystem.rst
+
+.. _vSphere API 5.0: ../../vim/version.rst#vimversionversion7
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+.. _ComputeResourceHostSPBMLicenseInfo: ../../vim/ComputeResource/HostSPBMLicenseInfo.rst
+
+.. _vim.ComputeResource.HostSPBMLicenseInfo.HostSPBMLicenseState: ../../vim/ComputeResource/HostSPBMLicenseInfo/HostSPBMLicenseState.rst
+
+
+vim.ComputeResource.HostSPBMLicenseInfo
+=======================================
+  The `ComputeResourceHostSPBMLicenseInfo`_ data object encapsulates the SPBM(Storage Policy Based Management) license information for a host.
+:extends: vmodl.DynamicData_
+:since: `vSphere API 5.0`_
+
+Attributes:
+    host (`vim.HostSystem`_):
+
+    licenseState (`vim.ComputeResource.HostSPBMLicenseInfo.HostSPBMLicenseState`_):
+

docs/vim/ComputeResource/HostSPBMLicenseInfo/HostSPBMLicenseState.rst

@@ -0,0 +1,24 @@
+.. _vim.ComputeResource.HostSPBMLicenseInfo: ../../../vim/ComputeResource/HostSPBMLicenseInfo.rst
+
+.. _vim.ComputeResource.HostSPBMLicenseInfo.HostSPBMLicenseState: ../../../vim/ComputeResource/HostSPBMLicenseInfo/HostSPBMLicenseState.rst
+
+vim.ComputeResource.HostSPBMLicenseInfo.HostSPBMLicenseState
+============================================================
+  The SPBM(Storage Policy Based Management) license state for a host
+  :contained by: `vim.ComputeResource.HostSPBMLicenseInfo`_
+
+  :type: `vim.ComputeResource.HostSPBMLicenseInfo.HostSPBMLicenseState`_
+
+  :name: unknown
+
+values:
+--------
+
+unknown
+   The host license information is unknown, this could happen if the host is not in a available state
+
+unlicensed
+   The host is not licensed
+
+licensed
+   The host is licensed

docs/vim/ComputeResource/Summary.rst

@@ -0,0 +1,44 @@
+.. _int: https://docs.python.org/2/library/stdtypes.html
+
+.. _long: https://docs.python.org/2/library/stdtypes.html
+
+.. _short: https://docs.python.org/2/library/stdtypes.html
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+.. _vim.ManagedEntity.Status: ../../vim/ManagedEntity/Status.rst
+
+
+vim.ComputeResource.Summary
+===========================
+  This data object type encapsulates a typical set of ComputeResource information that is useful for list views and summary pages.
+:extends: vmodl.DynamicData_
+
+Attributes:
+    totalCpu (`int`_):
+
+       Aggregated CPU resources of all hosts, in MHz.
+    totalMemory (`long`_):
+
+       Aggregated memory resources of all hosts, in bytes.
+    numCpuCores (`short`_):
+
+       Number of physical CPU cores. Physical CPU cores are the processors contained by a CPU package.
+    numCpuThreads (`short`_):
+
+       Aggregated number of CPU threads.
+    effectiveCpu (`int`_):
+
+       Effective CPU resources (in MHz) available to run virtual machines. This is the aggregated effective resource level from all running hosts. Hosts that are in maintenance mode or are unresponsive are not counted. Resources used by the VMware Service Console are not included in the aggregate. This value represents the amount of resources available for the root resource pool for running virtual machines.
+    effectiveMemory (`long`_):
+
+       Effective memory resources (in MB) available to run virtual machines. This is the aggregated effective resource level from all running hosts. Hosts that are in maintenance mode or are unresponsive are not counted. Resources used by the VMware Service Console are not included in the aggregate. This value represents the amount of resources available for the root resource pool for running virtual machines.
+    numHosts (`int`_):
+
+       Total number of hosts.
+    numEffectiveHosts (`int`_):
+
+       Total number of effective hosts.
+    overallStatus (`vim.ManagedEntity.Status`_):
+
+       Overall alarm status. In releases after vSphere API 5.0, vSphere Servers might not generate property collector update notifications for this property. To obtain the latest value of the property, you can use PropertyCollector methods RetrievePropertiesEx or WaitForUpdatesEx. If you use the PropertyCollector.WaitForUpdatesEx method, specify an empty string for the version parameter. Since this property is on a DataObject, an update returned by WaitForUpdatesEx may contain values for this property when some other property on the DataObject changes. If this update is a result of a call to WaitForUpdatesEx with a non-empty version parameter, the value for this property may not be current.

docs/vim/ConfigSpecOperation.rst

@@ -0,0 +1,21 @@
+.. _vim.ConfigSpecOperation: ../vim/ConfigSpecOperation.rst
+
+vim.ConfigSpecOperation
+=======================
+  Config spec operation type.
+
+  :type: `vim.ConfigSpecOperation`_
+
+  :name: remove
+
+values:
+--------
+
+edit
+   Indicates the change of an element in the configuration.
+
+add
+   Indicates the addition of an element to the configuration.
+
+remove
+   Indicates the removal of an element in the configuration.

docs/vim/CustomFieldsManager.rst

@@ -0,0 +1,167 @@
+.. _int: https://docs.python.org/2/library/stdtypes.html
+
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _vim.Task: ../vim/Task.rst
+
+.. _vim.ManagedEntity: ../vim/ManagedEntity.rst
+
+.. _vim.PrivilegePolicyDef: ../vim/PrivilegePolicyDef.rst
+
+.. _vim.fault.DuplicateName: ../vim/fault/DuplicateName.rst
+
+.. _vim.fault.InvalidPrivilege: ../vim/fault/InvalidPrivilege.rst
+
+.. _vmodl.fault.InvalidArgument: ../vmodl/fault/InvalidArgument.rst
+
+.. _vim.CustomFieldsManager.FieldDef: ../vim/CustomFieldsManager/FieldDef.rst
+
+
+vim.CustomFieldsManager
+=======================
+  The CustomFieldsManager object is used to add and remove custom fields to managed entities.The custom fields values set on managed entities are available through the `customValue`_ property and through the summary objects for `VirtualMachine`_ and `HostSystem`_ . They are not available directly through this managed object.This functionality is only available through VirtualCenter.
+
+
+
+
+Attributes
+----------
+    field (`vim.CustomFieldsManager.FieldDef`_):
+      privilege: System.View
+       List of custom fields defined on this server. The fields are sorted by name.
+
+
+Methods
+-------
+
+
+AddCustomFieldDef(name, moType, fieldDefPolicy, fieldPolicy):
+   Creates a new custom field. If the moType is specified, the field will only be available for that type of managed object.
+
+
+  Privilege:
+               Global.ManageCustomFields
+
+
+
+  Args:
+    name (`str`_):
+       The name of the field.
+
+
+    moType (`str`_, optional, since `VI API 2.5`_ ):
+       The managed object type to which this field will apply
+
+
+    fieldDefPolicy (`vim.PrivilegePolicyDef`_, optional, since `VI API 2.5`_ ):
+       Privilege policy to apply to FieldDef being created
+
+
+    fieldPolicy (`vim.PrivilegePolicyDef`_, optional, since `VI API 2.5`_ ):
+       Privilege policy to apply to instances of field
+
+
+
+
+  Returns:
+    `vim.CustomFieldsManager.FieldDef`_:
+         
+
+  Raises:
+
+    `vim.fault.DuplicateName`_: 
+       if a custom field with the name already exists.
+
+    `vim.fault.InvalidPrivilege`_: 
+       if a specified privilege is not defined.
+
+
+RemoveCustomFieldDef(key):
+   Removes a custom field. This also removes all values assigned to this custom field.
+
+
+  Privilege:
+               Global.ManageCustomFields
+
+
+
+  Args:
+    key (`int`_):
+       The unique key for the field definition.
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vmodl.fault.InvalidArgument`_: 
+       if no custom field with that key exists.
+
+
+RenameCustomFieldDef(key, name):
+   Renames a custom field.
+
+
+  Privilege:
+               Global.ManageCustomFields
+
+
+
+  Args:
+    key (`int`_):
+       The unique key for the field definition.
+
+
+    name (`str`_):
+       The new name for the field.
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vim.fault.DuplicateName`_: 
+       if a custom field with the name already exists.
+
+    `vmodl.fault.InvalidArgument`_: 
+       if no custom field with that key exists.
+
+
+SetField(entity, key, value):
+   Assigns a value to a custom field on an entity.
+
+
+  Privilege:
+
+
+
+  Args:
+    entity (`vim.ManagedEntity`_):
+
+
+    key (`int`_):
+
+
+    value (`str`_):
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vmodl.fault.InvalidArgument`_: 
+       if no custom field with that key exists.
+
+

docs/vim/CustomFieldsManager/FieldDef.rst

@@ -0,0 +1,33 @@
+.. _int: https://docs.python.org/2/library/stdtypes.html
+
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+.. _vim.PrivilegePolicyDef: ../../vim/PrivilegePolicyDef.rst
+
+
+vim.CustomFieldsManager.FieldDef
+================================
+  Describes a custom field.
+:extends: vmodl.DynamicData_
+
+Attributes:
+    key (`int`_):
+
+       A unique ID used to reference this custom field in assignments. This ID is unique for the lifetime of the field (even across rename operations).
+    name (`str`_):
+
+       Name of the field.
+    type (`str`_):
+
+       Type of the field.
+    managedObjectType (`str`_, optional):
+
+       Type of object for which the field is valid. If not specified, the field is valid for all managed objects.
+    fieldDefPrivileges (`vim.PrivilegePolicyDef`_, optional):
+
+       The set of privileges to apply on this field definition
+    fieldInstancePrivileges (`vim.PrivilegePolicyDef`_, optional):
+
+       The set of privileges to apply on instances of this field

docs/vim/CustomFieldsManager/StringValue.rst

@@ -0,0 +1,14 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _vim.CustomFieldsManager.Value: ../../vim/CustomFieldsManager/Value.rst
+
+
+vim.CustomFieldsManager.StringValue
+===================================
+  Subtype for string values (currently the only supported type).
+:extends: vim.CustomFieldsManager.Value_
+
+Attributes:
+    value (`str`_):
+
+       Value assigned to the custom field.

docs/vim/CustomFieldsManager/Value.rst

@@ -0,0 +1,14 @@
+.. _int: https://docs.python.org/2/library/stdtypes.html
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+
+vim.CustomFieldsManager.Value
+=============================
+  Base type for storing values.
+:extends: vmodl.DynamicData_
+
+Attributes:
+    key (`int`_):
+
+       The ID of the field to which this value belongs.

docs/vim/CustomizationSpecInfo.rst

@@ -0,0 +1,28 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _datetime: https://docs.python.org/2/library/stdtypes.html
+
+.. _vmodl.DynamicData: ../vmodl/DynamicData.rst
+
+
+vim.CustomizationSpecInfo
+=========================
+  Information about a specification.
+:extends: vmodl.DynamicData_
+
+Attributes:
+    name (`str`_):
+
+       Unique name of the specification.
+    description (`str`_):
+
+       Description of the specification.
+    type (`str`_):
+
+       Guest operating system for this specification (Linux or Windows).
+    changeVersion (`str`_, optional):
+
+       The changeVersion is a unique identifier for a given version of the configuration. Each change to the configuration will update this value. This is typically implemented as an ever increasing count or a time-stamp. However, a client should always treat this as an opaque string.If specified when updating a specification, the changes will only be applied if the current changeVersion matches the specified changeVersion. This field can be used to guard against updates that has happened between the configInfo was read and until it is applied.
+    lastUpdateTime (`datetime`_, optional):
+
+       Time when the specification was last modified. This time is ignored when the CustomizationSpecItem containing this is used as an input to CustomizationSpecManager.create.

docs/vim/CustomizationSpecItem.rst

@@ -0,0 +1,19 @@
+.. _vmodl.DynamicData: ../vmodl/DynamicData.rst
+
+.. _vim.CustomizationSpecInfo: ../vim/CustomizationSpecInfo.rst
+
+.. _vim.vm.customization.Specification: ../vim/vm/customization/Specification.rst
+
+
+vim.CustomizationSpecItem
+=========================
+  Specification information and the Specification object.
+:extends: vmodl.DynamicData_
+
+Attributes:
+    info (`vim.CustomizationSpecInfo`_):
+
+       Information about the specification - name, description, and so on.
+    spec (`vim.vm.customization.Specification`_):
+
+       The customization specification.

docs/vim/CustomizationSpecManager.rst

@@ -0,0 +1,328 @@
+.. _int: https://docs.python.org/2/library/stdtypes.html
+
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _vim.Task: ../vim/Task.rst
+
+.. _vim.fault.NotFound: ../vim/fault/NotFound.rst
+
+.. _vim.fault.AlreadyExists: ../vim/fault/AlreadyExists.rst
+
+.. _vim.CustomizationSpecInfo: ../vim/CustomizationSpecInfo.rst
+
+.. _vim.CustomizationSpecItem: ../vim/CustomizationSpecItem.rst
+
+.. _vim.fault.ConcurrentAccess: ../vim/fault/ConcurrentAccess.rst
+
+.. _vim.fault.CustomizationFault: ../vim/fault/CustomizationFault.rst
+
+.. _vim.fault.UncustomizableGuest: ../vim/fault/UncustomizableGuest.rst
+
+.. _vim.fault.CannotDecryptPasswords: ../vim/fault/CannotDecryptPasswords.rst
+
+.. _vim.fault.MissingLinuxCustResources: ../vim/fault/MissingLinuxCustResources.rst
+
+.. _vim.fault.MissingWindowsCustResources: ../vim/fault/MissingWindowsCustResources.rst
+
+
+vim.CustomizationSpecManager
+============================
+  The CustomizationSpecManager managed object is used to manage customization specifications stored on the VirtualCenter server.
+
+
+
+
+Attributes
+----------
+    info (`vim.CustomizationSpecInfo`_):
+      privilege: VirtualMachine.Provisioning.ReadCustSpecs
+       Gets a list of information on available specifications.
+    encryptionKey (`int`_):
+      privilege: System.View
+       Gets a binary public encryption key that can be used to encrypt passwords in stored specifications.
+
+
+Methods
+-------
+
+
+DoesCustomizationSpecExist(name):
+   Whether or not a specification exists.
+
+
+  Privilege:
+               VirtualMachine.Provisioning.ReadCustSpecs
+
+
+
+  Args:
+    name (`str`_):
+
+
+
+
+  Returns:
+    `bool`_:
+         
+
+
+GetCustomizationSpec(name):
+   Obtains a specification for the given name.
+
+
+  Privilege:
+               VirtualMachine.Provisioning.ReadCustSpecs
+
+
+
+  Args:
+    name (`str`_):
+       Unique name identifying the requested customization specification.
+
+
+
+
+  Returns:
+    `vim.CustomizationSpecItem`_:
+         
+
+  Raises:
+
+    `vim.fault.NotFound`_: 
+       vim.fault.NotFound
+
+
+CreateCustomizationSpec(item):
+   Creates a new specification.
+
+
+  Privilege:
+               VirtualMachine.Provisioning.ModifyCustSpecs
+
+
+
+  Args:
+    item (`vim.CustomizationSpecItem`_):
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vim.fault.CustomizationFault`_: 
+       vim.fault.CustomizationFault
+
+    `vim.fault.AlreadyExists`_: 
+       vim.fault.AlreadyExists
+
+    `vim.fault.CannotDecryptPasswords`_: 
+       vim.fault.CannotDecryptPasswords
+
+
+OverwriteCustomizationSpec(item):
+   Overwrites an existing specification, possibly after retrieving (by using 'get') and editing it. If, based on the item's changeVersion value, the overwrite process detects that the specification has changed since its retrieval, then the API uses the SpecModified exception to warn the client that he might overwrite another client's change.
+
+
+  Privilege:
+               VirtualMachine.Provisioning.ModifyCustSpecs
+
+
+
+  Args:
+    item (`vim.CustomizationSpecItem`_):
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vim.fault.CustomizationFault`_: 
+       vim.fault.CustomizationFault
+
+    `vim.fault.NotFound`_: 
+       vim.fault.NotFound
+
+    `vim.fault.ConcurrentAccess`_: 
+       vim.fault.ConcurrentAccess
+
+    `vim.fault.CannotDecryptPasswords`_: 
+       vim.fault.CannotDecryptPasswords
+
+
+DeleteCustomizationSpec(name):
+   Deletes a specification.
+
+
+  Privilege:
+               VirtualMachine.Provisioning.ModifyCustSpecs
+
+
+
+  Args:
+    name (`str`_):
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vim.fault.NotFound`_: 
+       vim.fault.NotFound
+
+
+DuplicateCustomizationSpec(name, newName):
+   Duplicates a specification.
+
+
+  Privilege:
+               VirtualMachine.Provisioning.ModifyCustSpecs
+
+
+
+  Args:
+    name (`str`_):
+
+
+    newName (`str`_):
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vim.fault.NotFound`_: 
+       vim.fault.NotFound
+
+    `vim.fault.AlreadyExists`_: 
+       vim.fault.AlreadyExists
+
+
+RenameCustomizationSpec(name, newName):
+   Renames a specification.
+
+
+  Privilege:
+               VirtualMachine.Provisioning.ModifyCustSpecs
+
+
+
+  Args:
+    name (`str`_):
+
+
+    newName (`str`_):
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vim.fault.NotFound`_: 
+       vim.fault.NotFound
+
+    `vim.fault.AlreadyExists`_: 
+       vim.fault.AlreadyExists
+
+
+CustomizationSpecItemToXml(item):
+   Converts a specification item to XML text
+
+
+  Privilege:
+               System.View
+
+
+
+  Args:
+    item (`vim.CustomizationSpecItem`_):
+
+
+
+
+  Returns:
+    `str`_:
+         
+
+
+XmlToCustomizationSpecItem(specItemXml):
+   Converts an XML string to a specification item
+
+
+  Privilege:
+               System.View
+
+
+
+  Args:
+    specItemXml (`str`_):
+
+
+
+
+  Returns:
+    `vim.CustomizationSpecItem`_:
+         
+
+  Raises:
+
+    `vim.fault.CustomizationFault`_: 
+       vim.fault.CustomizationFault
+
+
+CheckCustomizationResources(guestOs):
+   Validate that required resources are available on the server to customize a particular guest operating system. These would include sysprep for Windows and the debugfs and changefs volume editors for Linux guests.
+
+
+  Privilege:
+               System.View
+
+
+
+  Args:
+    guestOs (`str`_):
+       Short name from the guest OS descriptor list describing the OS we intend to customize.
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vim.fault.CustomizationFault`_: 
+       vim.fault.CustomizationFault
+
+    `vim.fault.MissingLinuxCustResources`_: 
+       vim.fault.MissingLinuxCustResources
+
+    `vim.fault.MissingWindowsCustResources`_: 
+       vim.fault.MissingWindowsCustResources
+
+    `vim.fault.UncustomizableGuest`_: 
+       vim.fault.UncustomizableGuest
+
+

docs/vim/Datacenter.rst

@@ -0,0 +1,268 @@
+.. _int: https://docs.python.org/2/library/stdtypes.html
+
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _host: ../vim/vm/ConfigOptionDescriptor.rst#host
+
+.. _Network: ../vim/Network.rst
+
+.. _template: ../vim/vm/ConfigInfo.rst#template
+
+.. _vim.Task: ../vim/Task.rst
+
+.. _VirtualApp: ../vim/VirtualApp.rst
+
+.. _vim.Folder: ../vim/Folder.rst
+
+.. _VI API 2.5: ../vim/version.rst#vimversionversion2
+
+.. _vim.Network: ../vim/Network.rst
+
+.. _ResourcePool: ../vim/ResourcePool.rst
+
+.. _vim.Datastore: ../vim/Datastore.rst
+
+.. _VirtualMachine: ../vim/VirtualMachine.rst
+
+.. _vSphere API 5.1: ../vim/version.rst#vimversionversion8
+
+.. _vSphere API 4.0: ../vim/version.rst#vimversionversion5
+
+.. _vim.fault.NoHost: ../vim/fault/NoHost.rst
+
+.. _vim.ManagedEntity: ../vim/ManagedEntity.rst
+
+.. _vim.VirtualMachine: ../vim/VirtualMachine.rst
+
+.. _vim.host.ConnectInfo: ../vim/host/ConnectInfo.rst
+
+.. _vim.option.OptionValue: ../vim/option/OptionValue.rst
+
+.. _vim.fault.InvalidLogin: ../vim/fault/InvalidLogin.rst
+
+.. _vmodl.fault.NotSupported: ../vmodl/fault/NotSupported.rst
+
+.. _vim.fault.SSLVerifyFault: ../vim/fault/SSLVerifyFault.rst
+
+.. _DistributedVirtualSwitch: ../vim/DistributedVirtualSwitch.rst
+
+.. _vim.Datacenter.ConfigSpec: ../vim/Datacenter/ConfigSpec.rst
+
+.. _defaultHardwareVersionKey: ../vim/Datacenter/ConfigSpec.rst#defaultHardwareVersionKey
+
+.. _vim.Datacenter.ConfigInfo: ../vim/Datacenter/ConfigInfo.rst
+
+.. _vim.fault.SSLDisabledFault: ../vim/fault/SSLDisabledFault.rst
+
+.. _vim.fault.AlreadyConnected: ../vim/fault/AlreadyConnected.rst
+
+.. _vim.fault.NotSupportedHost: ../vim/fault/NotSupportedHost.rst
+
+.. _vim.fault.HostConnectFault: ../vim/fault/HostConnectFault.rst
+
+.. _DistributedVirtualPortgroup: ../vim/dvs/DistributedVirtualPortgroup.rst
+
+.. _vmodl.fault.InvalidArgument: ../vmodl/fault/InvalidArgument.rst
+
+.. _vim.cluster.PowerOnVmResult: ../vim/cluster/PowerOnVmResult.rst
+
+.. _vim.vm.ConfigOptionDescriptor: ../vim/vm/ConfigOptionDescriptor.rst
+
+
+vim.Datacenter
+==============
+  The `Datacenter`_ managed object provides the interface to the common container object for hosts, virtual machines, networks, and datastores. These entities must be under a distinct datacenter in the inventory, and datacenters may not be nested under other datacenters.Every `Datacenter`_ has the following set of dedicated folders. These folders are empty until you create entities for the Datacenter.
+   * A folder for
+   * `VirtualMachine`_
+   * , template, and
+   * `VirtualApp`_
+   * objects.
+   * A folder for a
+   * `ComputeResource`_
+   * hierarchy.
+   * A folder for
+   * `Network`_
+   * ,
+   * `DistributedVirtualSwitch`_
+   * , and
+   * `DistributedVirtualPortgroup`_
+   * objects.
+   * A folder for
+   * `Datastore`_
+   * objects.
+   * 
+   * For a visual representation of the organization of objects in a vCenter hierarchy, see the description of the
+   * `ServiceInstance`_
+   * object.
+
+
+:extends: vim.ManagedEntity_
+
+
+Attributes
+----------
+    vmFolder (`vim.Folder`_):
+      privilege: System.View
+       A reference to the folder hierarchy that contains `VirtualMachine`_ virtual machine templates (identified by the `template`_ property, and `VirtualApp`_ objects for this datacenter.Note that a VirtualApp that is a child of a `ResourcePool`_ may also be visible in this folder. VirtualApp objects can be nested, but only the parent VirtualApp can be visible in the folder.This folder is guaranteed to exist.
+    hostFolder (`vim.Folder`_):
+      privilege: System.View
+       A reference to the folder hierarchy that contains the compute resources, including hosts and clusters, for this datacenter.This folder is guaranteed to exist.
+    datastoreFolder (`vim.Folder`_):
+      privilege: System.View
+       A reference to the folder hierarchy that contains the datastores for this datacenter.This folder is guaranteed to exist.
+    networkFolder (`vim.Folder`_):
+      privilege: System.View
+       A reference to the folder hierarchy that contains the network entities for this datacenter. The folder can include `Network`_ , `DistributedVirtualSwitch`_ , and `DistributedVirtualPortgroup`_ objects.This folder is guaranteed to exist.
+    datastore (`vim.Datastore`_):
+       A collection of references to the datastore objects available in this datacenter.
+    network (`vim.Network`_):
+       A collection of references to the network objects available in this datacenter.
+    configuration (`vim.Datacenter.ConfigInfo`_):
+      privilege: System.View
+       Configuration of the datacenter.
+
+
+Methods
+-------
+
+
+QueryConnectionInfo(hostname, port, username, password, sslThumbprint):
+   This method provides a way of getting basic information about a host without adding it to a datacenter. Connection wizards typically use this method to show information about a host so a user can confirm a set of changes before applying them.
+
+
+  Privilege:
+               System.View
+
+
+
+  Args:
+    hostname (`str`_):
+       The target of the query.
+
+
+    port (`int`_):
+       The port number of the target host. For ESX 2.x this is the authd port (902 by default). For ESX 3.x and above and for VMware Server hosts this is the https port (443 by default). You can specify -1 to have the vCenter Server try the default ports.
+
+
+    username (`str`_):
+       The name of the user.
+
+
+    password (`str`_):
+       The password of the user.
+
+
+    sslThumbprint (`str`_, optional, since `VI API 2.5`_ ):
+       The expected SSL thumbprint of the host's certificate
+
+
+
+
+  Returns:
+    `vim.host.ConnectInfo`_:
+         
+
+  Raises:
+
+    `vim.fault.InvalidLogin`_: 
+       if unable to authenticate with the host.
+
+    `vim.fault.HostConnectFault`_: 
+       if an error occurred when querying about a host. Typically, a more specific subclass, such as AlreadyBeingManaged, is thrown.
+
+    `vmodl.fault.NotSupported`_: 
+       if called directly on a host.
+
+    `vim.fault.NoHost`_: 
+       if unable to contact the host.
+
+    `vim.fault.NotSupportedHost`_: 
+       if the software version on the host is not supported.
+
+    `vim.fault.AlreadyConnected`_: 
+       if the host is already being managed by this server.
+
+    `vim.fault.SSLDisabledFault`_: 
+       if the host has ssl access disabled
+
+    `vim.fault.SSLVerifyFault`_: 
+       if the host certificate could not be authenticated
+
+
+PowerOnMultiVM(vm, option):
+   Powers on multiple virtual machines in a data center. If the virtual machines are suspended, this method resumes execution from the suspend point. The virtual machines can belong to different clusters in the data center.If any virtual machine in the list is manually managed by DRS, or DRS has to migrate any manually managed virtual machine or power on any manually managed host in order to power on these virtual machines, a DRS recommendation will be generated, and the users need to manually apply the recommendation for actually powering on these virtual machines. Otherwise, all the virtual machine will be automatically powered on. The virtual machines on stand alone hosts or DRS disabled will be powered-on on the current host. The DRS automatically managed virtual machines will be powered-on on the recommended hosts.When powering on a virtual machine in a cluster, the system might do an implicit relocation of the virtual machine to another host.
+  since: `VI API 2.5`_
+
+
+  Privilege:
+               System.View
+
+
+
+  Args:
+    vm (`vim.VirtualMachine`_):
+       The virtual machines to power on.
+
+
+    option (`vim.option.OptionValue`_, optional, since `vSphere API 4.1`_ ):
+       An array of `OptionValue`_ options for this power-on session. The names and values of the options are defined in `ClusterPowerOnVmOption`_ .
+
+
+
+
+  Returns:
+     `vim.Task`_:
+         An array of Recommendation.
+
+  Raises:
+
+    `vmodl.fault.InvalidArgument`_: 
+       for unknown option keys or bad values.
+
+
+queryDatacenterConfigOptionDescriptor():
+   The list of possible choices for `defaultHardwareVersionKey`_ . Descriptors returned by the vCenter implementation do not have `host`_ field populated.
+  since: `vSphere API 5.1`_
+
+
+  Privilege:
+               System.View
+
+
+
+  Args:
+
+
+  Returns:
+    `vim.vm.ConfigOptionDescriptor`_:
+         
+
+
+ReconfigureDatacenter(spec, modify):
+   Change the datacenter configuration.
+  since: `vSphere API 5.1`_
+
+
+  Privilege:
+               Datacenter.Reconfigure
+
+
+
+  Args:
+    spec (`vim.Datacenter.ConfigSpec`_):
+       A set of configuration changes to apply to the datacenter. The specification can be a complete set of changes or a partial set of changes, applied incrementally.
+
+
+    modify (`bool`_):
+       Flag to specify whether the specification ("spec") should be applied incrementally. If "modify" is false and the operation succeeds, then the configuration of the datacenter matches the specification exactly; in this case any unset portions of the specification will result in unset or default portions of the configuration.
+
+
+
+
+  Returns:
+     `vim.Task`_:
+         
+
+

docs/vim/Datacenter/ConfigInfo.rst

@@ -0,0 +1,21 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _vSphere API 5.1: ../../vim/version.rst#vimversionversion8
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+.. _environmentBrowser: ../../vim/ComputeResource.rst#environmentBrowser
+
+.. _defaultConfigOption: ../../vim/vm/ConfigOptionDescriptor.rst#defaultConfigOption
+
+
+vim.Datacenter.ConfigInfo
+=========================
+  Configuration of the datacenter.
+:extends: vmodl.DynamicData_
+:since: `vSphere API 5.1`_
+
+Attributes:
+    defaultHardwareVersionKey (`str`_, optional):
+
+       Key for Default Hardware Version used on this datacenter in the format of `key`_ . This field affects `defaultConfigOption`_ returned by `environmentBrowser`_ of all its children with this field unset.

docs/vim/Datacenter/ConfigSpec.rst

@@ -0,0 +1,21 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _vSphere API 5.1: ../../vim/version.rst#vimversionversion8
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+.. _environmentBrowser: ../../vim/ComputeResource.rst#environmentBrowser
+
+.. _defaultConfigOption: ../../vim/vm/ConfigOptionDescriptor.rst#defaultConfigOption
+
+
+vim.Datacenter.ConfigSpec
+=========================
+  Changes to apply to the datacenter configuration.
+:extends: vmodl.DynamicData_
+:since: `vSphere API 5.1`_
+
+Attributes:
+    defaultHardwareVersionKey (`str`_, optional):
+
+       Key for Default Hardware Version to be used on this datacenter in the format of `key`_ . Setting this field affects `defaultConfigOption`_ returned by `environmentBrowser`_ of all its children with this field unset.

docs/vim/Datastore.rst

@@ -0,0 +1,284 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _Task: ../vim/Task.rst
+
+.. _info: ../vim/Datastore.rst#info
+
+.. _summary: ../vim/Datastore.rst#summary
+
+.. _vim.Task: ../vim/Task.rst
+
+.. _accessible: ../vim/host/MountInfo.rst#accessible
+
+.. _vSphere API 5.0: ../vim/version.rst#vimversionversion7
+
+.. _vSphere API 4.0: ../vim/version.rst#vimversionversion5
+
+.. _vSphere API 4.1: ../vim/version.rst#vimversionversion6
+
+.. _vim.ManagedEntity: ../vim/ManagedEntity.rst
+
+.. _vim.VirtualMachine: ../vim/VirtualMachine.rst
+
+.. _vim.Datastore.Info: ../vim/Datastore/Info.rst
+
+.. _vim.fault.NotFound: ../vim/fault/NotFound.rst
+
+.. _vim.Datastore.Summary: ../vim/Datastore/Summary.rst
+
+.. _vim.fault.InvalidName: ../vim/fault/InvalidName.rst
+
+.. _vim.fault.InvalidState: ../vim/fault/InvalidState.rst
+
+.. _StoragePlacementResult: ../vim/storageDrs/StoragePlacementResult.rst
+
+.. _vim.fault.ResourceInUse: ../vim/fault/ResourceInUse.rst
+
+.. _vim.Datastore.HostMount: ../vim/Datastore/HostMount.rst
+
+.. _vim.fault.DuplicateName: ../vim/fault/DuplicateName.rst
+
+.. _vim.fault.TaskInProgress: ../vim/fault/TaskInProgress.rst
+
+.. _vmodl.fault.NotSupported: ../vmodl/fault/NotSupported.rst
+
+.. _vim.Datastore.Capability: ../vim/Datastore/Capability.rst
+
+.. _vim.fault.HostConfigFault: ../vim/fault/HostConfigFault.rst
+
+.. _vim.host.DatastoreBrowser: ../vim/host/DatastoreBrowser.rst
+
+.. _vim.fault.InvalidDatastore: ../vim/fault/InvalidDatastore.rst
+
+.. _vmodl.fault.RequestCanceled: ../vmodl/fault/RequestCanceled.rst
+
+.. _vmodl.fault.InvalidArgument: ../vmodl/fault/InvalidArgument.rst
+
+.. _ConfigureDatastoreIORM_Task: ../vim/StorageResourceManager.rst#ConfigureDatastoreIORM
+
+.. _vim.fault.PlatformConfigFault: ../vim/fault/PlatformConfigFault.rst
+
+.. _vim.UpdateVirtualMachineFilesResult: ../vim/UpdateVirtualMachineFilesResult.rst
+
+.. _vim.Datastore.MountPathDatastorePair: ../vim/Datastore/MountPathDatastorePair.rst
+
+.. _vim.storageDrs.StoragePlacementResult: ../vim/storageDrs/StoragePlacementResult.rst
+
+.. _vim.StorageResourceManager.IORMConfigInfo: ../vim/StorageResourceManager/IORMConfigInfo.rst
+
+
+vim.Datastore
+=============
+  Represents a storage location for virtual machine files. A storage location can be a VMFS volume, a directory on Network Attached Storage, or a local file system path.A datastore is platform-independent and host-independent. Therefore, datastores do not change when the virtual machines they contain are moved between hosts. The scope of a datastore is a datacenter; the datastore is uniquely named within the datacenter.Any reference to a virtual machine or file accessed by any host within the datacenter must use a datastore path. A datastore path has the form "[datastore]path", wheredatastoreis the datastore name, andpathis a slash-delimited path from the root of the datastore. An example datastore path is "[storage] path/to/config.vmx".You may use the following characters in a path, but not in a datastore name: slash (/), backslash (\), and percent (%).All references to files in the VIM API are implicitly done using datastore paths.When a client creates a virtual machine, it may specify the name of the datastore, omitting the path; the system, meaning VirtualCenter or the host, automatically assigns filenames and creates directories on the given datastore. For example, specifying My_Datastore as a location for a virtual machine called MyVm results in a datastore location of My_Datastore\MyVm\MyVm.vmx.Datastores are configured per host. As part of host configuration, a HostSystem can be configured to mount a set of network drives. Multiple hosts may be configured to point to the same storage location. There exists only one Datastore object per Datacenter, for each such shared location. Each Datastore object keeps a reference to the set of hosts that have mounted the datastore. A Datastore object can be removed only if no hosts currently have the datastore mounted.Thus, managing datastores is done both at the host level and the datacenter level. Each host is configured explicitly with the set of datastores it can access. At the datacenter, a view of the datastores across the datacenter is shown.
+
+
+:extends: vim.ManagedEntity_
+
+
+Attributes
+----------
+    info (`vim.Datastore.Info`_):
+       Specific information about the datastore.
+    summary (`vim.Datastore.Summary`_):
+       Global properties of the datastore.
+    host (`vim.Datastore.HostMount`_):
+       Hosts attached to this datastore.
+    vm (`vim.VirtualMachine`_):
+       Virtual machines stored on this datastore.
+    browser (`vim.host.DatastoreBrowser`_):
+       DatastoreBrowser used to browse this datastore.
+    capability (`vim.Datastore.Capability`_):
+       Capabilities of this datastore.
+    iormConfiguration (`vim.StorageResourceManager.IORMConfigInfo`_):
+       Configuration of storage I/O resource management for the datastore. Currently we only support storage I/O resource management on VMFS volumes of a datastore.This configuration may not be available if the datastore is not accessible from any host, or if the datastore does not have VMFS volume. The configuration can be modified using the method `ConfigureDatastoreIORM_Task`_ 
+
+
+Methods
+-------
+
+
+RefreshDatastore():
+   Explicitly refreshes free-space and capacity values in `summary`_ and `info`_ .
+
+
+  Privilege:
+               System.Read
+
+
+
+  Args:
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vim.fault.NotFound`_: 
+       if the datastore or its underlying volume is not found.
+
+    `vim.fault.HostConfigFault`_: 
+       if unable to get the current system information for the datastore.
+
+
+RefreshDatastoreStorageInfo():
+   Refreshes all storage related information including free-space, capacity, and detailed usage of virtual machines. Updated values are available in `summary`_ and `info`_ .
+  since: `vSphere API 4.0`_
+
+
+  Privilege:
+               System.Read
+
+
+
+  Args:
+
+
+  Returns:
+    None
+         
+
+
+UpdateVirtualMachineFiles(mountPathDatastoreMapping):
+   Update file paths embedded in virtual machine files on the datastore. This can be called after the file system corresponding to the datastore has been resignatured or remounted. Any MountPathDatastorePairs where the new path is the same as the original file path will be ignored.This method is only supported by vCenter server. Also, this method requires that the datastore is `accessible`_ from at least one host (ESX version 4.1 or above) in vCenter server.While this operation is in progress, it is important that users do not initiate any operations that might read or write to any files on the datastore, such as registering a virtual machine with files residing on the datastore, or performing any virtual disk operations on any files in the datastore. These operations can potentially cause spurious file update failures, while at the same time they can prevent virtual machine files from being updated correctly.If users intend to update multiple datastores using this method, it is strongly advised that the users do not initiate any operations that might read or write to files on any of the datastores, until all of them have been updated. The files of a single virtual machine can reside on multiple datastores, and thus all the involved datastores should be updated, before the virtual machine is considered updated completely.
+  since: `vSphere API 4.1`_
+
+
+  Privilege:
+               Datastore.UpdateVirtualMachineFiles
+
+
+
+  Args:
+    mountPathDatastoreMapping (`vim.Datastore.MountPathDatastorePair`_):
+       Old mount path to datastore mapping.
+
+
+
+
+  Returns:
+     `vim.Task`_:
+         Return an array of failed virtual machine file info. When there are too many failed files, only a subset of failed files will be returned.
+
+  Raises:
+
+    `vim.fault.ResourceInUse`_: 
+       if there exists a registered virtual machine in the volume.
+
+    `vim.fault.PlatformConfigFault`_: 
+       if any error related to platform occurs during the operation.
+
+    `vim.fault.TaskInProgress`_: 
+       if the datastore is busy, for example, while another task is updating the datastore after volume resignaturing or remounting.
+
+    `vim.fault.InvalidDatastore`_: 
+       if the operation cannot be performed due to some error with the datastore; typically a specific subclass of the fault is reported.
+
+    `vmodl.fault.InvalidArgument`_: 
+       if old mount path is mapped to more than one datastores, or if any of the datastore being mapped can not be found.
+
+    `vmodl.fault.NotSupported`_: 
+       if all hosts attached to this datastore do not support updating virtual machine files.
+
+
+RenameDatastore(newName):
+   Renames a datastore.
+
+
+  Privilege:
+               Datastore.Rename
+
+
+
+  Args:
+    newName (`str`_):
+       The new name to assign to the datastore.
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vim.fault.DuplicateName`_: 
+       if another datastore in this datacenter already has the same name.
+
+    `vim.fault.InvalidName`_: 
+       if the name is not a valid datastore name.
+
+
+DestroyDatastore():
+   Removes a datastore. A datastore can be removed only if it is not currently used by any host or virtual machine.
+
+
+  Privilege:
+               Datastore.Delete
+
+
+
+  Args:
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vim.fault.ResourceInUse`_: 
+       if one or more hosts or virtual machines are configured to use the datastore.
+
+
+DatastoreEnterMaintenanceMode():
+   Puts the datastore in maintenance mode. While this task is running and when the datastore is in maintenance mode, no virtual machines can be powered on and no provisioning operations can be performed on the datastore. Once the call completes, it is safe to remove datastore without disrupting any virtual machines.The task completes once there are no virtual machines on the datastore and no provisioning operations in progress on the datastore. The operation does not directly initiate any operations to evacuate or power-down powered-on virtual machines. However, if the datastore is part of a storage pod with VMware Storage DRS enabled, Storage DRS provides migration recommendations to evacuate the virtual machines. If Storage DRS is in fully-automatic mode, these are automatically scheduled. The task is cancellable. This method returns a `StoragePlacementResult`_ object, which includes a `Task`_ object with which to monitor the operation, and a list of recommendations and faults generated by Storage DRS when it tries to evacuate the virtual machines on the datastore. The recommendations and faults fields are set only if the datastore is a part of a storage pod with Storage DRS enabled.
+  since: `vSphere API 5.0`_
+
+
+  Privilege:
+               Datastore.Config
+
+
+
+  Args:
+
+
+  Returns:
+    `vim.storageDrs.StoragePlacementResult`_:
+         
+
+  Raises:
+
+    `vim.fault.InvalidState`_: 
+       if the datastore is already in maintenance mode.
+
+    `vmodl.fault.RequestCanceled`_: 
+       if the operation is canceled.
+
+
+DatastoreExitMaintenanceMode():
+   Takes the datastore out of maintenance mode.The task is cancellable.
+  since: `vSphere API 5.0`_
+
+
+  Privilege:
+               Datastore.Config
+
+
+
+  Args:
+
+
+  Returns:
+     `vim.Task`_:
+         
+
+  Raises:
+
+    `vim.fault.InvalidState`_: 
+       if the datastore is not in maintenance mode.
+
+

docs/vim/Datastore/Accessible.rst

@@ -0,0 +1,20 @@
+.. _vim.Datastore: ../../vim/Datastore.rst
+
+.. _vim.Datastore.Accessible: ../../vim/Datastore/Accessible.rst
+
+vim.Datastore.Accessible
+========================
+  :contained by: `vim.Datastore`_
+
+  :type: `vim.Datastore.Accessible`_
+
+  :name: False
+
+values:
+--------
+
+False
+   Is not accessible
+
+True
+   Is accessible

docs/vim/Datastore/Capability.rst

@@ -0,0 +1,34 @@
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+.. _DatastoreNamespaceManager: ../../vim/DatastoreNamespaceManager.rst
+
+
+vim.Datastore.Capability
+========================
+  Information about the capabilities of this datastore.
+:extends: vmodl.DynamicData_
+
+Attributes:
+    directoryHierarchySupported (`bool`_):
+
+       Indicates whether or not directories can be created on this datastore.
+    rawDiskMappingsSupported (`bool`_):
+
+       Indicates whether or not raw disk mappings can be created on this datastore.
+    perFileThinProvisioningSupported (`bool`_):
+
+       Indicates whether or not the datastore supports thin provisioning on a per file basis. When thin provisioning is used, backing storage is lazily allocated.This is supported by VMFS3. VMFS2 always allocates storage eagerly. Thus, this value is false for VMFS2. Most NAS systems always use thin provisioning. They do not support configuring this on a per file basis, so for NAS systems this value is also false.
+    storageIORMSupported (`bool`_):
+
+       Indicates whether the datastore supports Storage I/O Resource Management.
+    nativeSnapshotSupported (`bool`_):
+
+       Indicates whether the datastore supports native snapshot feature which is based on Copy-On-Write.
+    topLevelDirectoryCreateSupported (`bool`_, optional):
+
+       Indicates whether the datastore supports traditional top-level directory creation.See `DatastoreNamespaceManager`_ 
+    seSparseSupported (`bool`_, optional):
+
+       Indicates whether the datastore supports the Flex-SE(SeSparse) feature.

docs/vim/Datastore/HostMount.rst

@@ -0,0 +1,19 @@
+.. _vim.HostSystem: ../../vim/HostSystem.rst
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+.. _vim.host.MountInfo: ../../vim/host/MountInfo.rst
+
+
+vim.Datastore.HostMount
+=======================
+  Host-specific datastore information.
+:extends: vmodl.DynamicData_
+
+Attributes:
+    key (`vim.HostSystem`_):
+
+       The host associated with this datastore.
+    mountInfo (`vim.host.MountInfo`_):
+
+       Host-specific information about the mount.

docs/vim/Datastore/Info.rst

@@ -0,0 +1,46 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _long: https://docs.python.org/2/library/stdtypes.html
+
+.. _datetime: https://docs.python.org/2/library/stdtypes.html
+
+.. _DatastoreInfo: ../../vim/Datastore/Info.rst
+
+.. _HostNasVolume: ../../vim/host/NasVolume.rst
+
+.. _HostVmfsVolume: ../../vim/host/VmfsVolume.rst
+
+.. _DatastoreSummary: ../../vim/Datastore/Summary.rst
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+.. _HostLocalFileSystemVolume: ../../vim/host/LocalFileSystemVolume.rst
+
+
+vim.Datastore.Info
+==================
+  Detailed information about a datastore. This is a base type for derived types that have more specific details about a datastore.See `HostVmfsVolume`_ See `HostNasVolume`_ See `HostLocalFileSystemVolume`_ 
+:extends: vmodl.DynamicData_
+
+Attributes:
+    name (`str`_):
+
+       The name of the datastore.
+    url (`str`_):
+
+       The unique locator for the datastore.
+    freeSpace (`long`_):
+
+       Free space of this datastore, in bytes. The server periodically updates this value. It can be explicitly refreshed with the Refresh operation.
+    maxFileSize (`long`_):
+
+       The maximum size of a file that can reside on this file system volume.
+    maxVirtualDiskCapacity (`long`_, optional):
+
+       The maximum capacity of a virtual disk which can be created on this volume.
+    timestamp (`datetime`_, optional):
+
+       Time when the free-space and capacity values in `DatastoreInfo`_ and `DatastoreSummary`_ were updated.
+    containerId (`str`_, optional):
+
+       The unique container ID of the datastore, if applicable.

docs/vim/Datastore/MountPathDatastorePair.rst

@@ -0,0 +1,26 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _path: ../../vim/host/MountInfo.rst#path
+
+.. _HostMountInfo: ../../vim/host/MountInfo.rst
+
+.. _vim.Datastore: ../../vim/Datastore.rst
+
+.. _vSphere API 4.1: ../../vim/version.rst#vimversionversion6
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+
+vim.Datastore.MountPathDatastorePair
+====================================
+  Contains a mapping of an old mount path and its corresponding resignatured or remounted datastore
+:extends: vmodl.DynamicData_
+:since: `vSphere API 4.1`_
+
+Attributes:
+    oldMountPath (`str`_):
+
+       Old file path where file system volume is mounted, which should be `path`_ value in `HostMountInfo`_ 
+    datastore (`vim.Datastore`_):
+
+       The resignatured or remounted datastore corresponding to the oldMountPath

docs/vim/Datastore/Summary.rst

@@ -0,0 +1,59 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _long: https://docs.python.org/2/library/stdtypes.html
+
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _type: ../../vim/host/FileSystemVolume.rst#type
+
+.. _accessible: ../../vim/Datastore/Summary.rst#accessible
+
+.. _DatastoreInfo: ../../vim/Datastore/Info.rst
+
+.. _vim.Datastore: ../../vim/Datastore.rst
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+.. _inaccessibleReason: ../../vim/host/MountInfo.rst#inaccessibleReason
+
+.. _RefreshDatastoreStorageInfo: ../../vim/Datastore.rst#refreshStorageInfo
+
+.. _DatastoreSummaryMaintenanceModeState: ../../vim/Datastore/Summary/MaintenanceModeState.rst
+
+
+vim.Datastore.Summary
+=====================
+  Summary information about the datastore. The status fields and managed object reference is not set when an object of this type is created. These fields and references are typically set later when these objects are associated with a host.
+:extends: vmodl.DynamicData_
+
+Attributes:
+    datastore (`vim.Datastore`_, optional):
+
+       The reference to the managed object.
+    name (`str`_):
+
+       The name of the datastore.
+    url (`str`_):
+
+       The unique locator for the datastore. This property is guaranteed to be valid only if `accessible`_ is true.
+    capacity (`long`_):
+
+       Maximum capacity of this datastore, in bytes. This value is updated periodically by the server. It can be explicitly refreshed with the Refresh operation. This property is guaranteed to be valid only if `accessible`_ is true.
+    freeSpace (`long`_):
+
+       Available space of this datastore, in bytes. The server periodically updates this value. It can be explicitly refreshed with the Refresh operation. This property is guaranteed to be valid only if `accessible`_ is true.
+    uncommitted (`long`_, optional):
+
+       Total additional storage space, in bytes, potentially used by all virtual machines on this datastore. The server periodically updates this value. It can be explicitly refreshed with the `RefreshDatastoreStorageInfo`_ operation. This property is valid only if `accessible`_ is true.
+    accessible (`bool`_):
+
+       The connectivity status of this datastore. If this is set to false, meaning the datastore is not accessible, this datastore's capacity and freespace properties cannot be validated. Furthermore, if this property is set to false, some of the properties in this summary and in `DatastoreInfo`_ should not be used. Refer to the documentation for the property of your interest. For datastores accessed from multiple hosts, vCenter Server reports `accessible`_ as an aggregated value of the properties reported in MountInfo. For instance, if a datastore is accessible through a subset of hosts, then the value of `accessible`_ will be reported as true by vCenter Server. And the reason for a daastore being inaccessible from a host will be reported in `inaccessibleReason`_ 
+    multipleHostAccess (`bool`_, optional):
+
+       More than one host in the datacenter has been configured with access to the datastore. This is only provided by VirtualCenter.
+    type (`str`_):
+
+       Type of file system volume, such as VMFS or NFS.See `type`_ 
+    maintenanceMode (`str`_, optional):
+
+       The current maintenance mode state of the datastore. The set of possible values is described in `DatastoreSummaryMaintenanceModeState`_ .

docs/vim/Datastore/Summary/MaintenanceModeState.rst

@@ -0,0 +1,24 @@
+.. _vim.Datastore.Summary: ../../../vim/Datastore/Summary.rst
+
+.. _vim.Datastore.Summary.MaintenanceModeState: ../../../vim/Datastore/Summary/MaintenanceModeState.rst
+
+vim.Datastore.Summary.MaintenanceModeState
+==========================================
+  Defines the current maintenance mode state of the datastore.
+  :contained by: `vim.Datastore.Summary`_
+
+  :type: `vim.Datastore.Summary.MaintenanceModeState`_
+
+  :name: inMaintenance
+
+values:
+--------
+
+inMaintenance
+   Successfully entered maintenance mode.
+
+enteringMaintenance
+   Started entering maintenance mode, but not finished. This could happen when waiting for user input or for long-running vmotions to complete.
+
+normal
+   Default state.

docs/vim/DatastoreNamespaceManager.rst

@@ -0,0 +1,122 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _vim.Task: ../vim/Task.rst
+
+.. _vim.Datastore: ../vim/Datastore.rst
+
+.. _vim.Datacenter: ../vim/Datacenter.rst
+
+.. _DeleteDirectory: ../vim/DatastoreNamespaceManager.rst#DeleteDirectory
+
+.. _vSphere API 5.5: ../vim/version.rst#vimversionversion9
+
+.. _CreateDirectory: ../vim/DatastoreNamespaceManager.rst#CreateDirectory
+
+.. _vim.fault.FileFault: ../vim/fault/FileFault.rst
+
+.. _vim.fault.FileNotFound: ../vim/fault/FileNotFound.rst
+
+.. _vim.fault.InvalidDatastore: ../vim/fault/InvalidDatastore.rst
+
+.. _vim.fault.CannotCreateFile: ../vim/fault/CannotCreateFile.rst
+
+.. _vim.fault.FileAlreadyExists: ../vim/fault/FileAlreadyExists.rst
+
+.. _vim.fault.InvalidDatastorePath: ../vim/fault/InvalidDatastorePath.rst
+
+
+vim.DatastoreNamespaceManager
+=============================
+  The DatastoreNamespaceManager managed object exposes APIs for manipulating top-level directories of datastores which do not support the traditional top-level directory creation.See `topLevelDirectoryCreateSupported`_ 
+
+
+:since: `vSphere API 5.5`_
+
+
+Attributes
+----------
+
+
+Methods
+-------
+
+
+CreateDirectory(datastore, displayName, policy):
+   Creates a top-level directory on the given datastore, using the given user display name hint and opaque storage policy.The optional given display name hint may be used by the underlying storage system for user display purposes, but it may not be relied upon for future directory references.Clients must use the returned stable path for future directory references.See `DeleteDirectory`_ 
+
+
+  Privilege:
+               Datastore.Config
+
+
+
+  Args:
+    datastore (`vim.Datastore`_):
+       datastore on which to create a top-level directorySee `DeleteDirectory`_ 
+
+
+    displayName (`str`_, optional):
+       display name hint for the directory to createSee `DeleteDirectory`_ 
+
+
+    policy (`str`_, optional):
+       opaque storage policy to associate with the directorySee `DeleteDirectory`_ 
+
+
+
+
+  Returns:
+    `str`_:
+         a stable vmfs path which may be used for future reference of the created directory, of the form/vmfs/volumes/[datastore-uuid]/[directory-uuid]
+
+  Raises:
+
+    `vim.fault.CannotCreateFile`_: 
+       if a general system error occurred while creating directory on the datastoreSee `DeleteDirectory`_ 
+
+    `vim.fault.FileAlreadyExists`_: 
+       if the given directory already existsSee `DeleteDirectory`_ 
+
+    `vim.fault.InvalidDatastore`_: 
+       if the given datastore is not supported by the DatastoreNamespaceManageSee `DeleteDirectory`_ 
+
+
+DeleteDirectory(datacenter, datastorePath):
+   Deletes the given top-level directory from a datastore.The top-level directory must be a full path of the form/vmfs/volumes/[datastore-uuid]/[directory-uuid]as returned by `CreateDirectory`_ .See `CreateDirectory`_ 
+
+
+  Privilege:
+               Datastore.Config
+
+
+
+  Args:
+    datacenter (`vim.Datacenter`_, optional):
+       The datacenter of the datastore path. Needs to be set when making the call to VC; ignored when the call is made to ESX.See `CreateDirectory`_ 
+
+
+    datastorePath (`str`_):
+       Stable vmfs path of the directory to delete.See `CreateDirectory`_ 
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vim.fault.FileFault`_: 
+       if a generic system error happened.See `CreateDirectory`_ 
+
+    `vim.fault.FileNotFound`_: 
+       if the given directory can not be foundSee `CreateDirectory`_ 
+
+    `vim.fault.InvalidDatastore`_: 
+       if the given datastore is not supported by the DatastoreNamespaceManagerSee `CreateDirectory`_ 
+
+    `vim.fault.InvalidDatastorePath`_: 
+       if the given path is not a top-level directorySee `CreateDirectory`_ 
+
+

docs/vim/Description.rst

@@ -0,0 +1,17 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _vmodl.DynamicData: ../vmodl/DynamicData.rst
+
+
+vim.Description
+===============
+  Static strings used for describing an object or property.
+:extends: vmodl.DynamicData_
+
+Attributes:
+    label (`str`_):
+
+       Display label.
+    summary (`str`_):
+
+       Summary description.

docs/vim/DiagnosticManager.rst

@@ -0,0 +1,140 @@
+.. _int: https://docs.python.org/2/library/stdtypes.html
+
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _vim.Task: ../vim/Task.rst
+
+.. _vim.HostSystem: ../vim/HostSystem.rst
+
+.. _vim.fault.TaskInProgress: ../vim/fault/TaskInProgress.rst
+
+.. _vim.fault.CannotAccessFile: ../vim/fault/CannotAccessFile.rst
+
+.. _vmodl.fault.InvalidArgument: ../vmodl/fault/InvalidArgument.rst
+
+.. _vim.fault.LogBundlingFailed: ../vim/fault/LogBundlingFailed.rst
+
+.. _vim.DiagnosticManager.LogHeader: ../vim/DiagnosticManager/LogHeader.rst
+
+.. _vim.DiagnosticManager.BundleInfo: ../vim/DiagnosticManager/BundleInfo.rst
+
+.. _vim.DiagnosticManager.LogDescriptor: ../vim/DiagnosticManager/LogDescriptor.rst
+
+
+vim.DiagnosticManager
+=====================
+  Provides an interface to get low-level debugging logs or diagnostic bundles for a server. For VirtualCenter, this includes the log files for the server daemon. For an ESX Server host, this includes detailed log files for the VMkernel.
+
+
+
+
+Attributes
+----------
+
+
+Methods
+-------
+
+
+QueryDescriptions(host):
+   Returns a list of diagnostic files for a given system.
+
+
+  Privilege:
+               Global.Diagnostics
+
+
+
+  Args:
+    host (`vim.HostSystem`_, optional):
+       Specifies the host. If not specified, then it defaults to the server itself. For example, if called on VirtualCenter, then the value defaults to VirtualCenter logs. When called on an ESX server host, the host should not be specified.
+
+
+
+
+  Returns:
+    `vim.DiagnosticManager.LogDescriptor`_:
+         
+
+  Raises:
+
+    `vmodl.fault.InvalidArgument`_: 
+       if the host does not exist or is specified on a host.
+
+
+BrowseDiagnosticLog(host, key, start, lines):
+   Returns part of a log file. Log entries are always returned chronologically, typically with the newest event last.
+
+
+  Privilege:
+               Global.Diagnostics
+
+
+
+  Args:
+    host (`vim.HostSystem`_, optional):
+       Specifies the host. If not specified, then it defaults to the default server. For example, if called on VirtualCenter, then the value defaults to VirtualCenter logs.
+
+
+    key (`str`_):
+       A string key specifying the key for the log file to browse. Keys can be obtained using the queryDescriptions method.
+
+
+    start (`int`_, optional):
+       The line number for the first entry to be returned. If the parameter is not specified, then the operation returns with lines starting from the top of the log.
+
+
+    lines (`int`_, optional):
+       The number of lines to return. If not specified, then all lines are returned from the start value to the end of the file.
+
+
+
+
+  Returns:
+    `vim.DiagnosticManager.LogHeader`_:
+         A LogHeader that includes the log lines. Sometimes fewer log lines are returned than were requested. For example, fewer lines are returned than expected if the client requests lines that do not exist or if the server limits the number of lines that it returns. If zero lines are returned, then the end of the log file may have been reached.
+
+  Raises:
+
+    `vim.fault.CannotAccessFile`_: 
+       if the key refers to a file that cannot be accessed at the present time.
+
+    `vmodl.fault.InvalidArgument`_: 
+       if the key refers to a nonexistent log file or the log file is not of type "plain".
+
+
+GenerateLogBundles(includeDefault, host):
+   Instructs the server to generate diagnostic bundles. A diagnostic bundle includes log files and other configuration information that can be used to investigate potential server issues. Virtual machine and guest operation system state is excluded from diagnostic bundles.
+
+
+  Privilege:
+               Global.Diagnostics
+
+
+
+  Args:
+    includeDefault (`bool`_):
+       Specifies if the bundle should include the default server. If called on a VirtualCenter server, then this means the VirtualCenter diagnostic files. If called directly on a host, then includeDefault must be set to true.
+
+
+    host (`vim.HostSystem`_, optional):
+       Lists hosts that are included. This is only used when called on VirtualCenter. If called directly on a host, then this parameter must be empty.
+
+
+
+
+  Returns:
+     `vim.Task`_:
+         a list of BundleInfo objects for each diagnostic bundle that has been generated. The list may include no information from some requested hosts. For example, hosts that are disconnected or not responding are ignored.
+
+  Raises:
+
+    `vim.fault.LogBundlingFailed`_: 
+       if generation of support bundle failed.
+
+    `vim.fault.TaskInProgress`_: 
+       if there is a pending request to generate a support bundle.The caller can download the bundles using an HTTP GET operation for each returned URL. Bundles are usually available for at least 24 hours, but the caller should not assume that the returned URLs are valid indefinitely. Servers often automatically delete generated diagnostic bundles after some given period of time.
+
+

docs/vim/DiagnosticManager/BundleInfo.rst

@@ -0,0 +1,19 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _vim.HostSystem: ../../vim/HostSystem.rst
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+
+vim.DiagnosticManager.BundleInfo
+================================
+  Describes a location of a diagnostic bundle and the server to which it belongs. This is a return type for the generateLogBundles operation.
+:extends: vmodl.DynamicData_
+
+Attributes:
+    system (`vim.HostSystem`_, optional):
+
+       The host to which this diagnostic bundle belongs. If this is for the default server, then it is not set.
+    url (`str`_):
+
+       The location from which the diagnostic bundle can be downloaded. The host part of the URL is returned as '*' if the hostname to be used is the name of the server to which the call was made. For example, if the call is made to vcsrv1.domain1.com, and the bundle is available for download from http://vcsrv1.domain1.com/diagnostics/bundle.zip, the URL returned may be http:// * /diagnostics/bundle.zip. The client replaces the asterisk with the server name on which it invoked the call.

docs/vim/DiagnosticManager/LogDescriptor.rst

@@ -0,0 +1,36 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _vim.Description: ../../vim/Description.rst
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+.. _DiagnosticManagerLogFormat: ../../vim/DiagnosticManager/LogDescriptor/Format.rst
+
+.. _DiagnosticManagerLogCreator: ../../vim/DiagnosticManager/LogDescriptor/Creator.rst
+
+
+vim.DiagnosticManager.LogDescriptor
+===================================
+  Describes a log file that is available on a server.
+:extends: vmodl.DynamicData_
+
+Attributes:
+    key (`str`_):
+
+       A key to identify the log file for browsing and download operations.
+    fileName (`str`_):
+
+       The filename of the log.
+    creator (`str`_):
+
+       The application that generated the log file. For more information on currently supported creators, see `DiagnosticManagerLogCreator`_ .
+    format (`str`_):
+
+       Describes the format of the log file. For more information on currently supported formats, see `DiagnosticManagerLogFormat`_ .
+    mimeType (`str`_):
+
+       Describes the mime-type of the returned file. Typical mime-types include:
+        * text/plain - for a plain log file
+    info (`vim.Description`_):
+
+       Localized description of log file.

docs/vim/DiagnosticManager/LogDescriptor/Creator.rst

@@ -0,0 +1,36 @@
+.. _vim.DiagnosticManager.LogDescriptor: ../../../vim/DiagnosticManager/LogDescriptor.rst
+
+.. _vim.DiagnosticManager.LogDescriptor.Creator: ../../../vim/DiagnosticManager/LogDescriptor/Creator.rst
+
+vim.DiagnosticManager.LogDescriptor.Creator
+===========================================
+  Pre-defined constants for possible creators of log files.
+  :contained by: `vim.DiagnosticManager.LogDescriptor`_
+
+  :type: `vim.DiagnosticManager.LogDescriptor.Creator`_
+
+  :name: recordLog
+
+values:
+--------
+
+hostd
+   Host agent
+
+vpxd
+   VirtualCenter service
+
+vpxa
+   VirtualCenter agent
+
+recordLog
+   System Record Log
+
+install
+   Installation
+
+serverd
+   Host server agent
+
+vpxClient
+   Virtual infrastructure client

docs/vim/DiagnosticManager/LogDescriptor/Format.rst

@@ -0,0 +1,18 @@
+.. _vim.DiagnosticManager.LogDescriptor: ../../../vim/DiagnosticManager/LogDescriptor.rst
+
+.. _vim.DiagnosticManager.LogDescriptor.Format: ../../../vim/DiagnosticManager/LogDescriptor/Format.rst
+
+vim.DiagnosticManager.LogDescriptor.Format
+==========================================
+  Constants for defined formats. For more information, see the comment for the format property.
+  :contained by: `vim.DiagnosticManager.LogDescriptor`_
+
+  :type: `vim.DiagnosticManager.LogDescriptor.Format`_
+
+  :name: plain
+
+values:
+--------
+
+plain
+   A standard ASCII-based line-based log file.

docs/vim/DiagnosticManager/LogHeader.rst

@@ -0,0 +1,22 @@
+.. _int: https://docs.python.org/2/library/stdtypes.html
+
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+
+vim.DiagnosticManager.LogHeader
+===============================
+  A header that is returned with a set of log entries. This header describes where entries are located in the log file. Log files typically grow dynamically, so indexes based on line numbers may become inaccurate.
+:extends: vmodl.DynamicData_
+
+Attributes:
+    lineStart (`int`_):
+
+       The first line of this log segment.
+    lineEnd (`int`_):
+
+       The last line of this log segment.
+    lineText (`str`_, optional):
+
+       Log entries, listed by line, for this log segment.

docs/vim/DistributedVirtualSwitch/BackupRestoreCapability.rst

@@ -0,0 +1,23 @@
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _vSphere API 5.1: ../../vim/version.rst#vimversionversion8
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+.. _DistributedVirtualSwitch: ../../vim/DistributedVirtualSwitch.rst
+
+.. _DVSBackupRestoreCapability: ../../vim/DistributedVirtualSwitch/BackupRestoreCapability.rst
+
+.. _DistributedVirtualPortgroup: ../../vim/dvs/DistributedVirtualPortgroup.rst
+
+
+vim.DistributedVirtualSwitch.BackupRestoreCapability
+====================================================
+  The `DVSBackupRestoreCapability`_ data object describes backup, restore, and rollback capabilities for distributed virtual switches and distributed virtual portgroups. Backup and restore capabilities are indicated for `DistributedVirtualSwitch`_ . Rollback capability is indicated for `DistributedVirtualSwitch`_ and `DistributedVirtualPortgroup`_ .
+:extends: vmodl.DynamicData_
+:since: `vSphere API 5.1`_
+
+Attributes:
+    backupRestoreSupported (`bool`_):
+
+       Indicates whether backup, restore, and rollback are supported.

docs/vim/DistributedVirtualSwitch/Capability.rst

@@ -0,0 +1,41 @@
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _DVSCapability: ../../vim/DistributedVirtualSwitch/Capability.rst
+
+.. _vSphere API 4.0: ../../vim/version.rst#vimversionversion5
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+.. _UpdateDvsCapability: ../../vim/DistributedVirtualSwitch.rst#updateCapability
+
+.. _DVSFeatureCapability: ../../vim/DistributedVirtualSwitch/FeatureCapability.rst
+
+.. _vim.dvs.HostProductSpec: ../../vim/dvs/HostProductSpec.rst
+
+.. _vmDirectPathGen2Supported: ../../vim/DistributedVirtualSwitch/FeatureCapability.rst#vmDirectPathGen2Supported
+
+.. _vim.DistributedVirtualSwitch.FeatureCapability: ../../vim/DistributedVirtualSwitch/FeatureCapability.rst
+
+
+vim.DistributedVirtualSwitch.Capability
+=======================================
+  The `DVSCapability`_ data object describes the distributed virtual switch features and indicates the level of configuration that is allowed.
+:extends: vmodl.DynamicData_
+:since: `vSphere API 4.0`_
+
+Attributes:
+    dvsOperationSupported (`bool`_, optional):
+
+       Indicates whether this switch allows vCenter users to modify the switch configuration at the switch level, except for host member, policy, and scope operations.
+    dvPortGroupOperationSupported (`bool`_, optional):
+
+       Indicates whether this switch allows vCenter users to modify the switch configuration at the portgroup level, except for host member, policy, and scope operations.
+    dvPortOperationSupported (`bool`_, optional):
+
+       Indicates whether this switch allows vCenter users to modify the switch configuration at the port level, except for host member, policy, and scope operations.
+    compatibleHostComponentProductInfo (`vim.dvs.HostProductSpec`_, optional):
+
+       List of host component product information that is compatible with the current switch implementation.
+    featuresSupported (`vim.DistributedVirtualSwitch.FeatureCapability`_, optional):
+
+       Indicators for which version-specific distributed virtual switch features are available on this switch.This information is read-only, with the following exception. For a third-party distributed switch implementation, you can set the property `DVSFeatureCapability`_ . `vmDirectPathGen2Supported`_ during switch creation or when you call the `UpdateDvsCapability`_ method.

docs/vim/DistributedVirtualSwitch/ConfigInfo.rst

@@ -0,0 +1,108 @@
+.. _int: https://docs.python.org/2/library/stdtypes.html
+
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _datetime: https://docs.python.org/2/library/stdtypes.html
+
+.. _vSphere API 4.0: ../../vim/version.rst#vimversionversion5
+
+.. _uplinkPortPolicy: ../../vim/DistributedVirtualSwitch/ConfigInfo.rst#uplinkPortPolicy
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+.. _vim.dvs.HostMember: ../../vim/dvs/HostMember.rst
+
+.. _vim.dvs.ProductSpec: ../../vim/dvs/ProductSpec.rst
+
+.. _vim.dvs.KeyedOpaqueBlob: ../../vim/dvs/KeyedOpaqueBlob.rst
+
+.. _DistributedVirtualSwitch: ../../vim/DistributedVirtualSwitch.rst
+
+.. _vim.dvs.DistributedVirtualPortgroup: ../../vim/dvs/DistributedVirtualPortgroup.rst
+
+.. _vim.dvs.DistributedVirtualPort.Setting: ../../vim/dvs/DistributedVirtualPort/Setting.rst
+
+.. _vim.DistributedVirtualSwitch.ContactInfo: ../../vim/DistributedVirtualSwitch/ContactInfo.rst
+
+.. _vim.DistributedVirtualSwitch.SwitchPolicy: ../../vim/DistributedVirtualSwitch/SwitchPolicy.rst
+
+.. _vim.DistributedVirtualSwitch.UplinkPortPolicy: ../../vim/DistributedVirtualSwitch/UplinkPortPolicy.rst
+
+.. _vim.DistributedVirtualSwitch.HealthCheckConfig: ../../vim/DistributedVirtualSwitch/HealthCheckConfig.rst
+
+
+vim.DistributedVirtualSwitch.ConfigInfo
+=======================================
+  Configuration of a `DistributedVirtualSwitch`_ .
+:extends: vmodl.DynamicData_
+:since: `vSphere API 4.0`_
+
+Attributes:
+    uuid (`str`_):
+
+       Generated UUID of the switch. Unique across vCenter Server inventory and instances.
+    name (`str`_):
+
+       Name of the switch.
+    numStandalonePorts (`int`_):
+
+       Number of standalone ports in the switch. Standalone ports are ports that do not belong to any portgroup.
+    numPorts (`int`_):
+
+       Current number of ports, not including conflict ports.
+    maxPorts (`int`_):
+
+       Maximum number of ports allowed in the switch, not including conflict ports.
+    uplinkPortPolicy (`vim.DistributedVirtualSwitch.UplinkPortPolicy`_):
+
+       Uplink port policy.
+    uplinkPortgroup (`vim.dvs.DistributedVirtualPortgroup`_, optional):
+
+       List of uplink portgroups. When adding host members, the server uses the `uplinkPortPolicy`_ to create a number of uplink ports for the host. If portgroups are shown here, those uplink ports will be added to the portgroups, with uplink ports evenly spread among the portgroups.
+    defaultPortConfig (`vim.dvs.DistributedVirtualPort.Setting`_):
+
+       Default configuration for the ports in the switch, if the port does not inherit configuration from the parent portgroup or has its own configuration.
+    host (`vim.dvs.HostMember`_, optional):
+
+       Hosts that join the switch.
+    productInfo (`vim.dvs.ProductSpec`_):
+
+       Vendor, product, and version information for the implementation module of the switch.
+    targetInfo (`vim.dvs.ProductSpec`_, optional):
+
+       Intended vendor, product, and version information for the implementation module of the switch.
+    extensionKey (`str`_, optional):
+
+       Key of the extension registered by the remote server that controls the switch.
+    vendorSpecificConfig (`vim.dvs.KeyedOpaqueBlob`_, optional):
+
+       Opaque binary blob that stores vendor specific configuration.
+    policy (`vim.DistributedVirtualSwitch.SwitchPolicy`_, optional):
+
+       Usage policy of the switch.
+    description (`str`_, optional):
+
+       Description string for the switch.
+    configVersion (`str`_):
+
+       Version string of the configuration.
+    contact (`vim.DistributedVirtualSwitch.ContactInfo`_):
+
+       Human operator contact information.
+    switchIpAddress (`str`_, optional):
+
+       IP address for the switch, specified using IPv4 dot notation. The utility of this address is defined by other switch features.
+    createTime (`datetime`_):
+
+       Create time of the switch.
+    networkResourceManagementEnabled (`bool`_):
+
+       Boolean to indicate if network I/O control is enabled on the switch.
+    defaultProxySwitchMaxNumPorts (`int`_, optional):
+
+       Default host proxy switch maximum port number
+    healthCheckConfig (`vim.DistributedVirtualSwitch.HealthCheckConfig`_, optional):
+
+       VDS health check configuration.

docs/vim/DistributedVirtualSwitch/ConfigSpec.rst

@@ -0,0 +1,85 @@
+.. _int: https://docs.python.org/2/library/stdtypes.html
+
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _DVSConfigSpec: ../../vim/DistributedVirtualSwitch/ConfigSpec.rst
+
+.. _configVersion: ../../vim/DistributedVirtualSwitch/ConfigInfo.rst#configVersion
+
+.. _vSphere API 4.0: ../../vim/version.rst#vimversionversion5
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+.. _ReconfigureDvs_Task: ../../vim/DistributedVirtualSwitch.rst#reconfigure
+
+.. _vim.dvs.KeyedOpaqueBlob: ../../vim/dvs/KeyedOpaqueBlob.rst
+
+.. _DistributedVirtualSwitch: ../../vim/DistributedVirtualSwitch.rst
+
+.. _QueryDvsCheckCompatibility: ../../vim/dvs/DistributedVirtualSwitchManager.rst#checkCompatibility
+
+.. _vim.dvs.HostMember.ConfigSpec: ../../vim/dvs/HostMember/ConfigSpec.rst
+
+.. _vim.dvs.DistributedVirtualPortgroup: ../../vim/dvs/DistributedVirtualPortgroup.rst
+
+.. _vim.dvs.DistributedVirtualPort.Setting: ../../vim/dvs/DistributedVirtualPort/Setting.rst
+
+.. _vim.DistributedVirtualSwitch.ContactInfo: ../../vim/DistributedVirtualSwitch/ContactInfo.rst
+
+.. _vim.DistributedVirtualSwitch.SwitchPolicy: ../../vim/DistributedVirtualSwitch/SwitchPolicy.rst
+
+.. _vim.DistributedVirtualSwitch.UplinkPortPolicy: ../../vim/DistributedVirtualSwitch/UplinkPortPolicy.rst
+
+
+vim.DistributedVirtualSwitch.ConfigSpec
+=======================================
+  The `DVSConfigSpec`_ data object contains configuration data for a `DistributedVirtualSwitch`_ . Use the `ReconfigureDvs_Task`_ method to apply the configuration to the switch.
+:extends: vmodl.DynamicData_
+:since: `vSphere API 4.0`_
+
+Attributes:
+    configVersion (`str`_, optional):
+
+       The version string of the configuration that this spec is trying to change. This property is required in reconfiguring a switch and should be set to the same value as `configVersion`_ . This property is ignored during switch creation.
+    name (`str`_, optional):
+
+       The name of the switch. Must be unique in the parent folder.
+    numStandalonePorts (`int`_, optional):
+
+       The number of standalone ports in the switch. Standalone ports are ports that do not belong to any portgroup. If set to a number larger than number of existing standalone ports in the switch, new ports get created to meet the number. If set to a number smaller than the number of existing standalone ports, free ports (uplink ports excluded) are deleted to meet the number. If the set number cannot be met by deleting free standalone ports, a fault is raised.
+    maxPorts (`int`_, optional):
+
+       The maximum number of DistributedVirtualPorts allowed in the switch. If specified in a reconfigure operation, this number cannot be smaller than the number of existing DistributedVirtualPorts.
+    uplinkPortPolicy (`vim.DistributedVirtualSwitch.UplinkPortPolicy`_, optional):
+
+       The uplink port policy.
+    uplinkPortgroup (`vim.dvs.DistributedVirtualPortgroup`_, optional):
+
+       The uplink portgroups.
+    defaultPortConfig (`vim.dvs.DistributedVirtualPort.Setting`_, optional):
+
+       The default configuration for ports.
+    host (`vim.dvs.HostMember.ConfigSpec`_, optional):
+
+       The host member specification. A particular host should have only one entry in this array. Duplicate entries for the same host will raise a fault. The host version should be compatible with the version of `DistributedVirtualSwitch`_ . Use `QueryDvsCheckCompatibility`_ to check for compatibility.
+    extensionKey (`str`_, optional):
+
+       The key of the extension registered by a remote server that controls the switch.
+    description (`str`_, optional):
+
+       Set the description string of the switch.
+    policy (`vim.DistributedVirtualSwitch.SwitchPolicy`_, optional):
+
+       The usage policy of the switch.
+    vendorSpecificConfig (`vim.dvs.KeyedOpaqueBlob`_, optional):
+
+       Set the opaque blob that stores vendor specific configuration.
+    contact (`vim.DistributedVirtualSwitch.ContactInfo`_, optional):
+
+       Set the human operator contact information.
+    switchIpAddress (`str`_, optional):
+
+       IP address for the switch, specified using IPv4 dot notation. The utility of this address is defined by other switch features.
+    defaultProxySwitchMaxNumPorts (`int`_, optional):
+
+       The default host proxy switch maximum port number

docs/vim/DistributedVirtualSwitch/ContactInfo.rst

@@ -0,0 +1,20 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _vSphere API 4.0: ../../vim/version.rst#vimversionversion5
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+
+vim.DistributedVirtualSwitch.ContactInfo
+========================================
+  Contact information of a human operator.
+:extends: vmodl.DynamicData_
+:since: `vSphere API 4.0`_
+
+Attributes:
+    name (`str`_, optional):
+
+       The name of the person who is responsible for the switch.
+    contact (`str`_, optional):
+
+       The contact information for the person.

docs/vim/DistributedVirtualSwitch/CreateSpec.rst

@@ -0,0 +1,29 @@
+.. _vSphere API 4.0: ../../vim/version.rst#vimversionversion5
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+.. _vim.dvs.ProductSpec: ../../vim/dvs/ProductSpec.rst
+
+.. _DistributedVirtualSwitch: ../../vim/DistributedVirtualSwitch.rst
+
+.. _vim.DistributedVirtualSwitch.Capability: ../../vim/DistributedVirtualSwitch/Capability.rst
+
+.. _vim.DistributedVirtualSwitch.ConfigSpec: ../../vim/DistributedVirtualSwitch/ConfigSpec.rst
+
+
+vim.DistributedVirtualSwitch.CreateSpec
+=======================================
+  Specification to create a `DistributedVirtualSwitch`_ .
+:extends: vmodl.DynamicData_
+:since: `vSphere API 4.0`_
+
+Attributes:
+    configSpec (`vim.DistributedVirtualSwitch.ConfigSpec`_):
+
+       Configuration data.
+    productInfo (`vim.dvs.ProductSpec`_, optional):
+
+       Product information for this switch implementation. If you do not specify this property, the Server will use the latest version to create the `DistributedVirtualSwitch`_ .
+    capability (`vim.DistributedVirtualSwitch.Capability`_, optional):
+
+       Capability of the switch.

docs/vim/DistributedVirtualSwitch/FeatureCapability.rst

@@ -0,0 +1,89 @@
+.. _int: https://docs.python.org/2/library/stdtypes.html
+
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _high: ../../vim/SharesInfo/Level.rst#high
+
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _shares: ../../vim/dvs/NetworkResourcePool/AllocationInfo.rst#shares
+
+.. _normal: ../../vim/SharesInfo/Level.rst#normal
+
+.. _PhysicalNic: ../../vim/host/PhysicalNic.rst
+
+.. _HostCapability: ../../vim/host/Capability.rst
+
+.. _vSphere API 4.1: ../../vim/version.rst#vimversionversion6
+
+.. _DVSRollback_Task: ../../vim/DistributedVirtualSwitch.rst#rollback
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+.. _rollbackSupported: ../../vim/DistributedVirtualSwitch/RollbackCapability.rst#rollbackSupported
+
+.. _UpdateDvsCapability: ../../vim/DistributedVirtualSwitch.rst#updateCapability
+
+.. _DVSFeatureCapability: ../../vim/DistributedVirtualSwitch/FeatureCapability.rst
+
+.. _DVPortgroupRollback_Task: ../../vim/dvs/DistributedVirtualPortgroup.rst#rollback
+
+.. _DistributedVirtualSwitch: ../../vim/DistributedVirtualSwitch.rst
+
+.. _vmDirectPathGen2Supported: ../../vim/host/PhysicalNic.rst#vmDirectPathGen2Supported
+
+.. _DistributedVirtualPortgroup: ../../vim/dvs/DistributedVirtualPortgroup.rst
+
+.. _DVSManagerImportEntity_Task: ../../vim/dvs/DistributedVirtualSwitchManager.rst#importEntity
+
+.. _DVSManagerExportEntity_Task: ../../vim/dvs/DistributedVirtualSwitchManager.rst#exportEntity
+
+.. _VmwareDistributedVirtualSwitch: ../../vim/dvs/VmwareDistributedVirtualSwitch.rst
+
+.. _DistributedVirtualSwitchManager: ../../vim/dvs/DistributedVirtualSwitchManager.rst
+
+.. _DistributedVirtualSwitchNicTeamingPolicyMode: ../../vim/DistributedVirtualSwitch/NicTeamingPolicyMode.rst
+
+.. _vim.DistributedVirtualSwitch.RollbackCapability: ../../vim/DistributedVirtualSwitch/RollbackCapability.rst
+
+.. _vim.DistributedVirtualSwitch.BackupRestoreCapability: ../../vim/DistributedVirtualSwitch/BackupRestoreCapability.rst
+
+.. _vim.DistributedVirtualSwitch.HealthCheckFeatureCapability: ../../vim/DistributedVirtualSwitch/HealthCheckFeatureCapability.rst
+
+.. _vim.DistributedVirtualSwitch.NetworkResourceManagementCapability: ../../vim/DistributedVirtualSwitch/NetworkResourceManagementCapability.rst
+
+
+vim.DistributedVirtualSwitch.FeatureCapability
+==============================================
+  The `DVSFeatureCapability`_ data object represents the capabilities supported by a `DistributedVirtualSwitch`_ . These properties are read-only with the exception of `vmDirectPathGen2Supported`_ .
+:extends: vmodl.DynamicData_
+:since: `vSphere API 4.1`_
+
+Attributes:
+    networkResourceManagementSupported (`bool`_):
+
+       Indicates whether network I/O control is supported on the vSphere Distributed Switch.
+    vmDirectPathGen2Supported (`bool`_):
+
+       Indicates whether VMDirectPath Gen 2 is supported on the distributed virtual switch. See `HostCapability`_ . `vmDirectPathGen2Supported`_ and `PhysicalNic`_ . `vmDirectPathGen2Supported`_ .For a third-party distributed switch implementation, you can specify this property during switch creation or when you call the `UpdateDvsCapability`_ method.VMDirectPath Gen 2 is supported in vSphere Distributed Switch Version 4.1 or later.
+    nicTeamingPolicy (`str`_, optional):
+
+       The available teaming modes for the vSphere Distributed Switch. The value can be one or more of `DistributedVirtualSwitchNicTeamingPolicyMode`_ .
+    networkResourcePoolHighShareValue (`int`_, optional):
+
+       This is the value for `high`_ in `shares`_ . This implicitly defines the legal range of share values to be between 1 and this. This also defines values for other level types, such as `normal`_ being one half of this value and `low`_ being one fourth of this value.
+    networkResourceManagementCapability (`vim.DistributedVirtualSwitch.NetworkResourceManagementCapability`_, optional):
+
+       Network resource management capabilities supported by a distributed virtual switch.
+    healthCheckCapability (`vim.DistributedVirtualSwitch.HealthCheckFeatureCapability`_, optional):
+
+       Health check capabilities supported by a `VmwareDistributedVirtualSwitch`_ .
+    rollbackCapability (`vim.DistributedVirtualSwitch.RollbackCapability`_, optional):
+
+       Host rollback capability. IfrollbackCapability. `rollbackSupported`_ is true, network operations that disconnect the the host are rolled back.
+    backupRestoreCapability (`vim.DistributedVirtualSwitch.BackupRestoreCapability`_, optional):
+
+       Backup, restore, and rollback capabilities. Backup and restore are supported only for `VmwareDistributedVirtualSwitch`_ . Rollback is supported for `VmwareDistributedVirtualSwitch`_ and `DistributedVirtualPortgroup`_ . For information about backup and restore, see the `DistributedVirtualSwitchManager`_ methods `DVSManagerExportEntity_Task`_ and `DVSManagerImportEntity_Task`_ . For information about rollback, see the `DistributedVirtualSwitch`_ . `DVSRollback_Task`_ and `DistributedVirtualPortgroup`_ . `DVPortgroupRollback_Task`_ methods.
+    networkFilterSupported (`bool`_, optional):
+
+       Indicates whether Network Filter feature is supported in vSphere Distributed Switch.

docs/vim/DistributedVirtualSwitch/HealthCheckConfig.rst

@@ -0,0 +1,24 @@
+.. _int: https://docs.python.org/2/library/stdtypes.html
+
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _vSphere API 5.1: ../../vim/version.rst#vimversionversion8
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+.. _DVSHealthCheckConfig: ../../vim/DistributedVirtualSwitch/HealthCheckConfig.rst
+
+
+vim.DistributedVirtualSwitch.HealthCheckConfig
+==============================================
+  The `DVSHealthCheckConfig`_ data object defines vSphere Distributed Switch health check configuration.
+:extends: vmodl.DynamicData_
+:since: `vSphere API 5.1`_
+
+Attributes:
+    enable (`bool`_, optional):
+
+       True if enable health check.
+    interval (`int`_, optional):
+
+       Interval of health check, in minutes.

docs/vim/DistributedVirtualSwitch/HealthCheckFeatureCapability.rst

@@ -0,0 +1,12 @@
+.. _vSphere API 5.1: ../../vim/version.rst#vimversionversion8
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+
+vim.DistributedVirtualSwitch.HealthCheckFeatureCapability
+=========================================================
+  Health check capabilities of health check supported by the vSphere Distributed Switch
+:extends: vmodl.DynamicData_
+:since: `vSphere API 5.1`_
+
+Attributes:

docs/vim/DistributedVirtualSwitch/HostInfrastructureTrafficClass.rst

@@ -0,0 +1,39 @@
+.. _vim.DistributedVirtualSwitch: ../../vim/DistributedVirtualSwitch.rst
+
+.. _vim.DistributedVirtualSwitch.HostInfrastructureTrafficClass: ../../vim/DistributedVirtualSwitch/HostInfrastructureTrafficClass.rst
+
+vim.DistributedVirtualSwitch.HostInfrastructureTrafficClass
+===========================================================
+  List of possible host infrastructure traffic classes
+  :contained by: `vim.DistributedVirtualSwitch`_
+
+  :type: `vim.DistributedVirtualSwitch.HostInfrastructureTrafficClass`_
+
+  :name: vsan
+
+values:
+--------
+
+management
+   Management Traffic
+
+virtualMachine
+   Virtual Machine Traffic
+
+iSCSI
+   iSCSI Traffic
+
+nfs
+   NFS Traffic
+
+faultTolerance
+   Fault Tolerance (FT) Traffic
+
+hbr
+   vSphere Replication (VR) Traffic
+
+vsan
+   vSphere Storage Area Network Traffic
+
+vmotion
+   vMotion Traffic

docs/vim/DistributedVirtualSwitch/NameArrayUplinkPortPolicy.rst

@@ -0,0 +1,21 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _portNameFormat: ../../vim/dvs/DistributedVirtualPortgroup/ConfigSpec.rst#portNameFormat
+
+.. _vSphere API 4.0: ../../vim/version.rst#vimversionversion5
+
+.. _DVPortgroupConfigSpec: ../../vim/dvs/DistributedVirtualPortgroup/ConfigSpec.rst
+
+.. _vim.DistributedVirtualSwitch.UplinkPortPolicy: ../../vim/DistributedVirtualSwitch/UplinkPortPolicy.rst
+
+
+vim.DistributedVirtualSwitch.NameArrayUplinkPortPolicy
+======================================================
+  The uplink port policy specifies an array of uniform names for the uplink ports across the hosts. The size of the array indicates the number of uplink ports that will be created for each host in the switch.When the names in this array change, the uplink ports on all the hosts are automatically renamed accordingly. Increasing the number of names in the array automatically creates additional uplink ports bearing the added name on each host. Decreasing the number of name automatically deletes the unused uplink ports on each host. Decreasing beyond the number of unused uplink port raises a fault.This policy overrides the portgroup port naming format ( `DVPortgroupConfigSpec`_ . `portNameFormat`_ ), if both are defined and the uplink ports are created in a uplink portgroup.
+:extends: vim.DistributedVirtualSwitch.UplinkPortPolicy_
+:since: `vSphere API 4.0`_
+
+Attributes:
+    uplinkPortName (`str`_):
+
+       The uniform name of uplink ports on each host.

docs/vim/DistributedVirtualSwitch/NetworkResourceManagementCapability.rst

@@ -0,0 +1,38 @@
+.. _int: https://docs.python.org/2/library/stdtypes.html
+
+.. _high: ../../vim/SharesInfo/Level.rst#high
+
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _normal: ../../vim/SharesInfo/Level.rst#normal
+
+.. _shares: ../../vim/dvs/NetworkResourcePool/AllocationInfo.rst#shares
+
+.. _SharesLevel: ../../vim/SharesInfo/Level.rst
+
+.. _vSphere API 5.0: ../../vim/version.rst#vimversionversion7
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+.. _DVSNetworkResourcePoolAllocationInfo: ../../vim/dvs/NetworkResourcePool/AllocationInfo.rst
+
+
+vim.DistributedVirtualSwitch.NetworkResourceManagementCapability
+================================================================
+  Dataobject representing the feature capabilities of network resource management supported by the vSphere Distributed Switch.
+:extends: vmodl.DynamicData_
+:since: `vSphere API 5.0`_
+
+Attributes:
+    networkResourceManagementSupported (`bool`_):
+
+       Indicates whether network I/O control is supported on the vSphere Distributed Switch. Network I/O control is supported in vSphere Distributed Switch Version 4.1 or later.
+    networkResourcePoolHighShareValue (`int`_):
+
+       High share level ( `SharesLevel`_ . `high`_ ) for `DVSNetworkResourcePoolAllocationInfo`_ . `shares`_ .ThenetworkResourcePoolHighshareValueproperty implicitly defines the legal range of share values to be between 1 and this value. This property also defines values for other level types, such as `normal`_ being one half of this value and `low`_ being one fourth of this value. This feature is supported in vSphere Distributed Switch Version 4.1 or later.
+    qosSupported (`bool`_):
+
+       Indicates whether Qos Tag(802.1p priority tag)is supported on the vSphere Distributed Switch. Qos Tag is supported in vSphere Distributed Switch Version 5.0 or later.
+    userDefinedNetworkResourcePoolsSupported (`bool`_):
+
+       Indicates whether the switch supports creating user defined resource pools. This feature is supported in vSphere Distributed Switch Version 5.0 or later.

docs/vim/DistributedVirtualSwitch/NicTeamingPolicyMode.rst

@@ -0,0 +1,30 @@
+.. _vim.DistributedVirtualSwitch: ../../vim/DistributedVirtualSwitch.rst
+
+.. _vim.DistributedVirtualSwitch.NicTeamingPolicyMode: ../../vim/DistributedVirtualSwitch/NicTeamingPolicyMode.rst
+
+vim.DistributedVirtualSwitch.NicTeamingPolicyMode
+=================================================
+  List of possible teaming modes supported by the vNetwork Distributed Switch. The different policy modes define the way traffic is routed through the different uplink ports in a team.
+  :contained by: `vim.DistributedVirtualSwitch`_
+
+  :type: `vim.DistributedVirtualSwitch.NicTeamingPolicyMode`_
+
+  :name: loadbalance_loadbased
+
+values:
+--------
+
+failover_explicit
+   Use explicit failover order
+
+loadbalance_ip
+   Routing based on IP hash
+
+loadbalance_srcid
+   Route based on the source of the port ID
+
+loadbalance_srcmac
+   Route based on source MAC hash
+
+loadbalance_loadbased
+   Routing based by dynamically balancing traffic through the NICs in a team. This is the recommended teaming policy when the network I/O control feature is enabled for the vNetwork Distributed Switch.

docs/vim/DistributedVirtualSwitch/ProductSpecOperationType.rst

@@ -0,0 +1,34 @@
+.. _autoUpgradeAllowed: ../../vim/DistributedVirtualSwitch/SwitchPolicy.rst#autoUpgradeAllowed
+
+.. _DvsUpgradeAvailableEvent: ../../vim/event/DvsUpgradeAvailableEvent.rst
+
+.. _vim.DistributedVirtualSwitch: ../../vim/DistributedVirtualSwitch.rst
+
+.. _vim.DistributedVirtualSwitch.ProductSpecOperationType: ../../vim/DistributedVirtualSwitch/ProductSpecOperationType.rst
+
+vim.DistributedVirtualSwitch.ProductSpecOperationType
+=====================================================
+  The product spec operation types.
+  :contained by: `vim.DistributedVirtualSwitch`_
+
+  :type: `vim.DistributedVirtualSwitch.ProductSpecOperationType`_
+
+  :name: updateBundleInfo
+
+values:
+--------
+
+updateBundleInfo
+   Update the bundle URL and ID information. If other properties in the specified product info differ from the corresponding properties of the switch's product info, a fault will be thrown. Updating the bundle ID will result in installing the new host component identified by the bundle ID.
+
+upgrade
+   Change the switch implementation to use the specified one. If the property values in the specified product info are different from those of the corresponding properties in the switch's product info, a host component preinstall and switch upgrade will be performed.
+
+proceedWithUpgrade
+   If productSpec is set to be same as that in the `DvsUpgradeAvailableEvent`_ configIssue, the switch implementation will proceed with the upgrade. To reject or stop the upgrade, leave the productSpec unset. If productSpec is set but does not match that in `DvsUpgradeAvailableEvent`_ configIssue, a fault will be raised. This operation is applicable only in the case when switch policy `autoUpgradeAllowed`_ is set to false.
+
+notifyAvailableUpgrade
+   Set the product information for an available switch upgrade that would be done by the switch implementation. This operation will post a config issue on the switch to signal the availability of an upgrade. This operation is applicable only in the case when switch policy `autoUpgradeAllowed`_ is set to false.
+
+preInstall
+   Push the switch's host component of the specified product info to the host members of the switch at a fixed location known by the host.

docs/vim/DistributedVirtualSwitch/RollbackCapability.rst

@@ -0,0 +1,21 @@
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _vSphere API 5.1: ../../vim/version.rst#vimversionversion8
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+.. _DVSRollbackCapability: ../../vim/DistributedVirtualSwitch/RollbackCapability.rst
+
+.. _DistributedVirtualSwitch: ../../vim/DistributedVirtualSwitch.rst
+
+
+vim.DistributedVirtualSwitch.RollbackCapability
+===============================================
+  The `DVSRollbackCapability`_ data object describes the rollback capabilities for a `DistributedVirtualSwitch`_ .
+:extends: vmodl.DynamicData_
+:since: `vSphere API 5.1`_
+
+Attributes:
+    rollbackSupported (`bool`_):
+
+       Indicates whether rollback is supported on the distributed switch.

docs/vim/DistributedVirtualSwitch/RuntimeInfo.rst

@@ -0,0 +1,19 @@
+.. _DVSRuntimeInfo: ../../vim/DistributedVirtualSwitch/RuntimeInfo.rst
+
+.. _vSphere API 5.1: ../../vim/version.rst#vimversionversion8
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+.. _vim.dvs.HostMember.RuntimeInfo: ../../vim/dvs/HostMember/RuntimeInfo.rst
+
+
+vim.DistributedVirtualSwitch.RuntimeInfo
+========================================
+  The `DVSRuntimeInfo`_ data object defines runtime information for a vSphere Distributed Switch.
+:extends: vmodl.DynamicData_
+:since: `vSphere API 5.1`_
+
+Attributes:
+    hostMemberRuntime (`vim.dvs.HostMember.RuntimeInfo`_, optional):
+
+       Runtime information of the hosts that joined the switch.

docs/vim/DistributedVirtualSwitch/Summary.rst

@@ -0,0 +1,57 @@
+.. _int: https://docs.python.org/2/library/stdtypes.html
+
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _vim.HostSystem: ../../vim/HostSystem.rst
+
+.. _vSphere API 4.0: ../../vim/version.rst#vimversionversion5
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+.. _vim.VirtualMachine: ../../vim/VirtualMachine.rst
+
+.. _vim.dvs.ProductSpec: ../../vim/dvs/ProductSpec.rst
+
+.. _vim.DistributedVirtualSwitch.ContactInfo: ../../vim/DistributedVirtualSwitch/ContactInfo.rst
+
+
+vim.DistributedVirtualSwitch.Summary
+====================================
+  Summary of the distributed switch configuration.
+:extends: vmodl.DynamicData_
+:since: `vSphere API 4.0`_
+
+Attributes:
+    name (`str`_):
+
+       The name of the switch.
+    uuid (`str`_):
+
+       The generated UUID of the switch.
+    numPorts (`int`_):
+
+       Current number of ports, not including conflict ports.
+    productInfo (`vim.dvs.ProductSpec`_, optional):
+
+       The product information for the implementation of the switch.
+    hostMember (`vim.HostSystem`_, optional):
+
+       The names of the hosts that join the switch.
+    vm (`vim.VirtualMachine`_, optional):
+
+       The Virtual Machines with Virtual NICs that connect to the switch. In releases after vSphere API 5.0, vSphere Servers might not generate property collector update notifications for this property. To obtain the latest value of the property, you can use PropertyCollector methods RetrievePropertiesEx or WaitForUpdatesEx. If you use the PropertyCollector.WaitForUpdatesEx method, specify an empty string for the version parameter. Since this property is on a DataObject, an update returned by WaitForUpdatesEx may contain values for this property when some other property on the DataObject changes. If this update is a result of a call to WaitForUpdatesEx with a non-empty version parameter, the value for this property may not be current.
+    host (`vim.HostSystem`_, optional):
+
+       The hosts with Virtual NICs that connect to the switch.
+    portgroupName (`str`_, optional):
+
+       The names of the portgroups that are defined on the switch.
+    description (`str`_, optional):
+
+       A description string of the switch.
+    contact (`vim.DistributedVirtualSwitch.ContactInfo`_, optional):
+
+       The human operator contact information.
+    numHosts (`int`_, optional):
+
+       The number of hosts in the switch. The value of this property is not affected by the privileges granted to the current user.

docs/vim/DistributedVirtualSwitch/SwitchPolicy.rst

@@ -0,0 +1,23 @@
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _vSphere API 4.0: ../../vim/version.rst#vimversionversion5
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+
+vim.DistributedVirtualSwitch.SwitchPolicy
+=========================================
+  The switch usage policy types
+:extends: vmodl.DynamicData_
+:since: `vSphere API 4.0`_
+
+Attributes:
+    autoPreInstallAllowed (`bool`_, optional):
+
+       Whether downloading a new proxy VirtualSwitch module to the host is allowed to be automatically executed by the switch.
+    autoUpgradeAllowed (`bool`_, optional):
+
+       Whether upgrading of the switch is allowed to be automatically executed by the switch.
+    partialUpgradeAllowed (`bool`_, optional):
+
+       Whether to allow upgrading a switch when some of the hosts failed to install the needed module. The vCenter Server will reattempt the pre-install operation of the host module on those failed hosts, whenever they reconnect to vCenter.

docs/vim/DistributedVirtualSwitch/UplinkPortPolicy.rst

@@ -0,0 +1,12 @@
+.. _vSphere API 4.0: ../../vim/version.rst#vimversionversion5
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+
+vim.DistributedVirtualSwitch.UplinkPortPolicy
+=============================================
+  The base class for uplink port policy.
+:extends: vmodl.DynamicData_
+:since: `vSphere API 4.0`_
+
+Attributes:

docs/vim/DrsStatsManager/InjectorWorkload/CorrelationState.rst

@@ -0,0 +1,21 @@
+.. _vim.DrsStatsManager.InjectorWorkload: ../../../vim/DrsStatsManager/InjectorWorkload.rst
+
+.. _vim.DrsStatsManager.InjectorWorkload.CorrelationState: ../../../vim/DrsStatsManager/InjectorWorkload/CorrelationState.rst
+
+vim.DrsStatsManager.InjectorWorkload.CorrelationState
+=====================================================
+  Correlation state as computed by storageRM module on host.
+  :contained by: `vim.DrsStatsManager.InjectorWorkload`_
+
+  :type: `vim.DrsStatsManager.InjectorWorkload.CorrelationState`_
+
+  :name: Uncorrelated
+
+values:
+--------
+
+Correlated
+   Correlated
+
+Uncorrelated
+   Uncorrelated

docs/vim/EVCMode.rst

@@ -0,0 +1,83 @@
+.. _int: https://docs.python.org/2/library/stdtypes.html
+
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _track: ../vim/EVCMode.rst#track
+
+.. _label: ../vim/Description.rst#label
+
+.. _summary: ../vim/Description.rst#summary
+
+.. _EVCMode: ../vim/EVCMode.rst
+
+.. _vendorTier: ../vim/EVCMode.rst#vendorTier
+
+.. _maxEVCModeKey: ../vim/host/Summary.rst#maxEVCModeKey
+
+.. _vSphere API 4.0: ../vim/version.rst#vimversionversion5
+
+.. _HostListSummary: ../vim/host/Summary.rst
+
+.. _currentEVCModeKey: ../vim/host/Summary.rst#currentEVCModeKey
+
+.. _vim.host.CpuIdInfo: ../vim/host/CpuIdInfo.rst
+
+.. _vim.host.FeatureMask: ../vim/host/FeatureMask.rst
+
+.. _guaranteedCPUFeatures: ../vim/EVCMode.rst#guaranteedCPUFeatures
+
+.. _minRequiredEVCModeKey: ../vim/vm/RuntimeInfo.rst#minRequiredEVCModeKey
+
+.. _vim.ElementDescription: ../vim/ElementDescription.rst
+
+.. _vim.vm.FeatureRequirement: ../vim/vm/FeatureRequirement.rst
+
+.. _VirtualMachineRuntimeInfo: ../vim/vm/RuntimeInfo.rst
+
+.. _vim.host.FeatureCapability: ../vim/host/FeatureCapability.rst
+
+.. _ClusterComputeResourceSummary: ../vim/ClusterComputeResource/Summary.rst
+
+
+vim.EVCMode
+===========
+  The `EVCMode`_ data object describes an Enhanced vMotion Compatibility mode. An EVC mode is associated with a set of CPU features. A vCenter Server defines the available EVC modes. You use them to establish a common set of features for compatibility between hosts in a cluster. An EVC-enabled cluster supports safe vMotion of virtual machines across a range of CPU generations. You must use the vSphere Client to configure EVC.When you add a host to an EVC-enabled cluster, the vCenter Server determines the CPU compatibility to preserve vMotion compatibility within the cluster. If the host CPU is compatible with those already in the cluster, the Server adds the host to the cluster and configures it for compatible operation. Hosts that are not compatible are not allowed to join the cluster.The inherited `key`_ property is a string value that uniquely identifies an EVC mode. The vCenter Server assigns the key value; the vSphere API uses the key to identify modes in summary and information objects:
+   * `ClusterComputeResourceSummary`_
+   * .
+   * `currentEVCModeKey`_
+   * `HostListSummary`_
+   * .
+   * `currentEVCModeKey`_
+   * `HostListSummary`_
+   * .
+   * `maxEVCModeKey`_
+   * `VirtualMachineRuntimeInfo`_
+   * .
+   * `minRequiredEVCModeKey`_The inherited `label`_ and `summary`_ properties are human-readable strings.You can use the `track`_ and `vendorTier`_ properties to determine feature-superset relationships between modes without examining the individual feature bits in `guaranteedCPUFeatures`_ . The CPU feature baseline of mode A is a superset of mode B's baseline if and only if:
+   * modeA.track is the same as or a superset of modeB.track
+   * modeA.vendorTier is equal to or greater than modeB.vendorTierUse the `track`_ and `vendorTier`_ properties only for the purpose of feature-superset calculations as described above. Do not use them to infer the presence or absence of specific features. The property values for a given mode may change across releases as the set of available EVC modes changes, to better represent mode relationships.
+:extends: vim.ElementDescription_
+:since: `vSphere API 4.0`_
+
+Attributes:
+    guaranteedCPUFeatures (`vim.host.CpuIdInfo`_, optional):
+
+       Describes the CPU feature baseline associated with the EVC mode. On the cluster where a particular EVC mode is configured, those CPU features are guaranteed, either because the host hardware naturally matches those features or because CPU feature override is used to mask out differences and enforce a match.
+    featureCapability (`vim.host.FeatureCapability`_, optional):
+
+       Describes the feature capability baseline associated with the EVC mode. On the cluster where a particular EVC mode is configured, these features capabilities are guaranteed, either because the host hardware naturally matches those features or because feature masks are used to mask out differences and enforce a match.
+    featureMask (`vim.host.FeatureMask`_, optional):
+
+       The masks (modifications to a host's feature capabilities) that limit a host's capabilities to that of the EVC mode baseline.
+    featureRequirement (`vim.vm.FeatureRequirement`_, optional):
+
+       The conditions that must be true of a host's feature capabilities in order for the host to meet the minimum requirements of the EVC mode baseline.
+    vendor (`str`_):
+
+       CPU hardware vendor required for this mode.
+    track (`str`_):
+
+       Identifiers for feature groups that are at least partially present in the `guaranteedCPUFeatures`_ array for this mode. Use this property to compare track values from two modes. Do not use this property to determine the presence or absence of specific features.
+    vendorTier (`int`_):
+
+       Index for ordering the set of modes that apply to a given CPU vendor. Use this property to compare vendor tier values from two modes. Do not use this property to determine the presence or absence of specific features.

docs/vim/ElementDescription.rst

@@ -0,0 +1,14 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _vim.Description: ../vim/Description.rst
+
+
+vim.ElementDescription
+======================
+  Static strings used for describing an object model string or enumeration.
+:extends: vim.Description_
+
+Attributes:
+    key (`str`_):
+
+       Enumeration or literal ID being described.

docs/vim/EnumDescription.rst

@@ -0,0 +1,22 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _vSphere API 4.0: ../vim/version.rst#vimversionversion5
+
+.. _vmodl.DynamicData: ../vmodl/DynamicData.rst
+
+.. _vim.ElementDescription: ../vim/ElementDescription.rst
+
+
+vim.EnumDescription
+===================
+  Static strings used for describing an enumerated type.
+:extends: vmodl.DynamicData_
+:since: `vSphere API 4.0`_
+
+Attributes:
+    key (`str`_):
+
+       Type of enumeration being described.
+    tags (`vim.ElementDescription`_):
+
+       Element descriptions of all the tags for that enumerated type.

docs/vim/EnvironmentBrowser.rst

@@ -0,0 +1,152 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _vim.Task: ../vim/Task.rst
+
+.. _vim.HostSystem: ../vim/HostSystem.rst
+
+.. _vSphere API 4.0: ../vim/version.rst#vimversionversion5
+
+.. _vim.vm.ConfigOption: ../vim/vm/ConfigOption.rst
+
+.. _vim.host.Capability: ../vim/host/Capability.rst
+
+.. _vim.vm.ConfigTarget: ../vim/vm/ConfigTarget.rst
+
+.. _vim.host.DatastoreBrowser: ../vim/host/DatastoreBrowser.rst
+
+.. _vmodl.fault.InvalidArgument: ../vmodl/fault/InvalidArgument.rst
+
+.. _vim.vm.ConfigOptionDescriptor: ../vim/vm/ConfigOptionDescriptor.rst
+
+
+vim.EnvironmentBrowser
+======================
+  This managed object type provides access to the environment that a ComputeResource presents for creating and configuring a virtual machine.The environment consists of three main components:
+   * The virtual machine configuration options. Each vim.vm.ConfigOption describes the execution environment for a virtual machine, the particular set of virtual hardware that is supported. A ComputeResource might support multiple sets. Access is provided through the configOptionDescriptor property and the
+   * `QueryConfigOption`_
+   * operation.
+   * The supported device targets. Each virtual device specified in the virtual machine needs to be hooked up to a "physical" counterpart. For networks, this means choosing a network name; for a virtual CD-rom this might be an ISO image, etc. The environment browser provides access to the device targets through the
+   * `QueryConfigTarget`_
+   * operation.
+   * Storage locations and files. A selection of locations where the virtual machine files can be stored, and the possibility to browse for existing virtual disks and ISO images. The datastore browser, provided by the datastoreBrowser property, provides access to the contents of one or more datastores. The items in a datastore are files that contain configuration, virtual disk, and the other data associated with a virtual machine.
+   * The capabilities supported by the ComputeResource to which the virtual machine belongs.
+   * 
+
+
+
+
+Attributes
+----------
+    datastoreBrowser (`vim.host.DatastoreBrowser`_):
+      privilege: System.View
+       DatastoreBrowser to browse datastores that are available on this entity.
+
+
+Methods
+-------
+
+
+QueryConfigOptionDescriptor():
+   The list of ConfigOption keys available on this entity.
+
+
+  Privilege:
+               System.View
+
+
+
+  Args:
+
+
+  Returns:
+    `vim.vm.ConfigOptionDescriptor`_:
+         
+
+
+QueryConfigOption(key, host):
+   Query for a specific virtual machine configuration option (the ConfigOption).If the EnvironmentBrowser is from a ComputeResource or ClusterComputeResource, the key or host, or both arguments can be used to return the required config options. If a key is specified, then the ConfigOption corresponding to that key value is returned. If a host is specified, then the default ConfigOption for that host is returned. If key and host both are specified, the ConfigOption corresponding to the given key for that host is returned. If neither is specified, then the default ConfigOption for this environment browser is returned. Typically, the default contains the options for the most recent virtual hardware supported.If the EnvironmentBrowser is from a VirtualMachine neither a host nor a key should be specified.
+
+
+  Privilege:
+               System.View
+
+
+
+  Args:
+    key (`str`_, optional):
+       The key found in the VirtualMachineConfigOptionDescriptor, obtained by invoking the `QueryConfigOptionDescriptor`_ operation.
+
+
+    host (`vim.HostSystem`_, optional):
+       The host whose ConfigOption is requested.
+
+
+
+
+  Returns:
+    `vim.vm.ConfigOption`_:
+         Returns the ConfigOption object. If invoked on a cluster with no hosts, or if the ConfigOption with given key is not found for the given host, null is returned.
+
+  Raises:
+
+    `vmodl.fault.InvalidArgument`_: 
+       if any of the following is true:
+        * An invalid key is passed.
+        * An invalid host is passed.
+        * A key or host is specified, when the command is invoked from the environment browser of a virtual machine.
+        * 
+
+
+QueryConfigTarget(host):
+   Queries for information about a specific target, a "physical" device that can be used to back virtual devices. The ConfigTarget that is returned specifies the set of values that can be used in the device backings to connect the virtual machine to physical (or logical) host devices.If the EnvironmentBrowser is from a ComputeResource or ClusterComputeResource, the host argument can be used to return the ConfigTarget provided by a particular host in the compute resource or cluster. If host is specified and the EnvironmentBrowser is from a ComputeResource or ClusterComputeResource, then the union of all the devices is returned and the vim.vm.TargetInfo.configurationTag field indicates how widely the device is available across the compute resource or cluster.If the EnvironmentBrowser is from a VirtualMachine a host should not be specified.
+
+
+  Privilege:
+               System.View
+
+
+
+  Args:
+    host (`vim.HostSystem`_, optional):
+       If specified, the host whose default BackingInfo is requested.
+
+
+
+
+  Returns:
+    `vim.vm.ConfigTarget`_:
+         Returns the ConfigTarget object. If invoked on a cluster with no hosts, null is returned.
+
+  Raises:
+
+    `vmodl.fault.InvalidArgument`_: 
+       if an invalid host is specified , or a host is given when the EnvironmentBrowser is from a virtual machine.
+
+
+QueryTargetCapabilities(host):
+   Queries for information on the capabilities supported by the ComputeResource associated with the EnvironmentBrowser.If the EnvironmentBrowser is from a ComputeResource or ClusterComputeResource, the host argument can be used to return the capabilities associated with a specific host in the compute resource or cluster. If the host argument is not specified and the EnvironmentBrowser is from a ComputeResource or ClusterComputeResource, then the intersection of the capabilities supported by all the hosts in the cluster is returned. If the EnvironmentBrowser is from a VirtualMachine, the compute resource associated with the virtual machine will be queried for its capabilities.If the EnvironmentBrowser is from a VirtualMachine a host should not be specified.
+  since: `vSphere API 4.0`_
+
+
+  Privilege:
+               System.View
+
+
+
+  Args:
+    host (`vim.HostSystem`_, optional):
+       If specified, the host whose capabilities are requested.
+
+
+
+
+  Returns:
+    `vim.host.Capability`_:
+         Returns the set of capabilities supported by the ComputeResource associated with the EnvironmentBrowser. If invoked on a cluster with no hosts, null is returned.
+
+  Raises:
+
+    `vmodl.fault.InvalidArgument`_: 
+       if an invalid host is specified , or a host is given when the EnvironmentBrowser is from a virtual machine.
+
+

docs/vim/ExtendedDescription.rst

@@ -0,0 +1,22 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _vSphere API 4.0: ../vim/version.rst#vimversionversion5
+
+.. _vim.Description: ../vim/Description.rst
+
+.. _vmodl.KeyAnyValue: ../vmodl/KeyAnyValue.rst
+
+
+vim.ExtendedDescription
+=======================
+  
+:extends: vim.Description_
+:since: `vSphere API 4.0`_
+
+Attributes:
+    messageCatalogKeyPrefix (`str`_):
+
+       Key to the localized message string in the catalog. If the localized string contains parameters, values to the parameters will be provided in #messageArg. E.g: If the message in the catalog is "IP address is {address}", value for "address" will be provided by #messageArg. Both summary and label in Description will have a corresponding entry in the message catalog with the keys.summary and.label respectively. Description.summary and Description.label will contain the strings in server locale.
+    messageArg (`vmodl.KeyAnyValue`_, optional):
+
+       Provides named arguments that can be used to localize the message in the catalog.

docs/vim/ExtendedElementDescription.rst

@@ -0,0 +1,22 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _vSphere API 4.0: ../vim/version.rst#vimversionversion5
+
+.. _vmodl.KeyAnyValue: ../vmodl/KeyAnyValue.rst
+
+.. _vim.ElementDescription: ../vim/ElementDescription.rst
+
+
+vim.ExtendedElementDescription
+==============================
+  
+:extends: vim.ElementDescription_
+:since: `vSphere API 4.0`_
+
+Attributes:
+    messageCatalogKeyPrefix (`str`_):
+
+       Key to the localized message string in the catalog. If the localized string contains parameters, values to the parameters will be provided in #messageArg. E.g: If the message in the catalog is "IP address is {address}", value for "address" will be provided by #messageArg. Both summary and label in ElementDescription will have a corresponding entry in the message catalog with the keys.summary and.label respectively. ElementDescription.summary and ElementDescription.label will contain the strings in server locale.
+    messageArg (`vmodl.KeyAnyValue`_, optional):
+
+       Provides named arguments that can be used to localize the message in the catalog.

docs/vim/ExtensibleManagedObject.rst

@@ -0,0 +1,71 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _name: ../vim/CustomFieldsManager/FieldDef.rst#name
+
+.. _vim.Task: ../vim/Task.rst
+
+.. _VI API 2.5: ../vim/version.rst#vimversionversion2
+
+.. _CustomFieldStringValue: ../vim/CustomFieldsManager/StringValue.rst
+
+.. _fieldInstancePrivileges: ../vim/CustomFieldsManager/FieldDef.rst#fieldInstancePrivileges
+
+.. _vmodl.fault.InvalidArgument: ../vmodl/fault/InvalidArgument.rst
+
+.. _vim.CustomFieldsManager.Value: ../vim/CustomFieldsManager/Value.rst
+
+.. _vim.CustomFieldsManager.FieldDef: ../vim/CustomFieldsManager/FieldDef.rst
+
+
+vim.ExtensibleManagedObject
+===========================
+   `ExtensibleManagedObject`_ provides methods and properties that provide access to custom fields that may be associated with a managed object. Use the `CustomFieldsManager`_ to define custom fields. The `CustomFieldsManager`_ handles the entire list of custom fields on a server. You can can specify the object type to which a particular custom field applies by setting its `managedObjectType`_ . (If you do not set a managed object type for a custom field definition, the field applies to all managed objects.)
+
+
+
+
+Attributes
+----------
+    value (`vim.CustomFieldsManager.Value`_):
+      privilege: System.View
+       List of custom field values. Each value uses a key to associate an instance of a `CustomFieldStringValue`_ with a custom field definition.
+    availableField (`vim.CustomFieldsManager.FieldDef`_):
+      privilege: System.View
+       List of custom field definitions that are valid for the object's type. The fields are sorted by `name`_ .
+
+
+Methods
+-------
+
+
+setCustomValue(key, value):
+   Assigns a value to a custom field. The setCustomValue method requires whichever updatePrivilege is defined as one of the `fieldInstancePrivileges`_ for the CustomFieldDef whose value is being changed.
+  since: `VI API 2.5`_
+
+
+  Privilege:
+               dynamic
+
+
+
+  Args:
+    key (`str`_):
+       The name of the field whose value is to be updated.
+
+
+    value (`str`_):
+       Value to be assigned to the custom field.
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vmodl.fault.InvalidArgument`_: 
+       if no custom field with that key exists.
+
+

docs/vim/Extension.rst

@@ -0,0 +1,109 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _datetime: https://docs.python.org/2/library/stdtypes.html
+
+.. _managedBy: ../vim/vm/ConfigSpec.rst#managedBy
+
+.. _VI API 2.5: ../vim/version.rst#vimversionversion2
+
+.. _vim.Description: ../vim/Description.rst
+
+.. _vmodl.DynamicData: ../vmodl/DynamicData.rst
+
+.. _vim.Extension.ServerInfo: ../vim/Extension/ServerInfo.rst
+
+.. _vim.Extension.HealthInfo: ../vim/Extension/HealthInfo.rst
+
+.. _vim.Extension.ClientInfo: ../vim/Extension/ClientInfo.rst
+
+.. _vim.ext.ManagedEntityInfo: ../vim/ext/ManagedEntityInfo.rst
+
+.. _vim.Extension.ResourceInfo: ../vim/Extension/ResourceInfo.rst
+
+.. _vim.Extension.TaskTypeInfo: ../vim/Extension/TaskTypeInfo.rst
+
+.. _vim.ext.ExtendedProductInfo: ../vim/ext/ExtendedProductInfo.rst
+
+.. _vim.Extension.EventTypeInfo: ../vim/Extension/EventTypeInfo.rst
+
+.. _vim.ext.SolutionManagerInfo: ../vim/ext/SolutionManagerInfo.rst
+
+.. _vim.Extension.PrivilegeInfo: ../vim/Extension/PrivilegeInfo.rst
+
+.. _vim.Extension.FaultTypeInfo: ../vim/Extension/FaultTypeInfo.rst
+
+.. _vim.Extension.OvfConsumerInfo: ../vim/Extension/OvfConsumerInfo.rst
+
+
+vim.Extension
+=============
+  This data object type contains all information about an extension. An extension may contain zero or more server interfaces and zero or more clients.
+:extends: vmodl.DynamicData_
+:since: `VI API 2.5`_
+
+Attributes:
+    description (`vim.Description`_):
+
+       Description of extension.
+    key (`str`_):
+
+       Extension key. Should follow java package naming conventions for uniqueness (e.g. "com.example.management").Extension names can only contain characters belonging to the lower ASCII character set (UTF-7) with the exception of the following characters:
+        * All whitespace characters ("space" - ascii character 0x20 is allowed)
+        * Control characters
+        * Comma (ascii 0x2c), Forward slash (ascii 0x2f), Backward slash (ascii 0x5c), Hash/Pound (ascii 0x23), Plus (ascii 0x2b), Greater (ascii 0x3e), Lesser (ascii 0x3c), Equals (ascii 0x3d), Semi-colon (ascii 0x3b) and Double quote (ascii 0x22).
+    company (`str`_, optional):
+
+       Company information.
+    type (`str`_, optional):
+
+       Type of extension (example may include CP-DVS, NUOVA-DVS, etc.).
+    version (`str`_):
+
+       Extension version number as a dot-separated string. For example, "1.0.0"
+    subjectName (`str`_, optional):
+
+       Subject name from client certificate.
+    server (`vim.Extension.ServerInfo`_, optional):
+
+       Servers for this extension.
+    client (`vim.Extension.ClientInfo`_, optional):
+
+       Clients for this extension.
+    taskList (`vim.Extension.TaskTypeInfo`_, optional):
+
+       Definitions of tasks defined by this extension.
+    eventList (`vim.Extension.EventTypeInfo`_, optional):
+
+       Definitions of events defined by this extension.
+    faultList (`vim.Extension.FaultTypeInfo`_, optional):
+
+       Definitions of faults defined by this extension.
+    privilegeList (`vim.Extension.PrivilegeInfo`_, optional):
+
+       Definitions privileges defined by this extension.
+    resourceList (`vim.Extension.ResourceInfo`_, optional):
+
+       Resource data for all locales
+    lastHeartbeatTime (`datetime`_):
+
+       Last extension heartbeat time.
+    healthInfo (`vim.Extension.HealthInfo`_, optional):
+
+       Health specification provided by this extension.
+    ovfConsumerInfo (`vim.Extension.OvfConsumerInfo`_, optional):
+
+       OVF consumer specification provided by this extension.
+    extendedProductInfo (`vim.ext.ExtendedProductInfo`_, optional):
+
+       Extended product information, such as URLs to vendor, product, etc.
+    managedEntityInfo (`vim.ext.ManagedEntityInfo`_, optional):
+
+       Information about entities managed by this extension. An extension can register virtual machines as managed by itself, by setting the `managedBy`_ property of the virtual machine.
+    shownInSolutionManager (`bool`_, optional):
+
+       Opt-in to the Solution Manager. If set to true, this extension will be shown in the Solution Manager. If not set, or set to false, this extension is not shown in the Solution Manager.
+    solutionManagerInfo (`vim.ext.SolutionManagerInfo`_, optional):
+
+       Solution Manager configuration for this extension.

docs/vim/Extension/ClientInfo.rst

@@ -0,0 +1,31 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _VI API 2.5: ../../vim/version.rst#vimversionversion2
+
+.. _vim.Description: ../../vim/Description.rst
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+
+vim.Extension.ClientInfo
+========================
+  This data object type describes a client of the extension.
+:extends: vmodl.DynamicData_
+:since: `VI API 2.5`_
+
+Attributes:
+    version (`str`_):
+
+       Client version number as a dot-separated string. For example, "1.0.0"
+    description (`vim.Description`_):
+
+       Description of client.
+    company (`str`_):
+
+       Company information.
+    type (`str`_):
+
+       Type of client (examples may include win32, .net, linux, etc.).
+    url (`str`_):
+
+       Plugin url.

docs/vim/Extension/EventTypeInfo.rst

@@ -0,0 +1,33 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _VI API 2.5: ../../vim/version.rst#vimversionversion2
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+
+vim.Extension.EventTypeInfo
+===========================
+  This data object type describes event types defined by the extension.
+:extends: vmodl.DynamicData_
+:since: `VI API 2.5`_
+
+Attributes:
+    eventID (`str`_):
+
+       The ID of the event type. Should follow java package naming conventions for uniqueness.
+    eventTypeSchema (`str`_, optional):
+
+       Optional XML descriptor for the EventType. The structure of this descriptor is:EventTypeeventTypeIDeventID/eventTypeIDdescriptionOptional description for event eventID/description!-- Optional arguments: --arguments!-- Zero or more of: --argumentnameargName/nametypeargtype/name/argument/arguments/EventTypewhereargtypecan be one of the following:
+        * string
+        * 
+        * moid
+        * 
+        * long
+        * 
+        * int
+        * 
+        * bool
+        * 
+        * Note:
+        * moid
+        * is really just a string, with some additional semantic meaning attached - that it is the identifier of some object in the inventory, and can be looked up by a client that is so inclined.

docs/vim/Extension/FaultTypeInfo.rst

@@ -0,0 +1,17 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _VI API 2.5: ../../vim/version.rst#vimversionversion2
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+
+vim.Extension.FaultTypeInfo
+===========================
+  This data object type describes fault types defined by the extension.
+:extends: vmodl.DynamicData_
+:since: `VI API 2.5`_
+
+Attributes:
+    faultID (`str`_):
+
+       The ID of the fault type. Should follow java package naming conventions for uniqueness.

docs/vim/Extension/HealthInfo.rst

@@ -0,0 +1,16 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _vSphere API 4.0: ../../vim/version.rst#vimversionversion5
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+
+vim.Extension.HealthInfo
+========================
+  This data object encapsulates the health specification for the extension.
+:extends: vmodl.DynamicData_
+:since: `vSphere API 4.0`_
+
+Attributes:
+    url (`str`_):
+

docs/vim/Extension/OvfConsumerInfo.rst

@@ -0,0 +1,20 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _vSphere API 5.0: ../../vim/version.rst#vimversionversion7
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+
+vim.Extension.OvfConsumerInfo
+=============================
+  This data object contains configuration for extensions that also extend the OVF functionality of vCenter server.Note:This feature is for internal use only.
+:extends: vmodl.DynamicData_
+:since: `vSphere API 5.0`_
+
+Attributes:
+    callbackUrl (`str`_):
+
+       Callback url for the OVF consumer. This URL must point to a SOAP API implementing the OVF consumer interface.Example: https://extension-host:8081/This callback is for internal use only.
+    sectionType (`str`_):
+
+       A list of fully qualified OVF section types that this consumer handles.Fully qualified means that each section type must be prefixed with its namespace enclosed in curly braces. See the examples below.An InvalidArgument error is thrown if there is overlap between OVF consumers, meaning that the same section type appears in the sectionType list of more than one OVF consumer.Example: [ "{http://www.vmware.com/schema/vServiceManager}vServiceDependency", "{http://www.vmware.com/schema/vServiceManager}vServiceBinding" ]

docs/vim/Extension/PrivilegeInfo.rst

@@ -0,0 +1,22 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _VI API 2.5: ../../vim/version.rst#vimversionversion2
+
+.. _privGroupName: ../../vim/AuthorizationManager/Privilege.rst#privGroupName
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+
+vim.Extension.PrivilegeInfo
+===========================
+  This data object type describes privileges defined by the extension.
+:extends: vmodl.DynamicData_
+:since: `VI API 2.5`_
+
+Attributes:
+    privID (`str`_):
+
+       The ID of the privilege. The format should begroup name.privilege name. The group name should be the same as the privGroupName property.The privilege name should follow java package naming conventions for uniqueness. The set of characters allowed follow the same rules as `key`_ .
+    privGroupName (`str`_):
+
+       Hierarchical group name. Each level of the grouping hierarchy is separated by a "." so group names may not include a ".". `privGroupName`_ .

docs/vim/Extension/ResourceInfo.rst

@@ -0,0 +1,23 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _VI API 2.5: ../../vim/version.rst#vimversionversion2
+
+.. _vim.KeyValue: ../../vim/KeyValue.rst
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+
+vim.Extension.ResourceInfo
+==========================
+  This data object encapsulates the message resources for all locales.
+:extends: vmodl.DynamicData_
+:since: `VI API 2.5`_
+
+Attributes:
+    locale (`str`_):
+
+    module (`str`_):
+
+       Module for a resource type and other message or fault resources. Examples: "task" for task, "event" for event and "auth" for "privilege".
+    data (`vim.KeyValue`_):
+

docs/vim/Extension/ServerInfo.rst

@@ -0,0 +1,34 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _VI API 2.5: ../../vim/version.rst#vimversionversion2
+
+.. _vim.Description: ../../vim/Description.rst
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+
+vim.Extension.ServerInfo
+========================
+  This data object type describes a server for the extension.
+:extends: vmodl.DynamicData_
+:since: `VI API 2.5`_
+
+Attributes:
+    url (`str`_):
+
+       Server url.
+    description (`vim.Description`_):
+
+       Server description.
+    company (`str`_):
+
+       Company information.
+    type (`str`_):
+
+       Type of server (examples may include SOAP, REST, HTTP, etc.).
+    adminEmail (`str`_):
+
+       Extension administrator email addresses.
+    serverThumbprint (`str`_, optional):
+
+       Thumbprint of the extension server certificate presented to clients

docs/vim/Extension/TaskTypeInfo.rst

@@ -0,0 +1,17 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _VI API 2.5: ../../vim/version.rst#vimversionversion2
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+
+vim.Extension.TaskTypeInfo
+==========================
+  This data object type describes task types defined by the extension.
+:extends: vmodl.DynamicData_
+:since: `VI API 2.5`_
+
+Attributes:
+    taskID (`str`_):
+
+       The ID of the task type. Should follow java package naming conventions for uniqueness.

docs/vim/ExtensionManager.rst

@@ -0,0 +1,278 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _vim.Task: ../vim/Task.rst
+
+.. _VI API 2.5: ../vim/version.rst#vimversionversion2
+
+.. _vim.Extension: ../vim/Extension.rst
+
+.. _IpPoolManager: ../vim/IpPoolManager.rst
+
+.. _vSphere API 4.0: ../vim/version.rst#vimversionversion5
+
+.. _vSphere API 5.1: ../vim/version.rst#vimversionversion8
+
+.. _vSphere API 5.0: ../vim/version.rst#vimversionversion7
+
+.. _vim.ManagedEntity: ../vim/ManagedEntity.rst
+
+.. _vim.fault.NotFound: ../vim/fault/NotFound.rst
+
+.. _LoginExtensionByCertificate: ../vim/SessionManager.rst#loginExtensionByCertificate
+
+.. _vmodl.fault.InvalidArgument: ../vmodl/fault/InvalidArgument.rst
+
+.. _vim.fault.NoClientCertificate: ../vim/fault/NoClientCertificate.rst
+
+.. _vim.ExtensionManager.IpAllocationUsage: ../vim/ExtensionManager/IpAllocationUsage.rst
+
+
+vim.ExtensionManager
+====================
+  This managed object type provides directory and basic management services for all registered extensions.Clients use the ExtensionManager, available in `ServiceInstance`_ , to access extension objects.While several authentication methods are available for extension servers to use (see `SessionManager`_ ), only one authentication method is valid for an extension at any given time.
+
+
+:since: `VI API 2.5`_
+
+
+Attributes
+----------
+    extensionList (`vim.Extension`_):
+      privilege: System.View
+       The list of currently registered extensions.
+
+
+Methods
+-------
+
+
+UnregisterExtension(extensionKey):
+   Unregisters the specified extension if it exists.
+
+
+  Privilege:
+               Extension.Unregister
+
+
+
+  Args:
+    extensionKey (`str`_):
+       Unique name of extension to unregister.
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vim.fault.NotFound`_: 
+       if the specified extension is not registered.
+
+
+FindExtension(extensionKey):
+   Returns extension with the given key, if any.
+
+
+  Privilege:
+               System.View
+
+
+
+  Args:
+    extensionKey (`str`_):
+       Key to search for.
+
+
+
+
+  Returns:
+    `vim.Extension`_:
+         Extension that matches given key, if any.
+
+
+RegisterExtension(extension):
+   Registers extension.
+
+
+  Privilege:
+               Extension.Register
+
+
+
+  Args:
+    extension (`vim.Extension`_):
+       Extension description to register.
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vmodl.fault.InvalidArgument`_: 
+       if the Extension description is incomplete or an extension is already registered with the given unique key, or if the extension is an OVF extension and its section types overlap with other registered OVF extensions.
+
+
+UpdateExtension(extension):
+   If the key specified in the extension exists, the existing record is updated.If thesubjectNameproperty of the Extension object has a value, and it is different from the existing value, this method will unset any public key or certificate associated with the extension.
+
+
+  Privilege:
+               Extension.Update
+
+
+
+  Args:
+    extension (`vim.Extension`_):
+       Updated extension description.
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vim.fault.NotFound`_: 
+       if the specified extension key is not registered.
+
+    `vmodl.fault.InvalidArgument`_: 
+       if the Extension description is incomplete or invalid, or if the extension is an OVF extension and its section types overlap with other registered OVF extensions.
+
+
+GetPublicKey():
+   Returns VirtualCenter Server public key.
+
+
+  Privilege:
+               System.View
+
+
+
+  Args:
+
+
+  Returns:
+    `str`_:
+         Public key of VirtualCenter Server, encoded in PEM (privacy-enhanced mail) format.
+
+
+SetPublicKey(extensionKey, publicKey):
+   Sets extension's public key.This method will unset any subject name or certificate associated with the extension.
+
+
+  Privilege:
+               Extension.Update
+
+
+
+  Args:
+    extensionKey (`str`_):
+       Key of extension to update.
+
+
+    publicKey (`str`_):
+       Public key of extension, encoded in PEM (privacy-enhanced mail) format.
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vmodl.fault.InvalidArgument`_: 
+       if the public key is invalid.
+
+
+SetExtensionCertificate(extensionKey, certificatePem):
+   Update the stored authentication certificate for a specified extension. Updates the registration of the specified extension with the thumbprint of the X.509 client certificate provided over SSL handshake, or by thecertificatePemargument. The thumbprint will be used to authenticate the extension during invocations of `LoginExtensionByCertificate`_ .NOTE: No verification is performed on the received certificate, such as expiry or revocation.This method will unset any public key or subject name associated with the extension.
+  since: `vSphere API 4.0`_
+
+
+  Privilege:
+               Extension.Update
+
+
+
+  Args:
+    extensionKey (`str`_):
+       Key of extension to update.
+
+
+    certificatePem (`str`_, optional):
+       PEM encoded certificate. If not specified, the certificate passed over SSL handshake is used.
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vim.fault.NotFound`_: 
+       if an extension specified byextensionKeyis not registered.
+
+    `vim.fault.NoClientCertificate`_: 
+       if certificatePem is not specified, and no certificate was passed over SSL handshake.
+
+    `vmodl.fault.InvalidArgument`_: 
+       if the certificate described bycertificatePemis not in PEM format, or could not be decoded to an X.509 certificate.
+
+
+QueryManagedBy(extensionKey):
+   Find entities managed by an extension. These can be either virtual machines or vApps.
+  since: `vSphere API 5.0`_
+
+
+  Privilege:
+               System.View
+
+
+
+  Args:
+    extensionKey (`str`_):
+       Key of the extension to find managed entities for.
+
+
+
+
+  Returns:
+    `vim.ManagedEntity`_:
+         List of entities managed by the extension.
+
+
+QueryExtensionIpAllocationUsage(extensionKeys):
+   Query statistics about IP allocation usage, either system wide or for specified extensions.Refer to `IpPoolManager`_ for details.
+  since: `vSphere API 5.1`_
+
+
+  Privilege:
+               System.View
+
+
+
+  Args:
+    extensionKeys (`str`_, optional):
+       List of extensions whose IP allocation is being queried. If no extension keys are specified then allocation data for all registered extensions are returned.
+
+
+
+
+  Returns:
+    `vim.ExtensionManager.IpAllocationUsage`_:
+         List of IP allocation usage.
+
+

docs/vim/ExtensionManager/IpAllocationUsage.rst

@@ -0,0 +1,22 @@
+.. _int: https://docs.python.org/2/library/stdtypes.html
+
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _vSphere API 5.1: ../../vim/version.rst#vimversionversion8
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+
+vim.ExtensionManager.IpAllocationUsage
+======================================
+  This data object type contains usage information about an extension's IP allocation usage.
+:extends: vmodl.DynamicData_
+:since: `vSphere API 5.1`_
+
+Attributes:
+    extensionKey (`str`_):
+
+       Key of the extension whose usage is being reported.
+    numAddresses (`int`_):
+
+       Number of IP addresses allocated from IP pools.

docs/vim/FileManager.rst

@@ -0,0 +1,323 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _vim.Task: ../vim/Task.rst
+
+.. _VI API 2.5: ../vim/version.rst#vimversionversion2
+
+.. _Rename_Task: ../vim/ManagedEntity.rst#rename
+
+.. _CloneVM_Task: ../vim/VirtualMachine.rst#clone
+
+.. _Destroy_Task: ../vim/ManagedEntity.rst#destroy
+
+.. _FileNotFound: ../vim/fault/FileNotFound.rst
+
+.. _vim.Datacenter: ../vim/Datacenter.rst
+
+.. _RelocateVM_Task: ../vim/VirtualMachine.rst#relocate
+
+.. _vSphere API 4.0: ../vim/version.rst#vimversionversion5
+
+.. _vim.fault.FileFault: ../vim/fault/FileFault.rst
+
+.. _vim.fault.FileLocked: ../vim/fault/FileLocked.rst
+
+.. _vim.fault.NoDiskSpace: ../vim/fault/NoDiskSpace.rst
+
+.. _vim.fault.UserNotFound: ../vim/fault/UserNotFound.rst
+
+.. _vim.fault.FileNotFound: ../vim/fault/FileNotFound.rst
+
+.. _vim.fault.CannotDeleteFile: ../vim/fault/CannotDeleteFile.rst
+
+.. _vim.fault.InvalidDatastore: ../vim/fault/InvalidDatastore.rst
+
+.. _vim.fault.CannotCreateFile: ../vim/fault/CannotCreateFile.rst
+
+.. _vim.fault.CannotAccessFile: ../vim/fault/CannotAccessFile.rst
+
+.. _vim.fault.FileAlreadyExists: ../vim/fault/FileAlreadyExists.rst
+
+
+vim.FileManager
+===============
+  This managed object type provides a way to manage and manipulate files and folders on datastores. The source and the destination names are in the form of a URL or a datastore path.A URL has the formscheme://authority/folder/path?dcPath=dcPath=dsNamewhere
+   * scheme
+   * is
+   * http
+   * or
+   * https
+   * .
+   * authority
+   * specifies the hostname or IP address of the VirtualCenter or ESX server and optionally the port.
+   * dcPath
+   * is the inventory path to the Datacenter containing the Datastore.
+   * dsName
+   * is the name of the Datastore.
+   * path
+   * is a slash-delimited path from the root of the datastore.A datastore path has the form[datastore]pathwhere
+   * datastore
+   * is the datastore name.
+   * path
+   * is a slash-delimited path from the root of the datastore.An example datastore path is "[storage] path/to/file.extension". A listing of all the files, disks and folders on a datastore can be obtained from the datastore browser.See `HostDatastoreBrowser`_ 
+
+
+:since: `VI API 2.5`_
+
+
+Attributes
+----------
+
+
+Methods
+-------
+
+
+MoveDatastoreFile(sourceName, sourceDatacenter, destinationName, destinationDatacenter, force):
+   Moves the source file or folder to the destination.If the destination file does not exist, it is created. If the destination file exists, the force parameter determines whether to overwrite it with the source or not. If the source path is a folder, then the destination path must not exist; the destination cannot be overwritten even with a force flag in that case. Folder moves are recursive, treating all files and disks to move as binary.If source (or destination) name is specified as a URL, then the corresponding datacenter parameter may be omitted.If any intermediate level folder specified by the source and destination does not exist, a `FileNotFound`_ fault is thrown.If a file of a virtual machine is moved, it may corrupt that virtual machine. If a file of a virtual machine is overwritten on the destination datastore as a result of the force parameter, it may corrupt that virtual machine.If the source is an extent of a virtual disk, this operation treats the extent as a file.If source and destination resolve to the same file system location, the call has no effect.It is important to note that this operation will provide transactional guarantees only for a file. No guarantees are provided for folder moves. If the intent is to move a virtual machine registered in the inventory, with transactional guarantees, please refer to `RelocateVM_Task`_ . If the intent is to rename a virtual machine registered in the inventory, please refer to `Rename_Task`_ .Datastore.FileManagement privilege is required on both source and destination datastores.
+
+
+  Privilege:
+               dynamic
+
+
+
+  Args:
+    sourceName (`str`_):
+       The name of the source, either a URL or a datastore path referring to the file or folder to be moved.
+
+
+    sourceDatacenter (`vim.Datacenter`_, optional):
+       IfsourceNameis a datastore path, the datacenter for that datastore path. Not needed when invoked directly on ESX. If not specified on a call to VirtualCenter,sourceNamemust be a URL.
+
+
+    destinationName (`str`_):
+       The name of the destination, either a URL or a datastore path referring to the destination file or folder.
+
+
+    destinationDatacenter (`vim.Datacenter`_, optional):
+       IfdestinationNameis a datastore path, the datacenter for that datastore path. Not needed when invoked directly on ESX. If not specified on a call to VirtualCenter, it is assumed that the destination path belongs to the source datacenter.
+
+
+    force (`bool`_, optional):
+       If true, overwrite any identically named file at the destination. If not specified, it is assumed to be false.
+
+
+
+
+  Returns:
+     `vim.Task`_:
+         
+
+  Raises:
+
+    `vim.fault.InvalidDatastore`_: 
+       if the operation cannot be performed on the source or destination datastores. Typically, a specific subclass of this exception is thrown.
+
+    `vim.fault.FileFault`_: 
+       if there is a generic file error
+
+    `vim.fault.FileNotFound`_: 
+       if the file or folder specified by sourceName is not found, or, any intermediate level folder specified by the destinationName is not found.
+
+    `vim.fault.CannotAccessFile`_: 
+       if the source file or folder cannot be moved because of insufficient permissions.
+
+    `vim.fault.FileLocked`_: 
+       if the source file or folder is currently locked or in use.
+
+    `vim.fault.FileAlreadyExists`_: 
+       if a file with the given name already exists at the destination, and the force flag is false. For folders, if the destination exists, this fault is thrown regardless.
+
+    `vim.fault.NoDiskSpace`_: 
+       if there is not enough space available on the destination datastore.
+
+
+CopyDatastoreFile(sourceName, sourceDatacenter, destinationName, destinationDatacenter, force):
+   Copies the source file or folder to the destination.If the destination file does not exist, it is created. If the destination file exists, the force parameter determines whether to overwrite it with the source or not. Folders can be copied recursively. In this case, the destination, if it exists, must be a folder, else one will be created. Existing files on the destination that conflict with source files can be overwritten using the force parameter. Files and disks are always copied in binary format during recursive copy.If source (or destination) name is specified as a URL, then the corresponding datacenter parameter may be omitted.If any intermediate level folder specified by the source and destination does not exist, a `FileNotFound`_ fault is thrown.If a file of a virtual machine is overwritten on the destination datastore as a result of the force parameter, it may corrupt that virtual machine.If the source is an extent of a virtual disk, this operation treats the extent as a file.If source and destination resolve to the same file system location, the call has no effect.It is important to note that this operation will provide transactional guarantees only for a file. No guarantees are provided when copying a folder. If the intent is to clone a virtual machine registered in the inventory, with transactional guarantees, please refer to `CloneVM_Task`_ .Datastore.FileManagement privilege is required on both source and destination datastores.
+
+
+  Privilege:
+               dynamic
+
+
+
+  Args:
+    sourceName (`str`_):
+       The name of the source, either a URL or a datastore path referring to the file or folder to be copied.
+
+
+    sourceDatacenter (`vim.Datacenter`_, optional):
+       IfsourceNameis a datastore path, the datacenter for that datastore path. Not needed when invoked directly on ESX. If not specified on a call to VirtualCenter,sourceNamemust be a URL.
+
+
+    destinationName (`str`_):
+       The name of the destination, either a URL or a datastore path referring to the destination file or folder.
+
+
+    destinationDatacenter (`vim.Datacenter`_, optional):
+       IfdestinationNameis a datastore path, the datacenter for that datastore path. Not needed when invoked directly on ESX. If not specified on a call to VirtualCenter, it is assumed that the destination path belongs to the source datacenter.
+
+
+    force (`bool`_, optional):
+       If true, overwrite any identically named file at the destination. If not specified, it is assumed to be false.
+
+
+
+
+  Returns:
+     `vim.Task`_:
+         
+
+  Raises:
+
+    `vim.fault.InvalidDatastore`_: 
+       if the operation cannot be performed on the source or destination datastores. Typically, a specific subclass of this exception is thrown.
+
+    `vim.fault.FileFault`_: 
+       if there is a generic file error
+
+    `vim.fault.FileNotFound`_: 
+       if the file or folder specified by sourceName is not found, or, any intermediate level folder specified by the destinationName is not found.
+
+    `vim.fault.CannotAccessFile`_: 
+       if the source cannot be accessed because of insufficient permissions.
+
+    `vim.fault.FileLocked`_: 
+       if the source file or folder is currently locked or in use.
+
+    `vim.fault.FileAlreadyExists`_: 
+       if a file with the given name already exists at the destination, and the force flag is false.
+
+    `vim.fault.NoDiskSpace`_: 
+       if there is not enough space available at the destination datastore.
+
+
+DeleteDatastoreFile(name, datacenter):
+   Deletes the specified file or folder from the datastore. If a file of a virtual machine is deleted, it may corrupt that virtual machine. Folder deletes are always recursive. The datacenter parameter may be omitted if a URL is used to name the file or folder.If the source is an extent of a virtual disk, this operation treats the extent as a file.It is important to note that this operation will provide transactional guarantees only for a file. No guarantees are provided when deleting folders. If the intent is to delete a virtual machine registered in the inventory, please refer to `Destroy_Task`_ .Requires Datastore.FileManagement privilege on the datastore.
+
+
+  Privilege:
+               dynamic
+
+
+
+  Args:
+    name (`str`_):
+       The name of the file or folder, either a URL or a datastore path referring to the file or folder to be deleted.
+
+
+    datacenter (`vim.Datacenter`_, optional):
+       Ifnameis a datastore path, the datacenter for that datastore path. Not needed when invoked directly on ESX. If not specified on a call to VirtualCenter,namemust be a URL.
+
+
+
+
+  Returns:
+     `vim.Task`_:
+         
+
+  Raises:
+
+    `vim.fault.InvalidDatastore`_: 
+       if the operation cannot be performed on the datastore. Typically, a specific subclass of this exception is thrown.
+
+    `vim.fault.FileFault`_: 
+       if there is a generic file error
+
+    `vim.fault.FileNotFound`_: 
+       if the file or folder specified by name is not found.
+
+    `vim.fault.CannotDeleteFile`_: 
+       if the delete operation on the file or folder fails.
+
+    `vim.fault.FileLocked`_: 
+       if the source file or folder is currently locked or in use.
+
+
+MakeDirectory(name, datacenter, createParentDirectories):
+   Create a folder using the specified name. If the parent or intermediate level folders do not exist, and the parameter createParentDirectories is false, a `FileNotFound`_ fault is thrown. If the intermediate level folders do not exist, and the parameter createParentDirectories is true, all the non-existent folders are created.Requires Datastore.FileManagement privilege on the datastore.
+
+
+  Privilege:
+               dynamic
+
+
+
+  Args:
+    name (`str`_):
+       The name of the folder, either a URL or a datastore path referring to the folder to be created.
+
+
+    datacenter (`vim.Datacenter`_, optional):
+       Ifnameis a datastore path, the datacenter for that datastore path. Not needed when invoked directly on ESX. If not specified on a call to VirtualCenter,namemust be a URL.
+
+
+    createParentDirectories (`bool`_, optional):
+       If true, any non-existent intermediate level folders will be created. If not specified, it is assumed to be false.
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vim.fault.InvalidDatastore`_: 
+       if the operation cannot be performed on the datastore. Typically, a specific subclass of this exception is thrown.
+
+    `vim.fault.FileFault`_: 
+       if there is a generic file error
+
+    `vim.fault.CannotCreateFile`_: 
+       if the create operation on the folder fails.
+
+    `vim.fault.FileAlreadyExists`_: 
+       if a file or folder with the given name already exists at the destination.
+
+    `vim.fault.FileNotFound`_: 
+       if the createParentDirectories is false and a intermediate level folder specified by name is not found.
+
+
+ChangeOwner(name, datacenter, owner):
+   Change the owner for a file.This method is currently not supported.
+  since: `vSphere API 4.0`_
+
+
+  Privilege:
+               dynamic
+
+
+
+  Args:
+    name (`str`_):
+
+
+    datacenter (`vim.Datacenter`_, optional):
+
+
+    owner (`str`_):
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vim.fault.InvalidDatastore`_: 
+       vim.fault.InvalidDatastore
+
+    `vim.fault.FileFault`_: 
+       vim.fault.FileFault
+
+    `vim.fault.UserNotFound`_: 
+       vim.fault.UserNotFound
+
+

docs/vim/Folder.rst

@@ -0,0 +1,717 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _vim.Task: ../vim/Task.rst
+
+.. _childType: ../vim/Folder.rst#childType
+
+.. _vim.Folder: ../vim/Folder.rst
+
+.. _VI API 2.5: ../vim/version.rst#vimversionversion2
+
+.. _DVSCreateSpec: ../vim/DistributedVirtualSwitch/CreateSpec.rst
+
+.. _vim.Datacenter: ../vim/Datacenter.rst
+
+.. _vim.StoragePod: ../vim/StoragePod.rst
+
+.. _vim.HostSystem: ../vim/HostSystem.rst
+
+.. _vSphere API 5.0: ../vim/version.rst#vimversionversion7
+
+.. _vSphere API 4.0: ../vim/version.rst#vimversionversion5
+
+.. _vim.ResourcePool: ../vim/ResourcePool.rst
+
+.. _vim.fault.NoHost: ../vim/fault/NoHost.rst
+
+.. _vim.vm.ConfigSpec: ../vim/vm/ConfigSpec.rst
+
+.. _vim.ManagedEntity: ../vim/ManagedEntity.rst
+
+.. _vim.fault.DvsFault: ../vim/fault/DvsFault.rst
+
+.. _vim.VirtualMachine: ../vim/VirtualMachine.rst
+
+.. _vim.fault.NotFound: ../vim/fault/NotFound.rst
+
+.. _vim.fault.FileFault: ../vim/fault/FileFault.rst
+
+.. _vim.ComputeResource: ../vim/ComputeResource.rst
+
+.. _MoveIntoFolder_Task: ../vim/Folder.rst#moveInto
+
+.. _vim.host.ConnectSpec: ../vim/host/ConnectSpec.rst
+
+.. _vim.fault.OutOfBounds: ../vim/fault/OutOfBounds.rst
+
+.. _vim.fault.InvalidName: ../vim/fault/InvalidName.rst
+
+.. _vim.fault.InvalidState: ../vim/fault/InvalidState.rst
+
+.. _vim.cluster.ConfigSpec: ../vim/cluster/ConfigSpec.rst
+
+.. _vim.fault.InvalidLogin: ../vim/fault/InvalidLogin.rst
+
+.. _vim.fault.VmWwnConflict: ../vim/fault/VmWwnConflict.rst
+
+.. _vim.fault.AlreadyExists: ../vim/fault/AlreadyExists.rst
+
+.. _vim.fault.InvalidFolder: ../vim/fault/InvalidFolder.rst
+
+.. _vim.fault.VmConfigFault: ../vim/fault/VmConfigFault.rst
+
+.. _vim.fault.DuplicateName: ../vim/fault/DuplicateName.rst
+
+.. _vim.cluster.ConfigSpecEx: ../vim/cluster/ConfigSpecEx.rst
+
+.. _vmodl.fault.NotSupported: ../vmodl/fault/NotSupported.rst
+
+.. _vim.fault.SSLVerifyFault: ../vim/fault/SSLVerifyFault.rst
+
+.. _DistributedVirtualSwitch: ../vim/DistributedVirtualSwitch.rst
+
+.. _vim.fault.InvalidDatastore: ../vim/fault/InvalidDatastore.rst
+
+.. _vim.fault.ConcurrentAccess: ../vim/fault/ConcurrentAccess.rst
+
+.. _vim.ClusterComputeResource: ../vim/ClusterComputeResource.rst
+
+.. _vim.fault.AlreadyConnected: ../vim/fault/AlreadyConnected.rst
+
+.. _vim.fault.NotSupportedHost: ../vim/fault/NotSupportedHost.rst
+
+.. _vim.fault.HostConnectFault: ../vim/fault/HostConnectFault.rst
+
+.. _vim.fault.DvsNotAuthorized: ../vim/fault/DvsNotAuthorized.rst
+
+.. _vmodl.fault.InvalidArgument: ../vmodl/fault/InvalidArgument.rst
+
+.. _vim.fault.FileAlreadyExists: ../vim/fault/FileAlreadyExists.rst
+
+.. _vim.fault.AgentInstallFailed: ../vim/fault/AgentInstallFailed.rst
+
+.. _vim.DistributedVirtualSwitch: ../vim/DistributedVirtualSwitch.rst
+
+.. _vim.fault.AlreadyBeingManaged: ../vim/fault/AlreadyBeingManaged.rst
+
+.. _vmodl.fault.NotEnoughLicenses: ../vmodl/fault/NotEnoughLicenses.rst
+
+.. _vim.ComputeResource.ConfigSpec: ../vim/ComputeResource/ConfigSpec.rst
+
+.. _vim.fault.InsufficientResourcesFault: ../vim/fault/InsufficientResourcesFault.rst
+
+.. _vim.fault.VmAlreadyExistsInDatacenter: ../vim/fault/VmAlreadyExistsInDatacenter.rst
+
+.. _vim.DistributedVirtualSwitch.CreateSpec: ../vim/DistributedVirtualSwitch/CreateSpec.rst
+
+.. _vim.fault.DisallowedOperationOnFailoverHost: ../vim/fault/DisallowedOperationOnFailoverHost.rst
+
+
+vim.Folder
+==========
+  The `Folder`_ managed object is a container for storing and organizing inventory objects. Folders can contain folders and other objects. The `childType`_ property identifies a folder's type and determines the types of folders and objects the folder can contain.
+   * A folder can contain a child folder of the same type as the parent folder.
+   * All
+   * `Datacenter`_
+   * objects contain dedicated folders for:
+   * 
+   * 
+   * `VirtualMachine`_
+   * , templates, and
+   * `VirtualApp`_
+   * objects.
+   * 
+   * `ComputeResource`_
+   * hierarchies.
+   * 
+   * `Network`_
+   * ,
+   * `DistributedVirtualSwitch`_
+   * , and
+   * `DistributedVirtualPortgroup`_
+   * objects.
+   * 
+   * `Datastore`_
+   * objects.
+   * 
+   * A folder can contain child objects of type
+   * `childType`_
+   * . Virtual machine and network entity folders can also contain additional object types.
+   * The root folder is a data center folder.
+   * See
+   * `ServiceInstance`_
+   * for a representation of the organization of the inventory.
+   * The
+   * `Folder`_
+   * managed object also acts as a factory object, meaning it creates new entities in a folder. The object provides methods to create child folders and objects, methods to add existing objects to folders, and methods to remove objects from folders and to delete folders.
+   * 
+   * `Folder`_
+   * inherits the
+   * `Destroy_Task`_
+   * method.
+   * `Destroy_Task`_
+   * is a recursive operation that removes all child objects and folders. When you call
+   * `Destroy_Task`_
+   * to destroy a folder, the system uses the specified folder as a root and traverses its descendant hierarchy, calling
+   * `Destroy_Task`_
+   * on each object.
+   * `Destroy_Task`_
+   * is a single operation that treats each recursive call as a single transaction, committing each call to remove an object individually. If
+   * `Destroy_Task`_
+   * fails on an object, the method terminates at that point with an exception, leaving some or all of the objects still in the inventory.
+   * Notes on the folder destroy method:
+   * 
+   * Calling
+   * `Destroy_Task`_
+   * on a virtual machine folder recursively calls
+   * `Destroy_Task`_
+   * on all the child virtual machines and vApps, which are then removed from disk. Use
+   * `UnregisterAndDestroy_Task`_
+   * to unregister virtual machines or vApps recursively without removing them from the disk.
+   * For virtual machine folders, the
+   * `Destroy_Task`_
+   * method requires the VirtualMachine.Delete privilege on the folder as well as all virtual machines to be destroyed. It also requires the VirtualApp.Delete privilege on all VirtualApp objects to be destroyed.
+   * Destroying a host folder or datacenter folder unregisters all child hosts and virtual machines from vCenter. The hosts are simply removed from the inventory, along with their virtual machines. The virtual machines are not removed from disk nor are their runtime states changed.
+   * You can remove network and datastore folders only if they are empty.
+   * You cannot destroy, rename, or move the virtual machine, compute resource, network entity, and datastore child folders of a Datacenter.
+   * 
+
+
+:extends: vim.ManagedEntity_
+
+
+Attributes
+----------
+    childType (`str`_):
+      privilege: System.View
+       Specifies the object types a folder may contain. When you create a folder, it inherits its childType from the parent folder in which it is created. childType is an array of strings. Each array entry identifies a set of object types - Folder and one or more managed object types. The following list shows childType values for the different folders:
+        * { "vim.Folder", "vim.Datacenter" } - Identifies the root folder and its descendant folders. Data center folders can contain child data center folders and Datacenter managed objects. Datacenter objects contain virtual machine, compute resource, network entity, and datastore folders.
+        * { "vim.Folder", "vim.Virtualmachine", "vim.VirtualApp" } - Identifies a virtual machine folder. A virtual machine folder may contain child virtual machine folders. It also can contain VirtualMachine managed objects, templates, and VirtualApp managed objects.
+        * { "vim.Folder", "vim.ComputeResource" } - Identifies a compute resource folder, which contains child compute resource folders and ComputeResource hierarchies.
+        * { "vim.Folder", "vim.Network" } - Identifies a network entity folder. Network entity folders on a vCenter Server can contain Network, DistributedVirtualSwitch, and DistributedVirtualPortgroup managed objects. Network entity folders on an ESXi host can contain only Network objects.
+        * { "vim.Folder", "vim.Datastore" } - Identifies a datastore folder. Datastore folders can contain child datastore folders and Datastore managed objects.
+    childEntity (`vim.ManagedEntity`_):
+      privilege: System.View
+       An array of managed object references. Each entry is a reference to a child entity.
+
+
+Methods
+-------
+
+
+CreateFolder(name):
+   Creates a new sub-folder with the specified name. The `childType`_ property of the new folder is the same as the `childType`_ property of the current folder.Any % (percent) character used in this name parameter must be escaped, unless it is used to start an escape sequence. Clients may also escape any other characters in this name parameter.
+
+
+  Privilege:
+               Folder.Create
+
+
+
+  Args:
+    name (`str`_):
+       The name to be given the new folder. An entity name must be a non-empty string of less than 80 characters. The slash (/), backslash (\) and percent (%) will be escaped using the URL syntax. For example, %2F.
+
+
+
+
+  Returns:
+    `vim.Folder`_:
+         A reference to the new folder.
+
+  Raises:
+
+    `vim.fault.DuplicateName`_: 
+       if another object in the same folder has the target name.
+
+    `vim.fault.InvalidName`_: 
+       if the name is not a valid entity name.
+
+
+MoveIntoFolder(list):
+   Moves a set of managed entities into this folder.This operation is typically used by clients when they implement a drag-and-drop interface to move a set of objects into a folder.This operation is transactional only with respect to each individual entity. The set of entities is moved sequentially as specified in the list, and committed one at a time. If the `MoveIntoFolder_Task`_ method fails on an object, the method terminates at that point with an exception, leaving the rest of the managed entities in their original location.The objects that can be moved into a folder depends on the folder's type (as defined by the folder's `childType`_ property). For a datacenter folder, only datacenters and datacenter folders can be moved into the folder. For a virtual machine folder, only virtual machines and virtual machine folders can be moved into the folder. For a host folder, ComputeResource objects, host folder objects, and HostSystem objects can be moved into the folder.Moving a HostSystem into a host folder creates a stand-alone host from a host that is currently part of a ClusterComputeResource. The host must be part of a ClusterComputeResource in the same datacenter and the host must be in maintenance mode. Otherwise, the operation fails.A ComputeResource with a single root resource pool is created for each HostSystem. The name of the ComputeResource is the DNS or IP address of the host. This operation moves the (physical) host resources out of a cluster. It does not move or change the ResourcePool configuration that is part of the ClusterComputeResource with which the host was associated.Note that all virtual machines associated with a host are moved with the host into the folder. If there are virtual machines that should not be moved with the host, then migrate them from the host before initiating this operation.For a HostSystem move, the privileges required are Host.Inventory.EditCluster on the source ClusterComputeResource, Host.Inventory.MoveHost on the HostSystem, and Host.Inventory.AddStandaloneHost on the target Folder.Otherwise, the privilege required for this operation varies depending on this folder's type and is checked against the source container, destination container, and the object:
+    * Folder.Move if the object is a Folder
+    * Datacenter.Move if the object is a Datacenter
+    * Host.Inventory.MoveCluster if the object is a ComputeResource
+    * VirtualMachine.Inventory.Move if the object is a virtual machine or virtual machine template
+    * DVSwitch.Move if the object is a DistributedVirtualSwitch
+    * Datastore.Move if the object is a datastore
+    * Network.Move if the object is a network
+    * If the object is a HostSystem, the privileges required are Host.Inventory.AddStandaloneHost on the folder, Host.Inventory.MoveHost on the HostSystem, and Host.Inventory.EditCluster on the host's original ComputeResource.
+
+
+  Privilege:
+               dynamic
+
+
+
+  Args:
+    list (`vim.ManagedEntity`_):
+       The list of objects to be moved into the folder.
+
+
+
+
+  Returns:
+     `vim.Task`_:
+         
+
+  Raises:
+
+    `vim.fault.DuplicateName`_: 
+       if this folder already contains an object with the specified name.
+
+    `vim.fault.InvalidFolder`_: 
+       if a Folder that is a parent of this Folder is part of the list of objects.
+
+    `vim.fault.InvalidState`_: 
+       if a HostSystem is not part of the same datacenter, not part of a ClusterComputeResource, or not in maintenance mode.
+
+    `vmodl.fault.NotSupported`_: 
+       if the entity is being moved into a folder whose `childType`_ property is not set to the appropriate value. For example, a VirtualMachine entity cannot be moved into a folder whose ChildType property value does not contain "VirtualMachine".
+
+    `vim.fault.DisallowedOperationOnFailoverHost`_: 
+       if the host is being moved out of a cluster and was configured as a failover host in that cluster. See `ClusterFailoverHostAdmissionControlPolicy`_ .
+
+    `vim.fault.VmAlreadyExistsInDatacenter`_: 
+       if moving a standalone host between datacenters, and one or more of the host's virtual machines is already registered to a host in the destination datacenter.
+
+
+CreateVM(config, pool, host):
+   Creates a new virtual machine in the current folder and attaches it to the specified resource pool. This operation creates a virtual machine, instead of cloning a virtual machine from an existing one.The server does not support creating templates using this method. Instead, you should create templates by marking existing virtual machines as templates, or by cloning an existing virtual machine or template.This operation only works if the folder's childType includes VirtualMachine. In addition to the VirtualMachine.Inventory.Create privilege, may also require any of the following privileges depending on the properties of the virtual machine bring created:
+    * VirtualMachine.Config.AddExistingDisk if including a virtual disk device that refers to an existing virtual disk file (not RDM)
+    * VirtualMachine.Config.AddNewDisk if including a virtual disk device that creates a new virtual disk file (not RDM)
+    * VirtualMachine.Config.RawDevice if including a raw device mapping (RDM) or SCSI passthrough device
+    * VirtualMachine.Config.HostUSBDevice if including a VirtualUSB device backed by a host USB device
+    * VirtualMachine.Config.AdvancedConfig if setting values in ConfigSpec.extraConfig
+    * VirtualMachine.Config.SwapPlacement if setting swapPlacement
+    * VirtualMachine.Config.ChangeTracking if setting changed block tracking for the virtual machine's disks.
+    * Datastore.AllocateSpace required on all datastores where the virtual machine and its virtual disks will be created
+    * Network.Assign required on the network which is assigned to the new virtual machine that is being created
+
+
+  Privilege:
+               VirtualMachine.Inventory.Create
+
+
+
+  Args:
+    config (`vim.vm.ConfigSpec`_):
+       The configuration of the virtual machine hardware.
+
+
+    pool (`vim.ResourcePool`_):
+       The resource pool to which the virtual machine will be attached.
+
+
+    host (`vim.HostSystem`_, optional):
+       The target host on which the virtual machine will run. This must specify a host that is a member of the ComputeResource indirectly specified by the pool. For a stand-alone host or a cluster with DRS, host can be omitted, and the system selects a default.
+
+
+
+
+  Returns:
+     `vim.Task`_:
+         the newly created VirtualMachine.
+
+  Raises:
+
+    `vim.fault.VmConfigFault`_: 
+       if the configSpec has incorrect values. Typically, a more specific subclass is thrown.
+
+    `vim.fault.FileFault`_: 
+       if there is a problem creating the virtual machine on disk. Typically, a more specific subclass, such as NoDiskSpace, will be thrown.
+
+    `vim.fault.OutOfBounds`_: 
+       if Host.capability.maxSupportedVMs is exceeded.
+
+    `vim.fault.DuplicateName`_: 
+       if another virtual machine in the same folder already has the specified target name.
+
+    `vim.fault.InvalidName`_: 
+       if the name is not a valid entity name.
+
+    `vim.fault.InvalidDatastore`_: 
+       if the operation cannot be performed on the target datastores.
+
+    `vim.fault.InsufficientResourcesFault`_: 
+       if this operation would violate a resource usage policy.
+
+    `vim.fault.AlreadyExists`_: 
+       if the requested cfgPath (or the default cfgPath) for the virtual machine's configuration file is already loaded in the inventory.
+
+    `vim.fault.InvalidState`_: 
+       if the operation is not allowed in current state of the entities involved.
+
+    `vim.fault.FileAlreadyExists`_: 
+       if the requested cfgPath for the virtual machine's configuration file already exists.
+
+    `vmodl.fault.NotSupported`_: 
+       if the virtual machine is being created within a folder whose `childType`_ property is not set to "VirtualMachine".
+
+    `vim.fault.VmWwnConflict`_: 
+       if the WWN of the virtual machine has been used by other virtual machines.
+
+
+RegisterVM(path, name, asTemplate, pool, host):
+   Adds an existing virtual machine to the folder.Any % (percent) character used in this name parameter must be escaped, unless it is used to start an escape sequence. Clients may also escape any other characters in this name parameter.This operation only works if the folder's type is VirtualMachine. In addition to the VirtualMachine.Inventory.Register and Resource.AssignVMToPool privileges, it requires System.Read privilege on the datastore that the existing virtual machine resides on.
+
+
+  Privilege:
+               VirtualMachine.Inventory.Register
+
+
+
+  Args:
+    path (`str`_):
+       A datastore path to the virtual machine.
+
+
+    name (`str`_, optional):
+       The name to be assigned to the virtual machine. If this parameter is not set, the displayName configuration parameter of the virtual machine is used. An entity name must be a non-empty string of less than 80 characters. The slash (/), backslash (\) and percent (%) will be escaped using the URL syntax. For example, %2F.
+
+
+    asTemplate (`bool`_):
+       Flag to specify whether or not the virtual machine should be marked as a template.
+
+
+    pool (`vim.ResourcePool`_, optional):
+       The resource pool to which the virtual machine should be attached. If imported as a template, this parameter is not set.
+
+
+    host (`vim.HostSystem`_, optional):
+       The target host on which the virtual machine will run. This parameter must specify a host that is a member of the ComputeResource indirectly specified by the pool. For a stand-alone host or a cluster with DRS, the parameter can be omitted, and the system selects a default.
+
+
+
+
+  Returns:
+     `vim.Task`_:
+         the newly registered VirtualMachine.
+
+  Raises:
+
+    `vim.fault.OutOfBounds`_: 
+       if the maximum number of VMs for this folder has been exceeded. The maximum number is determined by Host.capability.maxSupportedVMs.
+
+    `vim.fault.DuplicateName`_: 
+       if another virtual machine in the same folder has the target name.
+
+    `vim.fault.AlreadyExists`_: 
+       if the virtual machine is already registered.
+
+    `vim.fault.InvalidDatastore`_: 
+       if the operation cannot be performed on the target datastores.
+
+    `vim.fault.NotFound`_: 
+       if the configuration file is not found on the system.
+
+    `vim.fault.InvalidName`_: 
+       if the entity name is invalid.
+
+    `vim.fault.VmConfigFault`_: 
+       if the format / configuration of the virtual machine is invalid. Typically, a more specific fault is thrown such as InvalidFormat if the configuration file cannot be read, or InvalidDiskFormat if the disks cannot be read.
+
+    `vim.fault.InsufficientResourcesFault`_: 
+       if this operation would violate a resource usage policy.
+
+    `vim.fault.FileFault`_: 
+       if there is an error accessing the files on disk.
+
+    `vim.fault.InvalidState`_: 
+       if the operation is not allowed in current state of the entities involved.
+
+    `vmodl.fault.NotSupported`_: 
+       if the operation is not supported. For example, templates are not supported directly on hosts. Also, if the operation is invoked on a folder whose `childType`_ property is not set to "VirtualMachine".
+
+    `vmodl.fault.InvalidArgument`_: 
+       if any of the arguments such as host or resource pool are not set to valid values.
+
+
+CreateCluster(name, spec):
+   Creates a new cluster compute resource in this folder.Any % (percent) character used in this name parameter must be escaped, unless it is used to start an escape sequence. Clients may also escape any other characters in this name parameter.
+
+
+  Privilege:
+               Host.Inventory.CreateCluster
+
+
+
+  Args:
+    name (`str`_):
+       Name for the new cluster.
+
+
+    spec (`vim.cluster.ConfigSpec`_):
+       Specification for the cluster.
+
+
+
+
+  Returns:
+    `vim.ClusterComputeResource`_:
+         A new ClusterComputeResource instance.
+
+  Raises:
+
+    `vim.fault.DuplicateName`_: 
+       if an entity with that name already exists.
+
+    `vim.fault.InvalidName`_: 
+       if the name is not a valid entity name.
+
+    `vmodl.fault.InvalidArgument`_: 
+       if the cluster configuration specification parameter is invalid.
+
+    `vmodl.fault.NotSupported`_: 
+       if the cluster is being added to a folder whose `childType`_ property value does not contain "ComputeResource" or "ClusterComputeResource".
+
+
+CreateClusterEx(name, spec):
+   Creates a new cluster compute resource in this folder.Any % (percent) character used in this name parameter must be escaped, unless it is used to start an escape sequence. Clients may also escape any other characters in this name parameter.
+  since: `VI API 2.5`_
+
+
+  Privilege:
+               Host.Inventory.CreateCluster
+
+
+
+  Args:
+    name (`str`_):
+       Name for the new cluster.
+
+
+    spec (`vim.cluster.ConfigSpecEx`_):
+       Specification for the cluster.
+
+
+
+
+  Returns:
+    `vim.ClusterComputeResource`_:
+         A new ClusterComputeResource instance.
+
+  Raises:
+
+    `vim.fault.DuplicateName`_: 
+       if an entity with that name already exists.
+
+    `vim.fault.InvalidName`_: 
+       if the name is not a valid entity name.
+
+    `vmodl.fault.InvalidArgument`_: 
+       if the cluster configuration specification parameter is invalid.
+
+    `vmodl.fault.NotSupported`_: 
+       if the cluster is being added to a folder whose `childType`_ property value does not contain "ComputeResource" or "ClusterComputeResource".
+
+
+AddStandaloneHost(spec, compResSpec, addConnected, license):
+   Creates a new single-host compute resource. The name provided can be an IP address, such as 192.168.0.120, or a string, such as esx120. If a name is specified, a DNS lookup is used to resolve it to a fully-qualified name, such as esx120.vmware.com. If the DNS lookup fails, the string is stored as specified.Licenses for the host are allocated when making the first connection to the host. This is because the license needed typically depends on the type of host and the number of CPUs.In addition to the Host.Inventory.AddStandaloneHost privilege, it requires System.View privilege on the VM folder that the VMs of the host will be placed on.
+
+
+  Privilege:
+               Host.Inventory.AddStandaloneHost
+
+
+
+  Args:
+    spec (`vim.host.ConnectSpec`_):
+       The host name, port, and passwords for the host to be added.
+
+
+    compResSpec (`vim.ComputeResource.ConfigSpec`_, optional, since `VI API 2.5`_ ):
+       Optionally specify the configuration for the compute resource that will be created to contain the host.
+
+
+    addConnected (`bool`_):
+       Flag to specify whether or not the host should be connected as soon as it is added. The host will not be added if a connection attempt is made and fails.
+
+
+    license (`str`_, optional, since `vSphere API 4.0`_ ):
+       Provide a licenseKey or licenseKeyType. See `LicenseManager`_ 
+
+
+
+
+  Returns:
+     `vim.Task`_:
+         the newly added ComputeResource.
+
+  Raises:
+
+    `vim.fault.InvalidLogin`_: 
+       if authentication with the host fails.
+
+    `vim.fault.HostConnectFault`_: 
+       if an error occurred when attempting to connect to a host. Typically, a more specific subclass, such as AlreadyBeingManaged, is thrown.
+
+    `vim.fault.DuplicateName`_: 
+       if another host in the same folder has the name.
+
+    `vmodl.fault.InvalidArgument`_: 
+       if an argument is specified incorrectly.
+
+    `vim.fault.AlreadyBeingManaged`_: 
+       if the host is already being managed by a vCenter server. If the host is being managed by a different vCenter server, this can be overridden by the "force" flag in the connection specification.
+
+    `vmodl.fault.NotEnoughLicenses`_: 
+       if there are not enough licenses to add the host.
+
+    `vim.fault.NoHost`_: 
+       if the host cannot be contacted.
+
+    `vmodl.fault.NotSupported`_: 
+       if the host is being added to a folder whose `childType`_ property does not contain "ComputeResource".
+
+    `vim.fault.NotSupportedHost`_: 
+       if the host is running a software version that is not supported.
+
+    `vim.fault.AgentInstallFailed`_: 
+       if there is an error installing the vCenter agent on the new host.
+
+    `vim.fault.AlreadyConnected`_: 
+       if addConnected is true and the host is already connected to vCenter.
+
+    `vim.fault.SSLVerifyFault`_: 
+       if the host certificate could not be authenticated
+
+
+CreateDatacenter(name):
+   Creates a new datacenter with the given name.Any % (percent) character used in this name parameter must be escaped, unless it is used to start an escape sequence. Clients may also escape any other characters in this name parameter.
+
+
+  Privilege:
+               Datacenter.Create
+
+
+
+  Args:
+    name (`str`_):
+       Name for the new datacenter. An entity name must be a non-empty string of less than 80 characters. The slash (/), backslash (\) and percent (%) will be escaped using the URL syntax. For example, %2F.
+
+
+
+
+  Returns:
+    `vim.Datacenter`_:
+         A new Datacenter instance.
+
+  Raises:
+
+    `vim.fault.DuplicateName`_: 
+       if an entity with that name already exists.
+
+    `vim.fault.InvalidName`_: 
+       if the new name is not a valid entity name.
+
+    `vmodl.fault.NotSupported`_: 
+       if the datacenter is being created within a folder whose `childType`_ property value does not contain "Datacenter".
+
+
+UnregisterAndDestroy():
+   Recursively unregisters all virtual machines and vApps, and destroys all child virtual machine folders. This is similar to the Destroy_Task method, but this method calls UnregisterAndDestroy_Task on each virtual machine object instead of calling Destroy_Task. This operation applies only to VirtualMachine folders.UnregisterAndDestroy_Task is a recursive operation that destroys the specified virtual machine folder, unregisters all child virtual machine objects, and destroys all child virtual machine folders. When you call UnregisterAndDestroy_Task to destroy a virtual machine folder, the system uses the specified folder as a root and traverses its descendant hierarchy, calling UnregisterAndDestroy_Task on each virtual machine object and Destroy_Task on each virtual machine folder. UnregisterAndDestroy_Task is a single operation that treats each recursive call as a single transaction, committing each call to remove an object individually. If a failure occurs, the method terminates at that point with an exception, leaving some or all objects unaffected.If you are removing virtual machines, you must hold the VirtualMachine.Delete privilege on all of the virtual machines to be unregistered, and on their parent folders. If you are removing virtual applications, you must hold the VApp.Delete privilege on all of the virtual applications to be unregistered, and on their parent folders.
+
+
+  Privilege:
+               Folder.Delete
+
+
+
+  Args:
+
+
+  Returns:
+     `vim.Task`_:
+         
+
+  Raises:
+
+    `vim.fault.ConcurrentAccess`_: 
+       if another client modifies the folder contents before this operation completes.
+
+    `vim.fault.InvalidState`_: 
+       if a virtual machine is not powered off or suspended.
+
+    `vmodl.fault.NotSupported`_: 
+       if the `childType`_ property of the folder is not set to "VirtualMachine".
+
+
+CreateDVS(spec):
+   Create a `DistributedVirtualSwitch`_ in the folder according to the specified `DVSCreateSpec`_ . The specified Folder must be a Network entity folder.
+  since: `vSphere API 4.0`_
+
+
+  Privilege:
+               DVSwitch.Create
+
+
+
+  Args:
+    spec (`vim.DistributedVirtualSwitch.CreateSpec`_):
+       The `DVSCreateSpec`_ to create the distributed virtual switch.
+
+
+
+
+  Returns:
+     `vim.Task`_:
+         A new DistributedVirtualSwitch instance.
+
+  Raises:
+
+    `vim.fault.DvsFault`_: 
+       vim.fault.DvsFault
+
+    `vim.fault.DuplicateName`_: 
+       vim.fault.DuplicateName
+
+    `vim.fault.InvalidName`_: 
+       vim.fault.InvalidName
+
+    `vim.fault.NotFound`_: 
+       vim.fault.NotFound
+
+    `vim.fault.DvsNotAuthorized`_: 
+       if login-session's extension key does not match ( `extensionKey`_ ).
+
+    `vmodl.fault.NotSupported`_: 
+       if called directly on a host.
+
+
+CreateStoragePod(name):
+   Creates a new storage pod in this folder.Any % (percent) character used in this name parameter must be escaped, unless it is used to start an escape sequence. Clients may also escape any other characters in this name parameter.
+  since: `vSphere API 5.0`_
+
+
+  Privilege:
+               Folder.Create
+
+
+
+  Args:
+    name (`str`_):
+       Name for the new storage pod.
+
+
+
+
+  Returns:
+    `vim.StoragePod`_:
+         A new StoragePod instance.
+
+  Raises:
+
+    `vim.fault.DuplicateName`_: 
+       if an entity with that name already exists.
+
+    `vim.fault.InvalidName`_: 
+       if the name is not a valid entity name.
+
+    `vmodl.fault.NotSupported`_: 
+       if the storage pod is being added to a folder whose `childType`_ property value does not contain "StoragePod".
+
+

docs/vim/HbrManager/ReplicationVmInfo.rst

@@ -0,0 +1,36 @@
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _VirtualMachine: ../../vim/VirtualMachine.rst
+
+.. _vSphere API 5.0: ../../vim/version.rst#vimversionversion7
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+.. _HbrCreateInstance_Task: ../../vim/HbrManager.rst#createInstance
+
+.. _vmodl.LocalizedMethodFault: ../../vmodl/LocalizedMethodFault.rst
+
+.. _HbrStartOfflineInstance_Task: ../../vim/HbrManager.rst#startOfflineInstance
+
+.. _vim.HbrManager.ReplicationVmInfo.ProgressInfo: ../../vim/HbrManager/ReplicationVmInfo/ProgressInfo.rst
+
+
+vim.HbrManager.ReplicationVmInfo
+================================
+  This data object represents the essential information about the state of a given replicated `VirtualMachine`_ .
+:extends: vmodl.DynamicData_
+:since: `vSphere API 5.0`_
+
+Attributes:
+    state (`str`_):
+
+       A string representing the current State of the virtual machine.
+    progressInfo (`vim.HbrManager.ReplicationVmInfo.ProgressInfo`_, optional):
+
+       Progress stats for the current operation. Never present if the state is not "syncing" or "active". If not present while in one of these states, the host is still gathering initial operation statistics (progress can be assumed to be 0).
+    imageId (`str`_, optional):
+
+       An optional imageId that identifies the instance being created, this is the imagId string that is passed to `HbrCreateInstance_Task`_ or `HbrStartOfflineInstance_Task`_ 
+    lastError (`vmodl.LocalizedMethodFault`_, optional):
+
+       A MethodFault representing the last replication specific error that the `VirtualMachine`_ encountered during a create instance operation. The successful creation of an instance will clear any error.

docs/vim/HbrManager/ReplicationVmInfo/ProgressInfo.rst

@@ -0,0 +1,31 @@
+.. _int: https://docs.python.org/2/library/stdtypes.html
+
+.. _long: https://docs.python.org/2/library/stdtypes.html
+
+.. _vSphere API 5.0: ../../../vim/version.rst#vimversionversion7
+
+.. _vmodl.DynamicData: ../../../vmodl/DynamicData.rst
+
+
+vim.HbrManager.ReplicationVmInfo.ProgressInfo
+=============================================
+  A set of statistics related to the progress of the current operation (full sync or lwd).
+:extends: vmodl.DynamicData_
+:since: `vSphere API 5.0`_
+
+Attributes:
+    progress (`int`_):
+
+       An estimation of the operation progress as a percentage completed, from 0 to 100.
+    bytesTransferred (`long`_):
+
+       Number of bytes transferred so far.For sync operations, this value includes (i.e. counts multiple times) areas that were transferred multiple times (due to stopping and continuing the operation, or for some errors).
+    bytesToTransfer (`long`_):
+
+       The total number of bytes to be transferred.For lwd operations, this is the total size of the disk images that are transferring. This is known from the start and will not change during a lwd operation.For sync operations, this is the total size of the blocks that have been found not to match between the primary and secondary (by comparing checksums). It starts from 0 and grows as the checksum operations advance. The value includes (i.e. counts multiple times) areas that will end up being transferred more than once (due to stopping and continuing the operation, or for some errors).
+    checksumTotalBytes (`long`_, optional):
+
+       The total number of bytes to be checksummed, only present for sync tasks. This is the total size of all disks.
+    checksumComparedBytes (`long`_, optional):
+
+       The total number of bytes that were checksummed, only present for sync tasks.

docs/vim/HbrManager/ReplicationVmInfo/State.rst

@@ -0,0 +1,35 @@
+.. _VirtualMachine: ../../../vim/VirtualMachine.rst
+
+.. _vim.HbrManager.ReplicationVmInfo: ../../../vim/HbrManager/ReplicationVmInfo.rst
+
+.. _vim.HbrManager.ReplicationVmInfo.State: ../../../vim/HbrManager/ReplicationVmInfo/State.rst
+
+vim.HbrManager.ReplicationVmInfo.State
+======================================
+  Describes the current state of a replicated `VirtualMachine`_ 
+  :contained by: `vim.HbrManager.ReplicationVmInfo`_
+
+  :type: `vim.HbrManager.ReplicationVmInfo.State`_
+
+  :name: error
+
+values:
+--------
+
+none
+   The `VirtualMachine`_ has no current replication state. This is a virtual machine that is configured for replication, but is powered off and not undergoing offline replication.
+
+syncing
+   One or more of the `VirtualMachine`_ disks is in the process of an initial synchronization with the remote site.
+
+paused
+   The `VirtualMachine`_ replication is paused.
+
+idle
+   The `VirtualMachine`_ is being replicated but is not currently in the process of having a consistent instance created.
+
+error
+   The `VirtualMachine`_ is unable to replicate due to errors.XXX Currently unused.
+
+active
+   The `VirtualMachine`_ is in the process of having a consistent instance created.

docs/vim/HistoricalInterval.rst

@@ -0,0 +1,73 @@
+.. _int: https://docs.python.org/2/library/stdtypes.html
+
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _rollup type: ../vim/PerformanceManager/CounterInfo/RollupType.rst
+
+.. _rollup types: ../vim/PerformanceManager/CounterInfo/RollupType.rst
+
+.. _vmodl.DynamicData: ../vmodl/DynamicData.rst
+
+.. _UpdatePerfInterval: ../vim/PerformanceManager.rst#updateHistoricalInterval
+
+.. _CreatePerfInterval: ../vim/PerformanceManager.rst#createHistoricalInterval
+
+
+vim.HistoricalInterval
+======================
+  This data object type contains metadata about a performance interval.
+   * For VirtualCenter Server systems, instances of this data object are referred to as
+   * historical intervals
+   * because they control how data collected from the ESX systems will be aggregated and stored in the database.
+   * For ESX system, this data object is typically referred to simply as the
+   * interval
+   * or
+   * performance interval
+   * because ESX does not aggregate statistical data.For ESX systems, a single instance of this data object exists. It cannot be modified. It has these properties:keysamplingPeriodlengthnamelevelenabled1300129600PastDaynulltrueVirtualCenter Server system provides four instances of this data object by default, that apply globally to all system entities.Example Collection LevelsVirtualCenter Server uses the specifications configured in its historical intervals to collect metrics from the ESX systems that it manages. The quantity of data collected depends on the level settings for the server, and the level associated with a specific counter. Both factors may change from one version of the products to the next. In general, the lower the number, the smaller the amount of data collected. For VirtualCenter Server 2.5, for example, the levels 1 through 4 collected data as follows:
+   * Basic counters defined with "average"
+   * `rollup type`_
+   * for CPU, Memory, Disk, and Network; plus counters for System Uptime, System Heartbeat, and DRS (Distributed Resource Scheduler, tracked in the "clusterServices" group). Does not include counters for devices.
+   * Counters defined with "average," "summation," and "latest"
+   * `rollup types`_
+   * for CPU, Memory, Disk, and Network; plus counters for System Uptime, System Heartbeat, and DRS (clusterServices). Does not include counters for devices.
+   * Counters defined with "average," "summmation," and "latest"
+   * `rollup types`_
+   * for CPU, Memory, Disk, Network, and all devices; plus counters for System Uptime, System Heartbeat, and DRS (clusterServices).
+   * All counters defined for all entities and devices, for every
+   * `rollup type`_
+   * , including
+   * minimum
+   * and
+   * maximum
+   * Default properties for the four built-in historical intervals include:keysamplingPeriodlengthnamelevelenabled130086400Pastday1true21800604800Pastweek1true372002592000Pastmonth1true46640031536000Pastyear1trueAll values are in seconds. The default setting for vCenter Server is level 1, which retains sampled statistical data as follows:
+   * 5-minute samples for the past day
+   * 30-minute samples for the past week
+   * 2-hour samples for the past month
+   * 1-day samples for the past yearData older than a year is purged from the vCenter Server database.Prior to version 25 of the API, this data object could be used in conjunction with the `CreatePerfInterval`_ operation, to define new, custom historical intervals. That operation has been deprecated: Adding and deleting objects of this type is no longer supported. However, the default historical intervals can be enabled or disabled, and can be modified within certain limits (with the `UpdatePerfInterval`_ operation)
+:extends: vmodl.DynamicData_
+
+Attributes:
+    key (`int`_):
+
+       A unique identifier for the interval.
+    samplingPeriod (`int`_):
+
+       Number of seconds that data is sampled for this interval. The real-time samplingPeriod is 20 seconds.
+    name (`str`_):
+
+       The name of the historical interval. A localized string that provides a name for the interval. Names include:
+        * "Past Day"
+        * "Past Week"
+        * "Past Month"
+        * "Past Year"The name is not meaningful in terms of system behavior. That is, the interval namedPast Weekworks as it does because of its length, level, and so on, not because of the value of this string.
+    length (`int`_):
+
+       Number of seconds that the statistics corresponding to this interval are kept on the system.
+    level (`int`_, optional):
+
+       Statistics collection level for this historical interval. vCenter Server will aggregate only those statistics that match the value of this property for this historical interval. For ESX, the value of this property is null. For vCenter Server, the value will be a number from 1 to 4.
+    enabled (`bool`_):
+
+       Indicates whether the interval is enabled (true) or disabled (false). Disabling a historical interval prevents vCenter Server from collecting metrics for that interval and all higher (longer) intervals.For example, disabling the "Past Month" interval disables both "Past Month" and "Past Year" intervals. The system will aggregate and retain performance data using the "Past Day" and "Past Week" intervals only.

docs/vim/HistoryCollector.rst

@@ -0,0 +1,122 @@
+.. _int: https://docs.python.org/2/library/stdtypes.html
+
+.. _object: https://docs.python.org/2/library/stdtypes.html
+
+.. _vim.Task: ../vim/Task.rst
+
+.. _ReadNextTasks: ../vim/TaskHistoryCollector.rst#readNext
+
+.. _ReadNextEvents: ../vim/event/EventHistoryCollector.rst#readNext
+
+.. _ReadPreviousTasks: ../vim/TaskHistoryCollector.rst#readPrev
+
+.. _ReadPreviousEvents: ../vim/event/EventHistoryCollector.rst#readPrev
+
+.. _vmodl.fault.InvalidArgument: ../vmodl/fault/InvalidArgument.rst
+
+
+vim.HistoryCollector
+====================
+  This managed object type enables clients to retrieve historical data and receive updates when the server appends new data to a collection. This is a base type for item-specific types related to event or task history. Historical data is inherently append-only, although a server administrator may periodically purge old data.Typically, a client creates a history collector by using a filter on a potentially large set, such as all the events in a datacenter. The collector provides access to the items that match the filter, which could also be a relatively large set.The items in a collector are always ordered by date and time of creation. Item properties normally include this time stamp.The client may set the "viewable latest page" for the collector, which is the contiguous subset of the items that are of immediate interest. These items are available as the "latestPage" property, which the client may retrieve and monitor by using the `PropertyCollector`_ managed object.Clients can change the page size of the "latestPage" by using `setLatestPageSize()`_ .The client may use the following features of the history collector.
+   * `RewindCollector`_
+   * - Moves the "scrollable view" to the oldest item (the default setting).
+   * readNext - Retrieves all the items in the collector, from the oldest item to the newest item. Retrieves either
+   * `tasks`_
+   * or
+   * `events`_
+   * depending on the operation.
+   * readPrev - Retrieves all items (excluding the "viewable latest page") in the collector, from the newest item to the oldest item. Retrieves either
+   * `tasks`_
+   * or
+   * `events`_
+   * depending on the operation.
+   * `ResetCollector`_
+   * - Moves the "scrollable view" to the item immediately preceding the "viewable latest page".
+   * 
+
+
+
+
+Attributes
+----------
+    filter (`object`_):
+       The filter used to create this collector.The type of the returned filter is determined by the managed object for which the collector is created.
+
+
+Methods
+-------
+
+
+SetCollectorPageSize(maxCount):
+   Sets the "viewable latest page" size to contain at most the number of items specified by the maxCount parameter).
+
+
+  Privilege:
+
+
+
+  Args:
+    maxCount (`int`_):
+       The maximum number of items in the page.
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vmodl.fault.InvalidArgument`_: 
+       if maxCount is out of range.
+
+
+RewindCollector():
+   Moves the "scrollable view" to the oldest item. If you use `ReadNextTasks`_ or `ReadNextEvents`_ , all items are retrieved from the oldest item to the newest item. This is the default setting when the collector is created.
+
+
+  Privilege:
+
+
+
+  Args:
+
+
+  Returns:
+    None
+         
+
+
+ResetCollector():
+   Moves the "scrollable view" to the item immediately preceding the "viewable latest page". If you use "readPrev", `ReadPreviousTasks`_ or `ReadPreviousEvents`_ , all items are retrieved from the newest item to the oldest item.
+
+
+  Privilege:
+
+
+
+  Args:
+
+
+  Returns:
+    None
+         
+
+
+DestroyCollector():
+   Destroys this collector.
+
+
+  Privilege:
+
+
+
+  Args:
+
+
+  Returns:
+    None
+         
+
+

docs/vim/HostServiceTicket.rst

@@ -0,0 +1,31 @@
+.. _int: https://docs.python.org/2/library/stdtypes.html
+
+.. _str: https://docs.python.org/2/library/stdtypes.html
+
+.. _vmodl.DynamicData: ../vmodl/DynamicData.rst
+
+
+vim.HostServiceTicket
+=====================
+  Return value for ticketable host services. The server has the option to provide a hostname and port for a future ticket-authenticated connection to a service on a host. If the service provider does not return a host the client must connect to the same host it used to request the ticket. In case the service provider does not return a port, except in the case of connecting to CIM interfaces, the client must connect using the same port it used to request the ticket. In the case of connecting to a CIM interface the standard well known port number for the particular service will be used for the connection.For example, when a client requests a ticket from an ESX Server, the returned ticket may omit the optional host and port. In such a case, the client establishes an out-of-band ticketed connection to the same server host and on the same port on which it made the connection to request the ticket. If this request is made to the VirtualCenter server, but the server does not provide the required service directly, then the server provides a hostname and port for a server that accepts the ticketed connection and provides the service.
+:extends: vmodl.DynamicData_
+
+Attributes:
+    host (`str`_, optional):
+
+       The name of the host providing the service for which the ticket applies. If omitted, then the client uses the host name for the server that issued the ticket.
+    port (`int`_, optional):
+
+       Access to some services is made possible by connecting to a port on a server. If the service for which a ticket is issued is available on a particular port, that port number is specified with this property. If omitted, except in the case of connecting to CIM interfaces, the port number for the service that issued the ticket is used. In the case of connecting to a CIM interface the standard well known port for the particular service will be used for the connection.
+    sslThumbprint (`str`_, optional):
+
+       The expected thumbprint of the SSL cert of the host to which we are connecting.
+    service (`str`_):
+
+       The name of the service to which to connect.
+    serviceVersion (`str`_):
+
+       A dot-separated string identifying the service protocol version. For example, 1.0 is used for NFC hosted by vpxa on ESX 2.5, and 1.1 is used for NFC hosted by hostd on ESX 3.0.
+    sessionId (`str`_):
+
+       An identifying string for the session created for the ticketed connection. This is used by the host service to identify the operations permitted within the session.

docs/vim/HostSystem.rst

@@ -0,0 +1,777 @@
+.. _int: https://docs.python.org/2/library/stdtypes.html
+
+.. _long: https://docs.python.org/2/library/stdtypes.html
+
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _vim.Task: ../vim/Task.rst
+
+.. _hardware: ../vim/HostSystem.rst#hardware
+
+.. _VI API 2.5: ../vim/version.rst#vimversionversion2
+
+.. _vim.Network: ../vim/Network.rst
+
+.. _HostIpmiInfo: ../vim/host/IpmiInfo.rst
+
+.. _HostFlagInfo: ../vim/host/FlagInfo.rst
+
+.. _vim.Datastore: ../vim/Datastore.rst
+
+.. _adminDisabled: ../vim/host/ConfigInfo.rst#adminDisabled
+
+.. _LicenseManager: ../vim/LicenseManager.rst
+
+.. _vSphere API 5.1: ../vim/version.rst#vimversionversion8
+
+.. _vSphere API 5.0: ../vim/version.rst#vimversionversion7
+
+.. _vSphere API 4.0: ../vim/version.rst#vimversionversion5
+
+.. _vSphere API 4.1: ../vim/version.rst#vimversionversion6
+
+.. _vim.host.Summary: ../vim/host/Summary.rst
+
+.. _standbySupported: ../vim/host/Capability.rst#standbySupported
+
+.. _vim.fault.NoHost: ../vim/fault/NoHost.rst
+
+.. _vim.vm.ConfigInfo: ../vim/vm/ConfigInfo.rst
+
+.. _vim.host.FlagInfo: ../vim/host/FlagInfo.rst
+
+.. _shutdownSupported: ../vim/host/Capability.rst#shutdownSupported
+
+.. _vim.ManagedEntity: ../vim/ManagedEntity.rst
+
+.. _vim.host.IpmiInfo: ../vim/host/IpmiInfo.rst
+
+.. _EnterLockdownMode: ../vim/HostSystem.rst#enterLockdownMode
+
+.. _vim.fault.Timedout: ../vim/fault/Timedout.rst
+
+.. _vim.VirtualMachine: ../vim/VirtualMachine.rst
+
+.. _vim.host.Capability: ../vim/host/Capability.rst
+
+.. _vim.host.ConfigInfo: ../vim/host/ConfigInfo.rst
+
+.. _vim.host.ConnectInfo: ../vim/host/ConnectInfo.rst
+
+.. _AuthorizationManager: ../vim/AuthorizationManager.rst
+
+.. _vim.host.RuntimeInfo: ../vim/host/RuntimeInfo.rst
+
+.. _vim.host.ConnectSpec: ../vim/host/ConnectSpec.rst
+
+.. _vim.fault.InvalidName: ../vim/fault/InvalidName.rst
+
+.. _vim.HostServiceTicket: ../vim/HostServiceTicket.rst
+
+.. _vim.host.HardwareInfo: ../vim/host/HardwareInfo.rst
+
+.. _vim.fault.InvalidLogin: ../vim/fault/InvalidLogin.rst
+
+.. _vim.host.ConfigManager: ../vim/host/ConfigManager.rst
+
+.. _vim.fault.InvalidState: ../vim/fault/InvalidState.rst
+
+.. _vim.fault.AdminDisabled: ../vim/fault/AdminDisabled.rst
+
+.. _vim.host.MaintenanceSpec: ../vim/host/MaintenanceSpec.rst
+
+.. _vmodl.fault.NotSupported: ../vmodl/fault/NotSupported.rst
+
+.. _vim.fault.SSLVerifyFault: ../vim/fault/SSLVerifyFault.rst
+
+.. _vim.fault.DasConfigFault: ../vim/fault/DasConfigFault.rst
+
+.. _vim.host.DatastoreBrowser: ../vim/host/DatastoreBrowser.rst
+
+.. _vim.fault.HostConfigFault: ../vim/fault/HostConfigFault.rst
+
+.. _vim.fault.AdminNotDisabled: ../vim/fault/AdminNotDisabled.rst
+
+.. _vim.fault.NotSupportedHost: ../vim/fault/NotSupportedHost.rst
+
+.. _vim.fault.HostConnectFault: ../vim/fault/HostConnectFault.rst
+
+.. _HostSystemSwapConfiguration: ../vim/host/SystemSwapConfiguration.rst
+
+.. _vmodl.fault.InvalidArgument: ../vmodl/fault/InvalidArgument.rst
+
+.. _vim.fault.HostPowerOpFailed: ../vim/fault/HostPowerOpFailed.rst
+
+.. _vmodl.fault.RequestCanceled: ../vmodl/fault/RequestCanceled.rst
+
+.. _vim.host.SystemResourceInfo: ../vim/host/SystemResourceInfo.rst
+
+.. _vim.HostSystem.ReconnectSpec: ../vim/HostSystem/ReconnectSpec.rst
+
+.. _vim.host.TpmAttestationReport: ../vim/host/TpmAttestationReport.rst
+
+.. _vim.fault.AlreadyBeingManaged: ../vim/fault/AlreadyBeingManaged.rst
+
+.. _vmodl.fault.NotEnoughLicenses: ../vmodl/fault/NotEnoughLicenses.rst
+
+.. _vim.fault.InvalidIpmiLoginInfo: ../vim/fault/InvalidIpmiLoginInfo.rst
+
+.. _vim.fault.InvalidIpmiMacAddress: ../vim/fault/InvalidIpmiMacAddress.rst
+
+.. _vim.host.SystemSwapConfiguration: ../vim/host/SystemSwapConfiguration.rst
+
+.. _vim.fault.DisableAdminNotSupported: ../vim/fault/DisableAdminNotSupported.rst
+
+.. _vim.host.Capability.rebootSupported: ../vim/host/Capability.rst#rebootSupported
+
+.. _vim.LicenseManager.LicensableResourceInfo: ../vim/LicenseManager/LicensableResourceInfo.rst
+
+
+vim.HostSystem
+==============
+  The HostSystem managed object type provides access to a virtualization host platform.Invoking destroy on a HostSystem of standalone type throws a NotSupported fault. A standalone HostSystem can be destroyed only by invoking destroy on its parent ComputeResource. Invoking destroy on a failover host throws a `DisallowedOperationOnFailoverHost`_ fault. See `ClusterFailoverHostAdmissionControlPolicy`_ .
+
+
+:extends: vim.ManagedEntity_
+
+
+Attributes
+----------
+    runtime (`vim.host.RuntimeInfo`_):
+       Runtime state information about the host such as connection state.
+    summary (`vim.host.Summary`_):
+       Basic information about the host, including connection state.
+    hardware (`vim.host.HardwareInfo`_):
+       Hardware configuration of the host. This might not be available for a disconnected host.
+    capability (`vim.host.Capability`_):
+       Host capabilities. This might not be available for a disconnected host.
+    licensableResource (`vim.LicenseManager.LicensableResourceInfo`_):
+       Information about all licensable resources, currently present on this host.This information is used mostly by the modules, manipulating information in the `LicenseManager`_ . Developers of such modules should use this property instead of `hardware`_ .NOTE: The values in this property may not be accurate for pre-5.0 hosts when returned by vCenter 5.0
+    configManager (`vim.host.ConfigManager`_):
+       Host configuration systems. In releases after vSphere API 5.0, vSphere Servers might not generate property collector update notifications for this property. To obtain the latest value of the property, you can use PropertyCollector methods RetrievePropertiesEx or WaitForUpdatesEx. If you use the PropertyCollector.WaitForUpdatesEx method, specify an empty string for the version parameter. Any other version value will not produce any property values as no updates are generated.
+    config (`vim.host.ConfigInfo`_):
+       Host configuration information. This might not be available for a disconnected host.
+    vm (`vim.VirtualMachine`_):
+       List of virtual machines associated with this host.
+    datastore (`vim.Datastore`_):
+      privilege: System.View
+       A collection of references to the subset of datastore objects in the datacenter that are available in this HostSystem.
+    network (`vim.Network`_):
+      privilege: System.View
+       A collection of references to the subset of network objects in the datacenter that are available in this HostSystem.
+    datastoreBrowser (`vim.host.DatastoreBrowser`_):
+      privilege: System.View
+       DatastoreBrowser to browse datastores for this host.
+    systemResources (`vim.host.SystemResourceInfo`_):
+       Reference for the system resource hierarchy, used for configuring the set of resources reserved to the system and unavailable to virtual machines.
+
+
+Methods
+-------
+
+
+QueryTpmAttestationReport():
+   Basic information about TPM attestation state of the host.
+  since: `vSphere API 5.1`_
+
+
+  Privilege:
+               System.Read
+
+
+
+  Args:
+
+
+  Returns:
+    `vim.host.TpmAttestationReport`_:
+         
+
+
+QueryHostConnectionInfo():
+   Connection-oriented information about a host.
+
+
+  Privilege:
+               System.Read
+
+
+
+  Args:
+
+
+  Returns:
+    `vim.host.ConnectInfo`_:
+         
+
+
+UpdateSystemResources(resourceInfo):
+   Update the configuration of the system resource hierarchy.
+
+
+  Privilege:
+               Host.Config.Resources
+
+
+
+  Args:
+    resourceInfo (`vim.host.SystemResourceInfo`_):
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vmodl.fault.InvalidArgument`_: 
+       if the resource specification is invalid.
+
+
+UpdateSystemSwapConfiguration(sysSwapConfig):
+   Update the System Swap Configuration.See `HostSystemSwapConfiguration`_ 
+  since: `vSphere API 5.1`_
+
+
+  Privilege:
+               Host.Config.Settings
+
+
+
+  Args:
+    sysSwapConfig (`vim.host.SystemSwapConfiguration`_):
+       Contains a list of system swap options that configure the system swap functionality.See `HostSystemSwapConfiguration`_ 
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vmodl.fault.InvalidArgument`_: 
+       if the supplied sysSwapConfig is not correct.See `HostSystemSwapConfiguration`_ 
+
+
+ReconnectHost(cnxSpec, reconnectSpec):
+   Reconnects to a host. This process reinstalls agents and reconfigures the host, if it has gotten out of date with VirtualCenter. The reconnection process goes through many of the same steps as addHost: ensuring the correct set of licenses for the number of CPUs on the host, ensuring the correct set of agents is installed, and ensuring that networks and datastores are discovered and registered with VirtualCenter.The client can change the IP address and port of the host when doing a reconnect operation. This can be useful if the client wants to preserve existing metadata, even though the host is changing its IP address. For example, clients could preserve existing statistics, alarms, and privileges.This method can also be used to change the SSL thumbprint of a connected host without disconnecting it.Any changes made to the resource hierarchy on the host when the host was disconnected are overriden by VirtualCenter settings on reconnect.This method is only supported through VirtualCenter.
+
+
+  Privilege:
+               Host.Config.Connection
+
+
+
+  Args:
+    cnxSpec (`vim.host.ConnectSpec`_, optional):
+       Includes the parameters to use, including user name and password, when reconnecting to the host. If this parameter is not specified, the default connection parameters is used.
+
+
+    reconnectSpec (`vim.HostSystem.ReconnectSpec`_, optional, since `vSphere API 5.0`_ ):
+       Includes connection parameters specific to reconnect. This will mainly be used to indicate how to handle divergence between the host settings and vCenter Server settings when the host was disconnected.
+
+
+
+
+  Returns:
+     `vim.Task`_:
+         
+
+  Raises:
+
+    `vim.fault.InvalidLogin`_: 
+       if the method fails to authenticate with the host.
+
+    `vim.fault.InvalidState`_: 
+       if the host is not disconnected.
+
+    `vim.fault.InvalidName`_: 
+       if the host name is invalid.
+
+    `vim.fault.HostConnectFault`_: 
+       if an error occurred when attempting to reconnect to a host. Typically, a more specific subclass, such as AlreadyBeingManaged, is thrown.
+
+    `vmodl.fault.NotSupported`_: 
+       if no host can be added to this group. This is the case if the ComputeResource is a standalone type.
+
+    `vim.fault.AlreadyBeingManaged`_: 
+       if host is already being managed by another VirtualCenter server
+
+    `vmodl.fault.NotEnoughLicenses`_: 
+       if there are not enough licenses to add this host.
+
+    `vim.fault.NoHost`_: 
+       if the method is unable to contact the server.
+
+    `vim.fault.NotSupportedHost`_: 
+       if the host is running a software version that is not supported.
+
+    `vim.fault.SSLVerifyFault`_: 
+       if the host certificate could not be authenticated.
+
+
+DisconnectHost():
+   Disconnects from a host and instructs the server to stop sending heartbeats.
+
+
+  Privilege:
+               Host.Config.Connection
+
+
+
+  Args:
+
+
+  Returns:
+     `vim.Task`_:
+         
+
+  Raises:
+
+    `vmodl.fault.NotSupported`_: 
+       if run directly on an ESX Server host.
+
+
+EnterMaintenanceMode(timeout, evacuatePoweredOffVms, maintenanceSpec):
+   Puts the host in maintenance mode. While this task is running and when the host is in maintenance mode, no virtual machines can be powered on and no provisioning operations can be performed on the host. Once the call completes, it is safe to turn off a host without disrupting any virtual machines.The task completes once there are no powered-on virtual machines on the host and no provisioning operations in progress on the host. The operation does not directly initiate any operations to evacuate or power-down powered-on virtual machines. However, if the host is part of a cluster with VMware DRS enabled, DRS provides migration recommendations to evacuate the powered-on virtual machines. If DRS is in fully-automatic mode, these are automatically scheduled.If the host is part of a cluster and the task is issued through VirtualCenter with evacuatePoweredOffVms set to true, the task will not succeed unless all the powered-off virtual machines are reregistered to other hosts. If VMware DRS is enabled, vCenter Server will automatically evacuate powered-off virtual machines. The task is cancellable.
+
+
+  Privilege:
+               Host.Config.Maintenance
+
+
+
+  Args:
+    timeout (`int`_):
+       The task completes when the host successfully enters maintenance mode or the timeout expires, and in the latter case the task contains a Timeout fault. If the timeout is less than or equal to zero, there is no timeout. The timeout is specified in seconds.
+
+
+    evacuatePoweredOffVms (`bool`_, optional, since `VI API 2.5`_ ):
+       This is a parameter only supported by VirtualCenter. If set to true, for a DRS disabled cluster, the task will not succeed unless all powered-off virtual machines have been manually reregistered; for a DRS enabled cluster, VirtualCenter will automatically reregister powered-off virtual machines and a powered-off virtual machine may remain at the host only for two reasons: (a) no compatible host found for reregistration, (b) DRS is disabled for the virtual machine. If set to false, powered-off virtual machines do not need to be moved.
+
+
+    maintenanceSpec (`vim.host.MaintenanceSpec`_, optional, since `vSphere API 5.5`_ ):
+       Any additional actions to be taken by the host upon entering maintenance mode. If omitted, default actions will be taken as documented in the `HostMaintenanceSpec`_ .
+
+
+
+
+  Returns:
+     `vim.Task`_:
+         
+
+  Raises:
+
+    `vim.fault.InvalidState`_: 
+       if the host is already in maintenance mode.
+
+    `vim.fault.Timedout`_: 
+       if the operation timed out.
+
+    `vmodl.fault.RequestCanceled`_: 
+       if the operation is canceled.
+
+
+ExitMaintenanceMode(timeout):
+   Takes the host out of maintenance mode. This blocks if any concurrent running maintenance-only host configurations operations are being performed. For example, if VMFS volumes are being upgraded.The task is cancellable.
+
+
+  Privilege:
+               Host.Config.Maintenance
+
+
+
+  Args:
+    timeout (`int`_):
+       Number of seconds to wait for the exit maintenance mode to succeed. If the timeout is less than or equal to zero, there is no timeout.
+
+
+
+
+  Returns:
+     `vim.Task`_:
+         
+
+  Raises:
+
+    `vim.fault.InvalidState`_: 
+       if the host is not in maintenance mode.
+
+    `vim.fault.Timedout`_: 
+       vim.fault.Timedout
+
+
+RebootHost(force):
+   Reboots a host. If the command is successful, then the host has been rebooted. If connected directly to the host, the client never receives an indicator of success in the returned task but simply loses connection to the host, upon success.This command is not supported on all hosts. Check the host capability `vim.host.Capability.rebootSupported`_ .
+
+
+  Privilege:
+               Host.Config.Maintenance
+
+
+
+  Args:
+    force (`bool`_):
+       Flag to specify whether or not the host should be rebooted regardless of whether it is in maintenance mode. If true, the host is rebooted, even if there are virtual machines running or other operations in progress.
+
+
+
+
+  Returns:
+     `vim.Task`_:
+         
+
+  Raises:
+
+    `vim.fault.InvalidState`_: 
+       if "force" is false and the host is not in maintenance mode.
+
+    `vmodl.fault.NotSupported`_: 
+       if the host does not support the reboot operation.
+
+
+ShutdownHost(force):
+   Shuts down a host. If the command is successful, then the host has been shut down. Thus, the client never receives an indicator of success in the returned task if connected directly to the host.This command is not supported on all hosts. Check the host capability `shutdownSupported`_ .
+
+
+  Privilege:
+               Host.Config.Maintenance
+
+
+
+  Args:
+    force (`bool`_):
+       Flag to specify whether or not the host should be shut down regardless of whether it is in maintenance mode. If true, the host is shut down, even if there are virtual machines running or other operations in progress.
+
+
+
+
+  Returns:
+     `vim.Task`_:
+         
+
+  Raises:
+
+    `vim.fault.InvalidState`_: 
+       if "force" is false and the host is not in maintenance mode.
+
+    `vmodl.fault.NotSupported`_: 
+       if the host does not support shutdown.
+
+
+PowerDownHostToStandBy(timeoutSec, evacuatePoweredOffVms):
+   Puts the host in standby mode, a mode in which the host is in a standby state from which it can be powered up remotely. While this task is running, no virtual machines can be powered on and no provisioning operations can be performed on the host.The task completes only if there are no powered-on virtual machines on the host, no provisioning operations in progress on the host, and the host stopped responding. The operation does not directly initiate any operations to evacuate or power-down powered-on virtual machines. However, if a dynamic recommendation generation module is running, if possible, it will provide, and depending on the automation level, it will execute migrations of powered-on virtual machine. Furthermore, VMware power management module may evacute and put a host in standby mode to save power. If the host is part of a cluster and the task is issued through VirtualCenter with evacuatePoweredOffVms set to true, the task will not succeed unless all the powered-off virtual machines are reregistered to other hosts. If VMware DRS is enabled, vCenter Server will automatically evacuate powered-off virtual machines.The task is cancellable.This command is not supported on all hosts. Check the host capability `standbySupported`_ .
+  since: `VI API 2.5`_
+
+
+  Privilege:
+               Host.Config.Maintenance
+
+
+
+  Args:
+    timeoutSec (`int`_):
+       The task completes when the host successfully enters standby mode and stops sending heartbeat signals. If heartbeats are still coming after timeoutSecs seconds, the host is declared timedout, and the task is assumed failed.
+
+
+    evacuatePoweredOffVms (`bool`_, optional):
+       This is a parameter used only by VirtualCenter. If set to true, for a DRS disabled cluster, the task will not succeed unless all powered-off virtual machines have been manually reregistered; for a DRS enabled cluster, VirtualCenter will automatically reregister powered-off virtual machines and a powered-off virtual machine may remain at the host only for two reasons: (a) no compatible host found for reregistration, (b) DRS is disabled for the virtual machine.
+
+
+
+
+  Returns:
+     `vim.Task`_:
+         
+
+  Raises:
+
+    `vim.fault.HostPowerOpFailed`_: 
+       if the standby operation fails.
+
+    `vim.fault.InvalidState`_: 
+       if the host is already in standby mode, or disconnected.
+
+    `vmodl.fault.NotSupported`_: 
+       if the host does not support standby mode.
+
+    `vim.fault.Timedout`_: 
+       vim.fault.Timedout
+
+    `vmodl.fault.RequestCanceled`_: 
+       if the operation is canceled.
+
+
+PowerUpHostFromStandBy(timeoutSec):
+   Takes the host out of standby mode. If the command is successful, the host wakes up and starts sending heartbeats. This method may be called automatically by a dynamic recommendation generation module to add capacity to a cluster, if the host is not in maintenance mode.Note that, depending on the implementation of the wakeup method, the client may never receive an indicator of success in the returned task. In some cases, it is not even possible to ensure that the wakeup request has made it to the host.The task is cancellable.
+  since: `VI API 2.5`_
+
+
+  Privilege:
+               Host.Config.Maintenance
+
+
+
+  Args:
+    timeoutSec (`int`_):
+       The task completes when the host successfully exits standby state and sends a heartbeat signal. If nothing is received from the host for timeoutSec seconds, the host is declared timedout, and the task is assumed failed.
+
+
+
+
+  Returns:
+     `vim.Task`_:
+         
+
+  Raises:
+
+    `vim.fault.HostPowerOpFailed`_: 
+       if the standby operation fails.
+
+    `vim.fault.InvalidState`_: 
+       if the host is in a state from which it cannot be woken up (e.g., disconnected, poweredOff)
+
+    `vmodl.fault.NotSupported`_: 
+       if the host does not support standby mode.
+
+    `vim.fault.Timedout`_: 
+       vim.fault.Timedout
+
+    `vmodl.fault.RequestCanceled`_: 
+       if the operation is canceled.
+
+
+QueryMemoryOverhead(memorySize, videoRamSize, numVcpus):
+   Determines the amount of memory overhead necessary to power on a virtual machine with the specified characteristics.
+
+
+  Privilege:
+               System.Read
+
+
+
+  Args:
+    memorySize (`long`_):
+       The amount of virtual system RAM, in bytes. For an existing virtual machine, this value can be found (in megabytes) as the memoryMB property of the `VirtualHardware`_ .
+
+
+    videoRamSize (`int`_, optional):
+       The amount of virtual video RAM, in bytes. For an existing virtual machine on a host that supports advertising this property, this value can be found (in kilobytes) as the videoRamSizeInKB property of the `VirtualMachineVideoCard`_ . If this parameter is left unset, the default video RAM size for virtual machines on this host is assumed.
+
+
+    numVcpus (`int`_):
+       The number of virtual CPUs. For an existing virtual machine, this value can be found as the numCPU property of the `VirtualHardware`_ .
+
+
+
+
+  Returns:
+    `long`_:
+         The amount of overhead memory required to power on such a virtual machine, in bytes.
+
+  Raises:
+
+    `vmodl.fault.NotSupported`_: 
+       if the host does not have memory resource allocation features.
+
+
+QueryMemoryOverheadEx(vmConfigInfo):
+   Determines the amount of memory overhead necessary to power on a virtual machine with the specified characteristics.
+  since: `VI API 2.5`_
+
+
+  Privilege:
+               System.Read
+
+
+
+  Args:
+    vmConfigInfo (`vim.vm.ConfigInfo`_):
+       The configuration of the virtual machine.
+
+
+
+
+  Returns:
+    `long`_:
+         The amount of overhead memory required to power on such a virtual machine, in bytes.
+
+  Raises:
+
+    `vmodl.fault.NotSupported`_: 
+       if the host does not have memory resource allocation features.
+
+
+ReconfigureHostForDAS():
+   Reconfigures the host for vSphere HA.If the host is part of a HA cluster, this operation reconfigures the host for HA. For example, this operation may be used if a host is added to a HA enabled cluster and the automatic HA configuration system task fails. Automatic HA configuration may fail for a variety of reasons. For example, the host is configured incorrectly.
+
+
+  Privilege:
+               Host.Config.Connection
+
+
+
+  Args:
+
+
+  Returns:
+     `vim.Task`_:
+         
+
+  Raises:
+
+    `vim.fault.DasConfigFault`_: 
+       if there is a problem reconfiguring the host for HA.
+
+    `vmodl.fault.NotSupported`_: 
+       if run directly on an ESX Server host.
+
+
+UpdateFlags(flagInfo):
+   Update flags that are part of the `HostFlagInfo`_ object.
+  since: `VI API 2.5`_
+
+
+  Privilege:
+               Host.Config.Settings
+
+
+
+  Args:
+    flagInfo (`vim.host.FlagInfo`_):
+
+
+
+
+  Returns:
+    None
+         
+
+
+EnterLockdownMode():
+   Modifies the permissions on the host, so that it will only be accessible through local console or an authorized centralized management application. Any user defined permissions found on the host are lost.Access via a VI client connected to the host is blocked. Access though other services running on the host is also blocked.If the operation is successful, `adminDisabled`_ will be set to true. This API is not supported on the host, If invoked directly on a host, a NotSupported fault will be thrown.See `AuthorizationManager`_ 
+  since: `vSphere API 4.1`_
+
+
+  Privilege:
+               Host.Config.Settings
+
+
+
+  Args:
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vim.fault.HostConfigFault`_: 
+       See `AuthorizationManager`_ 
+
+    `vim.fault.AdminDisabled`_: 
+       If the host's Administrator permission has been disabled.See `AuthorizationManager`_ 
+
+    `vim.fault.DisableAdminNotSupported`_: 
+       If invoked directly on the host or the host doesn't support this operation.See `AuthorizationManager`_ 
+
+
+ExitLockdownMode():
+   Restores Administrator permission for the local administrative account for the host that was removed by prior call to `EnterLockdownMode`_ . If the operation is successful, `adminDisabled`_ will be set to false. This API is not supported on the host. If invoked directly on a host, a NotSupported fault will be thrown.See `AuthorizationManager`_ 
+  since: `vSphere API 4.1`_
+
+
+  Privilege:
+               Host.Config.Settings
+
+
+
+  Args:
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vim.fault.HostConfigFault`_: 
+       See `AuthorizationManager`_ 
+
+    `vim.fault.DisableAdminNotSupported`_: 
+       If invoked directly on the host or the host doesn't support this operation.See `AuthorizationManager`_ 
+
+    `vim.fault.AdminNotDisabled`_: 
+       If the host's Administrator permission is not disabled.See `AuthorizationManager`_ 
+
+
+AcquireCimServicesTicket():
+   Creates and returns a one-time credential used to establish a remote connection to a CIM interface. The port to connect to is the standard well known port for the service.
+  since: `VI API 2.5`_
+
+
+  Privilege:
+               Host.Cim.CimInteraction
+
+
+
+  Args:
+
+
+  Returns:
+    `vim.HostServiceTicket`_:
+         
+
+
+UpdateIpmi(ipmiInfo):
+   Update fields that are part of the `HostIpmiInfo`_ object.
+  since: `vSphere API 4.0`_
+
+
+  Privilege:
+               Host.Config.Settings
+
+
+
+  Args:
+    ipmiInfo (`vim.host.IpmiInfo`_):
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vim.fault.InvalidIpmiLoginInfo`_: 
+       if the supplied user ID and/or password is invalid.
+
+    `vim.fault.InvalidIpmiMacAddress`_: 
+       if the supplied MAC address is invalid.
+
+
+RetrieveHardwareUptime():
+   Return the hardware uptime of the host in seconds. The harware uptime of a host is not affected by NTP and changes to its wall clock time and can be used by clients to provide a common time reference for all hosts.
+  since: `vSphere API 4.1`_
+
+
+  Privilege:
+               System.Read
+
+
+
+  Args:
+
+
+  Returns:
+    `long`_:
+         
+
+

docs/vim/HostSystem/ConnectionState.rst

@@ -0,0 +1,24 @@
+.. _vim.HostSystem: ../../vim/HostSystem.rst
+
+.. _vim.HostSystem.ConnectionState: ../../vim/HostSystem/ConnectionState.rst
+
+vim.HostSystem.ConnectionState
+==============================
+  Defines a host's connection state.
+  :contained by: `vim.HostSystem`_
+
+  :type: `vim.HostSystem.ConnectionState`_
+
+  :name: disconnected
+
+values:
+--------
+
+connected
+   Connected to the server. For ESX Server, this is always the setting.
+
+disconnected
+   The user has explicitly taken the host down. VirtualCenter does not expect to receive heartbeats from the host. The next time a heartbeat is received, the host is moved to the connected state again and an event is logged.
+
+notResponding
+   VirtualCenter is not receiving heartbeats from the server. The state automatically changes to connected once heartbeats are received again. This state is typically used to trigger an alarm on the host.

docs/vim/HostSystem/PowerState.rst

@@ -0,0 +1,31 @@
+.. _exiting: ../../vim/HostSystem/StandbyMode.rst#exiting
+
+.. _entering: ../../vim/HostSystem/StandbyMode.rst#entering
+
+.. _vim.HostSystem: ../../vim/HostSystem.rst
+
+.. _vim.HostSystem.PowerState: ../../vim/HostSystem/PowerState.rst
+
+vim.HostSystem.PowerState
+=========================
+  Defines a host's power state.
+  :contained by: `vim.HostSystem`_
+
+  :type: `vim.HostSystem.PowerState`_
+
+  :name: unknown
+
+values:
+--------
+
+standBy
+   The host was specifically put in standby mode, either explicitly by the user, or automatically by DPM. This state is not a cetain state, because after VirtualCenter issues the command to put the host in standby state, the host might crash, or kill all the processes but fail to power off. A host that is exiting standby mode `exiting`_ is also in this state.
+
+unknown
+   If the host is disconnected, or notResponding, we cannot possibly have knowledge of its power state. Hence, the host is marked as unknown.
+
+poweredOn
+   The host is powered on. A host that is entering standby mode `entering`_ is also in this state.
+
+poweredOff
+   The host was specifically powered off by the user through VirtualCenter. This state is not a cetain state, because after VirtualCenter issues the command to power off the host, the host might crash, or kill all the processes but fail to power off.

docs/vim/HostSystem/ReconnectSpec.rst

@@ -0,0 +1,17 @@
+.. _bool: https://docs.python.org/2/library/stdtypes.html
+
+.. _vSphere API 5.0: ../../vim/version.rst#vimversionversion7
+
+.. _vmodl.DynamicData: ../../vmodl/DynamicData.rst
+
+
+vim.HostSystem.ReconnectSpec
+============================
+  Specifies the parameters needed to merge vCenter Server settings and host settings on reconnect.
+:extends: vmodl.DynamicData_
+:since: `vSphere API 5.0`_
+
+Attributes:
+    syncState (`bool`_, optional):
+
+       This flag should be set if on a host reconnect, state such as virtual machine state in vCenter Server e.g. the virtual machine inventory and autostart rules, has to be propogated to the host. Any virtual machines that may have been unregistered or orphaned will be reregistered according to the vCenter Server inventory. Any autostart rules that may have changed on the host will be similarly restored. This flag is primarily intended for stateless hosts to enable vCenter Server to resync these hosts after a reboot.

docs/vim/HostSystem/StandbyMode.rst

@@ -0,0 +1,27 @@
+.. _vim.HostSystem: ../../vim/HostSystem.rst
+
+.. _vim.HostSystem.StandbyMode: ../../vim/HostSystem/StandbyMode.rst
+
+vim.HostSystem.StandbyMode
+==========================
+  Defines a host's standby mode.
+  :contained by: `vim.HostSystem`_
+
+  :type: `vim.HostSystem.StandbyMode`_
+
+  :name: none
+
+values:
+--------
+
+none
+   The host is not in standy mode. And it is not in the process of entering/exiting standby mode.
+
+in
+   The host is in standby mode.
+
+entering
+   The host is entering standby mode.
+
+exiting
+   The host is exiting standby mode.

docs/vim/HttpNfcLease.rst

@@ -0,0 +1,151 @@
+.. _int: https://docs.python.org/2/library/stdtypes.html
+
+.. _vim.Task: ../vim/Task.rst
+
+.. _VirtualMachine: ../vim/VirtualMachine.rst
+
+.. _vSphere API 4.1: ../vim/version.rst#vimversionversion6
+
+.. _vSphere API 4.0: ../vim/version.rst#vimversionversion5
+
+.. _vmodl.MethodFault: ../vmodl/MethodFault.rst
+
+.. _vim.fault.Timedout: ../vim/fault/Timedout.rst
+
+.. _vim.HttpNfcLease.Info: ../vim/HttpNfcLease/Info.rst
+
+.. _vim.fault.InvalidState: ../vim/fault/InvalidState.rst
+
+.. _vim.HttpNfcLease.State: ../vim/HttpNfcLease/State.rst
+
+.. _vmodl.LocalizedMethodFault: ../vmodl/LocalizedMethodFault.rst
+
+.. _vim.HttpNfcLease.ManifestEntry: ../vim/HttpNfcLease/ManifestEntry.rst
+
+
+vim.HttpNfcLease
+================
+  Represents a lease on a `VirtualMachine`_ or a `VirtualApp`_ , which can be used to import or export disks for the entity. While the lease is held, operations that alter the state of the virtual machines covered by the lease are blocked. Examples of blocked operations are PowerOn, Destroy, Migrate, etc.A lease is in one of four states:InitializingThis is the initial state. The lease remains in this state while the corresponding import/export task is preparing the objects. In an import session, this involves creating inventory objects.ReadyThe lease changes to this state once the corresponding import/export task is done preparing the lease. The leased objects are now ready, and the client can use the information provided in the `info`_ property to determine where to up/download disks. The client must call `HttpNfcLeaseProgress`_ periodically to keep the lease alive and report progress to the corresponding import/export task. Failure to do so causes the lease to time out and enter the error state.DoneWhen the client is done transferring disks, it calls `HttpNfcLeaseComplete`_ to signal the end of the import/export session. This causes the corresponding import/export task to complete successfully.ErrorIf an error occurs during initialization or the lease times out, it will change to this state. The client can also abort the lease manually by calling `HttpNfcLeaseAbort`_ . In this state, the `error`_ property can be read to determine the cause. If the lease belongs to an import session, all objects created during the import are removed when the lease enters this state.The import/export task corresponding to the lease continues running while the lease is held.
+
+
+:since: `vSphere API 4.0`_
+
+
+Attributes
+----------
+    initializeProgress (`int`_):
+       Provides progress information (0-100 percent) for the initializing state of the lease. Clients can use this to track overall progress.
+    info (`vim.HttpNfcLease.Info`_):
+       Provides information on the objects contained in this lease. The info property is only valid when the lease is in the ready state.
+    state (`vim.HttpNfcLease.State`_):
+       The current state of the lease.
+    error (`vmodl.LocalizedMethodFault`_):
+       If the lease is in the error state, this property contains the error that caused the lease to be aborted.
+
+
+Methods
+-------
+
+
+HttpNfcLeaseGetManifest():
+   Gets the download manifest for this lease.
+  since: `vSphere API 4.1`_
+
+
+  Privilege:
+
+
+
+  Args:
+
+
+  Returns:
+    `vim.HttpNfcLease.ManifestEntry`_:
+         
+
+  Raises:
+
+    `vim.fault.Timedout`_: 
+       vim.fault.Timedout
+
+    `vim.fault.InvalidState`_: 
+       vim.fault.InvalidState
+
+
+HttpNfcLeaseComplete():
+   Completes the import/export and releases this lease. Operations on the objects contained in this lease will no longer be blocked. After calling this method, this lease will no longer be valid.Clients should call this method when they are done accessing the disks for the `VirtualMachine`_ s in this lease. The status of the corresponding task will be set to success.
+
+
+  Privilege:
+
+
+
+  Args:
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vim.fault.Timedout`_: 
+       if the lease has timed out before this call.
+
+    `vim.fault.InvalidState`_: 
+       if the lease has already been completed or aborted.
+
+
+HttpNfcLeaseAbort(fault):
+   Aborts the import/export and releases this lease. Operations on the objects contained in this lease will no longer be blocked. After calling this method, this lease will no longer be valid.Clients should call this method if an error occurs while accessing the disks, or if the operation is cancelled. The client can report the cause of the abort to other clients listening on the task with the fault parameter.
+
+
+  Privilege:
+
+
+
+  Args:
+    fault (`vmodl.MethodFault`_, optional):
+       [in] The fault that caused the abort, if any.
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vim.fault.Timedout`_: 
+       if the lease has timed out before this call.
+
+    `vim.fault.InvalidState`_: 
+       if the lease has already been aborted.
+
+
+HttpNfcLeaseProgress(percent):
+   Sets the disk up/download progress, and renews this lease. A lease will time out automatically after a while. If the client wishes to continue using it, for example if it is not done accessing the disks, this method must be called periodically.
+
+
+  Privilege:
+
+
+
+  Args:
+    percent (`int`_):
+       [in] Completion status represented as an integer in the 0-100 range.
+
+
+
+
+  Returns:
+    None
+         
+
+  Raises:
+
+    `vim.fault.Timedout`_: 
+       if the lease has timed out.
+
+