diff --git a/vro-types/o11n-plugin-vc/index.d.ts b/vro-types/o11n-plugin-vc/index.d.ts
index 31d501afc..a79d47f66 100644
--- a/vro-types/o11n-plugin-vc/index.d.ts
+++ b/vro-types/o11n-plugin-vc/index.d.ts
@@ -1,58 +1,64 @@
+interface IPseudoEnum {
+	id: string,
+	name: string,
+	value: string,
+	toString: () => string
+}
+type EnumVal<K extends string> = IPseudoEnum | K; // for comparing
+type TcleanKeys<T> = Exclude<keyof T, "prototype" | "fromString">;
+
 /**
  * List of precreated resource pools based on traffic type that the platform
  * supports.
  */
-declare class VcHostDistributedVirtualSwitchManagerNetworkResourcePoolKey {
-	readonly virtualMachine: VcHostDistributedVirtualSwitchManagerNetworkResourcePoolKey;
-	readonly iSCSI: VcHostDistributedVirtualSwitchManagerNetworkResourcePoolKey;
-	readonly vdp: VcHostDistributedVirtualSwitchManagerNetworkResourcePoolKey;
-	readonly management: VcHostDistributedVirtualSwitchManagerNetworkResourcePoolKey;
-	readonly faultTolerance: VcHostDistributedVirtualSwitchManagerNetworkResourcePoolKey;
-	readonly name: string;
-	readonly hbr: VcHostDistributedVirtualSwitchManagerNetworkResourcePoolKey;
-	readonly nfs: VcHostDistributedVirtualSwitchManagerNetworkResourcePoolKey;
+declare class VcHostDistributedVirtualSwitchManagerNetworkResourcePoolKey implements IPseudoEnum {
+	static readonly virtualMachine: VcHostDistributedVirtualSwitchManagerNetworkResourcePoolKey & EnumVal<'virtualMachine'>;
+	static readonly iSCSI: VcHostDistributedVirtualSwitchManagerNetworkResourcePoolKey & EnumVal<'iSCSI'>;
+	static readonly vdp: VcHostDistributedVirtualSwitchManagerNetworkResourcePoolKey & EnumVal<'vdp'>;
+	static readonly management: VcHostDistributedVirtualSwitchManagerNetworkResourcePoolKey & EnumVal<'management'>;
+	static readonly faultTolerance: VcHostDistributedVirtualSwitchManagerNetworkResourcePoolKey & EnumVal<'faultTolerance'>;
+	static readonly hbr: VcHostDistributedVirtualSwitchManagerNetworkResourcePoolKey & EnumVal<'hbr'>;
+	static readonly nfs: VcHostDistributedVirtualSwitchManagerNetworkResourcePoolKey & EnumVal<'nfs'>;
+	static readonly vsan: VcHostDistributedVirtualSwitchManagerNetworkResourcePoolKey & EnumVal<'vsan'>;
+	static readonly vmotion: VcHostDistributedVirtualSwitchManagerNetworkResourcePoolKey & EnumVal<'vmotion'>;
+	static fromString(value: string): VcHostDistributedVirtualSwitchManagerNetworkResourcePoolKey & EnumVal<TcleanKeys<typeof VcHostDistributedVirtualSwitchManagerNetworkResourcePoolKey>>;
+
 	readonly id: string;
-	readonly vsan: VcHostDistributedVirtualSwitchManagerNetworkResourcePoolKey;
+	readonly name: string;
 	readonly value: string;
-	readonly vmotion: VcHostDistributedVirtualSwitchManagerNetworkResourcePoolKey;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostDistributedVirtualSwitchManagerNetworkResourcePoolKey): VcHostDistributedVirtualSwitchManagerNetworkResourcePoolKey;
+	toString: () => string;
 }
 
 /**
  * Set of possible values for {@link vim.vm.FlagInfo#virtualMmuUsage}.
  */
-declare class VcVirtualMachineFlagInfoVirtualMmuUsage {
-	readonly name: string;
-	readonly automatic: VcVirtualMachineFlagInfoVirtualMmuUsage;
+declare class VcVirtualMachineFlagInfoVirtualMmuUsage implements IPseudoEnum {
+	static readonly automatic: VcVirtualMachineFlagInfoVirtualMmuUsage & EnumVal<'automatic'>;
+	static readonly off: VcVirtualMachineFlagInfoVirtualMmuUsage & EnumVal<'off'>;
+	static readonly on: VcVirtualMachineFlagInfoVirtualMmuUsage & EnumVal<'on'>;
+	static fromString(value: string): VcVirtualMachineFlagInfoVirtualMmuUsage & EnumVal<TcleanKeys<typeof VcVirtualMachineFlagInfoVirtualMmuUsage>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly off: VcVirtualMachineFlagInfoVirtualMmuUsage;
-	readonly on: VcVirtualMachineFlagInfoVirtualMmuUsage;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineFlagInfoVirtualMmuUsage): VcVirtualMachineFlagInfoVirtualMmuUsage;
+	toString: () => string;
 }
 
 /**
  * Pre-defined constants for cache modes.
  */
-declare class VcVirtualDiskVFlashCacheConfigInfoCacheMode {
-	readonly write_thru: VcVirtualDiskVFlashCacheConfigInfoCacheMode;
-	readonly name: string;
-	readonly write_back: VcVirtualDiskVFlashCacheConfigInfoCacheMode;
+declare class VcVirtualDiskVFlashCacheConfigInfoCacheMode implements IPseudoEnum {
+	static readonly write_thru: VcVirtualDiskVFlashCacheConfigInfoCacheMode & EnumVal<'write_thru'>;
+	static readonly write_back: VcVirtualDiskVFlashCacheConfigInfoCacheMode & EnumVal<'write_back'>;
+	static fromString(value: string): VcVirtualDiskVFlashCacheConfigInfoCacheMode & EnumVal<TcleanKeys<typeof VcVirtualDiskVFlashCacheConfigInfoCacheMode>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualDiskVFlashCacheConfigInfoCacheMode): VcVirtualDiskVFlashCacheConfigInfoCacheMode;
+	toString: () => string;
 }
 
 /**
@@ -65,38 +71,36 @@ declare class VcVirtualDiskVFlashCacheConfigInfoCacheMode {
  * fails, then we would just create a crash consistent
  * instance.
  */
-declare class VcQuiesceMode {
-	readonly application: VcQuiesceMode;
-	readonly name: string;
-	readonly none: VcQuiesceMode;
+declare class VcQuiesceMode implements IPseudoEnum {
+	static readonly application: VcQuiesceMode & EnumVal<'application'>;
+	static readonly none: VcQuiesceMode & EnumVal<'none'>;
+	static readonly filesystem: VcQuiesceMode & EnumVal<'filesystem'>;
+	static fromString(value: string): VcQuiesceMode & EnumVal<TcleanKeys<typeof VcQuiesceMode>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly filesystem: VcQuiesceMode;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcQuiesceMode): VcQuiesceMode;
+	toString: () => string;
 }
 
 /**
  * Set of possible values for protocol field in FilterSpec.
  */
-declare class VcVirtualMachineVMCIDeviceProtocol {
-	readonly queuepair: VcVirtualMachineVMCIDeviceProtocol;
-	readonly stream: VcVirtualMachineVMCIDeviceProtocol;
-	readonly doorbell: VcVirtualMachineVMCIDeviceProtocol;
-	readonly hypervisor: VcVirtualMachineVMCIDeviceProtocol;
-	readonly anyProtocol: VcVirtualMachineVMCIDeviceProtocol;
-	readonly name: string;
-	readonly datagram: VcVirtualMachineVMCIDeviceProtocol;
+declare class VcVirtualMachineVMCIDeviceProtocol implements IPseudoEnum {
+	static readonly queuepair: VcVirtualMachineVMCIDeviceProtocol & EnumVal<'queuepair'>;
+	static readonly stream: VcVirtualMachineVMCIDeviceProtocol & EnumVal<'stream'>;
+	static readonly doorbell: VcVirtualMachineVMCIDeviceProtocol & EnumVal<'doorbell'>;
+	static readonly hypervisor: VcVirtualMachineVMCIDeviceProtocol & EnumVal<'hypervisor'>;
+	static readonly anyProtocol: VcVirtualMachineVMCIDeviceProtocol & EnumVal<'anyProtocol'>;
+	static readonly datagram: VcVirtualMachineVMCIDeviceProtocol & EnumVal<'datagram'>;
+	static fromString(value: string): VcVirtualMachineVMCIDeviceProtocol & EnumVal<TcleanKeys<typeof VcVirtualMachineVMCIDeviceProtocol>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineVMCIDeviceProtocol): VcVirtualMachineVMCIDeviceProtocol;
+	toString: () => string;
 }
 
 /**
@@ -105,35 +109,33 @@ declare class VcVirtualMachineVMCIDeviceProtocol {
  * one slot.  If the diagnostic partition is on shared storage, it could
  * be used by multiple hosts.  As a result, it will need multiple slots.
  */
-declare class VcDiagnosticPartitionStorageType {
-	readonly networkAttached: VcDiagnosticPartitionStorageType;
-	readonly name: string;
-	readonly directAttached: VcDiagnosticPartitionStorageType;
+declare class VcDiagnosticPartitionStorageType implements IPseudoEnum {
+	static readonly networkAttached: VcDiagnosticPartitionStorageType & EnumVal<'networkAttached'>;
+	static readonly directAttached: VcDiagnosticPartitionStorageType & EnumVal<'directAttached'>;
+	static fromString(value: string): VcDiagnosticPartitionStorageType & EnumVal<TcleanKeys<typeof VcDiagnosticPartitionStorageType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDiagnosticPartitionStorageType): VcDiagnosticPartitionStorageType;
+	toString: () => string;
 }
 
 /**
  * Status for last attempt to run scheduled hardware upgrade.
  */
-declare class VcScheduledHardwareUpgradeInfoHardwareUpgradeStatus {
-	readonly success: VcScheduledHardwareUpgradeInfoHardwareUpgradeStatus;
-	readonly pending: VcScheduledHardwareUpgradeInfoHardwareUpgradeStatus;
-	readonly name: string;
-	readonly none: VcScheduledHardwareUpgradeInfoHardwareUpgradeStatus;
-	readonly failed: VcScheduledHardwareUpgradeInfoHardwareUpgradeStatus;
+declare class VcScheduledHardwareUpgradeInfoHardwareUpgradeStatus implements IPseudoEnum {
+	static readonly success: VcScheduledHardwareUpgradeInfoHardwareUpgradeStatus & EnumVal<'success'>;
+	static readonly pending: VcScheduledHardwareUpgradeInfoHardwareUpgradeStatus & EnumVal<'pending'>;
+	static readonly none: VcScheduledHardwareUpgradeInfoHardwareUpgradeStatus & EnumVal<'none'>;
+	static readonly failed: VcScheduledHardwareUpgradeInfoHardwareUpgradeStatus & EnumVal<'failed'>;
+	static fromString(value: string): VcScheduledHardwareUpgradeInfoHardwareUpgradeStatus & EnumVal<TcleanKeys<typeof VcScheduledHardwareUpgradeInfoHardwareUpgradeStatus>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcScheduledHardwareUpgradeInfoHardwareUpgradeStatus): VcScheduledHardwareUpgradeInfoHardwareUpgradeStatus;
+	toString: () => string;
 }
 
 /**
@@ -147,25 +149,24 @@ declare class VcScheduledHardwareUpgradeInfoHardwareUpgradeStatus {
  * master, and by vCenter Server. See {@link vim.cluster.DasFdmHostState}
  * for more information about the vSphere HA architecture.
  */
-declare class VcClusterDasFdmAvailabilityState {
-	readonly connectedToMaster: VcClusterDasFdmAvailabilityState;
-	readonly uninitializationError: VcClusterDasFdmAvailabilityState;
-	readonly election: VcClusterDasFdmAvailabilityState;
-	readonly hostDown: VcClusterDasFdmAvailabilityState;
-	readonly networkPartitionedFromMaster: VcClusterDasFdmAvailabilityState;
-	readonly master: VcClusterDasFdmAvailabilityState;
-	readonly initializationError: VcClusterDasFdmAvailabilityState;
-	readonly fdmUnreachable: VcClusterDasFdmAvailabilityState;
-	readonly networkIsolated: VcClusterDasFdmAvailabilityState;
-	readonly name: string;
+declare class VcClusterDasFdmAvailabilityState implements IPseudoEnum {
+	static readonly connectedToMaster: VcClusterDasFdmAvailabilityState & EnumVal<'connectedToMaster'>;
+	static readonly uninitializationError: VcClusterDasFdmAvailabilityState & EnumVal<'uninitializationError'>;
+	static readonly election: VcClusterDasFdmAvailabilityState & EnumVal<'election'>;
+	static readonly hostDown: VcClusterDasFdmAvailabilityState & EnumVal<'hostDown'>;
+	static readonly networkPartitionedFromMaster: VcClusterDasFdmAvailabilityState & EnumVal<'networkPartitionedFromMaster'>;
+	static readonly master: VcClusterDasFdmAvailabilityState & EnumVal<'master'>;
+	static readonly initializationError: VcClusterDasFdmAvailabilityState & EnumVal<'initializationError'>;
+	static readonly fdmUnreachable: VcClusterDasFdmAvailabilityState & EnumVal<'fdmUnreachable'>;
+	static readonly networkIsolated: VcClusterDasFdmAvailabilityState & EnumVal<'networkIsolated'>;
+	static readonly uninitialized: VcClusterDasFdmAvailabilityState & EnumVal<'uninitialized'>;
+	static fromString(value: string): VcClusterDasFdmAvailabilityState & EnumVal<TcleanKeys<typeof VcClusterDasFdmAvailabilityState>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly uninitialized: VcClusterDasFdmAvailabilityState;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcClusterDasFdmAvailabilityState): VcClusterDasFdmAvailabilityState;
+	toString: () => string;
 }
 
 /**
@@ -182,68 +183,64 @@ declare class VcClusterDasFdmAvailabilityState {
  * {@link vim.ManagedEntity#recentTask activeTask} data object in addition to the
  * {@link vim.vm.RuntimeInfo#powerState powerState} object.
  */
-declare class VcVirtualMachinePowerState {
-	readonly poweredOn: VcVirtualMachinePowerState;
-	readonly name: string;
+declare class VcVirtualMachinePowerState implements IPseudoEnum {
+	static readonly poweredOn: VcVirtualMachinePowerState & EnumVal<'poweredOn'>;
+	static readonly poweredOff: VcVirtualMachinePowerState & EnumVal<'poweredOff'>;
+	static readonly suspended: VcVirtualMachinePowerState & EnumVal<'suspended'>;
+	static fromString(value: string): VcVirtualMachinePowerState & EnumVal<TcleanKeys<typeof VcVirtualMachinePowerState>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly poweredOff: VcVirtualMachinePowerState;
-	readonly suspended: VcVirtualMachinePowerState;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachinePowerState): VcVirtualMachinePowerState;
+	toString: () => string;
 }
 
 /**
  * Define TCP congestion control algorithm used by an instance
  */
-declare class VcHostNetStackInstanceCongestionControlAlgorithmType {
-	readonly cubic: VcHostNetStackInstanceCongestionControlAlgorithmType;
-	readonly name: string;
+declare class VcHostNetStackInstanceCongestionControlAlgorithmType implements IPseudoEnum {
+	static readonly cubic: VcHostNetStackInstanceCongestionControlAlgorithmType & EnumVal<'cubic'>;
+	static readonly newreno: VcHostNetStackInstanceCongestionControlAlgorithmType & EnumVal<'newreno'>;
+	static fromString(value: string): VcHostNetStackInstanceCongestionControlAlgorithmType & EnumVal<TcleanKeys<typeof VcHostNetStackInstanceCongestionControlAlgorithmType>>;
+
 	readonly id: string;
-	readonly newreno: VcHostNetStackInstanceCongestionControlAlgorithmType;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostNetStackInstanceCongestionControlAlgorithmType): VcHostNetStackInstanceCongestionControlAlgorithmType;
+	toString: () => string;
 }
 
 /**
  * Set of possible values for
  * {@link vim.dvs.DistributedVirtualPort.RuntimeInfo}.{@link vim.dvs.DistributedVirtualPort.RuntimeInfo#vmDirectPathGen2InactiveReasonOther}.
  */
-declare class VcDVPortStatusVmDirectPathGen2InactiveReasonOther {
-	readonly name: string;
+declare class VcDVPortStatusVmDirectPathGen2InactiveReasonOther implements IPseudoEnum {
+	static readonly portNptIncompatibleHost: VcDVPortStatusVmDirectPathGen2InactiveReasonOther & EnumVal<'portNptIncompatibleHost'>;
+	static readonly portNptIncompatibleConnectee: VcDVPortStatusVmDirectPathGen2InactiveReasonOther & EnumVal<'portNptIncompatibleConnectee'>;
+	static fromString(value: string): VcDVPortStatusVmDirectPathGen2InactiveReasonOther & EnumVal<TcleanKeys<typeof VcDVPortStatusVmDirectPathGen2InactiveReasonOther>>;
+
 	readonly id: string;
-	readonly portNptIncompatibleHost: VcDVPortStatusVmDirectPathGen2InactiveReasonOther;
-	readonly portNptIncompatibleConnectee: VcDVPortStatusVmDirectPathGen2InactiveReasonOther;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDVPortStatusVmDirectPathGen2InactiveReasonOther): VcDVPortStatusVmDirectPathGen2InactiveReasonOther;
+	toString: () => string;
 }
 
 /**
  * Application heartbeat status type.
  */
-declare class VcVirtualMachineAppHeartbeatStatusType {
-	readonly appStatusRed: VcVirtualMachineAppHeartbeatStatusType;
-	readonly appStatusGray: VcVirtualMachineAppHeartbeatStatusType;
-	readonly name: string;
+declare class VcVirtualMachineAppHeartbeatStatusType implements IPseudoEnum {
+	static readonly appStatusRed: VcVirtualMachineAppHeartbeatStatusType & EnumVal<'appStatusRed'>;
+	static readonly appStatusGray: VcVirtualMachineAppHeartbeatStatusType & EnumVal<'appStatusGray'>;
+	static readonly appStatusGreen: VcVirtualMachineAppHeartbeatStatusType & EnumVal<'appStatusGreen'>;
+	static fromString(value: string): VcVirtualMachineAppHeartbeatStatusType & EnumVal<TcleanKeys<typeof VcVirtualMachineAppHeartbeatStatusType>>;
+
 	readonly id: string;
-	readonly appStatusGreen: VcVirtualMachineAppHeartbeatStatusType;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineAppHeartbeatStatusType): VcVirtualMachineAppHeartbeatStatusType;
+	toString: () => string;
 }
 
 /**
@@ -251,166 +248,157 @@ declare class VcVirtualMachineAppHeartbeatStatusType {
  * they are a clone of, thin provisioned or thick provisioned, or
  * linked clones (i.e., using delta disks).
  */
-declare class VcVAppCloneSpecProvisioningType {
-	readonly name: string;
-	readonly sameAsSource: VcVAppCloneSpecProvisioningType;
+declare class VcVAppCloneSpecProvisioningType implements IPseudoEnum {
+	static readonly sameAsSource: VcVAppCloneSpecProvisioningType & EnumVal<'sameAsSource'>;
+	static readonly thick: VcVAppCloneSpecProvisioningType & EnumVal<'thick'>;
+	static readonly thin: VcVAppCloneSpecProvisioningType & EnumVal<'thin'>;
+	static fromString(value: string): VcVAppCloneSpecProvisioningType & EnumVal<TcleanKeys<typeof VcVAppCloneSpecProvisioningType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly thick: VcVAppCloneSpecProvisioningType;
-	readonly thin: VcVAppCloneSpecProvisioningType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVAppCloneSpecProvisioningType): VcVAppCloneSpecProvisioningType;
+	toString: () => string;
 }
 
 /**
  * Data class to represent agent virtual machine state in vCenter
  */
-declare class VcEsxAgentConfigManagerAgentVmState {
-	readonly unavailable: VcEsxAgentConfigManagerAgentVmState;
-	readonly manuallyEnabled: VcEsxAgentConfigManagerAgentVmState;
-	readonly name: string;
-	readonly disabled: VcEsxAgentConfigManagerAgentVmState;
+declare class VcEsxAgentConfigManagerAgentVmState implements IPseudoEnum {
+	static readonly unavailable: VcEsxAgentConfigManagerAgentVmState & EnumVal<'unavailable'>;
+	static readonly manuallyEnabled: VcEsxAgentConfigManagerAgentVmState & EnumVal<'manuallyEnabled'>;
+	static readonly disabled: VcEsxAgentConfigManagerAgentVmState & EnumVal<'disabled'>;
+	static readonly enabled: VcEsxAgentConfigManagerAgentVmState & EnumVal<'enabled'>;
+	static fromString(value: string): VcEsxAgentConfigManagerAgentVmState & EnumVal<TcleanKeys<typeof VcEsxAgentConfigManagerAgentVmState>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly enabled: VcEsxAgentConfigManagerAgentVmState;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcEsxAgentConfigManagerAgentVmState): VcEsxAgentConfigManagerAgentVmState;
+	toString: () => string;
 }
 
 /**
  * The SPBM(Storage Policy Based Management) license state for a host
  */
-declare class VcComputeResourceHostSPBMLicenseInfoHostSPBMLicenseState {
-	readonly licensed: VcComputeResourceHostSPBMLicenseInfoHostSPBMLicenseState;
-	readonly unlicensed: VcComputeResourceHostSPBMLicenseInfoHostSPBMLicenseState;
-	readonly name: string;
+declare class VcComputeResourceHostSPBMLicenseInfoHostSPBMLicenseState implements IPseudoEnum {
+	static readonly licensed: VcComputeResourceHostSPBMLicenseInfoHostSPBMLicenseState & EnumVal<'licensed'>;
+	static readonly unlicensed: VcComputeResourceHostSPBMLicenseInfoHostSPBMLicenseState & EnumVal<'unlicensed'>;
+	static readonly unknown: VcComputeResourceHostSPBMLicenseInfoHostSPBMLicenseState & EnumVal<'unknown'>;
+	static fromString(value: string): VcComputeResourceHostSPBMLicenseInfoHostSPBMLicenseState & EnumVal<TcleanKeys<typeof VcComputeResourceHostSPBMLicenseInfoHostSPBMLicenseState>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly unknown: VcComputeResourceHostSPBMLicenseInfoHostSPBMLicenseState;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcComputeResourceHostSPBMLicenseInfoHostSPBMLicenseState): VcComputeResourceHostSPBMLicenseInfoHostSPBMLicenseState;
+	toString: () => string;
 }
 
 /**
  * The disallowed change type.
  */
-declare class VcDisallowedChangeByServiceDisallowedChange {
-	readonly hotExtendDisk: VcDisallowedChangeByServiceDisallowedChange;
-	readonly name: string;
+declare class VcDisallowedChangeByServiceDisallowedChange implements IPseudoEnum {
+	static readonly hotExtendDisk: VcDisallowedChangeByServiceDisallowedChange & EnumVal<'hotExtendDisk'>;
+	static fromString(value: string): VcDisallowedChangeByServiceDisallowedChange & EnumVal<TcleanKeys<typeof VcDisallowedChangeByServiceDisallowedChange>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDisallowedChangeByServiceDisallowedChange): VcDisallowedChangeByServiceDisallowedChange;
+	toString: () => string;
 }
 
 /**
  * The delta disk format variant constants
  */
-declare class VcVirtualDiskDeltaDiskFormatVariant {
-	readonly vsanSparseVariant: VcVirtualDiskDeltaDiskFormatVariant;
-	readonly name: string;
+declare class VcVirtualDiskDeltaDiskFormatVariant implements IPseudoEnum {
+	static readonly vsanSparseVariant: VcVirtualDiskDeltaDiskFormatVariant & EnumVal<'vsanSparseVariant'>;
+	static readonly vmfsSparseVariant: VcVirtualDiskDeltaDiskFormatVariant & EnumVal<'vmfsSparseVariant'>;
+	static fromString(value: string): VcVirtualDiskDeltaDiskFormatVariant & EnumVal<TcleanKeys<typeof VcVirtualDiskDeltaDiskFormatVariant>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly vmfsSparseVariant: VcVirtualDiskDeltaDiskFormatVariant;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualDiskDeltaDiskFormatVariant): VcVirtualDiskDeltaDiskFormatVariant;
+	toString: () => string;
 }
 
-declare class VcReplicationVmInProgressFaultActivity {
-	readonly delta: VcReplicationVmInProgressFaultActivity;
-	readonly name: string;
+declare class VcReplicationVmInProgressFaultActivity implements IPseudoEnum {
+	static readonly delta: VcReplicationVmInProgressFaultActivity & EnumVal<'delta'>;
+	static readonly fullSync: VcReplicationVmInProgressFaultActivity & EnumVal<'fullSync'>;
+	static fromString(value: string): VcReplicationVmInProgressFaultActivity & EnumVal<TcleanKeys<typeof VcReplicationVmInProgressFaultActivity>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly fullSync: VcReplicationVmInProgressFaultActivity;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcReplicationVmInProgressFaultActivity): VcReplicationVmInProgressFaultActivity;
+	toString: () => string;
 }
 
 /**
  * NetBIOS configuration mode.
  */
-declare class VcNetBIOSConfigInfoMode {
-	readonly enabledViaDHCP: VcNetBIOSConfigInfoMode;
-	readonly name: string;
-	readonly disabled: VcNetBIOSConfigInfoMode;
+declare class VcNetBIOSConfigInfoMode implements IPseudoEnum {
+	static readonly enabledViaDHCP: VcNetBIOSConfigInfoMode & EnumVal<'enabledViaDHCP'>;
+	static readonly disabled: VcNetBIOSConfigInfoMode & EnumVal<'disabled'>;
+	static readonly enabled: VcNetBIOSConfigInfoMode & EnumVal<'enabled'>;
+	static readonly unknown: VcNetBIOSConfigInfoMode & EnumVal<'unknown'>;
+	static fromString(value: string): VcNetBIOSConfigInfoMode & EnumVal<TcleanKeys<typeof VcNetBIOSConfigInfoMode>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly enabled: VcNetBIOSConfigInfoMode;
-	readonly unknown: VcNetBIOSConfigInfoMode;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcNetBIOSConfigInfoMode): VcNetBIOSConfigInfoMode;
+	toString: () => string;
 }
 
 /**
  * Possible values for graphics type.
  */
-declare class VcHostGraphicsInfoGraphicsType {
-	readonly shared: VcHostGraphicsInfoGraphicsType;
-	readonly sharedDirect: VcHostGraphicsInfoGraphicsType;
-	readonly direct: VcHostGraphicsInfoGraphicsType;
-	readonly name: string;
+declare class VcHostGraphicsInfoGraphicsType implements IPseudoEnum {
+	static readonly shared: VcHostGraphicsInfoGraphicsType & EnumVal<'shared'>;
+	static readonly sharedDirect: VcHostGraphicsInfoGraphicsType & EnumVal<'sharedDirect'>;
+	static readonly direct: VcHostGraphicsInfoGraphicsType & EnumVal<'direct'>;
+	static readonly basic: VcHostGraphicsInfoGraphicsType & EnumVal<'basic'>;
+	static fromString(value: string): VcHostGraphicsInfoGraphicsType & EnumVal<TcleanKeys<typeof VcHostGraphicsInfoGraphicsType>>;
+
 	readonly id: string;
-	readonly basic: VcHostGraphicsInfoGraphicsType;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostGraphicsInfoGraphicsType): VcHostGraphicsInfoGraphicsType;
+	toString: () => string;
 }
 
 /**
  * Device class family.
  */
-declare class VcVirtualMachineUsbInfoFamily {
-	readonly hid: VcVirtualMachineUsbInfoFamily;
-	readonly other: VcVirtualMachineUsbInfoFamily;
-	readonly hid_bootable: VcVirtualMachineUsbInfoFamily;
-	readonly printer: VcVirtualMachineUsbInfoFamily;
-	readonly storage: VcVirtualMachineUsbInfoFamily;
-	readonly video: VcVirtualMachineUsbInfoFamily;
-	readonly pda: VcVirtualMachineUsbInfoFamily;
-	readonly imaging: VcVirtualMachineUsbInfoFamily;
-	readonly unknownFamily: VcVirtualMachineUsbInfoFamily;
-	readonly smart_card: VcVirtualMachineUsbInfoFamily;
-	readonly security: VcVirtualMachineUsbInfoFamily;
-	readonly hub: VcVirtualMachineUsbInfoFamily;
-	readonly bluetooth: VcVirtualMachineUsbInfoFamily;
-	readonly name: string;
-	readonly wireless: VcVirtualMachineUsbInfoFamily;
-	readonly wusb: VcVirtualMachineUsbInfoFamily;
-	readonly audio: VcVirtualMachineUsbInfoFamily;
+declare class VcVirtualMachineUsbInfoFamily implements IPseudoEnum {
+	static readonly hid: VcVirtualMachineUsbInfoFamily & EnumVal<'hid'>;
+	static readonly other: VcVirtualMachineUsbInfoFamily & EnumVal<'other'>;
+	static readonly hid_bootable: VcVirtualMachineUsbInfoFamily & EnumVal<'hid_bootable'>;
+	static readonly printer: VcVirtualMachineUsbInfoFamily & EnumVal<'printer'>;
+	static readonly storage: VcVirtualMachineUsbInfoFamily & EnumVal<'storage'>;
+	static readonly video: VcVirtualMachineUsbInfoFamily & EnumVal<'video'>;
+	static readonly pda: VcVirtualMachineUsbInfoFamily & EnumVal<'pda'>;
+	static readonly imaging: VcVirtualMachineUsbInfoFamily & EnumVal<'imaging'>;
+	static readonly unknownFamily: VcVirtualMachineUsbInfoFamily & EnumVal<'unknownFamily'>;
+	static readonly smart_card: VcVirtualMachineUsbInfoFamily & EnumVal<'smart_card'>;
+	static readonly security: VcVirtualMachineUsbInfoFamily & EnumVal<'security'>;
+	static readonly hub: VcVirtualMachineUsbInfoFamily & EnumVal<'hub'>;
+	static readonly bluetooth: VcVirtualMachineUsbInfoFamily & EnumVal<'bluetooth'>;
+	static readonly wireless: VcVirtualMachineUsbInfoFamily & EnumVal<'wireless'>;
+	static readonly wusb: VcVirtualMachineUsbInfoFamily & EnumVal<'wusb'>;
+	static readonly audio: VcVirtualMachineUsbInfoFamily & EnumVal<'audio'>;
+	static readonly physical: VcVirtualMachineUsbInfoFamily & EnumVal<'physical'>;
+	static readonly communication: VcVirtualMachineUsbInfoFamily & EnumVal<'communication'>;
+	static readonly vendor_specific: VcVirtualMachineUsbInfoFamily & EnumVal<'vendor_specific'>;
+	static fromString(value: string): VcVirtualMachineUsbInfoFamily & EnumVal<TcleanKeys<typeof VcVirtualMachineUsbInfoFamily>>;
+
 	readonly id: string;
-	readonly physical: VcVirtualMachineUsbInfoFamily;
-	readonly communication: VcVirtualMachineUsbInfoFamily;
+	readonly name: string;
 	readonly value: string;
-	readonly vendor_specific: VcVirtualMachineUsbInfoFamily;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineUsbInfoFamily): VcVirtualMachineUsbInfoFamily;
+	toString: () => string;
 }
 
 /**
@@ -418,85 +406,80 @@ declare class VcVirtualMachineUsbInfoFamily {
  * slot, so can only be used by one host. Shared diagnostic parititon
  * needs multiple slots so to be usable by multiple hosts.
  */
-declare class VcDiagnosticPartitionType {
-	readonly multiHost: VcDiagnosticPartitionType;
-	readonly name: string;
+declare class VcDiagnosticPartitionType implements IPseudoEnum {
+	static readonly multiHost: VcDiagnosticPartitionType & EnumVal<'multiHost'>;
+	static readonly singleHost: VcDiagnosticPartitionType & EnumVal<'singleHost'>;
+	static fromString(value: string): VcDiagnosticPartitionType & EnumVal<TcleanKeys<typeof VcDiagnosticPartitionType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly singleHost: VcDiagnosticPartitionType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDiagnosticPartitionType): VcDiagnosticPartitionType;
+	toString: () => string;
 }
 
 /**
  * Possible states of an HA service. All services support the
  * disabled and enabled states.
  */
-declare class VcClusterDasConfigInfoServiceState {
-	static readonly name: string;
-	static readonly disabled: VcClusterDasConfigInfoServiceState;
-	static readonly id: string;
-	static readonly value: string;
-	static readonly enabled: VcClusterDasConfigInfoServiceState;
+declare class VcClusterDasConfigInfoServiceState implements IPseudoEnum {
+	static readonly disabled: VcClusterDasConfigInfoServiceState & EnumVal<'disabled'>;
+	static readonly enabled: VcClusterDasConfigInfoServiceState & EnumVal<'enabled'>;
+	static fromString(value: string): VcClusterDasConfigInfoServiceState & EnumVal<TcleanKeys<typeof VcClusterDasConfigInfoServiceState>>;
+
+	readonly id: string;
+	readonly name: string;
+	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	static fromString(value: VcClusterDasConfigInfoServiceState): VcClusterDasConfigInfoServiceState;
+	toString: () => string;
 }
 
-declare class VcApplyHostProfileConfigurationResultStatus {
-	readonly canceled: VcApplyHostProfileConfigurationResultStatus;
-	readonly stateless_reboot_failed: VcApplyHostProfileConfigurationResultStatus;
-	readonly exit_maintenancemode_failed: VcApplyHostProfileConfigurationResultStatus;
-	readonly success: VcApplyHostProfileConfigurationResultStatus;
-	readonly check_compliance_failed: VcApplyHostProfileConfigurationResultStatus;
-	readonly name: string;
-	readonly reboot_failed: VcApplyHostProfileConfigurationResultStatus;
-	readonly state_not_satisfied: VcApplyHostProfileConfigurationResultStatus;
-	readonly failed: VcApplyHostProfileConfigurationResultStatus;
+declare class VcApplyHostProfileConfigurationResultStatus implements IPseudoEnum {
+	static readonly canceled: VcApplyHostProfileConfigurationResultStatus & EnumVal<'canceled'>;
+	static readonly stateless_reboot_failed: VcApplyHostProfileConfigurationResultStatus & EnumVal<'stateless_reboot_failed'>;
+	static readonly exit_maintenancemode_failed: VcApplyHostProfileConfigurationResultStatus & EnumVal<'exit_maintenancemode_failed'>;
+	static readonly success: VcApplyHostProfileConfigurationResultStatus & EnumVal<'success'>;
+	static readonly check_compliance_failed: VcApplyHostProfileConfigurationResultStatus & EnumVal<'check_compliance_failed'>;
+	static readonly reboot_failed: VcApplyHostProfileConfigurationResultStatus & EnumVal<'reboot_failed'>;
+	static readonly state_not_satisfied: VcApplyHostProfileConfigurationResultStatus & EnumVal<'state_not_satisfied'>;
+	static readonly failed: VcApplyHostProfileConfigurationResultStatus & EnumVal<'failed'>;
+	static fromString(value: string): VcApplyHostProfileConfigurationResultStatus & EnumVal<TcleanKeys<typeof VcApplyHostProfileConfigurationResultStatus>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcApplyHostProfileConfigurationResultStatus): VcApplyHostProfileConfigurationResultStatus;
+	toString: () => string;
 }
 
 /**
  * Reasons why fault tolerance is not supported on the host.
  */
-declare class VcHostIncompatibleForFaultToleranceReason {
-	readonly product: VcHostIncompatibleForFaultToleranceReason;
-	readonly name: string;
+declare class VcHostIncompatibleForFaultToleranceReason implements IPseudoEnum {
+	static readonly product: VcHostIncompatibleForFaultToleranceReason & EnumVal<'product'>;
+	static readonly processor: VcHostIncompatibleForFaultToleranceReason & EnumVal<'processor'>;
+	static fromString(value: string): VcHostIncompatibleForFaultToleranceReason & EnumVal<TcleanKeys<typeof VcHostIncompatibleForFaultToleranceReason>>;
+
 	readonly id: string;
-	readonly processor: VcHostIncompatibleForFaultToleranceReason;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostIncompatibleForFaultToleranceReason): VcHostIncompatibleForFaultToleranceReason;
+	toString: () => string;
 }
 
 /**
  * Profiles supported by VASA Provider.
  */
-declare class ProviderProfile {
-	readonly ProfileBasedManagement: ProviderProfile;
-	readonly name: string;
-	readonly Replication: ProviderProfile;
+declare class ProviderProfile implements IPseudoEnum {
+	static readonly ProfileBasedManagement: ProviderProfile & EnumVal<'ProfileBasedManagement'>;
+	static readonly Replication: ProviderProfile & EnumVal<'Replication'>;
+	static fromString(value: string): ProviderProfile & EnumVal<TcleanKeys<typeof ProviderProfile>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: ProviderProfile): ProviderProfile;
+	toString: () => string;
 }
 
 /**
@@ -504,48 +487,45 @@ declare class ProviderProfile {
  * the type of entity that was exported
  * ({@link vim.dvs.DistributedVirtualSwitchManager#exportEntity}).
  */
-declare class VcEntityType {
-	readonly distributedVirtualSwitch: VcEntityType;
-	readonly name: string;
+declare class VcEntityType implements IPseudoEnum {
+	static readonly distributedVirtualSwitch: VcEntityType & EnumVal<'distributedVirtualSwitch'>;
+	static readonly distributedVirtualPortgroup: VcEntityType & EnumVal<'distributedVirtualPortgroup'>;
+	static fromString(value: string): VcEntityType & EnumVal<TcleanKeys<typeof VcEntityType>>;
+
 	readonly id: string;
-	readonly distributedVirtualPortgroup: VcEntityType;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcEntityType): VcEntityType;
+	toString: () => string;
 }
 
 /**
  * The Discovery Protocol types.
  */
-declare class VcLinkDiscoveryProtocolConfigProtocolType {
-	readonly name: string;
+declare class VcLinkDiscoveryProtocolConfigProtocolType implements IPseudoEnum {
+	static readonly cdp: VcLinkDiscoveryProtocolConfigProtocolType & EnumVal<'cdp'>;
+	static readonly lldp: VcLinkDiscoveryProtocolConfigProtocolType & EnumVal<'lldp'>;
+	static fromString(value: string): VcLinkDiscoveryProtocolConfigProtocolType & EnumVal<TcleanKeys<typeof VcLinkDiscoveryProtocolConfigProtocolType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly cdp: VcLinkDiscoveryProtocolConfigProtocolType;
-	readonly lldp: VcLinkDiscoveryProtocolConfigProtocolType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcLinkDiscoveryProtocolConfigProtocolType): VcLinkDiscoveryProtocolConfigProtocolType;
+	toString: () => string;
 }
 
-declare class VcIscsiPortInfoPathStatus {
-	readonly notUsed: VcIscsiPortInfoPathStatus;
-	readonly standBy: VcIscsiPortInfoPathStatus;
-	readonly lastActive: VcIscsiPortInfoPathStatus;
-	readonly name: string;
-	readonly active: VcIscsiPortInfoPathStatus;
+declare class VcIscsiPortInfoPathStatus implements IPseudoEnum {
+	static readonly notUsed: VcIscsiPortInfoPathStatus & EnumVal<'notUsed'>;
+	static readonly standBy: VcIscsiPortInfoPathStatus & EnumVal<'standBy'>;
+	static readonly lastActive: VcIscsiPortInfoPathStatus & EnumVal<'lastActive'>;
+	static readonly active: VcIscsiPortInfoPathStatus & EnumVal<'active'>;
+	static fromString(value: string): VcIscsiPortInfoPathStatus & EnumVal<TcleanKeys<typeof VcIscsiPortInfoPathStatus>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcIscsiPortInfoPathStatus): VcIscsiPortInfoPathStatus;
+	toString: () => string;
 }
 
 /**
@@ -570,124 +550,117 @@ declare class VcIscsiPortInfoPathStatus {
  * a way to unshare such disk backings.
  * <p>
  */
-declare class VcVirtualMachineRelocateDiskMoveOptions {
-	readonly moveAllDiskBackingsAndDisallowSharing: VcVirtualMachineRelocateDiskMoveOptions;
-	readonly name: string;
-	readonly moveAllDiskBackingsAndConsolidate: VcVirtualMachineRelocateDiskMoveOptions;
-	readonly moveChildMostDiskBacking: VcVirtualMachineRelocateDiskMoveOptions;
+declare class VcVirtualMachineRelocateDiskMoveOptions implements IPseudoEnum {
+	static readonly moveAllDiskBackingsAndDisallowSharing: VcVirtualMachineRelocateDiskMoveOptions & EnumVal<'moveAllDiskBackingsAndDisallowSharing'>;
+	static readonly moveAllDiskBackingsAndConsolidate: VcVirtualMachineRelocateDiskMoveOptions & EnumVal<'moveAllDiskBackingsAndConsolidate'>;
+	static readonly moveChildMostDiskBacking: VcVirtualMachineRelocateDiskMoveOptions & EnumVal<'moveChildMostDiskBacking'>;
+	static readonly moveAllDiskBackingsAndAllowSharing: VcVirtualMachineRelocateDiskMoveOptions & EnumVal<'moveAllDiskBackingsAndAllowSharing'>;
+	static readonly createNewChildDiskBacking: VcVirtualMachineRelocateDiskMoveOptions & EnumVal<'createNewChildDiskBacking'>;
+	static fromString(value: string): VcVirtualMachineRelocateDiskMoveOptions & EnumVal<TcleanKeys<typeof VcVirtualMachineRelocateDiskMoveOptions>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly moveAllDiskBackingsAndAllowSharing: VcVirtualMachineRelocateDiskMoveOptions;
-	readonly createNewChildDiskBacking: VcVirtualMachineRelocateDiskMoveOptions;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineRelocateDiskMoveOptions): VcVirtualMachineRelocateDiskMoveOptions;
+	toString: () => string;
 }
 
 /**
  * The current status of the hardware
  */
-declare class VcHostHardwareElementStatus {
-	readonly Red: VcHostHardwareElementStatus;
-	readonly Unknown: VcHostHardwareElementStatus;
-	readonly Yellow: VcHostHardwareElementStatus;
-	readonly name: string;
+declare class VcHostHardwareElementStatus implements IPseudoEnum {
+	static readonly Red: VcHostHardwareElementStatus & EnumVal<'Red'>;
+	static readonly Unknown: VcHostHardwareElementStatus & EnumVal<'Unknown'>;
+	static readonly Yellow: VcHostHardwareElementStatus & EnumVal<'Yellow'>;
+	static readonly Green: VcHostHardwareElementStatus & EnumVal<'Green'>;
+	static fromString(value: string): VcHostHardwareElementStatus & EnumVal<TcleanKeys<typeof VcHostHardwareElementStatus>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly Green: VcHostHardwareElementStatus;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostHardwareElementStatus): VcHostHardwareElementStatus;
+	toString: () => string;
 }
 
 /**
  * Defines the type of operation for an IO Filter.
  */
-declare class VcIoFilterOperation {
-	readonly uninstall: VcIoFilterOperation;
-	readonly upgrade: VcIoFilterOperation;
-	readonly install: VcIoFilterOperation;
-	readonly name: string;
+declare class VcIoFilterOperation implements IPseudoEnum {
+	static readonly uninstall: VcIoFilterOperation & EnumVal<'uninstall'>;
+	static readonly upgrade: VcIoFilterOperation & EnumVal<'upgrade'>;
+	static readonly install: VcIoFilterOperation & EnumVal<'install'>;
+	static fromString(value: string): VcIoFilterOperation & EnumVal<TcleanKeys<typeof VcIoFilterOperation>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcIoFilterOperation): VcIoFilterOperation;
+	toString: () => string;
 }
 
 /**
  * Provisioning type constants.
  */
-declare class VcBaseConfigInfoDiskFileBackingInfoProvisioningType {
-	readonly name: string;
-	readonly lazyZeroedThick: VcBaseConfigInfoDiskFileBackingInfoProvisioningType;
+declare class VcBaseConfigInfoDiskFileBackingInfoProvisioningType implements IPseudoEnum {
+	static readonly lazyZeroedThick: VcBaseConfigInfoDiskFileBackingInfoProvisioningType & EnumVal<'lazyZeroedThick'>;
+	static readonly eagerZeroedThick: VcBaseConfigInfoDiskFileBackingInfoProvisioningType & EnumVal<'eagerZeroedThick'>;
+	static readonly thin: VcBaseConfigInfoDiskFileBackingInfoProvisioningType & EnumVal<'thin'>;
+	static fromString(value: string): VcBaseConfigInfoDiskFileBackingInfoProvisioningType & EnumVal<TcleanKeys<typeof VcBaseConfigInfoDiskFileBackingInfoProvisioningType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly eagerZeroedThick: VcBaseConfigInfoDiskFileBackingInfoProvisioningType;
-	readonly thin: VcBaseConfigInfoDiskFileBackingInfoProvisioningType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcBaseConfigInfoDiskFileBackingInfoProvisioningType): VcBaseConfigInfoDiskFileBackingInfoProvisioningType;
+	toString: () => string;
 }
 
 /**
  * The status of the provider certificate
  */
-declare class VasaProviderCertificateStatus {
-	readonly valid: VasaProviderCertificateStatus;
-	readonly expired: VasaProviderCertificateStatus;
-	readonly invalid: VasaProviderCertificateStatus;
-	readonly name: string;
+declare class VasaProviderCertificateStatus implements IPseudoEnum {
+	static readonly valid: VasaProviderCertificateStatus & EnumVal<'valid'>;
+	static readonly expired: VasaProviderCertificateStatus & EnumVal<'expired'>;
+	static readonly invalid: VasaProviderCertificateStatus & EnumVal<'invalid'>;
+	static readonly expirySoftLimitReached: VasaProviderCertificateStatus & EnumVal<'expirySoftLimitReached'>;
+	static readonly expiryHardLimitReached: VasaProviderCertificateStatus & EnumVal<'expiryHardLimitReached'>;
+	static fromString(value: string): VasaProviderCertificateStatus & EnumVal<TcleanKeys<typeof VasaProviderCertificateStatus>>;
+
 	readonly id: string;
-	readonly expirySoftLimitReached: VasaProviderCertificateStatus;
-	readonly expiryHardLimitReached: VasaProviderCertificateStatus;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VasaProviderCertificateStatus): VasaProviderCertificateStatus;
+	toString: () => string;
 }
 
 /**
  * Pre-defined constants for possible recommendation types. Virtual Center
  * uses this information to coordinate with the clients.
  */
-declare class VcRecommendationType {
-	readonly name: string;
-	readonly V1: VcRecommendationType;
+declare class VcRecommendationType implements IPseudoEnum {
+	static readonly V1: VcRecommendationType & EnumVal<'V1'>;
+	static fromString(value: string): VcRecommendationType & EnumVal<TcleanKeys<typeof VcRecommendationType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcRecommendationType): VcRecommendationType;
+	toString: () => string;
 }
 
 /**
  * Defines the current maintenance mode state of the datastore.
  */
-declare class VcDatastoreSummaryMaintenanceModeState {
-	readonly normal: VcDatastoreSummaryMaintenanceModeState;
-	readonly enteringMaintenance: VcDatastoreSummaryMaintenanceModeState;
-	readonly inMaintenance: VcDatastoreSummaryMaintenanceModeState;
-	readonly name: string;
+declare class VcDatastoreSummaryMaintenanceModeState implements IPseudoEnum {
+	static readonly normal: VcDatastoreSummaryMaintenanceModeState & EnumVal<'normal'>;
+	static readonly enteringMaintenance: VcDatastoreSummaryMaintenanceModeState & EnumVal<'enteringMaintenance'>;
+	static readonly inMaintenance: VcDatastoreSummaryMaintenanceModeState & EnumVal<'inMaintenance'>;
+	static fromString(value: string): VcDatastoreSummaryMaintenanceModeState & EnumVal<TcleanKeys<typeof VcDatastoreSummaryMaintenanceModeState>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDatastoreSummaryMaintenanceModeState): VcDatastoreSummaryMaintenanceModeState;
+	toString: () => string;
 }
 
 /**
@@ -705,58 +678,55 @@ declare class VcDatastoreSummaryMaintenanceModeState {
  * the cluster-wide default HA configuration for virtual machines
  * ({@link vim.cluster.DasConfigInfo#defaultVmSettings}).
  */
-declare class VcClusterDasVmSettingsRestartPriority {
-	static readonly clusterRestartPriority: VcClusterDasVmSettingsRestartPriority;
-	static readonly high: VcClusterDasVmSettingsRestartPriority;
-	static readonly low: VcClusterDasVmSettingsRestartPriority;
-	static readonly highest: VcClusterDasVmSettingsRestartPriority;
-	static readonly name: string;
-	static readonly disabled: VcClusterDasVmSettingsRestartPriority;
-	static readonly medium: VcClusterDasVmSettingsRestartPriority;
-	static readonly id: string;
-	static readonly lowest: VcClusterDasVmSettingsRestartPriority;
-	static readonly value: string;
+declare class VcClusterDasVmSettingsRestartPriority implements IPseudoEnum {
+	static readonly clusterRestartPriority: VcClusterDasVmSettingsRestartPriority & EnumVal<'clusterRestartPriority'>;
+	static readonly high: VcClusterDasVmSettingsRestartPriority & EnumVal<'high'>;
+	static readonly low: VcClusterDasVmSettingsRestartPriority & EnumVal<'low'>;
+	static readonly highest: VcClusterDasVmSettingsRestartPriority & EnumVal<'highest'>;
+	static readonly disabled: VcClusterDasVmSettingsRestartPriority & EnumVal<'disabled'>;
+	static readonly medium: VcClusterDasVmSettingsRestartPriority & EnumVal<'medium'>;
+	static readonly lowest: VcClusterDasVmSettingsRestartPriority & EnumVal<'lowest'>;
+	static fromString(value: string): VcClusterDasVmSettingsRestartPriority & EnumVal<TcleanKeys<typeof VcClusterDasVmSettingsRestartPriority>>;
+
+	readonly id: string;
+	readonly name: string;
+	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	static fromString(value: VcClusterDasVmSettingsRestartPriority): VcClusterDasVmSettingsRestartPriority;
+	toString: () => string;
 }
 
 /**
  * Types of affinities.
  */
-declare class VcAffinityType {
-	readonly memory: VcAffinityType;
-	readonly name: string;
-	readonly cpu: VcAffinityType;
+declare class VcAffinityType implements IPseudoEnum {
+	static readonly memory: VcAffinityType & EnumVal<'memory'>;
+	static readonly cpu: VcAffinityType & EnumVal<'cpu'>;
+	static fromString(value: string): VcAffinityType & EnumVal<TcleanKeys<typeof VcAffinityType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcAffinityType): VcAffinityType;
+	toString: () => string;
 }
 
 /**
  * Describes the current state of a replicated {@link vim.VirtualMachine}
  */
-declare class VcReplicationVmState {
-	readonly paused: VcReplicationVmState;
-	readonly syncing: VcReplicationVmState;
-	readonly idle: VcReplicationVmState;
-	readonly name: string;
-	readonly active: VcReplicationVmState;
-	readonly none: VcReplicationVmState;
+declare class VcReplicationVmState implements IPseudoEnum {
+	static readonly paused: VcReplicationVmState & EnumVal<'paused'>;
+	static readonly syncing: VcReplicationVmState & EnumVal<'syncing'>;
+	static readonly idle: VcReplicationVmState & EnumVal<'idle'>;
+	static readonly active: VcReplicationVmState & EnumVal<'active'>;
+	static readonly none: VcReplicationVmState & EnumVal<'none'>;
+	static readonly error: VcReplicationVmState & EnumVal<'error'>;
+	static fromString(value: string): VcReplicationVmState & EnumVal<TcleanKeys<typeof VcReplicationVmState>>;
+
 	readonly id: string;
-	readonly error: VcReplicationVmState;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcReplicationVmState): VcReplicationVmState;
+	toString: () => string;
 }
 
 /**
@@ -764,22 +734,21 @@ declare class VcReplicationVmState {
  * These should match(upper case) the IO Filter classes as defined by IO Filter framework.
  * See https://opengrok.eng.vmware.com/source/xref/vmcore-main.perforce.1666/bora/scons/apps/esx/iofilterApps.sc#33
  */
-declare class PbmIofilterInfoFilterType {
-	readonly INSPECTION: PbmIofilterInfoFilterType;
-	readonly ENCRYPTION: PbmIofilterInfoFilterType;
-	readonly REPLICATION: PbmIofilterInfoFilterType;
-	readonly name: string;
-	readonly COMPRESSION: PbmIofilterInfoFilterType;
+declare class PbmIofilterInfoFilterType implements IPseudoEnum {
+	static readonly INSPECTION: PbmIofilterInfoFilterType & EnumVal<'INSPECTION'>;
+	static readonly ENCRYPTION: PbmIofilterInfoFilterType & EnumVal<'ENCRYPTION'>;
+	static readonly REPLICATION: PbmIofilterInfoFilterType & EnumVal<'REPLICATION'>;
+	static readonly COMPRESSION: PbmIofilterInfoFilterType & EnumVal<'COMPRESSION'>;
+	static readonly CACHE: PbmIofilterInfoFilterType & EnumVal<'CACHE'>;
+	static readonly DATASTOREIOCONTROL: PbmIofilterInfoFilterType & EnumVal<'DATASTOREIOCONTROL'>;
+	static readonly DATAPROVIDER: PbmIofilterInfoFilterType & EnumVal<'DATAPROVIDER'>;
+	static fromString(value: string): PbmIofilterInfoFilterType & EnumVal<TcleanKeys<typeof PbmIofilterInfoFilterType>>;
+
 	readonly id: string;
-	readonly CACHE: PbmIofilterInfoFilterType;
-	readonly DATASTOREIOCONTROL: PbmIofilterInfoFilterType;
+	readonly name: string;
 	readonly value: string;
-	readonly DATAPROVIDER: PbmIofilterInfoFilterType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: PbmIofilterInfoFilterType): PbmIofilterInfoFilterType;
+	toString: () => string;
 }
 
 /**
@@ -788,17 +757,16 @@ declare class PbmIofilterInfoFilterType {
  * operations to apply on the managed object.
  * <p>
  */
-declare class VcHostConfigChangeMode {
-	readonly modify: VcHostConfigChangeMode;
-	readonly replace: VcHostConfigChangeMode;
-	readonly name: string;
+declare class VcHostConfigChangeMode implements IPseudoEnum {
+	static readonly modify: VcHostConfigChangeMode & EnumVal<'modify'>;
+	static readonly replace: VcHostConfigChangeMode & EnumVal<'replace'>;
+	static fromString(value: string): VcHostConfigChangeMode & EnumVal<TcleanKeys<typeof VcHostConfigChangeMode>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostConfigChangeMode): VcHostConfigChangeMode;
+	toString: () => string;
 }
 
 /**
@@ -808,40 +776,38 @@ declare class VcHostConfigChangeMode {
  * we don't need fine-grained control on local user permissions like the
  * interface provided by {@link vim.AuthorizationManager}.
  */
-declare class VcHostAccessMode {
-	readonly accessAdmin: VcHostAccessMode;
-	readonly accessNoAccess: VcHostAccessMode;
-	readonly accessReadOnly: VcHostAccessMode;
-	readonly accessNone: VcHostAccessMode;
-	readonly name: string;
-	readonly accessOther: VcHostAccessMode;
+declare class VcHostAccessMode implements IPseudoEnum {
+	static readonly accessAdmin: VcHostAccessMode & EnumVal<'accessAdmin'>;
+	static readonly accessNoAccess: VcHostAccessMode & EnumVal<'accessNoAccess'>;
+	static readonly accessReadOnly: VcHostAccessMode & EnumVal<'accessReadOnly'>;
+	static readonly accessNone: VcHostAccessMode & EnumVal<'accessNone'>;
+	static readonly accessOther: VcHostAccessMode & EnumVal<'accessOther'>;
+	static fromString(value: string): VcHostAccessMode & EnumVal<TcleanKeys<typeof VcHostAccessMode>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostAccessMode): VcHostAccessMode;
+	toString: () => string;
 }
 
 /**
  * The VM policy settings that determine the response to
  * storage failures.
  */
-declare class VcClusterVmComponentProtectionSettingsStorageVmReaction {
-	static readonly clusterDefault: VcClusterVmComponentProtectionSettingsStorageVmReaction;
-	static readonly restartAggressive: VcClusterVmComponentProtectionSettingsStorageVmReaction;
-	static readonly name: string;
-	static readonly warning: VcClusterVmComponentProtectionSettingsStorageVmReaction;
-	static readonly restartConservative: VcClusterVmComponentProtectionSettingsStorageVmReaction;
-	static readonly disabled: VcClusterVmComponentProtectionSettingsStorageVmReaction;
-	static readonly id: string;
-	static readonly value: string;
+declare class VcClusterVmComponentProtectionSettingsStorageVmReaction implements IPseudoEnum {
+	static readonly clusterDefault: VcClusterVmComponentProtectionSettingsStorageVmReaction & EnumVal<'clusterDefault'>;
+	static readonly restartAggressive: VcClusterVmComponentProtectionSettingsStorageVmReaction & EnumVal<'restartAggressive'>;
+	static readonly warning: VcClusterVmComponentProtectionSettingsStorageVmReaction & EnumVal<'warning'>;
+	static readonly restartConservative: VcClusterVmComponentProtectionSettingsStorageVmReaction & EnumVal<'restartConservative'>;
+	static readonly disabled: VcClusterVmComponentProtectionSettingsStorageVmReaction & EnumVal<'disabled'>;
+	static fromString(value: string): VcClusterVmComponentProtectionSettingsStorageVmReaction & EnumVal<TcleanKeys<typeof VcClusterVmComponentProtectionSettingsStorageVmReaction>>;
+
+	readonly id: string;
+	readonly name: string;
+	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	static fromString(value: VcClusterVmComponentProtectionSettingsStorageVmReaction): VcClusterVmComponentProtectionSettingsStorageVmReaction;
+	toString: () => string;
 }
 
 /**
@@ -851,53 +817,50 @@ declare class VcClusterVmComponentProtectionSettingsStorageVmReaction {
  * In terms of latency-sensitivity the values relate:
  * high>medium>normal>low.
  */
-declare class VcLatencySensitivitySensitivityLevel {
-	readonly normal: VcLatencySensitivitySensitivityLevel;
-	readonly high: VcLatencySensitivitySensitivityLevel;
-	readonly low: VcLatencySensitivitySensitivityLevel;
-	readonly custom: VcLatencySensitivitySensitivityLevel;
-	readonly name: string;
-	readonly medium: VcLatencySensitivitySensitivityLevel;
+declare class VcLatencySensitivitySensitivityLevel implements IPseudoEnum {
+	static readonly normal: VcLatencySensitivitySensitivityLevel & EnumVal<'normal'>;
+	static readonly high: VcLatencySensitivitySensitivityLevel & EnumVal<'high'>;
+	static readonly low: VcLatencySensitivitySensitivityLevel & EnumVal<'low'>;
+	static readonly custom: VcLatencySensitivitySensitivityLevel & EnumVal<'custom'>;
+	static readonly medium: VcLatencySensitivitySensitivityLevel & EnumVal<'medium'>;
+	static fromString(value: string): VcLatencySensitivitySensitivityLevel & EnumVal<TcleanKeys<typeof VcLatencySensitivitySensitivityLevel>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcLatencySensitivitySensitivityLevel): VcLatencySensitivitySensitivityLevel;
+	toString: () => string;
 }
 
 /**
  * The set of valid encrypted vMotion modes for a VM.
  */
-declare class VcVirtualMachineConfigSpecEncryptedVMotionModes {
-	readonly opportunistic: VcVirtualMachineConfigSpecEncryptedVMotionModes;
-	readonly name: string;
-	readonly disabled: VcVirtualMachineConfigSpecEncryptedVMotionModes;
+declare class VcVirtualMachineConfigSpecEncryptedVMotionModes implements IPseudoEnum {
+	static readonly opportunistic: VcVirtualMachineConfigSpecEncryptedVMotionModes & EnumVal<'opportunistic'>;
+	static readonly disabled: VcVirtualMachineConfigSpecEncryptedVMotionModes & EnumVal<'disabled'>;
+	static readonly required: VcVirtualMachineConfigSpecEncryptedVMotionModes & EnumVal<'required'>;
+	static fromString(value: string): VcVirtualMachineConfigSpecEncryptedVMotionModes & EnumVal<TcleanKeys<typeof VcVirtualMachineConfigSpecEncryptedVMotionModes>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly required: VcVirtualMachineConfigSpecEncryptedVMotionModes;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineConfigSpecEncryptedVMotionModes): VcVirtualMachineConfigSpecEncryptedVMotionModes;
+	toString: () => string;
 }
 
 /**
  * Pre-defined constants for cache consistency types
  */
-declare class VcVirtualDiskVFlashCacheConfigInfoCacheConsistencyType {
-	readonly strong: VcVirtualDiskVFlashCacheConfigInfoCacheConsistencyType;
-	readonly name: string;
+declare class VcVirtualDiskVFlashCacheConfigInfoCacheConsistencyType implements IPseudoEnum {
+	static readonly strong: VcVirtualDiskVFlashCacheConfigInfoCacheConsistencyType & EnumVal<'strong'>;
+	static readonly weak: VcVirtualDiskVFlashCacheConfigInfoCacheConsistencyType & EnumVal<'weak'>;
+	static fromString(value: string): VcVirtualDiskVFlashCacheConfigInfoCacheConsistencyType & EnumVal<TcleanKeys<typeof VcVirtualDiskVFlashCacheConfigInfoCacheConsistencyType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly weak: VcVirtualDiskVFlashCacheConfigInfoCacheConsistencyType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualDiskVFlashCacheConfigInfoCacheConsistencyType): VcVirtualDiskVFlashCacheConfigInfoCacheConsistencyType;
+	toString: () => string;
 }
 
 /**
@@ -905,231 +868,218 @@ declare class VcVirtualDiskVFlashCacheConfigInfoCacheConsistencyType {
  * 
  * <p>
  */
-declare class VcVirtualPointingDeviceHostChoice {
-	readonly autodetect: VcVirtualPointingDeviceHostChoice;
-	readonly mouseSystems: VcVirtualPointingDeviceHostChoice;
-	readonly microsoft_serial: VcVirtualPointingDeviceHostChoice;
-	readonly mousemanSerial: VcVirtualPointingDeviceHostChoice;
-	readonly name: string;
-	readonly intellimousePs2: VcVirtualPointingDeviceHostChoice;
+declare class VcVirtualPointingDeviceHostChoice implements IPseudoEnum {
+	static readonly autodetect: VcVirtualPointingDeviceHostChoice & EnumVal<'autodetect'>;
+	static readonly mouseSystems: VcVirtualPointingDeviceHostChoice & EnumVal<'mouseSystems'>;
+	static readonly microsoft_serial: VcVirtualPointingDeviceHostChoice & EnumVal<'microsoft_serial'>;
+	static readonly mousemanSerial: VcVirtualPointingDeviceHostChoice & EnumVal<'mousemanSerial'>;
+	static readonly intellimousePs2: VcVirtualPointingDeviceHostChoice & EnumVal<'intellimousePs2'>;
+	static readonly intellimouseExplorer: VcVirtualPointingDeviceHostChoice & EnumVal<'intellimouseExplorer'>;
+	static readonly logitechMouseman: VcVirtualPointingDeviceHostChoice & EnumVal<'logitechMouseman'>;
+	static readonly ps2: VcVirtualPointingDeviceHostChoice & EnumVal<'ps2'>;
+	static fromString(value: string): VcVirtualPointingDeviceHostChoice & EnumVal<TcleanKeys<typeof VcVirtualPointingDeviceHostChoice>>;
+
 	readonly id: string;
-	readonly intellimouseExplorer: VcVirtualPointingDeviceHostChoice;
-	readonly logitechMouseman: VcVirtualPointingDeviceHostChoice;
+	readonly name: string;
 	readonly value: string;
-	readonly ps2: VcVirtualPointingDeviceHostChoice;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualPointingDeviceHostChoice): VcVirtualPointingDeviceHostChoice;
+	toString: () => string;
 }
 
-declare class VcCannotPowerOffVmInClusterOperation {
-	readonly suspend: VcCannotPowerOffVmInClusterOperation;
-	readonly guestSuspend: VcCannotPowerOffVmInClusterOperation;
-	readonly powerOff: VcCannotPowerOffVmInClusterOperation;
-	readonly name: string;
-	readonly guestShutdown: VcCannotPowerOffVmInClusterOperation;
+declare class VcCannotPowerOffVmInClusterOperation implements IPseudoEnum {
+	static readonly suspend: VcCannotPowerOffVmInClusterOperation & EnumVal<'suspend'>;
+	static readonly guestSuspend: VcCannotPowerOffVmInClusterOperation & EnumVal<'guestSuspend'>;
+	static readonly powerOff: VcCannotPowerOffVmInClusterOperation & EnumVal<'powerOff'>;
+	static readonly guestShutdown: VcCannotPowerOffVmInClusterOperation & EnumVal<'guestShutdown'>;
+	static fromString(value: string): VcCannotPowerOffVmInClusterOperation & EnumVal<TcleanKeys<typeof VcCannotPowerOffVmInClusterOperation>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcCannotPowerOffVmInClusterOperation): VcCannotPowerOffVmInClusterOperation;
+	toString: () => string;
 }
 
 /**
  * Link Aggregation Control Protocol policy modes.
  */
-declare class VcVMwareUplinkLacpMode {
-	readonly name: string;
-	readonly active: VcVMwareUplinkLacpMode;
+declare class VcVMwareUplinkLacpMode implements IPseudoEnum {
+	static readonly active: VcVMwareUplinkLacpMode & EnumVal<'active'>;
+	static readonly passive: VcVMwareUplinkLacpMode & EnumVal<'passive'>;
+	static fromString(value: string): VcVMwareUplinkLacpMode & EnumVal<TcleanKeys<typeof VcVMwareUplinkLacpMode>>;
+
 	readonly id: string;
-	readonly passive: VcVMwareUplinkLacpMode;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVMwareUplinkLacpMode): VcVMwareUplinkLacpMode;
+	toString: () => string;
 }
 
 /**
  * Pre-defined constants for possible action types. Virtual Center
  * uses this information to coordinate with the clients.
  */
-declare class VcActionType {
-	readonly IncreaseSizeV1: VcActionType;
-	readonly MigrationV1: VcActionType;
-	readonly IncreaseLimitV1: VcActionType;
-	readonly DecreaseMigrationThresholdV1: VcActionType;
-	readonly IncreaseSharesV1: VcActionType;
-	readonly PlacementV1: VcActionType;
-	readonly HostPowerV1: VcActionType;
-	readonly IncreaseClusterCapacityV1: VcActionType;
-	readonly IncreaseReservationV1: VcActionType;
-	readonly HostMaintenanceV1: VcActionType;
-	readonly HostInfraUpdateHaV1: VcActionType;
-	readonly name: string;
-	readonly StoragePlacementV1: VcActionType;
+declare class VcActionType implements IPseudoEnum {
+	static readonly IncreaseSizeV1: VcActionType & EnumVal<'IncreaseSizeV1'>;
+	static readonly MigrationV1: VcActionType & EnumVal<'MigrationV1'>;
+	static readonly IncreaseLimitV1: VcActionType & EnumVal<'IncreaseLimitV1'>;
+	static readonly DecreaseMigrationThresholdV1: VcActionType & EnumVal<'DecreaseMigrationThresholdV1'>;
+	static readonly IncreaseSharesV1: VcActionType & EnumVal<'IncreaseSharesV1'>;
+	static readonly PlacementV1: VcActionType & EnumVal<'PlacementV1'>;
+	static readonly HostPowerV1: VcActionType & EnumVal<'HostPowerV1'>;
+	static readonly IncreaseClusterCapacityV1: VcActionType & EnumVal<'IncreaseClusterCapacityV1'>;
+	static readonly IncreaseReservationV1: VcActionType & EnumVal<'IncreaseReservationV1'>;
+	static readonly HostMaintenanceV1: VcActionType & EnumVal<'HostMaintenanceV1'>;
+	static readonly HostInfraUpdateHaV1: VcActionType & EnumVal<'HostInfraUpdateHaV1'>;
+	static readonly StoragePlacementV1: VcActionType & EnumVal<'StoragePlacementV1'>;
+	static readonly StorageMigrationV1: VcActionType & EnumVal<'StorageMigrationV1'>;
+	static readonly VmPowerV1: VcActionType & EnumVal<'VmPowerV1'>;
+	static readonly DecreaseOthersReservationV1: VcActionType & EnumVal<'DecreaseOthersReservationV1'>;
+	static fromString(value: string): VcActionType & EnumVal<TcleanKeys<typeof VcActionType>>;
+
 	readonly id: string;
-	readonly StorageMigrationV1: VcActionType;
+	readonly name: string;
 	readonly value: string;
-	readonly VmPowerV1: VcActionType;
-	readonly DecreaseOthersReservationV1: VcActionType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcActionType): VcActionType;
+	toString: () => string;
 }
 
-declare class VcCannotEnableVmcpForClusterReason {
-	readonly IncompatibleHostVersion: VcCannotEnableVmcpForClusterReason;
-	readonly name: string;
-	readonly APDTimeoutDisabled: VcCannotEnableVmcpForClusterReason;
+declare class VcCannotEnableVmcpForClusterReason implements IPseudoEnum {
+	static readonly IncompatibleHostVersion: VcCannotEnableVmcpForClusterReason & EnumVal<'IncompatibleHostVersion'>;
+	static readonly APDTimeoutDisabled: VcCannotEnableVmcpForClusterReason & EnumVal<'APDTimeoutDisabled'>;
+	static fromString(value: string): VcCannotEnableVmcpForClusterReason & EnumVal<TcleanKeys<typeof VcCannotEnableVmcpForClusterReason>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcCannotEnableVmcpForClusterReason): VcCannotEnableVmcpForClusterReason;
+	toString: () => string;
 }
 
-declare class VcDayOfWeek {
-	readonly sunday: VcDayOfWeek;
-	readonly saturday: VcDayOfWeek;
-	readonly tuesday: VcDayOfWeek;
-	readonly name: string;
-	readonly wednesday: VcDayOfWeek;
-	readonly thursday: VcDayOfWeek;
-	readonly friday: VcDayOfWeek;
+declare class VcDayOfWeek implements IPseudoEnum {
+	static readonly sunday: VcDayOfWeek & EnumVal<'sunday'>;
+	static readonly saturday: VcDayOfWeek & EnumVal<'saturday'>;
+	static readonly tuesday: VcDayOfWeek & EnumVal<'tuesday'>;
+	static readonly wednesday: VcDayOfWeek & EnumVal<'wednesday'>;
+	static readonly thursday: VcDayOfWeek & EnumVal<'thursday'>;
+	static readonly friday: VcDayOfWeek & EnumVal<'friday'>;
+	static readonly monday: VcDayOfWeek & EnumVal<'monday'>;
+	static fromString(value: string): VcDayOfWeek & EnumVal<TcleanKeys<typeof VcDayOfWeek>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly monday: VcDayOfWeek;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDayOfWeek): VcDayOfWeek;
+	toString: () => string;
 }
 
 /**
  * The FaultToleranceType defines the type of fault tolerance, if any,
  * the virtual machine is configured for.
  */
-declare class VcVirtualMachineFaultToleranceType {
-	readonly checkpointing: VcVirtualMachineFaultToleranceType;
-	readonly recordReplay: VcVirtualMachineFaultToleranceType;
-	readonly name: string;
+declare class VcVirtualMachineFaultToleranceType implements IPseudoEnum {
+	static readonly checkpointing: VcVirtualMachineFaultToleranceType & EnumVal<'checkpointing'>;
+	static readonly recordReplay: VcVirtualMachineFaultToleranceType & EnumVal<'recordReplay'>;
+	static readonly unset: VcVirtualMachineFaultToleranceType & EnumVal<'unset'>;
+	static fromString(value: string): VcVirtualMachineFaultToleranceType & EnumVal<TcleanKeys<typeof VcVirtualMachineFaultToleranceType>>;
+
 	readonly id: string;
-	readonly unset: VcVirtualMachineFaultToleranceType;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineFaultToleranceType): VcVirtualMachineFaultToleranceType;
+	toString: () => string;
 }
 
-declare class VcHostOperationCleanupManagerOperationActivity {
-	readonly name: string;
-	readonly create: VcHostOperationCleanupManagerOperationActivity;
-	readonly nfc: VcHostOperationCleanupManagerOperationActivity;
+declare class VcHostOperationCleanupManagerOperationActivity implements IPseudoEnum {
+	static readonly create: VcHostOperationCleanupManagerOperationActivity & EnumVal<'create'>;
+	static readonly nfc: VcHostOperationCleanupManagerOperationActivity & EnumVal<'nfc'>;
+	static readonly vmotion: VcHostOperationCleanupManagerOperationActivity & EnumVal<'vmotion'>;
+	static fromString(value: string): VcHostOperationCleanupManagerOperationActivity & EnumVal<TcleanKeys<typeof VcHostOperationCleanupManagerOperationActivity>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly vmotion: VcHostOperationCleanupManagerOperationActivity;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostOperationCleanupManagerOperationActivity): VcHostOperationCleanupManagerOperationActivity;
+	toString: () => string;
 }
 
-declare class VcCannotUseNetworkReason {
-	readonly NetworkReservationNotSupported: VcCannotUseNetworkReason;
-	readonly VMotionToUnsupportedNetworkType: VcCannotUseNetworkReason;
-	readonly name: string;
-	readonly MismatchedDvsVersionOrVendor: VcCannotUseNetworkReason;
+declare class VcCannotUseNetworkReason implements IPseudoEnum {
+	static readonly NetworkReservationNotSupported: VcCannotUseNetworkReason & EnumVal<'NetworkReservationNotSupported'>;
+	static readonly VMotionToUnsupportedNetworkType: VcCannotUseNetworkReason & EnumVal<'VMotionToUnsupportedNetworkType'>;
+	static readonly MismatchedDvsVersionOrVendor: VcCannotUseNetworkReason & EnumVal<'MismatchedDvsVersionOrVendor'>;
+	static readonly MismatchedNetworkPolicies: VcCannotUseNetworkReason & EnumVal<'MismatchedNetworkPolicies'>;
+	static fromString(value: string): VcCannotUseNetworkReason & EnumVal<TcleanKeys<typeof VcCannotUseNetworkReason>>;
+
 	readonly id: string;
-	readonly MismatchedNetworkPolicies: VcCannotUseNetworkReason;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcCannotUseNetworkReason): VcCannotUseNetworkReason;
+	toString: () => string;
 }
 
 /**
  * Set of possible values for {@link vim.vm.FlagInfo#virtualExecUsage}.
  */
-declare class VcVirtualMachineFlagInfoVirtualExecUsage {
-	readonly hvOff: VcVirtualMachineFlagInfoVirtualExecUsage;
-	readonly name: string;
-	readonly hvAuto: VcVirtualMachineFlagInfoVirtualExecUsage;
+declare class VcVirtualMachineFlagInfoVirtualExecUsage implements IPseudoEnum {
+	static readonly hvOff: VcVirtualMachineFlagInfoVirtualExecUsage & EnumVal<'hvOff'>;
+	static readonly hvAuto: VcVirtualMachineFlagInfoVirtualExecUsage & EnumVal<'hvAuto'>;
+	static readonly hvOn: VcVirtualMachineFlagInfoVirtualExecUsage & EnumVal<'hvOn'>;
+	static fromString(value: string): VcVirtualMachineFlagInfoVirtualExecUsage & EnumVal<TcleanKeys<typeof VcVirtualMachineFlagInfoVirtualExecUsage>>;
+
 	readonly id: string;
-	readonly hvOn: VcVirtualMachineFlagInfoVirtualExecUsage;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineFlagInfoVirtualExecUsage): VcVirtualMachineFlagInfoVirtualExecUsage;
+	toString: () => string;
 }
 
 /**
  * IP protocols supported by the guest.
  */
-declare class VcVAppIPAssignmentInfoProtocols {
-	readonly IPv6: VcVAppIPAssignmentInfoProtocols;
-	readonly IPv4: VcVAppIPAssignmentInfoProtocols;
-	readonly name: string;
+declare class VcVAppIPAssignmentInfoProtocols implements IPseudoEnum {
+	static readonly IPv6: VcVAppIPAssignmentInfoProtocols & EnumVal<'IPv6'>;
+	static readonly IPv4: VcVAppIPAssignmentInfoProtocols & EnumVal<'IPv4'>;
+	static fromString(value: string): VcVAppIPAssignmentInfoProtocols & EnumVal<TcleanKeys<typeof VcVAppIPAssignmentInfoProtocols>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVAppIPAssignmentInfoProtocols): VcVAppIPAssignmentInfoProtocols;
+	toString: () => string;
 }
 
 /**
  * Values used for indicating a disk's status for use by the VSAN service.
  */
-declare class VcVsanHostDiskResultState {
-	readonly ineligible: VcVsanHostDiskResultState;
-	readonly eligible: VcVsanHostDiskResultState;
-	readonly inUse: VcVsanHostDiskResultState;
-	readonly name: string;
+declare class VcVsanHostDiskResultState implements IPseudoEnum {
+	static readonly ineligible: VcVsanHostDiskResultState & EnumVal<'ineligible'>;
+	static readonly eligible: VcVsanHostDiskResultState & EnumVal<'eligible'>;
+	static readonly inUse: VcVsanHostDiskResultState & EnumVal<'inUse'>;
+	static fromString(value: string): VcVsanHostDiskResultState & EnumVal<TcleanKeys<typeof VcVsanHostDiskResultState>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVsanHostDiskResultState): VcVsanHostDiskResultState;
+	toString: () => string;
 }
 
 /**
  * Set of possible values for
  * {@link vim.dvs.DistributedVirtualPort.RuntimeInfo}.{@link vim.dvs.DistributedVirtualPort.RuntimeInfo#vmDirectPathGen2InactiveReasonNetwork}.
  */
-declare class VcDVPortStatusVmDirectPathGen2InactiveReasonNetwork {
-	readonly portNptDisabledForPort: VcDVPortStatusVmDirectPathGen2InactiveReasonNetwork;
-	readonly name: string;
-	readonly portNptNoVirtualFunctionsAvailable: VcDVPortStatusVmDirectPathGen2InactiveReasonNetwork;
+declare class VcDVPortStatusVmDirectPathGen2InactiveReasonNetwork implements IPseudoEnum {
+	static readonly portNptDisabledForPort: VcDVPortStatusVmDirectPathGen2InactiveReasonNetwork & EnumVal<'portNptDisabledForPort'>;
+	static readonly portNptNoVirtualFunctionsAvailable: VcDVPortStatusVmDirectPathGen2InactiveReasonNetwork & EnumVal<'portNptNoVirtualFunctionsAvailable'>;
+	static readonly portNptNoCompatibleNics: VcDVPortStatusVmDirectPathGen2InactiveReasonNetwork & EnumVal<'portNptNoCompatibleNics'>;
+	static readonly portNptIncompatibleDvs: VcDVPortStatusVmDirectPathGen2InactiveReasonNetwork & EnumVal<'portNptIncompatibleDvs'>;
+	static fromString(value: string): VcDVPortStatusVmDirectPathGen2InactiveReasonNetwork & EnumVal<TcleanKeys<typeof VcDVPortStatusVmDirectPathGen2InactiveReasonNetwork>>;
+
 	readonly id: string;
-	readonly portNptNoCompatibleNics: VcDVPortStatusVmDirectPathGen2InactiveReasonNetwork;
+	readonly name: string;
 	readonly value: string;
-	readonly portNptIncompatibleDvs: VcDVPortStatusVmDirectPathGen2InactiveReasonNetwork;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDVPortStatusVmDirectPathGen2InactiveReasonNetwork): VcDVPortStatusVmDirectPathGen2InactiveReasonNetwork;
+	toString: () => string;
 }
 
 /**
@@ -1142,18 +1092,17 @@ declare class VcDVPortStatusVmDirectPathGen2InactiveReasonNetwork {
  * http://msdn.microsoft.com/en-us/library/aa384249(v=vs.85).aspx and
  * http://msdn.microsoft.com/en-us/library/aa384253(v=vs.85).aspx
  */
-declare class VcGuestRegKeyWowSpec {
-	readonly WOW32: VcGuestRegKeyWowSpec;
-	readonly WOW64: VcGuestRegKeyWowSpec;
-	readonly WOWNative: VcGuestRegKeyWowSpec;
-	readonly name: string;
+declare class VcGuestRegKeyWowSpec implements IPseudoEnum {
+	static readonly WOW32: VcGuestRegKeyWowSpec & EnumVal<'WOW32'>;
+	static readonly WOW64: VcGuestRegKeyWowSpec & EnumVal<'WOW64'>;
+	static readonly WOWNative: VcGuestRegKeyWowSpec & EnumVal<'WOWNative'>;
+	static fromString(value: string): VcGuestRegKeyWowSpec & EnumVal<TcleanKeys<typeof VcGuestRegKeyWowSpec>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcGuestRegKeyWowSpec): VcGuestRegKeyWowSpec;
+	toString: () => string;
 }
 
 /**
@@ -1163,53 +1112,50 @@ declare class VcGuestRegKeyWowSpec {
  * virtual machines on a host get preference over low priority
  * virtual machines.
  */
-declare class VcDasVmPriority {
-	readonly high: VcDasVmPriority;
-	readonly low: VcDasVmPriority;
-	readonly name: string;
-	readonly disabled: VcDasVmPriority;
-	readonly medium: VcDasVmPriority;
+declare class VcDasVmPriority implements IPseudoEnum {
+	static readonly high: VcDasVmPriority & EnumVal<'high'>;
+	static readonly low: VcDasVmPriority & EnumVal<'low'>;
+	static readonly disabled: VcDasVmPriority & EnumVal<'disabled'>;
+	static readonly medium: VcDasVmPriority & EnumVal<'medium'>;
+	static fromString(value: string): VcDasVmPriority & EnumVal<TcleanKeys<typeof VcDasVmPriority>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDasVmPriority): VcDasVmPriority;
+	toString: () => string;
 }
 
 /**
  * The VSS Snapshot Context
  * VSS_SNAPSHOT_CONTEXT values not listed below are not implemented.
  */
-declare class VcVirtualMachineWindowsQuiesceSpecVssBackupContext {
-	readonly ctx_auto: VcVirtualMachineWindowsQuiesceSpecVssBackupContext;
-	readonly ctx_file_share_backup: VcVirtualMachineWindowsQuiesceSpecVssBackupContext;
-	readonly name: string;
+declare class VcVirtualMachineWindowsQuiesceSpecVssBackupContext implements IPseudoEnum {
+	static readonly ctx_auto: VcVirtualMachineWindowsQuiesceSpecVssBackupContext & EnumVal<'ctx_auto'>;
+	static readonly ctx_file_share_backup: VcVirtualMachineWindowsQuiesceSpecVssBackupContext & EnumVal<'ctx_file_share_backup'>;
+	static readonly ctx_backup: VcVirtualMachineWindowsQuiesceSpecVssBackupContext & EnumVal<'ctx_backup'>;
+	static fromString(value: string): VcVirtualMachineWindowsQuiesceSpecVssBackupContext & EnumVal<TcleanKeys<typeof VcVirtualMachineWindowsQuiesceSpecVssBackupContext>>;
+
 	readonly id: string;
-	readonly ctx_backup: VcVirtualMachineWindowsQuiesceSpecVssBackupContext;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineWindowsQuiesceSpecVssBackupContext): VcVirtualMachineWindowsQuiesceSpecVssBackupContext;
+	toString: () => string;
 }
 
 /**
  * This enum represents the set of legal operations
  */
-declare class VcVirtualMachineMetadataManagerVmMetadataOp {
-	readonly name: string;
-	readonly Remove: VcVirtualMachineMetadataManagerVmMetadataOp;
+declare class VcVirtualMachineMetadataManagerVmMetadataOp implements IPseudoEnum {
+	static readonly Remove: VcVirtualMachineMetadataManagerVmMetadataOp & EnumVal<'Remove'>;
+	static readonly Update: VcVirtualMachineMetadataManagerVmMetadataOp & EnumVal<'Update'>;
+	static fromString(value: string): VcVirtualMachineMetadataManagerVmMetadataOp & EnumVal<TcleanKeys<typeof VcVirtualMachineMetadataManagerVmMetadataOp>>;
+
 	readonly id: string;
-	readonly Update: VcVirtualMachineMetadataManagerVmMetadataOp;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineMetadataManagerVmMetadataOp): VcVirtualMachineMetadataManagerVmMetadataOp;
+	toString: () => string;
 }
 
 /**
@@ -1217,16 +1163,15 @@ declare class VcVirtualMachineMetadataManagerVmMetadataOp {
  * {@link vim.host.FeatureVersionInfo#key}, which
  * is a unique key that identifies a feature.
  */
-declare class VcHostFeatureVersionKey {
-	readonly faultTolerance: VcHostFeatureVersionKey;
-	readonly name: string;
+declare class VcHostFeatureVersionKey implements IPseudoEnum {
+	static readonly faultTolerance: VcHostFeatureVersionKey & EnumVal<'faultTolerance'>;
+	static fromString(value: string): VcHostFeatureVersionKey & EnumVal<TcleanKeys<typeof VcHostFeatureVersionKey>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostFeatureVersionKey): VcHostFeatureVersionKey;
+	toString: () => string;
 }
 
 /**
@@ -1235,155 +1180,146 @@ declare class VcHostFeatureVersionKey {
  * no longer be operational. VM Component Protection may be configured to reset the
  * VM ({@link vim.VirtualMachine#reset}) to restore the service of guest applications.
  */
-declare class VcClusterVmComponentProtectionSettingsVmReactionOnAPDCleared {
-	readonly name: string;
-	readonly reset: VcClusterVmComponentProtectionSettingsVmReactionOnAPDCleared;
-	readonly none: VcClusterVmComponentProtectionSettingsVmReactionOnAPDCleared;
+declare class VcClusterVmComponentProtectionSettingsVmReactionOnAPDCleared implements IPseudoEnum {
+	static readonly reset: VcClusterVmComponentProtectionSettingsVmReactionOnAPDCleared & EnumVal<'reset'>;
+	static readonly none: VcClusterVmComponentProtectionSettingsVmReactionOnAPDCleared & EnumVal<'none'>;
+	static readonly useClusterDefault: VcClusterVmComponentProtectionSettingsVmReactionOnAPDCleared & EnumVal<'useClusterDefault'>;
+	static fromString(value: string): VcClusterVmComponentProtectionSettingsVmReactionOnAPDCleared & EnumVal<TcleanKeys<typeof VcClusterVmComponentProtectionSettingsVmReactionOnAPDCleared>>;
+
 	readonly id: string;
-	readonly useClusterDefault: VcClusterVmComponentProtectionSettingsVmReactionOnAPDCleared;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcClusterVmComponentProtectionSettingsVmReactionOnAPDCleared): VcClusterVmComponentProtectionSettingsVmReactionOnAPDCleared;
+	toString: () => string;
 }
 
-declare class VcVmFaultToleranceInvalidFileBackingDeviceType {
-	readonly virtualParallelPort: VcVmFaultToleranceInvalidFileBackingDeviceType;
-	readonly virtualCdrom: VcVmFaultToleranceInvalidFileBackingDeviceType;
-	readonly virtualSerialPort: VcVmFaultToleranceInvalidFileBackingDeviceType;
-	readonly virtualDisk: VcVmFaultToleranceInvalidFileBackingDeviceType;
-	readonly virtualFloppy: VcVmFaultToleranceInvalidFileBackingDeviceType;
-	readonly name: string;
+declare class VcVmFaultToleranceInvalidFileBackingDeviceType implements IPseudoEnum {
+	static readonly virtualParallelPort: VcVmFaultToleranceInvalidFileBackingDeviceType & EnumVal<'virtualParallelPort'>;
+	static readonly virtualCdrom: VcVmFaultToleranceInvalidFileBackingDeviceType & EnumVal<'virtualCdrom'>;
+	static readonly virtualSerialPort: VcVmFaultToleranceInvalidFileBackingDeviceType & EnumVal<'virtualSerialPort'>;
+	static readonly virtualDisk: VcVmFaultToleranceInvalidFileBackingDeviceType & EnumVal<'virtualDisk'>;
+	static readonly virtualFloppy: VcVmFaultToleranceInvalidFileBackingDeviceType & EnumVal<'virtualFloppy'>;
+	static fromString(value: string): VcVmFaultToleranceInvalidFileBackingDeviceType & EnumVal<TcleanKeys<typeof VcVmFaultToleranceInvalidFileBackingDeviceType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVmFaultToleranceInvalidFileBackingDeviceType): VcVmFaultToleranceInvalidFileBackingDeviceType;
+	toString: () => string;
 }
 
 /**
  * Profiles supported by VASA Provider.
  */
-declare class VasaProviderProfile {
-	readonly blockDevice: VasaProviderProfile;
-	readonly fileSystem: VasaProviderProfile;
-	readonly capability: VasaProviderProfile;
-	readonly name: string;
+declare class VasaProviderProfile implements IPseudoEnum {
+	static readonly blockDevice: VasaProviderProfile & EnumVal<'blockDevice'>;
+	static readonly fileSystem: VasaProviderProfile & EnumVal<'fileSystem'>;
+	static readonly capability: VasaProviderProfile & EnumVal<'capability'>;
+	static fromString(value: string): VasaProviderProfile & EnumVal<TcleanKeys<typeof VasaProviderProfile>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VasaProviderProfile): VasaProviderProfile;
+	toString: () => string;
 }
 
 /**
  * List of partition format types. This denotes the partition table layout.
  */
-declare class VcHostDiskPartitionInfoPartitionFormat {
-	readonly name: string;
-	readonly gpt: VcHostDiskPartitionInfoPartitionFormat;
+declare class VcHostDiskPartitionInfoPartitionFormat implements IPseudoEnum {
+	static readonly gpt: VcHostDiskPartitionInfoPartitionFormat & EnumVal<'gpt'>;
+	static readonly mbr: VcHostDiskPartitionInfoPartitionFormat & EnumVal<'mbr'>;
+	static readonly unknown: VcHostDiskPartitionInfoPartitionFormat & EnumVal<'unknown'>;
+	static fromString(value: string): VcHostDiskPartitionInfoPartitionFormat & EnumVal<TcleanKeys<typeof VcHostDiskPartitionInfoPartitionFormat>>;
+
 	readonly id: string;
-	readonly mbr: VcHostDiskPartitionInfoPartitionFormat;
+	readonly name: string;
 	readonly value: string;
-	readonly unknown: VcHostDiskPartitionInfoPartitionFormat;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostDiskPartitionInfoPartitionFormat): VcHostDiskPartitionInfoPartitionFormat;
+	toString: () => string;
 }
 
 /**
  * Defines the access mode of the datastore.
  */
-declare class VcHostMountMode {
-	readonly name: string;
-	readonly readWrite: VcHostMountMode;
-	readonly readOnly: VcHostMountMode;
+declare class VcHostMountMode implements IPseudoEnum {
+	static readonly readWrite: VcHostMountMode & EnumVal<'readWrite'>;
+	static readonly readOnly: VcHostMountMode & EnumVal<'readOnly'>;
+	static fromString(value: string): VcHostMountMode & EnumVal<TcleanKeys<typeof VcHostMountMode>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostMountMode): VcHostMountMode;
+	toString: () => string;
 }
 
 /**
  * The binding mode of the adapter.
  */
-declare class VcHostInternetScsiHbaNetworkBindingSupportType {
-	readonly name: string;
-	readonly optional: VcHostInternetScsiHbaNetworkBindingSupportType;
+declare class VcHostInternetScsiHbaNetworkBindingSupportType implements IPseudoEnum {
+	static readonly optional: VcHostInternetScsiHbaNetworkBindingSupportType & EnumVal<'optional'>;
+	static readonly notsupported: VcHostInternetScsiHbaNetworkBindingSupportType & EnumVal<'notsupported'>;
+	static readonly required: VcHostInternetScsiHbaNetworkBindingSupportType & EnumVal<'required'>;
+	static fromString(value: string): VcHostInternetScsiHbaNetworkBindingSupportType & EnumVal<TcleanKeys<typeof VcHostInternetScsiHbaNetworkBindingSupportType>>;
+
 	readonly id: string;
-	readonly notsupported: VcHostInternetScsiHbaNetworkBindingSupportType;
+	readonly name: string;
 	readonly value: string;
-	readonly required: VcHostInternetScsiHbaNetworkBindingSupportType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostInternetScsiHbaNetworkBindingSupportType): VcHostInternetScsiHbaNetworkBindingSupportType;
+	toString: () => string;
 }
 
-declare class VcHostDasErrorEventHostDasErrorReason {
-	readonly agentFailed: VcHostDasErrorEventHostDasErrorReason;
-	readonly other: VcHostDasErrorEventHostDasErrorReason;
-	readonly configFailed: VcHostDasErrorEventHostDasErrorReason;
-	readonly communicationInitFailed: VcHostDasErrorEventHostDasErrorReason;
-	readonly agentShutdown: VcHostDasErrorEventHostDasErrorReason;
-	readonly name: string;
-	readonly healthCheckScriptFailed: VcHostDasErrorEventHostDasErrorReason;
+declare class VcHostDasErrorEventHostDasErrorReason implements IPseudoEnum {
+	static readonly agentFailed: VcHostDasErrorEventHostDasErrorReason & EnumVal<'agentFailed'>;
+	static readonly other: VcHostDasErrorEventHostDasErrorReason & EnumVal<'other'>;
+	static readonly configFailed: VcHostDasErrorEventHostDasErrorReason & EnumVal<'configFailed'>;
+	static readonly communicationInitFailed: VcHostDasErrorEventHostDasErrorReason & EnumVal<'communicationInitFailed'>;
+	static readonly agentShutdown: VcHostDasErrorEventHostDasErrorReason & EnumVal<'agentShutdown'>;
+	static readonly healthCheckScriptFailed: VcHostDasErrorEventHostDasErrorReason & EnumVal<'healthCheckScriptFailed'>;
+	static readonly timeout: VcHostDasErrorEventHostDasErrorReason & EnumVal<'timeout'>;
+	static readonly isolationAddressUnpingable: VcHostDasErrorEventHostDasErrorReason & EnumVal<'isolationAddressUnpingable'>;
+	static fromString(value: string): VcHostDasErrorEventHostDasErrorReason & EnumVal<TcleanKeys<typeof VcHostDasErrorEventHostDasErrorReason>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly timeout: VcHostDasErrorEventHostDasErrorReason;
-	readonly isolationAddressUnpingable: VcHostDasErrorEventHostDasErrorReason;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostDasErrorEventHostDasErrorReason): VcHostDasErrorEventHostDasErrorReason;
+	toString: () => string;
 }
 
 /**
  * The set of tranformations that can be performed on the virtual disks
  * as part of the copy.
  */
-declare class VcVirtualMachineRelocateTransformation {
-	readonly sparse: VcVirtualMachineRelocateTransformation;
-	readonly flat: VcVirtualMachineRelocateTransformation;
-	readonly name: string;
+declare class VcVirtualMachineRelocateTransformation implements IPseudoEnum {
+	static readonly sparse: VcVirtualMachineRelocateTransformation & EnumVal<'sparse'>;
+	static readonly flat: VcVirtualMachineRelocateTransformation & EnumVal<'flat'>;
+	static fromString(value: string): VcVirtualMachineRelocateTransformation & EnumVal<TcleanKeys<typeof VcVirtualMachineRelocateTransformation>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineRelocateTransformation): VcVirtualMachineRelocateTransformation;
+	toString: () => string;
 }
 
 /**
  * State of licensing subsystem.
  */
-declare class VcLicenseManagerState {
-	readonly normal: VcLicenseManagerState;
-	readonly marginal: VcLicenseManagerState;
-	readonly name: string;
-	readonly fault: VcLicenseManagerState;
-	readonly initializing: VcLicenseManagerState;
+declare class VcLicenseManagerState implements IPseudoEnum {
+	static readonly normal: VcLicenseManagerState & EnumVal<'normal'>;
+	static readonly marginal: VcLicenseManagerState & EnumVal<'marginal'>;
+	static readonly fault: VcLicenseManagerState & EnumVal<'fault'>;
+	static readonly initializing: VcLicenseManagerState & EnumVal<'initializing'>;
+	static fromString(value: string): VcLicenseManagerState & EnumVal<TcleanKeys<typeof VcLicenseManagerState>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcLicenseManagerState): VcLicenseManagerState;
+	toString: () => string;
 }
 
 /**
@@ -1392,139 +1328,131 @@ declare class VcLicenseManagerState {
  * Consumption type describes how the virtual storage object is connected and
  * consumed for data by the clients.
  */
-declare class VcVStorageObjectConsumptionType {
-	readonly disk: VcVStorageObjectConsumptionType;
-	readonly name: string;
+declare class VcVStorageObjectConsumptionType implements IPseudoEnum {
+	static readonly disk: VcVStorageObjectConsumptionType & EnumVal<'disk'>;
+	static fromString(value: string): VcVStorageObjectConsumptionType & EnumVal<TcleanKeys<typeof VcVStorageObjectConsumptionType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVStorageObjectConsumptionType): VcVStorageObjectConsumptionType;
+	toString: () => string;
 }
 
 /**
  * Constants for defined formats. For more information, see the comment for the
  * format property.
  */
-declare class VcDiagnosticManagerLogFormat {
-	readonly plain: VcDiagnosticManagerLogFormat;
-	readonly name: string;
+declare class VcDiagnosticManagerLogFormat implements IPseudoEnum {
+	static readonly plain: VcDiagnosticManagerLogFormat & EnumVal<'plain'>;
+	static fromString(value: string): VcDiagnosticManagerLogFormat & EnumVal<TcleanKeys<typeof VcDiagnosticManagerLogFormat>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDiagnosticManagerLogFormat): VcDiagnosticManagerLogFormat;
+	toString: () => string;
 }
 
 /**
  * Set of possible values for direction field in FilterSpec.
  */
-declare class VcVirtualMachineVMCIDeviceDirection {
-	readonly host: VcVirtualMachineVMCIDeviceDirection;
-	readonly name: string;
-	readonly guest: VcVirtualMachineVMCIDeviceDirection;
+declare class VcVirtualMachineVMCIDeviceDirection implements IPseudoEnum {
+	static readonly host: VcVirtualMachineVMCIDeviceDirection & EnumVal<'host'>;
+	static readonly guest: VcVirtualMachineVMCIDeviceDirection & EnumVal<'guest'>;
+	static readonly anyDirection: VcVirtualMachineVMCIDeviceDirection & EnumVal<'anyDirection'>;
+	static fromString(value: string): VcVirtualMachineVMCIDeviceDirection & EnumVal<TcleanKeys<typeof VcVirtualMachineVMCIDeviceDirection>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly anyDirection: VcVirtualMachineVMCIDeviceDirection;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineVMCIDeviceDirection): VcVirtualMachineVMCIDeviceDirection;
+	toString: () => string;
 }
 
-declare class VcImageLibraryManagerMediaType {
-	readonly Cust: VcImageLibraryManagerMediaType;
-	readonly Iso: VcImageLibraryManagerMediaType;
-	readonly Vmdk: VcImageLibraryManagerMediaType;
-	readonly Generic: VcImageLibraryManagerMediaType;
-	readonly name: string;
-	readonly Flp: VcImageLibraryManagerMediaType;
+declare class VcImageLibraryManagerMediaType implements IPseudoEnum {
+	static readonly Cust: VcImageLibraryManagerMediaType & EnumVal<'Cust'>;
+	static readonly Iso: VcImageLibraryManagerMediaType & EnumVal<'Iso'>;
+	static readonly Vmdk: VcImageLibraryManagerMediaType & EnumVal<'Vmdk'>;
+	static readonly Generic: VcImageLibraryManagerMediaType & EnumVal<'Generic'>;
+	static readonly Flp: VcImageLibraryManagerMediaType & EnumVal<'Flp'>;
+	static readonly Ovf: VcImageLibraryManagerMediaType & EnumVal<'Ovf'>;
+	static fromString(value: string): VcImageLibraryManagerMediaType & EnumVal<TcleanKeys<typeof VcImageLibraryManagerMediaType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly Ovf: VcImageLibraryManagerMediaType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcImageLibraryManagerMediaType): VcImageLibraryManagerMediaType;
+	toString: () => string;
 }
 
 /**
  * The {@link vim.profile.host.ProfileManager.AnswerFileStatus} enum
  * defines possible values for answer file status.
  */
-declare class VcHostProfileManagerAnswerFileStatus {
-	readonly valid: VcHostProfileManagerAnswerFileStatus;
-	readonly invalid: VcHostProfileManagerAnswerFileStatus;
-	readonly name: string;
+declare class VcHostProfileManagerAnswerFileStatus implements IPseudoEnum {
+	static readonly valid: VcHostProfileManagerAnswerFileStatus & EnumVal<'valid'>;
+	static readonly invalid: VcHostProfileManagerAnswerFileStatus & EnumVal<'invalid'>;
+	static readonly unknown: VcHostProfileManagerAnswerFileStatus & EnumVal<'unknown'>;
+	static fromString(value: string): VcHostProfileManagerAnswerFileStatus & EnumVal<TcleanKeys<typeof VcHostProfileManagerAnswerFileStatus>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly unknown: VcHostProfileManagerAnswerFileStatus;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostProfileManagerAnswerFileStatus): VcHostProfileManagerAnswerFileStatus;
+	toString: () => string;
 }
 
 /**
  * Set of possible values for action field in FilterSpec.
  * Determines whether traffic is allowed or denied.
  */
-declare class VcVirtualMachineVMCIDeviceAction {
-	readonly allow: VcVirtualMachineVMCIDeviceAction;
-	readonly deny: VcVirtualMachineVMCIDeviceAction;
-	readonly name: string;
+declare class VcVirtualMachineVMCIDeviceAction implements IPseudoEnum {
+	static readonly allow: VcVirtualMachineVMCIDeviceAction & EnumVal<'allow'>;
+	static readonly deny: VcVirtualMachineVMCIDeviceAction & EnumVal<'deny'>;
+	static fromString(value: string): VcVirtualMachineVMCIDeviceAction & EnumVal<TcleanKeys<typeof VcVirtualMachineVMCIDeviceAction>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineVMCIDeviceAction): VcVirtualMachineVMCIDeviceAction;
+	toString: () => string;
 }
 
-declare class VcHostCpuPackageVendor {
-	readonly name: string;
-	readonly amd: VcHostCpuPackageVendor;
+declare class VcHostCpuPackageVendor implements IPseudoEnum {
+	static readonly amd: VcHostCpuPackageVendor & EnumVal<'amd'>;
+	static readonly intel: VcHostCpuPackageVendor & EnumVal<'intel'>;
+	static readonly arm: VcHostCpuPackageVendor & EnumVal<'arm'>;
+	static readonly unknown: VcHostCpuPackageVendor & EnumVal<'unknown'>;
+	static fromString(value: string): VcHostCpuPackageVendor & EnumVal<TcleanKeys<typeof VcHostCpuPackageVendor>>;
+
 	readonly id: string;
-	readonly intel: VcHostCpuPackageVendor;
-	readonly arm: VcHostCpuPackageVendor;
+	readonly name: string;
 	readonly value: string;
-	readonly unknown: VcHostCpuPackageVendor;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostCpuPackageVendor): VcHostCpuPackageVendor;
+	toString: () => string;
 }
 
 /**
  * Type of file system volume.
  */
-declare class VcHostFileSystemVolumeFileSystemType {
-	readonly PMEM: VcHostFileSystemVolumeFileSystemType;
-	readonly OTHER: VcHostFileSystemVolumeFileSystemType;
-	readonly NFS41: VcHostFileSystemVolumeFileSystemType;
-	readonly VFFS: VcHostFileSystemVolumeFileSystemType;
-	readonly VVOL: VcHostFileSystemVolumeFileSystemType;
-	readonly name: string;
-	readonly NFS: VcHostFileSystemVolumeFileSystemType;
+declare class VcHostFileSystemVolumeFileSystemType implements IPseudoEnum {
+	static readonly PMEM: VcHostFileSystemVolumeFileSystemType & EnumVal<'PMEM'>;
+	static readonly OTHER: VcHostFileSystemVolumeFileSystemType & EnumVal<'OTHER'>;
+	static readonly NFS41: VcHostFileSystemVolumeFileSystemType & EnumVal<'NFS41'>;
+	static readonly VFFS: VcHostFileSystemVolumeFileSystemType & EnumVal<'VFFS'>;
+	static readonly VVOL: VcHostFileSystemVolumeFileSystemType & EnumVal<'VVOL'>;
+	static readonly NFS: VcHostFileSystemVolumeFileSystemType & EnumVal<'NFS'>;
+	static readonly VMFS: VcHostFileSystemVolumeFileSystemType & EnumVal<'VMFS'>;
+	static readonly CIFS: VcHostFileSystemVolumeFileSystemType & EnumVal<'CIFS'>;
+	static readonly vsan: VcHostFileSystemVolumeFileSystemType & EnumVal<'vsan'>;
+	static fromString(value: string): VcHostFileSystemVolumeFileSystemType & EnumVal<TcleanKeys<typeof VcHostFileSystemVolumeFileSystemType>>;
+
 	readonly id: string;
-	readonly VMFS: VcHostFileSystemVolumeFileSystemType;
-	readonly CIFS: VcHostFileSystemVolumeFileSystemType;
-	readonly vsan: VcHostFileSystemVolumeFileSystemType;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostFileSystemVolumeFileSystemType): VcHostFileSystemVolumeFileSystemType;
+	toString: () => string;
 }
 
 /**
@@ -1533,49 +1461,46 @@ declare class VcHostFileSystemVolumeFileSystemType {
  * One of these values is assigned to the sharedBus object to determine
  * if or how the SCSI bus is shared.
  */
-declare class VcVirtualSCSISharing {
-	readonly noSharing: VcVirtualSCSISharing;
-	readonly name: string;
-	readonly physicalSharing: VcVirtualSCSISharing;
+declare class VcVirtualSCSISharing implements IPseudoEnum {
+	static readonly noSharing: VcVirtualSCSISharing & EnumVal<'noSharing'>;
+	static readonly physicalSharing: VcVirtualSCSISharing & EnumVal<'physicalSharing'>;
+	static readonly virtualSharing: VcVirtualSCSISharing & EnumVal<'virtualSharing'>;
+	static fromString(value: string): VcVirtualSCSISharing & EnumVal<TcleanKeys<typeof VcVirtualSCSISharing>>;
+
 	readonly id: string;
-	readonly virtualSharing: VcVirtualSCSISharing;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualSCSISharing): VcVirtualSCSISharing;
+	toString: () => string;
 }
 
-declare class VcObjectUpdateKind {
-	readonly modify: VcObjectUpdateKind;
-	readonly leave: VcObjectUpdateKind;
-	readonly name: string;
-	readonly enter: VcObjectUpdateKind;
+declare class VcObjectUpdateKind implements IPseudoEnum {
+	static readonly modify: VcObjectUpdateKind & EnumVal<'modify'>;
+	static readonly leave: VcObjectUpdateKind & EnumVal<'leave'>;
+	static readonly enter: VcObjectUpdateKind & EnumVal<'enter'>;
+	static fromString(value: string): VcObjectUpdateKind & EnumVal<TcleanKeys<typeof VcObjectUpdateKind>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcObjectUpdateKind): VcObjectUpdateKind;
+	toString: () => string;
 }
 
 /**
  * Set of possible values for {@link vim.vm.FlagInfo#htSharing}.
  */
-declare class VcVirtualMachineHtSharing {
-	readonly internal: VcVirtualMachineHtSharing;
-	readonly name: string;
-	readonly none: VcVirtualMachineHtSharing;
+declare class VcVirtualMachineHtSharing implements IPseudoEnum {
+	static readonly internal: VcVirtualMachineHtSharing & EnumVal<'internal'>;
+	static readonly none: VcVirtualMachineHtSharing & EnumVal<'none'>;
+	static readonly any: VcVirtualMachineHtSharing & EnumVal<'any'>;
+	static fromString(value: string): VcVirtualMachineHtSharing & EnumVal<TcleanKeys<typeof VcVirtualMachineHtSharing>>;
+
 	readonly id: string;
-	readonly any: VcVirtualMachineHtSharing;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineHtSharing): VcVirtualMachineHtSharing;
+	toString: () => string;
 }
 
 /**
@@ -1586,35 +1511,33 @@ declare class VcVirtualMachineHtSharing {
  * machine to power on or it waits until it receives a successful heartbeat from a
  * powered on virtual machine. By default, this is set to no.
  */
-declare class VcAutoStartWaitHeartbeatSetting {
-	readonly systemDefault: VcAutoStartWaitHeartbeatSetting;
-	readonly no: VcAutoStartWaitHeartbeatSetting;
-	readonly yes: VcAutoStartWaitHeartbeatSetting;
-	readonly name: string;
+declare class VcAutoStartWaitHeartbeatSetting implements IPseudoEnum {
+	static readonly systemDefault: VcAutoStartWaitHeartbeatSetting & EnumVal<'systemDefault'>;
+	static readonly no: VcAutoStartWaitHeartbeatSetting & EnumVal<'no'>;
+	static readonly yes: VcAutoStartWaitHeartbeatSetting & EnumVal<'yes'>;
+	static fromString(value: string): VcAutoStartWaitHeartbeatSetting & EnumVal<TcleanKeys<typeof VcAutoStartWaitHeartbeatSetting>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcAutoStartWaitHeartbeatSetting): VcAutoStartWaitHeartbeatSetting;
+	toString: () => string;
 }
 
 /**
  * Set of possible values for {@link vim.vm.device.VirtualVideoCard#use3dRenderer}.
  */
-declare class VcVirtualMachineVideoCardUse3dRenderer {
-	readonly software: VcVirtualMachineVideoCardUse3dRenderer;
-	readonly name: string;
-	readonly automatic: VcVirtualMachineVideoCardUse3dRenderer;
+declare class VcVirtualMachineVideoCardUse3dRenderer implements IPseudoEnum {
+	static readonly software: VcVirtualMachineVideoCardUse3dRenderer & EnumVal<'software'>;
+	static readonly automatic: VcVirtualMachineVideoCardUse3dRenderer & EnumVal<'automatic'>;
+	static readonly hardware: VcVirtualMachineVideoCardUse3dRenderer & EnumVal<'hardware'>;
+	static fromString(value: string): VcVirtualMachineVideoCardUse3dRenderer & EnumVal<TcleanKeys<typeof VcVirtualMachineVideoCardUse3dRenderer>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly hardware: VcVirtualMachineVideoCardUse3dRenderer;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineVideoCardUse3dRenderer): VcVirtualMachineVideoCardUse3dRenderer;
+	toString: () => string;
 }
 
 /**
@@ -1622,253 +1545,237 @@ declare class VcVirtualMachineVideoCardUse3dRenderer {
  * in the inventory hierarchy. If a managed entity has children, their events
  * can be retrieved with this filter option.
  */
-declare class VcEventFilterSpecRecursionOption {
-	readonly all: VcEventFilterSpecRecursionOption;
-	readonly children: VcEventFilterSpecRecursionOption;
-	readonly name: string;
-	readonly self: VcEventFilterSpecRecursionOption;
+declare class VcEventFilterSpecRecursionOption implements IPseudoEnum {
+	static readonly all: VcEventFilterSpecRecursionOption & EnumVal<'all'>;
+	static readonly children: VcEventFilterSpecRecursionOption & EnumVal<'children'>;
+	static readonly self: VcEventFilterSpecRecursionOption & EnumVal<'self'>;
+	static fromString(value: string): VcEventFilterSpecRecursionOption & EnumVal<TcleanKeys<typeof VcEventFilterSpecRecursionOption>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcEventFilterSpecRecursionOption): VcEventFilterSpecRecursionOption;
+	toString: () => string;
 }
 
 /**
  * Enumeration of port types.
  */
-declare class VcHostFirewallRulePortType {
-	readonly dst: VcHostFirewallRulePortType;
-	readonly src: VcHostFirewallRulePortType;
-	readonly name: string;
+declare class VcHostFirewallRulePortType implements IPseudoEnum {
+	static readonly dst: VcHostFirewallRulePortType & EnumVal<'dst'>;
+	static readonly src: VcHostFirewallRulePortType & EnumVal<'src'>;
+	static fromString(value: string): VcHostFirewallRulePortType & EnumVal<TcleanKeys<typeof VcHostFirewallRulePortType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostFirewallRulePortType): VcHostFirewallRulePortType;
+	toString: () => string;
 }
 
 /**
  * Set of possible values for {@link #vmDirectPathGen2UnsupportedReason}.
  */
-declare class VcHostCapabilityVmDirectPathGen2UnsupportedReason {
-	readonly hostNptIncompatibleProduct: VcHostCapabilityVmDirectPathGen2UnsupportedReason;
-	readonly name: string;
+declare class VcHostCapabilityVmDirectPathGen2UnsupportedReason implements IPseudoEnum {
+	static readonly hostNptIncompatibleProduct: VcHostCapabilityVmDirectPathGen2UnsupportedReason & EnumVal<'hostNptIncompatibleProduct'>;
+	static readonly hostNptDisabled: VcHostCapabilityVmDirectPathGen2UnsupportedReason & EnumVal<'hostNptDisabled'>;
+	static readonly hostNptIncompatibleHardware: VcHostCapabilityVmDirectPathGen2UnsupportedReason & EnumVal<'hostNptIncompatibleHardware'>;
+	static fromString(value: string): VcHostCapabilityVmDirectPathGen2UnsupportedReason & EnumVal<TcleanKeys<typeof VcHostCapabilityVmDirectPathGen2UnsupportedReason>>;
+
 	readonly id: string;
-	readonly hostNptDisabled: VcHostCapabilityVmDirectPathGen2UnsupportedReason;
+	readonly name: string;
 	readonly value: string;
-	readonly hostNptIncompatibleHardware: VcHostCapabilityVmDirectPathGen2UnsupportedReason;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostCapabilityVmDirectPathGen2UnsupportedReason): VcHostCapabilityVmDirectPathGen2UnsupportedReason;
+	toString: () => string;
 }
 
-declare class VcHostOperationCleanupManagerCleanupItemType {
-	readonly disk: VcHostOperationCleanupManagerCleanupItemType;
-	readonly file: VcHostOperationCleanupManagerCleanupItemType;
-	readonly vm: VcHostOperationCleanupManagerCleanupItemType;
-	readonly name: string;
+declare class VcHostOperationCleanupManagerCleanupItemType implements IPseudoEnum {
+	static readonly disk: VcHostOperationCleanupManagerCleanupItemType & EnumVal<'disk'>;
+	static readonly file: VcHostOperationCleanupManagerCleanupItemType & EnumVal<'file'>;
+	static readonly vm: VcHostOperationCleanupManagerCleanupItemType & EnumVal<'vm'>;
+	static readonly dir: VcHostOperationCleanupManagerCleanupItemType & EnumVal<'dir'>;
+	static fromString(value: string): VcHostOperationCleanupManagerCleanupItemType & EnumVal<TcleanKeys<typeof VcHostOperationCleanupManagerCleanupItemType>>;
+
 	readonly id: string;
-	readonly dir: VcHostOperationCleanupManagerCleanupItemType;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostOperationCleanupManagerCleanupItemType): VcHostOperationCleanupManagerCleanupItemType;
+	toString: () => string;
 }
 
-declare class VcIncompatibleHostForVmReplicationIncompatibleReason {
-	readonly rpo: VcIncompatibleHostForVmReplicationIncompatibleReason;
-	readonly netCompression: VcIncompatibleHostForVmReplicationIncompatibleReason;
-	readonly name: string;
+declare class VcIncompatibleHostForVmReplicationIncompatibleReason implements IPseudoEnum {
+	static readonly rpo: VcIncompatibleHostForVmReplicationIncompatibleReason & EnumVal<'rpo'>;
+	static readonly netCompression: VcIncompatibleHostForVmReplicationIncompatibleReason & EnumVal<'netCompression'>;
+	static fromString(value: string): VcIncompatibleHostForVmReplicationIncompatibleReason & EnumVal<TcleanKeys<typeof VcIncompatibleHostForVmReplicationIncompatibleReason>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcIncompatibleHostForVmReplicationIncompatibleReason): VcIncompatibleHostForVmReplicationIncompatibleReason;
+	toString: () => string;
 }
 
-declare class VcNotSupportedDeviceForFTDeviceType {
-	readonly virtualVmxnet3: VcNotSupportedDeviceForFTDeviceType;
-	readonly name: string;
+declare class VcNotSupportedDeviceForFTDeviceType implements IPseudoEnum {
+	static readonly virtualVmxnet3: VcNotSupportedDeviceForFTDeviceType & EnumVal<'virtualVmxnet3'>;
+	static readonly paraVirtualSCSIController: VcNotSupportedDeviceForFTDeviceType & EnumVal<'paraVirtualSCSIController'>;
+	static fromString(value: string): VcNotSupportedDeviceForFTDeviceType & EnumVal<TcleanKeys<typeof VcNotSupportedDeviceForFTDeviceType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly paraVirtualSCSIController: VcNotSupportedDeviceForFTDeviceType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcNotSupportedDeviceForFTDeviceType): VcNotSupportedDeviceForFTDeviceType;
+	toString: () => string;
 }
 
 /**
  * Set of possible values for {@link #vmDirectPathGen2SupportedMode}.
  */
-declare class VcPhysicalNicVmDirectPathGen2SupportedMode {
-	readonly upt: VcPhysicalNicVmDirectPathGen2SupportedMode;
-	readonly name: string;
+declare class VcPhysicalNicVmDirectPathGen2SupportedMode implements IPseudoEnum {
+	static readonly upt: VcPhysicalNicVmDirectPathGen2SupportedMode & EnumVal<'upt'>;
+	static fromString(value: string): VcPhysicalNicVmDirectPathGen2SupportedMode & EnumVal<TcleanKeys<typeof VcPhysicalNicVmDirectPathGen2SupportedMode>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcPhysicalNicVmDirectPathGen2SupportedMode): VcPhysicalNicVmDirectPathGen2SupportedMode;
+	toString: () => string;
 }
 
 /**
  * VchaNodeState enum defines possible state a node can be in a
  * VCHA Cluster.
  */
-declare class VcVchaNodeState {
-	readonly name: string;
-	readonly up: VcVchaNodeState;
+declare class VcVchaNodeState implements IPseudoEnum {
+	static readonly up: VcVchaNodeState & EnumVal<'up'>;
+	static readonly down: VcVchaNodeState & EnumVal<'down'>;
+	static fromString(value: string): VcVchaNodeState & EnumVal<TcleanKeys<typeof VcVchaNodeState>>;
+
 	readonly id: string;
-	readonly down: VcVchaNodeState;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVchaNodeState): VcVchaNodeState;
+	toString: () => string;
 }
 
 /**
  * List of possible states of a lease.
  */
-declare class VcHttpNfcLeaseState {
-	readonly ready: VcHttpNfcLeaseState;
-	readonly name: string;
-	readonly initializing: VcHttpNfcLeaseState;
+declare class VcHttpNfcLeaseState implements IPseudoEnum {
+	static readonly ready: VcHttpNfcLeaseState & EnumVal<'ready'>;
+	static readonly initializing: VcHttpNfcLeaseState & EnumVal<'initializing'>;
+	static readonly error: VcHttpNfcLeaseState & EnumVal<'error'>;
+	static readonly done: VcHttpNfcLeaseState & EnumVal<'done'>;
+	static fromString(value: string): VcHttpNfcLeaseState & EnumVal<TcleanKeys<typeof VcHttpNfcLeaseState>>;
+
 	readonly id: string;
-	readonly error: VcHttpNfcLeaseState;
-	readonly done: VcHttpNfcLeaseState;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHttpNfcLeaseState): VcHttpNfcLeaseState;
+	toString: () => string;
 }
 
 /**
  * VASA Provider type.
  */
-declare class VpType {
-	readonly PERSISTENCE: VpType;
-	readonly name: string;
-	readonly UNKNOWN: VpType;
+declare class VpType implements IPseudoEnum {
+	static readonly PERSISTENCE: VpType & EnumVal<'PERSISTENCE'>;
+	static readonly UNKNOWN: VpType & EnumVal<'UNKNOWN'>;
+	static readonly DATASERVICE: VpType & EnumVal<'DATASERVICE'>;
+	static fromString(value: string): VpType & EnumVal<TcleanKeys<typeof VpType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly DATASERVICE: VpType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VpType): VpType;
+	toString: () => string;
 }
 
 /**
  * VASA provider authentication type.
  */
-declare class VasaAuthenticationType {
-	readonly UseSessionId: VasaAuthenticationType;
-	readonly LoginByToken: VasaAuthenticationType;
-	readonly name: string;
+declare class VasaAuthenticationType implements IPseudoEnum {
+	static readonly UseSessionId: VasaAuthenticationType & EnumVal<'UseSessionId'>;
+	static readonly LoginByToken: VasaAuthenticationType & EnumVal<'LoginByToken'>;
+	static fromString(value: string): VasaAuthenticationType & EnumVal<TcleanKeys<typeof VasaAuthenticationType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VasaAuthenticationType): VasaAuthenticationType;
+	toString: () => string;
 }
 
 /**
  * Possible values for graphics type.
  */
-declare class VcHostGraphicsConfigGraphicsType {
-	readonly shared: VcHostGraphicsConfigGraphicsType;
-	readonly sharedDirect: VcHostGraphicsConfigGraphicsType;
-	readonly name: string;
+declare class VcHostGraphicsConfigGraphicsType implements IPseudoEnum {
+	static readonly shared: VcHostGraphicsConfigGraphicsType & EnumVal<'shared'>;
+	static readonly sharedDirect: VcHostGraphicsConfigGraphicsType & EnumVal<'sharedDirect'>;
+	static fromString(value: string): VcHostGraphicsConfigGraphicsType & EnumVal<TcleanKeys<typeof VcHostGraphicsConfigGraphicsType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostGraphicsConfigGraphicsType): VcHostGraphicsConfigGraphicsType;
+	toString: () => string;
 }
 
 /**
  * This enum contains a list of valid owner values for
  * the name field
  */
-declare class VcVirtualMachineMetadataManagerVmMetadataOwnerOwner {
-	readonly name: string;
+declare class VcVirtualMachineMetadataManagerVmMetadataOwnerOwner implements IPseudoEnum {
+	static readonly ComVmwareVsphereHA: VcVirtualMachineMetadataManagerVmMetadataOwnerOwner & EnumVal<'ComVmwareVsphereHA'>;
+	static fromString(value: string): VcVirtualMachineMetadataManagerVmMetadataOwnerOwner & EnumVal<TcleanKeys<typeof VcVirtualMachineMetadataManagerVmMetadataOwnerOwner>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly ComVmwareVsphereHA: VcVirtualMachineMetadataManagerVmMetadataOwnerOwner;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineMetadataManagerVmMetadataOwnerOwner): VcVirtualMachineMetadataManagerVmMetadataOwnerOwner;
+	toString: () => string;
 }
 
-declare class VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOther {
-	readonly vmNptIncompatibleNetwork: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOther;
-	readonly name: string;
-	readonly vmNptIncompatibleHost: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOther;
+declare class VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOther implements IPseudoEnum {
+	static readonly vmNptIncompatibleNetwork: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOther & EnumVal<'vmNptIncompatibleNetwork'>;
+	static readonly vmNptIncompatibleHost: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOther & EnumVal<'vmNptIncompatibleHost'>;
+	static fromString(value: string): VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOther & EnumVal<TcleanKeys<typeof VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOther>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOther): VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOther;
+	toString: () => string;
 }
 
 /**
  * Redirect types
  */
-declare class VcProxyServiceRedirectSpecRedirectType {
-	readonly found: VcProxyServiceRedirectSpecRedirectType;
-	readonly permanent: VcProxyServiceRedirectSpecRedirectType;
-	readonly name: string;
+declare class VcProxyServiceRedirectSpecRedirectType implements IPseudoEnum {
+	static readonly found: VcProxyServiceRedirectSpecRedirectType & EnumVal<'found'>;
+	static readonly permanent: VcProxyServiceRedirectSpecRedirectType & EnumVal<'permanent'>;
+	static fromString(value: string): VcProxyServiceRedirectSpecRedirectType & EnumVal<TcleanKeys<typeof VcProxyServiceRedirectSpecRedirectType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcProxyServiceRedirectSpecRedirectType): VcProxyServiceRedirectSpecRedirectType;
+	toString: () => string;
 }
 
 /**
  * HostSelectionType defines how the host was selected
  */
-declare class VcFtIssuesOnHostHostSelectionType {
-	readonly drs: VcFtIssuesOnHostHostSelectionType;
-	readonly name: string;
+declare class VcFtIssuesOnHostHostSelectionType implements IPseudoEnum {
+	static readonly drs: VcFtIssuesOnHostHostSelectionType & EnumVal<'drs'>;
+	static readonly user: VcFtIssuesOnHostHostSelectionType & EnumVal<'user'>;
+	static readonly vc: VcFtIssuesOnHostHostSelectionType & EnumVal<'vc'>;
+	static fromString(value: string): VcFtIssuesOnHostHostSelectionType & EnumVal<TcleanKeys<typeof VcFtIssuesOnHostHostSelectionType>>;
+
 	readonly id: string;
-	readonly user: VcFtIssuesOnHostHostSelectionType;
-	readonly vc: VcFtIssuesOnHostHostSelectionType;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcFtIssuesOnHostHostSelectionType): VcFtIssuesOnHostHostSelectionType;
+	toString: () => string;
 }
 
 /**
@@ -1877,349 +1784,329 @@ declare class VcFtIssuesOnHostHostSelectionType {
  * ({@link vim.cluster.DasAamNodeState#configState} and
  * {@link vim.cluster.DasAamNodeState#runtimeState}).
  */
-declare class VcClusterDasAamNodeStateDasState {
-	readonly running: VcClusterDasAamNodeStateDasState;
-	readonly configuring: VcClusterDasAamNodeStateDasState;
-	readonly agentShutdown: VcClusterDasAamNodeStateDasState;
-	readonly name: string;
-	readonly initialized: VcClusterDasAamNodeStateDasState;
+declare class VcClusterDasAamNodeStateDasState implements IPseudoEnum {
+	static readonly running: VcClusterDasAamNodeStateDasState & EnumVal<'running'>;
+	static readonly configuring: VcClusterDasAamNodeStateDasState & EnumVal<'configuring'>;
+	static readonly agentShutdown: VcClusterDasAamNodeStateDasState & EnumVal<'agentShutdown'>;
+	static readonly initialized: VcClusterDasAamNodeStateDasState & EnumVal<'initialized'>;
+	static readonly error: VcClusterDasAamNodeStateDasState & EnumVal<'error'>;
+	static readonly unconfiguring: VcClusterDasAamNodeStateDasState & EnumVal<'unconfiguring'>;
+	static readonly nodeFailed: VcClusterDasAamNodeStateDasState & EnumVal<'nodeFailed'>;
+	static readonly uninitialized: VcClusterDasAamNodeStateDasState & EnumVal<'uninitialized'>;
+	static fromString(value: string): VcClusterDasAamNodeStateDasState & EnumVal<TcleanKeys<typeof VcClusterDasAamNodeStateDasState>>;
+
 	readonly id: string;
-	readonly error: VcClusterDasAamNodeStateDasState;
-	readonly unconfiguring: VcClusterDasAamNodeStateDasState;
+	readonly name: string;
 	readonly value: string;
-	readonly nodeFailed: VcClusterDasAamNodeStateDasState;
-	readonly uninitialized: VcClusterDasAamNodeStateDasState;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcClusterDasAamNodeStateDasState): VcClusterDasAamNodeStateDasState;
+	toString: () => string;
 }
 
-declare class VcHostOperationCleanupManagerOperationState {
-	readonly running: VcHostOperationCleanupManagerOperationState;
-	readonly success: VcHostOperationCleanupManagerOperationState;
-	readonly failure: VcHostOperationCleanupManagerOperationState;
-	readonly name: string;
+declare class VcHostOperationCleanupManagerOperationState implements IPseudoEnum {
+	static readonly running: VcHostOperationCleanupManagerOperationState & EnumVal<'running'>;
+	static readonly success: VcHostOperationCleanupManagerOperationState & EnumVal<'success'>;
+	static readonly failure: VcHostOperationCleanupManagerOperationState & EnumVal<'failure'>;
+	static fromString(value: string): VcHostOperationCleanupManagerOperationState & EnumVal<TcleanKeys<typeof VcHostOperationCleanupManagerOperationState>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostOperationCleanupManagerOperationState): VcHostOperationCleanupManagerOperationState;
+	toString: () => string;
 }
 
 /**
  * Reasons for identifying the disk extent
  * as copy of VMFS volume extent.
  */
-declare class VcHostUnresolvedVmfsExtentUnresolvedReason {
-	readonly diskIdMismatch: VcHostUnresolvedVmfsExtentUnresolvedReason;
-	readonly uuidConflict: VcHostUnresolvedVmfsExtentUnresolvedReason;
-	readonly name: string;
+declare class VcHostUnresolvedVmfsExtentUnresolvedReason implements IPseudoEnum {
+	static readonly diskIdMismatch: VcHostUnresolvedVmfsExtentUnresolvedReason & EnumVal<'diskIdMismatch'>;
+	static readonly uuidConflict: VcHostUnresolvedVmfsExtentUnresolvedReason & EnumVal<'uuidConflict'>;
+	static fromString(value: string): VcHostUnresolvedVmfsExtentUnresolvedReason & EnumVal<TcleanKeys<typeof VcHostUnresolvedVmfsExtentUnresolvedReason>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostUnresolvedVmfsExtentUnresolvedReason): VcHostUnresolvedVmfsExtentUnresolvedReason;
+	toString: () => string;
 }
 
-declare class VcInvalidDasConfigArgumentEntryForInvalidArgument {
-	readonly userHeartbeatDs: VcInvalidDasConfigArgumentEntryForInvalidArgument;
-	readonly name: string;
-	readonly admissionControl: VcInvalidDasConfigArgumentEntryForInvalidArgument;
+declare class VcInvalidDasConfigArgumentEntryForInvalidArgument implements IPseudoEnum {
+	static readonly userHeartbeatDs: VcInvalidDasConfigArgumentEntryForInvalidArgument & EnumVal<'userHeartbeatDs'>;
+	static readonly admissionControl: VcInvalidDasConfigArgumentEntryForInvalidArgument & EnumVal<'admissionControl'>;
+	static readonly vmConfig: VcInvalidDasConfigArgumentEntryForInvalidArgument & EnumVal<'vmConfig'>;
+	static fromString(value: string): VcInvalidDasConfigArgumentEntryForInvalidArgument & EnumVal<TcleanKeys<typeof VcInvalidDasConfigArgumentEntryForInvalidArgument>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly vmConfig: VcInvalidDasConfigArgumentEntryForInvalidArgument;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcInvalidDasConfigArgumentEntryForInvalidArgument): VcInvalidDasConfigArgumentEntryForInvalidArgument;
+	toString: () => string;
 }
 
 /**
  * The set of signing method that can be used to calcuate the signature
  * values.
  */
-declare class VcHostSignatureInfoSigningMethodType {
-	readonly DSA_SHA1: VcHostSignatureInfoSigningMethodType;
-	readonly RSA_SHA1: VcHostSignatureInfoSigningMethodType;
-	readonly name: string;
+declare class VcHostSignatureInfoSigningMethodType implements IPseudoEnum {
+	static readonly DSA_SHA1: VcHostSignatureInfoSigningMethodType & EnumVal<'DSA_SHA1'>;
+	static readonly RSA_SHA1: VcHostSignatureInfoSigningMethodType & EnumVal<'RSA_SHA1'>;
+	static readonly RSA_MD5: VcHostSignatureInfoSigningMethodType & EnumVal<'RSA_MD5'>;
+	static fromString(value: string): VcHostSignatureInfoSigningMethodType & EnumVal<TcleanKeys<typeof VcHostSignatureInfoSigningMethodType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly RSA_MD5: VcHostSignatureInfoSigningMethodType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostSignatureInfoSigningMethodType): VcHostSignatureInfoSigningMethodType;
+	toString: () => string;
 }
 
 /**
  * List of possible BackingStoragePool types
  */
-declare class BackingStoragePoolType {
-	readonly thinAndDeduplicationCombinedPool: BackingStoragePoolType;
-	readonly thinProvisioningPool: BackingStoragePoolType;
-	readonly name: string;
+declare class BackingStoragePoolType implements IPseudoEnum {
+	static readonly thinAndDeduplicationCombinedPool: BackingStoragePoolType & EnumVal<'thinAndDeduplicationCombinedPool'>;
+	static readonly thinProvisioningPool: BackingStoragePoolType & EnumVal<'thinProvisioningPool'>;
+	static readonly deduplicationPool: BackingStoragePoolType & EnumVal<'deduplicationPool'>;
+	static fromString(value: string): BackingStoragePoolType & EnumVal<TcleanKeys<typeof BackingStoragePoolType>>;
+
 	readonly id: string;
-	readonly deduplicationPool: BackingStoragePoolType;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: BackingStoragePoolType): BackingStoragePoolType;
+	toString: () => string;
 }
 
 /**
  * Defines the type of placement
  */
-declare class VcPlacementSpecPlacementType {
-	readonly relocate: VcPlacementSpecPlacementType;
-	readonly clone: VcPlacementSpecPlacementType;
-	readonly name: string;
-	readonly create: VcPlacementSpecPlacementType;
+declare class VcPlacementSpecPlacementType implements IPseudoEnum {
+	static readonly relocate: VcPlacementSpecPlacementType & EnumVal<'relocate'>;
+	static readonly clone: VcPlacementSpecPlacementType & EnumVal<'clone'>;
+	static readonly create: VcPlacementSpecPlacementType & EnumVal<'create'>;
+	static readonly reconfigure: VcPlacementSpecPlacementType & EnumVal<'reconfigure'>;
+	static fromString(value: string): VcPlacementSpecPlacementType & EnumVal<TcleanKeys<typeof VcPlacementSpecPlacementType>>;
+
 	readonly id: string;
-	readonly reconfigure: VcPlacementSpecPlacementType;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcPlacementSpecPlacementType): VcPlacementSpecPlacementType;
+	toString: () => string;
 }
 
 /**
  * The type of operation being performed on the specified virtual device.
  * Valid values are:
  */
-declare class VcVirtualDeviceConfigSpecOperation {
-	static add: VcVirtualDeviceConfigSpecOperation;
-	static edit: VcVirtualDeviceConfigSpecOperation;
-	static name: string;
-	static id: string;
-	static value: string;
-	static remove: VcVirtualDeviceConfigSpecOperation;
+declare class VcVirtualDeviceConfigSpecOperation implements IPseudoEnum {
+	static readonly add: VcVirtualDeviceConfigSpecOperation & EnumVal<'add'>;
+	static readonly edit: VcVirtualDeviceConfigSpecOperation & EnumVal<'edit'>;
+	static readonly remove: VcVirtualDeviceConfigSpecOperation & EnumVal<'remove'>;
+	static fromString(value: string): VcVirtualDeviceConfigSpecOperation & EnumVal<TcleanKeys<typeof VcVirtualDeviceConfigSpecOperation>>;
+
+	readonly id: string;
+	readonly name: string;
+	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualDeviceConfigSpecOperation): VcVirtualDeviceConfigSpecOperation;
+	toString: () => string;
 }
 
 /**
  * The encoding of the resultant return data. This is a hint to the client side
  * to indicate the format of the information being returned.
  */
-declare class VcSimpleCommandEncoding {
-	readonly CSV: VcSimpleCommandEncoding;
-	readonly name: string;
-	readonly STRING: VcSimpleCommandEncoding;
-	readonly HEX: VcSimpleCommandEncoding;
+declare class VcSimpleCommandEncoding implements IPseudoEnum {
+	static readonly CSV: VcSimpleCommandEncoding & EnumVal<'CSV'>;
+	static readonly STRING: VcSimpleCommandEncoding & EnumVal<'STRING'>;
+	static readonly HEX: VcSimpleCommandEncoding & EnumVal<'HEX'>;
+	static fromString(value: string): VcSimpleCommandEncoding & EnumVal<TcleanKeys<typeof VcSimpleCommandEncoding>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcSimpleCommandEncoding): VcSimpleCommandEncoding;
+	toString: () => string;
 }
 
 /**
  * Defines a host's encryption state
  */
-declare class VcHostCryptoState {
-	readonly prepared: VcHostCryptoState;
-	readonly safe: VcHostCryptoState;
-	readonly name: string;
+declare class VcHostCryptoState implements IPseudoEnum {
+	static readonly prepared: VcHostCryptoState & EnumVal<'prepared'>;
+	static readonly safe: VcHostCryptoState & EnumVal<'safe'>;
+	static readonly incapable: VcHostCryptoState & EnumVal<'incapable'>;
+	static fromString(value: string): VcHostCryptoState & EnumVal<TcleanKeys<typeof VcHostCryptoState>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly incapable: VcHostCryptoState;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostCryptoState): VcHostCryptoState;
+	toString: () => string;
 }
 
 /**
  * The target of the disk reload.
  */
-declare class VcHostLowLevelProvisioningManagerReloadTarget {
-	readonly snapshotConfig: VcHostLowLevelProvisioningManagerReloadTarget;
-	readonly name: string;
-	readonly currentConfig: VcHostLowLevelProvisioningManagerReloadTarget;
+declare class VcHostLowLevelProvisioningManagerReloadTarget implements IPseudoEnum {
+	static readonly snapshotConfig: VcHostLowLevelProvisioningManagerReloadTarget & EnumVal<'snapshotConfig'>;
+	static readonly currentConfig: VcHostLowLevelProvisioningManagerReloadTarget & EnumVal<'currentConfig'>;
+	static fromString(value: string): VcHostLowLevelProvisioningManagerReloadTarget & EnumVal<TcleanKeys<typeof VcHostLowLevelProvisioningManagerReloadTarget>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostLowLevelProvisioningManagerReloadTarget): VcHostLowLevelProvisioningManagerReloadTarget;
+	toString: () => string;
 }
 
 /**
  * Describes how widely the endpoint is availabe in a cluster. Note that these
  * fields are not neccessarily mutual-exclusive.
  */
-declare class VcVirtualMachineTargetInfoConfigurationTag {
-	readonly name: string;
-	readonly compliant: VcVirtualMachineTargetInfoConfigurationTag;
-	readonly clusterWide: VcVirtualMachineTargetInfoConfigurationTag;
+declare class VcVirtualMachineTargetInfoConfigurationTag implements IPseudoEnum {
+	static readonly compliant: VcVirtualMachineTargetInfoConfigurationTag & EnumVal<'compliant'>;
+	static readonly clusterWide: VcVirtualMachineTargetInfoConfigurationTag & EnumVal<'clusterWide'>;
+	static fromString(value: string): VcVirtualMachineTargetInfoConfigurationTag & EnumVal<TcleanKeys<typeof VcVirtualMachineTargetInfoConfigurationTag>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineTargetInfoConfigurationTag): VcVirtualMachineTargetInfoConfigurationTag;
+	toString: () => string;
 }
 
 /**
  * enum listing possible IPv6 address configuration methods.
  */
-declare class VcHostInternetScsiHbaIscsiIpv6AddressAddressConfigurationType {
-	readonly AutoConfigured: VcHostInternetScsiHbaIscsiIpv6AddressAddressConfigurationType;
-	readonly name: string;
+declare class VcHostInternetScsiHbaIscsiIpv6AddressAddressConfigurationType implements IPseudoEnum {
+	static readonly AutoConfigured: VcHostInternetScsiHbaIscsiIpv6AddressAddressConfigurationType & EnumVal<'AutoConfigured'>;
+	static readonly Static: VcHostInternetScsiHbaIscsiIpv6AddressAddressConfigurationType & EnumVal<'Static'>;
+	static readonly DHCP: VcHostInternetScsiHbaIscsiIpv6AddressAddressConfigurationType & EnumVal<'DHCP'>;
+	static readonly Other: VcHostInternetScsiHbaIscsiIpv6AddressAddressConfigurationType & EnumVal<'Other'>;
+	static fromString(value: string): VcHostInternetScsiHbaIscsiIpv6AddressAddressConfigurationType & EnumVal<TcleanKeys<typeof VcHostInternetScsiHbaIscsiIpv6AddressAddressConfigurationType>>;
+
 	readonly id: string;
-	readonly Static: VcHostInternetScsiHbaIscsiIpv6AddressAddressConfigurationType;
+	readonly name: string;
 	readonly value: string;
-	readonly DHCP: VcHostInternetScsiHbaIscsiIpv6AddressAddressConfigurationType;
-	readonly Other: VcHostInternetScsiHbaIscsiIpv6AddressAddressConfigurationType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostInternetScsiHbaIscsiIpv6AddressAddressConfigurationType): VcHostInternetScsiHbaIscsiIpv6AddressAddressConfigurationType;
+	toString: () => string;
 }
 
 /**
  * List of possible block device interfaces
  */
-declare class BlockDeviceInterface {
-	readonly iscsi: BlockDeviceInterface;
-	readonly name: string;
-	readonly otherBlock: BlockDeviceInterface;
+declare class BlockDeviceInterface implements IPseudoEnum {
+	static readonly iscsi: BlockDeviceInterface & EnumVal<'iscsi'>;
+	static readonly otherBlock: BlockDeviceInterface & EnumVal<'otherBlock'>;
+	static readonly fcoe: BlockDeviceInterface & EnumVal<'fcoe'>;
+	static readonly fc: BlockDeviceInterface & EnumVal<'fc'>;
+	static fromString(value: string): BlockDeviceInterface & EnumVal<TcleanKeys<typeof BlockDeviceInterface>>;
+
 	readonly id: string;
-	readonly fcoe: BlockDeviceInterface;
-	readonly fc: BlockDeviceInterface;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: BlockDeviceInterface): BlockDeviceInterface;
+	toString: () => string;
 }
 
 /**
  * The list of metric types that can sent from an external service.
  */
-declare class VcExternalStatsManagerMetricType {
-	readonly name: string;
-	readonly MemoryNonZeroActiveMb: VcExternalStatsManagerMetricType;
+declare class VcExternalStatsManagerMetricType implements IPseudoEnum {
+	static readonly MemoryNonZeroActiveMb: VcExternalStatsManagerMetricType & EnumVal<'MemoryNonZeroActiveMb'>;
+	static readonly CpuActivePct: VcExternalStatsManagerMetricType & EnumVal<'CpuActivePct'>;
+	static fromString(value: string): VcExternalStatsManagerMetricType & EnumVal<TcleanKeys<typeof VcExternalStatsManagerMetricType>>;
+
 	readonly id: string;
-	readonly CpuActivePct: VcExternalStatsManagerMetricType;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcExternalStatsManagerMetricType): VcExternalStatsManagerMetricType;
+	toString: () => string;
 }
 
 /**
  * enum listing IPv6 address operations.
  */
-declare class VcHostInternetScsiHbaIscsiIpv6AddressIPv6AddressOperation {
-	readonly add: VcHostInternetScsiHbaIscsiIpv6AddressIPv6AddressOperation;
-	readonly name: string;
+declare class VcHostInternetScsiHbaIscsiIpv6AddressIPv6AddressOperation implements IPseudoEnum {
+	static readonly add: VcHostInternetScsiHbaIscsiIpv6AddressIPv6AddressOperation & EnumVal<'add'>;
+	static readonly remove: VcHostInternetScsiHbaIscsiIpv6AddressIPv6AddressOperation & EnumVal<'remove'>;
+	static fromString(value: string): VcHostInternetScsiHbaIscsiIpv6AddressIPv6AddressOperation & EnumVal<TcleanKeys<typeof VcHostInternetScsiHbaIscsiIpv6AddressIPv6AddressOperation>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly remove: VcHostInternetScsiHbaIscsiIpv6AddressIPv6AddressOperation;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostInternetScsiHbaIscsiIpv6AddressIPv6AddressOperation): VcHostInternetScsiHbaIscsiIpv6AddressIPv6AddressOperation;
+	toString: () => string;
 }
 
-declare class VcVchaState {
-	readonly configured: VcVchaState;
-	readonly notConfigured: VcVchaState;
-	readonly prepared: VcVchaState;
-	readonly invalid: VcVchaState;
-	readonly name: string;
+declare class VcVchaState implements IPseudoEnum {
+	static readonly configured: VcVchaState & EnumVal<'configured'>;
+	static readonly notConfigured: VcVchaState & EnumVal<'notConfigured'>;
+	static readonly prepared: VcVchaState & EnumVal<'prepared'>;
+	static readonly invalid: VcVchaState & EnumVal<'invalid'>;
+	static fromString(value: string): VcVchaState & EnumVal<TcleanKeys<typeof VcVchaState>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVchaState): VcVchaState;
+	toString: () => string;
 }
 
 /**
  * A enum constant specifying what should be done to the guest vm after running
  * sysprep.
  */
-declare class VcCustomizationSysprepRebootOption {
-	readonly reboot: VcCustomizationSysprepRebootOption;
-	readonly name: string;
+declare class VcCustomizationSysprepRebootOption implements IPseudoEnum {
+	static readonly reboot: VcCustomizationSysprepRebootOption & EnumVal<'reboot'>;
+	static readonly noreboot: VcCustomizationSysprepRebootOption & EnumVal<'noreboot'>;
+	static readonly shutdown: VcCustomizationSysprepRebootOption & EnumVal<'shutdown'>;
+	static fromString(value: string): VcCustomizationSysprepRebootOption & EnumVal<TcleanKeys<typeof VcCustomizationSysprepRebootOption>>;
+
 	readonly id: string;
-	readonly noreboot: VcCustomizationSysprepRebootOption;
+	readonly name: string;
 	readonly value: string;
-	readonly shutdown: VcCustomizationSysprepRebootOption;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcCustomizationSysprepRebootOption): VcCustomizationSysprepRebootOption;
+	toString: () => string;
 }
 
-declare class VcHostFaultToleranceManagerFaultToleranceType {
-	readonly fault_tolerance_using_recordreplay: VcHostFaultToleranceManagerFaultToleranceType;
-	readonly name: string;
-	readonly fault_tolerance_using_checkpoints: VcHostFaultToleranceManagerFaultToleranceType;
+declare class VcHostFaultToleranceManagerFaultToleranceType implements IPseudoEnum {
+	static readonly fault_tolerance_using_recordreplay: VcHostFaultToleranceManagerFaultToleranceType & EnumVal<'fault_tolerance_using_recordreplay'>;
+	static readonly fault_tolerance_using_checkpoints: VcHostFaultToleranceManagerFaultToleranceType & EnumVal<'fault_tolerance_using_checkpoints'>;
+	static fromString(value: string): VcHostFaultToleranceManagerFaultToleranceType & EnumVal<TcleanKeys<typeof VcHostFaultToleranceManagerFaultToleranceType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostFaultToleranceManagerFaultToleranceType): VcHostFaultToleranceManagerFaultToleranceType;
+	toString: () => string;
 }
 
 /**
  * The list of SCSI device types.  These values correspond to values
  * published in the SCSI specification.
  */
-declare class VcScsiLunType {
-	readonly worm: VcScsiLunType;
-	readonly printer: VcScsiLunType;
-	readonly mediaChanger: VcScsiLunType;
-	readonly opticalDevice: VcScsiLunType;
-	readonly processor: VcScsiLunType;
-	readonly cdrom: VcScsiLunType;
-	readonly unknown: VcScsiLunType;
-	readonly disk: VcScsiLunType;
-	readonly communications: VcScsiLunType;
-	readonly tape: VcScsiLunType;
-	readonly enclosure: VcScsiLunType;
-	readonly scanner: VcScsiLunType;
-	readonly name: string;
+declare class VcScsiLunType implements IPseudoEnum {
+	static readonly worm: VcScsiLunType & EnumVal<'worm'>;
+	static readonly printer: VcScsiLunType & EnumVal<'printer'>;
+	static readonly mediaChanger: VcScsiLunType & EnumVal<'mediaChanger'>;
+	static readonly opticalDevice: VcScsiLunType & EnumVal<'opticalDevice'>;
+	static readonly processor: VcScsiLunType & EnumVal<'processor'>;
+	static readonly cdrom: VcScsiLunType & EnumVal<'cdrom'>;
+	static readonly unknown: VcScsiLunType & EnumVal<'unknown'>;
+	static readonly disk: VcScsiLunType & EnumVal<'disk'>;
+	static readonly communications: VcScsiLunType & EnumVal<'communications'>;
+	static readonly tape: VcScsiLunType & EnumVal<'tape'>;
+	static readonly enclosure: VcScsiLunType & EnumVal<'enclosure'>;
+	static readonly scanner: VcScsiLunType & EnumVal<'scanner'>;
+	static readonly storageArrayController: VcScsiLunType & EnumVal<'storageArrayController'>;
+	static fromString(value: string): VcScsiLunType & EnumVal<TcleanKeys<typeof VcScsiLunType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly storageArrayController: VcScsiLunType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcScsiLunType): VcScsiLunType;
+	toString: () => string;
 }
 
 /**
@@ -2228,300 +2115,284 @@ declare class VcScsiLunType {
  * for compliance operations. See {@link ComplianceResult} and
  * {@link pbm.compliance.RollupComplianceResult}.
  */
-declare class PbmComplianceStatus {
-	readonly outOfDate: PbmComplianceStatus;
-	readonly name: string;
-	readonly compliant: PbmComplianceStatus;
+declare class PbmComplianceStatus implements IPseudoEnum {
+	static readonly outOfDate: PbmComplianceStatus & EnumVal<'outOfDate'>;
+	static readonly compliant: PbmComplianceStatus & EnumVal<'compliant'>;
+	static readonly notApplicable: PbmComplianceStatus & EnumVal<'notApplicable'>;
+	static readonly nonCompliant: PbmComplianceStatus & EnumVal<'nonCompliant'>;
+	static readonly unknown: PbmComplianceStatus & EnumVal<'unknown'>;
+	static fromString(value: string): PbmComplianceStatus & EnumVal<TcleanKeys<typeof PbmComplianceStatus>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly notApplicable: PbmComplianceStatus;
-	readonly nonCompliant: PbmComplianceStatus;
-	readonly unknown: PbmComplianceStatus;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: PbmComplianceStatus): PbmComplianceStatus;
+	toString: () => string;
 }
 
 /**
  * The names of all supported <i>Change Log</i>s that could be
  * monitored for changes.
  */
-declare class VcCDCChangeLogCollectorChangeLog {
-	readonly alarmStatus: VcCDCChangeLogCollectorChangeLog;
-	readonly name: string;
+declare class VcCDCChangeLogCollectorChangeLog implements IPseudoEnum {
+	static readonly alarmStatus: VcCDCChangeLogCollectorChangeLog & EnumVal<'alarmStatus'>;
+	static readonly inventory: VcCDCChangeLogCollectorChangeLog & EnumVal<'inventory'>;
+	static fromString(value: string): VcCDCChangeLogCollectorChangeLog & EnumVal<TcleanKeys<typeof VcCDCChangeLogCollectorChangeLog>>;
+
 	readonly id: string;
-	readonly inventory: VcCDCChangeLogCollectorChangeLog;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcCDCChangeLogCollectorChangeLog): VcCDCChangeLogCollectorChangeLog;
+	toString: () => string;
 }
 
 /**
  * The NeedSecondaryReason type defines all reasons a virtual machine is
  * in the needSecondary Fault Tolerance state following a failure.
  */
-declare class VcVirtualMachineNeedSecondaryReason {
-	readonly divergence: VcVirtualMachineNeedSecondaryReason;
-	readonly userAction: VcVirtualMachineNeedSecondaryReason;
-	readonly other: VcVirtualMachineNeedSecondaryReason;
-	readonly lostConnection: VcVirtualMachineNeedSecondaryReason;
-	readonly name: string;
-	readonly checkpointError: VcVirtualMachineNeedSecondaryReason;
-	readonly initializing: VcVirtualMachineNeedSecondaryReason;
+declare class VcVirtualMachineNeedSecondaryReason implements IPseudoEnum {
+	static readonly divergence: VcVirtualMachineNeedSecondaryReason & EnumVal<'divergence'>;
+	static readonly userAction: VcVirtualMachineNeedSecondaryReason & EnumVal<'userAction'>;
+	static readonly other: VcVirtualMachineNeedSecondaryReason & EnumVal<'other'>;
+	static readonly lostConnection: VcVirtualMachineNeedSecondaryReason & EnumVal<'lostConnection'>;
+	static readonly checkpointError: VcVirtualMachineNeedSecondaryReason & EnumVal<'checkpointError'>;
+	static readonly initializing: VcVirtualMachineNeedSecondaryReason & EnumVal<'initializing'>;
+	static readonly partialHardwareFailure: VcVirtualMachineNeedSecondaryReason & EnumVal<'partialHardwareFailure'>;
+	static fromString(value: string): VcVirtualMachineNeedSecondaryReason & EnumVal<TcleanKeys<typeof VcVirtualMachineNeedSecondaryReason>>;
+
 	readonly id: string;
-	readonly partialHardwareFailure: VcVirtualMachineNeedSecondaryReason;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineNeedSecondaryReason): VcVirtualMachineNeedSecondaryReason;
+	toString: () => string;
 }
 
 /**
  * Fork child type. A child could be type of none, persistent, or
  * nonpersistent.
  */
-declare class VcVirtualMachineForkConfigInfoChildType {
-	readonly nonpersistent: VcVirtualMachineForkConfigInfoChildType;
-	readonly name: string;
-	readonly none: VcVirtualMachineForkConfigInfoChildType;
+declare class VcVirtualMachineForkConfigInfoChildType implements IPseudoEnum {
+	static readonly nonpersistent: VcVirtualMachineForkConfigInfoChildType & EnumVal<'nonpersistent'>;
+	static readonly none: VcVirtualMachineForkConfigInfoChildType & EnumVal<'none'>;
+	static readonly persistent: VcVirtualMachineForkConfigInfoChildType & EnumVal<'persistent'>;
+	static fromString(value: string): VcVirtualMachineForkConfigInfoChildType & EnumVal<TcleanKeys<typeof VcVirtualMachineForkConfigInfoChildType>>;
+
 	readonly id: string;
-	readonly persistent: VcVirtualMachineForkConfigInfoChildType;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineForkConfigInfoChildType): VcVirtualMachineForkConfigInfoChildType;
+	toString: () => string;
 }
 
 /**
  * List of defined migration reason codes:
  */
-declare class VcDrsRecommendationReasonCode {
-	readonly antiAffin: VcDrsRecommendationReasonCode;
-	readonly name: string;
-	readonly fairnessMemAvg: VcDrsRecommendationReasonCode;
-	readonly fairnessCpuAvg: VcDrsRecommendationReasonCode;
-	readonly hostMaint: VcDrsRecommendationReasonCode;
+declare class VcDrsRecommendationReasonCode implements IPseudoEnum {
+	static readonly antiAffin: VcDrsRecommendationReasonCode & EnumVal<'antiAffin'>;
+	static readonly fairnessMemAvg: VcDrsRecommendationReasonCode & EnumVal<'fairnessMemAvg'>;
+	static readonly fairnessCpuAvg: VcDrsRecommendationReasonCode & EnumVal<'fairnessCpuAvg'>;
+	static readonly hostMaint: VcDrsRecommendationReasonCode & EnumVal<'hostMaint'>;
+	static readonly jointAffin: VcDrsRecommendationReasonCode & EnumVal<'jointAffin'>;
+	static fromString(value: string): VcDrsRecommendationReasonCode & EnumVal<TcleanKeys<typeof VcDrsRecommendationReasonCode>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly jointAffin: VcDrsRecommendationReasonCode;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDrsRecommendationReasonCode): VcDrsRecommendationReasonCode;
+	toString: () => string;
 }
 
 /**
  * VMFS unmap priority. VMFS unmap reclaims unused storage space.
  * This specifies the processing rate of unmaps.
  */
-declare class VcHostVmfsVolumeUnmapPriority {
-	readonly low: VcHostVmfsVolumeUnmapPriority;
-	readonly name: string;
-	readonly none: VcHostVmfsVolumeUnmapPriority;
+declare class VcHostVmfsVolumeUnmapPriority implements IPseudoEnum {
+	static readonly low: VcHostVmfsVolumeUnmapPriority & EnumVal<'low'>;
+	static readonly none: VcHostVmfsVolumeUnmapPriority & EnumVal<'none'>;
+	static fromString(value: string): VcHostVmfsVolumeUnmapPriority & EnumVal<TcleanKeys<typeof VcHostVmfsVolumeUnmapPriority>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostVmfsVolumeUnmapPriority): VcHostVmfsVolumeUnmapPriority;
+	toString: () => string;
 }
 
 /**
  * Set of possible values for {@link vim.vm.FlagInfo#monitorType}.
  */
-declare class VcVirtualMachineFlagInfoMonitorType {
-	readonly debug: VcVirtualMachineFlagInfoMonitorType;
-	readonly stats: VcVirtualMachineFlagInfoMonitorType;
-	readonly release: VcVirtualMachineFlagInfoMonitorType;
-	readonly name: string;
+declare class VcVirtualMachineFlagInfoMonitorType implements IPseudoEnum {
+	static readonly debug: VcVirtualMachineFlagInfoMonitorType & EnumVal<'debug'>;
+	static readonly stats: VcVirtualMachineFlagInfoMonitorType & EnumVal<'stats'>;
+	static readonly release: VcVirtualMachineFlagInfoMonitorType & EnumVal<'release'>;
+	static fromString(value: string): VcVirtualMachineFlagInfoMonitorType & EnumVal<TcleanKeys<typeof VcVirtualMachineFlagInfoMonitorType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineFlagInfoMonitorType): VcVirtualMachineFlagInfoMonitorType;
+	toString: () => string;
 }
 
-declare class VcDynamicTypeMgrPropertyTypeInfoAnnotationType {
-	readonly readonly: VcDynamicTypeMgrPropertyTypeInfoAnnotationType;
-	readonly linkable: VcDynamicTypeMgrPropertyTypeInfoAnnotationType;
-	readonly link: VcDynamicTypeMgrPropertyTypeInfoAnnotationType;
-	readonly name: string;
-	readonly optional: VcDynamicTypeMgrPropertyTypeInfoAnnotationType;
+declare class VcDynamicTypeMgrPropertyTypeInfoAnnotationType implements IPseudoEnum {
+	static readonly readonly: VcDynamicTypeMgrPropertyTypeInfoAnnotationType & EnumVal<'readonly'>;
+	static readonly linkable: VcDynamicTypeMgrPropertyTypeInfoAnnotationType & EnumVal<'linkable'>;
+	static readonly link: VcDynamicTypeMgrPropertyTypeInfoAnnotationType & EnumVal<'link'>;
+	static readonly optional: VcDynamicTypeMgrPropertyTypeInfoAnnotationType & EnumVal<'optional'>;
+	static fromString(value: string): VcDynamicTypeMgrPropertyTypeInfoAnnotationType & EnumVal<TcleanKeys<typeof VcDynamicTypeMgrPropertyTypeInfoAnnotationType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDynamicTypeMgrPropertyTypeInfoAnnotationType): VcDynamicTypeMgrPropertyTypeInfoAnnotationType;
+	toString: () => string;
 }
 
 /**
  * Define the instance state type
  */
-declare class VcHostRuntimeInfoNetStackInstanceRuntimeInfoState {
-	readonly inactive: VcHostRuntimeInfoNetStackInstanceRuntimeInfoState;
-	readonly deactivating: VcHostRuntimeInfoNetStackInstanceRuntimeInfoState;
-	readonly name: string;
-	readonly active: VcHostRuntimeInfoNetStackInstanceRuntimeInfoState;
-	readonly activating: VcHostRuntimeInfoNetStackInstanceRuntimeInfoState;
+declare class VcHostRuntimeInfoNetStackInstanceRuntimeInfoState implements IPseudoEnum {
+	static readonly inactive: VcHostRuntimeInfoNetStackInstanceRuntimeInfoState & EnumVal<'inactive'>;
+	static readonly deactivating: VcHostRuntimeInfoNetStackInstanceRuntimeInfoState & EnumVal<'deactivating'>;
+	static readonly active: VcHostRuntimeInfoNetStackInstanceRuntimeInfoState & EnumVal<'active'>;
+	static readonly activating: VcHostRuntimeInfoNetStackInstanceRuntimeInfoState & EnumVal<'activating'>;
+	static fromString(value: string): VcHostRuntimeInfoNetStackInstanceRuntimeInfoState & EnumVal<TcleanKeys<typeof VcHostRuntimeInfoNetStackInstanceRuntimeInfoState>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostRuntimeInfoNetStackInstanceRuntimeInfoState): VcHostRuntimeInfoNetStackInstanceRuntimeInfoState;
+	toString: () => string;
 }
 
 /**
  * A {@link NodeState} represents the state of participation of a host
  * in the VSAN service.
  */
-declare class VcVsanHostNodeState {
-	readonly agent: VcVsanHostNodeState;
-	readonly backup: VcVsanHostNodeState;
-	readonly error: VcVsanHostNodeState;
-	readonly master: VcVsanHostNodeState;
-	readonly stopping: VcVsanHostNodeState;
-	readonly name: string;
-	readonly decommissioning: VcVsanHostNodeState;
-	readonly disabled: VcVsanHostNodeState;
+declare class VcVsanHostNodeState implements IPseudoEnum {
+	static readonly agent: VcVsanHostNodeState & EnumVal<'agent'>;
+	static readonly backup: VcVsanHostNodeState & EnumVal<'backup'>;
+	static readonly error: VcVsanHostNodeState & EnumVal<'error'>;
+	static readonly master: VcVsanHostNodeState & EnumVal<'master'>;
+	static readonly stopping: VcVsanHostNodeState & EnumVal<'stopping'>;
+	static readonly decommissioning: VcVsanHostNodeState & EnumVal<'decommissioning'>;
+	static readonly disabled: VcVsanHostNodeState & EnumVal<'disabled'>;
+	static readonly starting: VcVsanHostNodeState & EnumVal<'starting'>;
+	static readonly exitingMaintenanceMode: VcVsanHostNodeState & EnumVal<'exitingMaintenanceMode'>;
+	static readonly enteringMaintenanceMode: VcVsanHostNodeState & EnumVal<'enteringMaintenanceMode'>;
+	static fromString(value: string): VcVsanHostNodeState & EnumVal<TcleanKeys<typeof VcVsanHostNodeState>>;
+
 	readonly id: string;
-	readonly starting: VcVsanHostNodeState;
-	readonly exitingMaintenanceMode: VcVsanHostNodeState;
+	readonly name: string;
 	readonly value: string;
-	readonly enteringMaintenanceMode: VcVsanHostNodeState;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVsanHostNodeState): VcVsanHostNodeState;
+	toString: () => string;
 }
 
 /**
  * Correlation state as computed by storageRM
  * module on host.
  */
-declare class VcDrsInjectorWorkloadCorrelationState {
-	readonly Uncorrelated: VcDrsInjectorWorkloadCorrelationState;
-	readonly name: string;
+declare class VcDrsInjectorWorkloadCorrelationState implements IPseudoEnum {
+	static readonly Uncorrelated: VcDrsInjectorWorkloadCorrelationState & EnumVal<'Uncorrelated'>;
+	static readonly Correlated: VcDrsInjectorWorkloadCorrelationState & EnumVal<'Correlated'>;
+	static fromString(value: string): VcDrsInjectorWorkloadCorrelationState & EnumVal<TcleanKeys<typeof VcDrsInjectorWorkloadCorrelationState>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly Correlated: VcDrsInjectorWorkloadCorrelationState;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDrsInjectorWorkloadCorrelationState): VcDrsInjectorWorkloadCorrelationState;
+	toString: () => string;
 }
 
 /**
  * Some licenses may only be allowed to load from a specified source.
  * This enum indicates what restrictions exist for this license if any.
  */
-declare class VcLicenseFeatureInfoSourceRestriction {
-	readonly file: VcLicenseFeatureInfoSourceRestriction;
-	readonly unrestricted: VcLicenseFeatureInfoSourceRestriction;
-	readonly served: VcLicenseFeatureInfoSourceRestriction;
-	readonly name: string;
+declare class VcLicenseFeatureInfoSourceRestriction implements IPseudoEnum {
+	static readonly file: VcLicenseFeatureInfoSourceRestriction & EnumVal<'file'>;
+	static readonly unrestricted: VcLicenseFeatureInfoSourceRestriction & EnumVal<'unrestricted'>;
+	static readonly served: VcLicenseFeatureInfoSourceRestriction & EnumVal<'served'>;
+	static fromString(value: string): VcLicenseFeatureInfoSourceRestriction & EnumVal<TcleanKeys<typeof VcLicenseFeatureInfoSourceRestriction>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcLicenseFeatureInfoSourceRestriction): VcLicenseFeatureInfoSourceRestriction;
+	toString: () => string;
 }
 
-declare class VcDasConfigFaultDasConfigFaultReason {
-	readonly NoDatastoresConfigured: VcDasConfigFaultDasConfigFaultReason;
-	readonly CreateConfigVvolFailed: VcDasConfigFaultDasConfigFaultReason;
-	readonly HostNetworkMisconfiguration: VcDasConfigFaultDasConfigFaultReason;
-	readonly name: string;
-	readonly InsufficientPrivileges: VcDasConfigFaultDasConfigFaultReason;
-	readonly DasNetworkMisconfiguration: VcDasConfigFaultDasConfigFaultReason;
+declare class VcDasConfigFaultDasConfigFaultReason implements IPseudoEnum {
+	static readonly NoDatastoresConfigured: VcDasConfigFaultDasConfigFaultReason & EnumVal<'NoDatastoresConfigured'>;
+	static readonly CreateConfigVvolFailed: VcDasConfigFaultDasConfigFaultReason & EnumVal<'CreateConfigVvolFailed'>;
+	static readonly HostNetworkMisconfiguration: VcDasConfigFaultDasConfigFaultReason & EnumVal<'HostNetworkMisconfiguration'>;
+	static readonly InsufficientPrivileges: VcDasConfigFaultDasConfigFaultReason & EnumVal<'InsufficientPrivileges'>;
+	static readonly DasNetworkMisconfiguration: VcDasConfigFaultDasConfigFaultReason & EnumVal<'DasNetworkMisconfiguration'>;
+	static readonly VSanNotSupportedOnHost: VcDasConfigFaultDasConfigFaultReason & EnumVal<'VSanNotSupportedOnHost'>;
+	static readonly HostMisconfiguration: VcDasConfigFaultDasConfigFaultReason & EnumVal<'HostMisconfiguration'>;
+	static readonly NoPrimaryAgentAvailable: VcDasConfigFaultDasConfigFaultReason & EnumVal<'NoPrimaryAgentAvailable'>;
+	static readonly Other: VcDasConfigFaultDasConfigFaultReason & EnumVal<'Other'>;
+	static fromString(value: string): VcDasConfigFaultDasConfigFaultReason & EnumVal<TcleanKeys<typeof VcDasConfigFaultDasConfigFaultReason>>;
+
 	readonly id: string;
-	readonly VSanNotSupportedOnHost: VcDasConfigFaultDasConfigFaultReason;
+	readonly name: string;
 	readonly value: string;
-	readonly HostMisconfiguration: VcDasConfigFaultDasConfigFaultReason;
-	readonly NoPrimaryAgentAvailable: VcDasConfigFaultDasConfigFaultReason;
-	readonly Other: VcDasConfigFaultDasConfigFaultReason;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDasConfigFaultDasConfigFaultReason): VcDasConfigFaultDasConfigFaultReason;
+	toString: () => string;
 }
 
 /**
  * Firmware types
  */
-declare class VcGuestOsDescriptorFirmwareType {
-	readonly bios: VcGuestOsDescriptorFirmwareType;
-	readonly name: string;
-	readonly efi: VcGuestOsDescriptorFirmwareType;
+declare class VcGuestOsDescriptorFirmwareType implements IPseudoEnum {
+	static readonly bios: VcGuestOsDescriptorFirmwareType & EnumVal<'bios'>;
+	static readonly efi: VcGuestOsDescriptorFirmwareType & EnumVal<'efi'>;
+	static readonly csm: VcGuestOsDescriptorFirmwareType & EnumVal<'csm'>;
+	static fromString(value: string): VcGuestOsDescriptorFirmwareType & EnumVal<TcleanKeys<typeof VcGuestOsDescriptorFirmwareType>>;
+
 	readonly id: string;
-	readonly csm: VcGuestOsDescriptorFirmwareType;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcGuestOsDescriptorFirmwareType): VcGuestOsDescriptorFirmwareType;
+	toString: () => string;
 }
 
 /**
  * Basic Comparison operators
  */
-declare class VcEventAlarmExpressionComparisonOperator {
-	readonly doesNotEndWith: VcEventAlarmExpressionComparisonOperator;
-	readonly equals: VcEventAlarmExpressionComparisonOperator;
-	readonly endsWith: VcEventAlarmExpressionComparisonOperator;
-	readonly name: string;
-	readonly doesNotStartWith: VcEventAlarmExpressionComparisonOperator;
+declare class VcEventAlarmExpressionComparisonOperator implements IPseudoEnum {
+	static readonly doesNotEndWith: VcEventAlarmExpressionComparisonOperator & EnumVal<'doesNotEndWith'>;
+	static readonly equals: VcEventAlarmExpressionComparisonOperator & EnumVal<'equals'>;
+	static readonly endsWith: VcEventAlarmExpressionComparisonOperator & EnumVal<'endsWith'>;
+	static readonly doesNotStartWith: VcEventAlarmExpressionComparisonOperator & EnumVal<'doesNotStartWith'>;
+	static readonly notEqualTo: VcEventAlarmExpressionComparisonOperator & EnumVal<'notEqualTo'>;
+	static readonly startsWith: VcEventAlarmExpressionComparisonOperator & EnumVal<'startsWith'>;
+	static fromString(value: string): VcEventAlarmExpressionComparisonOperator & EnumVal<TcleanKeys<typeof VcEventAlarmExpressionComparisonOperator>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly notEqualTo: VcEventAlarmExpressionComparisonOperator;
-	readonly startsWith: VcEventAlarmExpressionComparisonOperator;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcEventAlarmExpressionComparisonOperator): VcEventAlarmExpressionComparisonOperator;
+	toString: () => string;
 }
 
-declare class VcAgentInstallFailedReason {
-	readonly SignatureVerificationFailed: VcAgentInstallFailedReason;
-	readonly PrepareToUpgradeFailed: VcAgentInstallFailedReason;
-	readonly AgentNotRunning: VcAgentInstallFailedReason;
-	readonly InstallTimedout: VcAgentInstallFailedReason;
-	readonly name: string;
-	readonly NotEnoughSpaceOnDevice: VcAgentInstallFailedReason;
-	readonly AgentNotReachable: VcAgentInstallFailedReason;
-	readonly UnknownInstallerError: VcAgentInstallFailedReason;
+declare class VcAgentInstallFailedReason implements IPseudoEnum {
+	static readonly SignatureVerificationFailed: VcAgentInstallFailedReason & EnumVal<'SignatureVerificationFailed'>;
+	static readonly PrepareToUpgradeFailed: VcAgentInstallFailedReason & EnumVal<'PrepareToUpgradeFailed'>;
+	static readonly AgentNotRunning: VcAgentInstallFailedReason & EnumVal<'AgentNotRunning'>;
+	static readonly InstallTimedout: VcAgentInstallFailedReason & EnumVal<'InstallTimedout'>;
+	static readonly NotEnoughSpaceOnDevice: VcAgentInstallFailedReason & EnumVal<'NotEnoughSpaceOnDevice'>;
+	static readonly AgentNotReachable: VcAgentInstallFailedReason & EnumVal<'AgentNotReachable'>;
+	static readonly UnknownInstallerError: VcAgentInstallFailedReason & EnumVal<'UnknownInstallerError'>;
+	static readonly AgentUploadTimedout: VcAgentInstallFailedReason & EnumVal<'AgentUploadTimedout'>;
+	static readonly AgentUploadFailed: VcAgentInstallFailedReason & EnumVal<'AgentUploadFailed'>;
+	static fromString(value: string): VcAgentInstallFailedReason & EnumVal<TcleanKeys<typeof VcAgentInstallFailedReason>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly AgentUploadTimedout: VcAgentInstallFailedReason;
-	readonly AgentUploadFailed: VcAgentInstallFailedReason;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcAgentInstallFailedReason): VcAgentInstallFailedReason;
+	toString: () => string;
 }
 
 /**
@@ -2529,121 +2400,114 @@ declare class VcAgentInstallFailedReason {
  * packets will be allowed or all the packets will be denied when
  * Filter fails to configure.
  */
-declare class VcDvsFilterOnFailure {
-	readonly failOpen: VcDvsFilterOnFailure;
-	readonly failClosed: VcDvsFilterOnFailure;
-	readonly name: string;
+declare class VcDvsFilterOnFailure implements IPseudoEnum {
+	static readonly failOpen: VcDvsFilterOnFailure & EnumVal<'failOpen'>;
+	static readonly failClosed: VcDvsFilterOnFailure & EnumVal<'failClosed'>;
+	static fromString(value: string): VcDvsFilterOnFailure & EnumVal<TcleanKeys<typeof VcDvsFilterOnFailure>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDvsFilterOnFailure): VcDvsFilterOnFailure;
+	toString: () => string;
 }
 
 /**
  * Types of tests available for validateMigration.
  */
-declare class VcValidateMigrationTestType {
-	readonly compatibilityTests: VcValidateMigrationTestType;
-	readonly resourceTests: VcValidateMigrationTestType;
-	readonly sourceTests: VcValidateMigrationTestType;
-	readonly diskAccessibilityTests: VcValidateMigrationTestType;
-	readonly name: string;
+declare class VcValidateMigrationTestType implements IPseudoEnum {
+	static readonly compatibilityTests: VcValidateMigrationTestType & EnumVal<'compatibilityTests'>;
+	static readonly resourceTests: VcValidateMigrationTestType & EnumVal<'resourceTests'>;
+	static readonly sourceTests: VcValidateMigrationTestType & EnumVal<'sourceTests'>;
+	static readonly diskAccessibilityTests: VcValidateMigrationTestType & EnumVal<'diskAccessibilityTests'>;
+	static fromString(value: string): VcValidateMigrationTestType & EnumVal<TcleanKeys<typeof VcValidateMigrationTestType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcValidateMigrationTestType): VcValidateMigrationTestType;
+	toString: () => string;
 }
 
-declare class VcWillLoseHAProtectionResolution {
-	readonly svmotion: VcWillLoseHAProtectionResolution;
-	readonly relocate: VcWillLoseHAProtectionResolution;
-	readonly name: string;
+declare class VcWillLoseHAProtectionResolution implements IPseudoEnum {
+	static readonly svmotion: VcWillLoseHAProtectionResolution & EnumVal<'svmotion'>;
+	static readonly relocate: VcWillLoseHAProtectionResolution & EnumVal<'relocate'>;
+	static fromString(value: string): VcWillLoseHAProtectionResolution & EnumVal<TcleanKeys<typeof VcWillLoseHAProtectionResolution>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcWillLoseHAProtectionResolution): VcWillLoseHAProtectionResolution;
+	toString: () => string;
 }
 
-declare class VcVAppAutoStartAction {
-	readonly suspend: VcVAppAutoStartAction;
-	readonly powerOn: VcVAppAutoStartAction;
-	readonly powerOff: VcVAppAutoStartAction;
-	readonly name: string;
-	readonly none: VcVAppAutoStartAction;
-	readonly guestShutdown: VcVAppAutoStartAction;
+declare class VcVAppAutoStartAction implements IPseudoEnum {
+	static readonly suspend: VcVAppAutoStartAction & EnumVal<'suspend'>;
+	static readonly powerOn: VcVAppAutoStartAction & EnumVal<'powerOn'>;
+	static readonly powerOff: VcVAppAutoStartAction & EnumVal<'powerOff'>;
+	static readonly none: VcVAppAutoStartAction & EnumVal<'none'>;
+	static readonly guestShutdown: VcVAppAutoStartAction & EnumVal<'guestShutdown'>;
+	static fromString(value: string): VcVAppAutoStartAction & EnumVal<TcleanKeys<typeof VcVAppAutoStartAction>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVAppAutoStartAction): VcVAppAutoStartAction;
+	toString: () => string;
 }
 
 /**
  * The available iSNS discovery methods.
  */
-declare class VcInternetScsiSnsDiscoveryMethod {
-	readonly isnsStatic: VcInternetScsiSnsDiscoveryMethod;
-	readonly isnsDhcp: VcInternetScsiSnsDiscoveryMethod;
-	readonly isnsSlp: VcInternetScsiSnsDiscoveryMethod;
-	readonly name: string;
+declare class VcInternetScsiSnsDiscoveryMethod implements IPseudoEnum {
+	static readonly isnsStatic: VcInternetScsiSnsDiscoveryMethod & EnumVal<'isnsStatic'>;
+	static readonly isnsDhcp: VcInternetScsiSnsDiscoveryMethod & EnumVal<'isnsDhcp'>;
+	static readonly isnsSlp: VcInternetScsiSnsDiscoveryMethod & EnumVal<'isnsSlp'>;
+	static fromString(value: string): VcInternetScsiSnsDiscoveryMethod & EnumVal<TcleanKeys<typeof VcInternetScsiSnsDiscoveryMethod>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcInternetScsiSnsDiscoveryMethod): VcInternetScsiSnsDiscoveryMethod;
+	toString: () => string;
 }
 
 /**
  * Types of disk provisioning that can be set for the disk in the deployed OVF
  * package.
  */
-declare class VcOvfCreateImportSpecParamsDiskProvisioningType {
-	readonly monolithicSparse: VcOvfCreateImportSpecParamsDiskProvisioningType;
-	readonly seSparse: VcOvfCreateImportSpecParamsDiskProvisioningType;
-	readonly thick: VcOvfCreateImportSpecParamsDiskProvisioningType;
-	readonly thin: VcOvfCreateImportSpecParamsDiskProvisioningType;
-	readonly twoGbMaxExtentFlat: VcOvfCreateImportSpecParamsDiskProvisioningType;
-	readonly sparse: VcOvfCreateImportSpecParamsDiskProvisioningType;
-	readonly flat: VcOvfCreateImportSpecParamsDiskProvisioningType;
-	readonly name: string;
-	readonly monolithicFlat: VcOvfCreateImportSpecParamsDiskProvisioningType;
+declare class VcOvfCreateImportSpecParamsDiskProvisioningType implements IPseudoEnum {
+	static readonly monolithicSparse: VcOvfCreateImportSpecParamsDiskProvisioningType & EnumVal<'monolithicSparse'>;
+	static readonly seSparse: VcOvfCreateImportSpecParamsDiskProvisioningType & EnumVal<'seSparse'>;
+	static readonly thick: VcOvfCreateImportSpecParamsDiskProvisioningType & EnumVal<'thick'>;
+	static readonly thin: VcOvfCreateImportSpecParamsDiskProvisioningType & EnumVal<'thin'>;
+	static readonly twoGbMaxExtentFlat: VcOvfCreateImportSpecParamsDiskProvisioningType & EnumVal<'twoGbMaxExtentFlat'>;
+	static readonly sparse: VcOvfCreateImportSpecParamsDiskProvisioningType & EnumVal<'sparse'>;
+	static readonly flat: VcOvfCreateImportSpecParamsDiskProvisioningType & EnumVal<'flat'>;
+	static readonly monolithicFlat: VcOvfCreateImportSpecParamsDiskProvisioningType & EnumVal<'monolithicFlat'>;
+	static readonly twoGbMaxExtentSparse: VcOvfCreateImportSpecParamsDiskProvisioningType & EnumVal<'twoGbMaxExtentSparse'>;
+	static readonly eagerZeroedThick: VcOvfCreateImportSpecParamsDiskProvisioningType & EnumVal<'eagerZeroedThick'>;
+	static fromString(value: string): VcOvfCreateImportSpecParamsDiskProvisioningType & EnumVal<TcleanKeys<typeof VcOvfCreateImportSpecParamsDiskProvisioningType>>;
+
 	readonly id: string;
-	readonly twoGbMaxExtentSparse: VcOvfCreateImportSpecParamsDiskProvisioningType;
+	readonly name: string;
 	readonly value: string;
-	readonly eagerZeroedThick: VcOvfCreateImportSpecParamsDiskProvisioningType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcOvfCreateImportSpecParamsDiskProvisioningType): VcOvfCreateImportSpecParamsDiskProvisioningType;
+	toString: () => string;
 }
 
-declare class VcServiceProtocol {
-	readonly vimApi: VcServiceProtocol;
-	readonly viImageLibrary: VcServiceProtocol;
-	readonly vimWebServices: VcServiceProtocol;
-	readonly name: string;
+declare class VcServiceProtocol implements IPseudoEnum {
+	static readonly vimApi: VcServiceProtocol & EnumVal<'vimApi'>;
+	static readonly viImageLibrary: VcServiceProtocol & EnumVal<'viImageLibrary'>;
+	static readonly vimWebServices: VcServiceProtocol & EnumVal<'vimWebServices'>;
+	static readonly unknown: VcServiceProtocol & EnumVal<'unknown'>;
+	static fromString(value: string): VcServiceProtocol & EnumVal<TcleanKeys<typeof VcServiceProtocol>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly unknown: VcServiceProtocol;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcServiceProtocol): VcServiceProtocol;
+	toString: () => string;
 }
 
 /**
@@ -2658,60 +2522,57 @@ declare class VcServiceProtocol {
  * The type information determines how capability constraints are interpreted
  * {@link pbm.capability.PropertyInstance#value}).
  */
-declare class PbmBuiltinType {
-	readonly VMW_TIMESPAN: PbmBuiltinType;
-	readonly XSD_INTEGER: PbmBuiltinType;
-	readonly XSD_BOOLEAN: PbmBuiltinType;
-	readonly XSD_LONG: PbmBuiltinType;
-	readonly XSD_INT: PbmBuiltinType;
-	readonly VMW_POLICY: PbmBuiltinType;
-	readonly XSD_STRING: PbmBuiltinType;
-	readonly name: string;
-	readonly XSD_SHORT: PbmBuiltinType;
+declare class PbmBuiltinType implements IPseudoEnum {
+	static readonly VMW_TIMESPAN: PbmBuiltinType & EnumVal<'VMW_TIMESPAN'>;
+	static readonly XSD_INTEGER: PbmBuiltinType & EnumVal<'XSD_INTEGER'>;
+	static readonly XSD_BOOLEAN: PbmBuiltinType & EnumVal<'XSD_BOOLEAN'>;
+	static readonly XSD_LONG: PbmBuiltinType & EnumVal<'XSD_LONG'>;
+	static readonly XSD_INT: PbmBuiltinType & EnumVal<'XSD_INT'>;
+	static readonly VMW_POLICY: PbmBuiltinType & EnumVal<'VMW_POLICY'>;
+	static readonly XSD_STRING: PbmBuiltinType & EnumVal<'XSD_STRING'>;
+	static readonly XSD_SHORT: PbmBuiltinType & EnumVal<'XSD_SHORT'>;
+	static readonly XSD_DATETIME: PbmBuiltinType & EnumVal<'XSD_DATETIME'>;
+	static readonly XSD_DOUBLE: PbmBuiltinType & EnumVal<'XSD_DOUBLE'>;
+	static fromString(value: string): PbmBuiltinType & EnumVal<TcleanKeys<typeof PbmBuiltinType>>;
+
 	readonly id: string;
-	readonly XSD_DATETIME: PbmBuiltinType;
+	readonly name: string;
 	readonly value: string;
-	readonly XSD_DOUBLE: PbmBuiltinType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: PbmBuiltinType): PbmBuiltinType;
+	toString: () => string;
 }
 
 /**
  * The operating mode of the adapter.
  */
-declare class VcFibreChannelPortType {
-	readonly fabric: VcFibreChannelPortType;
-	readonly loop: VcFibreChannelPortType;
-	readonly pointToPoint: VcFibreChannelPortType;
-	readonly name: string;
+declare class VcFibreChannelPortType implements IPseudoEnum {
+	static readonly fabric: VcFibreChannelPortType & EnumVal<'fabric'>;
+	static readonly loop: VcFibreChannelPortType & EnumVal<'loop'>;
+	static readonly pointToPoint: VcFibreChannelPortType & EnumVal<'pointToPoint'>;
+	static readonly unknown: VcFibreChannelPortType & EnumVal<'unknown'>;
+	static fromString(value: string): VcFibreChannelPortType & EnumVal<TcleanKeys<typeof VcFibreChannelPortType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly unknown: VcFibreChannelPortType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcFibreChannelPortType): VcFibreChannelPortType;
+	toString: () => string;
 }
 
 /**
  * State of Namespace or interleave set
  */
-declare class VcNvdimmState {
-	readonly unusable: VcNvdimmState;
-	readonly usable: VcNvdimmState;
-	readonly invalid: VcNvdimmState;
-	readonly name: string;
+declare class VcNvdimmState implements IPseudoEnum {
+	static readonly unusable: VcNvdimmState & EnumVal<'unusable'>;
+	static readonly usable: VcNvdimmState & EnumVal<'usable'>;
+	static readonly invalid: VcNvdimmState & EnumVal<'invalid'>;
+	static fromString(value: string): VcNvdimmState & EnumVal<TcleanKeys<typeof VcNvdimmState>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcNvdimmState): VcNvdimmState;
+	toString: () => string;
 }
 
 /**
@@ -2722,215 +2583,205 @@ declare class VcNvdimmState {
  * <li>physicalMode
  * </ul>
  */
-declare class VcVirtualDiskCompatibilityMode {
-	readonly name: string;
+declare class VcVirtualDiskCompatibilityMode implements IPseudoEnum {
+	static readonly physicalMode: VcVirtualDiskCompatibilityMode & EnumVal<'physicalMode'>;
+	static readonly virtualMode: VcVirtualDiskCompatibilityMode & EnumVal<'virtualMode'>;
+	static fromString(value: string): VcVirtualDiskCompatibilityMode & EnumVal<TcleanKeys<typeof VcVirtualDiskCompatibilityMode>>;
+
 	readonly id: string;
-	readonly physicalMode: VcVirtualDiskCompatibilityMode;
+	readonly name: string;
 	readonly value: string;
-	readonly virtualMode: VcVirtualDiskCompatibilityMode;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualDiskCompatibilityMode): VcVirtualDiskCompatibilityMode;
+	toString: () => string;
 }
 
 /**
  * The list of possible standby actions that the virtual machine can take
  * for S1 ACPI.
  */
-declare class VcVirtualMachineStandbyActionType {
-	readonly checkpoint: VcVirtualMachineStandbyActionType;
-	readonly powerOnSuspend: VcVirtualMachineStandbyActionType;
-	readonly name: string;
+declare class VcVirtualMachineStandbyActionType implements IPseudoEnum {
+	static readonly checkpoint: VcVirtualMachineStandbyActionType & EnumVal<'checkpoint'>;
+	static readonly powerOnSuspend: VcVirtualMachineStandbyActionType & EnumVal<'powerOnSuspend'>;
+	static fromString(value: string): VcVirtualMachineStandbyActionType & EnumVal<TcleanKeys<typeof VcVirtualMachineStandbyActionType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineStandbyActionType): VcVirtualMachineStandbyActionType;
+	toString: () => string;
 }
 
 /**
  * The format in which performance counter data is returned.
  */
-declare class VcPerfFormat {
-	readonly normal: VcPerfFormat;
-	readonly csv: VcPerfFormat;
-	readonly name: string;
+declare class VcPerfFormat implements IPseudoEnum {
+	static readonly normal: VcPerfFormat & EnumVal<'normal'>;
+	static readonly csv: VcPerfFormat & EnumVal<'csv'>;
+	static fromString(value: string): VcPerfFormat & EnumVal<TcleanKeys<typeof VcPerfFormat>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcPerfFormat): VcPerfFormat;
+	toString: () => string;
 }
 
 /**
  * Defines the type of an IO Filter.
  */
-declare class VcIoFilterType {
-	readonly replication: VcIoFilterType;
-	readonly cache: VcIoFilterType;
-	readonly datastoreIoControl: VcIoFilterType;
-	readonly encryption: VcIoFilterType;
-	readonly name: string;
-	readonly dataProvider: VcIoFilterType;
+declare class VcIoFilterType implements IPseudoEnum {
+	static readonly replication: VcIoFilterType & EnumVal<'replication'>;
+	static readonly cache: VcIoFilterType & EnumVal<'cache'>;
+	static readonly datastoreIoControl: VcIoFilterType & EnumVal<'datastoreIoControl'>;
+	static readonly encryption: VcIoFilterType & EnumVal<'encryption'>;
+	static readonly dataProvider: VcIoFilterType & EnumVal<'dataProvider'>;
+	static readonly compression: VcIoFilterType & EnumVal<'compression'>;
+	static readonly inspection: VcIoFilterType & EnumVal<'inspection'>;
+	static fromString(value: string): VcIoFilterType & EnumVal<TcleanKeys<typeof VcIoFilterType>>;
+
 	readonly id: string;
-	readonly compression: VcIoFilterType;
+	readonly name: string;
 	readonly value: string;
-	readonly inspection: VcIoFilterType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcIoFilterType): VcIoFilterType;
+	toString: () => string;
 }
 
 /**
  * Defines a host's connection state.
  */
-declare class VcHostSystemConnectionState {
-	readonly connected: VcHostSystemConnectionState;
-	readonly notResponding: VcHostSystemConnectionState;
-	readonly disconnected: VcHostSystemConnectionState;
-	readonly name: string;
+declare class VcHostSystemConnectionState implements IPseudoEnum {
+	static readonly connected: VcHostSystemConnectionState & EnumVal<'connected'>;
+	static readonly notResponding: VcHostSystemConnectionState & EnumVal<'notResponding'>;
+	static readonly disconnected: VcHostSystemConnectionState & EnumVal<'disconnected'>;
+	static fromString(value: string): VcHostSystemConnectionState & EnumVal<TcleanKeys<typeof VcHostSystemConnectionState>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostSystemConnectionState): VcHostSystemConnectionState;
+	toString: () => string;
 }
 
 /**
  * Enum describing the different IP allocation modes supported on a given network.
  */
-declare class VcVdcsIpAddressingMode {
-	readonly name: string;
-	readonly POOL: VcVdcsIpAddressingMode;
-	readonly MANUAL: VcVdcsIpAddressingMode;
+declare class VcVdcsIpAddressingMode implements IPseudoEnum {
+	static readonly POOL: VcVdcsIpAddressingMode & EnumVal<'POOL'>;
+	static readonly MANUAL: VcVdcsIpAddressingMode & EnumVal<'MANUAL'>;
+	static readonly DHCP: VcVdcsIpAddressingMode & EnumVal<'DHCP'>;
+	static fromString(value: string): VcVdcsIpAddressingMode & EnumVal<TcleanKeys<typeof VcVdcsIpAddressingMode>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly DHCP: VcVdcsIpAddressingMode;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVdcsIpAddressingMode): VcVdcsIpAddressingMode;
+	toString: () => string;
 }
 
 /**
  * Load balance algorithm in a Link Aggregation Control Protocol group.
  */
-declare class VcVMwareDvsLacpLoadBalanceAlgorithm {
-	readonly destIp: VcVMwareDvsLacpLoadBalanceAlgorithm;
-	readonly destIpVlan: VcVMwareDvsLacpLoadBalanceAlgorithm;
-	readonly srcIp: VcVMwareDvsLacpLoadBalanceAlgorithm;
-	readonly srcPortId: VcVMwareDvsLacpLoadBalanceAlgorithm;
-	readonly srcDestTcpUdpPort: VcVMwareDvsLacpLoadBalanceAlgorithm;
-	readonly srcTcpUdpPort: VcVMwareDvsLacpLoadBalanceAlgorithm;
-	readonly srcIpTcpUdpPortVlan: VcVMwareDvsLacpLoadBalanceAlgorithm;
-	readonly destIpTcpUdpPortVlan: VcVMwareDvsLacpLoadBalanceAlgorithm;
-	readonly vlan: VcVMwareDvsLacpLoadBalanceAlgorithm;
-	readonly destIpTcpUdpPort: VcVMwareDvsLacpLoadBalanceAlgorithm;
-	readonly srcDestIp: VcVMwareDvsLacpLoadBalanceAlgorithm;
-	readonly srcDestIpTcpUdpPortVlan: VcVMwareDvsLacpLoadBalanceAlgorithm;
-	readonly name: string;
-	readonly srcDestIpVlan: VcVMwareDvsLacpLoadBalanceAlgorithm;
-	readonly srcMac: VcVMwareDvsLacpLoadBalanceAlgorithm;
+declare class VcVMwareDvsLacpLoadBalanceAlgorithm implements IPseudoEnum {
+	static readonly destIp: VcVMwareDvsLacpLoadBalanceAlgorithm & EnumVal<'destIp'>;
+	static readonly destIpVlan: VcVMwareDvsLacpLoadBalanceAlgorithm & EnumVal<'destIpVlan'>;
+	static readonly srcIp: VcVMwareDvsLacpLoadBalanceAlgorithm & EnumVal<'srcIp'>;
+	static readonly srcPortId: VcVMwareDvsLacpLoadBalanceAlgorithm & EnumVal<'srcPortId'>;
+	static readonly srcDestTcpUdpPort: VcVMwareDvsLacpLoadBalanceAlgorithm & EnumVal<'srcDestTcpUdpPort'>;
+	static readonly srcTcpUdpPort: VcVMwareDvsLacpLoadBalanceAlgorithm & EnumVal<'srcTcpUdpPort'>;
+	static readonly srcIpTcpUdpPortVlan: VcVMwareDvsLacpLoadBalanceAlgorithm & EnumVal<'srcIpTcpUdpPortVlan'>;
+	static readonly destIpTcpUdpPortVlan: VcVMwareDvsLacpLoadBalanceAlgorithm & EnumVal<'destIpTcpUdpPortVlan'>;
+	static readonly vlan: VcVMwareDvsLacpLoadBalanceAlgorithm & EnumVal<'vlan'>;
+	static readonly destIpTcpUdpPort: VcVMwareDvsLacpLoadBalanceAlgorithm & EnumVal<'destIpTcpUdpPort'>;
+	static readonly srcDestIp: VcVMwareDvsLacpLoadBalanceAlgorithm & EnumVal<'srcDestIp'>;
+	static readonly srcDestIpTcpUdpPortVlan: VcVMwareDvsLacpLoadBalanceAlgorithm & EnumVal<'srcDestIpTcpUdpPortVlan'>;
+	static readonly srcDestIpVlan: VcVMwareDvsLacpLoadBalanceAlgorithm & EnumVal<'srcDestIpVlan'>;
+	static readonly srcMac: VcVMwareDvsLacpLoadBalanceAlgorithm & EnumVal<'srcMac'>;
+	static readonly srcIpTcpUdpPort: VcVMwareDvsLacpLoadBalanceAlgorithm & EnumVal<'srcIpTcpUdpPort'>;
+	static readonly srcDestIpTcpUdpPort: VcVMwareDvsLacpLoadBalanceAlgorithm & EnumVal<'srcDestIpTcpUdpPort'>;
+	static readonly destMac: VcVMwareDvsLacpLoadBalanceAlgorithm & EnumVal<'destMac'>;
+	static readonly srcDestMac: VcVMwareDvsLacpLoadBalanceAlgorithm & EnumVal<'srcDestMac'>;
+	static readonly srcIpVlan: VcVMwareDvsLacpLoadBalanceAlgorithm & EnumVal<'srcIpVlan'>;
+	static readonly destTcpUdpPort: VcVMwareDvsLacpLoadBalanceAlgorithm & EnumVal<'destTcpUdpPort'>;
+	static fromString(value: string): VcVMwareDvsLacpLoadBalanceAlgorithm & EnumVal<TcleanKeys<typeof VcVMwareDvsLacpLoadBalanceAlgorithm>>;
+
 	readonly id: string;
-	readonly srcIpTcpUdpPort: VcVMwareDvsLacpLoadBalanceAlgorithm;
-	readonly srcDestIpTcpUdpPort: VcVMwareDvsLacpLoadBalanceAlgorithm;
+	readonly name: string;
 	readonly value: string;
-	readonly destMac: VcVMwareDvsLacpLoadBalanceAlgorithm;
-	readonly srcDestMac: VcVMwareDvsLacpLoadBalanceAlgorithm;
-	readonly srcIpVlan: VcVMwareDvsLacpLoadBalanceAlgorithm;
-	readonly destTcpUdpPort: VcVMwareDvsLacpLoadBalanceAlgorithm;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVMwareDvsLacpLoadBalanceAlgorithm): VcVMwareDvsLacpLoadBalanceAlgorithm;
+	toString: () => string;
 }
 
 /**
  * List of possible states of a task.
  */
-declare class VcTaskInfoState {
-	readonly running: VcTaskInfoState;
-	readonly success: VcTaskInfoState;
-	readonly queued: VcTaskInfoState;
-	readonly name: string;
+declare class VcTaskInfoState implements IPseudoEnum {
+	static readonly running: VcTaskInfoState & EnumVal<'running'>;
+	static readonly success: VcTaskInfoState & EnumVal<'success'>;
+	static readonly queued: VcTaskInfoState & EnumVal<'queued'>;
+	static readonly error: VcTaskInfoState & EnumVal<'error'>;
+	static fromString(value: string): VcTaskInfoState & EnumVal<TcleanKeys<typeof VcTaskInfoState>>;
+
 	readonly id: string;
-	readonly error: VcTaskInfoState;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcTaskInfoState): VcTaskInfoState;
+	toString: () => string;
 }
 
 /**
  * Enumeration of the supported Entity Type values.
  */
-declare class SmsEntityType {
-	readonly CapabilityProfileEntity: SmsEntityType;
-	readonly StorageProcessorEntity: SmsEntityType;
-	readonly ProtocolEndpointEntity: SmsEntityType;
-	readonly StorageFileSystemEntity: SmsEntityType;
-	readonly MessageCatalogEntity: SmsEntityType;
-	readonly StorageObjectEntity: SmsEntityType;
-	readonly BackingStoragePoolEntity: SmsEntityType;
-	readonly FaultDomainEntity: SmsEntityType;
-	readonly ReplicationGroupEntity: SmsEntityType;
-	readonly ResourceAssociationEntity: SmsEntityType;
-	readonly CapabilitySchemaEntity: SmsEntityType;
-	readonly VirtualVolumeInfoEntity: SmsEntityType;
-	readonly StorageArrayEntity: SmsEntityType;
-	readonly StoragePortEntity: SmsEntityType;
-	readonly name: string;
-	readonly StorageContainerEntity: SmsEntityType;
-	readonly StorageCapabilityEntity: SmsEntityType;
-	readonly DefaultProfileEntity: SmsEntityType;
+declare class SmsEntityType implements IPseudoEnum {
+	static readonly CapabilityProfileEntity: SmsEntityType & EnumVal<'CapabilityProfileEntity'>;
+	static readonly StorageProcessorEntity: SmsEntityType & EnumVal<'StorageProcessorEntity'>;
+	static readonly ProtocolEndpointEntity: SmsEntityType & EnumVal<'ProtocolEndpointEntity'>;
+	static readonly StorageFileSystemEntity: SmsEntityType & EnumVal<'StorageFileSystemEntity'>;
+	static readonly MessageCatalogEntity: SmsEntityType & EnumVal<'MessageCatalogEntity'>;
+	static readonly StorageObjectEntity: SmsEntityType & EnumVal<'StorageObjectEntity'>;
+	static readonly BackingStoragePoolEntity: SmsEntityType & EnumVal<'BackingStoragePoolEntity'>;
+	static readonly FaultDomainEntity: SmsEntityType & EnumVal<'FaultDomainEntity'>;
+	static readonly ReplicationGroupEntity: SmsEntityType & EnumVal<'ReplicationGroupEntity'>;
+	static readonly ResourceAssociationEntity: SmsEntityType & EnumVal<'ResourceAssociationEntity'>;
+	static readonly CapabilitySchemaEntity: SmsEntityType & EnumVal<'CapabilitySchemaEntity'>;
+	static readonly VirtualVolumeInfoEntity: SmsEntityType & EnumVal<'VirtualVolumeInfoEntity'>;
+	static readonly StorageArrayEntity: SmsEntityType & EnumVal<'StorageArrayEntity'>;
+	static readonly StoragePortEntity: SmsEntityType & EnumVal<'StoragePortEntity'>;
+	static readonly StorageContainerEntity: SmsEntityType & EnumVal<'StorageContainerEntity'>;
+	static readonly StorageCapabilityEntity: SmsEntityType & EnumVal<'StorageCapabilityEntity'>;
+	static readonly DefaultProfileEntity: SmsEntityType & EnumVal<'DefaultProfileEntity'>;
+	static readonly StorageLunEntity: SmsEntityType & EnumVal<'StorageLunEntity'>;
+	static fromString(value: string): SmsEntityType & EnumVal<TcleanKeys<typeof SmsEntityType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly StorageLunEntity: SmsEntityType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: SmsEntityType): SmsEntityType;
+	toString: () => string;
 }
 
 /**
  * Possible SCSI classes.
  */
-declare class VcVirtualMachineScsiPassthroughType {
-	readonly com: VcVirtualMachineScsiPassthroughType;
-	readonly worm: VcVirtualMachineScsiPassthroughType;
-	readonly printer: VcVirtualMachineScsiPassthroughType;
-	readonly media: VcVirtualMachineScsiPassthroughType;
-	readonly processor: VcVirtualMachineScsiPassthroughType;
-	readonly cdrom: VcVirtualMachineScsiPassthroughType;
-	readonly unknown: VcVirtualMachineScsiPassthroughType;
-	readonly disk: VcVirtualMachineScsiPassthroughType;
-	readonly tape: VcVirtualMachineScsiPassthroughType;
-	readonly scanner: VcVirtualMachineScsiPassthroughType;
-	readonly name: string;
+declare class VcVirtualMachineScsiPassthroughType implements IPseudoEnum {
+	static readonly com: VcVirtualMachineScsiPassthroughType & EnumVal<'com'>;
+	static readonly worm: VcVirtualMachineScsiPassthroughType & EnumVal<'worm'>;
+	static readonly printer: VcVirtualMachineScsiPassthroughType & EnumVal<'printer'>;
+	static readonly media: VcVirtualMachineScsiPassthroughType & EnumVal<'media'>;
+	static readonly processor: VcVirtualMachineScsiPassthroughType & EnumVal<'processor'>;
+	static readonly cdrom: VcVirtualMachineScsiPassthroughType & EnumVal<'cdrom'>;
+	static readonly unknown: VcVirtualMachineScsiPassthroughType & EnumVal<'unknown'>;
+	static readonly disk: VcVirtualMachineScsiPassthroughType & EnumVal<'disk'>;
+	static readonly tape: VcVirtualMachineScsiPassthroughType & EnumVal<'tape'>;
+	static readonly scanner: VcVirtualMachineScsiPassthroughType & EnumVal<'scanner'>;
+	static readonly optical: VcVirtualMachineScsiPassthroughType & EnumVal<'optical'>;
+	static readonly raid: VcVirtualMachineScsiPassthroughType & EnumVal<'raid'>;
+	static fromString(value: string): VcVirtualMachineScsiPassthroughType & EnumVal<TcleanKeys<typeof VcVirtualMachineScsiPassthroughType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly optical: VcVirtualMachineScsiPassthroughType;
-	readonly raid: VcVirtualMachineScsiPassthroughType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineScsiPassthroughType): VcVirtualMachineScsiPassthroughType;
+	toString: () => string;
 }
 
 /**
@@ -2940,87 +2791,82 @@ declare class VcVirtualMachineScsiPassthroughType {
  * it determines whether the storage device supports hardware acceleration
  * and sets the {@link ScsiLun#vStorageSupport} property accordingly.
  */
-declare class VcScsiLunVStorageSupportStatus {
-	readonly name: string;
-	readonly vStorageUnsupported: VcScsiLunVStorageSupportStatus;
+declare class VcScsiLunVStorageSupportStatus implements IPseudoEnum {
+	static readonly vStorageUnsupported: VcScsiLunVStorageSupportStatus & EnumVal<'vStorageUnsupported'>;
+	static readonly vStorageSupported: VcScsiLunVStorageSupportStatus & EnumVal<'vStorageSupported'>;
+	static readonly vStorageUnknown: VcScsiLunVStorageSupportStatus & EnumVal<'vStorageUnknown'>;
+	static fromString(value: string): VcScsiLunVStorageSupportStatus & EnumVal<TcleanKeys<typeof VcScsiLunVStorageSupportStatus>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly vStorageSupported: VcScsiLunVStorageSupportStatus;
-	readonly vStorageUnknown: VcScsiLunVStorageSupportStatus;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcScsiLunVStorageSupportStatus): VcScsiLunVStorageSupportStatus;
+	toString: () => string;
 }
 
 /**
  * Possible values for shared passthrough assignment policy
  */
-declare class VcHostGraphicsConfigSharedPassthruAssignmentPolicy {
-	readonly performance: VcHostGraphicsConfigSharedPassthruAssignmentPolicy;
-	readonly name: string;
+declare class VcHostGraphicsConfigSharedPassthruAssignmentPolicy implements IPseudoEnum {
+	static readonly performance: VcHostGraphicsConfigSharedPassthruAssignmentPolicy & EnumVal<'performance'>;
+	static readonly consolidation: VcHostGraphicsConfigSharedPassthruAssignmentPolicy & EnumVal<'consolidation'>;
+	static fromString(value: string): VcHostGraphicsConfigSharedPassthruAssignmentPolicy & EnumVal<TcleanKeys<typeof VcHostGraphicsConfigSharedPassthruAssignmentPolicy>>;
+
 	readonly id: string;
-	readonly consolidation: VcHostGraphicsConfigSharedPassthruAssignmentPolicy;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostGraphicsConfigSharedPassthruAssignmentPolicy): VcHostGraphicsConfigSharedPassthruAssignmentPolicy;
+	toString: () => string;
 }
 
 /**
  * These are the constraint relationships between software packages.
  */
-declare class VcSoftwarePackageConstraint {
-	readonly lessThanEqual: VcSoftwarePackageConstraint;
-	readonly greaterThanEqual: VcSoftwarePackageConstraint;
-	readonly equals: VcSoftwarePackageConstraint;
-	readonly lessThan: VcSoftwarePackageConstraint;
-	readonly name: string;
+declare class VcSoftwarePackageConstraint implements IPseudoEnum {
+	static readonly lessThanEqual: VcSoftwarePackageConstraint & EnumVal<'lessThanEqual'>;
+	static readonly greaterThanEqual: VcSoftwarePackageConstraint & EnumVal<'greaterThanEqual'>;
+	static readonly equals: VcSoftwarePackageConstraint & EnumVal<'equals'>;
+	static readonly lessThan: VcSoftwarePackageConstraint & EnumVal<'lessThan'>;
+	static readonly greaterThan: VcSoftwarePackageConstraint & EnumVal<'greaterThan'>;
+	static fromString(value: string): VcSoftwarePackageConstraint & EnumVal<TcleanKeys<typeof VcSoftwarePackageConstraint>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly greaterThan: VcSoftwarePackageConstraint;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcSoftwarePackageConstraint): VcSoftwarePackageConstraint;
+	toString: () => string;
 }
 
 /**
  * Type of disk group operation performed.
  */
-declare class VcVsanUpgradeSystemUpgradeHistoryDiskGroupOpType {
-	readonly add: VcVsanUpgradeSystemUpgradeHistoryDiskGroupOpType;
-	readonly name: string;
+declare class VcVsanUpgradeSystemUpgradeHistoryDiskGroupOpType implements IPseudoEnum {
+	static readonly add: VcVsanUpgradeSystemUpgradeHistoryDiskGroupOpType & EnumVal<'add'>;
+	static readonly remove: VcVsanUpgradeSystemUpgradeHistoryDiskGroupOpType & EnumVal<'remove'>;
+	static fromString(value: string): VcVsanUpgradeSystemUpgradeHistoryDiskGroupOpType & EnumVal<TcleanKeys<typeof VcVsanUpgradeSystemUpgradeHistoryDiskGroupOpType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly remove: VcVsanUpgradeSystemUpgradeHistoryDiskGroupOpType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVsanUpgradeSystemUpgradeHistoryDiskGroupOpType): VcVsanUpgradeSystemUpgradeHistoryDiskGroupOpType;
+	toString: () => string;
 }
 
-declare class VcNetIpConfigInfoIpAddressStatus {
-	readonly inaccessible: VcNetIpConfigInfoIpAddressStatus;
-	readonly deprecated: VcNetIpConfigInfoIpAddressStatus;
-	readonly invalid: VcNetIpConfigInfoIpAddressStatus;
-	readonly name: string;
-	readonly tentative: VcNetIpConfigInfoIpAddressStatus;
-	readonly duplicate: VcNetIpConfigInfoIpAddressStatus;
+declare class VcNetIpConfigInfoIpAddressStatus implements IPseudoEnum {
+	static readonly inaccessible: VcNetIpConfigInfoIpAddressStatus & EnumVal<'inaccessible'>;
+	static readonly deprecated: VcNetIpConfigInfoIpAddressStatus & EnumVal<'deprecated'>;
+	static readonly invalid: VcNetIpConfigInfoIpAddressStatus & EnumVal<'invalid'>;
+	static readonly tentative: VcNetIpConfigInfoIpAddressStatus & EnumVal<'tentative'>;
+	static readonly duplicate: VcNetIpConfigInfoIpAddressStatus & EnumVal<'duplicate'>;
+	static readonly preferred: VcNetIpConfigInfoIpAddressStatus & EnumVal<'preferred'>;
+	static readonly unknown: VcNetIpConfigInfoIpAddressStatus & EnumVal<'unknown'>;
+	static fromString(value: string): VcNetIpConfigInfoIpAddressStatus & EnumVal<TcleanKeys<typeof VcNetIpConfigInfoIpAddressStatus>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly preferred: VcNetIpConfigInfoIpAddressStatus;
-	readonly unknown: VcNetIpConfigInfoIpAddressStatus;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcNetIpConfigInfoIpAddressStatus): VcNetIpConfigInfoIpAddressStatus;
+	toString: () => string;
 }
 
 /**
@@ -3028,150 +2874,142 @@ declare class VcNetIpConfigInfoIpAddressStatus {
  * that the host is only exiting the quarantine state (i.e. not the
  * maintenance mode).
  */
-declare class VcClusterHostInfraUpdateHaModeActionOperationType {
-	readonly enterMaintenance: VcClusterHostInfraUpdateHaModeActionOperationType;
-	readonly exitQuarantine: VcClusterHostInfraUpdateHaModeActionOperationType;
-	readonly enterQuarantine: VcClusterHostInfraUpdateHaModeActionOperationType;
-	readonly name: string;
+declare class VcClusterHostInfraUpdateHaModeActionOperationType implements IPseudoEnum {
+	static readonly enterMaintenance: VcClusterHostInfraUpdateHaModeActionOperationType & EnumVal<'enterMaintenance'>;
+	static readonly exitQuarantine: VcClusterHostInfraUpdateHaModeActionOperationType & EnumVal<'exitQuarantine'>;
+	static readonly enterQuarantine: VcClusterHostInfraUpdateHaModeActionOperationType & EnumVal<'enterQuarantine'>;
+	static fromString(value: string): VcClusterHostInfraUpdateHaModeActionOperationType & EnumVal<TcleanKeys<typeof VcClusterHostInfraUpdateHaModeActionOperationType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcClusterHostInfraUpdateHaModeActionOperationType): VcClusterHostInfraUpdateHaModeActionOperationType;
+	toString: () => string;
 }
 
 /**
  * Means for allocating additional memory for virtual machines.
  */
-declare class VcVirtualMachineMemoryAllocationPolicy {
-	readonly swapSome: VcVirtualMachineMemoryAllocationPolicy;
-	readonly swapMost: VcVirtualMachineMemoryAllocationPolicy;
-	readonly name: string;
-	readonly swapNone: VcVirtualMachineMemoryAllocationPolicy;
+declare class VcVirtualMachineMemoryAllocationPolicy implements IPseudoEnum {
+	static readonly swapSome: VcVirtualMachineMemoryAllocationPolicy & EnumVal<'swapSome'>;
+	static readonly swapMost: VcVirtualMachineMemoryAllocationPolicy & EnumVal<'swapMost'>;
+	static readonly swapNone: VcVirtualMachineMemoryAllocationPolicy & EnumVal<'swapNone'>;
+	static fromString(value: string): VcVirtualMachineMemoryAllocationPolicy & EnumVal<TcleanKeys<typeof VcVirtualMachineMemoryAllocationPolicy>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineMemoryAllocationPolicy): VcVirtualMachineMemoryAllocationPolicy;
+	toString: () => string;
 }
 
 /**
  * Reasons why a virtual device would not be supported on a host.
  */
-declare class VcDeviceNotSupportedReason {
-	readonly host: VcDeviceNotSupportedReason;
-	readonly name: string;
-	readonly guest: VcDeviceNotSupportedReason;
+declare class VcDeviceNotSupportedReason implements IPseudoEnum {
+	static readonly host: VcDeviceNotSupportedReason & EnumVal<'host'>;
+	static readonly guest: VcDeviceNotSupportedReason & EnumVal<'guest'>;
+	static fromString(value: string): VcDeviceNotSupportedReason & EnumVal<TcleanKeys<typeof VcDeviceNotSupportedReason>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDeviceNotSupportedReason): VcDeviceNotSupportedReason;
-}
-
-declare class VcVmFaultToleranceConfigIssueReasonForIssue {
-	readonly missingVMotionNic: VcVmFaultToleranceConfigIssueReasonForIssue;
-	readonly hasEFIFirmware: VcVmFaultToleranceConfigIssueReasonForIssue;
-	readonly moreThanOneSecondary: VcVmFaultToleranceConfigIssueReasonForIssue;
-	readonly recordReplayNotSupported: VcVmFaultToleranceConfigIssueReasonForIssue;
-	readonly missingFTLoggingNic: VcVmFaultToleranceConfigIssueReasonForIssue;
-	readonly hasVFlashConfiguration: VcVmFaultToleranceConfigIssueReasonForIssue;
-	readonly replayNotSupported: VcVmFaultToleranceConfigIssueReasonForIssue;
-	readonly hasLocalDisk: VcVmFaultToleranceConfigIssueReasonForIssue;
-	readonly esxAgentVm: VcVmFaultToleranceConfigIssueReasonForIssue;
-	readonly unsupportedProduct: VcVmFaultToleranceConfigIssueReasonForIssue;
-	readonly ftUnsupportedProduct: VcVmFaultToleranceConfigIssueReasonForIssue;
-	readonly ftUnsupportedHardware: VcVmFaultToleranceConfigIssueReasonForIssue;
-	readonly hostInactive: VcVmFaultToleranceConfigIssueReasonForIssue;
-	readonly hasNestedHVConfiguration: VcVmFaultToleranceConfigIssueReasonForIssue;
-	readonly ftSecondaryVm: VcVmFaultToleranceConfigIssueReasonForIssue;
-	readonly hasSnapshots: VcVmFaultToleranceConfigIssueReasonForIssue;
-	readonly noConfig: VcVmFaultToleranceConfigIssueReasonForIssue;
-	readonly video3dEnabled: VcVmFaultToleranceConfigIssueReasonForIssue;
-	readonly insufficientBandwidth: VcVmFaultToleranceConfigIssueReasonForIssue;
+	toString: () => string;
+}
+
+declare class VcVmFaultToleranceConfigIssueReasonForIssue implements IPseudoEnum {
+	static readonly missingVMotionNic: VcVmFaultToleranceConfigIssueReasonForIssue & EnumVal<'missingVMotionNic'>;
+	static readonly hasEFIFirmware: VcVmFaultToleranceConfigIssueReasonForIssue & EnumVal<'hasEFIFirmware'>;
+	static readonly moreThanOneSecondary: VcVmFaultToleranceConfigIssueReasonForIssue & EnumVal<'moreThanOneSecondary'>;
+	static readonly recordReplayNotSupported: VcVmFaultToleranceConfigIssueReasonForIssue & EnumVal<'recordReplayNotSupported'>;
+	static readonly missingFTLoggingNic: VcVmFaultToleranceConfigIssueReasonForIssue & EnumVal<'missingFTLoggingNic'>;
+	static readonly hasVFlashConfiguration: VcVmFaultToleranceConfigIssueReasonForIssue & EnumVal<'hasVFlashConfiguration'>;
+	static readonly replayNotSupported: VcVmFaultToleranceConfigIssueReasonForIssue & EnumVal<'replayNotSupported'>;
+	static readonly hasLocalDisk: VcVmFaultToleranceConfigIssueReasonForIssue & EnumVal<'hasLocalDisk'>;
+	static readonly esxAgentVm: VcVmFaultToleranceConfigIssueReasonForIssue & EnumVal<'esxAgentVm'>;
+	static readonly unsupportedProduct: VcVmFaultToleranceConfigIssueReasonForIssue & EnumVal<'unsupportedProduct'>;
+	static readonly ftUnsupportedProduct: VcVmFaultToleranceConfigIssueReasonForIssue & EnumVal<'ftUnsupportedProduct'>;
+	static readonly ftUnsupportedHardware: VcVmFaultToleranceConfigIssueReasonForIssue & EnumVal<'ftUnsupportedHardware'>;
+	static readonly hostInactive: VcVmFaultToleranceConfigIssueReasonForIssue & EnumVal<'hostInactive'>;
+	static readonly hasNestedHVConfiguration: VcVmFaultToleranceConfigIssueReasonForIssue & EnumVal<'hasNestedHVConfiguration'>;
+	static readonly ftSecondaryVm: VcVmFaultToleranceConfigIssueReasonForIssue & EnumVal<'ftSecondaryVm'>;
+	static readonly hasSnapshots: VcVmFaultToleranceConfigIssueReasonForIssue & EnumVal<'hasSnapshots'>;
+	static readonly noConfig: VcVmFaultToleranceConfigIssueReasonForIssue & EnumVal<'noConfig'>;
+	static readonly video3dEnabled: VcVmFaultToleranceConfigIssueReasonForIssue & EnumVal<'video3dEnabled'>;
+	static readonly insufficientBandwidth: VcVmFaultToleranceConfigIssueReasonForIssue & EnumVal<'insufficientBandwidth'>;
+	static readonly cpuHwmmuUnsupported: VcVmFaultToleranceConfigIssueReasonForIssue & EnumVal<'cpuHwmmuUnsupported'>;
+	static readonly haNotEnabled: VcVmFaultToleranceConfigIssueReasonForIssue & EnumVal<'haNotEnabled'>;
+	static readonly templateVm: VcVmFaultToleranceConfigIssueReasonForIssue & EnumVal<'templateVm'>;
+	static readonly cpuHvUnsupported: VcVmFaultToleranceConfigIssueReasonForIssue & EnumVal<'cpuHvUnsupported'>;
+	static readonly cpuHvDisabled: VcVmFaultToleranceConfigIssueReasonForIssue & EnumVal<'cpuHvDisabled'>;
+	static readonly hasUnsupportedDisk: VcVmFaultToleranceConfigIssueReasonForIssue & EnumVal<'hasUnsupportedDisk'>;
+	static readonly multipleVCPU: VcVmFaultToleranceConfigIssueReasonForIssue & EnumVal<'multipleVCPU'>;
+	static readonly thinDisk: VcVmFaultToleranceConfigIssueReasonForIssue & EnumVal<'thinDisk'>;
+	static readonly verifySSLCertificateFlagNotSet: VcVmFaultToleranceConfigIssueReasonForIssue & EnumVal<'verifySSLCertificateFlagNotSet'>;
+	static fromString(value: string): VcVmFaultToleranceConfigIssueReasonForIssue & EnumVal<TcleanKeys<typeof VcVmFaultToleranceConfigIssueReasonForIssue>>;
+
 	readonly id: string;
-	readonly value: string;
-	readonly cpuHwmmuUnsupported: VcVmFaultToleranceConfigIssueReasonForIssue;
-	readonly haNotEnabled: VcVmFaultToleranceConfigIssueReasonForIssue;
-	readonly templateVm: VcVmFaultToleranceConfigIssueReasonForIssue;
-	readonly cpuHvUnsupported: VcVmFaultToleranceConfigIssueReasonForIssue;
-	readonly cpuHvDisabled: VcVmFaultToleranceConfigIssueReasonForIssue;
-	readonly hasUnsupportedDisk: VcVmFaultToleranceConfigIssueReasonForIssue;
 	readonly name: string;
-	readonly multipleVCPU: VcVmFaultToleranceConfigIssueReasonForIssue;
-	readonly thinDisk: VcVmFaultToleranceConfigIssueReasonForIssue;
-	readonly verifySSLCertificateFlagNotSet: VcVmFaultToleranceConfigIssueReasonForIssue;
+	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVmFaultToleranceConfigIssueReasonForIssue): VcVmFaultToleranceConfigIssueReasonForIssue;
+	toString: () => string;
 }
 
-declare class VcComplianceResultStatus {
-	readonly name: string;
-	readonly compliant: VcComplianceResultStatus;
+declare class VcComplianceResultStatus implements IPseudoEnum {
+	static readonly compliant: VcComplianceResultStatus & EnumVal<'compliant'>;
+	static readonly nonCompliant: VcComplianceResultStatus & EnumVal<'nonCompliant'>;
+	static readonly unknown: VcComplianceResultStatus & EnumVal<'unknown'>;
+	static fromString(value: string): VcComplianceResultStatus & EnumVal<TcleanKeys<typeof VcComplianceResultStatus>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly nonCompliant: VcComplianceResultStatus;
-	readonly unknown: VcComplianceResultStatus;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcComplianceResultStatus): VcComplianceResultStatus;
+	toString: () => string;
 }
 
 /**
  * NetBIOS setting for Windows.
  */
-declare class VcCustomizationNetBIOSMode {
-	readonly enableNetBIOSViaDhcp: VcCustomizationNetBIOSMode;
-	readonly enableNetBIOS: VcCustomizationNetBIOSMode;
-	readonly name: string;
-	readonly disableNetBIOS: VcCustomizationNetBIOSMode;
+declare class VcCustomizationNetBIOSMode implements IPseudoEnum {
+	static readonly enableNetBIOSViaDhcp: VcCustomizationNetBIOSMode & EnumVal<'enableNetBIOSViaDhcp'>;
+	static readonly enableNetBIOS: VcCustomizationNetBIOSMode & EnumVal<'enableNetBIOS'>;
+	static readonly disableNetBIOS: VcCustomizationNetBIOSMode & EnumVal<'disableNetBIOS'>;
+	static fromString(value: string): VcCustomizationNetBIOSMode & EnumVal<TcleanKeys<typeof VcCustomizationNetBIOSMode>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcCustomizationNetBIOSMode): VcCustomizationNetBIOSMode;
+	toString: () => string;
 }
 
-declare class VcDatastoreAccessible {
-	readonly name: string;
-	readonly True: VcDatastoreAccessible;
-	readonly False: VcDatastoreAccessible;
+declare class VcDatastoreAccessible implements IPseudoEnum {
+	static readonly True: VcDatastoreAccessible & EnumVal<'True'>;
+	static readonly False: VcDatastoreAccessible & EnumVal<'False'>;
+	static fromString(value: string): VcDatastoreAccessible & EnumVal<TcleanKeys<typeof VcDatastoreAccessible>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDatastoreAccessible): VcDatastoreAccessible;
+	toString: () => string;
 }
 
-declare class VcHostVMotionManagerVMotionType {
-	readonly memory_mirror: VcHostVMotionManagerVMotionType;
-	readonly fast_suspend_resume: VcHostVMotionManagerVMotionType;
-	readonly name: string;
-	readonly disks_only: VcHostVMotionManagerVMotionType;
+declare class VcHostVMotionManagerVMotionType implements IPseudoEnum {
+	static readonly memory_mirror: VcHostVMotionManagerVMotionType & EnumVal<'memory_mirror'>;
+	static readonly fast_suspend_resume: VcHostVMotionManagerVMotionType & EnumVal<'fast_suspend_resume'>;
+	static readonly disks_only: VcHostVMotionManagerVMotionType & EnumVal<'disks_only'>;
+	static readonly vmotion: VcHostVMotionManagerVMotionType & EnumVal<'vmotion'>;
+	static readonly fault_tolerance: VcHostVMotionManagerVMotionType & EnumVal<'fault_tolerance'>;
+	static fromString(value: string): VcHostVMotionManagerVMotionType & EnumVal<TcleanKeys<typeof VcHostVMotionManagerVMotionType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly vmotion: VcHostVMotionManagerVMotionType;
-	readonly fault_tolerance: VcHostVMotionManagerVMotionType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostVMotionManagerVMotionType): VcHostVMotionManagerVMotionType;
+	toString: () => string;
 }
 
 /**
@@ -3180,35 +3018,33 @@ declare class VcHostVMotionManagerVMotionType {
  * operation. The result data is contained in the
  * {@link vim.profile.host.ExecuteResult} data object.
  */
-declare class VcProfileExecuteResultStatus {
-	readonly needInput: VcProfileExecuteResultStatus;
-	readonly success: VcProfileExecuteResultStatus;
-	readonly name: string;
+declare class VcProfileExecuteResultStatus implements IPseudoEnum {
+	static readonly needInput: VcProfileExecuteResultStatus & EnumVal<'needInput'>;
+	static readonly success: VcProfileExecuteResultStatus & EnumVal<'success'>;
+	static readonly error: VcProfileExecuteResultStatus & EnumVal<'error'>;
+	static fromString(value: string): VcProfileExecuteResultStatus & EnumVal<TcleanKeys<typeof VcProfileExecuteResultStatus>>;
+
 	readonly id: string;
-	readonly error: VcProfileExecuteResultStatus;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcProfileExecuteResultStatus): VcProfileExecuteResultStatus;
+	toString: () => string;
 }
 
 /**
  * VchaClusterMode enum defines the possible modes for a VCHA Cluster.
  */
-declare class VcVchaClusterMode {
-	readonly name: string;
-	readonly disabled: VcVchaClusterMode;
+declare class VcVchaClusterMode implements IPseudoEnum {
+	static readonly disabled: VcVchaClusterMode & EnumVal<'disabled'>;
+	static readonly maintenance: VcVchaClusterMode & EnumVal<'maintenance'>;
+	static readonly enabled: VcVchaClusterMode & EnumVal<'enabled'>;
+	static fromString(value: string): VcVchaClusterMode & EnumVal<TcleanKeys<typeof VcVchaClusterMode>>;
+
 	readonly id: string;
-	readonly maintenance: VcVchaClusterMode;
+	readonly name: string;
 	readonly value: string;
-	readonly enabled: VcVchaClusterMode;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVchaClusterMode): VcVchaClusterMode;
+	toString: () => string;
 }
 
 /**
@@ -3233,22 +3069,21 @@ declare class VcVchaClusterMode {
  * vCenter Server will publish an alarm and indicate via the UI that the
  * certificate expiration is imminent.
  */
-declare class VcHostCertificateManagerCertificateInfoCertificateStatus {
-	readonly expiringShortly: VcHostCertificateManagerCertificateInfoCertificateStatus;
-	readonly expiring: VcHostCertificateManagerCertificateInfoCertificateStatus;
-	readonly expired: VcHostCertificateManagerCertificateInfoCertificateStatus;
-	readonly expirationImminent: VcHostCertificateManagerCertificateInfoCertificateStatus;
-	readonly name: string;
+declare class VcHostCertificateManagerCertificateInfoCertificateStatus implements IPseudoEnum {
+	static readonly expiringShortly: VcHostCertificateManagerCertificateInfoCertificateStatus & EnumVal<'expiringShortly'>;
+	static readonly expiring: VcHostCertificateManagerCertificateInfoCertificateStatus & EnumVal<'expiring'>;
+	static readonly expired: VcHostCertificateManagerCertificateInfoCertificateStatus & EnumVal<'expired'>;
+	static readonly expirationImminent: VcHostCertificateManagerCertificateInfoCertificateStatus & EnumVal<'expirationImminent'>;
+	static readonly revoked: VcHostCertificateManagerCertificateInfoCertificateStatus & EnumVal<'revoked'>;
+	static readonly good: VcHostCertificateManagerCertificateInfoCertificateStatus & EnumVal<'good'>;
+	static readonly unknown: VcHostCertificateManagerCertificateInfoCertificateStatus & EnumVal<'unknown'>;
+	static fromString(value: string): VcHostCertificateManagerCertificateInfoCertificateStatus & EnumVal<TcleanKeys<typeof VcHostCertificateManagerCertificateInfoCertificateStatus>>;
+
 	readonly id: string;
-	readonly revoked: VcHostCertificateManagerCertificateInfoCertificateStatus;
-	readonly good: VcHostCertificateManagerCertificateInfoCertificateStatus;
+	readonly name: string;
 	readonly value: string;
-	readonly unknown: VcHostCertificateManagerCertificateInfoCertificateStatus;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostCertificateManagerCertificateInfoCertificateStatus): VcHostCertificateManagerCertificateInfoCertificateStatus;
+	toString: () => string;
 }
 
 /**
@@ -3260,24 +3095,23 @@ declare class VcHostCertificateManagerCertificateInfoCertificateStatus {
  * <tt>"Alarm - {alarmName} Description:\n{eventDescription}"</tt>.
  * Or a script action provided could be: <tt>"myScript {alarmName}"</tt>
  */
-declare class VcActionParameter {
-	readonly triggeringSummary: VcActionParameter;
-	readonly targetName: VcActionParameter;
-	readonly declaringSummary: VcActionParameter;
-	readonly newStatus: VcActionParameter;
-	readonly oldStatus: VcActionParameter;
-	readonly eventDescription: VcActionParameter;
-	readonly alarm: VcActionParameter;
-	readonly name: string;
-	readonly alarmName: VcActionParameter;
+declare class VcActionParameter implements IPseudoEnum {
+	static readonly triggeringSummary: VcActionParameter & EnumVal<'triggeringSummary'>;
+	static readonly targetName: VcActionParameter & EnumVal<'targetName'>;
+	static readonly declaringSummary: VcActionParameter & EnumVal<'declaringSummary'>;
+	static readonly newStatus: VcActionParameter & EnumVal<'newStatus'>;
+	static readonly oldStatus: VcActionParameter & EnumVal<'oldStatus'>;
+	static readonly eventDescription: VcActionParameter & EnumVal<'eventDescription'>;
+	static readonly alarm: VcActionParameter & EnumVal<'alarm'>;
+	static readonly alarmName: VcActionParameter & EnumVal<'alarmName'>;
+	static readonly target: VcActionParameter & EnumVal<'target'>;
+	static fromString(value: string): VcActionParameter & EnumVal<TcleanKeys<typeof VcActionParameter>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly target: VcActionParameter;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcActionParameter): VcActionParameter;
+	toString: () => string;
 }
 
 /**
@@ -3286,18 +3120,17 @@ declare class VcActionParameter {
  * operations. See {@link ComplianceResult} and
  * {@link pbm.compliance.RollupComplianceResult}.
  */
-declare class PbmComplianceResultComplianceTaskStatus {
-	readonly inProgress: PbmComplianceResultComplianceTaskStatus;
-	readonly success: PbmComplianceResultComplianceTaskStatus;
-	readonly name: string;
-	readonly failed: PbmComplianceResultComplianceTaskStatus;
+declare class PbmComplianceResultComplianceTaskStatus implements IPseudoEnum {
+	static readonly inProgress: PbmComplianceResultComplianceTaskStatus & EnumVal<'inProgress'>;
+	static readonly success: PbmComplianceResultComplianceTaskStatus & EnumVal<'success'>;
+	static readonly failed: PbmComplianceResultComplianceTaskStatus & EnumVal<'failed'>;
+	static fromString(value: string): PbmComplianceResultComplianceTaskStatus & EnumVal<TcleanKeys<typeof PbmComplianceResultComplianceTaskStatus>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: PbmComplianceResultComplianceTaskStatus): PbmComplianceResultComplianceTaskStatus;
+	toString: () => string;
 }
 
 /**
@@ -3306,98 +3139,92 @@ declare class PbmComplianceResultComplianceTaskStatus {
  * object returned as part of a <code>generateConfigTaskList</code>
  * operation.
  */
-declare class VcHostProfileManagerTaskListRequirement {
-	readonly maintenanceModeRequired: VcHostProfileManagerTaskListRequirement;
-	readonly rebootRequired: VcHostProfileManagerTaskListRequirement;
-	readonly name: string;
+declare class VcHostProfileManagerTaskListRequirement implements IPseudoEnum {
+	static readonly maintenanceModeRequired: VcHostProfileManagerTaskListRequirement & EnumVal<'maintenanceModeRequired'>;
+	static readonly rebootRequired: VcHostProfileManagerTaskListRequirement & EnumVal<'rebootRequired'>;
+	static fromString(value: string): VcHostProfileManagerTaskListRequirement & EnumVal<TcleanKeys<typeof VcHostProfileManagerTaskListRequirement>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostProfileManagerTaskListRequirement): VcHostProfileManagerTaskListRequirement;
+	toString: () => string;
 }
 
 /**
  * Internal event type to notify datastore
  */
-declare class VcHostDatastoreSystemDatastoreEventType {
-	readonly PreUnmount: VcHostDatastoreSystemDatastoreEventType;
-	readonly name: string;
+declare class VcHostDatastoreSystemDatastoreEventType implements IPseudoEnum {
+	static readonly PreUnmount: VcHostDatastoreSystemDatastoreEventType & EnumVal<'PreUnmount'>;
+	static readonly VvolFastPolling: VcHostDatastoreSystemDatastoreEventType & EnumVal<'VvolFastPolling'>;
+	static readonly FailedUnmount: VcHostDatastoreSystemDatastoreEventType & EnumVal<'FailedUnmount'>;
+	static fromString(value: string): VcHostDatastoreSystemDatastoreEventType & EnumVal<TcleanKeys<typeof VcHostDatastoreSystemDatastoreEventType>>;
+
 	readonly id: string;
-	readonly VvolFastPolling: VcHostDatastoreSystemDatastoreEventType;
+	readonly name: string;
 	readonly value: string;
-	readonly FailedUnmount: VcHostDatastoreSystemDatastoreEventType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostDatastoreSystemDatastoreEventType): VcHostDatastoreSystemDatastoreEventType;
+	toString: () => string;
 }
 
 /**
  * The policy setting used to determine when tools are auto-upgraded for
  * a virtual machine
  */
-declare class VcUpgradePolicy {
-	readonly upgradeAtPowerCycle: VcUpgradePolicy;
-	readonly name: string;
+declare class VcUpgradePolicy implements IPseudoEnum {
+	static readonly upgradeAtPowerCycle: VcUpgradePolicy & EnumVal<'upgradeAtPowerCycle'>;
+	static readonly manual: VcUpgradePolicy & EnumVal<'manual'>;
+	static fromString(value: string): VcUpgradePolicy & EnumVal<TcleanKeys<typeof VcUpgradePolicy>>;
+
 	readonly id: string;
-	readonly manual: VcUpgradePolicy;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcUpgradePolicy): VcUpgradePolicy;
+	toString: () => string;
 }
 
-declare class VcHostPowerOperationType {
-	readonly powerOn: VcHostPowerOperationType;
-	readonly powerOff: VcHostPowerOperationType;
-	readonly name: string;
+declare class VcHostPowerOperationType implements IPseudoEnum {
+	static readonly powerOn: VcHostPowerOperationType & EnumVal<'powerOn'>;
+	static readonly powerOff: VcHostPowerOperationType & EnumVal<'powerOff'>;
+	static fromString(value: string): VcHostPowerOperationType & EnumVal<TcleanKeys<typeof VcHostPowerOperationType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostPowerOperationType): VcHostPowerOperationType;
+	toString: () => string;
 }
 
 /**
  * Defines a host's standby mode.
  */
-declare class VcHostStandbyMode {
-	readonly entering: VcHostStandbyMode;
-	readonly in: VcHostStandbyMode;
-	readonly name: string;
-	readonly none: VcHostStandbyMode;
+declare class VcHostStandbyMode implements IPseudoEnum {
+	static readonly entering: VcHostStandbyMode & EnumVal<'entering'>;
+	static readonly in: VcHostStandbyMode & EnumVal<'in'>;
+	static readonly none: VcHostStandbyMode & EnumVal<'none'>;
+	static readonly exiting: VcHostStandbyMode & EnumVal<'exiting'>;
+	static fromString(value: string): VcHostStandbyMode & EnumVal<TcleanKeys<typeof VcHostStandbyMode>>;
+
 	readonly id: string;
-	readonly exiting: VcHostStandbyMode;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostStandbyMode): VcHostStandbyMode;
+	toString: () => string;
 }
 
 /**
  * Enum for IP address types.
  */
-declare class VcVdcsIpAddressType {
-	readonly IPV6: VcVdcsIpAddressType;
-	readonly IPV4: VcVdcsIpAddressType;
-	readonly name: string;
+declare class VcVdcsIpAddressType implements IPseudoEnum {
+	static readonly IPV6: VcVdcsIpAddressType & EnumVal<'IPV6'>;
+	static readonly IPV4: VcVdcsIpAddressType & EnumVal<'IPV4'>;
+	static fromString(value: string): VcVdcsIpAddressType & EnumVal<TcleanKeys<typeof VcVdcsIpAddressType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVdcsIpAddressType): VcVdcsIpAddressType;
+	toString: () => string;
 }
 
 /**
@@ -3406,66 +3233,62 @@ declare class VcVdcsIpAddressType {
  * For more information, see
  * {@link vim.StorageResourceManager.IORMConfigInfo#congestionThreshold}
  */
-declare class VcStorageIORMThresholdMode {
-	readonly name: string;
-	readonly automatic: VcStorageIORMThresholdMode;
+declare class VcStorageIORMThresholdMode implements IPseudoEnum {
+	static readonly automatic: VcStorageIORMThresholdMode & EnumVal<'automatic'>;
+	static readonly manual: VcStorageIORMThresholdMode & EnumVal<'manual'>;
+	static fromString(value: string): VcStorageIORMThresholdMode & EnumVal<TcleanKeys<typeof VcStorageIORMThresholdMode>>;
+
 	readonly id: string;
-	readonly manual: VcStorageIORMThresholdMode;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcStorageIORMThresholdMode): VcStorageIORMThresholdMode;
+	toString: () => string;
 }
 
-declare class VcLicenseAssignmentFailedReason {
-	readonly downgradeDisallowed: VcLicenseAssignmentFailedReason;
-	readonly keyEntityMismatch: VcLicenseAssignmentFailedReason;
-	readonly hostsUnmanageableByVirtualCenterWithoutLicenseServer: VcLicenseAssignmentFailedReason;
-	readonly name: string;
-	readonly inventoryNotManageableByVirtualCenter: VcLicenseAssignmentFailedReason;
+declare class VcLicenseAssignmentFailedReason implements IPseudoEnum {
+	static readonly downgradeDisallowed: VcLicenseAssignmentFailedReason & EnumVal<'downgradeDisallowed'>;
+	static readonly keyEntityMismatch: VcLicenseAssignmentFailedReason & EnumVal<'keyEntityMismatch'>;
+	static readonly hostsUnmanageableByVirtualCenterWithoutLicenseServer: VcLicenseAssignmentFailedReason & EnumVal<'hostsUnmanageableByVirtualCenterWithoutLicenseServer'>;
+	static readonly inventoryNotManageableByVirtualCenter: VcLicenseAssignmentFailedReason & EnumVal<'inventoryNotManageableByVirtualCenter'>;
+	static fromString(value: string): VcLicenseAssignmentFailedReason & EnumVal<TcleanKeys<typeof VcLicenseAssignmentFailedReason>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcLicenseAssignmentFailedReason): VcLicenseAssignmentFailedReason;
+	toString: () => string;
 }
 
 /**
  * The policy setting used to determine when to perform scheduled
  * upgrades for a virtual machine.
  */
-declare class VcScheduledHardwareUpgradeInfoHardwareUpgradePolicy {
-	readonly always: VcScheduledHardwareUpgradeInfoHardwareUpgradePolicy;
-	readonly never: VcScheduledHardwareUpgradeInfoHardwareUpgradePolicy;
-	readonly onSoftPowerOff: VcScheduledHardwareUpgradeInfoHardwareUpgradePolicy;
-	readonly name: string;
+declare class VcScheduledHardwareUpgradeInfoHardwareUpgradePolicy implements IPseudoEnum {
+	static readonly always: VcScheduledHardwareUpgradeInfoHardwareUpgradePolicy & EnumVal<'always'>;
+	static readonly never: VcScheduledHardwareUpgradeInfoHardwareUpgradePolicy & EnumVal<'never'>;
+	static readonly onSoftPowerOff: VcScheduledHardwareUpgradeInfoHardwareUpgradePolicy & EnumVal<'onSoftPowerOff'>;
+	static fromString(value: string): VcScheduledHardwareUpgradeInfoHardwareUpgradePolicy & EnumVal<TcleanKeys<typeof VcScheduledHardwareUpgradeInfoHardwareUpgradePolicy>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcScheduledHardwareUpgradeInfoHardwareUpgradePolicy): VcScheduledHardwareUpgradeInfoHardwareUpgradePolicy;
+	toString: () => string;
 }
 
 /**
  * Reasons why record/replay is not supported on a host.
  */
-declare class VcHostIncompatibleForRecordReplayReason {
-	readonly product: VcHostIncompatibleForRecordReplayReason;
-	readonly name: string;
+declare class VcHostIncompatibleForRecordReplayReason implements IPseudoEnum {
+	static readonly product: VcHostIncompatibleForRecordReplayReason & EnumVal<'product'>;
+	static readonly processor: VcHostIncompatibleForRecordReplayReason & EnumVal<'processor'>;
+	static fromString(value: string): VcHostIncompatibleForRecordReplayReason & EnumVal<TcleanKeys<typeof VcHostIncompatibleForRecordReplayReason>>;
+
 	readonly id: string;
-	readonly processor: VcHostIncompatibleForRecordReplayReason;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostIncompatibleForRecordReplayReason): VcHostIncompatibleForRecordReplayReason;
+	toString: () => string;
 }
 
 /**
@@ -3478,73 +3301,69 @@ declare class VcHostIncompatibleForRecordReplayReason {
  * and for VMware Server Linux hosts, the device name could be specified as "/dev/vmnet[0-9]"
  * depending on what devices are available on that particular host.
  */
-declare class VcVirtualEthernetCardLegacyNetworkDeviceName {
-	readonly nat: VcVirtualEthernetCardLegacyNetworkDeviceName;
-	readonly hostonly: VcVirtualEthernetCardLegacyNetworkDeviceName;
-	readonly name: string;
-	readonly bridged: VcVirtualEthernetCardLegacyNetworkDeviceName;
+declare class VcVirtualEthernetCardLegacyNetworkDeviceName implements IPseudoEnum {
+	static readonly nat: VcVirtualEthernetCardLegacyNetworkDeviceName & EnumVal<'nat'>;
+	static readonly hostonly: VcVirtualEthernetCardLegacyNetworkDeviceName & EnumVal<'hostonly'>;
+	static readonly bridged: VcVirtualEthernetCardLegacyNetworkDeviceName & EnumVal<'bridged'>;
+	static fromString(value: string): VcVirtualEthernetCardLegacyNetworkDeviceName & EnumVal<TcleanKeys<typeof VcVirtualEthernetCardLegacyNetworkDeviceName>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualEthernetCardLegacyNetworkDeviceName): VcVirtualEthernetCardLegacyNetworkDeviceName;
+	toString: () => string;
 }
 
 /**
  * Simplified shares notation.
  * These designations have different meanings for different resources.
  */
-declare class VcSharesLevel {
-	static readonly normal: VcSharesLevel;
-	static readonly high: VcSharesLevel;
-	static readonly low: VcSharesLevel;
-	static readonly custom: VcSharesLevel;
-	static readonly name: string;
-	static readonly id: string;
-	static readonly value: string;
+declare class VcSharesLevel implements IPseudoEnum {
+	static readonly normal: VcSharesLevel & EnumVal<'normal'>;
+	static readonly high: VcSharesLevel & EnumVal<'high'>;
+	static readonly low: VcSharesLevel & EnumVal<'low'>;
+	static readonly custom: VcSharesLevel & EnumVal<'custom'>;
+	static fromString(value: string): VcSharesLevel & EnumVal<TcleanKeys<typeof VcSharesLevel>>;
+
+	readonly id: string;
+	readonly name: string;
+	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	static fromString(value: VcSharesLevel): VcSharesLevel;
+	toString: () => string;
 }
 
 /**
  * Severity level constants.
  */
-declare class VcEventEventSeverity {
-	readonly name: string;
-	readonly warning: VcEventEventSeverity;
+declare class VcEventEventSeverity implements IPseudoEnum {
+	static readonly warning: VcEventEventSeverity & EnumVal<'warning'>;
+	static readonly error: VcEventEventSeverity & EnumVal<'error'>;
+	static readonly user: VcEventEventSeverity & EnumVal<'user'>;
+	static readonly info: VcEventEventSeverity & EnumVal<'info'>;
+	static fromString(value: string): VcEventEventSeverity & EnumVal<TcleanKeys<typeof VcEventEventSeverity>>;
+
 	readonly id: string;
-	readonly error: VcEventEventSeverity;
-	readonly user: VcEventEventSeverity;
+	readonly name: string;
 	readonly value: string;
-	readonly info: VcEventEventSeverity;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcEventEventSeverity): VcEventEventSeverity;
+	toString: () => string;
 }
 
 /**
  * The available SLP discovery methods.
  */
-declare class VcSlpDiscoveryMethod {
-	readonly slpAutoMulticast: VcSlpDiscoveryMethod;
-	readonly name: string;
-	readonly slpDhcp: VcSlpDiscoveryMethod;
-	readonly slpManual: VcSlpDiscoveryMethod;
+declare class VcSlpDiscoveryMethod implements IPseudoEnum {
+	static readonly slpAutoMulticast: VcSlpDiscoveryMethod & EnumVal<'slpAutoMulticast'>;
+	static readonly slpDhcp: VcSlpDiscoveryMethod & EnumVal<'slpDhcp'>;
+	static readonly slpManual: VcSlpDiscoveryMethod & EnumVal<'slpManual'>;
+	static readonly slpAutoUnicast: VcSlpDiscoveryMethod & EnumVal<'slpAutoUnicast'>;
+	static fromString(value: string): VcSlpDiscoveryMethod & EnumVal<TcleanKeys<typeof VcSlpDiscoveryMethod>>;
+
 	readonly id: string;
-	readonly slpAutoUnicast: VcSlpDiscoveryMethod;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcSlpDiscoveryMethod): VcSlpDiscoveryMethod;
+	toString: () => string;
 }
 
 /**
@@ -3553,35 +3372,33 @@ declare class VcSlpDiscoveryMethod {
  * Each OST node corresponds to an element in the OVF descriptor. See {@link OstNode}
  * for a description of the different node types.
  */
-declare class VcOvfConsumerOstNodeType {
-	readonly virtualSystem: VcOvfConsumerOstNodeType;
-	readonly envelope: VcOvfConsumerOstNodeType;
-	readonly name: string;
+declare class VcOvfConsumerOstNodeType implements IPseudoEnum {
+	static readonly virtualSystem: VcOvfConsumerOstNodeType & EnumVal<'virtualSystem'>;
+	static readonly envelope: VcOvfConsumerOstNodeType & EnumVal<'envelope'>;
+	static readonly virtualSystemCollection: VcOvfConsumerOstNodeType & EnumVal<'virtualSystemCollection'>;
+	static fromString(value: string): VcOvfConsumerOstNodeType & EnumVal<TcleanKeys<typeof VcOvfConsumerOstNodeType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly virtualSystemCollection: VcOvfConsumerOstNodeType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcOvfConsumerOstNodeType): VcOvfConsumerOstNodeType;
+	toString: () => string;
 }
 
 /**
  * The <code>VirtualDeviceURIBackingOptionDirection</code> enum type
  * provides values for the direction of a network connection.
  */
-declare class VcVirtualDeviceURIBackingOptionDirection {
-	readonly server: VcVirtualDeviceURIBackingOptionDirection;
-	readonly name: string;
-	readonly client: VcVirtualDeviceURIBackingOptionDirection;
+declare class VcVirtualDeviceURIBackingOptionDirection implements IPseudoEnum {
+	static readonly server: VcVirtualDeviceURIBackingOptionDirection & EnumVal<'server'>;
+	static readonly client: VcVirtualDeviceURIBackingOptionDirection & EnumVal<'client'>;
+	static fromString(value: string): VcVirtualDeviceURIBackingOptionDirection & EnumVal<TcleanKeys<typeof VcVirtualDeviceURIBackingOptionDirection>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualDeviceURIBackingOptionDirection): VcVirtualDeviceURIBackingOptionDirection;
+	toString: () => string;
 }
 
 /**
@@ -3590,19 +3407,18 @@ declare class VcVirtualDeviceURIBackingOptionDirection {
  * since the starting or stopping of a vApp is typically a time-consuming
  * process that might take minutes to complete.
  */
-declare class VcVirtualAppVAppState {
-	readonly stopped: VcVirtualAppVAppState;
-	readonly stopping: VcVirtualAppVAppState;
-	readonly name: string;
-	readonly started: VcVirtualAppVAppState;
+declare class VcVirtualAppVAppState implements IPseudoEnum {
+	static readonly stopped: VcVirtualAppVAppState & EnumVal<'stopped'>;
+	static readonly stopping: VcVirtualAppVAppState & EnumVal<'stopping'>;
+	static readonly started: VcVirtualAppVAppState & EnumVal<'started'>;
+	static readonly starting: VcVirtualAppVAppState & EnumVal<'starting'>;
+	static fromString(value: string): VcVirtualAppVAppState & EnumVal<TcleanKeys<typeof VcVirtualAppVAppState>>;
+
 	readonly id: string;
-	readonly starting: VcVirtualAppVAppState;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualAppVAppState): VcVirtualAppVAppState;
+	toString: () => string;
 }
 
 /**
@@ -3610,109 +3426,103 @@ declare class VcVirtualAppVAppState {
  * that moves a virtual machine from one host to another or one storage location
  * to another. Note this priority can affect both the source and target hosts.
  */
-declare class VcVirtualMachineMovePriority {
-	readonly highPriority: VcVirtualMachineMovePriority;
-	readonly defaultPriority: VcVirtualMachineMovePriority;
-	readonly name: string;
+declare class VcVirtualMachineMovePriority implements IPseudoEnum {
+	static readonly highPriority: VcVirtualMachineMovePriority & EnumVal<'highPriority'>;
+	static readonly defaultPriority: VcVirtualMachineMovePriority & EnumVal<'defaultPriority'>;
+	static readonly lowPriority: VcVirtualMachineMovePriority & EnumVal<'lowPriority'>;
+	static fromString(value: string): VcVirtualMachineMovePriority & EnumVal<TcleanKeys<typeof VcVirtualMachineMovePriority>>;
+
 	readonly id: string;
-	readonly lowPriority: VcVirtualMachineMovePriority;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineMovePriority): VcVirtualMachineMovePriority;
+	toString: () => string;
 }
 
 /**
  * This specifies how an IP address was obtained for a given interface.
  * See RFC 4293 IpAddressOriginTC.
  */
-declare class VcNetIpConfigInfoIpAddressOrigin {
-	readonly random: VcNetIpConfigInfoIpAddressOrigin;
-	readonly other: VcNetIpConfigInfoIpAddressOrigin;
-	readonly name: string;
-	readonly linklayer: VcNetIpConfigInfoIpAddressOrigin;
+declare class VcNetIpConfigInfoIpAddressOrigin implements IPseudoEnum {
+	static readonly random: VcNetIpConfigInfoIpAddressOrigin & EnumVal<'random'>;
+	static readonly other: VcNetIpConfigInfoIpAddressOrigin & EnumVal<'other'>;
+	static readonly linklayer: VcNetIpConfigInfoIpAddressOrigin & EnumVal<'linklayer'>;
+	static readonly manual: VcNetIpConfigInfoIpAddressOrigin & EnumVal<'manual'>;
+	static readonly dhcp: VcNetIpConfigInfoIpAddressOrigin & EnumVal<'dhcp'>;
+	static fromString(value: string): VcNetIpConfigInfoIpAddressOrigin & EnumVal<TcleanKeys<typeof VcNetIpConfigInfoIpAddressOrigin>>;
+
 	readonly id: string;
-	readonly manual: VcNetIpConfigInfoIpAddressOrigin;
+	readonly name: string;
 	readonly value: string;
-	readonly dhcp: VcNetIpConfigInfoIpAddressOrigin;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcNetIpConfigInfoIpAddressOrigin): VcNetIpConfigInfoIpAddressOrigin;
+	toString: () => string;
 }
 
 /**
  * The reason for the failure.
  */
-declare class VcVmFailedStartingSecondaryEventFailureReason {
-	readonly incompatibleHost: VcVmFailedStartingSecondaryEventFailureReason;
-	readonly loginFailed: VcVmFailedStartingSecondaryEventFailureReason;
-	readonly name: string;
+declare class VcVmFailedStartingSecondaryEventFailureReason implements IPseudoEnum {
+	static readonly incompatibleHost: VcVmFailedStartingSecondaryEventFailureReason & EnumVal<'incompatibleHost'>;
+	static readonly loginFailed: VcVmFailedStartingSecondaryEventFailureReason & EnumVal<'loginFailed'>;
+	static readonly migrateFailed: VcVmFailedStartingSecondaryEventFailureReason & EnumVal<'migrateFailed'>;
+	static readonly registerVmFailed: VcVmFailedStartingSecondaryEventFailureReason & EnumVal<'registerVmFailed'>;
+	static fromString(value: string): VcVmFailedStartingSecondaryEventFailureReason & EnumVal<TcleanKeys<typeof VcVmFailedStartingSecondaryEventFailureReason>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly migrateFailed: VcVmFailedStartingSecondaryEventFailureReason;
-	readonly registerVmFailed: VcVmFailedStartingSecondaryEventFailureReason;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVmFailedStartingSecondaryEventFailureReason): VcVmFailedStartingSecondaryEventFailureReason;
+	toString: () => string;
 }
 
 /**
  * Denotes the line of service of a schema.
  */
-declare class PbmLineOfServiceInfoLineOfServiceEnum {
-	readonly INSPECTION: PbmLineOfServiceInfoLineOfServiceEnum;
-	readonly CACHING: PbmLineOfServiceInfoLineOfServiceEnum;
-	readonly ENCRYPTION: PbmLineOfServiceInfoLineOfServiceEnum;
-	readonly REPLICATION: PbmLineOfServiceInfoLineOfServiceEnum;
-	readonly PERSISTENCE: PbmLineOfServiceInfoLineOfServiceEnum;
-	readonly DATASTORE_IO_CONTROL: PbmLineOfServiceInfoLineOfServiceEnum;
-	readonly name: string;
-	readonly COMPRESSION: PbmLineOfServiceInfoLineOfServiceEnum;
+declare class PbmLineOfServiceInfoLineOfServiceEnum implements IPseudoEnum {
+	static readonly INSPECTION: PbmLineOfServiceInfoLineOfServiceEnum & EnumVal<'INSPECTION'>;
+	static readonly CACHING: PbmLineOfServiceInfoLineOfServiceEnum & EnumVal<'CACHING'>;
+	static readonly ENCRYPTION: PbmLineOfServiceInfoLineOfServiceEnum & EnumVal<'ENCRYPTION'>;
+	static readonly REPLICATION: PbmLineOfServiceInfoLineOfServiceEnum & EnumVal<'REPLICATION'>;
+	static readonly PERSISTENCE: PbmLineOfServiceInfoLineOfServiceEnum & EnumVal<'PERSISTENCE'>;
+	static readonly DATASTORE_IO_CONTROL: PbmLineOfServiceInfoLineOfServiceEnum & EnumVal<'DATASTORE_IO_CONTROL'>;
+	static readonly COMPRESSION: PbmLineOfServiceInfoLineOfServiceEnum & EnumVal<'COMPRESSION'>;
+	static readonly DATA_PROVIDER: PbmLineOfServiceInfoLineOfServiceEnum & EnumVal<'DATA_PROVIDER'>;
+	static fromString(value: string): PbmLineOfServiceInfoLineOfServiceEnum & EnumVal<TcleanKeys<typeof PbmLineOfServiceInfoLineOfServiceEnum>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly DATA_PROVIDER: PbmLineOfServiceInfoLineOfServiceEnum;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: PbmLineOfServiceInfoLineOfServiceEnum): PbmLineOfServiceInfoLineOfServiceEnum;
+	toString: () => string;
 }
 
-declare class VcInvalidProfileReferenceHostReason {
-	readonly missingReferenceHost: VcInvalidProfileReferenceHostReason;
-	readonly incompatibleVersion: VcInvalidProfileReferenceHostReason;
-	readonly name: string;
+declare class VcInvalidProfileReferenceHostReason implements IPseudoEnum {
+	static readonly missingReferenceHost: VcInvalidProfileReferenceHostReason & EnumVal<'missingReferenceHost'>;
+	static readonly incompatibleVersion: VcInvalidProfileReferenceHostReason & EnumVal<'incompatibleVersion'>;
+	static fromString(value: string): VcInvalidProfileReferenceHostReason & EnumVal<TcleanKeys<typeof VcInvalidProfileReferenceHostReason>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcInvalidProfileReferenceHostReason): VcInvalidProfileReferenceHostReason;
+	toString: () => string;
 }
 
 /**
  * The possible kinds of alarm state changes that are reported.
  */
-declare class VcCDCAlarmChangeKind {
-	readonly retriggered: VcCDCAlarmChangeKind;
-	readonly triggered: VcCDCAlarmChangeKind;
-	readonly acknowledged: VcCDCAlarmChangeKind;
-	readonly name: string;
+declare class VcCDCAlarmChangeKind implements IPseudoEnum {
+	static readonly retriggered: VcCDCAlarmChangeKind & EnumVal<'retriggered'>;
+	static readonly triggered: VcCDCAlarmChangeKind & EnumVal<'triggered'>;
+	static readonly acknowledged: VcCDCAlarmChangeKind & EnumVal<'acknowledged'>;
+	static readonly cleared: VcCDCAlarmChangeKind & EnumVal<'cleared'>;
+	static fromString(value: string): VcCDCAlarmChangeKind & EnumVal<TcleanKeys<typeof VcCDCAlarmChangeKind>>;
+
 	readonly id: string;
-	readonly cleared: VcCDCAlarmChangeKind;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcCDCAlarmChangeKind): VcCDCAlarmChangeKind;
+	toString: () => string;
 }
 
 /**
@@ -3720,36 +3530,34 @@ declare class VcCDCAlarmChangeKind {
  * physical address lookups for IP addresses. Here are the standard
  * states per @see RFC 4293 ipNetToMediaType.
  */
-declare class VcNetIpStackInfoEntryType {
-	readonly other: VcNetIpStackInfoEntryType;
-	readonly invalid: VcNetIpStackInfoEntryType;
-	readonly name: string;
-	readonly dynamic: VcNetIpStackInfoEntryType;
+declare class VcNetIpStackInfoEntryType implements IPseudoEnum {
+	static readonly other: VcNetIpStackInfoEntryType & EnumVal<'other'>;
+	static readonly invalid: VcNetIpStackInfoEntryType & EnumVal<'invalid'>;
+	static readonly dynamic: VcNetIpStackInfoEntryType & EnumVal<'dynamic'>;
+	static readonly manual: VcNetIpStackInfoEntryType & EnumVal<'manual'>;
+	static fromString(value: string): VcNetIpStackInfoEntryType & EnumVal<TcleanKeys<typeof VcNetIpStackInfoEntryType>>;
+
 	readonly id: string;
-	readonly manual: VcNetIpStackInfoEntryType;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcNetIpStackInfoEntryType): VcNetIpStackInfoEntryType;
+	toString: () => string;
 }
 
 /**
  * The set of digest methods that can be used by TPM to calculate the PCR
  * values.
  */
-declare class VcHostDigestInfoDigestMethodType {
-	readonly SHA1: VcHostDigestInfoDigestMethodType;
-	readonly name: string;
+declare class VcHostDigestInfoDigestMethodType implements IPseudoEnum {
+	static readonly SHA1: VcHostDigestInfoDigestMethodType & EnumVal<'SHA1'>;
+	static readonly MD5: VcHostDigestInfoDigestMethodType & EnumVal<'MD5'>;
+	static fromString(value: string): VcHostDigestInfoDigestMethodType & EnumVal<TcleanKeys<typeof VcHostDigestInfoDigestMethodType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly MD5: VcHostDigestInfoDigestMethodType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostDigestInfoDigestMethodType): VcHostDigestInfoDigestMethodType;
+	toString: () => string;
 }
 
 /**
@@ -3760,287 +3568,270 @@ declare class VcHostDigestInfoDigestMethodType {
  * 2. VirtualDisk - This value indicates to the method that the operation
  * should be performed on all extents of a virtual disk.
  */
-declare class VcFileManagerFileType {
-	readonly name: string;
+declare class VcFileManagerFileType implements IPseudoEnum {
+	static readonly File: VcFileManagerFileType & EnumVal<'File'>;
+	static readonly VirtualDisk: VcFileManagerFileType & EnumVal<'VirtualDisk'>;
+	static fromString(value: string): VcFileManagerFileType & EnumVal<TcleanKeys<typeof VcFileManagerFileType>>;
+
 	readonly id: string;
-	readonly File: VcFileManagerFileType;
+	readonly name: string;
 	readonly value: string;
-	readonly VirtualDisk: VcFileManagerFileType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcFileManagerFileType): VcFileManagerFileType;
+	toString: () => string;
 }
 
 /**
  * The composition validation status class.
  */
-declare class VcHostProfileManagerCompositionValidationResultResultElementStatus {
-	readonly success: VcHostProfileManagerCompositionValidationResultResultElementStatus;
-	readonly name: string;
+declare class VcHostProfileManagerCompositionValidationResultResultElementStatus implements IPseudoEnum {
+	static readonly success: VcHostProfileManagerCompositionValidationResultResultElementStatus & EnumVal<'success'>;
+	static readonly error: VcHostProfileManagerCompositionValidationResultResultElementStatus & EnumVal<'error'>;
+	static fromString(value: string): VcHostProfileManagerCompositionValidationResultResultElementStatus & EnumVal<TcleanKeys<typeof VcHostProfileManagerCompositionValidationResultResultElementStatus>>;
+
 	readonly id: string;
-	readonly error: VcHostProfileManagerCompositionValidationResultResultElementStatus;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostProfileManagerCompositionValidationResultResultElementStatus): VcHostProfileManagerCompositionValidationResultResultElementStatus;
+	toString: () => string;
 }
 
 /**
  * Defines the options for a Datacenter::powerOnVm() invocation.
  */
-declare class VcClusterPowerOnVmOption {
-	readonly ReserveResources: VcClusterPowerOnVmOption;
-	readonly name: string;
-	readonly OverrideAutomationLevel: VcClusterPowerOnVmOption;
+declare class VcClusterPowerOnVmOption implements IPseudoEnum {
+	static readonly ReserveResources: VcClusterPowerOnVmOption & EnumVal<'ReserveResources'>;
+	static readonly OverrideAutomationLevel: VcClusterPowerOnVmOption & EnumVal<'OverrideAutomationLevel'>;
+	static fromString(value: string): VcClusterPowerOnVmOption & EnumVal<TcleanKeys<typeof VcClusterPowerOnVmOption>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcClusterPowerOnVmOption): VcClusterPowerOnVmOption;
+	toString: () => string;
 }
 
 /**
  * Guest OS support level
  */
-declare class VcGuestOsDescriptorSupportLevel {
-	readonly legacy: VcGuestOsDescriptorSupportLevel;
-	readonly unsupported: VcGuestOsDescriptorSupportLevel;
-	readonly deprecated: VcGuestOsDescriptorSupportLevel;
-	readonly name: string;
-	readonly experimental: VcGuestOsDescriptorSupportLevel;
+declare class VcGuestOsDescriptorSupportLevel implements IPseudoEnum {
+	static readonly legacy: VcGuestOsDescriptorSupportLevel & EnumVal<'legacy'>;
+	static readonly unsupported: VcGuestOsDescriptorSupportLevel & EnumVal<'unsupported'>;
+	static readonly deprecated: VcGuestOsDescriptorSupportLevel & EnumVal<'deprecated'>;
+	static readonly experimental: VcGuestOsDescriptorSupportLevel & EnumVal<'experimental'>;
+	static readonly terminated: VcGuestOsDescriptorSupportLevel & EnumVal<'terminated'>;
+	static readonly supported: VcGuestOsDescriptorSupportLevel & EnumVal<'supported'>;
+	static readonly techPreview: VcGuestOsDescriptorSupportLevel & EnumVal<'techPreview'>;
+	static fromString(value: string): VcGuestOsDescriptorSupportLevel & EnumVal<TcleanKeys<typeof VcGuestOsDescriptorSupportLevel>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly terminated: VcGuestOsDescriptorSupportLevel;
-	readonly supported: VcGuestOsDescriptorSupportLevel;
-	readonly techPreview: VcGuestOsDescriptorSupportLevel;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcGuestOsDescriptorSupportLevel): VcGuestOsDescriptorSupportLevel;
+	toString: () => string;
 }
 
-declare class VcClusterInfraUpdateHaConfigInfoRemediationType {
-	readonly QuarantineMode: VcClusterInfraUpdateHaConfigInfoRemediationType;
-	readonly MaintenanceMode: VcClusterInfraUpdateHaConfigInfoRemediationType;
-	readonly name: string;
+declare class VcClusterInfraUpdateHaConfigInfoRemediationType implements IPseudoEnum {
+	static readonly QuarantineMode: VcClusterInfraUpdateHaConfigInfoRemediationType & EnumVal<'QuarantineMode'>;
+	static readonly MaintenanceMode: VcClusterInfraUpdateHaConfigInfoRemediationType & EnumVal<'MaintenanceMode'>;
+	static fromString(value: string): VcClusterInfraUpdateHaConfigInfoRemediationType & EnumVal<TcleanKeys<typeof VcClusterInfraUpdateHaConfigInfoRemediationType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcClusterInfraUpdateHaConfigInfoRemediationType): VcClusterInfraUpdateHaConfigInfoRemediationType;
+	toString: () => string;
 }
 
 /**
  * The virtual machine ticket type.
  */
-declare class VcVirtualMachineTicketType {
-	readonly mks: VcVirtualMachineTicketType;
-	readonly name: string;
-	readonly guestControl: VcVirtualMachineTicketType;
-	readonly dnd: VcVirtualMachineTicketType;
+declare class VcVirtualMachineTicketType implements IPseudoEnum {
+	static readonly mks: VcVirtualMachineTicketType & EnumVal<'mks'>;
+	static readonly guestControl: VcVirtualMachineTicketType & EnumVal<'guestControl'>;
+	static readonly dnd: VcVirtualMachineTicketType & EnumVal<'dnd'>;
+	static readonly device: VcVirtualMachineTicketType & EnumVal<'device'>;
+	static readonly webmks: VcVirtualMachineTicketType & EnumVal<'webmks'>;
+	static readonly guestIntegrity: VcVirtualMachineTicketType & EnumVal<'guestIntegrity'>;
+	static fromString(value: string): VcVirtualMachineTicketType & EnumVal<TcleanKeys<typeof VcVirtualMachineTicketType>>;
+
 	readonly id: string;
-	readonly device: VcVirtualMachineTicketType;
+	readonly name: string;
 	readonly value: string;
-	readonly webmks: VcVirtualMachineTicketType;
-	readonly guestIntegrity: VcVirtualMachineTicketType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineTicketType): VcVirtualMachineTicketType;
+	toString: () => string;
 }
 
 /**
  * The installation state if the update is installed on the server.
  */
-declare class VcHostPatchManagerInstallState {
-	readonly imageActive: VcHostPatchManagerInstallState;
-	readonly hostRestarted: VcHostPatchManagerInstallState;
-	readonly name: string;
+declare class VcHostPatchManagerInstallState implements IPseudoEnum {
+	static readonly imageActive: VcHostPatchManagerInstallState & EnumVal<'imageActive'>;
+	static readonly hostRestarted: VcHostPatchManagerInstallState & EnumVal<'hostRestarted'>;
+	static fromString(value: string): VcHostPatchManagerInstallState & EnumVal<TcleanKeys<typeof VcHostPatchManagerInstallState>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostPatchManagerInstallState): VcHostPatchManagerInstallState;
+	toString: () => string;
 }
 
 /**
  * Defines the two ways a space utilization threshold can be specified.
  */
-declare class VcStorageDrsSpaceLoadBalanceConfigSpaceThresholdMode {
-	readonly freeSpace: VcStorageDrsSpaceLoadBalanceConfigSpaceThresholdMode;
-	readonly name: string;
-	readonly utilization: VcStorageDrsSpaceLoadBalanceConfigSpaceThresholdMode;
+declare class VcStorageDrsSpaceLoadBalanceConfigSpaceThresholdMode implements IPseudoEnum {
+	static readonly freeSpace: VcStorageDrsSpaceLoadBalanceConfigSpaceThresholdMode & EnumVal<'freeSpace'>;
+	static readonly utilization: VcStorageDrsSpaceLoadBalanceConfigSpaceThresholdMode & EnumVal<'utilization'>;
+	static fromString(value: string): VcStorageDrsSpaceLoadBalanceConfigSpaceThresholdMode & EnumVal<TcleanKeys<typeof VcStorageDrsSpaceLoadBalanceConfigSpaceThresholdMode>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcStorageDrsSpaceLoadBalanceConfigSpaceThresholdMode): VcStorageDrsSpaceLoadBalanceConfigSpaceThresholdMode;
+	toString: () => string;
 }
 
 /**
  * The  port blocked/unblocked state.
  */
-declare class VcDvsEventPortBlockState {
-	readonly unblocked: VcDvsEventPortBlockState;
-	readonly blocked: VcDvsEventPortBlockState;
-	readonly name: string;
+declare class VcDvsEventPortBlockState implements IPseudoEnum {
+	static readonly unblocked: VcDvsEventPortBlockState & EnumVal<'unblocked'>;
+	static readonly blocked: VcDvsEventPortBlockState & EnumVal<'blocked'>;
+	static readonly unset: VcDvsEventPortBlockState & EnumVal<'unset'>;
+	static readonly unknown: VcDvsEventPortBlockState & EnumVal<'unknown'>;
+	static fromString(value: string): VcDvsEventPortBlockState & EnumVal<TcleanKeys<typeof VcDvsEventPortBlockState>>;
+
 	readonly id: string;
-	readonly unset: VcDvsEventPortBlockState;
+	readonly name: string;
 	readonly value: string;
-	readonly unknown: VcDvsEventPortBlockState;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDvsEventPortBlockState): VcDvsEventPortBlockState;
+	toString: () => string;
 }
 
 /**
  * This enumeration lists the types of events the in-guest components will
  * send back to the client application.
  */
-declare class VcVirtualMachineBackupEventInfoBackupEventType {
-	readonly snapshotPrepare: VcVirtualMachineBackupEventInfoBackupEventType;
-	readonly keepAlive: VcVirtualMachineBackupEventInfoBackupEventType;
-	readonly providerAbort: VcVirtualMachineBackupEventInfoBackupEventType;
-	readonly writerError: VcVirtualMachineBackupEventInfoBackupEventType;
-	readonly requestorDone: VcVirtualMachineBackupEventInfoBackupEventType;
-	readonly backupManifest: VcVirtualMachineBackupEventInfoBackupEventType;
-	readonly snapshotCommit: VcVirtualMachineBackupEventInfoBackupEventType;
-	readonly requestorError: VcVirtualMachineBackupEventInfoBackupEventType;
-	readonly name: string;
-	readonly reset: VcVirtualMachineBackupEventInfoBackupEventType;
+declare class VcVirtualMachineBackupEventInfoBackupEventType implements IPseudoEnum {
+	static readonly snapshotPrepare: VcVirtualMachineBackupEventInfoBackupEventType & EnumVal<'snapshotPrepare'>;
+	static readonly keepAlive: VcVirtualMachineBackupEventInfoBackupEventType & EnumVal<'keepAlive'>;
+	static readonly providerAbort: VcVirtualMachineBackupEventInfoBackupEventType & EnumVal<'providerAbort'>;
+	static readonly writerError: VcVirtualMachineBackupEventInfoBackupEventType & EnumVal<'writerError'>;
+	static readonly requestorDone: VcVirtualMachineBackupEventInfoBackupEventType & EnumVal<'requestorDone'>;
+	static readonly backupManifest: VcVirtualMachineBackupEventInfoBackupEventType & EnumVal<'backupManifest'>;
+	static readonly snapshotCommit: VcVirtualMachineBackupEventInfoBackupEventType & EnumVal<'snapshotCommit'>;
+	static readonly requestorError: VcVirtualMachineBackupEventInfoBackupEventType & EnumVal<'requestorError'>;
+	static readonly reset: VcVirtualMachineBackupEventInfoBackupEventType & EnumVal<'reset'>;
+	static readonly requestorAbort: VcVirtualMachineBackupEventInfoBackupEventType & EnumVal<'requestorAbort'>;
+	static fromString(value: string): VcVirtualMachineBackupEventInfoBackupEventType & EnumVal<TcleanKeys<typeof VcVirtualMachineBackupEventInfoBackupEventType>>;
+
 	readonly id: string;
-	readonly requestorAbort: VcVirtualMachineBackupEventInfoBackupEventType;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineBackupEventInfoBackupEventType): VcVirtualMachineBackupEventInfoBackupEventType;
+	toString: () => string;
 }
 
 /**
  * IP allocation schemes supported by the guest.
  */
-declare class VcVAppIPAssignmentInfoAllocationSchemes {
-	readonly ovfenv: VcVAppIPAssignmentInfoAllocationSchemes;
-	readonly name: string;
+declare class VcVAppIPAssignmentInfoAllocationSchemes implements IPseudoEnum {
+	static readonly ovfenv: VcVAppIPAssignmentInfoAllocationSchemes & EnumVal<'ovfenv'>;
+	static readonly dhcp: VcVAppIPAssignmentInfoAllocationSchemes & EnumVal<'dhcp'>;
+	static fromString(value: string): VcVAppIPAssignmentInfoAllocationSchemes & EnumVal<TcleanKeys<typeof VcVAppIPAssignmentInfoAllocationSchemes>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly dhcp: VcVAppIPAssignmentInfoAllocationSchemes;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVAppIPAssignmentInfoAllocationSchemes): VcVAppIPAssignmentInfoAllocationSchemes;
+	toString: () => string;
 }
 
-declare class VcDynamicTypeMgrMethodTypeInfoAnnotationType {
-	readonly internal: VcDynamicTypeMgrMethodTypeInfoAnnotationType;
-	readonly name: string;
+declare class VcDynamicTypeMgrMethodTypeInfoAnnotationType implements IPseudoEnum {
+	static readonly internal: VcDynamicTypeMgrMethodTypeInfoAnnotationType & EnumVal<'internal'>;
+	static fromString(value: string): VcDynamicTypeMgrMethodTypeInfoAnnotationType & EnumVal<TcleanKeys<typeof VcDynamicTypeMgrMethodTypeInfoAnnotationType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDynamicTypeMgrMethodTypeInfoAnnotationType): VcDynamicTypeMgrMethodTypeInfoAnnotationType;
+	toString: () => string;
 }
 
 /**
  * The PVLAN port types.
  */
-declare class VcVmwareDistributedVirtualSwitchPvlanPortType {
-	readonly promiscuous: VcVmwareDistributedVirtualSwitchPvlanPortType;
-	readonly isolated: VcVmwareDistributedVirtualSwitchPvlanPortType;
-	readonly name: string;
+declare class VcVmwareDistributedVirtualSwitchPvlanPortType implements IPseudoEnum {
+	static readonly promiscuous: VcVmwareDistributedVirtualSwitchPvlanPortType & EnumVal<'promiscuous'>;
+	static readonly isolated: VcVmwareDistributedVirtualSwitchPvlanPortType & EnumVal<'isolated'>;
+	static readonly community: VcVmwareDistributedVirtualSwitchPvlanPortType & EnumVal<'community'>;
+	static fromString(value: string): VcVmwareDistributedVirtualSwitchPvlanPortType & EnumVal<TcleanKeys<typeof VcVmwareDistributedVirtualSwitchPvlanPortType>>;
+
 	readonly id: string;
-	readonly community: VcVmwareDistributedVirtualSwitchPvlanPortType;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVmwareDistributedVirtualSwitchPvlanPortType): VcVmwareDistributedVirtualSwitchPvlanPortType;
+	toString: () => string;
 }
 
 /**
  * The meta tag names recognizable in the
  * {@link DistributedVirtualPortgroup.ConfigInfo#portNameFormat} string.
  */
-declare class VcDistributedVirtualPortgroupMetaTagName {
-	readonly portIndex: VcDistributedVirtualPortgroupMetaTagName;
-	readonly dvsName: VcDistributedVirtualPortgroupMetaTagName;
-	readonly name: string;
-	readonly portgroupName: VcDistributedVirtualPortgroupMetaTagName;
+declare class VcDistributedVirtualPortgroupMetaTagName implements IPseudoEnum {
+	static readonly portIndex: VcDistributedVirtualPortgroupMetaTagName & EnumVal<'portIndex'>;
+	static readonly dvsName: VcDistributedVirtualPortgroupMetaTagName & EnumVal<'dvsName'>;
+	static readonly portgroupName: VcDistributedVirtualPortgroupMetaTagName & EnumVal<'portgroupName'>;
+	static fromString(value: string): VcDistributedVirtualPortgroupMetaTagName & EnumVal<TcleanKeys<typeof VcDistributedVirtualPortgroupMetaTagName>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDistributedVirtualPortgroupMetaTagName): VcDistributedVirtualPortgroupMetaTagName;
+	toString: () => string;
 }
 
-declare class VcDpmBehavior {
-	readonly automated: VcDpmBehavior;
-	readonly name: string;
+declare class VcDpmBehavior implements IPseudoEnum {
+	static readonly automated: VcDpmBehavior & EnumVal<'automated'>;
+	static readonly manual: VcDpmBehavior & EnumVal<'manual'>;
+	static fromString(value: string): VcDpmBehavior & EnumVal<TcleanKeys<typeof VcDpmBehavior>>;
+
 	readonly id: string;
-	readonly manual: VcDpmBehavior;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDpmBehavior): VcDpmBehavior;
+	toString: () => string;
 }
 
-declare class VcReplicationDiskConfigFaultReasonForFault {
-	readonly diskTypeNotSupported: VcReplicationDiskConfigFaultReasonForFault;
-	readonly invalidDiskReplicationId: VcReplicationDiskConfigFaultReasonForFault;
-	readonly diskNotFound: VcReplicationDiskConfigFaultReasonForFault;
-	readonly invalidPersistentFilePath: VcReplicationDiskConfigFaultReasonForFault;
-	readonly invalidDiskKey: VcReplicationDiskConfigFaultReasonForFault;
-	readonly duplicateDiskReplicationId: VcReplicationDiskConfigFaultReasonForFault;
-	readonly name: string;
+declare class VcReplicationDiskConfigFaultReasonForFault implements IPseudoEnum {
+	static readonly diskTypeNotSupported: VcReplicationDiskConfigFaultReasonForFault & EnumVal<'diskTypeNotSupported'>;
+	static readonly invalidDiskReplicationId: VcReplicationDiskConfigFaultReasonForFault & EnumVal<'invalidDiskReplicationId'>;
+	static readonly diskNotFound: VcReplicationDiskConfigFaultReasonForFault & EnumVal<'diskNotFound'>;
+	static readonly invalidPersistentFilePath: VcReplicationDiskConfigFaultReasonForFault & EnumVal<'invalidPersistentFilePath'>;
+	static readonly invalidDiskKey: VcReplicationDiskConfigFaultReasonForFault & EnumVal<'invalidDiskKey'>;
+	static readonly duplicateDiskReplicationId: VcReplicationDiskConfigFaultReasonForFault & EnumVal<'duplicateDiskReplicationId'>;
+	static readonly reconfigureDiskReplicationIdNotAllowed: VcReplicationDiskConfigFaultReasonForFault & EnumVal<'reconfigureDiskReplicationIdNotAllowed'>;
+	static fromString(value: string): VcReplicationDiskConfigFaultReasonForFault & EnumVal<TcleanKeys<typeof VcReplicationDiskConfigFaultReasonForFault>>;
+
 	readonly id: string;
-	readonly reconfigureDiskReplicationIdNotAllowed: VcReplicationDiskConfigFaultReasonForFault;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcReplicationDiskConfigFaultReasonForFault): VcReplicationDiskConfigFaultReasonForFault;
+	toString: () => string;
 }
 
 /**
  * Supported hash algorithms.
  */
-declare class VcDiagnosticManagerFileHashSpecHashAlgorithm {
-	readonly sha256: VcDiagnosticManagerFileHashSpecHashAlgorithm;
-	readonly name: string;
+declare class VcDiagnosticManagerFileHashSpecHashAlgorithm implements IPseudoEnum {
+	static readonly sha256: VcDiagnosticManagerFileHashSpecHashAlgorithm & EnumVal<'sha256'>;
+	static fromString(value: string): VcDiagnosticManagerFileHashSpecHashAlgorithm & EnumVal<TcleanKeys<typeof VcDiagnosticManagerFileHashSpecHashAlgorithm>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDiagnosticManagerFileHashSpecHashAlgorithm): VcDiagnosticManagerFileHashSpecHashAlgorithm;
+	toString: () => string;
 }
 
 /**
@@ -4050,149 +3841,141 @@ declare class VcDiagnosticManagerFileHashSpecHashAlgorithm {
  * when you create the distributed virtual portgroup. An ephemeral portgroup uses dynamic
  * ports that are created when you power on a virtual machine.
  */
-declare class VcDistributedVirtualPortgroupPortgroupType {
-	readonly lateBinding: VcDistributedVirtualPortgroupPortgroupType;
-	readonly earlyBinding: VcDistributedVirtualPortgroupPortgroupType;
-	readonly name: string;
-	readonly ephemeral: VcDistributedVirtualPortgroupPortgroupType;
+declare class VcDistributedVirtualPortgroupPortgroupType implements IPseudoEnum {
+	static readonly lateBinding: VcDistributedVirtualPortgroupPortgroupType & EnumVal<'lateBinding'>;
+	static readonly earlyBinding: VcDistributedVirtualPortgroupPortgroupType & EnumVal<'earlyBinding'>;
+	static readonly ephemeral: VcDistributedVirtualPortgroupPortgroupType & EnumVal<'ephemeral'>;
+	static fromString(value: string): VcDistributedVirtualPortgroupPortgroupType & EnumVal<TcleanKeys<typeof VcDistributedVirtualPortgroupPortgroupType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDistributedVirtualPortgroupPortgroupType): VcDistributedVirtualPortgroupPortgroupType;
+	toString: () => string;
 }
 
-declare class AlarmType {
-	readonly ReplicationAlarm: AlarmType;
-	readonly StorageObjectAlarm: AlarmType;
-	readonly name: string;
-	readonly ManageabilityAlarm: AlarmType;
-	readonly ComplianceAlarm: AlarmType;
-	readonly CapabilityAlarm: AlarmType;
+declare class AlarmType implements IPseudoEnum {
+	static readonly ReplicationAlarm: AlarmType & EnumVal<'ReplicationAlarm'>;
+	static readonly StorageObjectAlarm: AlarmType & EnumVal<'StorageObjectAlarm'>;
+	static readonly ManageabilityAlarm: AlarmType & EnumVal<'ManageabilityAlarm'>;
+	static readonly ComplianceAlarm: AlarmType & EnumVal<'ComplianceAlarm'>;
+	static readonly CapabilityAlarm: AlarmType & EnumVal<'CapabilityAlarm'>;
+	static readonly ObjectAlarm: AlarmType & EnumVal<'ObjectAlarm'>;
+	static readonly SpaceCapacityAlarm: AlarmType & EnumVal<'SpaceCapacityAlarm'>;
+	static fromString(value: string): AlarmType & EnumVal<TcleanKeys<typeof AlarmType>>;
+
 	readonly id: string;
-	readonly ObjectAlarm: AlarmType;
+	readonly name: string;
 	readonly value: string;
-	readonly SpaceCapacityAlarm: AlarmType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: AlarmType): AlarmType;
+	toString: () => string;
 }
 
 /**
  * ProtocolEndpoint type.
  */
-declare class VcHostProtocolEndpointProtocolEndpointType {
-	readonly nfs4x: VcHostProtocolEndpointProtocolEndpointType;
-	readonly scsi: VcHostProtocolEndpointProtocolEndpointType;
-	readonly name: string;
-	readonly nfs: VcHostProtocolEndpointProtocolEndpointType;
+declare class VcHostProtocolEndpointProtocolEndpointType implements IPseudoEnum {
+	static readonly nfs4x: VcHostProtocolEndpointProtocolEndpointType & EnumVal<'nfs4x'>;
+	static readonly scsi: VcHostProtocolEndpointProtocolEndpointType & EnumVal<'scsi'>;
+	static readonly nfs: VcHostProtocolEndpointProtocolEndpointType & EnumVal<'nfs'>;
+	static fromString(value: string): VcHostProtocolEndpointProtocolEndpointType & EnumVal<TcleanKeys<typeof VcHostProtocolEndpointProtocolEndpointType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostProtocolEndpointProtocolEndpointType): VcHostProtocolEndpointProtocolEndpointType;
+	toString: () => string;
 }
 
-declare class VcReplicationVmFaultReasonForFault {
-	readonly invalidInstanceId: VcReplicationVmFaultReasonForFault;
-	readonly notConfigured: VcReplicationVmFaultReasonForFault;
-	readonly poweredOn: VcReplicationVmFaultReasonForFault;
-	readonly closeDiskError: VcReplicationVmFaultReasonForFault;
-	readonly name: string;
-	readonly invalidState: VcReplicationVmFaultReasonForFault;
+declare class VcReplicationVmFaultReasonForFault implements IPseudoEnum {
+	static readonly invalidInstanceId: VcReplicationVmFaultReasonForFault & EnumVal<'invalidInstanceId'>;
+	static readonly notConfigured: VcReplicationVmFaultReasonForFault & EnumVal<'notConfigured'>;
+	static readonly poweredOn: VcReplicationVmFaultReasonForFault & EnumVal<'poweredOn'>;
+	static readonly closeDiskError: VcReplicationVmFaultReasonForFault & EnumVal<'closeDiskError'>;
+	static readonly invalidState: VcReplicationVmFaultReasonForFault & EnumVal<'invalidState'>;
+	static readonly offlineReplicating: VcReplicationVmFaultReasonForFault & EnumVal<'offlineReplicating'>;
+	static readonly groupExist: VcReplicationVmFaultReasonForFault & EnumVal<'groupExist'>;
+	static readonly poweredOff: VcReplicationVmFaultReasonForFault & EnumVal<'poweredOff'>;
+	static readonly suspended: VcReplicationVmFaultReasonForFault & EnumVal<'suspended'>;
+	static fromString(value: string): VcReplicationVmFaultReasonForFault & EnumVal<TcleanKeys<typeof VcReplicationVmFaultReasonForFault>>;
+
 	readonly id: string;
-	readonly offlineReplicating: VcReplicationVmFaultReasonForFault;
-	readonly groupExist: VcReplicationVmFaultReasonForFault;
+	readonly name: string;
 	readonly value: string;
-	readonly poweredOff: VcReplicationVmFaultReasonForFault;
-	readonly suspended: VcReplicationVmFaultReasonForFault;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcReplicationVmFaultReasonForFault): VcReplicationVmFaultReasonForFault;
+	toString: () => string;
 }
 
 /**
  * Pre-defined constants for possible creators of log files.
  */
-declare class VcDiagnosticManagerLogCreator {
-	readonly vpxd: VcDiagnosticManagerLogCreator;
-	readonly hostd: VcDiagnosticManagerLogCreator;
-	readonly serverd: VcDiagnosticManagerLogCreator;
-	readonly vpxa: VcDiagnosticManagerLogCreator;
-	readonly install: VcDiagnosticManagerLogCreator;
-	readonly name: string;
-	readonly vpxClient: VcDiagnosticManagerLogCreator;
-	readonly recordLog: VcDiagnosticManagerLogCreator;
+declare class VcDiagnosticManagerLogCreator implements IPseudoEnum {
+	static readonly vpxd: VcDiagnosticManagerLogCreator & EnumVal<'vpxd'>;
+	static readonly hostd: VcDiagnosticManagerLogCreator & EnumVal<'hostd'>;
+	static readonly serverd: VcDiagnosticManagerLogCreator & EnumVal<'serverd'>;
+	static readonly vpxa: VcDiagnosticManagerLogCreator & EnumVal<'vpxa'>;
+	static readonly install: VcDiagnosticManagerLogCreator & EnumVal<'install'>;
+	static readonly vpxClient: VcDiagnosticManagerLogCreator & EnumVal<'vpxClient'>;
+	static readonly recordLog: VcDiagnosticManagerLogCreator & EnumVal<'recordLog'>;
+	static fromString(value: string): VcDiagnosticManagerLogCreator & EnumVal<TcleanKeys<typeof VcDiagnosticManagerLogCreator>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDiagnosticManagerLogCreator): VcDiagnosticManagerLogCreator;
+	toString: () => string;
 }
 
 /**
  * Current status of VMware Tools running in the guest operating system.
  */
-declare class VcVirtualMachineToolsStatus {
-	readonly toolsOld: VcVirtualMachineToolsStatus;
-	readonly toolsNotInstalled: VcVirtualMachineToolsStatus;
-	readonly toolsNotRunning: VcVirtualMachineToolsStatus;
-	readonly name: string;
+declare class VcVirtualMachineToolsStatus implements IPseudoEnum {
+	static readonly toolsOld: VcVirtualMachineToolsStatus & EnumVal<'toolsOld'>;
+	static readonly toolsNotInstalled: VcVirtualMachineToolsStatus & EnumVal<'toolsNotInstalled'>;
+	static readonly toolsNotRunning: VcVirtualMachineToolsStatus & EnumVal<'toolsNotRunning'>;
+	static readonly toolsOk: VcVirtualMachineToolsStatus & EnumVal<'toolsOk'>;
+	static fromString(value: string): VcVirtualMachineToolsStatus & EnumVal<TcleanKeys<typeof VcVirtualMachineToolsStatus>>;
+
 	readonly id: string;
-	readonly toolsOk: VcVirtualMachineToolsStatus;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineToolsStatus): VcVirtualMachineToolsStatus;
+	toString: () => string;
 }
 
 /**
  * Guest operating system family constants.
  */
-declare class VcVirtualMachineGuestOsFamily {
-	readonly darwinGuestFamily: VcVirtualMachineGuestOsFamily;
-	readonly linuxGuest: VcVirtualMachineGuestOsFamily;
-	readonly name: string;
-	readonly netwareGuest: VcVirtualMachineGuestOsFamily;
-	readonly windowsGuest: VcVirtualMachineGuestOsFamily;
-	readonly otherGuestFamily: VcVirtualMachineGuestOsFamily;
+declare class VcVirtualMachineGuestOsFamily implements IPseudoEnum {
+	static readonly darwinGuestFamily: VcVirtualMachineGuestOsFamily & EnumVal<'darwinGuestFamily'>;
+	static readonly linuxGuest: VcVirtualMachineGuestOsFamily & EnumVal<'linuxGuest'>;
+	static readonly netwareGuest: VcVirtualMachineGuestOsFamily & EnumVal<'netwareGuest'>;
+	static readonly windowsGuest: VcVirtualMachineGuestOsFamily & EnumVal<'windowsGuest'>;
+	static readonly otherGuestFamily: VcVirtualMachineGuestOsFamily & EnumVal<'otherGuestFamily'>;
+	static readonly solarisGuest: VcVirtualMachineGuestOsFamily & EnumVal<'solarisGuest'>;
+	static fromString(value: string): VcVirtualMachineGuestOsFamily & EnumVal<TcleanKeys<typeof VcVirtualMachineGuestOsFamily>>;
+
 	readonly id: string;
-	readonly solarisGuest: VcVirtualMachineGuestOsFamily;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineGuestOsFamily): VcVirtualMachineGuestOsFamily;
+	toString: () => string;
 }
 
 /**
  * Set of possible values for mode field in AccessSpec.
  */
-declare class VcHostVmciAccessManagerMode {
-	readonly replace: VcHostVmciAccessManagerMode;
-	readonly name: string;
-	readonly revoke: VcHostVmciAccessManagerMode;
+declare class VcHostVmciAccessManagerMode implements IPseudoEnum {
+	static readonly replace: VcHostVmciAccessManagerMode & EnumVal<'replace'>;
+	static readonly revoke: VcHostVmciAccessManagerMode & EnumVal<'revoke'>;
+	static readonly grant: VcHostVmciAccessManagerMode & EnumVal<'grant'>;
+	static fromString(value: string): VcHostVmciAccessManagerMode & EnumVal<TcleanKeys<typeof VcHostVmciAccessManagerMode>>;
+
 	readonly id: string;
-	readonly grant: VcHostVmciAccessManagerMode;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostVmciAccessManagerMode): VcHostVmciAccessManagerMode;
+	toString: () => string;
 }
 
 /**
@@ -4202,132 +3985,125 @@ declare class VcHostVmciAccessManagerMode {
  * machine is set to disconnected if the hosts that manage the virtual
  * machine becomes unavailable.
  */
-declare class VcVirtualMachineConnectionState {
-	readonly connected: VcVirtualMachineConnectionState;
-	readonly disconnected: VcVirtualMachineConnectionState;
-	readonly inaccessible: VcVirtualMachineConnectionState;
-	readonly invalid: VcVirtualMachineConnectionState;
-	readonly name: string;
-	readonly orphaned: VcVirtualMachineConnectionState;
+declare class VcVirtualMachineConnectionState implements IPseudoEnum {
+	static readonly connected: VcVirtualMachineConnectionState & EnumVal<'connected'>;
+	static readonly disconnected: VcVirtualMachineConnectionState & EnumVal<'disconnected'>;
+	static readonly inaccessible: VcVirtualMachineConnectionState & EnumVal<'inaccessible'>;
+	static readonly invalid: VcVirtualMachineConnectionState & EnumVal<'invalid'>;
+	static readonly orphaned: VcVirtualMachineConnectionState & EnumVal<'orphaned'>;
+	static fromString(value: string): VcVirtualMachineConnectionState & EnumVal<TcleanKeys<typeof VcVirtualMachineConnectionState>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineConnectionState): VcVirtualMachineConnectionState;
+	toString: () => string;
 }
 
 /**
  * The set of access modes that are valid for a given web service
  * over the reverse proxy.
  */
-declare class VcProxyServiceAccessMode {
-	readonly httpAndHttps: VcProxyServiceAccessMode;
-	readonly httpsOnly: VcProxyServiceAccessMode;
-	readonly name: string;
-	readonly httpOnly: VcProxyServiceAccessMode;
+declare class VcProxyServiceAccessMode implements IPseudoEnum {
+	static readonly httpAndHttps: VcProxyServiceAccessMode & EnumVal<'httpAndHttps'>;
+	static readonly httpsOnly: VcProxyServiceAccessMode & EnumVal<'httpsOnly'>;
+	static readonly httpOnly: VcProxyServiceAccessMode & EnumVal<'httpOnly'>;
+	static readonly httpsWithRedirect: VcProxyServiceAccessMode & EnumVal<'httpsWithRedirect'>;
+	static fromString(value: string): VcProxyServiceAccessMode & EnumVal<TcleanKeys<typeof VcProxyServiceAccessMode>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly httpsWithRedirect: VcProxyServiceAccessMode;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcProxyServiceAccessMode): VcProxyServiceAccessMode;
+	toString: () => string;
 }
 
 /**
  * List of symbol partition types
  */
-declare class VcHostDiskPartitionInfoType {
-	readonly ntfs: VcHostDiskPartitionInfoType;
-	readonly vmfs: VcHostDiskPartitionInfoType;
-	readonly linuxNative: VcHostDiskPartitionInfoType;
-	readonly linuxSwap: VcHostDiskPartitionInfoType;
-	readonly vmkDiagnostic: VcHostDiskPartitionInfoType;
-	readonly name: string;
-	readonly vffs: VcHostDiskPartitionInfoType;
-	readonly none: VcHostDiskPartitionInfoType;
+declare class VcHostDiskPartitionInfoType implements IPseudoEnum {
+	static readonly ntfs: VcHostDiskPartitionInfoType & EnumVal<'ntfs'>;
+	static readonly vmfs: VcHostDiskPartitionInfoType & EnumVal<'vmfs'>;
+	static readonly linuxNative: VcHostDiskPartitionInfoType & EnumVal<'linuxNative'>;
+	static readonly linuxSwap: VcHostDiskPartitionInfoType & EnumVal<'linuxSwap'>;
+	static readonly vmkDiagnostic: VcHostDiskPartitionInfoType & EnumVal<'vmkDiagnostic'>;
+	static readonly vffs: VcHostDiskPartitionInfoType & EnumVal<'vffs'>;
+	static readonly none: VcHostDiskPartitionInfoType & EnumVal<'none'>;
+	static readonly extended: VcHostDiskPartitionInfoType & EnumVal<'extended'>;
+	static fromString(value: string): VcHostDiskPartitionInfoType & EnumVal<TcleanKeys<typeof VcHostDiskPartitionInfoType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly extended: VcHostDiskPartitionInfoType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostDiskPartitionInfoType): VcHostDiskPartitionInfoType;
+	toString: () => string;
 }
 
-declare class VcThirdPartyLicenseAssignmentFailedReason {
-	readonly moduleNotInstalled: VcThirdPartyLicenseAssignmentFailedReason;
-	readonly name: string;
+declare class VcThirdPartyLicenseAssignmentFailedReason implements IPseudoEnum {
+	static readonly moduleNotInstalled: VcThirdPartyLicenseAssignmentFailedReason & EnumVal<'moduleNotInstalled'>;
+	static readonly licenseAssignmentFailed: VcThirdPartyLicenseAssignmentFailedReason & EnumVal<'licenseAssignmentFailed'>;
+	static fromString(value: string): VcThirdPartyLicenseAssignmentFailedReason & EnumVal<TcleanKeys<typeof VcThirdPartyLicenseAssignmentFailedReason>>;
+
 	readonly id: string;
-	readonly licenseAssignmentFailed: VcThirdPartyLicenseAssignmentFailedReason;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcThirdPartyLicenseAssignmentFailedReason): VcThirdPartyLicenseAssignmentFailedReason;
+	toString: () => string;
 }
 
 /**
  * Overall health state for a namespace
  */
-declare class VcNvdimmNamespaceHealthStatus {
-	readonly normal: VcNvdimmNamespaceHealthStatus;
-	readonly labelInconsistent: VcNvdimmNamespaceHealthStatus;
-	readonly badBlockSize: VcNvdimmNamespaceHealthStatus;
-	readonly bttCorrupt: VcNvdimmNamespaceHealthStatus;
-	readonly interleaveBroken: VcNvdimmNamespaceHealthStatus;
-	readonly missing: VcNvdimmNamespaceHealthStatus;
-	readonly name: string;
+declare class VcNvdimmNamespaceHealthStatus implements IPseudoEnum {
+	static readonly normal: VcNvdimmNamespaceHealthStatus & EnumVal<'normal'>;
+	static readonly labelInconsistent: VcNvdimmNamespaceHealthStatus & EnumVal<'labelInconsistent'>;
+	static readonly badBlockSize: VcNvdimmNamespaceHealthStatus & EnumVal<'badBlockSize'>;
+	static readonly bttCorrupt: VcNvdimmNamespaceHealthStatus & EnumVal<'bttCorrupt'>;
+	static readonly interleaveBroken: VcNvdimmNamespaceHealthStatus & EnumVal<'interleaveBroken'>;
+	static readonly missing: VcNvdimmNamespaceHealthStatus & EnumVal<'missing'>;
+	static readonly labelMissing: VcNvdimmNamespaceHealthStatus & EnumVal<'labelMissing'>;
+	static fromString(value: string): VcNvdimmNamespaceHealthStatus & EnumVal<TcleanKeys<typeof VcNvdimmNamespaceHealthStatus>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly labelMissing: VcNvdimmNamespaceHealthStatus;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcNvdimmNamespaceHealthStatus): VcNvdimmNamespaceHealthStatus;
+	toString: () => string;
 }
 
 /**
  * Enumerates different operations supported for comparing
  * numerical values.
  */
-declare class VcProfileNumericComparator {
-	readonly equal: VcProfileNumericComparator;
-	readonly lessThanEqual: VcProfileNumericComparator;
-	readonly greaterThanEqual: VcProfileNumericComparator;
-	readonly lessThan: VcProfileNumericComparator;
-	readonly name: string;
-	readonly notEqual: VcProfileNumericComparator;
+declare class VcProfileNumericComparator implements IPseudoEnum {
+	static readonly equal: VcProfileNumericComparator & EnumVal<'equal'>;
+	static readonly lessThanEqual: VcProfileNumericComparator & EnumVal<'lessThanEqual'>;
+	static readonly greaterThanEqual: VcProfileNumericComparator & EnumVal<'greaterThanEqual'>;
+	static readonly lessThan: VcProfileNumericComparator & EnumVal<'lessThan'>;
+	static readonly notEqual: VcProfileNumericComparator & EnumVal<'notEqual'>;
+	static readonly greaterThan: VcProfileNumericComparator & EnumVal<'greaterThan'>;
+	static fromString(value: string): VcProfileNumericComparator & EnumVal<TcleanKeys<typeof VcProfileNumericComparator>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly greaterThan: VcProfileNumericComparator;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcProfileNumericComparator): VcProfileNumericComparator;
+	toString: () => string;
 }
 
 /**
  * Set of valid port protocols.
  */
-declare class VcHostFirewallRuleProtocol {
-	readonly tcp: VcHostFirewallRuleProtocol;
-	readonly udp: VcHostFirewallRuleProtocol;
-	readonly name: string;
+declare class VcHostFirewallRuleProtocol implements IPseudoEnum {
+	static readonly tcp: VcHostFirewallRuleProtocol & EnumVal<'tcp'>;
+	static readonly udp: VcHostFirewallRuleProtocol & EnumVal<'udp'>;
+	static fromString(value: string): VcHostFirewallRuleProtocol & EnumVal<TcleanKeys<typeof VcHostFirewallRuleProtocol>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostFirewallRuleProtocol): VcHostFirewallRuleProtocol;
+	toString: () => string;
 }
 
 /**
@@ -4342,158 +4118,149 @@ declare class VcHostFirewallRuleProtocol {
  * 
  * datastore: All Vms in the rule list are placed in a single datastore.
  */
-declare class VcPlacementAffinityRuleRuleScope {
-	readonly cluster: VcPlacementAffinityRuleRuleScope;
-	readonly storagePod: VcPlacementAffinityRuleRuleScope;
-	readonly datastore: VcPlacementAffinityRuleRuleScope;
-	readonly host: VcPlacementAffinityRuleRuleScope;
-	readonly name: string;
+declare class VcPlacementAffinityRuleRuleScope implements IPseudoEnum {
+	static readonly cluster: VcPlacementAffinityRuleRuleScope & EnumVal<'cluster'>;
+	static readonly storagePod: VcPlacementAffinityRuleRuleScope & EnumVal<'storagePod'>;
+	static readonly datastore: VcPlacementAffinityRuleRuleScope & EnumVal<'datastore'>;
+	static readonly host: VcPlacementAffinityRuleRuleScope & EnumVal<'host'>;
+	static fromString(value: string): VcPlacementAffinityRuleRuleScope & EnumVal<TcleanKeys<typeof VcPlacementAffinityRuleRuleScope>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcPlacementAffinityRuleRuleScope): VcPlacementAffinityRuleRuleScope;
+	toString: () => string;
 }
 
 /**
  * This option specifies how to order selected events
  */
-declare class VcEventFilterSpecOrderBy {
-	readonly eventId: VcEventFilterSpecOrderBy;
-	readonly name: string;
-	readonly createdTime: VcEventFilterSpecOrderBy;
+declare class VcEventFilterSpecOrderBy implements IPseudoEnum {
+	static readonly eventId: VcEventFilterSpecOrderBy & EnumVal<'eventId'>;
+	static readonly createdTime: VcEventFilterSpecOrderBy & EnumVal<'createdTime'>;
+	static fromString(value: string): VcEventFilterSpecOrderBy & EnumVal<TcleanKeys<typeof VcEventFilterSpecOrderBy>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcEventFilterSpecOrderBy): VcEventFilterSpecOrderBy;
+	toString: () => string;
 }
 
-declare class VcClusterInfraUpdateHaConfigInfoBehaviorType {
-	readonly Automated: VcClusterInfraUpdateHaConfigInfoBehaviorType;
-	readonly name: string;
-	readonly Manual: VcClusterInfraUpdateHaConfigInfoBehaviorType;
+declare class VcClusterInfraUpdateHaConfigInfoBehaviorType implements IPseudoEnum {
+	static readonly Automated: VcClusterInfraUpdateHaConfigInfoBehaviorType & EnumVal<'Automated'>;
+	static readonly Manual: VcClusterInfraUpdateHaConfigInfoBehaviorType & EnumVal<'Manual'>;
+	static fromString(value: string): VcClusterInfraUpdateHaConfigInfoBehaviorType & EnumVal<TcleanKeys<typeof VcClusterInfraUpdateHaConfigInfoBehaviorType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcClusterInfraUpdateHaConfigInfoBehaviorType): VcClusterInfraUpdateHaConfigInfoBehaviorType;
+	toString: () => string;
 }
 
 /**
  * Storage DRS behavior.
  */
-declare class VcStorageDrsPodConfigInfoBehavior {
-	readonly automated: VcStorageDrsPodConfigInfoBehavior;
-	readonly name: string;
+declare class VcStorageDrsPodConfigInfoBehavior implements IPseudoEnum {
+	static readonly automated: VcStorageDrsPodConfigInfoBehavior & EnumVal<'automated'>;
+	static readonly manual: VcStorageDrsPodConfigInfoBehavior & EnumVal<'manual'>;
+	static fromString(value: string): VcStorageDrsPodConfigInfoBehavior & EnumVal<TcleanKeys<typeof VcStorageDrsPodConfigInfoBehavior>>;
+
 	readonly id: string;
-	readonly manual: VcStorageDrsPodConfigInfoBehavior;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcStorageDrsPodConfigInfoBehavior): VcStorageDrsPodConfigInfoBehavior;
+	toString: () => string;
 }
 
 /**
  * Distributed Port Mirroring session Encapsulation types.
  */
-declare class VcVMwareDVSVspanSessionEncapType {
-	readonly name: string;
-	readonly erspan3: VcVMwareDVSVspanSessionEncapType;
-	readonly gre: VcVMwareDVSVspanSessionEncapType;
+declare class VcVMwareDVSVspanSessionEncapType implements IPseudoEnum {
+	static readonly erspan3: VcVMwareDVSVspanSessionEncapType & EnumVal<'erspan3'>;
+	static readonly gre: VcVMwareDVSVspanSessionEncapType & EnumVal<'gre'>;
+	static readonly erspan2: VcVMwareDVSVspanSessionEncapType & EnumVal<'erspan2'>;
+	static fromString(value: string): VcVMwareDVSVspanSessionEncapType & EnumVal<TcleanKeys<typeof VcVMwareDVSVspanSessionEncapType>>;
+
 	readonly id: string;
-	readonly erspan2: VcVMwareDVSVspanSessionEncapType;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVMwareDVSVspanSessionEncapType): VcVMwareDVSVspanSessionEncapType;
+	toString: () => string;
 }
 
 /**
  * key to uniquely identify the process group.
  */
-declare class VcHostSystemDebugManagerProcessKey {
-	readonly hostd: VcHostSystemDebugManagerProcessKey;
-	readonly name: string;
+declare class VcHostSystemDebugManagerProcessKey implements IPseudoEnum {
+	static readonly hostd: VcHostSystemDebugManagerProcessKey & EnumVal<'hostd'>;
+	static fromString(value: string): VcHostSystemDebugManagerProcessKey & EnumVal<TcleanKeys<typeof VcHostSystemDebugManagerProcessKey>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostSystemDebugManagerProcessKey): VcHostSystemDebugManagerProcessKey;
+	toString: () => string;
 }
 
 /**
  * This list specifies the type of operation being performed on the array.
  */
-declare class VcArrayUpdateOperation {
-	static readonly add: VcArrayUpdateOperation;
-	static readonly edit: VcArrayUpdateOperation;
-	static readonly name: string;
-	static readonly id: string;
-	static readonly value: string;
-	static readonly remove: VcArrayUpdateOperation;
+declare class VcArrayUpdateOperation implements IPseudoEnum {
+	static readonly add: VcArrayUpdateOperation & EnumVal<'add'>;
+	static readonly edit: VcArrayUpdateOperation & EnumVal<'edit'>;
+	static readonly remove: VcArrayUpdateOperation & EnumVal<'remove'>;
+	static fromString(value: string): VcArrayUpdateOperation & EnumVal<TcleanKeys<typeof VcArrayUpdateOperation>>;
+
+	readonly id: string;
+	readonly name: string;
+	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	static fromString(value: VcArrayUpdateOperation): VcArrayUpdateOperation;
+	toString: () => string;
 }
 
-declare class VcHostIpConfigIpV6AddressStatus {
-	readonly inaccessible: VcHostIpConfigIpV6AddressStatus;
-	readonly deprecated: VcHostIpConfigIpV6AddressStatus;
-	readonly invalid: VcHostIpConfigIpV6AddressStatus;
-	readonly name: string;
-	readonly tentative: VcHostIpConfigIpV6AddressStatus;
-	readonly duplicate: VcHostIpConfigIpV6AddressStatus;
+declare class VcHostIpConfigIpV6AddressStatus implements IPseudoEnum {
+	static readonly inaccessible: VcHostIpConfigIpV6AddressStatus & EnumVal<'inaccessible'>;
+	static readonly deprecated: VcHostIpConfigIpV6AddressStatus & EnumVal<'deprecated'>;
+	static readonly invalid: VcHostIpConfigIpV6AddressStatus & EnumVal<'invalid'>;
+	static readonly tentative: VcHostIpConfigIpV6AddressStatus & EnumVal<'tentative'>;
+	static readonly duplicate: VcHostIpConfigIpV6AddressStatus & EnumVal<'duplicate'>;
+	static readonly preferred: VcHostIpConfigIpV6AddressStatus & EnumVal<'preferred'>;
+	static readonly unknown: VcHostIpConfigIpV6AddressStatus & EnumVal<'unknown'>;
+	static fromString(value: string): VcHostIpConfigIpV6AddressStatus & EnumVal<TcleanKeys<typeof VcHostIpConfigIpV6AddressStatus>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly preferred: VcHostIpConfigIpV6AddressStatus;
-	readonly unknown: VcHostIpConfigIpV6AddressStatus;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostIpConfigIpV6AddressStatus): VcHostIpConfigIpV6AddressStatus;
+	toString: () => string;
 }
 
 /**
  * The types of virtual disks that can be created or cloned.
  */
-declare class VcVirtualDiskType {
-	readonly rdmp: VcVirtualDiskType;
-	readonly seSparse: VcVirtualDiskType;
-	readonly sparse2Gb: VcVirtualDiskType;
-	readonly preallocated: VcVirtualDiskType;
-	readonly delta: VcVirtualDiskType;
-	readonly raw: VcVirtualDiskType;
-	readonly thick: VcVirtualDiskType;
-	readonly thin: VcVirtualDiskType;
-	readonly flatMonolithic: VcVirtualDiskType;
-	readonly thick2Gb: VcVirtualDiskType;
-	readonly name: string;
-	readonly rdm: VcVirtualDiskType;
+declare class VcVirtualDiskType implements IPseudoEnum {
+	static readonly rdmp: VcVirtualDiskType & EnumVal<'rdmp'>;
+	static readonly seSparse: VcVirtualDiskType & EnumVal<'seSparse'>;
+	static readonly sparse2Gb: VcVirtualDiskType & EnumVal<'sparse2Gb'>;
+	static readonly preallocated: VcVirtualDiskType & EnumVal<'preallocated'>;
+	static readonly delta: VcVirtualDiskType & EnumVal<'delta'>;
+	static readonly raw: VcVirtualDiskType & EnumVal<'raw'>;
+	static readonly thick: VcVirtualDiskType & EnumVal<'thick'>;
+	static readonly thin: VcVirtualDiskType & EnumVal<'thin'>;
+	static readonly flatMonolithic: VcVirtualDiskType & EnumVal<'flatMonolithic'>;
+	static readonly thick2Gb: VcVirtualDiskType & EnumVal<'thick2Gb'>;
+	static readonly rdm: VcVirtualDiskType & EnumVal<'rdm'>;
+	static readonly eagerZeroedThick: VcVirtualDiskType & EnumVal<'eagerZeroedThick'>;
+	static readonly sparseMonolithic: VcVirtualDiskType & EnumVal<'sparseMonolithic'>;
+	static fromString(value: string): VcVirtualDiskType & EnumVal<TcleanKeys<typeof VcVirtualDiskType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly eagerZeroedThick: VcVirtualDiskType;
-	readonly sparseMonolithic: VcVirtualDiskType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualDiskType): VcVirtualDiskType;
+	toString: () => string;
 }
 
 /**
@@ -4501,299 +4268,282 @@ declare class VcVirtualDiskType {
  * value represents. Valid types are &#147;absolute&#148;,
  * &#147;delta&#148;, or &#147;rate&#148;.
  */
-declare class VcPerfStatsType {
-	readonly rate: VcPerfStatsType;
-	readonly absolute: VcPerfStatsType;
-	readonly delta: VcPerfStatsType;
-	readonly name: string;
+declare class VcPerfStatsType implements IPseudoEnum {
+	static readonly rate: VcPerfStatsType & EnumVal<'rate'>;
+	static readonly absolute: VcPerfStatsType & EnumVal<'absolute'>;
+	static readonly delta: VcPerfStatsType & EnumVal<'delta'>;
+	static fromString(value: string): VcPerfStatsType & EnumVal<TcleanKeys<typeof VcPerfStatsType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcPerfStatsType): VcPerfStatsType;
+	toString: () => string;
 }
 
 /**
  * Defines the possible states of lockdown mode.
  */
-declare class VcHostLockdownMode {
-	static lockdownDisabled: VcHostLockdownMode;
-	static name: string;
-	static id: string;
-	static lockdownStrict: VcHostLockdownMode;
-	static value: string;
-	static lockdownNormal: VcHostLockdownMode;
+declare class VcHostLockdownMode implements IPseudoEnum {
+	static readonly lockdownDisabled: VcHostLockdownMode & EnumVal<'lockdownDisabled'>;
+	static readonly lockdownStrict: VcHostLockdownMode & EnumVal<'lockdownStrict'>;
+	static readonly lockdownNormal: VcHostLockdownMode & EnumVal<'lockdownNormal'>;
+	static fromString(value: string): VcHostLockdownMode & EnumVal<TcleanKeys<typeof VcHostLockdownMode>>;
+
+	readonly id: string;
+	readonly name: string;
+	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	static fromString(value: VcHostLockdownMode): VcHostLockdownMode;
+	toString: () => string;
 }
 
 /**
  * List of possible file system interfaces
  */
-declare class FileSystemInterface {
-	readonly name: string;
-	readonly nfs: FileSystemInterface;
+declare class FileSystemInterface implements IPseudoEnum {
+	static readonly nfs: FileSystemInterface & EnumVal<'nfs'>;
+	static readonly otherFileSystem: FileSystemInterface & EnumVal<'otherFileSystem'>;
+	static fromString(value: string): FileSystemInterface & EnumVal<TcleanKeys<typeof FileSystemInterface>>;
+
 	readonly id: string;
-	readonly otherFileSystem: FileSystemInterface;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: FileSystemInterface): FileSystemInterface;
+	toString: () => string;
 }
 
 /**
  * Alarm triggering type. The main divisions are event triggered and
  * metric based alarms.
  */
-declare class VcAlarmFilterSpecAlarmTypeByTrigger {
-	readonly triggerTypeMetric: VcAlarmFilterSpecAlarmTypeByTrigger;
-	readonly triggerTypeAll: VcAlarmFilterSpecAlarmTypeByTrigger;
-	readonly triggerTypeEvent: VcAlarmFilterSpecAlarmTypeByTrigger;
-	readonly name: string;
+declare class VcAlarmFilterSpecAlarmTypeByTrigger implements IPseudoEnum {
+	static readonly triggerTypeMetric: VcAlarmFilterSpecAlarmTypeByTrigger & EnumVal<'triggerTypeMetric'>;
+	static readonly triggerTypeAll: VcAlarmFilterSpecAlarmTypeByTrigger & EnumVal<'triggerTypeAll'>;
+	static readonly triggerTypeEvent: VcAlarmFilterSpecAlarmTypeByTrigger & EnumVal<'triggerTypeEvent'>;
+	static fromString(value: string): VcAlarmFilterSpecAlarmTypeByTrigger & EnumVal<TcleanKeys<typeof VcAlarmFilterSpecAlarmTypeByTrigger>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcAlarmFilterSpecAlarmTypeByTrigger): VcAlarmFilterSpecAlarmTypeByTrigger;
+	toString: () => string;
 }
 
 /**
  * Link Aggregation Control Protocol API versions.
  */
-declare class VcVMwareDvsLacpApiVersion {
-	readonly singleLag: VcVMwareDvsLacpApiVersion;
-	readonly multipleLag: VcVMwareDvsLacpApiVersion;
-	readonly name: string;
+declare class VcVMwareDvsLacpApiVersion implements IPseudoEnum {
+	static readonly singleLag: VcVMwareDvsLacpApiVersion & EnumVal<'singleLag'>;
+	static readonly multipleLag: VcVMwareDvsLacpApiVersion & EnumVal<'multipleLag'>;
+	static fromString(value: string): VcVMwareDvsLacpApiVersion & EnumVal<TcleanKeys<typeof VcVMwareDvsLacpApiVersion>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVMwareDvsLacpApiVersion): VcVMwareDvsLacpApiVersion;
+	toString: () => string;
 }
 
 /**
  * Indicates the unit of measure represented by a counter or statistical
  * value.
  */
-declare class VcPerformanceManagerUnit {
-	readonly joule: VcPerformanceManagerUnit;
-	readonly megaHertz: VcPerformanceManagerUnit;
-	readonly kiloBytesPerSecond: VcPerformanceManagerUnit;
-	readonly megaBytes: VcPerformanceManagerUnit;
-	readonly millisecond: VcPerformanceManagerUnit;
-	readonly teraBytes: VcPerformanceManagerUnit;
-	readonly percent: VcPerformanceManagerUnit;
-	readonly second: VcPerformanceManagerUnit;
-	readonly megaBytesPerSecond: VcPerformanceManagerUnit;
-	readonly kiloBytes: VcPerformanceManagerUnit;
-	readonly number: VcPerformanceManagerUnit;
-	readonly microsecond: VcPerformanceManagerUnit;
-	readonly celsius: VcPerformanceManagerUnit;
-	readonly name: string;
+declare class VcPerformanceManagerUnit implements IPseudoEnum {
+	static readonly joule: VcPerformanceManagerUnit & EnumVal<'joule'>;
+	static readonly megaHertz: VcPerformanceManagerUnit & EnumVal<'megaHertz'>;
+	static readonly kiloBytesPerSecond: VcPerformanceManagerUnit & EnumVal<'kiloBytesPerSecond'>;
+	static readonly megaBytes: VcPerformanceManagerUnit & EnumVal<'megaBytes'>;
+	static readonly millisecond: VcPerformanceManagerUnit & EnumVal<'millisecond'>;
+	static readonly teraBytes: VcPerformanceManagerUnit & EnumVal<'teraBytes'>;
+	static readonly percent: VcPerformanceManagerUnit & EnumVal<'percent'>;
+	static readonly second: VcPerformanceManagerUnit & EnumVal<'second'>;
+	static readonly megaBytesPerSecond: VcPerformanceManagerUnit & EnumVal<'megaBytesPerSecond'>;
+	static readonly kiloBytes: VcPerformanceManagerUnit & EnumVal<'kiloBytes'>;
+	static readonly number: VcPerformanceManagerUnit & EnumVal<'number'>;
+	static readonly microsecond: VcPerformanceManagerUnit & EnumVal<'microsecond'>;
+	static readonly celsius: VcPerformanceManagerUnit & EnumVal<'celsius'>;
+	static readonly watt: VcPerformanceManagerUnit & EnumVal<'watt'>;
+	static fromString(value: string): VcPerformanceManagerUnit & EnumVal<TcleanKeys<typeof VcPerformanceManagerUnit>>;
+
 	readonly id: string;
-	readonly watt: VcPerformanceManagerUnit;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcPerformanceManagerUnit): VcPerformanceManagerUnit;
+	toString: () => string;
 }
 
 /**
  * Distributed Port Mirroring session types.
  */
-declare class VcVMwareDVSVspanSessionType {
-	readonly remoteMirrorSource: VcVMwareDVSVspanSessionType;
-	readonly remoteMirrorDest: VcVMwareDVSVspanSessionType;
-	readonly mixedDestMirror: VcVMwareDVSVspanSessionType;
-	readonly encapsulatedRemoteMirrorSource: VcVMwareDVSVspanSessionType;
-	readonly name: string;
-	readonly dvPortMirror: VcVMwareDVSVspanSessionType;
+declare class VcVMwareDVSVspanSessionType implements IPseudoEnum {
+	static readonly remoteMirrorSource: VcVMwareDVSVspanSessionType & EnumVal<'remoteMirrorSource'>;
+	static readonly remoteMirrorDest: VcVMwareDVSVspanSessionType & EnumVal<'remoteMirrorDest'>;
+	static readonly mixedDestMirror: VcVMwareDVSVspanSessionType & EnumVal<'mixedDestMirror'>;
+	static readonly encapsulatedRemoteMirrorSource: VcVMwareDVSVspanSessionType & EnumVal<'encapsulatedRemoteMirrorSource'>;
+	static readonly dvPortMirror: VcVMwareDVSVspanSessionType & EnumVal<'dvPortMirror'>;
+	static fromString(value: string): VcVMwareDVSVspanSessionType & EnumVal<TcleanKeys<typeof VcVMwareDVSVspanSessionType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVMwareDVSVspanSessionType): VcVMwareDVSVspanSessionType;
+	toString: () => string;
 }
 
-declare class VcHealthUpdateInfoComponentType {
-	readonly Fan: VcHealthUpdateInfoComponentType;
-	readonly Storage: VcHealthUpdateInfoComponentType;
-	readonly Memory: VcHealthUpdateInfoComponentType;
-	readonly Network: VcHealthUpdateInfoComponentType;
-	readonly name: string;
+declare class VcHealthUpdateInfoComponentType implements IPseudoEnum {
+	static readonly Fan: VcHealthUpdateInfoComponentType & EnumVal<'Fan'>;
+	static readonly Storage: VcHealthUpdateInfoComponentType & EnumVal<'Storage'>;
+	static readonly Memory: VcHealthUpdateInfoComponentType & EnumVal<'Memory'>;
+	static readonly Network: VcHealthUpdateInfoComponentType & EnumVal<'Network'>;
+	static readonly Power: VcHealthUpdateInfoComponentType & EnumVal<'Power'>;
+	static fromString(value: string): VcHealthUpdateInfoComponentType & EnumVal<TcleanKeys<typeof VcHealthUpdateInfoComponentType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly Power: VcHealthUpdateInfoComponentType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHealthUpdateInfoComponentType): VcHealthUpdateInfoComponentType;
+	toString: () => string;
 }
 
 /**
  * Describes the state of the feature.
  */
-declare class VcLicenseFeatureInfoState {
-	readonly name: string;
-	readonly disabled: VcLicenseFeatureInfoState;
-	readonly optional: VcLicenseFeatureInfoState;
+declare class VcLicenseFeatureInfoState implements IPseudoEnum {
+	static readonly disabled: VcLicenseFeatureInfoState & EnumVal<'disabled'>;
+	static readonly optional: VcLicenseFeatureInfoState & EnumVal<'optional'>;
+	static readonly enabled: VcLicenseFeatureInfoState & EnumVal<'enabled'>;
+	static fromString(value: string): VcLicenseFeatureInfoState & EnumVal<TcleanKeys<typeof VcLicenseFeatureInfoState>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly enabled: VcLicenseFeatureInfoState;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcLicenseFeatureInfoState): VcLicenseFeatureInfoState;
+	toString: () => string;
 }
 
 /**
  * The provisioing policy action.
  */
-declare class VcVirtualMachineProvisioningPolicyAction {
-	readonly keep: VcVirtualMachineProvisioningPolicyAction;
-	readonly name: string;
+declare class VcVirtualMachineProvisioningPolicyAction implements IPseudoEnum {
+	static readonly keep: VcVirtualMachineProvisioningPolicyAction & EnumVal<'keep'>;
+	static readonly remove: VcVirtualMachineProvisioningPolicyAction & EnumVal<'remove'>;
+	static fromString(value: string): VcVirtualMachineProvisioningPolicyAction & EnumVal<TcleanKeys<typeof VcVirtualMachineProvisioningPolicyAction>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly remove: VcVirtualMachineProvisioningPolicyAction;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineProvisioningPolicyAction): VcVirtualMachineProvisioningPolicyAction;
+	toString: () => string;
 }
 
 /**
  * IP allocation policy for a deployment.
  */
-declare class VcVAppIPAssignmentInfoIpAllocationPolicy {
-	readonly transientPolicy: VcVAppIPAssignmentInfoIpAllocationPolicy;
-	readonly fixedAllocatedPolicy: VcVAppIPAssignmentInfoIpAllocationPolicy;
-	readonly name: string;
+declare class VcVAppIPAssignmentInfoIpAllocationPolicy implements IPseudoEnum {
+	static readonly transientPolicy: VcVAppIPAssignmentInfoIpAllocationPolicy & EnumVal<'transientPolicy'>;
+	static readonly fixedAllocatedPolicy: VcVAppIPAssignmentInfoIpAllocationPolicy & EnumVal<'fixedAllocatedPolicy'>;
+	static readonly dhcpPolicy: VcVAppIPAssignmentInfoIpAllocationPolicy & EnumVal<'dhcpPolicy'>;
+	static readonly fixedPolicy: VcVAppIPAssignmentInfoIpAllocationPolicy & EnumVal<'fixedPolicy'>;
+	static fromString(value: string): VcVAppIPAssignmentInfoIpAllocationPolicy & EnumVal<TcleanKeys<typeof VcVAppIPAssignmentInfoIpAllocationPolicy>>;
+
 	readonly id: string;
-	readonly dhcpPolicy: VcVAppIPAssignmentInfoIpAllocationPolicy;
-	readonly fixedPolicy: VcVAppIPAssignmentInfoIpAllocationPolicy;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVAppIPAssignmentInfoIpAllocationPolicy): VcVAppIPAssignmentInfoIpAllocationPolicy;
+	toString: () => string;
 }
 
 /**
  * The valid values for the "option" flag in fetchPortState function.
  */
-declare class VcHostDistributedVirtualSwitchManagerFetchPortOption {
-	readonly runtimeInfoOnly: VcHostDistributedVirtualSwitchManagerFetchPortOption;
-	readonly statsOnly: VcHostDistributedVirtualSwitchManagerFetchPortOption;
-	readonly stateBlobOnly: VcHostDistributedVirtualSwitchManagerFetchPortOption;
-	readonly name: string;
+declare class VcHostDistributedVirtualSwitchManagerFetchPortOption implements IPseudoEnum {
+	static readonly runtimeInfoOnly: VcHostDistributedVirtualSwitchManagerFetchPortOption & EnumVal<'runtimeInfoOnly'>;
+	static readonly statsOnly: VcHostDistributedVirtualSwitchManagerFetchPortOption & EnumVal<'statsOnly'>;
+	static readonly stateBlobOnly: VcHostDistributedVirtualSwitchManagerFetchPortOption & EnumVal<'stateBlobOnly'>;
+	static fromString(value: string): VcHostDistributedVirtualSwitchManagerFetchPortOption & EnumVal<TcleanKeys<typeof VcHostDistributedVirtualSwitchManagerFetchPortOption>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostDistributedVirtualSwitchManagerFetchPortOption): VcHostDistributedVirtualSwitchManagerFetchPortOption;
+	toString: () => string;
 }
 
 /**
  * List of supported algorithms for checksum calculation.
  */
-declare class VcHttpNfcLeaseManifestEntryChecksumType {
-	readonly sha1: VcHttpNfcLeaseManifestEntryChecksumType;
-	readonly sha256: VcHttpNfcLeaseManifestEntryChecksumType;
-	readonly name: string;
+declare class VcHttpNfcLeaseManifestEntryChecksumType implements IPseudoEnum {
+	static readonly sha1: VcHttpNfcLeaseManifestEntryChecksumType & EnumVal<'sha1'>;
+	static readonly sha256: VcHttpNfcLeaseManifestEntryChecksumType & EnumVal<'sha256'>;
+	static fromString(value: string): VcHttpNfcLeaseManifestEntryChecksumType & EnumVal<TcleanKeys<typeof VcHttpNfcLeaseManifestEntryChecksumType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHttpNfcLeaseManifestEntryChecksumType): VcHttpNfcLeaseManifestEntryChecksumType;
+	toString: () => string;
 }
 
 /**
  * Define the instance identifier for different traffic type
  */
-declare class VcHostNetStackInstanceSystemStackKey {
-	readonly vSphereProvisioning: VcHostNetStackInstanceSystemStackKey;
-	readonly name: string;
-	readonly defaultTcpipStack: VcHostNetStackInstanceSystemStackKey;
+declare class VcHostNetStackInstanceSystemStackKey implements IPseudoEnum {
+	static readonly vSphereProvisioning: VcHostNetStackInstanceSystemStackKey & EnumVal<'vSphereProvisioning'>;
+	static readonly defaultTcpipStack: VcHostNetStackInstanceSystemStackKey & EnumVal<'defaultTcpipStack'>;
+	static readonly vmotion: VcHostNetStackInstanceSystemStackKey & EnumVal<'vmotion'>;
+	static fromString(value: string): VcHostNetStackInstanceSystemStackKey & EnumVal<TcleanKeys<typeof VcHostNetStackInstanceSystemStackKey>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly vmotion: VcHostNetStackInstanceSystemStackKey;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostNetStackInstanceSystemStackKey): VcHostNetStackInstanceSystemStackKey;
+	toString: () => string;
 }
 
 /**
  * List of possible states of a task.
  */
-declare class SmsTaskState {
-	readonly running: SmsTaskState;
-	readonly success: SmsTaskState;
-	readonly queued: SmsTaskState;
-	readonly name: string;
+declare class SmsTaskState implements IPseudoEnum {
+	static readonly running: SmsTaskState & EnumVal<'running'>;
+	static readonly success: SmsTaskState & EnumVal<'success'>;
+	static readonly queued: SmsTaskState & EnumVal<'queued'>;
+	static readonly error: SmsTaskState & EnumVal<'error'>;
+	static fromString(value: string): SmsTaskState & EnumVal<TcleanKeys<typeof SmsTaskState>>;
+
 	readonly id: string;
-	readonly error: SmsTaskState;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: SmsTaskState): SmsTaskState;
+	toString: () => string;
 }
 
 /**
  * Health state of the numeric sensor as reported by the sensor probes.
  * Same data reported using command line: esxcli hardware ipmi sdr list
  */
-declare class VcHostNumericSensorHealthState {
-	readonly red: VcHostNumericSensorHealthState;
-	readonly green: VcHostNumericSensorHealthState;
-	readonly yellow: VcHostNumericSensorHealthState;
-	readonly name: string;
+declare class VcHostNumericSensorHealthState implements IPseudoEnum {
+	static readonly red: VcHostNumericSensorHealthState & EnumVal<'red'>;
+	static readonly green: VcHostNumericSensorHealthState & EnumVal<'green'>;
+	static readonly yellow: VcHostNumericSensorHealthState & EnumVal<'yellow'>;
+	static readonly unknown: VcHostNumericSensorHealthState & EnumVal<'unknown'>;
+	static fromString(value: string): VcHostNumericSensorHealthState & EnumVal<TcleanKeys<typeof VcHostNumericSensorHealthState>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly unknown: VcHostNumericSensorHealthState;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostNumericSensorHealthState): VcHostNumericSensorHealthState;
+	toString: () => string;
 }
 
-declare class FileSystemInterfaceVersion {
-	readonly name: string;
-	readonly NFSV3_0: FileSystemInterfaceVersion;
+declare class FileSystemInterfaceVersion implements IPseudoEnum {
+	static readonly NFSV3_0: FileSystemInterfaceVersion & EnumVal<'NFSV3_0'>;
+	static fromString(value: string): FileSystemInterfaceVersion & EnumVal<TcleanKeys<typeof FileSystemInterfaceVersion>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: FileSystemInterfaceVersion): FileSystemInterfaceVersion;
+	toString: () => string;
 }
 
 /**
@@ -4804,55 +4554,52 @@ declare class FileSystemInterfaceVersion {
  * isnsMethod: Internet Storage Name Service discovery
  * unknownMethod: discovery method not identified by iscsi stack
  */
-declare class VcHostInternetScsiHbaStaticTargetTargetDiscoveryMethod {
-	readonly isnsMethod: VcHostInternetScsiHbaStaticTargetTargetDiscoveryMethod;
-	readonly unknownMethod: VcHostInternetScsiHbaStaticTargetTargetDiscoveryMethod;
-	readonly name: string;
-	readonly slpMethod: VcHostInternetScsiHbaStaticTargetTargetDiscoveryMethod;
+declare class VcHostInternetScsiHbaStaticTargetTargetDiscoveryMethod implements IPseudoEnum {
+	static readonly isnsMethod: VcHostInternetScsiHbaStaticTargetTargetDiscoveryMethod & EnumVal<'isnsMethod'>;
+	static readonly unknownMethod: VcHostInternetScsiHbaStaticTargetTargetDiscoveryMethod & EnumVal<'unknownMethod'>;
+	static readonly slpMethod: VcHostInternetScsiHbaStaticTargetTargetDiscoveryMethod & EnumVal<'slpMethod'>;
+	static readonly staticMethod: VcHostInternetScsiHbaStaticTargetTargetDiscoveryMethod & EnumVal<'staticMethod'>;
+	static readonly sendTargetMethod: VcHostInternetScsiHbaStaticTargetTargetDiscoveryMethod & EnumVal<'sendTargetMethod'>;
+	static fromString(value: string): VcHostInternetScsiHbaStaticTargetTargetDiscoveryMethod & EnumVal<TcleanKeys<typeof VcHostInternetScsiHbaStaticTargetTargetDiscoveryMethod>>;
+
 	readonly id: string;
-	readonly staticMethod: VcHostInternetScsiHbaStaticTargetTargetDiscoveryMethod;
-	readonly sendTargetMethod: VcHostInternetScsiHbaStaticTargetTargetDiscoveryMethod;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostInternetScsiHbaStaticTargetTargetDiscoveryMethod): VcHostInternetScsiHbaStaticTargetTargetDiscoveryMethod;
+	toString: () => string;
 }
 
 /**
  * Acceptance level definitions
  */
-declare class VcHostImageAcceptanceLevel {
-	readonly partner: VcHostImageAcceptanceLevel;
-	readonly vmware_certified: VcHostImageAcceptanceLevel;
-	readonly name: string;
+declare class VcHostImageAcceptanceLevel implements IPseudoEnum {
+	static readonly partner: VcHostImageAcceptanceLevel & EnumVal<'partner'>;
+	static readonly vmware_certified: VcHostImageAcceptanceLevel & EnumVal<'vmware_certified'>;
+	static readonly vmware_accepted: VcHostImageAcceptanceLevel & EnumVal<'vmware_accepted'>;
+	static readonly community: VcHostImageAcceptanceLevel & EnumVal<'community'>;
+	static fromString(value: string): VcHostImageAcceptanceLevel & EnumVal<TcleanKeys<typeof VcHostImageAcceptanceLevel>>;
+
 	readonly id: string;
-	readonly vmware_accepted: VcHostImageAcceptanceLevel;
-	readonly community: VcHostImageAcceptanceLevel;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostImageAcceptanceLevel): VcHostImageAcceptanceLevel;
+	toString: () => string;
 }
 
 /**
  * Possible values for Current CPU power management policy
  */
-declare class VcHostCpuPowerManagementInfoPolicyType {
-	readonly name: string;
-	readonly dynamicPolicy: VcHostCpuPowerManagementInfoPolicyType;
-	readonly staticPolicy: VcHostCpuPowerManagementInfoPolicyType;
+declare class VcHostCpuPowerManagementInfoPolicyType implements IPseudoEnum {
+	static readonly dynamicPolicy: VcHostCpuPowerManagementInfoPolicyType & EnumVal<'dynamicPolicy'>;
+	static readonly staticPolicy: VcHostCpuPowerManagementInfoPolicyType & EnumVal<'staticPolicy'>;
+	static readonly off: VcHostCpuPowerManagementInfoPolicyType & EnumVal<'off'>;
+	static fromString(value: string): VcHostCpuPowerManagementInfoPolicyType & EnumVal<TcleanKeys<typeof VcHostCpuPowerManagementInfoPolicyType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly off: VcHostCpuPowerManagementInfoPolicyType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostCpuPowerManagementInfoPolicyType): VcHostCpuPowerManagementInfoPolicyType;
+	toString: () => string;
 }
 
 /**
@@ -4860,147 +4607,139 @@ declare class VcHostCpuPowerManagementInfoPolicyType {
  * entity.
  * <p>
  */
-declare class VcHostConfigChangeOperation {
-	readonly add: VcHostConfigChangeOperation;
-	readonly edit: VcHostConfigChangeOperation;
-	readonly name: string;
-	readonly ignore: VcHostConfigChangeOperation;
+declare class VcHostConfigChangeOperation implements IPseudoEnum {
+	static readonly add: VcHostConfigChangeOperation & EnumVal<'add'>;
+	static readonly edit: VcHostConfigChangeOperation & EnumVal<'edit'>;
+	static readonly ignore: VcHostConfigChangeOperation & EnumVal<'ignore'>;
+	static readonly remove: VcHostConfigChangeOperation & EnumVal<'remove'>;
+	static fromString(value: string): VcHostConfigChangeOperation & EnumVal<TcleanKeys<typeof VcHostConfigChangeOperation>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly remove: VcHostConfigChangeOperation;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostConfigChangeOperation): VcHostConfigChangeOperation;
+	toString: () => string;
 }
 
 /**
  * The possible hints that the guest could display about current tasks
  * inside the guest.
  */
-declare class VcVirtualMachineGuestState {
-	readonly running: VcVirtualMachineGuestState;
-	readonly resetting: VcVirtualMachineGuestState;
-	readonly shuttingDown: VcVirtualMachineGuestState;
-	readonly standby: VcVirtualMachineGuestState;
-	readonly notRunning: VcVirtualMachineGuestState;
-	readonly name: string;
+declare class VcVirtualMachineGuestState implements IPseudoEnum {
+	static readonly running: VcVirtualMachineGuestState & EnumVal<'running'>;
+	static readonly resetting: VcVirtualMachineGuestState & EnumVal<'resetting'>;
+	static readonly shuttingDown: VcVirtualMachineGuestState & EnumVal<'shuttingDown'>;
+	static readonly standby: VcVirtualMachineGuestState & EnumVal<'standby'>;
+	static readonly notRunning: VcVirtualMachineGuestState & EnumVal<'notRunning'>;
+	static readonly unknown: VcVirtualMachineGuestState & EnumVal<'unknown'>;
+	static fromString(value: string): VcVirtualMachineGuestState & EnumVal<TcleanKeys<typeof VcVirtualMachineGuestState>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly unknown: VcVirtualMachineGuestState;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineGuestState): VcVirtualMachineGuestState;
+	toString: () => string;
 }
 
 /**
  * An indicator of how a memory range is being used
  */
-declare class VcNvdimmRangeType {
-	readonly volatileVirtualDiskRange: VcNvdimmRangeType;
-	readonly controlRange: VcNvdimmRangeType;
-	readonly persistentVirtualCDRange: VcNvdimmRangeType;
-	readonly volatileRange: VcNvdimmRangeType;
-	readonly persistentVirtualDiskRange: VcNvdimmRangeType;
-	readonly name: string;
+declare class VcNvdimmRangeType implements IPseudoEnum {
+	static readonly volatileVirtualDiskRange: VcNvdimmRangeType & EnumVal<'volatileVirtualDiskRange'>;
+	static readonly controlRange: VcNvdimmRangeType & EnumVal<'controlRange'>;
+	static readonly persistentVirtualCDRange: VcNvdimmRangeType & EnumVal<'persistentVirtualCDRange'>;
+	static readonly volatileRange: VcNvdimmRangeType & EnumVal<'volatileRange'>;
+	static readonly persistentVirtualDiskRange: VcNvdimmRangeType & EnumVal<'persistentVirtualDiskRange'>;
+	static readonly persistentRange: VcNvdimmRangeType & EnumVal<'persistentRange'>;
+	static readonly volatileVirtualCDRange: VcNvdimmRangeType & EnumVal<'volatileVirtualCDRange'>;
+	static readonly blockRange: VcNvdimmRangeType & EnumVal<'blockRange'>;
+	static fromString(value: string): VcNvdimmRangeType & EnumVal<TcleanKeys<typeof VcNvdimmRangeType>>;
+
 	readonly id: string;
-	readonly persistentRange: VcNvdimmRangeType;
+	readonly name: string;
 	readonly value: string;
-	readonly volatileVirtualCDRange: VcNvdimmRangeType;
-	readonly blockRange: VcNvdimmRangeType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcNvdimmRangeType): VcNvdimmRangeType;
+	toString: () => string;
 }
 
 /**
  * Set of valid service policy strings.
  */
-declare class VcHostServicePolicy {
-	readonly name: string;
-	readonly automatic: VcHostServicePolicy;
+declare class VcHostServicePolicy implements IPseudoEnum {
+	static readonly automatic: VcHostServicePolicy & EnumVal<'automatic'>;
+	static readonly off: VcHostServicePolicy & EnumVal<'off'>;
+	static readonly on: VcHostServicePolicy & EnumVal<'on'>;
+	static fromString(value: string): VcHostServicePolicy & EnumVal<TcleanKeys<typeof VcHostServicePolicy>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly off: VcHostServicePolicy;
-	readonly on: VcHostServicePolicy;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostServicePolicy): VcHostServicePolicy;
+	toString: () => string;
 }
 
 /**
  * The delta disk format constants
  */
-declare class VcVirtualDiskDeltaDiskFormat {
-	readonly seSparseFormat: VcVirtualDiskDeltaDiskFormat;
-	readonly nativeFormat: VcVirtualDiskDeltaDiskFormat;
-	readonly name: string;
-	readonly redoLogFormat: VcVirtualDiskDeltaDiskFormat;
+declare class VcVirtualDiskDeltaDiskFormat implements IPseudoEnum {
+	static readonly seSparseFormat: VcVirtualDiskDeltaDiskFormat & EnumVal<'seSparseFormat'>;
+	static readonly nativeFormat: VcVirtualDiskDeltaDiskFormat & EnumVal<'nativeFormat'>;
+	static readonly redoLogFormat: VcVirtualDiskDeltaDiskFormat & EnumVal<'redoLogFormat'>;
+	static fromString(value: string): VcVirtualDiskDeltaDiskFormat & EnumVal<TcleanKeys<typeof VcVirtualDiskDeltaDiskFormat>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualDiskDeltaDiskFormat): VcVirtualDiskDeltaDiskFormat;
+	toString: () => string;
 }
 
 /**
  * Internal event type to process vmfs datastore
  */
-declare class VcHostDatastoreSystemVmfsEventType {
-	readonly Extend: VcHostDatastoreSystemVmfsEventType;
-	readonly Create: VcHostDatastoreSystemVmfsEventType;
-	readonly Expand: VcHostDatastoreSystemVmfsEventType;
-	readonly name: string;
-	readonly Remove: VcHostDatastoreSystemVmfsEventType;
+declare class VcHostDatastoreSystemVmfsEventType implements IPseudoEnum {
+	static readonly Extend: VcHostDatastoreSystemVmfsEventType & EnumVal<'Extend'>;
+	static readonly Create: VcHostDatastoreSystemVmfsEventType & EnumVal<'Create'>;
+	static readonly Expand: VcHostDatastoreSystemVmfsEventType & EnumVal<'Expand'>;
+	static readonly Remove: VcHostDatastoreSystemVmfsEventType & EnumVal<'Remove'>;
+	static fromString(value: string): VcHostDatastoreSystemVmfsEventType & EnumVal<TcleanKeys<typeof VcHostDatastoreSystemVmfsEventType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostDatastoreSystemVmfsEventType): VcHostDatastoreSystemVmfsEventType;
+	toString: () => string;
 }
 
 /**
  * Set of constants defining the possible states of a multipath path.
  */
-declare class VcMultipathState {
-	readonly standby: VcMultipathState;
-	readonly name: string;
-	readonly active: VcMultipathState;
-	readonly disabled: VcMultipathState;
-	readonly dead: VcMultipathState;
+declare class VcMultipathState implements IPseudoEnum {
+	static readonly standby: VcMultipathState & EnumVal<'standby'>;
+	static readonly active: VcMultipathState & EnumVal<'active'>;
+	static readonly disabled: VcMultipathState & EnumVal<'disabled'>;
+	static readonly dead: VcMultipathState & EnumVal<'dead'>;
+	static readonly unknown: VcMultipathState & EnumVal<'unknown'>;
+	static fromString(value: string): VcMultipathState & EnumVal<TcleanKeys<typeof VcMultipathState>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly unknown: VcMultipathState;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcMultipathState): VcMultipathState;
+	toString: () => string;
 }
 
-declare class VcVchaNodeRole {
-	readonly witness: VcVchaNodeRole;
-	readonly name: string;
-	readonly active: VcVchaNodeRole;
+declare class VcVchaNodeRole implements IPseudoEnum {
+	static readonly witness: VcVchaNodeRole & EnumVal<'witness'>;
+	static readonly active: VcVchaNodeRole & EnumVal<'active'>;
+	static readonly passive: VcVchaNodeRole & EnumVal<'passive'>;
+	static fromString(value: string): VcVchaNodeRole & EnumVal<TcleanKeys<typeof VcVchaNodeRole>>;
+
 	readonly id: string;
-	readonly passive: VcVchaNodeRole;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVchaNodeRole): VcVchaNodeRole;
+	toString: () => string;
 }
 
 /**
@@ -5008,237 +4747,233 @@ declare class VcVchaNodeRole {
  * {@link vim.host.Capability#replayUnsupportedReason} and
  * {@link vim.host.Capability#replayCompatibilityIssues}.
  */
-declare class VcHostReplayUnsupportedReason {
-	readonly incompatibleCpu: VcHostReplayUnsupportedReason;
-	readonly cpuidLimitSet: VcHostReplayUnsupportedReason;
-	readonly incompatibleProduct: VcHostReplayUnsupportedReason;
-	readonly name: string;
-	readonly hvDisabled: VcHostReplayUnsupportedReason;
+declare class VcHostReplayUnsupportedReason implements IPseudoEnum {
+	static readonly incompatibleCpu: VcHostReplayUnsupportedReason & EnumVal<'incompatibleCpu'>;
+	static readonly cpuidLimitSet: VcHostReplayUnsupportedReason & EnumVal<'cpuidLimitSet'>;
+	static readonly incompatibleProduct: VcHostReplayUnsupportedReason & EnumVal<'incompatibleProduct'>;
+	static readonly hvDisabled: VcHostReplayUnsupportedReason & EnumVal<'hvDisabled'>;
+	static readonly oldBIOS: VcHostReplayUnsupportedReason & EnumVal<'oldBIOS'>;
+	static readonly unknown: VcHostReplayUnsupportedReason & EnumVal<'unknown'>;
+	static fromString(value: string): VcHostReplayUnsupportedReason & EnumVal<TcleanKeys<typeof VcHostReplayUnsupportedReason>>;
+
 	readonly id: string;
-	readonly oldBIOS: VcHostReplayUnsupportedReason;
+	readonly name: string;
 	readonly value: string;
-	readonly unknown: VcHostReplayUnsupportedReason;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostReplayUnsupportedReason): VcHostReplayUnsupportedReason;
+	toString: () => string;
 }
 
 /**
  * The types of virtual disk adapters used by virtual disks
  */
-declare class VcVirtualDiskAdapterType {
-	readonly busLogic: VcVirtualDiskAdapterType;
-	readonly lsiLogic: VcVirtualDiskAdapterType;
-	readonly name: string;
-	readonly ide: VcVirtualDiskAdapterType;
+declare class VcVirtualDiskAdapterType implements IPseudoEnum {
+	static readonly busLogic: VcVirtualDiskAdapterType & EnumVal<'busLogic'>;
+	static readonly lsiLogic: VcVirtualDiskAdapterType & EnumVal<'lsiLogic'>;
+	static readonly ide: VcVirtualDiskAdapterType & EnumVal<'ide'>;
+	static fromString(value: string): VcVirtualDiskAdapterType & EnumVal<TcleanKeys<typeof VcVirtualDiskAdapterType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualDiskAdapterType): VcVirtualDiskAdapterType;
+	toString: () => string;
 }
 
 /**
  * File-type constants.
  */
-declare class VcVirtualMachineFileLayoutExFileType {
-	readonly extendedConfig: VcVirtualMachineFileLayoutExFileType;
-	readonly log: VcVirtualMachineFileLayoutExFileType;
-	readonly digestExtent: VcVirtualMachineFileLayoutExFileType;
-	readonly screenshot: VcVirtualMachineFileLayoutExFileType;
-	readonly ftMetadata: VcVirtualMachineFileLayoutExFileType;
-	readonly snapshotMemory: VcVirtualMachineFileLayoutExFileType;
-	readonly nvram: VcVirtualMachineFileLayoutExFileType;
-	readonly diskExtent: VcVirtualMachineFileLayoutExFileType;
-	readonly diskDescriptor: VcVirtualMachineFileLayoutExFileType;
-	readonly digestDescriptor: VcVirtualMachineFileLayoutExFileType;
-	readonly id: string;
-	readonly uwswap: VcVirtualMachineFileLayoutExFileType;
-	readonly value: string;
-	readonly suspendMemory: VcVirtualMachineFileLayoutExFileType;
-	readonly suspend: VcVirtualMachineFileLayoutExFileType;
-	readonly stat: VcVirtualMachineFileLayoutExFileType;
-	readonly swap: VcVirtualMachineFileLayoutExFileType;
-	readonly diskReplicationState: VcVirtualMachineFileLayoutExFileType;
-	readonly snapshotManifestList: VcVirtualMachineFileLayoutExFileType;
-	readonly core: VcVirtualMachineFileLayoutExFileType;
-	readonly snapshotList: VcVirtualMachineFileLayoutExFileType;
-	readonly namespaceData: VcVirtualMachineFileLayoutExFileType;
+declare class VcVirtualMachineFileLayoutExFileType implements IPseudoEnum {
+	static readonly extendedConfig: VcVirtualMachineFileLayoutExFileType & EnumVal<'extendedConfig'>;
+	static readonly log: VcVirtualMachineFileLayoutExFileType & EnumVal<'log'>;
+	static readonly digestExtent: VcVirtualMachineFileLayoutExFileType & EnumVal<'digestExtent'>;
+	static readonly screenshot: VcVirtualMachineFileLayoutExFileType & EnumVal<'screenshot'>;
+	static readonly ftMetadata: VcVirtualMachineFileLayoutExFileType & EnumVal<'ftMetadata'>;
+	static readonly snapshotMemory: VcVirtualMachineFileLayoutExFileType & EnumVal<'snapshotMemory'>;
+	static readonly nvram: VcVirtualMachineFileLayoutExFileType & EnumVal<'nvram'>;
+	static readonly diskExtent: VcVirtualMachineFileLayoutExFileType & EnumVal<'diskExtent'>;
+	static readonly diskDescriptor: VcVirtualMachineFileLayoutExFileType & EnumVal<'diskDescriptor'>;
+	static readonly digestDescriptor: VcVirtualMachineFileLayoutExFileType & EnumVal<'digestDescriptor'>;
+	static readonly uwswap: VcVirtualMachineFileLayoutExFileType & EnumVal<'uwswap'>;
+	static readonly suspendMemory: VcVirtualMachineFileLayoutExFileType & EnumVal<'suspendMemory'>;
+	static readonly suspend: VcVirtualMachineFileLayoutExFileType & EnumVal<'suspend'>;
+	static readonly stat: VcVirtualMachineFileLayoutExFileType & EnumVal<'stat'>;
+	static readonly swap: VcVirtualMachineFileLayoutExFileType & EnumVal<'swap'>;
+	static readonly diskReplicationState: VcVirtualMachineFileLayoutExFileType & EnumVal<'diskReplicationState'>;
+	static readonly snapshotManifestList: VcVirtualMachineFileLayoutExFileType & EnumVal<'snapshotManifestList'>;
+	static readonly core: VcVirtualMachineFileLayoutExFileType & EnumVal<'core'>;
+	static readonly snapshotList: VcVirtualMachineFileLayoutExFileType & EnumVal<'snapshotList'>;
+	static readonly namespaceData: VcVirtualMachineFileLayoutExFileType & EnumVal<'namespaceData'>;
+	static readonly snapshotData: VcVirtualMachineFileLayoutExFileType & EnumVal<'snapshotData'>;
+	static readonly config: VcVirtualMachineFileLayoutExFileType & EnumVal<'config'>;
+	static readonly guestCustomization: VcVirtualMachineFileLayoutExFileType & EnumVal<'guestCustomization'>;
+	static fromString(value: string): VcVirtualMachineFileLayoutExFileType & EnumVal<TcleanKeys<typeof VcVirtualMachineFileLayoutExFileType>>;
+
+	readonly id: string;
 	readonly name: string;
-	readonly snapshotData: VcVirtualMachineFileLayoutExFileType;
-	readonly config: VcVirtualMachineFileLayoutExFileType;
-	readonly guestCustomization: VcVirtualMachineFileLayoutExFileType;
+	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineFileLayoutExFileType): VcVirtualMachineFileLayoutExFileType;
+	toString: () => string;
 }
 
 /**
  * Guest operating system identifier.
  */
-declare class VcVirtualMachineGuestOsIdentifier {
-	readonly eComStationGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly debian5_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly opensuse64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly darwin64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly debian5Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly winXPProGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly mandrakeGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly win95Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly turboLinuxGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly winMeGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly rhel7Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly darwin11_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly other26xLinux64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly openServer6Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly debian4Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly netware4Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly rhel5_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly sjdsGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly vmwarePhoton64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly solaris6Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly openServer5Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly id: string;
-	readonly centos6Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly centos6_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly debian10Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly winNetStandard64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly windows8_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly solaris7Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly centos64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly other24xLinuxGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly winNetDatacenter64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly darwin15_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly winXPPro64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly opensuseGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly netware6Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly os2Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly windows7Server64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly freebsdGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly win31Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly windows8Server64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly vmkernel6Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly winNetBusinessGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly debian9_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly sles10_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly win2000ProGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly winLonghornGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly oracleLinux6_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly debian6_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly windows9_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly oracleLinux64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly win2000ServGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly rhel5Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly suse64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly winNetEnterpriseGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly darwin12_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly dosGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly coreos64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly sles64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly centos7_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly windows7Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly sles11Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly solaris9Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly asianux3_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly darwinGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly rhel6Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly asianux7_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly otherLinux64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly darwin16_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly debian9Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly debian6Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly asianux4Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly genericLinuxGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly winNetStandardGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly oracleLinux7Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly mandrivaGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly otherGuest64: VcVirtualMachineGuestOsIdentifier;
-	readonly rhel4_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly vmkernel5Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly win98Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly otherGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly sles11_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly solaris10_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly netware5Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly sles12_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly windows9Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly other24xLinux64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly win2000AdvServGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly suseGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly rhel2Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly darwin11Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly darwin13_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly asianux4_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly darwin10Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly vmkernelGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly rhel7_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly rhel3Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly winNetDatacenterGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly winVistaGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly rhel3_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly centosGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly mandriva64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly sles10Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly other3xLinux64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly windows9Server64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly debian10_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly winNetWebGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly oesGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly winNetEnterprise64Guest: VcVirtualMachineGuestOsIdentifier;
+declare class VcVirtualMachineGuestOsIdentifier implements IPseudoEnum {
+	static readonly eComStationGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'eComStationGuest'>;
+	static readonly debian5_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'debian5_64Guest'>;
+	static readonly opensuse64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'opensuse64Guest'>;
+	static readonly darwin64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'darwin64Guest'>;
+	static readonly debian5Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'debian5Guest'>;
+	static readonly winXPProGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'winXPProGuest'>;
+	static readonly mandrakeGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'mandrakeGuest'>;
+	static readonly win95Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'win95Guest'>;
+	static readonly turboLinuxGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'turboLinuxGuest'>;
+	static readonly winMeGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'winMeGuest'>;
+	static readonly rhel7Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'rhel7Guest'>;
+	static readonly darwin11_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'darwin11_64Guest'>;
+	static readonly other26xLinux64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'other26xLinux64Guest'>;
+	static readonly openServer6Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'openServer6Guest'>;
+	static readonly debian4Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'debian4Guest'>;
+	static readonly netware4Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'netware4Guest'>;
+	static readonly rhel5_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'rhel5_64Guest'>;
+	static readonly sjdsGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'sjdsGuest'>;
+	static readonly vmwarePhoton64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'vmwarePhoton64Guest'>;
+	static readonly solaris6Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'solaris6Guest'>;
+	static readonly openServer5Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'openServer5Guest'>;
+	static readonly centos6Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'centos6Guest'>;
+	static readonly centos6_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'centos6_64Guest'>;
+	static readonly debian10Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'debian10Guest'>;
+	static readonly winNetStandard64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'winNetStandard64Guest'>;
+	static readonly windows8_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'windows8_64Guest'>;
+	static readonly solaris7Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'solaris7Guest'>;
+	static readonly centos64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'centos64Guest'>;
+	static readonly other24xLinuxGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'other24xLinuxGuest'>;
+	static readonly winNetDatacenter64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'winNetDatacenter64Guest'>;
+	static readonly darwin15_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'darwin15_64Guest'>;
+	static readonly winXPPro64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'winXPPro64Guest'>;
+	static readonly opensuseGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'opensuseGuest'>;
+	static readonly netware6Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'netware6Guest'>;
+	static readonly os2Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'os2Guest'>;
+	static readonly windows7Server64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'windows7Server64Guest'>;
+	static readonly freebsdGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'freebsdGuest'>;
+	static readonly win31Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'win31Guest'>;
+	static readonly windows8Server64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'windows8Server64Guest'>;
+	static readonly vmkernel6Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'vmkernel6Guest'>;
+	static readonly winNetBusinessGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'winNetBusinessGuest'>;
+	static readonly debian9_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'debian9_64Guest'>;
+	static readonly sles10_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'sles10_64Guest'>;
+	static readonly win2000ProGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'win2000ProGuest'>;
+	static readonly winLonghornGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'winLonghornGuest'>;
+	static readonly oracleLinux6_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'oracleLinux6_64Guest'>;
+	static readonly debian6_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'debian6_64Guest'>;
+	static readonly windows9_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'windows9_64Guest'>;
+	static readonly oracleLinux64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'oracleLinux64Guest'>;
+	static readonly win2000ServGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'win2000ServGuest'>;
+	static readonly rhel5Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'rhel5Guest'>;
+	static readonly suse64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'suse64Guest'>;
+	static readonly winNetEnterpriseGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'winNetEnterpriseGuest'>;
+	static readonly darwin12_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'darwin12_64Guest'>;
+	static readonly dosGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'dosGuest'>;
+	static readonly coreos64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'coreos64Guest'>;
+	static readonly sles64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'sles64Guest'>;
+	static readonly centos7_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'centos7_64Guest'>;
+	static readonly windows7Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'windows7Guest'>;
+	static readonly sles11Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'sles11Guest'>;
+	static readonly solaris9Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'solaris9Guest'>;
+	static readonly asianux3_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'asianux3_64Guest'>;
+	static readonly darwinGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'darwinGuest'>;
+	static readonly rhel6Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'rhel6Guest'>;
+	static readonly asianux7_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'asianux7_64Guest'>;
+	static readonly otherLinux64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'otherLinux64Guest'>;
+	static readonly darwin16_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'darwin16_64Guest'>;
+	static readonly debian9Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'debian9Guest'>;
+	static readonly debian6Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'debian6Guest'>;
+	static readonly asianux4Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'asianux4Guest'>;
+	static readonly genericLinuxGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'genericLinuxGuest'>;
+	static readonly winNetStandardGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'winNetStandardGuest'>;
+	static readonly oracleLinux7Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'oracleLinux7Guest'>;
+	static readonly mandrivaGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'mandrivaGuest'>;
+	static readonly otherGuest64: VcVirtualMachineGuestOsIdentifier & EnumVal<'otherGuest64'>;
+	static readonly rhel4_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'rhel4_64Guest'>;
+	static readonly vmkernel5Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'vmkernel5Guest'>;
+	static readonly win98Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'win98Guest'>;
+	static readonly otherGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'otherGuest'>;
+	static readonly sles11_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'sles11_64Guest'>;
+	static readonly solaris10_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'solaris10_64Guest'>;
+	static readonly netware5Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'netware5Guest'>;
+	static readonly sles12_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'sles12_64Guest'>;
+	static readonly windows9Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'windows9Guest'>;
+	static readonly other24xLinux64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'other24xLinux64Guest'>;
+	static readonly win2000AdvServGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'win2000AdvServGuest'>;
+	static readonly suseGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'suseGuest'>;
+	static readonly rhel2Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'rhel2Guest'>;
+	static readonly darwin11Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'darwin11Guest'>;
+	static readonly darwin13_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'darwin13_64Guest'>;
+	static readonly asianux4_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'asianux4_64Guest'>;
+	static readonly darwin10Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'darwin10Guest'>;
+	static readonly vmkernelGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'vmkernelGuest'>;
+	static readonly rhel7_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'rhel7_64Guest'>;
+	static readonly rhel3Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'rhel3Guest'>;
+	static readonly winNetDatacenterGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'winNetDatacenterGuest'>;
+	static readonly winVistaGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'winVistaGuest'>;
+	static readonly rhel3_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'rhel3_64Guest'>;
+	static readonly centosGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'centosGuest'>;
+	static readonly mandriva64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'mandriva64Guest'>;
+	static readonly sles10Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'sles10Guest'>;
+	static readonly other3xLinux64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'other3xLinux64Guest'>;
+	static readonly windows9Server64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'windows9Server64Guest'>;
+	static readonly debian10_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'debian10_64Guest'>;
+	static readonly winNetWebGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'winNetWebGuest'>;
+	static readonly oesGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'oesGuest'>;
+	static readonly winNetEnterprise64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'winNetEnterprise64Guest'>;
+	static readonly solaris11_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'solaris11_64Guest'>;
+	static readonly nld9Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'nld9Guest'>;
+	static readonly ubuntu64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'ubuntu64Guest'>;
+	static readonly debian7_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'debian7_64Guest'>;
+	static readonly fedoraGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'fedoraGuest'>;
+	static readonly oracleLinux6Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'oracleLinux6Guest'>;
+	static readonly slesGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'slesGuest'>;
+	static readonly eComStation2Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'eComStation2Guest'>;
+	static readonly winNTGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'winNTGuest'>;
+	static readonly windows7_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'windows7_64Guest'>;
+	static readonly debian4_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'debian4_64Guest'>;
+	static readonly debian8Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'debian8Guest'>;
+	static readonly solaris8Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'solaris8Guest'>;
+	static readonly other3xLinuxGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'other3xLinuxGuest'>;
+	static readonly darwin10_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'darwin10_64Guest'>;
+	static readonly fedora64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'fedora64Guest'>;
+	static readonly rhel6_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'rhel6_64Guest'>;
+	static readonly debian7Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'debian7Guest'>;
+	static readonly vmkernel65Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'vmkernel65Guest'>;
+	static readonly freebsd64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'freebsd64Guest'>;
+	static readonly winXPHomeGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'winXPHomeGuest'>;
+	static readonly redhatGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'redhatGuest'>;
+	static readonly other26xLinuxGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'other26xLinuxGuest'>;
+	static readonly asianux3Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'asianux3Guest'>;
+	static readonly darwin14_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'darwin14_64Guest'>;
+	static readonly turboLinux64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'turboLinux64Guest'>;
+	static readonly asianux5_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'asianux5_64Guest'>;
+	static readonly centos7Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'centos7Guest'>;
+	static readonly windows8Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'windows8Guest'>;
+	static readonly oracleLinuxGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'oracleLinuxGuest'>;
+	static readonly sles12Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'sles12Guest'>;
+	static readonly winVista64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'winVista64Guest'>;
+	static readonly rhel4Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'rhel4Guest'>;
+	static readonly ubuntuGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'ubuntuGuest'>;
+	static readonly unixWare7Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'unixWare7Guest'>;
+	static readonly oracleLinux7_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'oracleLinux7_64Guest'>;
+	static readonly winLonghorn64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'winLonghorn64Guest'>;
+	static readonly debian8_64Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'debian8_64Guest'>;
+	static readonly otherLinuxGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'otherLinuxGuest'>;
+	static readonly windowsHyperVGuest: VcVirtualMachineGuestOsIdentifier & EnumVal<'windowsHyperVGuest'>;
+	static readonly solaris10Guest: VcVirtualMachineGuestOsIdentifier & EnumVal<'solaris10Guest'>;
+	static fromString(value: string): VcVirtualMachineGuestOsIdentifier & EnumVal<TcleanKeys<typeof VcVirtualMachineGuestOsIdentifier>>;
+
+	readonly id: string;
 	readonly name: string;
-	readonly solaris11_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly nld9Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly ubuntu64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly debian7_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly fedoraGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly oracleLinux6Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly slesGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly eComStation2Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly winNTGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly windows7_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly debian4_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly debian8Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly solaris8Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly other3xLinuxGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly darwin10_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly fedora64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly rhel6_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly debian7Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly vmkernel65Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly freebsd64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly winXPHomeGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly redhatGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly other26xLinuxGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly asianux3Guest: VcVirtualMachineGuestOsIdentifier;
 	readonly value: string;
-	readonly darwin14_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly turboLinux64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly asianux5_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly centos7Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly windows8Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly oracleLinuxGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly sles12Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly winVista64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly rhel4Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly ubuntuGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly unixWare7Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly oracleLinux7_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly winLonghorn64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly debian8_64Guest: VcVirtualMachineGuestOsIdentifier;
-	readonly otherLinuxGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly windowsHyperVGuest: VcVirtualMachineGuestOsIdentifier;
-	readonly solaris10Guest: VcVirtualMachineGuestOsIdentifier;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineGuestOsIdentifier): VcVirtualMachineGuestOsIdentifier;
+	toString: () => string;
 }
 
 /**
@@ -5246,64 +4981,61 @@ declare class VcVirtualMachineGuestOsIdentifier {
  * defines the supported list of time units for profiles that specify
  * time span capabilities and constraints. See {@link TimeSpan}.
  */
-declare class PbmCapabilityTimeUnitType {
-	readonly MONTHS: PbmCapabilityTimeUnitType;
-	readonly YEARS: PbmCapabilityTimeUnitType;
-	readonly HOURS: PbmCapabilityTimeUnitType;
-	readonly WEEKS: PbmCapabilityTimeUnitType;
-	readonly SECONDS: PbmCapabilityTimeUnitType;
-	readonly DAYS: PbmCapabilityTimeUnitType;
-	readonly name: string;
-	readonly MINUTES: PbmCapabilityTimeUnitType;
+declare class PbmCapabilityTimeUnitType implements IPseudoEnum {
+	static readonly MONTHS: PbmCapabilityTimeUnitType & EnumVal<'MONTHS'>;
+	static readonly YEARS: PbmCapabilityTimeUnitType & EnumVal<'YEARS'>;
+	static readonly HOURS: PbmCapabilityTimeUnitType & EnumVal<'HOURS'>;
+	static readonly WEEKS: PbmCapabilityTimeUnitType & EnumVal<'WEEKS'>;
+	static readonly SECONDS: PbmCapabilityTimeUnitType & EnumVal<'SECONDS'>;
+	static readonly DAYS: PbmCapabilityTimeUnitType & EnumVal<'DAYS'>;
+	static readonly MINUTES: PbmCapabilityTimeUnitType & EnumVal<'MINUTES'>;
+	static fromString(value: string): PbmCapabilityTimeUnitType & EnumVal<TcleanKeys<typeof PbmCapabilityTimeUnitType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: PbmCapabilityTimeUnitType): PbmCapabilityTimeUnitType;
+	toString: () => string;
 }
 
 /**
  * ProtocolEndpoint Type.
  */
-declare class VcHostProtocolEndpointPEType {
-	readonly nas: VcHostProtocolEndpointPEType;
-	readonly name: string;
-	readonly block: VcHostProtocolEndpointPEType;
+declare class VcHostProtocolEndpointPEType implements IPseudoEnum {
+	static readonly nas: VcHostProtocolEndpointPEType & EnumVal<'nas'>;
+	static readonly block: VcHostProtocolEndpointPEType & EnumVal<'block'>;
+	static fromString(value: string): VcHostProtocolEndpointPEType & EnumVal<TcleanKeys<typeof VcHostProtocolEndpointPEType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostProtocolEndpointPEType): VcHostProtocolEndpointPEType;
-}
-
-declare class VcReplicationVmConfigFaultReasonForFault {
-	readonly invalidPriorConfiguration: VcReplicationVmConfigFaultReasonForFault;
-	readonly invalidVmReplicationId: VcReplicationVmConfigFaultReasonForFault;
-	readonly replicationConfigurationFailed: VcReplicationVmConfigFaultReasonForFault;
-	readonly replicationAlreadyEnabled: VcReplicationVmConfigFaultReasonForFault;
-	readonly invalidExtraVmOptions: VcReplicationVmConfigFaultReasonForFault;
-	readonly staleGenerationNumber: VcReplicationVmConfigFaultReasonForFault;
-	readonly incompatibleHwVersion: VcReplicationVmConfigFaultReasonForFault;
-	readonly reconfigureVmReplicationIdNotAllowed: VcReplicationVmConfigFaultReasonForFault;
-	readonly replicationNotEnabled: VcReplicationVmConfigFaultReasonForFault;
-	readonly cannotRetrieveVmReplicationConfiguration: VcReplicationVmConfigFaultReasonForFault;
-	readonly encryptedVm: VcReplicationVmConfigFaultReasonForFault;
-	readonly invalidDestinationPort: VcReplicationVmConfigFaultReasonForFault;
-	readonly invalidGenerationNumber: VcReplicationVmConfigFaultReasonForFault;
-	readonly name: string;
+	toString: () => string;
+}
+
+declare class VcReplicationVmConfigFaultReasonForFault implements IPseudoEnum {
+	static readonly invalidPriorConfiguration: VcReplicationVmConfigFaultReasonForFault & EnumVal<'invalidPriorConfiguration'>;
+	static readonly invalidVmReplicationId: VcReplicationVmConfigFaultReasonForFault & EnumVal<'invalidVmReplicationId'>;
+	static readonly replicationConfigurationFailed: VcReplicationVmConfigFaultReasonForFault & EnumVal<'replicationConfigurationFailed'>;
+	static readonly replicationAlreadyEnabled: VcReplicationVmConfigFaultReasonForFault & EnumVal<'replicationAlreadyEnabled'>;
+	static readonly invalidExtraVmOptions: VcReplicationVmConfigFaultReasonForFault & EnumVal<'invalidExtraVmOptions'>;
+	static readonly staleGenerationNumber: VcReplicationVmConfigFaultReasonForFault & EnumVal<'staleGenerationNumber'>;
+	static readonly incompatibleHwVersion: VcReplicationVmConfigFaultReasonForFault & EnumVal<'incompatibleHwVersion'>;
+	static readonly reconfigureVmReplicationIdNotAllowed: VcReplicationVmConfigFaultReasonForFault & EnumVal<'reconfigureVmReplicationIdNotAllowed'>;
+	static readonly replicationNotEnabled: VcReplicationVmConfigFaultReasonForFault & EnumVal<'replicationNotEnabled'>;
+	static readonly cannotRetrieveVmReplicationConfiguration: VcReplicationVmConfigFaultReasonForFault & EnumVal<'cannotRetrieveVmReplicationConfiguration'>;
+	static readonly encryptedVm: VcReplicationVmConfigFaultReasonForFault & EnumVal<'encryptedVm'>;
+	static readonly invalidDestinationPort: VcReplicationVmConfigFaultReasonForFault & EnumVal<'invalidDestinationPort'>;
+	static readonly invalidGenerationNumber: VcReplicationVmConfigFaultReasonForFault & EnumVal<'invalidGenerationNumber'>;
+	static readonly outOfBoundsRpoValue: VcReplicationVmConfigFaultReasonForFault & EnumVal<'outOfBoundsRpoValue'>;
+	static readonly invalidDestinationIpAddress: VcReplicationVmConfigFaultReasonForFault & EnumVal<'invalidDestinationIpAddress'>;
+	static fromString(value: string): VcReplicationVmConfigFaultReasonForFault & EnumVal<TcleanKeys<typeof VcReplicationVmConfigFaultReasonForFault>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly outOfBoundsRpoValue: VcReplicationVmConfigFaultReasonForFault;
-	readonly invalidDestinationIpAddress: VcReplicationVmConfigFaultReasonForFault;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcReplicationVmConfigFaultReasonForFault): VcReplicationVmConfigFaultReasonForFault;
+	toString: () => string;
 }
 
 /**
@@ -5311,214 +5043,204 @@ declare class VcReplicationVmConfigFaultReasonForFault {
  * in the inventory hierarchy. If a managed entity has children, their tasks
  * can be retrieved with this filter option.
  */
-declare class VcTaskFilterSpecRecursionOption {
-	readonly all: VcTaskFilterSpecRecursionOption;
-	readonly children: VcTaskFilterSpecRecursionOption;
-	readonly name: string;
-	readonly self: VcTaskFilterSpecRecursionOption;
+declare class VcTaskFilterSpecRecursionOption implements IPseudoEnum {
+	static readonly all: VcTaskFilterSpecRecursionOption & EnumVal<'all'>;
+	static readonly children: VcTaskFilterSpecRecursionOption & EnumVal<'children'>;
+	static readonly self: VcTaskFilterSpecRecursionOption & EnumVal<'self'>;
+	static fromString(value: string): VcTaskFilterSpecRecursionOption & EnumVal<TcleanKeys<typeof VcTaskFilterSpecRecursionOption>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcTaskFilterSpecRecursionOption): VcTaskFilterSpecRecursionOption;
+	toString: () => string;
 }
 
 /**
  * Current version status of VMware Tools installed in the guest operating
  * system.
  */
-declare class VcVirtualMachineToolsVersionStatus {
-	readonly guestToolsTooOld: VcVirtualMachineToolsVersionStatus;
-	readonly guestToolsNotInstalled: VcVirtualMachineToolsVersionStatus;
-	readonly guestToolsSupportedOld: VcVirtualMachineToolsVersionStatus;
-	readonly guestToolsBlacklisted: VcVirtualMachineToolsVersionStatus;
-	readonly name: string;
-	readonly guestToolsUnmanaged: VcVirtualMachineToolsVersionStatus;
-	readonly guestToolsNeedUpgrade: VcVirtualMachineToolsVersionStatus;
-	readonly guestToolsTooNew: VcVirtualMachineToolsVersionStatus;
+declare class VcVirtualMachineToolsVersionStatus implements IPseudoEnum {
+	static readonly guestToolsTooOld: VcVirtualMachineToolsVersionStatus & EnumVal<'guestToolsTooOld'>;
+	static readonly guestToolsNotInstalled: VcVirtualMachineToolsVersionStatus & EnumVal<'guestToolsNotInstalled'>;
+	static readonly guestToolsSupportedOld: VcVirtualMachineToolsVersionStatus & EnumVal<'guestToolsSupportedOld'>;
+	static readonly guestToolsBlacklisted: VcVirtualMachineToolsVersionStatus & EnumVal<'guestToolsBlacklisted'>;
+	static readonly guestToolsUnmanaged: VcVirtualMachineToolsVersionStatus & EnumVal<'guestToolsUnmanaged'>;
+	static readonly guestToolsNeedUpgrade: VcVirtualMachineToolsVersionStatus & EnumVal<'guestToolsNeedUpgrade'>;
+	static readonly guestToolsTooNew: VcVirtualMachineToolsVersionStatus & EnumVal<'guestToolsTooNew'>;
+	static readonly guestToolsCurrent: VcVirtualMachineToolsVersionStatus & EnumVal<'guestToolsCurrent'>;
+	static readonly guestToolsSupportedNew: VcVirtualMachineToolsVersionStatus & EnumVal<'guestToolsSupportedNew'>;
+	static fromString(value: string): VcVirtualMachineToolsVersionStatus & EnumVal<TcleanKeys<typeof VcVirtualMachineToolsVersionStatus>>;
+
 	readonly id: string;
-	readonly guestToolsCurrent: VcVirtualMachineToolsVersionStatus;
-	readonly guestToolsSupportedNew: VcVirtualMachineToolsVersionStatus;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineToolsVersionStatus): VcVirtualMachineToolsVersionStatus;
+	toString: () => string;
 }
 
 /**
  * The policy to determine the candidates from which vCenter Server can
  * choose heartbeat datastores.
  */
-declare class VcClusterDasConfigInfoHBDatastoreCandidate {
-	readonly name: string;
-	readonly userSelectedDs: VcClusterDasConfigInfoHBDatastoreCandidate;
-	readonly allFeasibleDs: VcClusterDasConfigInfoHBDatastoreCandidate;
+declare class VcClusterDasConfigInfoHBDatastoreCandidate implements IPseudoEnum {
+	static readonly userSelectedDs: VcClusterDasConfigInfoHBDatastoreCandidate & EnumVal<'userSelectedDs'>;
+	static readonly allFeasibleDs: VcClusterDasConfigInfoHBDatastoreCandidate & EnumVal<'allFeasibleDs'>;
+	static readonly allFeasibleDsWithUserPreference: VcClusterDasConfigInfoHBDatastoreCandidate & EnumVal<'allFeasibleDsWithUserPreference'>;
+	static fromString(value: string): VcClusterDasConfigInfoHBDatastoreCandidate & EnumVal<TcleanKeys<typeof VcClusterDasConfigInfoHBDatastoreCandidate>>;
+
 	readonly id: string;
-	readonly allFeasibleDsWithUserPreference: VcClusterDasConfigInfoHBDatastoreCandidate;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcClusterDasConfigInfoHBDatastoreCandidate): VcClusterDasConfigInfoHBDatastoreCandidate;
+	toString: () => string;
 }
 
 /**
  * Class that represnts the different possible results of the
  * PreCallback instance
  */
-declare class VcPreCallbackResultResult {
-	readonly BlockOperation: VcPreCallbackResultResult;
-	readonly ContinueWithOperation: VcPreCallbackResultResult;
-	readonly name: string;
+declare class VcPreCallbackResultResult implements IPseudoEnum {
+	static readonly BlockOperation: VcPreCallbackResultResult & EnumVal<'BlockOperation'>;
+	static readonly ContinueWithOperation: VcPreCallbackResultResult & EnumVal<'ContinueWithOperation'>;
+	static fromString(value: string): VcPreCallbackResultResult & EnumVal<TcleanKeys<typeof VcPreCallbackResultResult>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcPreCallbackResultResult): VcPreCallbackResultResult;
+	toString: () => string;
 }
 
 /**
  * An indicator of the utility of Descriptor in being used as an
  * identifier that is stable, unique, and correlatable.
  */
-declare class VcScsiLunDescriptorQuality {
-	readonly unknownQuality: VcScsiLunDescriptorQuality;
-	readonly lowQuality: VcScsiLunDescriptorQuality;
-	readonly name: string;
-	readonly highQuality: VcScsiLunDescriptorQuality;
+declare class VcScsiLunDescriptorQuality implements IPseudoEnum {
+	static readonly unknownQuality: VcScsiLunDescriptorQuality & EnumVal<'unknownQuality'>;
+	static readonly lowQuality: VcScsiLunDescriptorQuality & EnumVal<'lowQuality'>;
+	static readonly highQuality: VcScsiLunDescriptorQuality & EnumVal<'highQuality'>;
+	static readonly mediumQuality: VcScsiLunDescriptorQuality & EnumVal<'mediumQuality'>;
+	static fromString(value: string): VcScsiLunDescriptorQuality & EnumVal<TcleanKeys<typeof VcScsiLunDescriptorQuality>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly mediumQuality: VcScsiLunDescriptorQuality;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcScsiLunDescriptorQuality): VcScsiLunDescriptorQuality;
+	toString: () => string;
 }
 
 /**
  * List of defined migration reason codes:
  */
-declare class VcRecommendationReasonCode {
-	readonly balanceDatastoreIOPSReservation: VcRecommendationReasonCode;
-	readonly virtualDiskJointAffin: VcRecommendationReasonCode;
-	readonly powerOnVm: VcRecommendationReasonCode;
-	readonly maxVmsConstraint: VcRecommendationReasonCode;
-	readonly jointAffin: VcRecommendationReasonCode;
-	readonly ftConstraints: VcRecommendationReasonCode;
-	readonly unreservedCapacity: VcRecommendationReasonCode;
-	readonly increaseCapacity: VcRecommendationReasonCode;
-	readonly fairnessMemAvg: VcRecommendationReasonCode;
-	readonly virtualDiskAntiAffin: VcRecommendationReasonCode;
-	readonly id: string;
-	readonly powerSaving: VcRecommendationReasonCode;
-	readonly value: string;
-	readonly networkBandwidthReservation: VcRecommendationReasonCode;
-	readonly hostInDegradation: VcRecommendationReasonCode;
-	readonly reservationCpu: VcRecommendationReasonCode;
-	readonly balanceDatastoreIOLoad: VcRecommendationReasonCode;
-	readonly vmHostSoftAffinity: VcRecommendationReasonCode;
-	readonly xvmotionPlacement: VcRecommendationReasonCode;
-	readonly vmHostHardAffinity: VcRecommendationReasonCode;
-	readonly fairnessCpuAvg: VcRecommendationReasonCode;
-	readonly hostMaint: VcRecommendationReasonCode;
-	readonly balanceDatastoreSpaceUsage: VcRecommendationReasonCode;
-	readonly hostExitDegradation: VcRecommendationReasonCode;
-	readonly checkResource: VcRecommendationReasonCode;
-	readonly increaseAllocation: VcRecommendationReasonCode;
-	readonly iolbDisabledInternal: VcRecommendationReasonCode;
-	readonly reservationMem: VcRecommendationReasonCode;
-	readonly balanceNetworkBandwidthUsage: VcRecommendationReasonCode;
-	readonly antiAffin: VcRecommendationReasonCode;
-	readonly datastoreMaint: VcRecommendationReasonCode;
+declare class VcRecommendationReasonCode implements IPseudoEnum {
+	static readonly balanceDatastoreIOPSReservation: VcRecommendationReasonCode & EnumVal<'balanceDatastoreIOPSReservation'>;
+	static readonly virtualDiskJointAffin: VcRecommendationReasonCode & EnumVal<'virtualDiskJointAffin'>;
+	static readonly powerOnVm: VcRecommendationReasonCode & EnumVal<'powerOnVm'>;
+	static readonly maxVmsConstraint: VcRecommendationReasonCode & EnumVal<'maxVmsConstraint'>;
+	static readonly jointAffin: VcRecommendationReasonCode & EnumVal<'jointAffin'>;
+	static readonly ftConstraints: VcRecommendationReasonCode & EnumVal<'ftConstraints'>;
+	static readonly unreservedCapacity: VcRecommendationReasonCode & EnumVal<'unreservedCapacity'>;
+	static readonly increaseCapacity: VcRecommendationReasonCode & EnumVal<'increaseCapacity'>;
+	static readonly fairnessMemAvg: VcRecommendationReasonCode & EnumVal<'fairnessMemAvg'>;
+	static readonly virtualDiskAntiAffin: VcRecommendationReasonCode & EnumVal<'virtualDiskAntiAffin'>;
+	static readonly powerSaving: VcRecommendationReasonCode & EnumVal<'powerSaving'>;
+	static readonly networkBandwidthReservation: VcRecommendationReasonCode & EnumVal<'networkBandwidthReservation'>;
+	static readonly hostInDegradation: VcRecommendationReasonCode & EnumVal<'hostInDegradation'>;
+	static readonly reservationCpu: VcRecommendationReasonCode & EnumVal<'reservationCpu'>;
+	static readonly balanceDatastoreIOLoad: VcRecommendationReasonCode & EnumVal<'balanceDatastoreIOLoad'>;
+	static readonly vmHostSoftAffinity: VcRecommendationReasonCode & EnumVal<'vmHostSoftAffinity'>;
+	static readonly xvmotionPlacement: VcRecommendationReasonCode & EnumVal<'xvmotionPlacement'>;
+	static readonly vmHostHardAffinity: VcRecommendationReasonCode & EnumVal<'vmHostHardAffinity'>;
+	static readonly fairnessCpuAvg: VcRecommendationReasonCode & EnumVal<'fairnessCpuAvg'>;
+	static readonly hostMaint: VcRecommendationReasonCode & EnumVal<'hostMaint'>;
+	static readonly balanceDatastoreSpaceUsage: VcRecommendationReasonCode & EnumVal<'balanceDatastoreSpaceUsage'>;
+	static readonly hostExitDegradation: VcRecommendationReasonCode & EnumVal<'hostExitDegradation'>;
+	static readonly checkResource: VcRecommendationReasonCode & EnumVal<'checkResource'>;
+	static readonly increaseAllocation: VcRecommendationReasonCode & EnumVal<'increaseAllocation'>;
+	static readonly iolbDisabledInternal: VcRecommendationReasonCode & EnumVal<'iolbDisabledInternal'>;
+	static readonly reservationMem: VcRecommendationReasonCode & EnumVal<'reservationMem'>;
+	static readonly balanceNetworkBandwidthUsage: VcRecommendationReasonCode & EnumVal<'balanceNetworkBandwidthUsage'>;
+	static readonly antiAffin: VcRecommendationReasonCode & EnumVal<'antiAffin'>;
+	static readonly datastoreMaint: VcRecommendationReasonCode & EnumVal<'datastoreMaint'>;
+	static readonly storagePlacement: VcRecommendationReasonCode & EnumVal<'storagePlacement'>;
+	static readonly enterStandby: VcRecommendationReasonCode & EnumVal<'enterStandby'>;
+	static readonly colocateCommunicatingVM: VcRecommendationReasonCode & EnumVal<'colocateCommunicatingVM'>;
+	static readonly datastoreSpaceOutage: VcRecommendationReasonCode & EnumVal<'datastoreSpaceOutage'>;
+	static fromString(value: string): VcRecommendationReasonCode & EnumVal<TcleanKeys<typeof VcRecommendationReasonCode>>;
+
+	readonly id: string;
 	readonly name: string;
-	readonly storagePlacement: VcRecommendationReasonCode;
-	readonly enterStandby: VcRecommendationReasonCode;
-	readonly colocateCommunicatingVM: VcRecommendationReasonCode;
-	readonly datastoreSpaceOutage: VcRecommendationReasonCode;
+	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcRecommendationReasonCode): VcRecommendationReasonCode;
+	toString: () => string;
 }
 
 /**
  * Config spec operation type.
  */
-declare class VcConfigSpecOperation {
-	readonly add: VcConfigSpecOperation;
-	readonly edit: VcConfigSpecOperation;
-	readonly name: string;
+declare class VcConfigSpecOperation implements IPseudoEnum {
+	static readonly add: VcConfigSpecOperation & EnumVal<'add'>;
+	static readonly edit: VcConfigSpecOperation & EnumVal<'edit'>;
+	static readonly remove: VcConfigSpecOperation & EnumVal<'remove'>;
+	static fromString(value: string): VcConfigSpecOperation & EnumVal<TcleanKeys<typeof VcConfigSpecOperation>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly remove: VcConfigSpecOperation;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcConfigSpecOperation): VcConfigSpecOperation;
+	toString: () => string;
 }
 
 /**
  * CPU scaling and throttling modes.
  */
-declare class VcVirtualMachinePowerPolicyCpuMode {
-	readonly constantProcessorThrottling: VcVirtualMachinePowerPolicyCpuMode;
-	readonly degradedProcessorThrottling: VcVirtualMachinePowerPolicyCpuMode;
-	readonly noProcessorThrottling: VcVirtualMachinePowerPolicyCpuMode;
-	readonly name: string;
+declare class VcVirtualMachinePowerPolicyCpuMode implements IPseudoEnum {
+	static readonly constantProcessorThrottling: VcVirtualMachinePowerPolicyCpuMode & EnumVal<'constantProcessorThrottling'>;
+	static readonly degradedProcessorThrottling: VcVirtualMachinePowerPolicyCpuMode & EnumVal<'degradedProcessorThrottling'>;
+	static readonly noProcessorThrottling: VcVirtualMachinePowerPolicyCpuMode & EnumVal<'noProcessorThrottling'>;
+	static readonly adaptiveProcessorThrottling: VcVirtualMachinePowerPolicyCpuMode & EnumVal<'adaptiveProcessorThrottling'>;
+	static fromString(value: string): VcVirtualMachinePowerPolicyCpuMode & EnumVal<TcleanKeys<typeof VcVirtualMachinePowerPolicyCpuMode>>;
+
 	readonly id: string;
-	readonly adaptiveProcessorThrottling: VcVirtualMachinePowerPolicyCpuMode;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachinePowerPolicyCpuMode): VcVirtualMachinePowerPolicyCpuMode;
+	toString: () => string;
 }
 
 /**
  * The connectee types.
  */
-declare class VcDistributedVirtualSwitchPortConnecteeConnecteeType {
-	readonly hostConsoleVnic: VcDistributedVirtualSwitchPortConnecteeConnecteeType;
-	readonly hostVmkVnic: VcDistributedVirtualSwitchPortConnecteeConnecteeType;
-	readonly name: string;
+declare class VcDistributedVirtualSwitchPortConnecteeConnecteeType implements IPseudoEnum {
+	static readonly hostConsoleVnic: VcDistributedVirtualSwitchPortConnecteeConnecteeType & EnumVal<'hostConsoleVnic'>;
+	static readonly hostVmkVnic: VcDistributedVirtualSwitchPortConnecteeConnecteeType & EnumVal<'hostVmkVnic'>;
+	static readonly pnic: VcDistributedVirtualSwitchPortConnecteeConnecteeType & EnumVal<'pnic'>;
+	static readonly vmVnic: VcDistributedVirtualSwitchPortConnecteeConnecteeType & EnumVal<'vmVnic'>;
+	static fromString(value: string): VcDistributedVirtualSwitchPortConnecteeConnecteeType & EnumVal<TcleanKeys<typeof VcDistributedVirtualSwitchPortConnecteeConnecteeType>>;
+
 	readonly id: string;
-	readonly pnic: VcDistributedVirtualSwitchPortConnecteeConnecteeType;
-	readonly vmVnic: VcDistributedVirtualSwitchPortConnecteeConnecteeType;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDistributedVirtualSwitchPortConnecteeConnecteeType): VcDistributedVirtualSwitchPortConnecteeConnecteeType;
+	toString: () => string;
 }
 
 /**
  * The Discovery Protocol operation.
  */
-declare class VcLinkDiscoveryProtocolConfigOperationType {
-	readonly name: string;
-	readonly none: VcLinkDiscoveryProtocolConfigOperationType;
+declare class VcLinkDiscoveryProtocolConfigOperationType implements IPseudoEnum {
+	static readonly none: VcLinkDiscoveryProtocolConfigOperationType & EnumVal<'none'>;
+	static readonly listen: VcLinkDiscoveryProtocolConfigOperationType & EnumVal<'listen'>;
+	static readonly advertise: VcLinkDiscoveryProtocolConfigOperationType & EnumVal<'advertise'>;
+	static readonly both: VcLinkDiscoveryProtocolConfigOperationType & EnumVal<'both'>;
+	static fromString(value: string): VcLinkDiscoveryProtocolConfigOperationType & EnumVal<TcleanKeys<typeof VcLinkDiscoveryProtocolConfigOperationType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly listen: VcLinkDiscoveryProtocolConfigOperationType;
-	readonly advertise: VcLinkDiscoveryProtocolConfigOperationType;
-	readonly both: VcLinkDiscoveryProtocolConfigOperationType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcLinkDiscoveryProtocolConfigOperationType): VcLinkDiscoveryProtocolConfigOperationType;
+	toString: () => string;
 }
 
 /**
@@ -5527,187 +5249,177 @@ declare class VcLinkDiscoveryProtocolConfigOperationType {
  * Note that this state does not capture the health of the replication link. If
  * necessary, that can be an additional attribute.
  */
-declare class ReplicationReplicationState {
-	readonly TARGET: ReplicationReplicationState;
-	readonly INTEST: ReplicationReplicationState;
-	readonly REMOTE_FAILEDOVER: ReplicationReplicationState;
-	readonly FAILEDOVER: ReplicationReplicationState;
-	readonly SOURCE: ReplicationReplicationState;
-	readonly name: string;
+declare class ReplicationReplicationState implements IPseudoEnum {
+	static readonly TARGET: ReplicationReplicationState & EnumVal<'TARGET'>;
+	static readonly INTEST: ReplicationReplicationState & EnumVal<'INTEST'>;
+	static readonly REMOTE_FAILEDOVER: ReplicationReplicationState & EnumVal<'REMOTE_FAILEDOVER'>;
+	static readonly FAILEDOVER: ReplicationReplicationState & EnumVal<'FAILEDOVER'>;
+	static readonly SOURCE: ReplicationReplicationState & EnumVal<'SOURCE'>;
+	static fromString(value: string): ReplicationReplicationState & EnumVal<TcleanKeys<typeof ReplicationReplicationState>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: ReplicationReplicationState): ReplicationReplicationState;
+	toString: () => string;
 }
 
-declare class VcCannotMoveFaultToleranceVmMoveType {
-	readonly cluster: VcCannotMoveFaultToleranceVmMoveType;
-	readonly name: string;
+declare class VcCannotMoveFaultToleranceVmMoveType implements IPseudoEnum {
+	static readonly cluster: VcCannotMoveFaultToleranceVmMoveType & EnumVal<'cluster'>;
+	static readonly resourcePool: VcCannotMoveFaultToleranceVmMoveType & EnumVal<'resourcePool'>;
+	static fromString(value: string): VcCannotMoveFaultToleranceVmMoveType & EnumVal<TcleanKeys<typeof VcCannotMoveFaultToleranceVmMoveType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly resourcePool: VcCannotMoveFaultToleranceVmMoveType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcCannotMoveFaultToleranceVmMoveType): VcCannotMoveFaultToleranceVmMoveType;
+	toString: () => string;
 }
 
 /**
  * The Operational state of the LUN
  */
-declare class VcScsiLunState {
-	readonly quiesced: VcScsiLunState;
-	readonly lostCommunication: VcScsiLunState;
-	readonly unknownState: VcScsiLunState;
-	readonly name: string;
+declare class VcScsiLunState implements IPseudoEnum {
+	static readonly quiesced: VcScsiLunState & EnumVal<'quiesced'>;
+	static readonly lostCommunication: VcScsiLunState & EnumVal<'lostCommunication'>;
+	static readonly unknownState: VcScsiLunState & EnumVal<'unknownState'>;
+	static readonly ok: VcScsiLunState & EnumVal<'ok'>;
+	static readonly error: VcScsiLunState & EnumVal<'error'>;
+	static readonly degraded: VcScsiLunState & EnumVal<'degraded'>;
+	static readonly off: VcScsiLunState & EnumVal<'off'>;
+	static readonly timeout: VcScsiLunState & EnumVal<'timeout'>;
+	static fromString(value: string): VcScsiLunState & EnumVal<TcleanKeys<typeof VcScsiLunState>>;
+
 	readonly id: string;
-	readonly ok: VcScsiLunState;
-	readonly error: VcScsiLunState;
-	readonly degraded: VcScsiLunState;
+	readonly name: string;
 	readonly value: string;
-	readonly off: VcScsiLunState;
-	readonly timeout: VcScsiLunState;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcScsiLunState): VcScsiLunState;
+	toString: () => string;
 }
 
 /**
  * Health status of a NVDIMM
  */
-declare class VcNvdimmHealthStatus {
-	readonly normal: VcNvdimmHealthStatus;
-	readonly critical: VcNvdimmHealthStatus;
-	readonly name: string;
+declare class VcNvdimmHealthStatus implements IPseudoEnum {
+	static readonly normal: VcNvdimmHealthStatus & EnumVal<'normal'>;
+	static readonly critical: VcNvdimmHealthStatus & EnumVal<'critical'>;
+	static readonly noncritical: VcNvdimmHealthStatus & EnumVal<'noncritical'>;
+	static readonly fatal: VcNvdimmHealthStatus & EnumVal<'fatal'>;
+	static fromString(value: string): VcNvdimmHealthStatus & EnumVal<TcleanKeys<typeof VcNvdimmHealthStatus>>;
+
 	readonly id: string;
-	readonly noncritical: VcNvdimmHealthStatus;
+	readonly name: string;
 	readonly value: string;
-	readonly fatal: VcNvdimmHealthStatus;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcNvdimmHealthStatus): VcNvdimmHealthStatus;
+	toString: () => string;
 }
 
 /**
  * Specifies the connectable virtual device status.
  */
-declare class VcVirtualDeviceConnectInfoStatus {
-	readonly unrecoverableError: VcVirtualDeviceConnectInfoStatus;
-	readonly recoverableError: VcVirtualDeviceConnectInfoStatus;
-	readonly untried: VcVirtualDeviceConnectInfoStatus;
-	readonly name: string;
+declare class VcVirtualDeviceConnectInfoStatus implements IPseudoEnum {
+	static readonly unrecoverableError: VcVirtualDeviceConnectInfoStatus & EnumVal<'unrecoverableError'>;
+	static readonly recoverableError: VcVirtualDeviceConnectInfoStatus & EnumVal<'recoverableError'>;
+	static readonly untried: VcVirtualDeviceConnectInfoStatus & EnumVal<'untried'>;
+	static readonly ok: VcVirtualDeviceConnectInfoStatus & EnumVal<'ok'>;
+	static fromString(value: string): VcVirtualDeviceConnectInfoStatus & EnumVal<TcleanKeys<typeof VcVirtualDeviceConnectInfoStatus>>;
+
 	readonly id: string;
-	readonly ok: VcVirtualDeviceConnectInfoStatus;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualDeviceConnectInfoStatus): VcVirtualDeviceConnectInfoStatus;
+	toString: () => string;
 }
 
 /**
  * This option specifies a time stamp governing the selection of tasks.
  */
-declare class VcTaskFilterSpecTimeOption {
-	readonly startedTime: VcTaskFilterSpecTimeOption;
-	readonly queuedTime: VcTaskFilterSpecTimeOption;
-	readonly completedTime: VcTaskFilterSpecTimeOption;
-	readonly name: string;
+declare class VcTaskFilterSpecTimeOption implements IPseudoEnum {
+	static readonly startedTime: VcTaskFilterSpecTimeOption & EnumVal<'startedTime'>;
+	static readonly queuedTime: VcTaskFilterSpecTimeOption & EnumVal<'queuedTime'>;
+	static readonly completedTime: VcTaskFilterSpecTimeOption & EnumVal<'completedTime'>;
+	static fromString(value: string): VcTaskFilterSpecTimeOption & EnumVal<TcleanKeys<typeof VcTaskFilterSpecTimeOption>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcTaskFilterSpecTimeOption): VcTaskFilterSpecTimeOption;
+	toString: () => string;
 }
 
 /**
  * Types of entities supported by the service.
  */
-declare class EntityReferenceEntityType {
-	readonly cluster: EntityReferenceEntityType;
-	readonly storagePod: EntityReferenceEntityType;
-	readonly datastore: EntityReferenceEntityType;
-	readonly scsiAdapter: EntityReferenceEntityType;
-	readonly datacenter: EntityReferenceEntityType;
-	readonly vmFile: EntityReferenceEntityType;
-	readonly scsiPath: EntityReferenceEntityType;
-	readonly nasMount: EntityReferenceEntityType;
-	readonly vm: EntityReferenceEntityType;
-	readonly host: EntityReferenceEntityType;
-	readonly name: string;
-	readonly scsiTarget: EntityReferenceEntityType;
-	readonly scsiVolume: EntityReferenceEntityType;
+declare class EntityReferenceEntityType implements IPseudoEnum {
+	static readonly cluster: EntityReferenceEntityType & EnumVal<'cluster'>;
+	static readonly storagePod: EntityReferenceEntityType & EnumVal<'storagePod'>;
+	static readonly datastore: EntityReferenceEntityType & EnumVal<'datastore'>;
+	static readonly scsiAdapter: EntityReferenceEntityType & EnumVal<'scsiAdapter'>;
+	static readonly datacenter: EntityReferenceEntityType & EnumVal<'datacenter'>;
+	static readonly vmFile: EntityReferenceEntityType & EnumVal<'vmFile'>;
+	static readonly scsiPath: EntityReferenceEntityType & EnumVal<'scsiPath'>;
+	static readonly nasMount: EntityReferenceEntityType & EnumVal<'nasMount'>;
+	static readonly vm: EntityReferenceEntityType & EnumVal<'vm'>;
+	static readonly host: EntityReferenceEntityType & EnumVal<'host'>;
+	static readonly scsiTarget: EntityReferenceEntityType & EnumVal<'scsiTarget'>;
+	static readonly scsiVolume: EntityReferenceEntityType & EnumVal<'scsiVolume'>;
+	static readonly resourcePool: EntityReferenceEntityType & EnumVal<'resourcePool'>;
+	static fromString(value: string): EntityReferenceEntityType & EnumVal<TcleanKeys<typeof EntityReferenceEntityType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly resourcePool: EntityReferenceEntityType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: EntityReferenceEntityType): EntityReferenceEntityType;
+	toString: () => string;
 }
 
 /**
  * Security type supported
  */
-declare class VcHostNasVolumeSecurityType {
-	readonly SEC_KRB5I: VcHostNasVolumeSecurityType;
-	readonly name: string;
-	readonly SEC_KRB5: VcHostNasVolumeSecurityType;
+declare class VcHostNasVolumeSecurityType implements IPseudoEnum {
+	static readonly SEC_KRB5I: VcHostNasVolumeSecurityType & EnumVal<'SEC_KRB5I'>;
+	static readonly SEC_KRB5: VcHostNasVolumeSecurityType & EnumVal<'SEC_KRB5'>;
+	static readonly AUTH_SYS: VcHostNasVolumeSecurityType & EnumVal<'AUTH_SYS'>;
+	static fromString(value: string): VcHostNasVolumeSecurityType & EnumVal<TcleanKeys<typeof VcHostNasVolumeSecurityType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly AUTH_SYS: VcHostNasVolumeSecurityType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostNasVolumeSecurityType): VcHostNasVolumeSecurityType;
+	toString: () => string;
 }
 
 /**
  * The NPIV WWN source type.
  */
-declare class VcVirtualMachineConfigInfoNpivWwnType {
-	readonly external: VcVirtualMachineConfigInfoNpivWwnType;
-	readonly host: VcVirtualMachineConfigInfoNpivWwnType;
-	readonly name: string;
+declare class VcVirtualMachineConfigInfoNpivWwnType implements IPseudoEnum {
+	static readonly external: VcVirtualMachineConfigInfoNpivWwnType & EnumVal<'external'>;
+	static readonly host: VcVirtualMachineConfigInfoNpivWwnType & EnumVal<'host'>;
+	static readonly vc: VcVirtualMachineConfigInfoNpivWwnType & EnumVal<'vc'>;
+	static fromString(value: string): VcVirtualMachineConfigInfoNpivWwnType & EnumVal<TcleanKeys<typeof VcVirtualMachineConfigInfoNpivWwnType>>;
+
 	readonly id: string;
-	readonly vc: VcVirtualMachineConfigInfoNpivWwnType;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineConfigInfoNpivWwnType): VcVirtualMachineConfigInfoNpivWwnType;
+	toString: () => string;
 }
 
 /**
  * The action to take with regard to storage objects upon decommissioning
  * a host from use with the VSAN service.
  */
-declare class VcVsanHostDecommissionModeObjectAction {
-	readonly evacuateAllData: VcVsanHostDecommissionModeObjectAction;
-	readonly name: string;
-	readonly ensureObjectAccessibility: VcVsanHostDecommissionModeObjectAction;
+declare class VcVsanHostDecommissionModeObjectAction implements IPseudoEnum {
+	static readonly evacuateAllData: VcVsanHostDecommissionModeObjectAction & EnumVal<'evacuateAllData'>;
+	static readonly ensureObjectAccessibility: VcVsanHostDecommissionModeObjectAction & EnumVal<'ensureObjectAccessibility'>;
+	static readonly noAction: VcVsanHostDecommissionModeObjectAction & EnumVal<'noAction'>;
+	static fromString(value: string): VcVsanHostDecommissionModeObjectAction & EnumVal<TcleanKeys<typeof VcVsanHostDecommissionModeObjectAction>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly noAction: VcVsanHostDecommissionModeObjectAction;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVsanHostDecommissionModeObjectAction): VcVsanHostDecommissionModeObjectAction;
+	toString: () => string;
 }
 
 /**
@@ -5737,69 +5449,65 @@ declare class VcVsanHostDecommissionModeObjectAction {
  * </li>
  * </ul>
  */
-declare class VcClusterDasConfigInfoVmMonitoringState {
-	static readonly vmMonitoringDisabled: VcClusterDasConfigInfoVmMonitoringState;
-	static readonly vmMonitoringOnly: VcClusterDasConfigInfoVmMonitoringState;
-	static readonly name: string;
-	static readonly id: string;
-	static readonly value: string;
-	static readonly vmAndAppMonitoring: VcClusterDasConfigInfoVmMonitoringState;
+declare class VcClusterDasConfigInfoVmMonitoringState implements IPseudoEnum {
+	static readonly vmMonitoringDisabled: VcClusterDasConfigInfoVmMonitoringState & EnumVal<'vmMonitoringDisabled'>;
+	static readonly vmMonitoringOnly: VcClusterDasConfigInfoVmMonitoringState & EnumVal<'vmMonitoringOnly'>;
+	static readonly vmAndAppMonitoring: VcClusterDasConfigInfoVmMonitoringState & EnumVal<'vmAndAppMonitoring'>;
+	static fromString(value: string): VcClusterDasConfigInfoVmMonitoringState & EnumVal<TcleanKeys<typeof VcClusterDasConfigInfoVmMonitoringState>>;
+
+	readonly id: string;
+	readonly name: string;
+	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	static fromString(value: VcClusterDasConfigInfoVmMonitoringState): VcClusterDasConfigInfoVmMonitoringState;
+	toString: () => string;
 }
 
 /**
  * The installation type of tools in the VM.
  */
-declare class VcVirtualMachineToolsInstallType {
-	readonly guestToolsTypeMSI: VcVirtualMachineToolsInstallType;
-	readonly name: string;
-	readonly guestToolsTypeOSP: VcVirtualMachineToolsInstallType;
-	readonly guestToolsTypeOpenVMTools: VcVirtualMachineToolsInstallType;
+declare class VcVirtualMachineToolsInstallType implements IPseudoEnum {
+	static readonly guestToolsTypeMSI: VcVirtualMachineToolsInstallType & EnumVal<'guestToolsTypeMSI'>;
+	static readonly guestToolsTypeOSP: VcVirtualMachineToolsInstallType & EnumVal<'guestToolsTypeOSP'>;
+	static readonly guestToolsTypeOpenVMTools: VcVirtualMachineToolsInstallType & EnumVal<'guestToolsTypeOpenVMTools'>;
+	static readonly guestToolsTypeUnknown: VcVirtualMachineToolsInstallType & EnumVal<'guestToolsTypeUnknown'>;
+	static readonly guestToolsTypeTar: VcVirtualMachineToolsInstallType & EnumVal<'guestToolsTypeTar'>;
+	static fromString(value: string): VcVirtualMachineToolsInstallType & EnumVal<TcleanKeys<typeof VcVirtualMachineToolsInstallType>>;
+
 	readonly id: string;
-	readonly guestToolsTypeUnknown: VcVirtualMachineToolsInstallType;
-	readonly guestToolsTypeTar: VcVirtualMachineToolsInstallType;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineToolsInstallType): VcVirtualMachineToolsInstallType;
+	toString: () => string;
 }
 
 /**
  * The list of possible default power operations available for the virtual machine
  */
-declare class VcVirtualMachinePowerOpType {
-	readonly name: string;
-	readonly hard: VcVirtualMachinePowerOpType;
-	readonly preset: VcVirtualMachinePowerOpType;
+declare class VcVirtualMachinePowerOpType implements IPseudoEnum {
+	static readonly hard: VcVirtualMachinePowerOpType & EnumVal<'hard'>;
+	static readonly preset: VcVirtualMachinePowerOpType & EnumVal<'preset'>;
+	static readonly soft: VcVirtualMachinePowerOpType & EnumVal<'soft'>;
+	static fromString(value: string): VcVirtualMachinePowerOpType & EnumVal<TcleanKeys<typeof VcVirtualMachinePowerOpType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly soft: VcVirtualMachinePowerOpType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachinePowerOpType): VcVirtualMachinePowerOpType;
+	toString: () => string;
 }
 
-declare class VcHostProfileManagerMetadataTypes {
-	readonly component: VcHostProfileManagerMetadataTypes;
-	readonly profile: VcHostProfileManagerMetadataTypes;
-	readonly name: string;
+declare class VcHostProfileManagerMetadataTypes implements IPseudoEnum {
+	static readonly component: VcHostProfileManagerMetadataTypes & EnumVal<'component'>;
+	static readonly profile: VcHostProfileManagerMetadataTypes & EnumVal<'profile'>;
+	static readonly category: VcHostProfileManagerMetadataTypes & EnumVal<'category'>;
+	static readonly policy: VcHostProfileManagerMetadataTypes & EnumVal<'policy'>;
+	static fromString(value: string): VcHostProfileManagerMetadataTypes & EnumVal<TcleanKeys<typeof VcHostProfileManagerMetadataTypes>>;
+
 	readonly id: string;
-	readonly category: VcHostProfileManagerMetadataTypes;
+	readonly name: string;
 	readonly value: string;
-	readonly policy: VcHostProfileManagerMetadataTypes;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostProfileManagerMetadataTypes): VcHostProfileManagerMetadataTypes;
+	toString: () => string;
 }
 
 /**
@@ -5845,136 +5553,128 @@ declare class VcHostProfileManagerMetadataTypes {
  * and that at least one network path is available at all times, host network
  * isolation should be a rare occurrence.
  */
-declare class VcClusterDasVmSettingsIsolationResponse {
-	static readonly powerOff: VcClusterDasVmSettingsIsolationResponse;
-	static readonly clusterIsolationResponse: VcClusterDasVmSettingsIsolationResponse;
-	static readonly name: string;
-	static readonly none: VcClusterDasVmSettingsIsolationResponse;
-	static readonly id: string;
-	static readonly value: string;
-	static readonly shutdown: VcClusterDasVmSettingsIsolationResponse;
+declare class VcClusterDasVmSettingsIsolationResponse implements IPseudoEnum {
+	static readonly powerOff: VcClusterDasVmSettingsIsolationResponse & EnumVal<'powerOff'>;
+	static readonly clusterIsolationResponse: VcClusterDasVmSettingsIsolationResponse & EnumVal<'clusterIsolationResponse'>;
+	static readonly none: VcClusterDasVmSettingsIsolationResponse & EnumVal<'none'>;
+	static readonly shutdown: VcClusterDasVmSettingsIsolationResponse & EnumVal<'shutdown'>;
+	static fromString(value: string): VcClusterDasVmSettingsIsolationResponse & EnumVal<TcleanKeys<typeof VcClusterDasVmSettingsIsolationResponse>>;
+
+	readonly id: string;
+	readonly name: string;
+	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	static fromString(value: VcClusterDasVmSettingsIsolationResponse): VcClusterDasVmSettingsIsolationResponse;
+	toString: () => string;
 }
 
 /**
  * Cost units apply to licenses for the purpose of determining
  * how many licenses are needed.
  */
-declare class VcLicenseFeatureInfoUnit {
-	readonly cpuPackage: VcLicenseFeatureInfoUnit;
-	readonly server: VcLicenseFeatureInfoUnit;
-	readonly vm: VcLicenseFeatureInfoUnit;
-	readonly host: VcLicenseFeatureInfoUnit;
-	readonly name: string;
+declare class VcLicenseFeatureInfoUnit implements IPseudoEnum {
+	static readonly cpuPackage: VcLicenseFeatureInfoUnit & EnumVal<'cpuPackage'>;
+	static readonly server: VcLicenseFeatureInfoUnit & EnumVal<'server'>;
+	static readonly vm: VcLicenseFeatureInfoUnit & EnumVal<'vm'>;
+	static readonly host: VcLicenseFeatureInfoUnit & EnumVal<'host'>;
+	static readonly cpuCore: VcLicenseFeatureInfoUnit & EnumVal<'cpuCore'>;
+	static fromString(value: string): VcLicenseFeatureInfoUnit & EnumVal<TcleanKeys<typeof VcLicenseFeatureInfoUnit>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly cpuCore: VcLicenseFeatureInfoUnit;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcLicenseFeatureInfoUnit): VcLicenseFeatureInfoUnit;
+	toString: () => string;
 }
 
-declare class VcHostUnresolvedVmfsResolutionSpecVmfsUuidResolution {
-	readonly forceMount: VcHostUnresolvedVmfsResolutionSpecVmfsUuidResolution;
-	readonly name: string;
-	readonly resignature: VcHostUnresolvedVmfsResolutionSpecVmfsUuidResolution;
+declare class VcHostUnresolvedVmfsResolutionSpecVmfsUuidResolution implements IPseudoEnum {
+	static readonly forceMount: VcHostUnresolvedVmfsResolutionSpecVmfsUuidResolution & EnumVal<'forceMount'>;
+	static readonly resignature: VcHostUnresolvedVmfsResolutionSpecVmfsUuidResolution & EnumVal<'resignature'>;
+	static fromString(value: string): VcHostUnresolvedVmfsResolutionSpecVmfsUuidResolution & EnumVal<TcleanKeys<typeof VcHostUnresolvedVmfsResolutionSpecVmfsUuidResolution>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostUnresolvedVmfsResolutionSpecVmfsUuidResolution): VcHostUnresolvedVmfsResolutionSpecVmfsUuidResolution;
+	toString: () => string;
 }
 
-declare class VcQuarantineModeFaultFaultType {
-	readonly CorrectionDisallowed: VcQuarantineModeFaultFaultType;
-	readonly CorrectionImpact: VcQuarantineModeFaultFaultType;
-	readonly name: string;
-	readonly NoCompatibleNonQuarantinedHost: VcQuarantineModeFaultFaultType;
+declare class VcQuarantineModeFaultFaultType implements IPseudoEnum {
+	static readonly CorrectionDisallowed: VcQuarantineModeFaultFaultType & EnumVal<'CorrectionDisallowed'>;
+	static readonly CorrectionImpact: VcQuarantineModeFaultFaultType & EnumVal<'CorrectionImpact'>;
+	static readonly NoCompatibleNonQuarantinedHost: VcQuarantineModeFaultFaultType & EnumVal<'NoCompatibleNonQuarantinedHost'>;
+	static fromString(value: string): VcQuarantineModeFaultFaultType & EnumVal<TcleanKeys<typeof VcQuarantineModeFaultFaultType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcQuarantineModeFaultFaultType): VcQuarantineModeFaultFaultType;
+	toString: () => string;
 }
 
 /**
  * list of defined statistics sets.
  */
-declare class VcInternalStatsSet {
-	readonly vmFaultToleranceStats: VcInternalStatsSet;
-	readonly vmMemoryOverheadStats: VcInternalStatsSet;
-	readonly name: string;
+declare class VcInternalStatsSet implements IPseudoEnum {
+	static readonly vmFaultToleranceStats: VcInternalStatsSet & EnumVal<'vmFaultToleranceStats'>;
+	static readonly vmMemoryOverheadStats: VcInternalStatsSet & EnumVal<'vmMemoryOverheadStats'>;
+	static fromString(value: string): VcInternalStatsSet & EnumVal<TcleanKeys<typeof VcInternalStatsSet>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcInternalStatsSet): VcInternalStatsSet;
+	toString: () => string;
 }
 
 /**
  * Network resource control version types.
  */
-declare class VcDistributedVirtualSwitchNetworkResourceControlVersion {
-	readonly version2: VcDistributedVirtualSwitchNetworkResourceControlVersion;
-	readonly version3: VcDistributedVirtualSwitchNetworkResourceControlVersion;
-	readonly name: string;
+declare class VcDistributedVirtualSwitchNetworkResourceControlVersion implements IPseudoEnum {
+	static readonly version2: VcDistributedVirtualSwitchNetworkResourceControlVersion & EnumVal<'version2'>;
+	static readonly version3: VcDistributedVirtualSwitchNetworkResourceControlVersion & EnumVal<'version3'>;
+	static fromString(value: string): VcDistributedVirtualSwitchNetworkResourceControlVersion & EnumVal<TcleanKeys<typeof VcDistributedVirtualSwitchNetworkResourceControlVersion>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDistributedVirtualSwitchNetworkResourceControlVersion): VcDistributedVirtualSwitchNetworkResourceControlVersion;
+	toString: () => string;
 }
 
 /**
  * The product spec operation types.
  */
-declare class VcDistributedVirtualSwitchProductSpecOperationType {
-	readonly preInstall: VcDistributedVirtualSwitchProductSpecOperationType;
-	readonly upgrade: VcDistributedVirtualSwitchProductSpecOperationType;
-	readonly proceedWithUpgrade: VcDistributedVirtualSwitchProductSpecOperationType;
-	readonly notifyAvailableUpgrade: VcDistributedVirtualSwitchProductSpecOperationType;
-	readonly updateBundleInfo: VcDistributedVirtualSwitchProductSpecOperationType;
-	readonly name: string;
+declare class VcDistributedVirtualSwitchProductSpecOperationType implements IPseudoEnum {
+	static readonly preInstall: VcDistributedVirtualSwitchProductSpecOperationType & EnumVal<'preInstall'>;
+	static readonly upgrade: VcDistributedVirtualSwitchProductSpecOperationType & EnumVal<'upgrade'>;
+	static readonly proceedWithUpgrade: VcDistributedVirtualSwitchProductSpecOperationType & EnumVal<'proceedWithUpgrade'>;
+	static readonly notifyAvailableUpgrade: VcDistributedVirtualSwitchProductSpecOperationType & EnumVal<'notifyAvailableUpgrade'>;
+	static readonly updateBundleInfo: VcDistributedVirtualSwitchProductSpecOperationType & EnumVal<'updateBundleInfo'>;
+	static fromString(value: string): VcDistributedVirtualSwitchProductSpecOperationType & EnumVal<TcleanKeys<typeof VcDistributedVirtualSwitchProductSpecOperationType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDistributedVirtualSwitchProductSpecOperationType): VcDistributedVirtualSwitchProductSpecOperationType;
+	toString: () => string;
 }
 
 /**
  * The set of values used to determine ordering of default routers.
  * See RFC 4293 ipDefaultRouterPreference.
  */
-declare class VcNetIpStackInfoPreference {
-	readonly high: VcNetIpStackInfoPreference;
-	readonly reserved: VcNetIpStackInfoPreference;
-	readonly low: VcNetIpStackInfoPreference;
-	readonly name: string;
-	readonly medium: VcNetIpStackInfoPreference;
+declare class VcNetIpStackInfoPreference implements IPseudoEnum {
+	static readonly high: VcNetIpStackInfoPreference & EnumVal<'high'>;
+	static readonly reserved: VcNetIpStackInfoPreference & EnumVal<'reserved'>;
+	static readonly low: VcNetIpStackInfoPreference & EnumVal<'low'>;
+	static readonly medium: VcNetIpStackInfoPreference & EnumVal<'medium'>;
+	static fromString(value: string): VcNetIpStackInfoPreference & EnumVal<TcleanKeys<typeof VcNetIpStackInfoPreference>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcNetIpStackInfoPreference): VcNetIpStackInfoPreference;
+	toString: () => string;
 }
 
 /**
@@ -5983,100 +5683,94 @@ declare class VcNetIpStackInfoPreference {
  * The list of supported disk modes varies by the backing type. The "persistent"
  * mode is supported by every backing type.
  */
-declare class VcVirtualDiskMode {
-	readonly nonpersistent: VcVirtualDiskMode;
-	readonly name: string;
-	readonly undoable: VcVirtualDiskMode;
-	readonly independent_nonpersistent: VcVirtualDiskMode;
+declare class VcVirtualDiskMode implements IPseudoEnum {
+	static readonly nonpersistent: VcVirtualDiskMode & EnumVal<'nonpersistent'>;
+	static readonly undoable: VcVirtualDiskMode & EnumVal<'undoable'>;
+	static readonly independent_nonpersistent: VcVirtualDiskMode & EnumVal<'independent_nonpersistent'>;
+	static readonly persistent: VcVirtualDiskMode & EnumVal<'persistent'>;
+	static readonly append: VcVirtualDiskMode & EnumVal<'append'>;
+	static readonly independent_persistent: VcVirtualDiskMode & EnumVal<'independent_persistent'>;
+	static fromString(value: string): VcVirtualDiskMode & EnumVal<TcleanKeys<typeof VcVirtualDiskMode>>;
+
 	readonly id: string;
-	readonly persistent: VcVirtualDiskMode;
+	readonly name: string;
 	readonly value: string;
-	readonly append: VcVirtualDiskMode;
-	readonly independent_persistent: VcVirtualDiskMode;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualDiskMode): VcVirtualDiskMode;
+	toString: () => string;
 }
 
-declare class VcDrsBehavior {
-	static readonly partiallyAutomated: VcDrsBehavior;
-	static readonly name: string;
-	static readonly id: string;
-	static readonly manual: VcDrsBehavior;
-	static readonly value: string;
-	static readonly fullyAutomated: VcDrsBehavior;
+declare class VcDrsBehavior implements IPseudoEnum {
+	static readonly partiallyAutomated: VcDrsBehavior & EnumVal<'partiallyAutomated'>;
+	static readonly manual: VcDrsBehavior & EnumVal<'manual'>;
+	static readonly fullyAutomated: VcDrsBehavior & EnumVal<'fullyAutomated'>;
+	static fromString(value: string): VcDrsBehavior & EnumVal<TcleanKeys<typeof VcDrsBehavior>>;
+
+	readonly id: string;
+	readonly name: string;
+	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	static fromString(value: VcDrsBehavior): VcDrsBehavior;
+	toString: () => string;
 }
 
 /**
  * Multicast Filtering mode.
  */
-declare class VcVMwareDvsMulticastFilteringMode {
-	readonly snooping: VcVMwareDvsMulticastFilteringMode;
-	readonly legacyFiltering: VcVMwareDvsMulticastFilteringMode;
-	readonly name: string;
+declare class VcVMwareDvsMulticastFilteringMode implements IPseudoEnum {
+	static readonly snooping: VcVMwareDvsMulticastFilteringMode & EnumVal<'snooping'>;
+	static readonly legacyFiltering: VcVMwareDvsMulticastFilteringMode & EnumVal<'legacyFiltering'>;
+	static fromString(value: string): VcVMwareDvsMulticastFilteringMode & EnumVal<TcleanKeys<typeof VcVMwareDvsMulticastFilteringMode>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVMwareDvsMulticastFilteringMode): VcVMwareDvsMulticastFilteringMode;
+	toString: () => string;
 }
 
-declare class VcDynamicTypeMgrParamTypeInfoAnnotationType {
-	readonly name: string;
-	readonly optional: VcDynamicTypeMgrParamTypeInfoAnnotationType;
-	readonly secret: VcDynamicTypeMgrParamTypeInfoAnnotationType;
+declare class VcDynamicTypeMgrParamTypeInfoAnnotationType implements IPseudoEnum {
+	static readonly optional: VcDynamicTypeMgrParamTypeInfoAnnotationType & EnumVal<'optional'>;
+	static readonly secret: VcDynamicTypeMgrParamTypeInfoAnnotationType & EnumVal<'secret'>;
+	static fromString(value: string): VcDynamicTypeMgrParamTypeInfoAnnotationType & EnumVal<TcleanKeys<typeof VcDynamicTypeMgrParamTypeInfoAnnotationType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDynamicTypeMgrParamTypeInfoAnnotationType): VcDynamicTypeMgrParamTypeInfoAnnotationType;
+	toString: () => string;
 }
 
 /**
  * A {@link HealthState} represents the state of a participating
  * host in the VSAN service.
  */
-declare class VcVsanHostHealthState {
-	readonly healthy: VcVsanHostHealthState;
-	readonly unhealthy: VcVsanHostHealthState;
-	readonly name: string;
+declare class VcVsanHostHealthState implements IPseudoEnum {
+	static readonly healthy: VcVsanHostHealthState & EnumVal<'healthy'>;
+	static readonly unhealthy: VcVsanHostHealthState & EnumVal<'unhealthy'>;
+	static readonly unknown: VcVsanHostHealthState & EnumVal<'unknown'>;
+	static fromString(value: string): VcVsanHostHealthState & EnumVal<TcleanKeys<typeof VcVsanHostHealthState>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly unknown: VcVsanHostHealthState;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVsanHostHealthState): VcVsanHostHealthState;
+	toString: () => string;
 }
 
 /**
  * Network Traffic Rule direction types. It specifies whether rule
  * needs to be applied for packets which are incoming/outgoing or both.
  */
-declare class VcDvsNetworkRuleDirectionType {
-	readonly name: string;
+declare class VcDvsNetworkRuleDirectionType implements IPseudoEnum {
+	static readonly incomingPackets: VcDvsNetworkRuleDirectionType & EnumVal<'incomingPackets'>;
+	static readonly outgoingPackets: VcDvsNetworkRuleDirectionType & EnumVal<'outgoingPackets'>;
+	static readonly both: VcDvsNetworkRuleDirectionType & EnumVal<'both'>;
+	static fromString(value: string): VcDvsNetworkRuleDirectionType & EnumVal<TcleanKeys<typeof VcDvsNetworkRuleDirectionType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly incomingPackets: VcDvsNetworkRuleDirectionType;
-	readonly outgoingPackets: VcDvsNetworkRuleDirectionType;
-	readonly both: VcDvsNetworkRuleDirectionType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDvsNetworkRuleDirectionType): VcDvsNetworkRuleDirectionType;
+	toString: () => string;
 }
 
 /**
@@ -6085,131 +5779,124 @@ declare class VcDvsNetworkRuleDirectionType {
  * disabled, starting, and enabled.
  * <p>
  */
-declare class VcVirtualMachineFaultToleranceState {
-	readonly running: VcVirtualMachineFaultToleranceState;
-	readonly notConfigured: VcVirtualMachineFaultToleranceState;
-	readonly name: string;
-	readonly disabled: VcVirtualMachineFaultToleranceState;
-	readonly needSecondary: VcVirtualMachineFaultToleranceState;
+declare class VcVirtualMachineFaultToleranceState implements IPseudoEnum {
+	static readonly running: VcVirtualMachineFaultToleranceState & EnumVal<'running'>;
+	static readonly notConfigured: VcVirtualMachineFaultToleranceState & EnumVal<'notConfigured'>;
+	static readonly disabled: VcVirtualMachineFaultToleranceState & EnumVal<'disabled'>;
+	static readonly needSecondary: VcVirtualMachineFaultToleranceState & EnumVal<'needSecondary'>;
+	static readonly starting: VcVirtualMachineFaultToleranceState & EnumVal<'starting'>;
+	static readonly enabled: VcVirtualMachineFaultToleranceState & EnumVal<'enabled'>;
+	static fromString(value: string): VcVirtualMachineFaultToleranceState & EnumVal<TcleanKeys<typeof VcVirtualMachineFaultToleranceState>>;
+
 	readonly id: string;
-	readonly starting: VcVirtualMachineFaultToleranceState;
+	readonly name: string;
 	readonly value: string;
-	readonly enabled: VcVirtualMachineFaultToleranceState;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineFaultToleranceState): VcVirtualMachineFaultToleranceState;
+	toString: () => string;
 }
 
 /**
  * The operation on the target state.
  */
-declare class VcStateAlarmOperator {
-	readonly isUnequal: VcStateAlarmOperator;
-	readonly isEqual: VcStateAlarmOperator;
-	readonly name: string;
+declare class VcStateAlarmOperator implements IPseudoEnum {
+	static readonly isUnequal: VcStateAlarmOperator & EnumVal<'isUnequal'>;
+	static readonly isEqual: VcStateAlarmOperator & EnumVal<'isEqual'>;
+	static fromString(value: string): VcStateAlarmOperator & EnumVal<TcleanKeys<typeof VcStateAlarmOperator>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcStateAlarmOperator): VcStateAlarmOperator;
+	toString: () => string;
 }
 
 /**
  * Reasons why the number of virtual CPUs is incompatible.
  */
-declare class VcNumVirtualCpusIncompatibleReason {
-	readonly recordReplay: VcNumVirtualCpusIncompatibleReason;
-	readonly faultTolerance: VcNumVirtualCpusIncompatibleReason;
-	readonly name: string;
+declare class VcNumVirtualCpusIncompatibleReason implements IPseudoEnum {
+	static readonly recordReplay: VcNumVirtualCpusIncompatibleReason & EnumVal<'recordReplay'>;
+	static readonly faultTolerance: VcNumVirtualCpusIncompatibleReason & EnumVal<'faultTolerance'>;
+	static fromString(value: string): VcNumVirtualCpusIncompatibleReason & EnumVal<TcleanKeys<typeof VcNumVirtualCpusIncompatibleReason>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcNumVirtualCpusIncompatibleReason): VcNumVirtualCpusIncompatibleReason;
+	toString: () => string;
 }
 
-declare class VcVmDasBeingResetEventReasonCode {
-	readonly appHeartbeatFailure: VcVmDasBeingResetEventReasonCode;
-	readonly name: string;
-	readonly vmcpResetApdCleared: VcVmDasBeingResetEventReasonCode;
-	readonly guestOsCrashFailure: VcVmDasBeingResetEventReasonCode;
+declare class VcVmDasBeingResetEventReasonCode implements IPseudoEnum {
+	static readonly appHeartbeatFailure: VcVmDasBeingResetEventReasonCode & EnumVal<'appHeartbeatFailure'>;
+	static readonly vmcpResetApdCleared: VcVmDasBeingResetEventReasonCode & EnumVal<'vmcpResetApdCleared'>;
+	static readonly guestOsCrashFailure: VcVmDasBeingResetEventReasonCode & EnumVal<'guestOsCrashFailure'>;
+	static readonly appImmediateResetRequest: VcVmDasBeingResetEventReasonCode & EnumVal<'appImmediateResetRequest'>;
+	static readonly vmtoolsHeartbeatFailure: VcVmDasBeingResetEventReasonCode & EnumVal<'vmtoolsHeartbeatFailure'>;
+	static fromString(value: string): VcVmDasBeingResetEventReasonCode & EnumVal<TcleanKeys<typeof VcVmDasBeingResetEventReasonCode>>;
+
 	readonly id: string;
-	readonly appImmediateResetRequest: VcVmDasBeingResetEventReasonCode;
+	readonly name: string;
 	readonly value: string;
-	readonly vmtoolsHeartbeatFailure: VcVmDasBeingResetEventReasonCode;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVmDasBeingResetEventReasonCode): VcVmDasBeingResetEventReasonCode;
+	toString: () => string;
 }
 
 /**
  * HTTP request methods.
  */
-declare class VcSessionManagerHttpServiceRequestSpecMethod {
-	readonly httpConnect: VcSessionManagerHttpServiceRequestSpecMethod;
-	readonly httpTrace: VcSessionManagerHttpServiceRequestSpecMethod;
-	readonly httpOptions: VcSessionManagerHttpServiceRequestSpecMethod;
-	readonly httpHead: VcSessionManagerHttpServiceRequestSpecMethod;
-	readonly httpPut: VcSessionManagerHttpServiceRequestSpecMethod;
-	readonly httpDelete: VcSessionManagerHttpServiceRequestSpecMethod;
-	readonly httpPost: VcSessionManagerHttpServiceRequestSpecMethod;
-	readonly name: string;
+declare class VcSessionManagerHttpServiceRequestSpecMethod implements IPseudoEnum {
+	static readonly httpConnect: VcSessionManagerHttpServiceRequestSpecMethod & EnumVal<'httpConnect'>;
+	static readonly httpTrace: VcSessionManagerHttpServiceRequestSpecMethod & EnumVal<'httpTrace'>;
+	static readonly httpOptions: VcSessionManagerHttpServiceRequestSpecMethod & EnumVal<'httpOptions'>;
+	static readonly httpHead: VcSessionManagerHttpServiceRequestSpecMethod & EnumVal<'httpHead'>;
+	static readonly httpPut: VcSessionManagerHttpServiceRequestSpecMethod & EnumVal<'httpPut'>;
+	static readonly httpDelete: VcSessionManagerHttpServiceRequestSpecMethod & EnumVal<'httpDelete'>;
+	static readonly httpPost: VcSessionManagerHttpServiceRequestSpecMethod & EnumVal<'httpPost'>;
+	static readonly httpGet: VcSessionManagerHttpServiceRequestSpecMethod & EnumVal<'httpGet'>;
+	static fromString(value: string): VcSessionManagerHttpServiceRequestSpecMethod & EnumVal<TcleanKeys<typeof VcSessionManagerHttpServiceRequestSpecMethod>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly httpGet: VcSessionManagerHttpServiceRequestSpecMethod;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcSessionManagerHttpServiceRequestSpecMethod): VcSessionManagerHttpServiceRequestSpecMethod;
+	toString: () => string;
 }
 
 /**
  * Enumeration of the supported Alarm Status values
  */
-declare class SmsAlarmStatus {
-	readonly Red: SmsAlarmStatus;
-	readonly Yellow: SmsAlarmStatus;
-	readonly name: string;
+declare class SmsAlarmStatus implements IPseudoEnum {
+	static readonly Red: SmsAlarmStatus & EnumVal<'Red'>;
+	static readonly Yellow: SmsAlarmStatus & EnumVal<'Yellow'>;
+	static readonly Green: SmsAlarmStatus & EnumVal<'Green'>;
+	static fromString(value: string): SmsAlarmStatus & EnumVal<TcleanKeys<typeof SmsAlarmStatus>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly Green: SmsAlarmStatus;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: SmsAlarmStatus): SmsAlarmStatus;
+	toString: () => string;
 }
 
 /**
  * List of possible host infrastructure traffic classes
  */
-declare class VcDistributedVirtualSwitchHostInfrastructureTrafficClass {
-	readonly virtualMachine: VcDistributedVirtualSwitchHostInfrastructureTrafficClass;
-	readonly iSCSI: VcDistributedVirtualSwitchHostInfrastructureTrafficClass;
-	readonly vdp: VcDistributedVirtualSwitchHostInfrastructureTrafficClass;
-	readonly management: VcDistributedVirtualSwitchHostInfrastructureTrafficClass;
-	readonly faultTolerance: VcDistributedVirtualSwitchHostInfrastructureTrafficClass;
-	readonly name: string;
-	readonly hbr: VcDistributedVirtualSwitchHostInfrastructureTrafficClass;
-	readonly nfs: VcDistributedVirtualSwitchHostInfrastructureTrafficClass;
+declare class VcDistributedVirtualSwitchHostInfrastructureTrafficClass implements IPseudoEnum {
+	static readonly virtualMachine: VcDistributedVirtualSwitchHostInfrastructureTrafficClass & EnumVal<'virtualMachine'>;
+	static readonly iSCSI: VcDistributedVirtualSwitchHostInfrastructureTrafficClass & EnumVal<'iSCSI'>;
+	static readonly vdp: VcDistributedVirtualSwitchHostInfrastructureTrafficClass & EnumVal<'vdp'>;
+	static readonly management: VcDistributedVirtualSwitchHostInfrastructureTrafficClass & EnumVal<'management'>;
+	static readonly faultTolerance: VcDistributedVirtualSwitchHostInfrastructureTrafficClass & EnumVal<'faultTolerance'>;
+	static readonly hbr: VcDistributedVirtualSwitchHostInfrastructureTrafficClass & EnumVal<'hbr'>;
+	static readonly nfs: VcDistributedVirtualSwitchHostInfrastructureTrafficClass & EnumVal<'nfs'>;
+	static readonly vsan: VcDistributedVirtualSwitchHostInfrastructureTrafficClass & EnumVal<'vsan'>;
+	static readonly vmotion: VcDistributedVirtualSwitchHostInfrastructureTrafficClass & EnumVal<'vmotion'>;
+	static fromString(value: string): VcDistributedVirtualSwitchHostInfrastructureTrafficClass & EnumVal<TcleanKeys<typeof VcDistributedVirtualSwitchHostInfrastructureTrafficClass>>;
+
 	readonly id: string;
-	readonly vsan: VcDistributedVirtualSwitchHostInfrastructureTrafficClass;
+	readonly name: string;
 	readonly value: string;
-	readonly vmotion: VcDistributedVirtualSwitchHostInfrastructureTrafficClass;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDistributedVirtualSwitchHostInfrastructureTrafficClass): VcDistributedVirtualSwitchHostInfrastructureTrafficClass;
+	toString: () => string;
 }
 
 /**
@@ -6222,121 +5909,114 @@ declare class VcDistributedVirtualSwitchHostInfrastructureTrafficClass {
  * acceleration and sets the {@link FileSystemMountInfo#vStorageSupport}
  * property accordingly.
  */
-declare class VcFileSystemMountInfoVStorageSupportStatus {
-	readonly name: string;
-	readonly vStorageUnsupported: VcFileSystemMountInfoVStorageSupportStatus;
+declare class VcFileSystemMountInfoVStorageSupportStatus implements IPseudoEnum {
+	static readonly vStorageUnsupported: VcFileSystemMountInfoVStorageSupportStatus & EnumVal<'vStorageUnsupported'>;
+	static readonly vStorageSupported: VcFileSystemMountInfoVStorageSupportStatus & EnumVal<'vStorageSupported'>;
+	static readonly vStorageUnknown: VcFileSystemMountInfoVStorageSupportStatus & EnumVal<'vStorageUnknown'>;
+	static fromString(value: string): VcFileSystemMountInfoVStorageSupportStatus & EnumVal<TcleanKeys<typeof VcFileSystemMountInfoVStorageSupportStatus>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly vStorageSupported: VcFileSystemMountInfoVStorageSupportStatus;
-	readonly vStorageUnknown: VcFileSystemMountInfoVStorageSupportStatus;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcFileSystemMountInfoVStorageSupportStatus): VcFileSystemMountInfoVStorageSupportStatus;
+	toString: () => string;
 }
 
 /**
  * Indicates how multiple samples of a specific counter type are
  * transformed into a single statistical value.
  */
-declare class VcPerfSummaryType {
-	readonly average: VcPerfSummaryType;
-	readonly name: string;
-	readonly maximum: VcPerfSummaryType;
-	readonly none: VcPerfSummaryType;
+declare class VcPerfSummaryType implements IPseudoEnum {
+	static readonly average: VcPerfSummaryType & EnumVal<'average'>;
+	static readonly maximum: VcPerfSummaryType & EnumVal<'maximum'>;
+	static readonly none: VcPerfSummaryType & EnumVal<'none'>;
+	static readonly minimum: VcPerfSummaryType & EnumVal<'minimum'>;
+	static readonly latest: VcPerfSummaryType & EnumVal<'latest'>;
+	static readonly summation: VcPerfSummaryType & EnumVal<'summation'>;
+	static fromString(value: string): VcPerfSummaryType & EnumVal<TcleanKeys<typeof VcPerfSummaryType>>;
+
 	readonly id: string;
-	readonly minimum: VcPerfSummaryType;
+	readonly name: string;
 	readonly value: string;
-	readonly latest: VcPerfSummaryType;
-	readonly summation: VcPerfSummaryType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcPerfSummaryType): VcPerfSummaryType;
+	toString: () => string;
 }
 
 /**
  * List of possible VASA profiles supported by Storage Array
  */
-declare class VasaProfile {
-	readonly blockDevice: VasaProfile;
-	readonly fileSystem: VasaProfile;
-	readonly capability: VasaProfile;
-	readonly storageDrsBlockDevice: VasaProfile;
-	readonly name: string;
-	readonly storageDrsFileSystem: VasaProfile;
+declare class VasaProfile implements IPseudoEnum {
+	static readonly blockDevice: VasaProfile & EnumVal<'blockDevice'>;
+	static readonly fileSystem: VasaProfile & EnumVal<'fileSystem'>;
+	static readonly capability: VasaProfile & EnumVal<'capability'>;
+	static readonly storageDrsBlockDevice: VasaProfile & EnumVal<'storageDrsBlockDevice'>;
+	static readonly storageDrsFileSystem: VasaProfile & EnumVal<'storageDrsFileSystem'>;
+	static readonly policy: VasaProfile & EnumVal<'policy'>;
+	static readonly object: VasaProfile & EnumVal<'object'>;
+	static readonly statistics: VasaProfile & EnumVal<'statistics'>;
+	static fromString(value: string): VasaProfile & EnumVal<TcleanKeys<typeof VasaProfile>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly policy: VasaProfile;
-	readonly object: VasaProfile;
-	readonly statistics: VasaProfile;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VasaProfile): VasaProfile;
+	toString: () => string;
 }
 
-declare class VcResourceType {
-	readonly memory: VcResourceType;
-	readonly name: string;
-	readonly cpu: VcResourceType;
+declare class VcResourceType implements IPseudoEnum {
+	static readonly memory: VcResourceType & EnumVal<'memory'>;
+	static readonly cpu: VcResourceType & EnumVal<'cpu'>;
+	static fromString(value: string): VcResourceType & EnumVal<TcleanKeys<typeof VcResourceType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcResourceType): VcResourceType;
+	toString: () => string;
 }
 
 /**
  * All known file extensions. Valid ones are:
  */
-declare class VcVirtualDeviceFileExtension {
-	readonly iso: VcVirtualDeviceFileExtension;
-	readonly name: string;
-	readonly vmdk: VcVirtualDeviceFileExtension;
-	readonly rdm: VcVirtualDeviceFileExtension;
-	readonly flp: VcVirtualDeviceFileExtension;
+declare class VcVirtualDeviceFileExtension implements IPseudoEnum {
+	static readonly iso: VcVirtualDeviceFileExtension & EnumVal<'iso'>;
+	static readonly vmdk: VcVirtualDeviceFileExtension & EnumVal<'vmdk'>;
+	static readonly rdm: VcVirtualDeviceFileExtension & EnumVal<'rdm'>;
+	static readonly flp: VcVirtualDeviceFileExtension & EnumVal<'flp'>;
+	static readonly dsk: VcVirtualDeviceFileExtension & EnumVal<'dsk'>;
+	static fromString(value: string): VcVirtualDeviceFileExtension & EnumVal<TcleanKeys<typeof VcVirtualDeviceFileExtension>>;
+
 	readonly id: string;
-	readonly dsk: VcVirtualDeviceFileExtension;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualDeviceFileExtension): VcVirtualDeviceFileExtension;
+	toString: () => string;
 }
 
-declare class VcSoftwarePackageVibType {
-	readonly meta: VcSoftwarePackageVibType;
-	readonly name: string;
+declare class VcSoftwarePackageVibType implements IPseudoEnum {
+	static readonly meta: VcSoftwarePackageVibType & EnumVal<'meta'>;
+	static readonly tools: VcSoftwarePackageVibType & EnumVal<'tools'>;
+	static readonly bootbank: VcSoftwarePackageVibType & EnumVal<'bootbank'>;
+	static fromString(value: string): VcSoftwarePackageVibType & EnumVal<TcleanKeys<typeof VcSoftwarePackageVibType>>;
+
 	readonly id: string;
-	readonly tools: VcSoftwarePackageVibType;
+	readonly name: string;
 	readonly value: string;
-	readonly bootbank: VcSoftwarePackageVibType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcSoftwarePackageVibType): VcSoftwarePackageVibType;
+	toString: () => string;
 }
 
-declare class VcAlarmTriggerType {
-	readonly metric: VcAlarmTriggerType;
-	readonly name: string;
-	readonly state: VcAlarmTriggerType;
+declare class VcAlarmTriggerType implements IPseudoEnum {
+	static readonly metric: VcAlarmTriggerType & EnumVal<'metric'>;
+	static readonly state: VcAlarmTriggerType & EnumVal<'state'>;
+	static readonly event: VcAlarmTriggerType & EnumVal<'event'>;
+	static fromString(value: string): VcAlarmTriggerType & EnumVal<TcleanKeys<typeof VcAlarmTriggerType>>;
+
 	readonly id: string;
-	readonly event: VcAlarmTriggerType;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcAlarmTriggerType): VcAlarmTriggerType;
+	toString: () => string;
 }
 
 /**
@@ -6344,18 +6024,17 @@ declare class VcAlarmTriggerType {
  * {@link vim.dvs.DistributedVirtualSwitchManager}.{@link vim.dvs.DistributedVirtualSwitchManager#importEntity}
  * operation.
  */
-declare class VcEntityImportType {
-	readonly createEntityWithNewIdentifier: VcEntityImportType;
-	readonly name: string;
+declare class VcEntityImportType implements IPseudoEnum {
+	static readonly createEntityWithNewIdentifier: VcEntityImportType & EnumVal<'createEntityWithNewIdentifier'>;
+	static readonly applyToEntitySpecified: VcEntityImportType & EnumVal<'applyToEntitySpecified'>;
+	static readonly createEntityWithOriginalIdentifier: VcEntityImportType & EnumVal<'createEntityWithOriginalIdentifier'>;
+	static fromString(value: string): VcEntityImportType & EnumVal<TcleanKeys<typeof VcEntityImportType>>;
+
 	readonly id: string;
-	readonly applyToEntitySpecified: VcEntityImportType;
+	readonly name: string;
 	readonly value: string;
-	readonly createEntityWithOriginalIdentifier: VcEntityImportType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcEntityImportType): VcEntityImportType;
+	toString: () => string;
 }
 
 /**
@@ -6363,113 +6042,107 @@ declare class VcEntityImportType {
  * is set/deleted always, or only if current value matches
  * one specified here.
  */
-declare class VcVirtualMachineNamespaceManagerDataSpecOpCode {
-	readonly updateAlways: VcVirtualMachineNamespaceManagerDataSpecOpCode;
-	readonly name: string;
+declare class VcVirtualMachineNamespaceManagerDataSpecOpCode implements IPseudoEnum {
+	static readonly updateAlways: VcVirtualMachineNamespaceManagerDataSpecOpCode & EnumVal<'updateAlways'>;
+	static readonly updateIfEqual: VcVirtualMachineNamespaceManagerDataSpecOpCode & EnumVal<'updateIfEqual'>;
+	static fromString(value: string): VcVirtualMachineNamespaceManagerDataSpecOpCode & EnumVal<TcleanKeys<typeof VcVirtualMachineNamespaceManagerDataSpecOpCode>>;
+
 	readonly id: string;
-	readonly updateIfEqual: VcVirtualMachineNamespaceManagerDataSpecOpCode;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineNamespaceManagerDataSpecOpCode): VcVirtualMachineNamespaceManagerDataSpecOpCode;
+	toString: () => string;
 }
 
 /**
  * Describes the state of the host proxy switch.
  */
-declare class VcDistributedVirtualSwitchHostMemberHostComponentState {
-	readonly disconnected: VcDistributedVirtualSwitchHostMemberHostComponentState;
-	readonly pending: VcDistributedVirtualSwitchHostMemberHostComponentState;
-	readonly name: string;
-	readonly warning: VcDistributedVirtualSwitchHostMemberHostComponentState;
-	readonly up: VcDistributedVirtualSwitchHostMemberHostComponentState;
+declare class VcDistributedVirtualSwitchHostMemberHostComponentState implements IPseudoEnum {
+	static readonly disconnected: VcDistributedVirtualSwitchHostMemberHostComponentState & EnumVal<'disconnected'>;
+	static readonly pending: VcDistributedVirtualSwitchHostMemberHostComponentState & EnumVal<'pending'>;
+	static readonly warning: VcDistributedVirtualSwitchHostMemberHostComponentState & EnumVal<'warning'>;
+	static readonly up: VcDistributedVirtualSwitchHostMemberHostComponentState & EnumVal<'up'>;
+	static readonly outOfSync: VcDistributedVirtualSwitchHostMemberHostComponentState & EnumVal<'outOfSync'>;
+	static readonly down: VcDistributedVirtualSwitchHostMemberHostComponentState & EnumVal<'down'>;
+	static fromString(value: string): VcDistributedVirtualSwitchHostMemberHostComponentState & EnumVal<TcleanKeys<typeof VcDistributedVirtualSwitchHostMemberHostComponentState>>;
+
 	readonly id: string;
-	readonly outOfSync: VcDistributedVirtualSwitchHostMemberHostComponentState;
-	readonly down: VcDistributedVirtualSwitchHostMemberHostComponentState;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDistributedVirtualSwitchHostMemberHostComponentState): VcDistributedVirtualSwitchHostMemberHostComponentState;
+	toString: () => string;
 }
 
 /**
  * Defines the storage placement operation type.
  * <p>
  */
-declare class VcStoragePlacementSpecPlacementType {
-	readonly expandDisk: VcStoragePlacementSpecPlacementType;
-	readonly relocate: VcStoragePlacementSpecPlacementType;
-	readonly clone: VcStoragePlacementSpecPlacementType;
-	readonly name: string;
-	readonly create: VcStoragePlacementSpecPlacementType;
+declare class VcStoragePlacementSpecPlacementType implements IPseudoEnum {
+	static readonly expandDisk: VcStoragePlacementSpecPlacementType & EnumVal<'expandDisk'>;
+	static readonly relocate: VcStoragePlacementSpecPlacementType & EnumVal<'relocate'>;
+	static readonly clone: VcStoragePlacementSpecPlacementType & EnumVal<'clone'>;
+	static readonly create: VcStoragePlacementSpecPlacementType & EnumVal<'create'>;
+	static readonly reconfigure: VcStoragePlacementSpecPlacementType & EnumVal<'reconfigure'>;
+	static fromString(value: string): VcStoragePlacementSpecPlacementType & EnumVal<TcleanKeys<typeof VcStoragePlacementSpecPlacementType>>;
+
 	readonly id: string;
-	readonly reconfigure: VcStoragePlacementSpecPlacementType;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcStoragePlacementSpecPlacementType): VcStoragePlacementSpecPlacementType;
+	toString: () => string;
 }
 
-declare class VcHostVirtualNicManagerNicType {
-	readonly vSphereProvisioning: VcHostVirtualNicManagerNicType;
-	readonly vSphereReplication: VcHostVirtualNicManagerNicType;
-	readonly management: VcHostVirtualNicManagerNicType;
-	readonly vsanWitness: VcHostVirtualNicManagerNicType;
-	readonly name: string;
-	readonly vSphereReplicationNFC: VcHostVirtualNicManagerNicType;
+declare class VcHostVirtualNicManagerNicType implements IPseudoEnum {
+	static readonly vSphereProvisioning: VcHostVirtualNicManagerNicType & EnumVal<'vSphereProvisioning'>;
+	static readonly vSphereReplication: VcHostVirtualNicManagerNicType & EnumVal<'vSphereReplication'>;
+	static readonly management: VcHostVirtualNicManagerNicType & EnumVal<'management'>;
+	static readonly vsanWitness: VcHostVirtualNicManagerNicType & EnumVal<'vsanWitness'>;
+	static readonly vSphereReplicationNFC: VcHostVirtualNicManagerNicType & EnumVal<'vSphereReplicationNFC'>;
+	static readonly faultToleranceLogging: VcHostVirtualNicManagerNicType & EnumVal<'faultToleranceLogging'>;
+	static readonly vsan: VcHostVirtualNicManagerNicType & EnumVal<'vsan'>;
+	static readonly vmotion: VcHostVirtualNicManagerNicType & EnumVal<'vmotion'>;
+	static fromString(value: string): VcHostVirtualNicManagerNicType & EnumVal<TcleanKeys<typeof VcHostVirtualNicManagerNicType>>;
+
 	readonly id: string;
-	readonly faultToleranceLogging: VcHostVirtualNicManagerNicType;
-	readonly vsan: VcHostVirtualNicManagerNicType;
+	readonly name: string;
 	readonly value: string;
-	readonly vmotion: VcHostVirtualNicManagerNicType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostVirtualNicManagerNicType): VcHostVirtualNicManagerNicType;
+	toString: () => string;
 }
 
 /**
  * The {@link pbm.profile.VmAssociations.Operation} enumerated type
  * defines the provisioning operation being performed on the virtual machine.
  */
-declare class PbmVmOperation {
-	readonly RECONFIGURE: PbmVmOperation;
-	readonly CREATE: PbmVmOperation;
-	readonly name: string;
-	readonly MIGRATE: PbmVmOperation;
+declare class PbmVmOperation implements IPseudoEnum {
+	static readonly RECONFIGURE: PbmVmOperation & EnumVal<'RECONFIGURE'>;
+	static readonly CREATE: PbmVmOperation & EnumVal<'CREATE'>;
+	static readonly MIGRATE: PbmVmOperation & EnumVal<'MIGRATE'>;
+	static readonly CLONE: PbmVmOperation & EnumVal<'CLONE'>;
+	static fromString(value: string): PbmVmOperation & EnumVal<TcleanKeys<typeof PbmVmOperation>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly CLONE: PbmVmOperation;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: PbmVmOperation): PbmVmOperation;
+	toString: () => string;
 }
 
 /**
  * Describes the reservation state of a license.
  */
-declare class VcLicenseReservationInfoState {
-	readonly notUsed: VcLicenseReservationInfoState;
-	readonly noLicense: VcLicenseReservationInfoState;
-	readonly unlicensedUse: VcLicenseReservationInfoState;
-	readonly licensed: VcLicenseReservationInfoState;
-	readonly name: string;
+declare class VcLicenseReservationInfoState implements IPseudoEnum {
+	static readonly notUsed: VcLicenseReservationInfoState & EnumVal<'notUsed'>;
+	static readonly noLicense: VcLicenseReservationInfoState & EnumVal<'noLicense'>;
+	static readonly unlicensedUse: VcLicenseReservationInfoState & EnumVal<'unlicensedUse'>;
+	static readonly licensed: VcLicenseReservationInfoState & EnumVal<'licensed'>;
+	static fromString(value: string): VcLicenseReservationInfoState & EnumVal<TcleanKeys<typeof VcLicenseReservationInfoState>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcLicenseReservationInfoState): VcLicenseReservationInfoState;
+	toString: () => string;
 }
 
 /**
@@ -6483,210 +6156,198 @@ declare class VcLicenseReservationInfoState {
  * 
  * Defaults to preferred on first configuration if unspecified.
  */
-declare class VcHostInternetScsiHbaChapAuthenticationType {
-	readonly chapRequired: VcHostInternetScsiHbaChapAuthenticationType;
-	readonly name: string;
-	readonly chapDiscouraged: VcHostInternetScsiHbaChapAuthenticationType;
-	readonly chapProhibited: VcHostInternetScsiHbaChapAuthenticationType;
+declare class VcHostInternetScsiHbaChapAuthenticationType implements IPseudoEnum {
+	static readonly chapRequired: VcHostInternetScsiHbaChapAuthenticationType & EnumVal<'chapRequired'>;
+	static readonly chapDiscouraged: VcHostInternetScsiHbaChapAuthenticationType & EnumVal<'chapDiscouraged'>;
+	static readonly chapProhibited: VcHostInternetScsiHbaChapAuthenticationType & EnumVal<'chapProhibited'>;
+	static readonly chapPreferred: VcHostInternetScsiHbaChapAuthenticationType & EnumVal<'chapPreferred'>;
+	static fromString(value: string): VcHostInternetScsiHbaChapAuthenticationType & EnumVal<TcleanKeys<typeof VcHostInternetScsiHbaChapAuthenticationType>>;
+
 	readonly id: string;
-	readonly chapPreferred: VcHostInternetScsiHbaChapAuthenticationType;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostInternetScsiHbaChapAuthenticationType): VcHostInternetScsiHbaChapAuthenticationType;
+	toString: () => string;
 }
 
-declare class VcWeekOfMonth {
-	readonly third: VcWeekOfMonth;
-	readonly last: VcWeekOfMonth;
-	readonly name: string;
-	readonly fourth: VcWeekOfMonth;
+declare class VcWeekOfMonth implements IPseudoEnum {
+	static readonly third: VcWeekOfMonth & EnumVal<'third'>;
+	static readonly last: VcWeekOfMonth & EnumVal<'last'>;
+	static readonly fourth: VcWeekOfMonth & EnumVal<'fourth'>;
+	static readonly first: VcWeekOfMonth & EnumVal<'first'>;
+	static readonly second: VcWeekOfMonth & EnumVal<'second'>;
+	static fromString(value: string): VcWeekOfMonth & EnumVal<TcleanKeys<typeof VcWeekOfMonth>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly first: VcWeekOfMonth;
-	readonly second: VcWeekOfMonth;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcWeekOfMonth): VcWeekOfMonth;
+	toString: () => string;
 }
 
 /**
  * This enum defines the possible types of file types that can be reserved
  * or deleted
  */
-declare class VcHostLowLevelProvisioningManagerFileType {
-	readonly name: string;
+declare class VcHostLowLevelProvisioningManagerFileType implements IPseudoEnum {
+	static readonly File: VcHostLowLevelProvisioningManagerFileType & EnumVal<'File'>;
+	static readonly VirtualDisk: VcHostLowLevelProvisioningManagerFileType & EnumVal<'VirtualDisk'>;
+	static readonly Directory: VcHostLowLevelProvisioningManagerFileType & EnumVal<'Directory'>;
+	static fromString(value: string): VcHostLowLevelProvisioningManagerFileType & EnumVal<TcleanKeys<typeof VcHostLowLevelProvisioningManagerFileType>>;
+
 	readonly id: string;
-	readonly File: VcHostLowLevelProvisioningManagerFileType;
+	readonly name: string;
 	readonly value: string;
-	readonly VirtualDisk: VcHostLowLevelProvisioningManagerFileType;
-	readonly Directory: VcHostLowLevelProvisioningManagerFileType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostLowLevelProvisioningManagerFileType): VcHostLowLevelProvisioningManagerFileType;
+	toString: () => string;
 }
 
 /**
  * List of supported modes by HttpNfcLease
  */
-declare class VcHttpNfcLeaseMode {
-	readonly pull: VcHttpNfcLeaseMode;
-	readonly pushOrGet: VcHttpNfcLeaseMode;
-	readonly name: string;
+declare class VcHttpNfcLeaseMode implements IPseudoEnum {
+	static readonly pull: VcHttpNfcLeaseMode & EnumVal<'pull'>;
+	static readonly pushOrGet: VcHttpNfcLeaseMode & EnumVal<'pushOrGet'>;
+	static fromString(value: string): VcHttpNfcLeaseMode & EnumVal<TcleanKeys<typeof VcHttpNfcLeaseMode>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHttpNfcLeaseMode): VcHttpNfcLeaseMode;
+	toString: () => string;
 }
 
 /**
  * The Status enumeration defines a general "health" value for a managed entity.
  */
-declare class VcManagedEntityStatus {
-	static red: VcManagedEntityStatus;
-	static gray: VcManagedEntityStatus;
-	static green: VcManagedEntityStatus;
-	static yellow: VcManagedEntityStatus;
-	static name: string;
-	static id: string;
-	static value: string;
+declare class VcManagedEntityStatus implements IPseudoEnum {
+	static readonly red: VcManagedEntityStatus & EnumVal<'red'>;
+	static readonly gray: VcManagedEntityStatus & EnumVal<'gray'>;
+	static readonly green: VcManagedEntityStatus & EnumVal<'green'>;
+	static readonly yellow: VcManagedEntityStatus & EnumVal<'yellow'>;
+	static fromString(value: string): VcManagedEntityStatus & EnumVal<TcleanKeys<typeof VcManagedEntityStatus>>;
+
+	readonly id: string;
+	readonly name: string;
+	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	static fromString(value: VcManagedEntityStatus): VcManagedEntityStatus;
+	toString: () => string;
 }
 
-declare class VcAutoStartAction {
-	readonly systemDefault: VcAutoStartAction;
-	readonly suspend: VcAutoStartAction;
-	readonly powerOn: VcAutoStartAction;
-	readonly powerOff: VcAutoStartAction;
-	readonly name: string;
-	readonly none: VcAutoStartAction;
-	readonly guestShutdown: VcAutoStartAction;
+declare class VcAutoStartAction implements IPseudoEnum {
+	static readonly systemDefault: VcAutoStartAction & EnumVal<'systemDefault'>;
+	static readonly suspend: VcAutoStartAction & EnumVal<'suspend'>;
+	static readonly powerOn: VcAutoStartAction & EnumVal<'powerOn'>;
+	static readonly powerOff: VcAutoStartAction & EnumVal<'powerOff'>;
+	static readonly none: VcAutoStartAction & EnumVal<'none'>;
+	static readonly guestShutdown: VcAutoStartAction & EnumVal<'guestShutdown'>;
+	static fromString(value: string): VcAutoStartAction & EnumVal<TcleanKeys<typeof VcAutoStartAction>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcAutoStartAction): VcAutoStartAction;
+	toString: () => string;
 }
 
-declare class VcHostHasComponentFailureHostComponentType {
-	readonly Datastore: VcHostHasComponentFailureHostComponentType;
-	readonly name: string;
+declare class VcHostHasComponentFailureHostComponentType implements IPseudoEnum {
+	static readonly Datastore: VcHostHasComponentFailureHostComponentType & EnumVal<'Datastore'>;
+	static fromString(value: string): VcHostHasComponentFailureHostComponentType & EnumVal<TcleanKeys<typeof VcHostHasComponentFailureHostComponentType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostHasComponentFailureHostComponentType): VcHostHasComponentFailureHostComponentType;
+	toString: () => string;
 }
 
 /**
  * Identifiers of currently supported resources.
  */
-declare class VcHostLicensableResourceKey {
-	readonly memorySize: VcHostLicensableResourceKey;
-	readonly numVmsStarting: VcHostLicensableResourceKey;
-	readonly name: string;
+declare class VcHostLicensableResourceKey implements IPseudoEnum {
+	static readonly memorySize: VcHostLicensableResourceKey & EnumVal<'memorySize'>;
+	static readonly numVmsStarting: VcHostLicensableResourceKey & EnumVal<'numVmsStarting'>;
+	static readonly numVmsStarted: VcHostLicensableResourceKey & EnumVal<'numVmsStarted'>;
+	static readonly numCpuCores: VcHostLicensableResourceKey & EnumVal<'numCpuCores'>;
+	static readonly numCpuPackages: VcHostLicensableResourceKey & EnumVal<'numCpuPackages'>;
+	static readonly memoryForVms: VcHostLicensableResourceKey & EnumVal<'memoryForVms'>;
+	static fromString(value: string): VcHostLicensableResourceKey & EnumVal<TcleanKeys<typeof VcHostLicensableResourceKey>>;
+
 	readonly id: string;
-	readonly numVmsStarted: VcHostLicensableResourceKey;
+	readonly name: string;
 	readonly value: string;
-	readonly numCpuCores: VcHostLicensableResourceKey;
-	readonly numCpuPackages: VcHostLicensableResourceKey;
-	readonly memoryForVms: VcHostLicensableResourceKey;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostLicensableResourceKey): VcHostLicensableResourceKey;
+	toString: () => string;
 }
 
 /**
  * List of possible values for thin provisioning status alarm.
  */
-declare class ThinProvisioningStatus {
-	readonly RED: ThinProvisioningStatus;
-	readonly name: string;
-	readonly YELLOW: ThinProvisioningStatus;
+declare class ThinProvisioningStatus implements IPseudoEnum {
+	static readonly RED: ThinProvisioningStatus & EnumVal<'RED'>;
+	static readonly YELLOW: ThinProvisioningStatus & EnumVal<'YELLOW'>;
+	static readonly GREEN: ThinProvisioningStatus & EnumVal<'GREEN'>;
+	static fromString(value: string): ThinProvisioningStatus & EnumVal<TcleanKeys<typeof ThinProvisioningStatus>>;
+
 	readonly id: string;
-	readonly GREEN: ThinProvisioningStatus;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: ThinProvisioningStatus): ThinProvisioningStatus;
+	toString: () => string;
 }
 
 /**
  * The integrity validation status.
  */
-declare class VcHostPatchManagerIntegrityStatus {
-	readonly notEnoughSignatures: VcHostPatchManagerIntegrityStatus;
-	readonly validated: VcHostPatchManagerIntegrityStatus;
-	readonly keyRevoked: VcHostPatchManagerIntegrityStatus;
-	readonly keyNotFound: VcHostPatchManagerIntegrityStatus;
-	readonly name: string;
-	readonly keyExpired: VcHostPatchManagerIntegrityStatus;
-	readonly digestMismatch: VcHostPatchManagerIntegrityStatus;
+declare class VcHostPatchManagerIntegrityStatus implements IPseudoEnum {
+	static readonly notEnoughSignatures: VcHostPatchManagerIntegrityStatus & EnumVal<'notEnoughSignatures'>;
+	static readonly validated: VcHostPatchManagerIntegrityStatus & EnumVal<'validated'>;
+	static readonly keyRevoked: VcHostPatchManagerIntegrityStatus & EnumVal<'keyRevoked'>;
+	static readonly keyNotFound: VcHostPatchManagerIntegrityStatus & EnumVal<'keyNotFound'>;
+	static readonly keyExpired: VcHostPatchManagerIntegrityStatus & EnumVal<'keyExpired'>;
+	static readonly digestMismatch: VcHostPatchManagerIntegrityStatus & EnumVal<'digestMismatch'>;
+	static readonly validationError: VcHostPatchManagerIntegrityStatus & EnumVal<'validationError'>;
+	static fromString(value: string): VcHostPatchManagerIntegrityStatus & EnumVal<TcleanKeys<typeof VcHostPatchManagerIntegrityStatus>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly validationError: VcHostPatchManagerIntegrityStatus;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostPatchManagerIntegrityStatus): VcHostPatchManagerIntegrityStatus;
+	toString: () => string;
 }
 
 /**
  * The operational state of VASA Provider.
  */
-declare class VasaProviderStatus {
-	readonly connected: VasaProviderStatus;
-	readonly offline: VasaProviderStatus;
-	readonly disconnected: VasaProviderStatus;
-	readonly syncError: VasaProviderStatus;
-	readonly name: string;
-	readonly online: VasaProviderStatus;
+declare class VasaProviderStatus implements IPseudoEnum {
+	static readonly connected: VasaProviderStatus & EnumVal<'connected'>;
+	static readonly offline: VasaProviderStatus & EnumVal<'offline'>;
+	static readonly disconnected: VasaProviderStatus & EnumVal<'disconnected'>;
+	static readonly syncError: VasaProviderStatus & EnumVal<'syncError'>;
+	static readonly online: VasaProviderStatus & EnumVal<'online'>;
+	static readonly unknown: VasaProviderStatus & EnumVal<'unknown'>;
+	static fromString(value: string): VasaProviderStatus & EnumVal<TcleanKeys<typeof VasaProviderStatus>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly unknown: VasaProviderStatus;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VasaProviderStatus): VasaProviderStatus;
+	toString: () => string;
 }
 
 /**
  * Used to determine which power policy profile is active.
  */
-declare class VcVirtualMachinePowerPolicyPowerMode {
-	readonly acPower: VcVirtualMachinePowerPolicyPowerMode;
-	readonly name: string;
+declare class VcVirtualMachinePowerPolicyPowerMode implements IPseudoEnum {
+	static readonly acPower: VcVirtualMachinePowerPolicyPowerMode & EnumVal<'acPower'>;
+	static readonly batteryPower: VcVirtualMachinePowerPolicyPowerMode & EnumVal<'batteryPower'>;
+	static fromString(value: string): VcVirtualMachinePowerPolicyPowerMode & EnumVal<TcleanKeys<typeof VcVirtualMachinePowerPolicyPowerMode>>;
+
 	readonly id: string;
-	readonly batteryPower: VcVirtualMachinePowerPolicyPowerMode;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachinePowerPolicyPowerMode): VcVirtualMachinePowerPolicyPowerMode;
+	toString: () => string;
 }
 
 /**
@@ -6694,50 +6355,47 @@ declare class VcVirtualMachinePowerPolicyPowerMode {
  * Switch. The different policy modes define the way traffic is routed
  * through the different uplink ports in a team.
  */
-declare class VcDistributedVirtualSwitchNicTeamingPolicyMode {
-	readonly loadbalance_loadbased: VcDistributedVirtualSwitchNicTeamingPolicyMode;
-	readonly loadbalance_ip: VcDistributedVirtualSwitchNicTeamingPolicyMode;
-	readonly loadbalance_srcmac: VcDistributedVirtualSwitchNicTeamingPolicyMode;
-	readonly name: string;
-	readonly loadbalance_srcid: VcDistributedVirtualSwitchNicTeamingPolicyMode;
+declare class VcDistributedVirtualSwitchNicTeamingPolicyMode implements IPseudoEnum {
+	static readonly loadbalance_loadbased: VcDistributedVirtualSwitchNicTeamingPolicyMode & EnumVal<'loadbalance_loadbased'>;
+	static readonly loadbalance_ip: VcDistributedVirtualSwitchNicTeamingPolicyMode & EnumVal<'loadbalance_ip'>;
+	static readonly loadbalance_srcmac: VcDistributedVirtualSwitchNicTeamingPolicyMode & EnumVal<'loadbalance_srcmac'>;
+	static readonly loadbalance_srcid: VcDistributedVirtualSwitchNicTeamingPolicyMode & EnumVal<'loadbalance_srcid'>;
+	static readonly failover_explicit: VcDistributedVirtualSwitchNicTeamingPolicyMode & EnumVal<'failover_explicit'>;
+	static fromString(value: string): VcDistributedVirtualSwitchNicTeamingPolicyMode & EnumVal<TcleanKeys<typeof VcDistributedVirtualSwitchNicTeamingPolicyMode>>;
+
 	readonly id: string;
-	readonly failover_explicit: VcDistributedVirtualSwitchNicTeamingPolicyMode;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcDistributedVirtualSwitchNicTeamingPolicyMode): VcDistributedVirtualSwitchNicTeamingPolicyMode;
+	toString: () => string;
 }
 
-declare class VcHostSystemIdentificationInfoIdentifier {
-	readonly AssetTag: VcHostSystemIdentificationInfoIdentifier;
-	readonly OemSpecificString: VcHostSystemIdentificationInfoIdentifier;
-	readonly ServiceTag: VcHostSystemIdentificationInfoIdentifier;
-	readonly name: string;
+declare class VcHostSystemIdentificationInfoIdentifier implements IPseudoEnum {
+	static readonly AssetTag: VcHostSystemIdentificationInfoIdentifier & EnumVal<'AssetTag'>;
+	static readonly OemSpecificString: VcHostSystemIdentificationInfoIdentifier & EnumVal<'OemSpecificString'>;
+	static readonly ServiceTag: VcHostSystemIdentificationInfoIdentifier & EnumVal<'ServiceTag'>;
+	static fromString(value: string): VcHostSystemIdentificationInfoIdentifier & EnumVal<TcleanKeys<typeof VcHostSystemIdentificationInfoIdentifier>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostSystemIdentificationInfoIdentifier): VcHostSystemIdentificationInfoIdentifier;
+	toString: () => string;
 }
 
 /**
  * The {@link ResourceTypeEnum} enumerated type defines the set of resource
  * types that are supported for profile management. See {@link pbm.profile.ResourceType}.
  */
-declare class PbmProfileResourceTypeEnum {
-	readonly STORAGE: PbmProfileResourceTypeEnum;
-	readonly name: string;
+declare class PbmProfileResourceTypeEnum implements IPseudoEnum {
+	static readonly STORAGE: PbmProfileResourceTypeEnum & EnumVal<'STORAGE'>;
+	static fromString(value: string): PbmProfileResourceTypeEnum & EnumVal<TcleanKeys<typeof PbmProfileResourceTypeEnum>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: PbmProfileResourceTypeEnum): PbmProfileResourceTypeEnum;
+	toString: () => string;
 }
 
 /**
@@ -6758,289 +6416,273 @@ declare class PbmProfileResourceTypeEnum {
  * <code>{@link VirtualSerialPortOption.PipeBackingOption#endpoint}</code>
  * property for the virtual serial port pipe backing option data object.
  */
-declare class VcVirtualSerialPortEndPoint {
-	readonly server: VcVirtualSerialPortEndPoint;
-	readonly name: string;
-	readonly client: VcVirtualSerialPortEndPoint;
+declare class VcVirtualSerialPortEndPoint implements IPseudoEnum {
+	static readonly server: VcVirtualSerialPortEndPoint & EnumVal<'server'>;
+	static readonly client: VcVirtualSerialPortEndPoint & EnumVal<'client'>;
+	static fromString(value: string): VcVirtualSerialPortEndPoint & EnumVal<TcleanKeys<typeof VcVirtualSerialPortEndPoint>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualSerialPortEndPoint): VcVirtualSerialPortEndPoint;
+	toString: () => string;
 }
 
 /**
  * Reasons why an update is not applicable to the ESX host.
  */
-declare class VcHostPatchManagerReason {
-	readonly conflictPatch: VcHostPatchManagerReason;
-	readonly hasDependentPatch: VcHostPatchManagerReason;
-	readonly name: string;
-	readonly missingLib: VcHostPatchManagerReason;
+declare class VcHostPatchManagerReason implements IPseudoEnum {
+	static readonly conflictPatch: VcHostPatchManagerReason & EnumVal<'conflictPatch'>;
+	static readonly hasDependentPatch: VcHostPatchManagerReason & EnumVal<'hasDependentPatch'>;
+	static readonly missingLib: VcHostPatchManagerReason & EnumVal<'missingLib'>;
+	static readonly obsoleted: VcHostPatchManagerReason & EnumVal<'obsoleted'>;
+	static readonly conflictLib: VcHostPatchManagerReason & EnumVal<'conflictLib'>;
+	static readonly missingPatch: VcHostPatchManagerReason & EnumVal<'missingPatch'>;
+	static fromString(value: string): VcHostPatchManagerReason & EnumVal<TcleanKeys<typeof VcHostPatchManagerReason>>;
+
 	readonly id: string;
-	readonly obsoleted: VcHostPatchManagerReason;
-	readonly conflictLib: VcHostPatchManagerReason;
+	readonly name: string;
 	readonly value: string;
-	readonly missingPatch: VcHostPatchManagerReason;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostPatchManagerReason): VcHostPatchManagerReason;
+	toString: () => string;
 }
 
 /**
  * The composition status class.
  */
-declare class VcHostProfileManagerCompositionResultResultElementStatus {
-	readonly success: VcHostProfileManagerCompositionResultResultElementStatus;
-	readonly name: string;
+declare class VcHostProfileManagerCompositionResultResultElementStatus implements IPseudoEnum {
+	static readonly success: VcHostProfileManagerCompositionResultResultElementStatus & EnumVal<'success'>;
+	static readonly error: VcHostProfileManagerCompositionResultResultElementStatus & EnumVal<'error'>;
+	static fromString(value: string): VcHostProfileManagerCompositionResultResultElementStatus & EnumVal<TcleanKeys<typeof VcHostProfileManagerCompositionResultResultElementStatus>>;
+
 	readonly id: string;
-	readonly error: VcHostProfileManagerCompositionResultResultElementStatus;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostProfileManagerCompositionResultResultElementStatus): VcHostProfileManagerCompositionResultResultElementStatus;
+	toString: () => string;
 }
 
 /**
  * Type of namespace.
  */
-declare class VcNvdimmNamespaceType {
-	readonly blockNamespace: VcNvdimmNamespaceType;
-	readonly name: string;
+declare class VcNvdimmNamespaceType implements IPseudoEnum {
+	static readonly blockNamespace: VcNvdimmNamespaceType & EnumVal<'blockNamespace'>;
+	static readonly persistentNamespace: VcNvdimmNamespaceType & EnumVal<'persistentNamespace'>;
+	static fromString(value: string): VcNvdimmNamespaceType & EnumVal<TcleanKeys<typeof VcNvdimmNamespaceType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly persistentNamespace: VcNvdimmNamespaceType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcNvdimmNamespaceType): VcNvdimmNamespaceType;
+	toString: () => string;
 }
 
 /**
  * VchaClusterState enum defines the possible states for a VCHA Cluster.
  */
-declare class VcVchaClusterState {
-	readonly healthy: VcVchaClusterState;
-	readonly isolated: VcVchaClusterState;
-	readonly name: string;
+declare class VcVchaClusterState implements IPseudoEnum {
+	static readonly healthy: VcVchaClusterState & EnumVal<'healthy'>;
+	static readonly isolated: VcVchaClusterState & EnumVal<'isolated'>;
+	static readonly degraded: VcVchaClusterState & EnumVal<'degraded'>;
+	static fromString(value: string): VcVchaClusterState & EnumVal<TcleanKeys<typeof VcVchaClusterState>>;
+
 	readonly id: string;
-	readonly degraded: VcVchaClusterState;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVchaClusterState): VcVchaClusterState;
+	toString: () => string;
 }
 
-declare class VcVirtualMachineBootOptionsNetworkBootProtocolType {
-	readonly ipv4: VcVirtualMachineBootOptionsNetworkBootProtocolType;
-	readonly ipv6: VcVirtualMachineBootOptionsNetworkBootProtocolType;
-	readonly name: string;
+declare class VcVirtualMachineBootOptionsNetworkBootProtocolType implements IPseudoEnum {
+	static readonly ipv4: VcVirtualMachineBootOptionsNetworkBootProtocolType & EnumVal<'ipv4'>;
+	static readonly ipv6: VcVirtualMachineBootOptionsNetworkBootProtocolType & EnumVal<'ipv6'>;
+	static fromString(value: string): VcVirtualMachineBootOptionsNetworkBootProtocolType & EnumVal<TcleanKeys<typeof VcVirtualMachineBootOptionsNetworkBootProtocolType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineBootOptionsNetworkBootProtocolType): VcVirtualMachineBootOptionsNetworkBootProtocolType;
+	toString: () => string;
 }
 
 /**
  * Licensed features have unique keys to identify them.
  */
-declare class VcLicenseManagerLicenseKey {
-	readonly san: VcLicenseManagerLicenseKey;
-	readonly nas: VcLicenseManagerLicenseKey;
-	readonly backup: VcLicenseManagerLicenseKey;
-	readonly esxHost: VcLicenseManagerLicenseKey;
-	readonly drs: VcLicenseManagerLicenseKey;
-	readonly gsxHost: VcLicenseManagerLicenseKey;
-	readonly esxVmtn: VcLicenseManagerLicenseKey;
-	readonly vc: VcLicenseManagerLicenseKey;
-	readonly serverHost: VcLicenseManagerLicenseKey;
-	readonly esxExpress: VcLicenseManagerLicenseKey;
-	readonly vcExpress: VcLicenseManagerLicenseKey;
-	readonly iscsi: VcLicenseManagerLicenseKey;
-	readonly drsPower: VcLicenseManagerLicenseKey;
-	readonly esxFull: VcLicenseManagerLicenseKey;
-	readonly vsmp: VcLicenseManagerLicenseKey;
-	readonly das: VcLicenseManagerLicenseKey;
-	readonly name: string;
+declare class VcLicenseManagerLicenseKey implements IPseudoEnum {
+	static readonly san: VcLicenseManagerLicenseKey & EnumVal<'san'>;
+	static readonly nas: VcLicenseManagerLicenseKey & EnumVal<'nas'>;
+	static readonly backup: VcLicenseManagerLicenseKey & EnumVal<'backup'>;
+	static readonly esxHost: VcLicenseManagerLicenseKey & EnumVal<'esxHost'>;
+	static readonly drs: VcLicenseManagerLicenseKey & EnumVal<'drs'>;
+	static readonly gsxHost: VcLicenseManagerLicenseKey & EnumVal<'gsxHost'>;
+	static readonly esxVmtn: VcLicenseManagerLicenseKey & EnumVal<'esxVmtn'>;
+	static readonly vc: VcLicenseManagerLicenseKey & EnumVal<'vc'>;
+	static readonly serverHost: VcLicenseManagerLicenseKey & EnumVal<'serverHost'>;
+	static readonly esxExpress: VcLicenseManagerLicenseKey & EnumVal<'esxExpress'>;
+	static readonly vcExpress: VcLicenseManagerLicenseKey & EnumVal<'vcExpress'>;
+	static readonly iscsi: VcLicenseManagerLicenseKey & EnumVal<'iscsi'>;
+	static readonly drsPower: VcLicenseManagerLicenseKey & EnumVal<'drsPower'>;
+	static readonly esxFull: VcLicenseManagerLicenseKey & EnumVal<'esxFull'>;
+	static readonly vsmp: VcLicenseManagerLicenseKey & EnumVal<'vsmp'>;
+	static readonly das: VcLicenseManagerLicenseKey & EnumVal<'das'>;
+	static readonly vmotion: VcLicenseManagerLicenseKey & EnumVal<'vmotion'>;
+	static fromString(value: string): VcLicenseManagerLicenseKey & EnumVal<TcleanKeys<typeof VcLicenseManagerLicenseKey>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly vmotion: VcLicenseManagerLicenseKey;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcLicenseManagerLicenseKey): VcLicenseManagerLicenseKey;
+	toString: () => string;
 }
 
 /**
  * Device speed.
  */
-declare class VcVirtualMachineUsbInfoSpeed {
-	readonly superSpeed: VcVirtualMachineUsbInfoSpeed;
-	readonly high: VcVirtualMachineUsbInfoSpeed;
-	readonly low: VcVirtualMachineUsbInfoSpeed;
-	readonly name: string;
+declare class VcVirtualMachineUsbInfoSpeed implements IPseudoEnum {
+	static readonly superSpeed: VcVirtualMachineUsbInfoSpeed & EnumVal<'superSpeed'>;
+	static readonly high: VcVirtualMachineUsbInfoSpeed & EnumVal<'high'>;
+	static readonly low: VcVirtualMachineUsbInfoSpeed & EnumVal<'low'>;
+	static readonly full: VcVirtualMachineUsbInfoSpeed & EnumVal<'full'>;
+	static readonly unknownSpeed: VcVirtualMachineUsbInfoSpeed & EnumVal<'unknownSpeed'>;
+	static fromString(value: string): VcVirtualMachineUsbInfoSpeed & EnumVal<TcleanKeys<typeof VcVirtualMachineUsbInfoSpeed>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly full: VcVirtualMachineUsbInfoSpeed;
-	readonly unknownSpeed: VcVirtualMachineUsbInfoSpeed;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineUsbInfoSpeed): VcVirtualMachineUsbInfoSpeed;
+	toString: () => string;
 }
 
 /**
  * Application state type.
  */
-declare class VcGuestInfoAppStateType {
-	readonly appStateOk: VcGuestInfoAppStateType;
-	readonly appStateNeedReset: VcGuestInfoAppStateType;
-	readonly name: string;
-	readonly none: VcGuestInfoAppStateType;
+declare class VcGuestInfoAppStateType implements IPseudoEnum {
+	static readonly appStateOk: VcGuestInfoAppStateType & EnumVal<'appStateOk'>;
+	static readonly appStateNeedReset: VcGuestInfoAppStateType & EnumVal<'appStateNeedReset'>;
+	static readonly none: VcGuestInfoAppStateType & EnumVal<'none'>;
+	static fromString(value: string): VcGuestInfoAppStateType & EnumVal<TcleanKeys<typeof VcGuestInfoAppStateType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcGuestInfoAppStateType): VcGuestInfoAppStateType;
+	toString: () => string;
 }
 
 /**
  * The enumeration of all known valid MAC address types.
  */
-declare class VcVirtualEthernetCardMacType {
-	readonly generated: VcVirtualEthernetCardMacType;
-	readonly name: string;
-	readonly assigned: VcVirtualEthernetCardMacType;
+declare class VcVirtualEthernetCardMacType implements IPseudoEnum {
+	static readonly generated: VcVirtualEthernetCardMacType & EnumVal<'generated'>;
+	static readonly assigned: VcVirtualEthernetCardMacType & EnumVal<'assigned'>;
+	static readonly manual: VcVirtualEthernetCardMacType & EnumVal<'manual'>;
+	static fromString(value: string): VcVirtualEthernetCardMacType & EnumVal<TcleanKeys<typeof VcVirtualEthernetCardMacType>>;
+
 	readonly id: string;
-	readonly manual: VcVirtualEthernetCardMacType;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualEthernetCardMacType): VcVirtualEthernetCardMacType;
+	toString: () => string;
 }
 
-declare class VcPhysicalNicResourcePoolSchedulerDisallowedReason {
-	readonly name: string;
-	readonly hardwareUnsupported: VcPhysicalNicResourcePoolSchedulerDisallowedReason;
+declare class VcPhysicalNicResourcePoolSchedulerDisallowedReason implements IPseudoEnum {
+	static readonly hardwareUnsupported: VcPhysicalNicResourcePoolSchedulerDisallowedReason & EnumVal<'hardwareUnsupported'>;
+	static readonly userOptOut: VcPhysicalNicResourcePoolSchedulerDisallowedReason & EnumVal<'userOptOut'>;
+	static fromString(value: string): VcPhysicalNicResourcePoolSchedulerDisallowedReason & EnumVal<TcleanKeys<typeof VcPhysicalNicResourcePoolSchedulerDisallowedReason>>;
+
 	readonly id: string;
-	readonly userOptOut: VcPhysicalNicResourcePoolSchedulerDisallowedReason;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcPhysicalNicResourcePoolSchedulerDisallowedReason): VcPhysicalNicResourcePoolSchedulerDisallowedReason;
+	toString: () => string;
 }
 
 /**
  * List of IS provider types
  */
-declare class PbmAtomFeedQsProviderTye {
-	readonly CAPABILITY_PROFILE: PbmAtomFeedQsProviderTye;
-	readonly name: string;
+declare class PbmAtomFeedQsProviderTye implements IPseudoEnum {
+	static readonly CAPABILITY_PROFILE: PbmAtomFeedQsProviderTye & EnumVal<'CAPABILITY_PROFILE'>;
+	static readonly COMPLIANCE: PbmAtomFeedQsProviderTye & EnumVal<'COMPLIANCE'>;
+	static readonly CAPABILITY_METADATA: PbmAtomFeedQsProviderTye & EnumVal<'CAPABILITY_METADATA'>;
+	static readonly ASSOCIATION: PbmAtomFeedQsProviderTye & EnumVal<'ASSOCIATION'>;
+	static readonly REQUIREMENTS_PROFILE: PbmAtomFeedQsProviderTye & EnumVal<'REQUIREMENTS_PROFILE'>;
+	static fromString(value: string): PbmAtomFeedQsProviderTye & EnumVal<TcleanKeys<typeof PbmAtomFeedQsProviderTye>>;
+
 	readonly id: string;
-	readonly COMPLIANCE: PbmAtomFeedQsProviderTye;
-	readonly CAPABILITY_METADATA: PbmAtomFeedQsProviderTye;
-	readonly ASSOCIATION: PbmAtomFeedQsProviderTye;
+	readonly name: string;
 	readonly value: string;
-	readonly REQUIREMENTS_PROFILE: PbmAtomFeedQsProviderTye;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: PbmAtomFeedQsProviderTye): PbmAtomFeedQsProviderTye;
+	toString: () => string;
 }
 
 /**
  * System pre-created profile types.
  */
-declare class PbmSystemCreatedProfileType {
-	readonly PmemDefaultProfile: PbmSystemCreatedProfileType;
-	readonly VsanDefaultProfile: PbmSystemCreatedProfileType;
-	readonly name: string;
-	readonly VVolDefaultProfile: PbmSystemCreatedProfileType;
+declare class PbmSystemCreatedProfileType implements IPseudoEnum {
+	static readonly PmemDefaultProfile: PbmSystemCreatedProfileType & EnumVal<'PmemDefaultProfile'>;
+	static readonly VsanDefaultProfile: PbmSystemCreatedProfileType & EnumVal<'VsanDefaultProfile'>;
+	static readonly VVolDefaultProfile: PbmSystemCreatedProfileType & EnumVal<'VVolDefaultProfile'>;
+	static fromString(value: string): PbmSystemCreatedProfileType & EnumVal<TcleanKeys<typeof PbmSystemCreatedProfileType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: PbmSystemCreatedProfileType): PbmSystemCreatedProfileType;
+	toString: () => string;
 }
 
 /**
  * Condition for VM's readiness
  */
-declare class VcClusterVmReadinessReadyCondition {
-	readonly poweredOn: VcClusterVmReadinessReadyCondition;
-	readonly appHbStatusGreen: VcClusterVmReadinessReadyCondition;
-	readonly name: string;
-	readonly none: VcClusterVmReadinessReadyCondition;
-	readonly guestHbStatusGreen: VcClusterVmReadinessReadyCondition;
+declare class VcClusterVmReadinessReadyCondition implements IPseudoEnum {
+	static readonly poweredOn: VcClusterVmReadinessReadyCondition & EnumVal<'poweredOn'>;
+	static readonly appHbStatusGreen: VcClusterVmReadinessReadyCondition & EnumVal<'appHbStatusGreen'>;
+	static readonly none: VcClusterVmReadinessReadyCondition & EnumVal<'none'>;
+	static readonly guestHbStatusGreen: VcClusterVmReadinessReadyCondition & EnumVal<'guestHbStatusGreen'>;
+	static readonly useClusterDefault: VcClusterVmReadinessReadyCondition & EnumVal<'useClusterDefault'>;
+	static fromString(value: string): VcClusterVmReadinessReadyCondition & EnumVal<TcleanKeys<typeof VcClusterVmReadinessReadyCondition>>;
+
 	readonly id: string;
-	readonly useClusterDefault: VcClusterVmReadinessReadyCondition;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcClusterVmReadinessReadyCondition): VcClusterVmReadinessReadyCondition;
+	toString: () => string;
 }
 
 /**
  * This specifies how the ipv6 address is configured for the interface.
  * We follow rfc4293 in defining the values for the configType.
  */
-declare class VcHostIpConfigIpV6AddressConfigType {
-	readonly random: VcHostIpConfigIpV6AddressConfigType;
-	readonly other: VcHostIpConfigIpV6AddressConfigType;
-	readonly name: string;
-	readonly linklayer: VcHostIpConfigIpV6AddressConfigType;
+declare class VcHostIpConfigIpV6AddressConfigType implements IPseudoEnum {
+	static readonly random: VcHostIpConfigIpV6AddressConfigType & EnumVal<'random'>;
+	static readonly other: VcHostIpConfigIpV6AddressConfigType & EnumVal<'other'>;
+	static readonly linklayer: VcHostIpConfigIpV6AddressConfigType & EnumVal<'linklayer'>;
+	static readonly manual: VcHostIpConfigIpV6AddressConfigType & EnumVal<'manual'>;
+	static readonly dhcp: VcHostIpConfigIpV6AddressConfigType & EnumVal<'dhcp'>;
+	static fromString(value: string): VcHostIpConfigIpV6AddressConfigType & EnumVal<TcleanKeys<typeof VcHostIpConfigIpV6AddressConfigType>>;
+
 	readonly id: string;
-	readonly manual: VcHostIpConfigIpV6AddressConfigType;
+	readonly name: string;
 	readonly value: string;
-	readonly dhcp: VcHostIpConfigIpV6AddressConfigType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostIpConfigIpV6AddressConfigType): VcHostIpConfigIpV6AddressConfigType;
+	toString: () => string;
 }
 
 /**
  * The type of component connected to a port group.
  */
-declare class VcPortGroupConnecteeType {
-	readonly virtualMachine: VcPortGroupConnecteeType;
-	readonly host: VcPortGroupConnecteeType;
-	readonly name: string;
-	readonly systemManagement: VcPortGroupConnecteeType;
+declare class VcPortGroupConnecteeType implements IPseudoEnum {
+	static readonly virtualMachine: VcPortGroupConnecteeType & EnumVal<'virtualMachine'>;
+	static readonly host: VcPortGroupConnecteeType & EnumVal<'host'>;
+	static readonly systemManagement: VcPortGroupConnecteeType & EnumVal<'systemManagement'>;
+	static readonly unknown: VcPortGroupConnecteeType & EnumVal<'unknown'>;
+	static fromString(value: string): VcPortGroupConnecteeType & EnumVal<TcleanKeys<typeof VcPortGroupConnecteeType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly unknown: VcPortGroupConnecteeType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcPortGroupConnecteeType): VcPortGroupConnecteeType;
+	toString: () => string;
 }
 
 /**
@@ -7050,34 +6692,32 @@ declare class VcPortGroupConnecteeType {
  * machines can write to the virtual disk. This sharing mode is allowed
  * only for eagerly zeroed thick virtual disks.
  */
-declare class VcVirtualDiskSharing {
-	readonly sharingMultiWriter: VcVirtualDiskSharing;
-	readonly name: string;
+declare class VcVirtualDiskSharing implements IPseudoEnum {
+	static readonly sharingMultiWriter: VcVirtualDiskSharing & EnumVal<'sharingMultiWriter'>;
+	static readonly sharingNone: VcVirtualDiskSharing & EnumVal<'sharingNone'>;
+	static fromString(value: string): VcVirtualDiskSharing & EnumVal<TcleanKeys<typeof VcVirtualDiskSharing>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly sharingNone: VcVirtualDiskSharing;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualDiskSharing): VcVirtualDiskSharing;
+	toString: () => string;
 }
 
 /**
  * Alarm entity type
  */
-declare class VcAlarmFilterSpecAlarmTypeByEntity {
-	readonly entityTypeAll: VcAlarmFilterSpecAlarmTypeByEntity;
-	readonly entityTypeVm: VcAlarmFilterSpecAlarmTypeByEntity;
-	readonly name: string;
-	readonly entityTypeHost: VcAlarmFilterSpecAlarmTypeByEntity;
+declare class VcAlarmFilterSpecAlarmTypeByEntity implements IPseudoEnum {
+	static readonly entityTypeAll: VcAlarmFilterSpecAlarmTypeByEntity & EnumVal<'entityTypeAll'>;
+	static readonly entityTypeVm: VcAlarmFilterSpecAlarmTypeByEntity & EnumVal<'entityTypeVm'>;
+	static readonly entityTypeHost: VcAlarmFilterSpecAlarmTypeByEntity & EnumVal<'entityTypeHost'>;
+	static fromString(value: string): VcAlarmFilterSpecAlarmTypeByEntity & EnumVal<TcleanKeys<typeof VcAlarmFilterSpecAlarmTypeByEntity>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcAlarmFilterSpecAlarmTypeByEntity): VcAlarmFilterSpecAlarmTypeByEntity;
+	toString: () => string;
 }
 
 /**
@@ -7104,102 +6744,96 @@ declare class VcAlarmFilterSpecAlarmTypeByEntity {
  * Once (and if) the APD condition clears, PermanentDataLoss will be reported if
  * PDL condition still exists.
  */
-declare class VcHostMountInfoInaccessibleReason {
-	readonly PermanentDeviceLoss: VcHostMountInfoInaccessibleReason;
-	readonly AllPathsDown_Start: VcHostMountInfoInaccessibleReason;
-	readonly name: string;
+declare class VcHostMountInfoInaccessibleReason implements IPseudoEnum {
+	static readonly PermanentDeviceLoss: VcHostMountInfoInaccessibleReason & EnumVal<'PermanentDeviceLoss'>;
+	static readonly AllPathsDown_Start: VcHostMountInfoInaccessibleReason & EnumVal<'AllPathsDown_Start'>;
+	static readonly AllPathsDown_Timeout: VcHostMountInfoInaccessibleReason & EnumVal<'AllPathsDown_Timeout'>;
+	static fromString(value: string): VcHostMountInfoInaccessibleReason & EnumVal<TcleanKeys<typeof VcHostMountInfoInaccessibleReason>>;
+
 	readonly id: string;
-	readonly AllPathsDown_Timeout: VcHostMountInfoInaccessibleReason;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostMountInfoInaccessibleReason): VcHostMountInfoInaccessibleReason;
+	toString: () => string;
 }
 
-declare class VcHostActiveDirectoryAuthenticationCertificateDigest {
-	readonly SHA1: VcHostActiveDirectoryAuthenticationCertificateDigest;
-	readonly name: string;
+declare class VcHostActiveDirectoryAuthenticationCertificateDigest implements IPseudoEnum {
+	static readonly SHA1: VcHostActiveDirectoryAuthenticationCertificateDigest & EnumVal<'SHA1'>;
+	static fromString(value: string): VcHostActiveDirectoryAuthenticationCertificateDigest & EnumVal<TcleanKeys<typeof VcHostActiveDirectoryAuthenticationCertificateDigest>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostActiveDirectoryAuthenticationCertificateDigest): VcHostActiveDirectoryAuthenticationCertificateDigest;
+	toString: () => string;
 }
 
 /**
  * The operation on the target metric item.
  */
-declare class VcMetricAlarmOperator {
-	static readonly name: string;
-	static readonly isBelow: VcMetricAlarmOperator;
-	static readonly id: string;
-	static readonly value: string;
-	static readonly isAbove: VcMetricAlarmOperator;
+declare class VcMetricAlarmOperator implements IPseudoEnum {
+	static readonly isBelow: VcMetricAlarmOperator & EnumVal<'isBelow'>;
+	static readonly isAbove: VcMetricAlarmOperator & EnumVal<'isAbove'>;
+	static fromString(value: string): VcMetricAlarmOperator & EnumVal<TcleanKeys<typeof VcMetricAlarmOperator>>;
+
+	readonly id: string;
+	readonly name: string;
+	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	static fromString(value: VcMetricAlarmOperator): VcMetricAlarmOperator;
+	toString: () => string;
 }
 
-declare class VcHostOpaqueSwitchOpaqueSwitchState {
-	readonly name: string;
-	readonly warning: VcHostOpaqueSwitchOpaqueSwitchState;
-	readonly up: VcHostOpaqueSwitchOpaqueSwitchState;
+declare class VcHostOpaqueSwitchOpaqueSwitchState implements IPseudoEnum {
+	static readonly warning: VcHostOpaqueSwitchOpaqueSwitchState & EnumVal<'warning'>;
+	static readonly up: VcHostOpaqueSwitchOpaqueSwitchState & EnumVal<'up'>;
+	static readonly down: VcHostOpaqueSwitchOpaqueSwitchState & EnumVal<'down'>;
+	static fromString(value: string): VcHostOpaqueSwitchOpaqueSwitchState & EnumVal<TcleanKeys<typeof VcHostOpaqueSwitchOpaqueSwitchState>>;
+
 	readonly id: string;
-	readonly down: VcHostOpaqueSwitchOpaqueSwitchState;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostOpaqueSwitchOpaqueSwitchState): VcHostOpaqueSwitchOpaqueSwitchState;
+	toString: () => string;
 }
 
 /**
  * Set of possible values for
  * {@link vim.host.Capability#ftCompatibilityIssues}
  */
-declare class VcHostCapabilityFtUnsupportedReason {
-	readonly missingVMotionNic: VcHostCapabilityFtUnsupportedReason;
-	readonly cpuHwmmuUnsupported: VcHostCapabilityFtUnsupportedReason;
-	readonly name: string;
-	readonly missingFTLoggingNic: VcHostCapabilityFtUnsupportedReason;
-	readonly vMotionNotLicensed: VcHostCapabilityFtUnsupportedReason;
+declare class VcHostCapabilityFtUnsupportedReason implements IPseudoEnum {
+	static readonly missingVMotionNic: VcHostCapabilityFtUnsupportedReason & EnumVal<'missingVMotionNic'>;
+	static readonly cpuHwmmuUnsupported: VcHostCapabilityFtUnsupportedReason & EnumVal<'cpuHwmmuUnsupported'>;
+	static readonly missingFTLoggingNic: VcHostCapabilityFtUnsupportedReason & EnumVal<'missingFTLoggingNic'>;
+	static readonly vMotionNotLicensed: VcHostCapabilityFtUnsupportedReason & EnumVal<'vMotionNotLicensed'>;
+	static readonly ftNotLicensed: VcHostCapabilityFtUnsupportedReason & EnumVal<'ftNotLicensed'>;
+	static readonly unsupportedProduct: VcHostCapabilityFtUnsupportedReason & EnumVal<'unsupportedProduct'>;
+	static readonly haAgentIssue: VcHostCapabilityFtUnsupportedReason & EnumVal<'haAgentIssue'>;
+	static readonly cpuHvUnsupported: VcHostCapabilityFtUnsupportedReason & EnumVal<'cpuHvUnsupported'>;
+	static readonly cpuHvDisabled: VcHostCapabilityFtUnsupportedReason & EnumVal<'cpuHvDisabled'>;
+	static fromString(value: string): VcHostCapabilityFtUnsupportedReason & EnumVal<TcleanKeys<typeof VcHostCapabilityFtUnsupportedReason>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly ftNotLicensed: VcHostCapabilityFtUnsupportedReason;
-	readonly unsupportedProduct: VcHostCapabilityFtUnsupportedReason;
-	readonly haAgentIssue: VcHostCapabilityFtUnsupportedReason;
-	readonly cpuHvUnsupported: VcHostCapabilityFtUnsupportedReason;
-	readonly cpuHvDisabled: VcHostCapabilityFtUnsupportedReason;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostCapabilityFtUnsupportedReason): VcHostCapabilityFtUnsupportedReason;
+	toString: () => string;
 }
 
 /**
  * Type of services for which Profile can be requested for
  */
-declare class VcClusterProfileServiceType {
-	readonly DPM: VcClusterProfileServiceType;
-	readonly DRS: VcClusterProfileServiceType;
-	readonly name: string;
-	readonly HA: VcClusterProfileServiceType;
+declare class VcClusterProfileServiceType implements IPseudoEnum {
+	static readonly DPM: VcClusterProfileServiceType & EnumVal<'DPM'>;
+	static readonly DRS: VcClusterProfileServiceType & EnumVal<'DRS'>;
+	static readonly HA: VcClusterProfileServiceType & EnumVal<'HA'>;
+	static readonly FT: VcClusterProfileServiceType & EnumVal<'FT'>;
+	static fromString(value: string): VcClusterProfileServiceType & EnumVal<TcleanKeys<typeof VcClusterProfileServiceType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly FT: VcClusterProfileServiceType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcClusterProfileServiceType): VcClusterProfileServiceType;
+	toString: () => string;
 }
 
 /**
@@ -7213,49 +6847,46 @@ declare class VcClusterProfileServiceType {
  * 
  * soft rule: The enforcement is best effort.
  */
-declare class VcPlacementAffinityRuleRuleType {
-	readonly antiAffinity: VcPlacementAffinityRuleRuleType;
-	readonly softAntiAffinity: VcPlacementAffinityRuleRuleType;
-	readonly name: string;
+declare class VcPlacementAffinityRuleRuleType implements IPseudoEnum {
+	static readonly antiAffinity: VcPlacementAffinityRuleRuleType & EnumVal<'antiAffinity'>;
+	static readonly softAntiAffinity: VcPlacementAffinityRuleRuleType & EnumVal<'softAntiAffinity'>;
+	static readonly affinity: VcPlacementAffinityRuleRuleType & EnumVal<'affinity'>;
+	static readonly softAffinity: VcPlacementAffinityRuleRuleType & EnumVal<'softAffinity'>;
+	static fromString(value: string): VcPlacementAffinityRuleRuleType & EnumVal<TcleanKeys<typeof VcPlacementAffinityRuleRuleType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly affinity: VcPlacementAffinityRuleRuleType;
-	readonly softAffinity: VcPlacementAffinityRuleRuleType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcPlacementAffinityRuleRuleType): VcPlacementAffinityRuleRuleType;
+	toString: () => string;
 }
 
 /**
  * The list of disk issues.
  */
-declare class VcVsanDiskIssueType {
-	readonly nonExist: VcVsanDiskIssueType;
-	readonly name: string;
+declare class VcVsanDiskIssueType implements IPseudoEnum {
+	static readonly nonExist: VcVsanDiskIssueType & EnumVal<'nonExist'>;
+	static readonly stampMismatch: VcVsanDiskIssueType & EnumVal<'stampMismatch'>;
+	static readonly unknown: VcVsanDiskIssueType & EnumVal<'unknown'>;
+	static fromString(value: string): VcVsanDiskIssueType & EnumVal<TcleanKeys<typeof VcVsanDiskIssueType>>;
+
 	readonly id: string;
-	readonly stampMismatch: VcVsanDiskIssueType;
+	readonly name: string;
 	readonly value: string;
-	readonly unknown: VcVsanDiskIssueType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVsanDiskIssueType): VcVsanDiskIssueType;
+	toString: () => string;
 }
 
-declare class VcVmShutdownOnIsolationEventOperation {
-	readonly name: string;
+declare class VcVmShutdownOnIsolationEventOperation implements IPseudoEnum {
+	static readonly shutdown: VcVmShutdownOnIsolationEventOperation & EnumVal<'shutdown'>;
+	static readonly poweredOff: VcVmShutdownOnIsolationEventOperation & EnumVal<'poweredOff'>;
+	static fromString(value: string): VcVmShutdownOnIsolationEventOperation & EnumVal<TcleanKeys<typeof VcVmShutdownOnIsolationEventOperation>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly shutdown: VcVmShutdownOnIsolationEventOperation;
-	readonly poweredOff: VcVmShutdownOnIsolationEventOperation;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVmShutdownOnIsolationEventOperation): VcVmShutdownOnIsolationEventOperation;
+	toString: () => string;
 }
 
 /**
@@ -7264,39 +6895,37 @@ declare class VcVmShutdownOnIsolationEventOperation {
  * to the Storage Policy Server.
  * See {@link ServerObjectRef}.{@link pbm.ServerObjectRef#objectType}.
  */
-declare class PbmObjectType {
-	readonly virtualMachine: PbmObjectType;
-	readonly virtualDiskUUID: PbmObjectType;
-	readonly cluster: PbmObjectType;
-	readonly virtualDiskId: PbmObjectType;
-	readonly datastore: PbmObjectType;
-	readonly host: PbmObjectType;
-	readonly name: string;
-	readonly virtualMachineAndDisks: PbmObjectType;
+declare class PbmObjectType implements IPseudoEnum {
+	static readonly virtualMachine: PbmObjectType & EnumVal<'virtualMachine'>;
+	static readonly virtualDiskUUID: PbmObjectType & EnumVal<'virtualDiskUUID'>;
+	static readonly cluster: PbmObjectType & EnumVal<'cluster'>;
+	static readonly virtualDiskId: PbmObjectType & EnumVal<'virtualDiskId'>;
+	static readonly datastore: PbmObjectType & EnumVal<'datastore'>;
+	static readonly host: PbmObjectType & EnumVal<'host'>;
+	static readonly virtualMachineAndDisks: PbmObjectType & EnumVal<'virtualMachineAndDisks'>;
+	static readonly unknown: PbmObjectType & EnumVal<'unknown'>;
+	static fromString(value: string): PbmObjectType & EnumVal<TcleanKeys<typeof PbmObjectType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly unknown: PbmObjectType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: PbmObjectType): PbmObjectType;
+	toString: () => string;
 }
 
 /**
  * Enumeration of port directions.
  */
-declare class VcHostFirewallRuleDirection {
-	readonly inbound: VcHostFirewallRuleDirection;
-	readonly outbound: VcHostFirewallRuleDirection;
-	readonly name: string;
+declare class VcHostFirewallRuleDirection implements IPseudoEnum {
+	static readonly inbound: VcHostFirewallRuleDirection & EnumVal<'inbound'>;
+	static readonly outbound: VcHostFirewallRuleDirection & EnumVal<'outbound'>;
+	static fromString(value: string): VcHostFirewallRuleDirection & EnumVal<TcleanKeys<typeof VcHostFirewallRuleDirection>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostFirewallRuleDirection): VcHostFirewallRuleDirection;
+	toString: () => string;
 }
 
 /**
@@ -7308,17 +6937,16 @@ declare class VcHostFirewallRuleDirection {
  * of a specific datatype ({@link pbm.capability.TypeInfo#typeName}).
  * <p>
  */
-declare class PbmBuiltinGenericType {
-	readonly VMW_SET: PbmBuiltinGenericType;
-	readonly name: string;
-	readonly VMW_RANGE: PbmBuiltinGenericType;
+declare class PbmBuiltinGenericType implements IPseudoEnum {
+	static readonly VMW_SET: PbmBuiltinGenericType & EnumVal<'VMW_SET'>;
+	static readonly VMW_RANGE: PbmBuiltinGenericType & EnumVal<'VMW_RANGE'>;
+	static fromString(value: string): PbmBuiltinGenericType & EnumVal<TcleanKeys<typeof PbmBuiltinGenericType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: PbmBuiltinGenericType): PbmBuiltinGenericType;
+	toString: () => string;
 }
 
 /**
@@ -7333,37 +6961,35 @@ declare class PbmBuiltinGenericType {
  * 
  * Defaults to preferred on first configuration if unspecified.
  */
-declare class VcHostInternetScsiHbaDigestType {
-	readonly digestPreferred: VcHostInternetScsiHbaDigestType;
-	readonly digestRequired: VcHostInternetScsiHbaDigestType;
-	readonly name: string;
-	readonly digestDiscouraged: VcHostInternetScsiHbaDigestType;
+declare class VcHostInternetScsiHbaDigestType implements IPseudoEnum {
+	static readonly digestPreferred: VcHostInternetScsiHbaDigestType & EnumVal<'digestPreferred'>;
+	static readonly digestRequired: VcHostInternetScsiHbaDigestType & EnumVal<'digestRequired'>;
+	static readonly digestDiscouraged: VcHostInternetScsiHbaDigestType & EnumVal<'digestDiscouraged'>;
+	static readonly digestProhibited: VcHostInternetScsiHbaDigestType & EnumVal<'digestProhibited'>;
+	static fromString(value: string): VcHostInternetScsiHbaDigestType & EnumVal<TcleanKeys<typeof VcHostInternetScsiHbaDigestType>>;
+
 	readonly id: string;
-	readonly digestProhibited: VcHostInternetScsiHbaDigestType;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostInternetScsiHbaDigestType): VcHostInternetScsiHbaDigestType;
+	toString: () => string;
 }
 
 /**
  * The type of operation being performed on the backing of a virtual device.
  * Valid values are:
  */
-declare class VcVirtualDeviceConfigSpecFileOperation {
-	static replace: VcVirtualDeviceConfigSpecFileOperation;
-	static name: string;
-	static create: VcVirtualDeviceConfigSpecFileOperation;
-	static destroy: VcVirtualDeviceConfigSpecFileOperation;
-	static id: string;
-	static value: string;
+declare class VcVirtualDeviceConfigSpecFileOperation implements IPseudoEnum {
+	static readonly replace: VcVirtualDeviceConfigSpecFileOperation & EnumVal<'replace'>;
+	static readonly create: VcVirtualDeviceConfigSpecFileOperation & EnumVal<'create'>;
+	static readonly destroy: VcVirtualDeviceConfigSpecFileOperation & EnumVal<'destroy'>;
+	static fromString(value: string): VcVirtualDeviceConfigSpecFileOperation & EnumVal<TcleanKeys<typeof VcVirtualDeviceConfigSpecFileOperation>>;
+
+	readonly id: string;
+	readonly name: string;
+	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualDeviceConfigSpecFileOperation): VcVirtualDeviceConfigSpecFileOperation;
+	toString: () => string;
 }
 
 /**
@@ -7371,54 +6997,51 @@ declare class VcVirtualDeviceConfigSpecFileOperation {
  * defines VVOL types. VvolType's are referenced to specify which objectType
  * to fetch for default capability.
  */
-declare class PbmVvolType {
-	readonly Swap: PbmVvolType;
-	readonly Config: PbmVvolType;
-	readonly name: string;
-	readonly Data: PbmVvolType;
+declare class PbmVvolType implements IPseudoEnum {
+	static readonly Swap: PbmVvolType & EnumVal<'Swap'>;
+	static readonly Config: PbmVvolType & EnumVal<'Config'>;
+	static readonly Data: PbmVvolType & EnumVal<'Data'>;
+	static fromString(value: string): PbmVvolType & EnumVal<TcleanKeys<typeof PbmVvolType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: PbmVvolType): PbmVvolType;
+	toString: () => string;
 }
 
 /**
  * The {@link pbm.profile.EntityAssociations.Operation} enumerated type
  * defines the provisioning operation being performed on the entity like FCD, virtual machine.
  */
-declare class PbmOperation {
-	readonly REGISTER: PbmOperation;
-	readonly RECONFIGURE: PbmOperation;
-	readonly CREATE: PbmOperation;
-	readonly name: string;
-	readonly MIGRATE: PbmOperation;
+declare class PbmOperation implements IPseudoEnum {
+	static readonly REGISTER: PbmOperation & EnumVal<'REGISTER'>;
+	static readonly RECONFIGURE: PbmOperation & EnumVal<'RECONFIGURE'>;
+	static readonly CREATE: PbmOperation & EnumVal<'CREATE'>;
+	static readonly MIGRATE: PbmOperation & EnumVal<'MIGRATE'>;
+	static readonly CLONE: PbmOperation & EnumVal<'CLONE'>;
+	static fromString(value: string): PbmOperation & EnumVal<TcleanKeys<typeof PbmOperation>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly CLONE: PbmOperation;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: PbmOperation): PbmOperation;
+	toString: () => string;
 }
 
 /**
  * Enum representing result of batch-APis.
  */
-declare class VcBatchResultResult {
-	readonly fail: VcBatchResultResult;
-	readonly success: VcBatchResultResult;
-	readonly name: string;
+declare class VcBatchResultResult implements IPseudoEnum {
+	static readonly fail: VcBatchResultResult & EnumVal<'fail'>;
+	static readonly success: VcBatchResultResult & EnumVal<'success'>;
+	static fromString(value: string): VcBatchResultResult & EnumVal<TcleanKeys<typeof VcBatchResultResult>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcBatchResultResult): VcBatchResultResult;
+	toString: () => string;
 }
 
 /**
@@ -7427,18 +7050,17 @@ declare class VcBatchResultResult {
  * storage profile. See
  * {@link pbm.profile.CapabilityBasedProfile}.
  */
-declare class PbmProfileCategoryEnum {
-	readonly name: string;
+declare class PbmProfileCategoryEnum implements IPseudoEnum {
+	static readonly DATA_SERVICE_POLICY: PbmProfileCategoryEnum & EnumVal<'DATA_SERVICE_POLICY'>;
+	static readonly REQUIREMENT: PbmProfileCategoryEnum & EnumVal<'REQUIREMENT'>;
+	static readonly RESOURCE: PbmProfileCategoryEnum & EnumVal<'RESOURCE'>;
+	static fromString(value: string): PbmProfileCategoryEnum & EnumVal<TcleanKeys<typeof PbmProfileCategoryEnum>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly DATA_SERVICE_POLICY: PbmProfileCategoryEnum;
-	readonly REQUIREMENT: PbmProfileCategoryEnum;
-	readonly RESOURCE: PbmProfileCategoryEnum;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: PbmProfileCategoryEnum): PbmProfileCategoryEnum;
+	toString: () => string;
 }
 
 /**
@@ -7446,206 +7068,194 @@ declare class PbmProfileCategoryEnum {
  * Currently only tag based properties can use this operator.
  * Other operators can be added as required.
  */
-declare class PbmCapabilityOperator {
-	readonly NOT: PbmCapabilityOperator;
-	readonly name: string;
+declare class PbmCapabilityOperator implements IPseudoEnum {
+	static readonly NOT: PbmCapabilityOperator & EnumVal<'NOT'>;
+	static fromString(value: string): PbmCapabilityOperator & EnumVal<TcleanKeys<typeof PbmCapabilityOperator>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: PbmCapabilityOperator): PbmCapabilityOperator;
+	toString: () => string;
 }
 
 /**
  * The types of tests which can requested by any of the methods in either
  * {@link CompatibilityChecker} or {@link ProvisioningChecker}.
  */
-declare class VcCheckTestType {
-	readonly sourceTests: VcCheckTestType;
-	readonly hostTests: VcCheckTestType;
-	readonly networkTests: VcCheckTestType;
-	readonly name: string;
-	readonly datastoreTests: VcCheckTestType;
+declare class VcCheckTestType implements IPseudoEnum {
+	static readonly sourceTests: VcCheckTestType & EnumVal<'sourceTests'>;
+	static readonly hostTests: VcCheckTestType & EnumVal<'hostTests'>;
+	static readonly networkTests: VcCheckTestType & EnumVal<'networkTests'>;
+	static readonly datastoreTests: VcCheckTestType & EnumVal<'datastoreTests'>;
+	static readonly resourcePoolTests: VcCheckTestType & EnumVal<'resourcePoolTests'>;
+	static fromString(value: string): VcCheckTestType & EnumVal<TcleanKeys<typeof VcCheckTestType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly resourcePoolTests: VcCheckTestType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcCheckTestType): VcCheckTestType;
+	toString: () => string;
 }
 
-declare class VcVFlashModuleNotSupportedReason {
-	readonly DiskSizeNotSupported: VcVFlashModuleNotSupportedReason;
-	readonly CacheModeNotSupported: VcVFlashModuleNotSupportedReason;
-	readonly CacheReservationNotSupported: VcVFlashModuleNotSupportedReason;
-	readonly CacheBlockSizeNotSupported: VcVFlashModuleNotSupportedReason;
-	readonly CacheConsistencyTypeNotSupported: VcVFlashModuleNotSupportedReason;
-	readonly name: string;
+declare class VcVFlashModuleNotSupportedReason implements IPseudoEnum {
+	static readonly DiskSizeNotSupported: VcVFlashModuleNotSupportedReason & EnumVal<'DiskSizeNotSupported'>;
+	static readonly CacheModeNotSupported: VcVFlashModuleNotSupportedReason & EnumVal<'CacheModeNotSupported'>;
+	static readonly CacheReservationNotSupported: VcVFlashModuleNotSupportedReason & EnumVal<'CacheReservationNotSupported'>;
+	static readonly CacheBlockSizeNotSupported: VcVFlashModuleNotSupportedReason & EnumVal<'CacheBlockSizeNotSupported'>;
+	static readonly CacheConsistencyTypeNotSupported: VcVFlashModuleNotSupportedReason & EnumVal<'CacheConsistencyTypeNotSupported'>;
+	static fromString(value: string): VcVFlashModuleNotSupportedReason & EnumVal<TcleanKeys<typeof VcVFlashModuleNotSupportedReason>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVFlashModuleNotSupportedReason): VcVFlashModuleNotSupportedReason;
-}
-
-declare class VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm {
-	readonly vmNptConflictingIOChainConfigured: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm;
-	readonly vmNptMonitorBlocks: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm;
-	readonly vmNptIncompatibleBackingType: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm;
-	readonly vmNptIncompatibleGuestDriver: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm;
-	readonly vmNptFaultToleranceOrRecordReplayConfigured: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm;
-	readonly vmNptIncompatibleAdapterType: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm;
-	readonly vmNptIncompatibleGuest: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm;
-	readonly vmNptConflictingOperationInProgress: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm;
-	readonly vmNptRuntimeError: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm;
-	readonly vmNptIncompatibleAdapterFeatures: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm;
-	readonly vmNptInsufficientMemoryReservation: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm;
-	readonly vmNptDisabledOrDisconnectedAdapter: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm;
-	readonly name: string;
-	readonly vmNptOutOfIntrVector: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm;
+	toString: () => string;
+}
+
+declare class VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm implements IPseudoEnum {
+	static readonly vmNptConflictingIOChainConfigured: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm & EnumVal<'vmNptConflictingIOChainConfigured'>;
+	static readonly vmNptMonitorBlocks: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm & EnumVal<'vmNptMonitorBlocks'>;
+	static readonly vmNptIncompatibleBackingType: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm & EnumVal<'vmNptIncompatibleBackingType'>;
+	static readonly vmNptIncompatibleGuestDriver: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm & EnumVal<'vmNptIncompatibleGuestDriver'>;
+	static readonly vmNptFaultToleranceOrRecordReplayConfigured: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm & EnumVal<'vmNptFaultToleranceOrRecordReplayConfigured'>;
+	static readonly vmNptIncompatibleAdapterType: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm & EnumVal<'vmNptIncompatibleAdapterType'>;
+	static readonly vmNptIncompatibleGuest: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm & EnumVal<'vmNptIncompatibleGuest'>;
+	static readonly vmNptConflictingOperationInProgress: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm & EnumVal<'vmNptConflictingOperationInProgress'>;
+	static readonly vmNptRuntimeError: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm & EnumVal<'vmNptRuntimeError'>;
+	static readonly vmNptIncompatibleAdapterFeatures: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm & EnumVal<'vmNptIncompatibleAdapterFeatures'>;
+	static readonly vmNptInsufficientMemoryReservation: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm & EnumVal<'vmNptInsufficientMemoryReservation'>;
+	static readonly vmNptDisabledOrDisconnectedAdapter: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm & EnumVal<'vmNptDisabledOrDisconnectedAdapter'>;
+	static readonly vmNptOutOfIntrVector: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm & EnumVal<'vmNptOutOfIntrVector'>;
+	static readonly vmNptVMCIActive: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm & EnumVal<'vmNptVMCIActive'>;
+	static fromString(value: string): VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm & EnumVal<TcleanKeys<typeof VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm>>;
+
 	readonly id: string;
-	readonly vmNptVMCIActive: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm): VcVirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVm;
+	toString: () => string;
 }
 
-declare class VcAnswerFileValidationResultStatus {
-	readonly needInput: VcAnswerFileValidationResultStatus;
-	readonly success: VcAnswerFileValidationResultStatus;
-	readonly name: string;
+declare class VcAnswerFileValidationResultStatus implements IPseudoEnum {
+	static readonly needInput: VcAnswerFileValidationResultStatus & EnumVal<'needInput'>;
+	static readonly success: VcAnswerFileValidationResultStatus & EnumVal<'success'>;
+	static readonly error: VcAnswerFileValidationResultStatus & EnumVal<'error'>;
+	static fromString(value: string): VcAnswerFileValidationResultStatus & EnumVal<TcleanKeys<typeof VcAnswerFileValidationResultStatus>>;
+
 	readonly id: string;
-	readonly error: VcAnswerFileValidationResultStatus;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcAnswerFileValidationResultStatus): VcAnswerFileValidationResultStatus;
+	toString: () => string;
 }
 
 /**
  * Current running status of VMware Tools running in the guest
  * operating system.
  */
-declare class VcVirtualMachineToolsRunningStatus {
-	readonly guestToolsRunning: VcVirtualMachineToolsRunningStatus;
-	readonly guestToolsExecutingScripts: VcVirtualMachineToolsRunningStatus;
-	readonly name: string;
-	readonly guestToolsNotRunning: VcVirtualMachineToolsRunningStatus;
+declare class VcVirtualMachineToolsRunningStatus implements IPseudoEnum {
+	static readonly guestToolsRunning: VcVirtualMachineToolsRunningStatus & EnumVal<'guestToolsRunning'>;
+	static readonly guestToolsExecutingScripts: VcVirtualMachineToolsRunningStatus & EnumVal<'guestToolsExecutingScripts'>;
+	static readonly guestToolsNotRunning: VcVirtualMachineToolsRunningStatus & EnumVal<'guestToolsNotRunning'>;
+	static fromString(value: string): VcVirtualMachineToolsRunningStatus & EnumVal<TcleanKeys<typeof VcVirtualMachineToolsRunningStatus>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineToolsRunningStatus): VcVirtualMachineToolsRunningStatus;
+	toString: () => string;
 }
 
 /**
  * The possible kinds of change events that are reported.
  */
-declare class VcCDCInventoryChangeKind {
-	readonly deleted: VcCDCInventoryChangeKind;
-	readonly created: VcCDCInventoryChangeKind;
-	readonly name: string;
+declare class VcCDCInventoryChangeKind implements IPseudoEnum {
+	static readonly deleted: VcCDCInventoryChangeKind & EnumVal<'deleted'>;
+	static readonly created: VcCDCInventoryChangeKind & EnumVal<'created'>;
+	static readonly updated: VcCDCInventoryChangeKind & EnumVal<'updated'>;
+	static fromString(value: string): VcCDCInventoryChangeKind & EnumVal<TcleanKeys<typeof VcCDCInventoryChangeKind>>;
+
 	readonly id: string;
-	readonly updated: VcCDCInventoryChangeKind;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcCDCInventoryChangeKind): VcCDCInventoryChangeKind;
+	toString: () => string;
 }
 
 /**
  * The root WWN operation mode.
  */
-declare class VcVirtualMachineConfigSpecNpivWwnOp {
-	readonly extend: VcVirtualMachineConfigSpecNpivWwnOp;
-	readonly set: VcVirtualMachineConfigSpecNpivWwnOp;
-	readonly name: string;
+declare class VcVirtualMachineConfigSpecNpivWwnOp implements IPseudoEnum {
+	static readonly extend: VcVirtualMachineConfigSpecNpivWwnOp & EnumVal<'extend'>;
+	static readonly set: VcVirtualMachineConfigSpecNpivWwnOp & EnumVal<'set'>;
+	static readonly generate: VcVirtualMachineConfigSpecNpivWwnOp & EnumVal<'generate'>;
+	static readonly remove: VcVirtualMachineConfigSpecNpivWwnOp & EnumVal<'remove'>;
+	static fromString(value: string): VcVirtualMachineConfigSpecNpivWwnOp & EnumVal<TcleanKeys<typeof VcVirtualMachineConfigSpecNpivWwnOp>>;
+
 	readonly id: string;
-	readonly generate: VcVirtualMachineConfigSpecNpivWwnOp;
+	readonly name: string;
 	readonly value: string;
-	readonly remove: VcVirtualMachineConfigSpecNpivWwnOp;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineConfigSpecNpivWwnOp): VcVirtualMachineConfigSpecNpivWwnOp;
+	toString: () => string;
 }
 
 /**
  * The types of disk drives.
  */
-declare class VcScsiDiskType {
-	readonly native4k: VcScsiDiskType;
-	readonly emulated512: VcScsiDiskType;
-	readonly name: string;
-	readonly native512: VcScsiDiskType;
+declare class VcScsiDiskType implements IPseudoEnum {
+	static readonly native4k: VcScsiDiskType & EnumVal<'native4k'>;
+	static readonly emulated512: VcScsiDiskType & EnumVal<'emulated512'>;
+	static readonly native512: VcScsiDiskType & EnumVal<'native512'>;
+	static readonly SoftwareEmulated4k: VcScsiDiskType & EnumVal<'SoftwareEmulated4k'>;
+	static readonly unknown: VcScsiDiskType & EnumVal<'unknown'>;
+	static fromString(value: string): VcScsiDiskType & EnumVal<TcleanKeys<typeof VcScsiDiskType>>;
+
 	readonly id: string;
-	readonly SoftwareEmulated4k: VcScsiDiskType;
+	readonly name: string;
 	readonly value: string;
-	readonly unknown: VcScsiDiskType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcScsiDiskType): VcScsiDiskType;
+	toString: () => string;
 }
 
-declare class PbmPlacementCapacityRequirementDiskProvisioningType {
-	readonly per_policy: PbmPlacementCapacityRequirementDiskProvisioningType;
-	readonly name: string;
+declare class PbmPlacementCapacityRequirementDiskProvisioningType implements IPseudoEnum {
+	static readonly per_policy: PbmPlacementCapacityRequirementDiskProvisioningType & EnumVal<'per_policy'>;
+	static readonly thick: PbmPlacementCapacityRequirementDiskProvisioningType & EnumVal<'thick'>;
+	static readonly thin: PbmPlacementCapacityRequirementDiskProvisioningType & EnumVal<'thin'>;
+	static fromString(value: string): PbmPlacementCapacityRequirementDiskProvisioningType & EnumVal<TcleanKeys<typeof PbmPlacementCapacityRequirementDiskProvisioningType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly thick: PbmPlacementCapacityRequirementDiskProvisioningType;
-	readonly thin: PbmPlacementCapacityRequirementDiskProvisioningType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: PbmPlacementCapacityRequirementDiskProvisioningType): PbmPlacementCapacityRequirementDiskProvisioningType;
+	toString: () => string;
 }
 
-declare class VcEventCategory {
-	readonly name: string;
-	readonly warning: VcEventCategory;
+declare class VcEventCategory implements IPseudoEnum {
+	static readonly warning: VcEventCategory & EnumVal<'warning'>;
+	static readonly error: VcEventCategory & EnumVal<'error'>;
+	static readonly user: VcEventCategory & EnumVal<'user'>;
+	static readonly info: VcEventCategory & EnumVal<'info'>;
+	static fromString(value: string): VcEventCategory & EnumVal<TcleanKeys<typeof VcEventCategory>>;
+
 	readonly id: string;
-	readonly error: VcEventCategory;
-	readonly user: VcEventCategory;
+	readonly name: string;
 	readonly value: string;
-	readonly info: VcEventCategory;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcEventCategory): VcEventCategory;
+	toString: () => string;
 }
 
-declare class VcGuestFileType {
-	readonly file: VcGuestFileType;
-	readonly symlink: VcGuestFileType;
-	readonly name: string;
+declare class VcGuestFileType implements IPseudoEnum {
+	static readonly file: VcGuestFileType & EnumVal<'file'>;
+	static readonly symlink: VcGuestFileType & EnumVal<'symlink'>;
+	static readonly directory: VcGuestFileType & EnumVal<'directory'>;
+	static fromString(value: string): VcGuestFileType & EnumVal<TcleanKeys<typeof VcGuestFileType>>;
+
 	readonly id: string;
-	readonly directory: VcGuestFileType;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcGuestFileType): VcGuestFileType;
+	toString: () => string;
 }
 
 /**
@@ -7655,33 +7265,31 @@ declare class VcGuestFileType {
  * and as outputs (to specify which compatibility types apply for
  * each host).
  */
-declare class VcVMotionCompatibilityType {
-	readonly software: VcVMotionCompatibilityType;
-	readonly name: string;
-	readonly cpu: VcVMotionCompatibilityType;
+declare class VcVMotionCompatibilityType implements IPseudoEnum {
+	static readonly software: VcVMotionCompatibilityType & EnumVal<'software'>;
+	static readonly cpu: VcVMotionCompatibilityType & EnumVal<'cpu'>;
+	static fromString(value: string): VcVMotionCompatibilityType & EnumVal<TcleanKeys<typeof VcVMotionCompatibilityType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVMotionCompatibilityType): VcVMotionCompatibilityType;
+	toString: () => string;
 }
 
 /**
  * Overall state of NVDIMM
  */
-declare class VcNvdimmNvdimmHealthInfoState {
-	readonly normal: VcNvdimmNvdimmHealthInfoState;
-	readonly name: string;
+declare class VcNvdimmNvdimmHealthInfoState implements IPseudoEnum {
+	static readonly normal: VcNvdimmNvdimmHealthInfoState & EnumVal<'normal'>;
+	static readonly error: VcNvdimmNvdimmHealthInfoState & EnumVal<'error'>;
+	static fromString(value: string): VcNvdimmNvdimmHealthInfoState & EnumVal<TcleanKeys<typeof VcNvdimmNvdimmHealthInfoState>>;
+
 	readonly id: string;
-	readonly error: VcNvdimmNvdimmHealthInfoState;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcNvdimmNvdimmHealthInfoState): VcNvdimmNvdimmHealthInfoState;
+	toString: () => string;
 }
 
 /**
@@ -7693,222 +7301,210 @@ declare class VcNvdimmNvdimmHealthInfoState {
  * {@link vim.ComputeResource.ConfigInfo#vmSwapPlacement vmSwapPlacement}
  * property.
  */
-declare class VcVirtualMachineConfigInfoSwapPlacementType {
-	readonly hostLocal: VcVirtualMachineConfigInfoSwapPlacementType;
-	readonly inherit: VcVirtualMachineConfigInfoSwapPlacementType;
-	readonly vmDirectory: VcVirtualMachineConfigInfoSwapPlacementType;
-	readonly name: string;
+declare class VcVirtualMachineConfigInfoSwapPlacementType implements IPseudoEnum {
+	static readonly hostLocal: VcVirtualMachineConfigInfoSwapPlacementType & EnumVal<'hostLocal'>;
+	static readonly inherit: VcVirtualMachineConfigInfoSwapPlacementType & EnumVal<'inherit'>;
+	static readonly vmDirectory: VcVirtualMachineConfigInfoSwapPlacementType & EnumVal<'vmDirectory'>;
+	static fromString(value: string): VcVirtualMachineConfigInfoSwapPlacementType & EnumVal<TcleanKeys<typeof VcVirtualMachineConfigInfoSwapPlacementType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineConfigInfoSwapPlacementType): VcVirtualMachineConfigInfoSwapPlacementType;
+	toString: () => string;
 }
 
 /**
  * The types of provisioning operation.
  */
-declare class VcVirtualMachineProvisioningPolicyOpType {
-	readonly clone: VcVirtualMachineProvisioningPolicyOpType;
-	readonly createSecondary: VcVirtualMachineProvisioningPolicyOpType;
-	readonly name: string;
+declare class VcVirtualMachineProvisioningPolicyOpType implements IPseudoEnum {
+	static readonly clone: VcVirtualMachineProvisioningPolicyOpType & EnumVal<'clone'>;
+	static readonly createSecondary: VcVirtualMachineProvisioningPolicyOpType & EnumVal<'createSecondary'>;
+	static readonly createForkChild: VcVirtualMachineProvisioningPolicyOpType & EnumVal<'createForkChild'>;
+	static readonly migrate: VcVirtualMachineProvisioningPolicyOpType & EnumVal<'migrate'>;
+	static fromString(value: string): VcVirtualMachineProvisioningPolicyOpType & EnumVal<TcleanKeys<typeof VcVirtualMachineProvisioningPolicyOpType>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly createForkChild: VcVirtualMachineProvisioningPolicyOpType;
-	readonly migrate: VcVirtualMachineProvisioningPolicyOpType;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineProvisioningPolicyOpType): VcVirtualMachineProvisioningPolicyOpType;
+	toString: () => string;
 }
 
-declare class VcHostDisconnectedEventReasonCode {
-	readonly userRequest: VcHostDisconnectedEventReasonCode;
-	readonly agentOutOfDate: VcHostDisconnectedEventReasonCode;
-	readonly vcVRAMCapacityExceeded: VcHostDisconnectedEventReasonCode;
-	readonly insufficientLicenses: VcHostDisconnectedEventReasonCode;
-	readonly passwordDecryptFailure: VcHostDisconnectedEventReasonCode;
-	readonly name: string;
-	readonly agentUpgrade: VcHostDisconnectedEventReasonCode;
-	readonly licenseExpired: VcHostDisconnectedEventReasonCode;
+declare class VcHostDisconnectedEventReasonCode implements IPseudoEnum {
+	static readonly userRequest: VcHostDisconnectedEventReasonCode & EnumVal<'userRequest'>;
+	static readonly agentOutOfDate: VcHostDisconnectedEventReasonCode & EnumVal<'agentOutOfDate'>;
+	static readonly vcVRAMCapacityExceeded: VcHostDisconnectedEventReasonCode & EnumVal<'vcVRAMCapacityExceeded'>;
+	static readonly insufficientLicenses: VcHostDisconnectedEventReasonCode & EnumVal<'insufficientLicenses'>;
+	static readonly passwordDecryptFailure: VcHostDisconnectedEventReasonCode & EnumVal<'passwordDecryptFailure'>;
+	static readonly agentUpgrade: VcHostDisconnectedEventReasonCode & EnumVal<'agentUpgrade'>;
+	static readonly licenseExpired: VcHostDisconnectedEventReasonCode & EnumVal<'licenseExpired'>;
+	static readonly sslThumbprintVerifyFailed: VcHostDisconnectedEventReasonCode & EnumVal<'sslThumbprintVerifyFailed'>;
+	static readonly unknown: VcHostDisconnectedEventReasonCode & EnumVal<'unknown'>;
+	static fromString(value: string): VcHostDisconnectedEventReasonCode & EnumVal<TcleanKeys<typeof VcHostDisconnectedEventReasonCode>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly sslThumbprintVerifyFailed: VcHostDisconnectedEventReasonCode;
-	readonly unknown: VcHostDisconnectedEventReasonCode;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostDisconnectedEventReasonCode): VcHostDisconnectedEventReasonCode;
+	toString: () => string;
 }
 
 /**
  * SNMP Agent supported capabilities enum
  */
-declare class VcHostSnmpAgentCapability {
-	readonly COMPLETE: VcHostSnmpAgentCapability;
-	readonly CONFIGURATION: VcHostSnmpAgentCapability;
-	readonly name: string;
+declare class VcHostSnmpAgentCapability implements IPseudoEnum {
+	static readonly COMPLETE: VcHostSnmpAgentCapability & EnumVal<'COMPLETE'>;
+	static readonly CONFIGURATION: VcHostSnmpAgentCapability & EnumVal<'CONFIGURATION'>;
+	static readonly DIAGNOSTICS: VcHostSnmpAgentCapability & EnumVal<'DIAGNOSTICS'>;
+	static fromString(value: string): VcHostSnmpAgentCapability & EnumVal<TcleanKeys<typeof VcHostSnmpAgentCapability>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly DIAGNOSTICS: VcHostSnmpAgentCapability;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostSnmpAgentCapability): VcHostSnmpAgentCapability;
+	toString: () => string;
 }
 
 /**
  * Enumeration of AutoMode values.
  */
-declare class VcCustomizationLicenseDataMode {
-	readonly perSeat: VcCustomizationLicenseDataMode;
-	readonly perServer: VcCustomizationLicenseDataMode;
-	readonly name: string;
+declare class VcCustomizationLicenseDataMode implements IPseudoEnum {
+	static readonly perSeat: VcCustomizationLicenseDataMode & EnumVal<'perSeat'>;
+	static readonly perServer: VcCustomizationLicenseDataMode & EnumVal<'perServer'>;
+	static fromString(value: string): VcCustomizationLicenseDataMode & EnumVal<TcleanKeys<typeof VcCustomizationLicenseDataMode>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcCustomizationLicenseDataMode): VcCustomizationLicenseDataMode;
+	toString: () => string;
 }
 
 /**
  * Defines a host's power state.
  */
-declare class VcHostSystemPowerState {
-	readonly poweredOn: VcHostSystemPowerState;
-	readonly standBy: VcHostSystemPowerState;
-	readonly name: string;
+declare class VcHostSystemPowerState implements IPseudoEnum {
+	static readonly poweredOn: VcHostSystemPowerState & EnumVal<'poweredOn'>;
+	static readonly standBy: VcHostSystemPowerState & EnumVal<'standBy'>;
+	static readonly poweredOff: VcHostSystemPowerState & EnumVal<'poweredOff'>;
+	static readonly unknown: VcHostSystemPowerState & EnumVal<'unknown'>;
+	static fromString(value: string): VcHostSystemPowerState & EnumVal<TcleanKeys<typeof VcHostSystemPowerState>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly poweredOff: VcHostSystemPowerState;
-	readonly unknown: VcHostSystemPowerState;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostSystemPowerState): VcHostSystemPowerState;
+	toString: () => string;
 }
 
-declare class VcHostActiveDirectoryInfoDomainMembershipStatus {
-	readonly inconsistentTrust: VcHostActiveDirectoryInfoDomainMembershipStatus;
-	readonly otherProblem: VcHostActiveDirectoryInfoDomainMembershipStatus;
-	readonly serverTrustBroken: VcHostActiveDirectoryInfoDomainMembershipStatus;
-	readonly name: string;
-	readonly noServers: VcHostActiveDirectoryInfoDomainMembershipStatus;
+declare class VcHostActiveDirectoryInfoDomainMembershipStatus implements IPseudoEnum {
+	static readonly inconsistentTrust: VcHostActiveDirectoryInfoDomainMembershipStatus & EnumVal<'inconsistentTrust'>;
+	static readonly otherProblem: VcHostActiveDirectoryInfoDomainMembershipStatus & EnumVal<'otherProblem'>;
+	static readonly serverTrustBroken: VcHostActiveDirectoryInfoDomainMembershipStatus & EnumVal<'serverTrustBroken'>;
+	static readonly noServers: VcHostActiveDirectoryInfoDomainMembershipStatus & EnumVal<'noServers'>;
+	static readonly ok: VcHostActiveDirectoryInfoDomainMembershipStatus & EnumVal<'ok'>;
+	static readonly clientTrustBroken: VcHostActiveDirectoryInfoDomainMembershipStatus & EnumVal<'clientTrustBroken'>;
+	static readonly unknown: VcHostActiveDirectoryInfoDomainMembershipStatus & EnumVal<'unknown'>;
+	static fromString(value: string): VcHostActiveDirectoryInfoDomainMembershipStatus & EnumVal<TcleanKeys<typeof VcHostActiveDirectoryInfoDomainMembershipStatus>>;
+
 	readonly id: string;
-	readonly ok: VcHostActiveDirectoryInfoDomainMembershipStatus;
-	readonly clientTrustBroken: VcHostActiveDirectoryInfoDomainMembershipStatus;
+	readonly name: string;
 	readonly value: string;
-	readonly unknown: VcHostActiveDirectoryInfoDomainMembershipStatus;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostActiveDirectoryInfoDomainMembershipStatus): VcHostActiveDirectoryInfoDomainMembershipStatus;
+	toString: () => string;
 }
 
-declare class VcPropertyChangeOp {
-	readonly add: VcPropertyChangeOp;
-	readonly indirectRemove: VcPropertyChangeOp;
-	readonly name: string;
+declare class VcPropertyChangeOp implements IPseudoEnum {
+	static readonly add: VcPropertyChangeOp & EnumVal<'add'>;
+	static readonly indirectRemove: VcPropertyChangeOp & EnumVal<'indirectRemove'>;
+	static readonly remove: VcPropertyChangeOp & EnumVal<'remove'>;
+	static readonly assign: VcPropertyChangeOp & EnumVal<'assign'>;
+	static fromString(value: string): VcPropertyChangeOp & EnumVal<TcleanKeys<typeof VcPropertyChangeOp>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly remove: VcPropertyChangeOp;
-	readonly assign: VcPropertyChangeOp;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcPropertyChangeOp): VcPropertyChangeOp;
+	toString: () => string;
 }
 
 /**
  * Sensor Types for specific hardware component are either based on
  * class of sensor or what the sensor monitors to allow for grouping
  */
-declare class VcHostNumericSensorType {
-	readonly other: VcHostNumericSensorType;
-	readonly memory: VcHostNumericSensorType;
-	readonly bios: VcHostNumericSensorType;
-	readonly storage: VcHostNumericSensorType;
-	readonly battery: VcHostNumericSensorType;
-	readonly processor: VcHostNumericSensorType;
-	readonly voltage: VcHostNumericSensorType;
-	readonly fan: VcHostNumericSensorType;
-	readonly systemBoard: VcHostNumericSensorType;
-	readonly watchdog: VcHostNumericSensorType;
-	readonly temperature: VcHostNumericSensorType;
-	readonly name: string;
-	readonly power: VcHostNumericSensorType;
+declare class VcHostNumericSensorType implements IPseudoEnum {
+	static readonly other: VcHostNumericSensorType & EnumVal<'other'>;
+	static readonly memory: VcHostNumericSensorType & EnumVal<'memory'>;
+	static readonly bios: VcHostNumericSensorType & EnumVal<'bios'>;
+	static readonly storage: VcHostNumericSensorType & EnumVal<'storage'>;
+	static readonly battery: VcHostNumericSensorType & EnumVal<'battery'>;
+	static readonly processor: VcHostNumericSensorType & EnumVal<'processor'>;
+	static readonly voltage: VcHostNumericSensorType & EnumVal<'voltage'>;
+	static readonly fan: VcHostNumericSensorType & EnumVal<'fan'>;
+	static readonly systemBoard: VcHostNumericSensorType & EnumVal<'systemBoard'>;
+	static readonly watchdog: VcHostNumericSensorType & EnumVal<'watchdog'>;
+	static readonly temperature: VcHostNumericSensorType & EnumVal<'temperature'>;
+	static readonly power: VcHostNumericSensorType & EnumVal<'power'>;
+	static readonly cable: VcHostNumericSensorType & EnumVal<'cable'>;
+	static fromString(value: string): VcHostNumericSensorType & EnumVal<TcleanKeys<typeof VcHostNumericSensorType>>;
+
 	readonly id: string;
-	readonly cable: VcHostNumericSensorType;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcHostNumericSensorType): VcHostNumericSensorType;
+	toString: () => string;
 }
 
 /**
  * The RecordReplayState type defines a simple set of record and replay
  * states for a virtual machine.
  */
-declare class VcVirtualMachineRecordReplayState {
-	readonly inactive: VcVirtualMachineRecordReplayState;
-	readonly name: string;
-	readonly recording: VcVirtualMachineRecordReplayState;
+declare class VcVirtualMachineRecordReplayState implements IPseudoEnum {
+	static readonly inactive: VcVirtualMachineRecordReplayState & EnumVal<'inactive'>;
+	static readonly recording: VcVirtualMachineRecordReplayState & EnumVal<'recording'>;
+	static readonly replaying: VcVirtualMachineRecordReplayState & EnumVal<'replaying'>;
+	static fromString(value: string): VcVirtualMachineRecordReplayState & EnumVal<TcleanKeys<typeof VcVirtualMachineRecordReplayState>>;
+
 	readonly id: string;
+	readonly name: string;
 	readonly value: string;
-	readonly replaying: VcVirtualMachineRecordReplayState;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachineRecordReplayState): VcVirtualMachineRecordReplayState;
+	toString: () => string;
 }
 
 /**
  * The teaming health check match status.
  */
-declare class VcVMwareDVSTeamingMatchStatus {
-	readonly nonIphashMismatch: VcVMwareDVSTeamingMatchStatus;
-	readonly name: string;
-	readonly nonIphashMatch: VcVMwareDVSTeamingMatchStatus;
+declare class VcVMwareDVSTeamingMatchStatus implements IPseudoEnum {
+	static readonly nonIphashMismatch: VcVMwareDVSTeamingMatchStatus & EnumVal<'nonIphashMismatch'>;
+	static readonly nonIphashMatch: VcVMwareDVSTeamingMatchStatus & EnumVal<'nonIphashMatch'>;
+	static readonly iphashMatch: VcVMwareDVSTeamingMatchStatus & EnumVal<'iphashMatch'>;
+	static readonly iphashMismatch: VcVMwareDVSTeamingMatchStatus & EnumVal<'iphashMismatch'>;
+	static fromString(value: string): VcVMwareDVSTeamingMatchStatus & EnumVal<TcleanKeys<typeof VcVMwareDVSTeamingMatchStatus>>;
+
 	readonly id: string;
-	readonly iphashMatch: VcVMwareDVSTeamingMatchStatus;
+	readonly name: string;
 	readonly value: string;
-	readonly iphashMismatch: VcVMwareDVSTeamingMatchStatus;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVMwareDVSTeamingMatchStatus): VcVMwareDVSTeamingMatchStatus;
+	toString: () => string;
 }
 
 /**
  * Set of possible values for {@link vim.vm.FlagInfo#snapshotPowerOffBehavior}.
  */
-declare class VcVirtualMachinePowerOffBehavior {
-	readonly take: VcVirtualMachinePowerOffBehavior;
-	readonly powerOff: VcVirtualMachinePowerOffBehavior;
-	readonly name: string;
-	readonly revert: VcVirtualMachinePowerOffBehavior;
+declare class VcVirtualMachinePowerOffBehavior implements IPseudoEnum {
+	static readonly take: VcVirtualMachinePowerOffBehavior & EnumVal<'take'>;
+	static readonly powerOff: VcVirtualMachinePowerOffBehavior & EnumVal<'powerOff'>;
+	static readonly revert: VcVirtualMachinePowerOffBehavior & EnumVal<'revert'>;
+	static readonly prompt: VcVirtualMachinePowerOffBehavior & EnumVal<'prompt'>;
+	static fromString(value: string): VcVirtualMachinePowerOffBehavior & EnumVal<TcleanKeys<typeof VcVirtualMachinePowerOffBehavior>>;
+
 	readonly id: string;
-	readonly prompt: VcVirtualMachinePowerOffBehavior;
+	readonly name: string;
 	readonly value: string;
 	private constructor();
-	/**
-	 * @param value 
-	 */
-	fromString(value: VcVirtualMachinePowerOffBehavior): VcVirtualMachinePowerOffBehavior;
+	toString: () => string;
 }
 
 declare class VcManagedObjectReference {
@@ -236315,4 +235911,4 @@ declare class VcVirtualMachineVirtualNumaInfo {
 	 * @param vnumaOnCpuHotaddExposed
 	 */
 	VcVirtualMachineVirtualNumaInfo(coresPerNumaNode: number, autoCoresPerNumaNode: boolean, vnumaOnCpuHotaddExposed: boolean): VcVirtualMachineVirtualNumaInfo
-}
\ No newline at end of file
+}