vim_rs 0.4.4

/// Possible values:
/// - `Alarm`
/// - `AlarmManager`
/// - `AuthorizationManager`
/// - `CertificateManager`
/// - `ClusterComputeResource`
/// - `ClusterEVCManager`
/// - `ClusterProfile`
/// - `ClusterProfileManager`
/// - `ComputeResource`
/// - `ContainerView`
/// - `CryptoManager`
/// - `CryptoManagerHost`
/// - `CryptoManagerHostKMS`
/// - `CryptoManagerKmip`
/// - `CustomFieldsManager`
/// - `CustomizationSpecManager`
/// - `Datacenter`
/// - `Datastore`
/// - `DatastoreNamespaceManager`
/// - `DiagnosticManager`
/// - `DirectPathProfileManager`: ***Since:*** vSphere API Release 9.0.0.0
/// - `DistributedVirtualPortgroup`
/// - `DistributedVirtualSwitch`
/// - `DistributedVirtualSwitchManager`
/// - `EnvironmentBrowser`
/// - `EventHistoryCollector`
/// - `EventManager`
/// - `ExtensibleManagedObject`
/// - `ExtensionManager`
/// - `FailoverClusterConfigurator`
/// - `FailoverClusterManager`
/// - `FileManager`
/// - `Folder`
/// - `GuestAliasManager`
/// - `GuestAuthManager`
/// - `GuestFileManager`
/// - `GuestOperationsManager`
/// - `GuestProcessManager`
/// - `GuestWindowsRegistryManager`
/// - `HealthUpdateManager`
/// - `HistoryCollector`
/// - `HostAccessManager`
/// - `HostActiveDirectoryAuthentication`
/// - `HostAssignableHardwareManager`
/// - `HostAuthenticationManager`
/// - `HostAuthenticationStore`
/// - `HostAutoStartManager`
/// - `HostBootDeviceSystem`
/// - `HostCacheConfigurationManager`
/// - `HostCertificateManager`
/// - `HostCpuSchedulerSystem`
/// - `HostDatastoreBrowser`
/// - `HostDatastoreSystem`
/// - `HostDateTimeSystem`
/// - `HostDiagnosticSystem`
/// - `HostDirectoryStore`
/// - `HostEsxAgentHostManager`
/// - `HostFirewallSystem`
/// - `HostFirmwareSystem`
/// - `HostGraphicsManager`
/// - `HostHealthStatusSystem`
/// - `HostImageConfigManager`
/// - `HostKernelModuleSystem`
/// - `HostLocalAccountManager`
/// - `HostLocalAuthentication`
/// - `HostMemorySystem`
/// - `HostNetworkSystem`
/// - `HostNvdimmSystem`
/// - `HostPatchManager`
/// - `HostPciPassthruSystem`
/// - `HostPowerSystem`
/// - `HostProfile`
/// - `HostProfileManager`
/// - `HostServiceSystem`
/// - `HostSnmpSystem`
/// - `HostSpecificationManager`
/// - `HostStorageSystem`
/// - `HostSystem`
/// - `HostVFlashManager`
/// - `HostVMotionSystem`
/// - `HostVStorageObjectManager`
/// - `HostVirtualNicManager`
/// - `HostVsanHealthSystem`
/// - `HostVsanInternalSystem`
/// - `HostVsanSystem`
/// - `HttpNfcLease`
/// - `InventoryView`
/// - `IoFilterManager`
/// - `IpPoolManager`
/// - `IscsiManager`
/// - `LicenseAssignmentManager`
/// - `LicenseManager`
/// - `ListView`
/// - `LocalizationManager`
/// - `ManagedEntity`
/// - `ManagedObjectView`
/// - `MessageBusProxy`
/// - `Network`
/// - `OpaqueNetwork`
/// - `OptionManager`
/// - `OverheadMemoryManager`
/// - `OvfManager`
/// - `PerformanceManager`
/// - `Profile`
/// - `ProfileComplianceManager`
/// - `ProfileManager`
/// - `PropertyCollector`
/// - `PropertyFilter`
/// - `ResourcePlanningManager`
/// - `ResourcePool`
/// - `ScheduledTask`
/// - `ScheduledTaskManager`
/// - `SearchIndex`
/// - `ServiceInstance`
/// - `ServiceManager`
/// - `SessionManager`
/// - `SimpleCommand`
/// - `SiteInfoManager`
/// - `StoragePod`
/// - `StorageQueryManager`
/// - `StorageResourceManager`
/// - `Task`
/// - `TaskHistoryCollector`
/// - `TaskManager`
/// - `TenantTenantManager`
/// - `UserDirectory`
/// - `VStorageObjectManagerBase`
/// - `VcenterVStorageObjectManager`
/// - `View`
/// - `ViewManager`
/// - `VimClusterVsanVcDiskManagementSystem`
/// - `VimClusterVsanVcStretchedClusterSystem`
/// - `VirtualApp`
/// - `VirtualDiskManager`
/// - `VirtualMachine`
/// - `VirtualMachineCompatibilityChecker`
/// - `VirtualMachineGuestCustomizationManager`
/// - `VirtualMachineProvisioningChecker`
/// - `VirtualMachineSnapshot`
/// - `VirtualizationManager`
/// - `VmwareDistributedVirtualSwitch`
/// - `VsanCapabilitySystem`
/// - `VsanClusterHealthSystem`
/// - `VsanClusterMgmtInternalSystem`
/// - `VsanIscsiTargetSystem`
/// - `VsanObjectSystem`
/// - `VsanPerformanceManager`
/// - `VsanSpaceReportSystem`
/// - `VsanSystemEx`
/// - `VsanUpgradeSystem`
/// - `VsanUpgradeSystemEx`
/// - `VsanVcClusterConfigSystem`
/// - `VsanVcClusterHealthSystem`
/// - `VsanVcsaDeployerSystem`
/// - `Agency`
/// - `Agent`
/// - `EamObject`
/// - `EamTask`
/// - `EsxAgentManager`
/// - `PbmCapabilityMetadataManager`
/// - `PbmComplianceManager`
/// - `PbmPlacementSolver`
/// - `PbmProfileProfileManager`
/// - `PbmProvider`
/// - `PbmReplicationManager`
/// - `PbmServiceInstance`
/// - `PbmSessionManager`
/// - `SmsProvider`
/// - `SmsServiceInstance`
/// - `SmsSessionManager`
/// - `SmsStorageManager`
/// - `SmsTask`
/// - `VasaProvider`
/// - `ManagedObject`
/// - `CnsVolumeManager`
/// - `HostSpbm`
/// - `VsanClusterPowerSystem`
/// - `VsanDiagnosticsSystem`
/// - `VsanFileServiceSystem`
/// - `VsanHostVdsSystem`
/// - `VsanIoInsightManager`
/// - `VsanMassCollector`
/// - `VsanObjectManager`: ***Since:*** 8.0.0.4
/// - `VsanPhoneHomeSystem`
/// - `VsanPolicyManager`
/// - `VsanRemoteDatastoreSystem`
/// - `VsanResourceCheckSystem`
/// - `VsanUpdateManager`
/// - `VsanVdsSystem`
/// - `VsanVumSystem`
/// - `VslmServiceInstance`
/// - `VslmSessionManager`
/// - `VslmStorageLifecycleManager`
/// - `VslmTask`
/// - `VslmVStorageObjectManager`
///
/// ### How to access
/// - `Alarm::info.alarm.r#type`
/// - `Alarm::info.entity.r#type`
/// - `ClusterComputeResource::add_host_task().r#type`
/// - `ClusterComputeResource::add_host_task(resource_pool).r#type`
/// - `ClusterComputeResource::configure_hci_task().r#type`
/// - `ClusterComputeResource::destroy_task().r#type`
/// - `ClusterComputeResource::add_host_task(spec).vm_folder?.r#type`
/// - `AlarmManager::acknowledge_alarm(alarm).r#type`
/// - `AlarmManager::acknowledge_alarm(entity).r#type`
/// - `AlarmManager::create_alarm().r#type`
/// 
/// *(10 of 98 paths)*
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum MoTypesEnum {
    Alarm,
    AlarmManager,
    AuthorizationManager,
    CertificateManager,
    ClusterComputeResource,
    ClusterEvcManager,
    ClusterProfile,
    ClusterProfileManager,
    ComputeResource,
    ContainerView,
    CryptoManager,
    CryptoManagerHost,
    CryptoManagerHostKms,
    CryptoManagerKmip,
    CustomFieldsManager,
    CustomizationSpecManager,
    Datacenter,
    Datastore,
    DatastoreNamespaceManager,
    DiagnosticManager,
    DirectPathProfileManager,
    DistributedVirtualPortgroup,
    DistributedVirtualSwitch,
    DistributedVirtualSwitchManager,
    EnvironmentBrowser,
    EventHistoryCollector,
    EventManager,
    ExtensibleManagedObject,
    ExtensionManager,
    FailoverClusterConfigurator,
    FailoverClusterManager,
    FileManager,
    Folder,
    GuestAliasManager,
    GuestAuthManager,
    GuestFileManager,
    GuestOperationsManager,
    GuestProcessManager,
    GuestWindowsRegistryManager,
    HealthUpdateManager,
    HistoryCollector,
    HostAccessManager,
    HostActiveDirectoryAuthentication,
    HostAssignableHardwareManager,
    HostAuthenticationManager,
    HostAuthenticationStore,
    HostAutoStartManager,
    HostBootDeviceSystem,
    HostCacheConfigurationManager,
    HostCertificateManager,
    HostCpuSchedulerSystem,
    HostDatastoreBrowser,
    HostDatastoreSystem,
    HostDateTimeSystem,
    HostDiagnosticSystem,
    HostDirectoryStore,
    HostEsxAgentHostManager,
    HostFirewallSystem,
    HostFirmwareSystem,
    HostGraphicsManager,
    HostHealthStatusSystem,
    HostImageConfigManager,
    HostKernelModuleSystem,
    HostLocalAccountManager,
    HostLocalAuthentication,
    HostMemorySystem,
    HostNetworkSystem,
    HostNvdimmSystem,
    HostPatchManager,
    HostPciPassthruSystem,
    HostPowerSystem,
    HostProfile,
    HostProfileManager,
    HostServiceSystem,
    HostSnmpSystem,
    HostSpecificationManager,
    HostStorageSystem,
    HostSystem,
    HostVFlashManager,
    HostVMotionSystem,
    HostVStorageObjectManager,
    HostVirtualNicManager,
    HostVsanHealthSystem,
    HostVsanInternalSystem,
    HostVsanSystem,
    HttpNfcLease,
    InventoryView,
    IoFilterManager,
    IpPoolManager,
    IscsiManager,
    LicenseAssignmentManager,
    LicenseManager,
    ListView,
    LocalizationManager,
    ManagedEntity,
    ManagedObjectView,
    MessageBusProxy,
    Network,
    OpaqueNetwork,
    OptionManager,
    OverheadMemoryManager,
    OvfManager,
    PerformanceManager,
    Profile,
    ProfileComplianceManager,
    ProfileManager,
    PropertyCollector,
    PropertyFilter,
    ResourcePlanningManager,
    ResourcePool,
    ScheduledTask,
    ScheduledTaskManager,
    SearchIndex,
    ServiceInstance,
    ServiceManager,
    SessionManager,
    SimpleCommand,
    SiteInfoManager,
    StoragePod,
    StorageQueryManager,
    StorageResourceManager,
    Task,
    TaskHistoryCollector,
    TaskManager,
    TenantTenantManager,
    UserDirectory,
    VStorageObjectManagerBase,
    VcenterVStorageObjectManager,
    View,
    ViewManager,
    VimClusterVsanVcDiskManagementSystem,
    VimClusterVsanVcStretchedClusterSystem,
    VirtualApp,
    VirtualDiskManager,
    VirtualMachine,
    VirtualMachineCompatibilityChecker,
    VirtualMachineGuestCustomizationManager,
    VirtualMachineProvisioningChecker,
    VirtualMachineSnapshot,
    VirtualizationManager,
    VmwareDistributedVirtualSwitch,
    VsanCapabilitySystem,
    VsanClusterHealthSystem,
    VsanClusterMgmtInternalSystem,
    VsanIscsiTargetSystem,
    VsanObjectSystem,
    VsanPerformanceManager,
    VsanSpaceReportSystem,
    VsanSystemEx,
    VsanUpgradeSystem,
    VsanUpgradeSystemEx,
    VsanVcClusterConfigSystem,
    VsanVcClusterHealthSystem,
    VsanVcsaDeployerSystem,
    Agency,
    Agent,
    EamObject,
    EamTask,
    EsxAgentManager,
    PbmCapabilityMetadataManager,
    PbmComplianceManager,
    PbmPlacementSolver,
    PbmProfileProfileManager,
    PbmProvider,
    PbmReplicationManager,
    PbmServiceInstance,
    PbmSessionManager,
    SmsProvider,
    SmsServiceInstance,
    SmsSessionManager,
    SmsStorageManager,
    SmsTask,
    VasaProvider,
    ManagedObject,
    CnsVolumeManager,
    HostSpbm,
    VsanClusterPowerSystem,
    VsanDiagnosticsSystem,
    VsanFileServiceSystem,
    VsanHostVdsSystem,
    VsanIoInsightManager,
    VsanMassCollector,
    VsanObjectManager,
    VsanPhoneHomeSystem,
    VsanPolicyManager,
    VsanRemoteDatastoreSystem,
    VsanResourceCheckSystem,
    VsanUpdateManager,
    VsanVdsSystem,
    VsanVumSystem,
    VslmServiceInstance,
    VslmSessionManager,
    VslmStorageLifecycleManager,
    VslmTask,
    VslmVStorageObjectManager,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration of reason codes representing the invalid data protection states.
/// 
/// Possible values:
/// - `protectionDegraded`: Data protection of one or more disks associated with the protected entity is degraded.
///   
///   The data protection must be disabled and re-enabled in order to have data protection supported.
/// - `notProtected`
/// - `invalidProtectionReasonUnknown`: A fallback value used when a client sees an unknown InvalidProtectionReason.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DpInvalidProtectionReasonEnum {
    ProtectionDegraded,
    NotProtected,
    InvalidProtectionReasonUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Indicates the type of migration that is in progress for a
/// *DpProtectedEntity*.
/// 
/// Possible values:
/// - `coldMigration`: A cold migration is in progress.
/// - `hotMigration`: A hot migration is in progress.
/// - `migrationTypeUnknown`: The value to be used when the older version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DpMigrationTypeEnum {
    ColdMigration,
    HotMigration,
    MigrationTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Indicates the protection status for the *DpProtectedEntity*.
/// 
/// Possible values:
/// - `pe_protected`: The ProtectedEntity is protected by vSphere Data Protection.
/// - `pe_unprotected`: The ProtectedEntity is not protected by vSphere Data Protection.
/// - `pe_partially_protected`: Only some elements of the ProtectedEntity are protected by vSphere Data Protection.
///   
///   For example, if only some disks of a *DpVirtualMachineProtectedEntity* are protected.
/// - `ProtectionStatusType_unknown`: Represents value when the lower version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DpProtectionStatusTypeEnum {
    PeProtected,
    PeUnprotected,
    PePartiallyProtected,
    ProtectionStatusTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Indicates if the cluster supports vSphere Data Protection.
/// 
/// Possible values:
/// - `supported`: The LWD VAIO filter is installed on all hosts in the cluster.
///   
///   The cluster supports data protection.
/// - `partially_supported`: The LWD VAIO filter is installed on some hosts in the cluster.
///   
///   If protection in enabled on an entity, it cannot migrate to other nodes in the cluster until all the nodes have the filter installed.
/// - `not_supported`: The LWD VAIO filter is not installed on any of the hosts in the cluster.
///   
///   Entities cannot be protected in this cluster.
/// - `ProtectionSupportType_unknown`: Represents value when the lower version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DpProtectionSupportTypeEnum {
    Supported,
    PartiallySupported,
    NotSupported,
    ProtectionSupportTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Indicates the type of snapshot taken on a given protected entity.
/// 
/// Possible values:
/// - `crashConsistent`: Crash Consistent snapshot.
/// - `applicationConsistent`: Application Consistent snapshot.
///   
///   Generally used for linux GOS to run pre-freeze and post-thaw scripts.
/// - `vssAppConsistentFull`: 
///   
///   Deprecated as of vSphere API 8.0 release. There is no replacement as this value is unused. VSS Application Consistent Snapshot whereby a full backup is requested regardless of whether files have been marked as backed up or not. Correlates to VSS\_BT\_FULL. Applicable only for windows VMs.
///   
///   This is deprecated.
/// - `vssAppConsistentCopy`: 
///   
///   Deprecated as of vSphere API 8.0 release. There is no replacement as this value is unused. VSS Application Consistent Snapshot whereby files on disk will be copied regardless of the state of each file's backup history, and the backup history will not be updated. Correlates to VSS\_BT\_COPY. Applicable only for windows VMs.
///   
///   This is deprecated.
/// - `metadataOnly`: Metadata only snapshot is similar to a crash consistent snapshot, with the exception that COW operation is not performed on snapshot extents of a 'metadataOnly' snapshot.
///   
///   It is generally used for restore operations like 'In-place' restore and 'Failback'.
/// - `vssAppConsistent`
/// - `snapshotTypeUnknown`: The value to be used when the older version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DpSnapshotTypeEnum {
    CrashConsistent,
    ApplicationConsistent,
    VssAppConsistentFull,
    VssAppConsistentCopy,
    MetadataOnly,
    VssAppConsistent,
    SnapshotTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Indicates the type of sync operation to perform on a given protected entity.
/// 
/// Possible values:
/// - `fullSync`: Full sync.
///   
///   Transfer all allocated data.
/// - `deltaSync`: Delta sync.
///   
///   Transfer changed blocks since the last sync operation.
/// - `syncTypeUnknown`: The value to be used when the older version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DpSyncTypeEnum {
    FullSync,
    DeltaSync,
    SyncTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration of vSphere Data Protection capabilities (features).
/// 
/// Possible values:
/// - `QueryPeInfo`: Support for QueryProtectedEntityInfo API.
///   
///   Required minimal ESX vmodl version: '7.0.3.0'.
/// - `PerDiskBaseSnapshotId`: Support for specifying per-disk base-snapshot ID when taking a vSphere Data Protection snapshot.
///   
///   Required minimal ESX vmodl version: '8.0.0.1'.
/// - `QuiescedSnapshot`: Support for vSphere Data Protection application consistent and quiesced snapshots.
///   
///   Required minimal ESX vmodl version: '8.0.1.0'.
/// - `RuntimeStats`: Support for querying DPD runtime stats with the QueryProtectedEntityInfo API.
///   
///   Required minimal ESX vmodl version: '8.0.1.0'.
/// - `PreservedExtents`: Support for DataIntegrity specific params (v1) when taking vSphere Data Protection snapshots.
///   
///   Required minimal ESX vmodl version: '8.0.1.0', and ESX version of '8.0.1' and patch level of at least '0.25'.
/// - `MultiPe`: Support for multi-PE consistency groups.
///   
///   Required minimal ESX vmodl version: '8.0.2.0'.
/// - `VsanNativeSnapshot`: Support for VSAN native snapshots.
///   
///   Required minimal ESX vmodl version: '8.0.3.0'.
/// - `SparseDiskEnhancement`: Enhancement for vSphere Data Protection operations over sparse disks.
///   
///   Required minimal ESX vmodl version: '8.0.3.0'.
/// - `VSphereDpCapabilities_Unknown`: Fallback value for an unknown VSphereDataProtectionCapabilities seen by a client.
///   
/// ***Since:*** 8.0.0.4
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DpVSphereDataProtectionCapabilitiesEnum {
    QueryPeInfo,
    PerDiskBaseSnapshotId,
    QuiescedSnapshot,
    RuntimeStats,
    PreservedExtents,
    MultiPe,
    VsanNativeSnapshot,
    SparseDiskEnhancement,
    VSphereDpCapabilitiesUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Indicates the backup context to be used for a VSS snapshot.
/// 
/// Applicable only
/// for windows VMs. Refer to `VSS_SNAPSHOT_CONTEXT` enumeration on MSDN.
/// 
/// Possible values:
/// - `vssBackupContextAuto`: This option lets the guest automatically select the right backup context among the values below.
/// - `vssBackupContextBackup`: This correlates to `VSS_CTX_BACKUP`.
///   
///   It specifies that a shadow copy should be created by involving VSS writers to quiesce their respective application's data. A shadow copy created under this context has auto-release, non-persistent attributes: in other words, it is deleted upon the termination of a backup operation.
/// - `vssBackupContextFileShareBackup`: This correlates to `VSS_CTX_FILE_SHARE_BACKUP`.
///   
///   It specifies that a shadow copy should be created without involving any VSS writer. A shadow copy created under this context has auto-release, non-persistent attributes: in other words, it is deleted upon the termination of a backup operation.
/// - `vssBackupContextUnknown`: The value to be used when the older version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DpVssBackupContextEnum {
    VssBackupContextAuto,
    VssBackupContextBackup,
    VssBackupContextFileShareBackup,
    VssBackupContextUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Indicates the backup type for a VSS snapshot.
/// 
/// Applicable only for windows
/// VMs. Refer to `VSS_BACKUP_TYPE` enumeration on MSDN.
/// 
/// Possible values:
/// - `vssBackupTypeFull`: This correlates to `VSS_BT_FULL`, whereby a full backup is requested, regardless of whether files have been marked as backed up or not.
/// - `vssBackupTypeCopy`: This correlates to `VSS_BT_COPY`, whereby files on disk will be copied, regardless of the state of each file's backup history, and the backup history will not be updated.
/// - `vssBackupTypeUnknown`: The value to be used when the older version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DpVssBackupTypeEnum {
    VssBackupTypeFull,
    VssBackupTypeCopy,
    VssBackupTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration of the support level for a cluster in terms of vSphere Data
/// Protection capabilities.
/// 
/// Possible values:
/// - `supported`: The capability is supported on all hosts in the cluster.
/// - `partially_supported`: The capability is supported on only some but not all of the hosts in the cluster.
/// - `not_supported`: The capability is not supported on any of the hosts in the cluster.
/// - `CapabilitySupportLevel_unknown`: Fallback value for an unknown CapabilitySupportLevel seen by a client.
///   
/// ***Since:*** 8.0.0.4
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DpCapabilitySupportLevelEnum {
    Supported,
    PartiallySupported,
    NotSupported,
    CapabilitySupportLevelUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration of type of SRM workflow.
/// 
/// Possible values:
/// - `test_failover`: A test failover workflow.
/// - `cleanup_test`: Clean up after a test failover.
/// - `failover`: A failover workflow.
/// - `reprotect`: A reprotect workflow.
/// - `srmWorkflowUnknown`: A fallback value used when a client sees an unknown SrmWorkflow.
///   
/// ***Since:*** 8.0.0.4
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DpDrSrmWorkflowEnum {
    TestFailover,
    CleanupTest,
    Failover,
    Reprotect,
    SrmWorkflowUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Deprecated as of vSphere 9.0. Please refer to vLCM System VMs APIs.
/// 
/// Defines if the deployed VMs needs to run on different hosts.
/// 
/// Possible values:
/// - `none`: Denotes no specific VM anti-affinity policy.
/// - `soft`: Best effort is made the VMs to run on different hosts as long as
///   this does not impact the ability of the host to satisfy current CPU
///   or memory requirements for virtual machines on the system.
///   
///   NOTE: Currently not supported - i.e. the agency configuration is
///   considered as invalid.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum AgencyVmPlacementPolicyVmAntiAffinityEnum {
    None,
    Soft,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Deprecated as of vSphere 9.0. Please refer to vLCM System VMs APIs.
/// 
/// Defines if the deployed VM is affinied to run on the same host it is
/// deployed on.
/// 
/// Possible values:
/// - `none`: Denotes no specific VM data affinity policy.
/// - `soft`: Best effort is made the VM to run on the same host it is deployed on
///   as long as this does not impact the ability of the host to satisfy
///   current CPU or memory requirements for virtual machines on the
///   system.
///   
///   NOTE: Currently not supported - i.e. the agency configuration is
///   considered as invalid.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum AgencyVmPlacementPolicyVmDataAffinityEnum {
    None,
    Soft,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Deprecated as of vSphere 9.0. Please refer to vLCM APIs.
/// 
/// Supported authentication schemes used to access an OVF URL.
/// 
/// Possible values:
/// - `NONE`: Accessing the OVF URL doesn't require authentication.
/// - `VMWARE_SESSION_ID`: Accessing the OVF URL requires Vmware client sessionID.
///   
/// ***Since:*** vEAM API 9.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum AgentConfigInfoAuthenticationSchemeEnum {
    None,
    VmwareSessionId,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Deprecated as of vSphere 9.0. Please refer to vLCM APIs.
/// 
/// Defines the type of disk provisioning for the target Agent VMs.
/// 
/// Possible values:
/// - `none`: Denotes no specific type for disk provisioning.
///   
///   Disks will be
///   provisioned as defaulted by vSphere.
/// - `thin`: Disks will be provisioned with only used space allocated.
/// - `thick`: Disks will be provisioned with full size allocated.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum AgentConfigInfoOvfDiskProvisioningEnum {
    None,
    Thin,
    Thick,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Represents the state of the VM lifecycle.
/// 
/// Possible values:
/// - `provisioned`: The VM is provisioned and not powered-on.
/// - `poweredOn`: The VM is powered on.
/// - `prePowerOn`: The VM is about to be powered on as part of a VM upgrade workflow.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum AgentVmHookVmStateEnum {
    Provisioned,
    PoweredOn,
    PrePowerOn,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Deprecated as of vSphere 9.0. Please refer to vLCM APIs.
/// 
/// The <code>GoalState</code> enumeration defines the goal of the entity.
/// 
/// Possible values:
/// - `enabled`: The entity should be fully deployed and active.
///   
///   If the entity is an
///   *Agency*, it should install VIBs and deploy and power on all agent
///   virtual machines. If the entity is an *Agent*, its VIB should be installed and its
///   agent virtual machine should be deployed and powered on.
/// - `disabled`: The entity should be fully deployed but inactive.
///   
///   f the entity is an
///   *Agency*, the behavior is similar to the <code>enabled</code> goal state, but
///   agents are not powered on (if they have been powered on they are powered
///   off).
/// - `uninstalled`: The entity should be completely removed from the vCenter Server.
///   
///   If the entity is an
///   *Agency*, no more VIBs or agent virtual machines are deployed. All installed VIBs
///   installed by the *Agency* are uninstalled and any deployed agent virtual machines
///   are powered off (if they have been powered on) and deleted.
///   If the entity is an *Agent*, its VIB is uninstalled and the virtual machine is
///   powered off and deleted.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum EamObjectRuntimeInfoGoalStateEnum {
    Enabled,
    Disabled,
    Uninstalled,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Deprecated as of vSphere 9.0. Please refer to vLCM APIs.
/// 
/// <code>Status</code> defines a health value that denotes how well the entity
/// conforms to the goal state.
/// 
/// Possible values:
/// - `green`: The entity is in perfect compliance with the goal state.
/// - `yellow`: The entity is actively working to reach the desired goal state.
/// - `red`: The entity has reached an issue which prevents it from reaching the desired goal
///   state.
///   
///   To remediate any offending issues, look at *EamObjectRuntimeInfo.issue*
///   and use either *EamObject.Resolve* or
///   *EamObject.ResolveAll*.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum EamObjectRuntimeInfoStatusEnum {
    Green,
    Yellow,
    Red,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Deprecated as of vSphere 9.0. Please refer to vLCM Image APIs.
/// 
/// <code>MaintenanceModePolicy</code> defines how ESX Agent Manager is going
/// to put into maintenance mode hosts which are part of a cluster not managed
/// by vSphere Lifecycle Manager.
/// 
/// Possible values:
/// - `singleHost`: Only a single host at a time will be put into maintenance mode.
/// - `multipleHosts`: Hosts will be put into maintenance mode simultaneously.
///   
///   If vSphere DRS
///   is enabled, its recommendations will be used. Otherwise, it will be
///   attempted to put in maintenance mode simultaneously as many host as
///   possible.
/// 
/// ***Since:*** vEAM API 7.4
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum EsxAgentManagerMaintenanceModePolicyEnum {
    SingleHost,
    MultipleHosts,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Supported types of hooks for agents.
/// 
/// Possible values:
/// - `POST_PROVISIONING`: Hook raised for an agent immediately after a Virtual Machine was
///   created.
/// - `POST_POWER_ON`: Hook raised for an agent immediately after a Virtual Machine was
///   powered on.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HooksHookTypeEnum {
    PostProvisioning,
    PostPowerOn,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Reasons solution is not valid for application.
/// 
/// Possible values:
/// - `INVALID_OVF_DESCRIPTOR`: The OVF descriptor provided in the VM source is invalid.
/// - `INACCESSBLE_VM_SOURCE`: The provided VM source is inaccessible from ESX Agent Manager.
/// - `INVALID_NETWORKS`: The provided networks are not suitable for application purposes.
/// - `INVALID_DATASTORES`: The provided datastores are not suitable for application purposes.
/// - `INVALID_RESOURCE_POOL`: The provided resource pool is not accessible or part of the cluster.
/// - `INVALID_FOLDER`: The provided folder is inaccessible or not part of the same datacenter
///   with the cluster.
/// - `INVALID_PROPERTIES`: The provided OVF properties are insufficient to satisfy the required
///   user configurable properties in the VM described in the vmSource.
/// - `INVALID_TRANSITION`: The legacy agency requested for transition is not valid/cannot be
///   mapped to systm Virtual Machines solution.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum SolutionsInvalidReasonEnum {
    InvalidOvfDescriptor,
    InaccessbleVmSource,
    InvalidNetworks,
    InvalidDatastores,
    InvalidResourcePool,
    InvalidFolder,
    InvalidProperties,
    InvalidTransition,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Describes possible reasons a solution is non compliant.
/// 
/// Possible values:
/// - `WORKING`: There is ongoing work to acheive the desired state.
/// - `ISSUE`: ESX Agent Manager has ecnountered am issue attempting to acheive the
///   desired state.
/// - `IN_HOOK`: ESX Agent Manager is awaiting user input to continue attempting to
///   acheive the desired state.
/// - `OBSOLETE_SPEC`: An obsoleted spec is currently in application for this solution.
///   
///   This state should take precedence over:
///   - *WORKING*
///   - *ISSUE*
///   - *IN_HOOK*
/// - `NO_SPEC`: Application for this solutiona has never been requested with
///   *Solutions.Apply*.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum SolutionsNonComplianceReasonEnum {
    Working,
    Issue,
    InHook,
    ObsoleteSpec,
    NoSpec,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Virtual Machine deployment optimization strategies.
/// 
/// Possible values:
/// - `ALL_CLONES`: Utilizes all cloning methods available, will create initial snapshots
///   on the Virtual Machines.
/// - `FULL_CLONES_ONLY`: Utilize only full copy cloning menthods, will create initial snapshots
///   on the Virtual Machines.
/// - `NO_CLONES`: Virtual Machiness will not be cloned from pre-existing deployment.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum SolutionsVmDeploymentOptimizationEnum {
    AllClones,
    FullClonesOnly,
    NoClones,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Provisioning types for system Virtual Machines.
/// 
/// Possible values:
/// - `THIN`: Disks will be provisioned with only used space allocated.
/// - `THICK`: Disks will be provisioned with full size allocated.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum SolutionsVmDiskProvisioningEnum {
    Thin,
    Thick,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines the DRS placement policies applied on the VMs.
/// 
/// Possible values:
/// - `VM_VM_ANTI_AFFINITY`: VMs are anti-affined to each other.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum SolutionsVmPlacementPolicyEnum {
    VmVmAntiAffinity,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This enum corresponds to the different packages whose logging
/// is configured independently by sps service.
/// 
/// Possible values:
/// - `pbm`: Modifies logging level of com.vmware.pbm package.
/// - `vslm`: Modifies logging level of com.vmware.vslm package.
/// - `sms`: Modifies logging level of com.vmware.vim.sms package.
/// - `spbm`: Modifies logging level of com.vmware.spbm package.
/// - `sps`: Modifies logging level of com.vmware.sps package.
/// - `httpclient_header`: Modifies logging level of httpclient wire header.
/// - `httpclient_content`: Modifies logging level of httpclient wire content.
/// - `vmomi`: Modifies logging level of com.vmware.vim.vmomi package.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PbmLoggingConfigurationComponentEnum {
    Pbm,
    Vslm,
    Sms,
    Spbm,
    Sps,
    HttpclientHeader,
    HttpclientContent,
    Vmomi,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This enum corresponds to the different log levels supported
/// by sps service.
/// 
/// Possible values:
/// - `INFO`: Refers to INFO level logging
/// - `DEBUG`: Refers to DEBUG level logging.
/// - `TRACE`: Refers to TRACE level logging.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PbmLoggingConfigurationLogLevelEnum {
    Info,
    Debug,
    Trace,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This enum corresponds to the keystores used by
/// sps.
/// 
/// Possible values:
/// - `SMS`: Refers to SMS keystore
/// - `TRUSTED_ROOTS`: Refers to TRUSTED\_ROOTS keystore.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PbmDebugManagerKeystoreNameEnum {
    Sms,
    TrustedRoots,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The *PbmObjectType_enum* enumerated type
/// defines vSphere Server object types that are known
/// to the Storage Policy Server.
/// 
/// See *PbmServerObjectRef*.*PbmServerObjectRef.objectType*.
/// 
/// Possible values:
/// - `virtualMachine`: Indicates a virtual machine, not including the disks, identified by the virtual machine
///   identifier _virtual-machine-mor_.
/// - `virtualMachineAndDisks`: Indicates the virtual machine and all its disks, identified by the virtual machine
///   identifier _virtual-machine-mor_.
/// - `virtualDiskId`: Indicates a virtual disk, identified by disk key
///   (_virtual-machine-mor_:_disk-key_).
/// - `virtualDiskUUID`: Indicates a virtual disk, identified by UUID - for First Class Storage Object support.
/// - `datastore`: Indicates a datastore.
/// - `vsanObjectId`: Indicates a VSAN object
/// - `fileShareId`: Indicates a file service
/// - `unknown`: Unknown object type.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PbmObjectTypeEnum {
    VirtualMachine,
    VirtualMachineAndDisks,
    VirtualDiskId,
    VirtualDiskUuid,
    Datastore,
    VsanObjectId,
    FileShareId,
    Unknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The *PbmVvolType_enum* enumeration type
/// defines VVOL types.
/// 
/// VvolType's are referenced to specify which objectType
/// to fetch for default capability.
/// 
/// Possible values:
/// - `Config`: meta-data volume
/// - `Data`: vmdk volume
/// - `Swap`: swap volume
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PbmVvolTypeEnum {
    Config,
    Data,
    Swap,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// List of operators that are supported for constructing policy.
/// 
/// Currently only tag based properties can use this operator.
/// Other operators can be added as required.
/// 
/// Possible values:
/// - `NOT`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PbmCapabilityOperatorEnum {
    Not,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Capability category type constants.
/// 
/// Possible values:
/// - `common`: Common and identical in all sub-profiles.
/// - `datastoreSpecific`: Part of a single sub-profile.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PbmCapabilitySchemaCapabilityCategoryEnum {
    Common,
    DatastoreSpecific,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Denotes the line of service of a schema.
/// 
/// Possible values:
/// - `INSPECTION`
/// - `COMPRESSION`
/// - `ENCRYPTION`
/// - `REPLICATION`
/// - `CACHING`
/// - `PERSISTENCE`
/// - `DATA_PROVIDER`
/// - `DATASTORE_IO_CONTROL`
/// - `DATA_PROTECTION`
/// - `STRETCHED_CLUSTER`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PbmLineOfServiceInfoLineOfServiceEnumEnum {
    Inspection,
    Compression,
    Encryption,
    Replication,
    Caching,
    Persistence,
    DataProvider,
    DatastoreIoControl,
    DataProtection,
    StretchedCluster,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The *PbmBuiltinGenericType_enum* enumerated type defines the list
/// of builtin generic datatypes.
/// 
/// See
/// *PbmCapabilityGenericTypeInfo*.*PbmCapabilityGenericTypeInfo.genericTypeName*.
/// 
/// A generic datatype indicates how to interpret a collection of values
/// of a specific datatype (*PbmCapabilityTypeInfo.typeName*).
/// 
/// Possible values:
/// - `VMW_RANGE`: Indicates a full or partial range of values (*PbmCapabilityRange*).
///   
///   A full range specifies both <code>min</code> and <code>max</code> values.
///   A partial range specifies one or the other, <code>min</code> or <code>max</code>.
/// - `VMW_SET`: Indicates a single value or a discrete set of values
///   (*PbmCapabilityDiscreteSet*).
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PbmBuiltinGenericTypeEnum {
    VmwRange,
    VmwSet,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The *PbmBuiltinType_enum* enumerated type defines datatypes
/// for storage profiles.
/// 
/// Property metadata
/// (*PbmCapabilityPropertyMetadata*) uses the builtin types
/// to define data types for storage capabilities and requirements.
/// It may also specify the semantics that are applied to a collection
/// of builtin type values. See *PbmCapabilityTypeInfo*.
/// These semantics are specified as a generic builtin type.
/// See *PbmCapabilityGenericTypeInfo*.
/// The type information determines how capability constraints are interpreted
/// *PbmCapabilityPropertyInstance.value*).
/// 
/// Possible values:
/// - `XSD_LONG`: Unsigned long value.
///   
///   This datatype supports the following constraint values.
///   - Single value
///   - Full or partial range of values (*PbmCapabilityRange*)
///   - Discrete set of values (*PbmCapabilityDiscreteSet*)
/// - `XSD_SHORT`: Datatype not supported.
/// - `XSD_INTEGER`: Datatype not supported.
///   
///   Use XSD\_INT instead.
/// - `XSD_INT`: Integer value.
///   
///   This datatype supports the following constraint values.
///   - Single value
///   - Full or partial range of values (*PbmCapabilityRange*)
///   - Discrete set of values (*PbmCapabilityDiscreteSet*)
/// - `XSD_STRING`: String value.
///   
///   This datatype supports a single value
///   or a discrete set of values (*PbmCapabilityDiscreteSet*).
/// - `XSD_BOOLEAN`: Boolean value.
/// - `XSD_DOUBLE`: Double precision floating point value.
///   
///   This datatype supports the following
///   constraint values.
///   - Single value
///   - Full or partial range of values (*PbmCapabilityRange*)
///   - Discrete set of values (*PbmCapabilityDiscreteSet*)
/// - `XSD_DATETIME`: Date and time value.
/// - `VMW_TIMESPAN`: Timespan value (*PbmCapabilityTimeSpan*).
///   
///   This datatype supports
///   the following constraint values.
///   - Single value
///   - Full or partial range of values (*PbmCapabilityRange*)
///   - Discrete set of values (*PbmCapabilityDiscreteSet*)
/// - `VMW_POLICY`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PbmBuiltinTypeEnum {
    XsdLong,
    XsdShort,
    XsdInteger,
    XsdInt,
    XsdString,
    XsdBoolean,
    XsdDouble,
    XsdDatetime,
    VmwTimespan,
    VmwPolicy,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The *PbmCapabilityTimeUnitType_enum* enumeration type
/// defines the supported list of time units for profiles that specify
/// time span capabilities and constraints.
/// 
/// See *PbmCapabilityTimeSpan*.
/// 
/// Possible values:
/// - `SECONDS`: Constraints and capabilities expressed in units of seconds.
/// - `MINUTES`: Constraints and capabilities expressed in units of minutes.
/// - `HOURS`: Constraints and capabilities expressed in units of hours.
/// - `DAYS`: Constraints and capabilities expressed in units of days.
/// - `WEEKS`: Constraints and capabilities expressed in units of weeks.
/// - `MONTHS`: Constraints and capabilities expressed in units of months.
/// - `YEARS`: Constraints and capabilities expressed in units of years.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PbmCapabilityTimeUnitTypeEnum {
    Seconds,
    Minutes,
    Hours,
    Days,
    Weeks,
    Months,
    Years,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The *PbmComplianceStatus_enum*
/// enumeration type defines the set of status values
/// for compliance operations.
/// 
/// See *PbmComplianceResult* and
/// *PbmRollupComplianceResult*.
/// 
/// Possible values:
/// - `compliant`: Entity is in compliance.
/// - `nonCompliant`: Entity is out of compliance.
/// - `unknown`: Compliance status of the entity is not known.
/// - `notApplicable`: Compliance computation is not applicable for this entity,
///   because it does not have any storage requirements that
///   apply to the object-based datastore on which this entity is placed.
/// - `outOfDate`: This is the same as *PbmComplianceResult.mismatch*
///   variable.
///   
///   Compliance status becomes out-of-date when the profile
///   associated with the entity is edited and not applied. The compliance
///   status will remain in out-of-date compliance status until the latest
///   policy is applied to the entity.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PbmComplianceStatusEnum {
    Compliant,
    NonCompliant,
    Unknown,
    NotApplicable,
    OutOfDate,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The *PbmComplianceResultComplianceTaskStatus_enum*
/// enumeration type defines the set of task status for compliance
/// operations.
/// 
/// See *PbmComplianceResult* and
/// *PbmRollupComplianceResult*.
/// 
/// Possible values:
/// - `inProgress`: Compliance calculation is in progress.
/// - `success`: Compliance calculation has succeeded.
/// - `failed`: Compliance calculation failed due to some exception.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PbmComplianceResultComplianceTaskStatusEnum {
    InProgress,
    Success,
    Failed,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The enumeration type defines the set of health status values for an entity
/// that is part of entity health operation.
/// 
/// Possible values:
/// - `red`: For file share: 'red' if the file server for this file share is in error
///   state or any of its backing vSAN objects are degraded.
///   
///   For FCD: 'red' if the datastore on which the FCD resides is not
///   accessible from any of the hosts it is mounted.
/// - `yellow`: For file share: 'yellow' if some backing objects are repairing, i.e.
///   
///   warning state.
///   For FCD: 'yellow' if the datastore on which the entity resides is
///   accessible only from some of the hosts it is mounted but not all.
/// - `green`: For file share: 'green' if the file server for this file share is
///   running properly and all its backing vSAN objects are healthy.
///   
///   For FCD: 'green' if the datastore on which the entity resides
///   is accessible from all the hosts it is mounted.
/// - `unknown`: If the health status of a file share is unknown, not valid for FCD.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PbmHealthStatusForEntityEnum {
    Red,
    Yellow,
    Green,
    Unknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `success`: Policy applied successfully.
/// - `failed`: Policy cannot be applied
/// - `invalid`: Policy cannot be applied
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PbmAssociateAndApplyPolicyStatusPolicyStatusEnum {
    Success,
    Failed,
    Invalid,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The *PbmProfileCategoryEnum_enum*
/// enumerated type defines the profile categories for a capability-based
/// storage profile.
/// 
/// See
/// *PbmCapabilityProfile*.
/// 
/// Possible values:
/// - `REQUIREMENT`: Indicates a storage requirement.
///   
///   Requirements are based on
///   storage capabilities.
/// - `RESOURCE`: Indicates a storage capability.
///   
///   Storage capabilities
///   are defined by storage providers.
/// - `DATA_SERVICE_POLICY`: Indicates a data service policy that can be embedded into
///   another storage policy.
///   
///   Policies of this type can't be assigned to
///   Virtual Machines or Virtual Disks.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PbmProfileCategoryEnumEnum {
    Requirement,
    Resource,
    DataServicePolicy,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// System pre-created profile types.
/// 
/// Possible values:
/// - `VsanDefaultProfile`: Indicates the system pre-created editable VSAN default profile.
/// - `VVolDefaultProfile`: Indicates the system pre-created non-editable default profile
///   for VVOL datastores.
/// - `PmemDefaultProfile`: 
///   
///   Deprecated as of vSphere 9.0 APIs with no replacement.
///   
///   Indicates the system pre-created non-editable default profile
///   for PMem datastores
/// - `VmcManagementProfile`: Indicates the system pre-created non-editable VMC default profile.
/// - `VsanMaxDefaultProfile`: Indicates the system pre-created non-editable VSANMAX default profile.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PbmSystemCreatedProfileTypeEnum {
    VsanDefaultProfile,
    VVolDefaultProfile,
    PmemDefaultProfile,
    VmcManagementProfile,
    VsanMaxDefaultProfile,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The *PbmOperation_enum* enumerated type
/// defines the provisioning operation being performed on the entity like FCD, virtual machine.
/// 
/// Possible values:
/// - `CREATE`: Indicates create operation of an entity.
/// - `REGISTER`: Indicates register operation of an entity.
/// - `RECONFIGURE`: Indicates reconfigure operation of an entity.
/// - `MIGRATE`: Indicates migrate operation of an entity.
/// - `CLONE`: Indicates clone operation of an entity.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PbmOperationEnum {
    Create,
    Register,
    Reconfigure,
    Migrate,
    Clone,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Recognized types of an IO Filter.
/// 
/// String constant used in `IofilterInfo#filterType`.
/// 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
/// 
/// Possible values:
/// - `INSPECTION`
/// - `COMPRESSION`
/// - `ENCRYPTION`
/// - `REPLICATION`
/// - `CACHE`
/// - `DATAPROVIDER`
/// - `DATASTOREIOCONTROL`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PbmIofilterInfoFilterTypeEnum {
    Inspection,
    Compression,
    Encryption,
    Replication,
    Cache,
    Dataprovider,
    Datastoreiocontrol,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Volume allocation type constants.
/// 
/// Possible values:
/// - `FullyInitialized`: Space required is fully allocated and initialized.
///   
///   It is wiped clean of any previous content on the
///   physical media. Gives faster runtime IO performance.
/// - `ReserveSpace`: Space required is fully allocated.
///   
///   It may contain
///   stale data on the physical media.
/// - `ConserveSpaceWhenPossible`: Space required is allocated and zeroed on demand
///   as the space is used.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PbmPolicyAssociationVolumeAllocationTypeEnum {
    FullyInitialized,
    ReserveSpace,
    ConserveSpaceWhenPossible,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The *PbmProfileResourceTypeEnum_enum* enumerated type defines the set of resource
/// types that are supported for profile management.
/// 
/// See *PbmProfileResourceType*.
/// 
/// Possible values:
/// - `STORAGE`: Indicates resources that support storage profiles.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PbmProfileResourceTypeEnumEnum {
    Storage,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The *PbmVmOperation_enum* enumerated type
/// defines the provisioning operation being performed on the virtual machine.
/// 
/// Possible values:
/// - `CREATE`: Indicates create operation of a virtual machine.
/// - `RECONFIGURE`: Indicates reconfigure operation of a virtual machine.
/// - `MIGRATE`: Indicates migrate operation of a virtual machine.
/// - `CLONE`: Indicates clone operation of a virtual machine.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PbmVmOperationEnum {
    Create,
    Reconfigure,
    Migrate,
    Clone,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Types of entities supported by the service.
/// 
/// Possible values:
/// - `datacenter`
/// - `resourcePool`
/// - `storagePod`
/// - `cluster`
/// - `vm`
/// - `datastore`
/// - `host`
/// - `vmFile`
/// - `scsiPath`
/// - `scsiTarget`
/// - `scsiVolume`
/// - `scsiAdapter`
/// - `nasMount`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum EntityReferenceEntityTypeEnum {
    Datacenter,
    ResourcePool,
    StoragePod,
    Cluster,
    Vm,
    Datastore,
    Host,
    VmFile,
    ScsiPath,
    ScsiTarget,
    ScsiVolume,
    ScsiAdapter,
    NasMount,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// List of possible states of a task.
/// 
/// Possible values:
/// - `queued`: Task is put in the queue.
/// - `running`: Task is currently running.
/// - `success`: Task has completed.
/// - `error`: Task has encountered an error or has been canceled.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum SmsTaskStateEnum {
    Queued,
    Running,
    Success,
    Error,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// A Category to indicate whether provider is of internal or external category.
/// 
/// This classification can help selectively enable few administrative functions
/// such as say unregistration of a provider.
/// 
/// Possible values:
/// - `internal`: An internal provider category indicates the set of providers such as IOFILTERS and VSAN.
/// - `external`: An external provider category indicates the set of providers are external and not belong
///   to say either of IOFILTERS or VSAN category.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VpCategoryEnum {
    Internal,
    External,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The status of the provider certificate
/// 
/// Possible values:
/// - `valid`: Provider certificate is valid.
/// - `expirySoftLimitReached`: Provider certificate is within the soft limit threshold.
/// - `expiryHardLimitReached`: Provider certificate is within the hard limit threshold.
/// - `expired`: Provider certificate has expired.
/// - `invalid`: Provider certificate is revoked, malformed or missing.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VasaProviderCertificateStatusEnum {
    Valid,
    ExpirySoftLimitReached,
    ExpiryHardLimitReached,
    Expired,
    Invalid,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Profiles supported by VASA Provider.
/// 
/// Possible values:
/// - `ProfileBasedManagement`: PBM profile
/// - `Replication`: Replication profile
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ProviderProfileEnum {
    ProfileBasedManagement,
    Replication,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// VASA Provider type.
/// 
/// Possible values:
/// - `PERSISTENCE`: Persistence provider.
/// - `DATASERVICE`: DataService provider.
///   
///   No storage supported for this type of provider.
/// - `UNKNOWN`: Type is unknown.
///   
///   VASA provider type can be UNKNOWN when it is undergoing sync operation.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VpTypeEnum {
    Persistence,
    Dataservice,
    Unknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Deprecated as of SMS API 3.0, use *VasaProfile_enum*.
/// 
/// Profiles supported by VASA Provider.
/// 
/// Possible values:
/// - `blockDevice`: Block device profile
/// - `fileSystem`: File system profile
/// - `capability`: Storage capability profile
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VasaProviderProfileEnum {
    BlockDevice,
    FileSystem,
    Capability,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The operational state of VASA Provider.
/// 
/// Possible values:
/// - `online`: VASA Provider is operating correctly.
/// - `offline`: VASA Provider is not responding, e.g.
///   
///   communication error due to temporary
///   network outage. SMS keeps polling the provider in this state.
/// - `syncError`: VASA Provider is connected, but sync operation failed.
/// - `unknown`: 
///   
///   Deprecated as of SMS API 4.0, this status is deprecated.
///   
///   VASA Provider is unreachable.
/// - `connected`: VASA Provider is connected, but has not triggered sync operation.
/// - `disconnected`: VASA Provider is disconnected, e.g.
///   
///   failed to establish a valid
///   SSL connection to the provider. SMS stops communication with the
///   provider in this state. The user can reconnect to the provider by invoking
///   *VasaProvider.VasaProviderReconnect_Task*.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VasaProviderStatusEnum {
    Online,
    Offline,
    SyncError,
    Unknown,
    Connected,
    Disconnected,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// VASA provider authentication type.
/// 
/// Possible values:
/// - `LoginByToken`: Login using SAML token.
/// - `UseSessionId`: Use id of an existing session that has logged-in from somewhere else.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VasaAuthenticationTypeEnum {
    LoginByToken,
    UseSessionId,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration of the supported Alarm Status values
/// 
/// Possible values:
/// - `Red`
/// - `Green`
/// - `Yellow`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum SmsAlarmStatusEnum {
    Red,
    Green,
    Yellow,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `SpaceCapacityAlarm`
/// - `CapabilityAlarm`
/// - `StorageObjectAlarm`
/// - `ObjectAlarm`
/// - `ComplianceAlarm`
/// - `ManageabilityAlarm`
/// - `ReplicationAlarm`
/// - `CertificateAlarm`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum AlarmTypeEnum {
    SpaceCapacityAlarm,
    CapabilityAlarm,
    StorageObjectAlarm,
    ObjectAlarm,
    ComplianceAlarm,
    ManageabilityAlarm,
    ReplicationAlarm,
    CertificateAlarm,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// List of possible BackingStoragePool types
/// 
/// Possible values:
/// - `thinProvisioningPool`
/// - `deduplicationPool`
/// - `thinAndDeduplicationCombinedPool`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum BackingStoragePoolTypeEnum {
    ThinProvisioningPool,
    DeduplicationPool,
    ThinAndDeduplicationCombinedPool,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration of the supported Entity Type values.
/// 
/// Possible values:
/// - `StorageArrayEntity`
/// - `StorageProcessorEntity`
/// - `StoragePortEntity`
/// - `StorageLunEntity`
/// - `StorageFileSystemEntity`
/// - `StorageCapabilityEntity`
/// - `CapabilitySchemaEntity`
/// - `CapabilityProfileEntity`
/// - `DefaultProfileEntity`
/// - `ResourceAssociationEntity`
/// - `StorageContainerEntity`
/// - `StorageObjectEntity`
/// - `MessageCatalogEntity`
/// - `ProtocolEndpointEntity`
/// - `VirtualVolumeInfoEntity`
/// - `BackingStoragePoolEntity`
/// - `FaultDomainEntity`
/// - `ReplicationGroupEntity`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum SmsEntityTypeEnum {
    StorageArrayEntity,
    StorageProcessorEntity,
    StoragePortEntity,
    StorageLunEntity,
    StorageFileSystemEntity,
    StorageCapabilityEntity,
    CapabilitySchemaEntity,
    CapabilityProfileEntity,
    DefaultProfileEntity,
    ResourceAssociationEntity,
    StorageContainerEntity,
    StorageObjectEntity,
    MessageCatalogEntity,
    ProtocolEndpointEntity,
    VirtualVolumeInfoEntity,
    BackingStoragePoolEntity,
    FaultDomainEntity,
    ReplicationGroupEntity,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// List of possible block device interfaces
/// 
/// Possible values:
/// - `fc`
/// - `iscsi`
/// - `fcoe`
/// - `otherBlock`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum BlockDeviceInterfaceEnum {
    Fc,
    Iscsi,
    Fcoe,
    OtherBlock,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// List of possible file system interfaces
/// 
/// Possible values:
/// - `nfs`
/// - `otherFileSystem`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum FileSystemInterfaceEnum {
    Nfs,
    OtherFileSystem,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// List of possible VASA profiles supported by Storage Array
/// 
/// Possible values:
/// - `blockDevice`: Block device profile
/// - `fileSystem`: File system profile
/// - `capability`: Storage capability profile
/// - `policy`: Policy profile
/// - `object`: Object based storage profile
/// - `statistics`: IO Statistics profile
/// - `storageDrsBlockDevice`: Storage DRS specific block device profile
/// - `storageDrsFileSystem`: Storage DRS specific file system profile
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VasaProfileEnum {
    BlockDevice,
    FileSystem,
    Capability,
    Policy,
    Object,
    Statistics,
    StorageDrsBlockDevice,
    StorageDrsFileSystem,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// List of supported VVOL Container types
/// 
/// Possible values:
/// - `NFS`
/// - `NFS4x`
/// - `SCSI`
/// - `NVMe`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum StorageContainerVvolContainerTypeEnumEnum {
    Nfs,
    Nfs4X,
    Scsi,
    NvMe,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `NFSV3_0`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum FileSystemInterfaceVersionEnum {
    Nfsv30,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// List of possible values for thin provisioning status alarm.
/// 
/// Possible values:
/// - `RED`
/// - `YELLOW`
/// - `GREEN`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ThinProvisioningStatusEnum {
    Red,
    Yellow,
    Green,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// State of the replication group at the site of the query.
/// 
/// A replication group
/// may be in different states at the source site and each of the target sites.
/// Note that this state does not capture the health of the replication link. If
/// necessary, that can be an additional attribute.
/// 
/// Possible values:
/// - `SOURCE`: Replication Source
/// - `TARGET`: Replication target
/// - `FAILEDOVER`: The group failed over at this site of the query.
///   
///   It has not yet been made
///   as a source of replication.
/// - `INTEST`: The group is InTest.
///   
///   The testFailover devices list will be available from
///   the *TargetGroupMemberInfo*
/// - `REMOTE_FAILEDOVER`: Remote group was failed over, and this site is neither the source nor the
///   target.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ReplicationReplicationStateEnum {
    Source,
    Target,
    Failedover,
    Intest,
    RemoteFailedover,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enum representing result of batch-APis.
/// 
/// Possible values:
/// - `success`
/// - `fail`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum BatchResultResultEnum {
    Success,
    Fail,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// HCIWorkflowState identifies the state of the cluser from the perspective of HCI
/// workflow.
/// 
/// The workflow begins with in\_progress mode and can transition
/// to 'done' or 'invalid', both of which are terminal states.
/// 
/// Possible values:
/// - `in_progress`: Indicates cluster is getting configured or will be configured.
/// - `done`: Indicates cluster configuration is complete.
/// - `invalid`: Indicates the workflow was abandoned on the cluster before the
///   configuration could complete.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ClusterComputeResourceHciWorkflowStateEnum {
    InProgress,
    Done,
    Invalid,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Deprecated as of vSphere 9.0 with no replacement. In a future release
/// of vSphere, the vCLS functionality will be disabled, vCLS
/// system VMs will be deleted, and vCLS APIs will be removed.
/// 
/// Do not use.
/// 
/// Possible values:
/// - `healthy`: Indicates vCS health status is normal.
/// - `degraded`: Indicates only vCS is unhealthy.
/// - `nonhealthy`: Indicates vCS is unhealthy and other cluster services are impacted.
///   
/// ***Since:*** vSphere API Release 7.0.1.1
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ClusterComputeResourceVcsHealthStatusEnum {
    Healthy,
    Degraded,
    Nonhealthy,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The SPBM(Storage Policy Based Management) license state for a host
/// 
/// Possible values:
/// - `licensed`: The host is licensed
/// - `unlicensed`: The host is not licensed
/// - `unknown`: The host license information is unknown, this could happen if the
///   host is not in a available state
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ComputeResourceHostSpbmLicenseInfoHostSpbmLicenseStateEnum {
    Licensed,
    Unlicensed,
    Unknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `bootstrap`
/// - `stateless`
/// 
/// ***Since:*** vSphere API Release 9.0.0.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ComputeResourceNetworkBootModeEnum {
    Bootstrap,
    Stateless,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Config spec operation type.
/// 
/// Possible values:
/// - `add`: Indicates the addition of an element to the configuration.
/// - `edit`: Indicates the change of an element in the configuration.
/// - `remove`: Indicates the removal of an element in the configuration.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ConfigSpecOperationEnum {
    Add,
    Edit,
    Remove,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `True`: Is accessible
/// - `False`: Is not accessible
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DatastoreAccessibleEnum {
    True,
    False,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The type of the sector size, such as, datastore and virtual disk,
/// for the 4k native disk/array support.
/// 
/// Possible values:
/// - `native_512`: 512 native sector size disk.
/// - `emulated_512`: 4K sector size disk in 512 emulation mode.
/// - `native_4k`: 4K native sector size disk.
///   
/// ***Since:*** vSphere API Release 9.0.0.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DatastoreSectorFormatEnum {
    Native512,
    Emulated512,
    Native4K,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines the current maintenance mode state of the datastore.
/// 
/// Possible values:
/// - `normal`: Default state.
/// - `enteringMaintenance`: Started entering maintenance mode, but not finished.
///   
///   This could happen when waiting for user input or for
///   long-running vmotions to complete.
/// - `inMaintenance`: Successfully entered maintenance mode.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DatastoreSummaryMaintenanceModeStateEnum {
    Normal,
    EnteringMaintenance,
    InMaintenance,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Pre-defined constants for possible creators of log files.
/// 
/// Possible values:
/// - `vpxd`: VirtualCenter service
/// - `vpxa`: VirtualCenter agent
/// - `hostd`: Host agent
/// - `serverd`: Host server agent
/// - `install`: Installation
/// - `vpxClient`: Virtual infrastructure client
/// - `recordLog`: System Record Log
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DiagnosticManagerLogCreatorEnum {
    Vpxd,
    Vpxa,
    Hostd,
    Serverd,
    Install,
    VpxClient,
    RecordLog,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Constants for defined formats.
/// 
/// For more information, see the comment for the format property.
/// 
/// Possible values:
/// - `plain`: A standard ASCII-based line-based log file.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DiagnosticManagerLogFormatEnum {
    Plain,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// List of possible host infrastructure traffic classes
/// 
/// Possible values:
/// - `management`: Management Traffic
/// - `faultTolerance`: Fault Tolerance (FT) Traffic
/// - `vmotion`: vMotion Traffic
/// - `virtualMachine`: Virtual Machine Traffic
/// - `iSCSI`: iSCSI Traffic
/// - `nfs`: NFS Traffic
/// - `hbr`: vSphere Replication (VR) Traffic
/// - `vsan`: vSphere Storage Area Network Traffic
/// - `vdp`: vSphere Data Protection - Backup Traffic
/// - `backupNfc`: vSphere Backup NFC Traffic
///   
///   ***Since:*** vSphere API Release 7.0.1.0
/// - `nvmetcp`: vSphere NVMETCP Traffic
///   
///   ***Since:*** vSphere API Release 7.0.3.0
/// - `provisioning`: vSphere Provisioning Traffic
///   
///   ***Since:*** vSphere API Release 9.0.0.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DistributedVirtualSwitchHostInfrastructureTrafficClassEnum {
    Management,
    FaultTolerance,
    Vmotion,
    VirtualMachine,
    IScsi,
    Nfs,
    Hbr,
    Vsan,
    Vdp,
    BackupNfc,
    Nvmetcp,
    Provisioning,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Network resource control version types.
/// 
/// Possible values:
/// - `version2`: Network Resource Control API version 2
/// - `version3`: Network Resource Control API version 3
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DistributedVirtualSwitchNetworkResourceControlVersionEnum {
    Version2,
    Version3,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// List of possible teaming modes supported by the vNetwork Distributed
/// Switch.
/// 
/// The different policy modes define the way traffic is routed
/// through the different uplink ports in a team.
/// 
/// Possible values:
/// - `loadbalance_ip`: Routing based on IP hash
/// - `loadbalance_srcmac`: Route based on source MAC hash
/// - `loadbalance_srcid`: Route based on the source of the port ID
/// - `failover_explicit`: Use explicit failover order
/// - `loadbalance_loadbased`: Routing based by dynamically balancing traffic through the NICs
///   in a team.
///   
///   This is the recommended teaming policy when the
///   network I/O control feature is enabled for the vNetwork
///   Distributed Switch.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DistributedVirtualSwitchNicTeamingPolicyModeEnum {
    LoadbalanceIp,
    LoadbalanceSrcmac,
    LoadbalanceSrcid,
    FailoverExplicit,
    LoadbalanceLoadbased,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The product spec operation types.
/// 
/// Possible values:
/// - `preInstall`: Push the switch's host component of the specified product info to the
///   host members of the switch at a fixed location known by the host.
/// - `upgrade`: Change the switch implementation to use the specified one.
///   
///   If the
///   property values in the specified product info are different from
///   those of the corresponding properties in the switch's product info,
///   a host component preinstall and switch upgrade will be performed.
/// - `notifyAvailableUpgrade`: Set the product information for an available switch upgrade that
///   would be done by the switch implementation.
///   
///   This operation will post
///   a config issue on the switch to signal the availability of an upgrade.
///   This operation is applicable only in the case when switch policy
///   *DVSPolicy.autoUpgradeAllowed*
///   is set to false.
/// - `proceedWithUpgrade`: If productSpec is set to be same as that in the
///   *DvsUpgradeAvailableEvent* configIssue, the switch
///   implementation will proceed with the upgrade.
///   
///   To reject or stop the
///   upgrade, leave the productSpec unset. If productSpec is set but does not
///   match that in *DvsUpgradeAvailableEvent* configIssue,
///   a fault will be raised.
///   This operation is applicable only in the case when switch policy
///   *DVSPolicy.autoUpgradeAllowed*
///   is set to false.
/// - `updateBundleInfo`: Update the bundle URL and ID information.
///   
///   If other properties in
///   the specified product info differ from the
///   corresponding properties of the switch's product info, a fault will
///   be thrown. Updating the bundle ID will result in installing the new host
///   component identified by the bundle ID.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DistributedVirtualSwitchProductSpecOperationTypeEnum {
    PreInstall,
    Upgrade,
    NotifyAvailableUpgrade,
    ProceedWithUpgrade,
    UpdateBundleInfo,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Correlation state as computed by storageRM
/// module on host.
/// 
/// Possible values:
/// - `Correlated`
/// - `Uncorrelated`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DrsInjectorWorkloadCorrelationStateEnum {
    Correlated,
    Uncorrelated,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `maintenance`: Add host in maintenance mode.
/// - `non_maintenance`: Add host in non-maintenance mode.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum FolderDesiredHostStateEnum {
    Maintenance,
    NonMaintenance,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Supported types of externally managed folder.
/// 
/// NSX Virtual Private Clouds(VPCs) is an abstraction layer that simplifies
/// setting up self-contained virtual private cloud networks within an NSX
/// project to consume networking and security services in a self-service
/// consumption model. It contains multiple subnets which represents an
/// independent layer 2 broadcast domain.
/// vCenter users can manage (create, update, delete) VPC and subnet under
/// *VPC_ROOT* folder. Requests are forwarded to NSX, and the VPCs
/// and subnets in NSX are realized as *VPC* and *SUBNET* folder
/// in vCenter.
/// A project in NSX is analogous to a tenant. NSX user can create VPC, segment,
/// and subnet within a project. These objects are represented as
/// *PROJECT*, *VPC*, *SEGMENT*, and *SUBNET* folder
/// under *PROJECT_ROOT* folder.
/// 
/// Possible values:
/// - `PROJECT_ROOT`: The root folder of *PROJECT* folders.
///   
///   It is a child of the network folder of a data center and
///   may contain multiple *PROJECT* folders.
/// - `PROJECT`: The folder representing a project in NSX.
///   
///   It is a child of the *PROJECT_ROOT* folder.
///   A project folder can contain multiple *VPC*,
///   and *SEGMENT* folders.
/// - `VPC_ROOT`: The folder containing VPC and subnet that can be managed by vCenter.
///   
///   It is a child of the network folder of a data center.
///   It may contain multiple *VPC* folders.
/// - `VPC`: The folder representing a VPC in NSX.
///   
///   It is a child of the *VPC_ROOT* folder or the *PROJECT*
///   folder.
///   It may contain multiple *SUBNET* folders.
/// - `SUBNET`: The folder representing a subnet in NSX.
///   
///   It is a child of the *VPC* folder.
/// - `SEGMENT`: The folder representing a segment in NSX.
///   
///   It is a child of the *PROJECT* folder.
/// - `SUPERVISOR`: The folder representing a vSphere IaaS Control Plane Supervisor.
///   
///   It is a VM\_TYPE folder and child of vSphere Namespaces Root folder.
///   It may contain multiple namespace associated folder, i.e., folder with
///   *Folder.namespace* property set and vSphere IaaS Control Plane
///   Virtual Machines.
/// - `VSPHERE_POD`: The folder containing vSphere Pods.
///   
///   It is a child of namespace associated folder, i.e., folder with
///   *Folder.namespace* property set and may contain vSphere Pods.
/// 
/// ***Since:*** vSphere API Release 9.0.0.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum FolderExternallyManagedFolderTypeEnum {
    ProjectRoot,
    Project,
    VpcRoot,
    Vpc,
    Subnet,
    Segment,
    Supervisor,
    VspherePod,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Describes the current state of a replicated *VirtualMachine*
/// 
/// Possible values:
/// - `none`: The *VirtualMachine* has no current replication state.
///   
///   This is a virtual machine that is configured for replication, but is
///   powered off and not undergoing offline replication.
/// - `paused`: The *VirtualMachine* replication is paused.
/// - `syncing`: One or more of the *VirtualMachine* disks is in the
///   process of an initial synchronization with the remote site.
/// - `idle`: The *VirtualMachine* is being replicated but is not
///   currently in the process of having a consistent instance created.
/// - `active`: The *VirtualMachine* is in the process of having
///   a consistent instance created.
/// - `error`: The *VirtualMachine* is unable to replicate due to
///   errors.
///   
///   XXX Currently unused.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ReplicationVmStateEnum {
    None,
    Paused,
    Syncing,
    Idle,
    Active,
    Error,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Quiescing is a boolean flag in *ReplicationConfigSpec*
/// and QuiesceModeType describes the supported quiesce mode
/// for *VirtualMachine*.
/// 
/// If application quiescing fails, HBR would attempt
/// filesystem quiescing and if even filesystem quiescing
/// fails, then we would just create a crash consistent
/// instance.
/// 
/// Possible values:
/// - `application`: HBR supports application quescing for this
///   *VirtualMachine*.
/// - `filesystem`: HBR supports filesystem quescing for this
///   *VirtualMachine*.
/// - `none`: HBR does not support quescing for this
///   *VirtualMachine*.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum QuiesceModeEnum {
    Application,
    Filesystem,
    None,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `Memory`
/// - `Power`
/// - `Fan`
/// - `Network`
/// - `Storage`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HealthUpdateInfoComponentTypeEnum {
    Memory,
    Power,
    Fan,
    Network,
    Storage,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines a host's connection state.
/// 
/// Possible values:
/// - `connected`: Connected to the server.
///   
///   For ESX Server, this is always the setting.
/// - `notResponding`: VirtualCenter is not receiving heartbeats from the server.
///   
///   The state
///   automatically changes to connected once heartbeats are received
///   again. This state is typically used to trigger an alarm on the host.
/// - `disconnected`: The user has explicitly taken the host down.
///   
///   VirtualCenter does not expect to
///   receive heartbeats from the host. The next time a heartbeat is received, the
///   host is moved to the connected state again and an event is logged.
///
/// ### How to access
/// - `HostSystem::runtime.connection_state`
/// - `HostSystem::summary.runtime?.connection_state`
/// - `HostSystem::query_host_connection_info().host.runtime?.connection_state`
/// - `Datacenter::query_connection_info().host.runtime?.connection_state`
/// - `Datacenter::query_connection_info_via_spec().host.runtime?.connection_state`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostSystemConnectionStateEnum {
    Connected,
    NotResponding,
    Disconnected,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines a host's encryption state
/// 
/// Possible values:
/// - `incapable`: The host is not safe for receiving sensitive material.
/// - `prepared`: The host is prepared for receiving sensitive material
///   but does not have a host key set yet.
/// - `safe`: The host is crypto safe and has a host key set.
/// - `pendingIncapable`: The host is explicitly crypto disabled and pending reboot to be
///   applied.
///   
///   When host is in this state, creating encrypted virtual
///   machines is not allowed, but still need a reboot to totally clean
///   up and enter incapable state.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostCryptoStateEnum {
    Incapable,
    Prepared,
    Safe,
    PendingIncapable,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines a host's power state.
/// 
/// Possible values:
/// - `poweredOn`: The host is powered on.
///   
///   A host that is entering standby mode
///   *entering* is also in this state.
/// - `poweredOff`: The host was specifically powered off by the user through
///   VirtualCenter.
///   
///   This state is not a cetain state, because
///   after VirtualCenter issues the command to power off the host,
///   the host might crash, or kill all the processes but fail to
///   power off.
/// - `standBy`: The host was specifically put in standby mode, either
///   explicitly by the user, or automatically by DPM.
///   
///   This state
///   is not a cetain state, because after VirtualCenter issues the
///   command to put the host in standby state, the host might
///   crash, or kill all the processes but fail to power off. A host
///   that is exiting standby mode *exiting*
///   is also in this state.
/// - `unknown`: If the host is disconnected, or notResponding, we cannot
///   possibly have knowledge of its power state.
///   
///   Hence, the host
///   is marked as unknown.
///
/// ### How to access
/// - `HostSystem::runtime.power_state`
/// - `HostSystem::summary.runtime?.power_state`
/// - `HostSystem::query_host_connection_info().host.runtime?.power_state`
/// - `Datacenter::query_connection_info().host.runtime?.power_state`
/// - `Datacenter::query_connection_info_via_spec().host.runtime?.power_state`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostSystemPowerStateEnum {
    PoweredOn,
    PoweredOff,
    StandBy,
    Unknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Valid state for host profile remediation.
/// 
/// Possible values:
/// - `remediationReady`: Before precheck remediation and remediation.
/// - `precheckRemediationRunning`: Preecheck remediation is running.
/// - `precheckRemediationComplete`: Preecheck remediation succeeded.
/// - `precheckRemediationFailed`: Preecheck remediation failed.
/// - `remediationRunning`: Remediation is running.
/// - `remediationFailed`: Remediation failed.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostSystemRemediationStateStateEnum {
    RemediationReady,
    PrecheckRemediationRunning,
    PrecheckRemediationComplete,
    PrecheckRemediationFailed,
    RemediationRunning,
    RemediationFailed,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines a host's standby mode.
/// 
/// Possible values:
/// - `entering`: The host is entering standby mode.
/// - `exiting`: The host is exiting standby mode.
/// - `in`: The host is in standby mode.
/// - `none`: The host is not in standy mode, and it is not
///   in the process of entering/exiting standby mode.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostStandbyModeEnum {
    Entering,
    Exiting,
    In,
    None,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// List of supported algorithms for checksum calculation.
/// 
/// Possible values:
/// - `sha1`
/// - `sha256`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HttpNfcLeaseManifestEntryChecksumTypeEnum {
    Sha1,
    Sha256,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// List of supported modes by HttpNfcLease
/// 
/// Possible values:
/// - `pushOrGet`: Client pushes or downloads individual files from/to
///   each host/url provided by this lease in *HttpNfcLease.info*
/// - `pull`: Mode where hosts itself pull files from source URLs.
///   
///   See *HttpNfcLease.HttpNfcLeasePullFromUrls_Task*
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HttpNfcLeaseModeEnum {
    PushOrGet,
    Pull,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// List of possible states of a lease.
/// 
/// Possible values:
/// - `initializing`: When the lease is being initialized.
/// - `ready`: When the lease is ready and disks may be transferred.
/// - `done`: When the import/export session is completed, and the lease
///   is no longer held.
/// - `error`: When an error has occurred.
///
/// ### How to access
/// - `HttpNfcLease::state`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HttpNfcLeaseStateEnum {
    Initializing,
    Ready,
    Done,
    Error,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines the type of an IO Filter.
/// 
/// Possible values:
/// - `cache`: Cache.
/// - `replication`: Replication.
/// - `encryption`: Encryption.
/// - `compression`: Compression.
/// - `inspection`: Inspection.
/// - `datastoreIoControl`: Datastore I/O Control.
/// - `dataProvider`: Data Provider.
/// - `dataCapture`: Lightweight Data Capture.
///   
///   ***Since:*** vSphere API Release 7.0.2.1
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum IoFilterTypeEnum {
    Cache,
    Replication,
    Encryption,
    Compression,
    Inspection,
    DatastoreIoControl,
    DataProvider,
    DataCapture,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines the type of operation for an IO Filter.
/// 
/// Possible values:
/// - `install`: Install an IO Filter.
/// - `uninstall`: Uninstall an IO Filter.
/// - `upgrade`: Upgrade an IO Filter.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum IoFilterOperationEnum {
    Install,
    Uninstall,
    Upgrade,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration of the nominal latency-sensitive values which can be
/// used to specify the latency-sensitivity level of the application.
/// 
/// In terms of latency-sensitivity the values relate:
/// high&gt;medium&gt;normal&gt;low.
/// 
/// Possible values:
/// - `low`: The relative latency-sensitivity low value.
/// - `normal`: The relative latency-sensitivity normal value.
///   
///   This is the default latency-sensitivity value.
/// - `medium`: The relative latency-sensitivity medium value.
/// - `high`: The relative latency-sensitivity high value.
/// - `custom`: 
///   
///   Deprecated as of vSphere API Ver 6.0. Value will be ignored and
///   treated as "normal" latency sensitivity.
///   
///   The custom absolute latency-sensitivity specified in
///   *LatencySensitivity.sensitivity* property is used to
///   define the latency-sensitivity.
///   
///   When this value is set to *LatencySensitivity.level* the
///   *LatencySensitivity.sensitivity* property should be
///   set also.
///
/// ### How to access
/// - `VirtualMachine::config.latency_sensitivity?.level`
/// - `VirtualMachine::config.vcpu_config?[*].latency_sensitivity?.level`
/// - `StoragePod::pod_storage_drs_entry.recommendation?[*].action?[*]→ClusterClusterInitialPlacementAction.config_spec?.latency_sensitivity?.level`
/// - `StoragePod::pod_storage_drs_entry.action_history?[*].action→ClusterClusterInitialPlacementAction.config_spec?.latency_sensitivity?.level`
/// - `StoragePod::pod_storage_drs_entry.recommendation?[*].action?[*]→ClusterClusterInitialPlacementAction.config_spec?.vcpu_config?[*].latency_sensitivity?.level`
/// - `StoragePod::pod_storage_drs_entry.action_history?[*].action→ClusterClusterInitialPlacementAction.config_spec?.vcpu_config?[*].latency_sensitivity?.level`
/// - `ClusterComputeResource::action_history.action→ClusterClusterInitialPlacementAction.config_spec?.latency_sensitivity?.level`
/// - `ClusterComputeResource::recommendation.action?[*]→ClusterClusterInitialPlacementAction.config_spec?.latency_sensitivity?.level`
/// - `ClusterComputeResource::action_history.action→ClusterClusterInitialPlacementAction.config_spec?.vcpu_config?[*].latency_sensitivity?.level`
/// - `ClusterComputeResource::recommendation.action?[*]→ClusterClusterInitialPlacementAction.config_spec?.vcpu_config?[*].latency_sensitivity?.level`
/// 
/// *(10 of 52 paths)*
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum LatencySensitivitySensitivityLevelEnum {
    Low,
    Normal,
    Medium,
    High,
    Custom,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Cost units apply to licenses for the purpose of determining
/// how many licenses are needed.
/// 
/// Possible values:
/// - `host`: One license is acquired per host.
/// - `cpuCore`: One license is acquired per CPU core.
/// - `cpuPackage`: One license is acquired per CPU package.
/// - `server`: One license is acquired per server.
/// - `vm`: One license is acquired per virtual machine.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum LicenseFeatureInfoUnitEnum {
    Host,
    CpuCore,
    CpuPackage,
    Server,
    Vm,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Some licenses may only be allowed to load from a specified source.
/// 
/// This enum indicates what restrictions exist for this license if any.
/// 
/// Possible values:
/// - `unrestricted`: The feature does not have a source restriction.
/// - `served`: The feature's license can only be served.
/// - `file`: The feature's license can only come from a file.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum LicenseFeatureInfoSourceRestrictionEnum {
    Unrestricted,
    Served,
    File,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Describes the state of the feature.
/// 
/// Possible values:
/// - `enabled`: The current edition license has implicitly enabled this additional feature.
/// - `disabled`: The current edition license does not allow this additional feature.
/// - `optional`: The current edition license allows this additional feature.
///   
///   The
///   *LicenseManager.EnableFeature* and *LicenseManager.DisableFeature* methods can be used to enable or disable
///   this feature.
///
/// ### How to access
/// - `LicenseManager::feature_info.state?`
/// - `LicenseManager::query_supported_features().state?`
/// - `LicenseManager::query_license_source_availability().feature.state?`
/// - `LicenseManager::query_license_usage().feature_info?[*].state?`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum LicenseFeatureInfoStateEnum {
    Enabled,
    Disabled,
    Optional,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Identifiers of currently supported resources.
/// 
/// Possible values:
/// - `numCpuPackages`: Number of CPU packages on this host.
/// - `numCpuCores`: Number of licensable CPU cores/compute-units on this host.
/// - `memorySize`: Total size of memory installed on this host, measured in kilobytes.
/// - `memoryForVms`: Total size of memory configured for VMs on this host, measured in kilobytes.
/// - `numVmsStarted`: Number of VMs already running on this host.
/// - `numVmsStarting`: Number of VMs that are currently powering-on, immigrating, etc.
/// - `vsanCapacity`: vSAN capacity in TiB on this host.
///   
///   ***Since:*** vSphere API Release 8.0.3.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostLicensableResourceKeyEnum {
    NumCpuPackages,
    NumCpuCores,
    MemorySize,
    MemoryForVms,
    NumVmsStarted,
    NumVmsStarting,
    VsanCapacity,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Deprecated as of VI API 2.5, use *LicenseManager.QueryLicenseSourceAvailability*
/// to obtain an array of *LicenseAvailabilityInfo* data
/// objects.
/// 
/// Licensed features have unique keys to identify them.
/// 
/// Possible values:
/// - `esxFull`: The edition license for the ESX Server, Standard edition.
///   
///   This is a per
///   CPU package license.
/// - `esxVmtn`: The edition license for the ESX server, VMTN edition.
///   
///   This is a per CPU package
///   license.
/// - `esxExpress`: The edition license for the ESX server, Starter edition.
///   
///   This is a per CPU
///   package license.
/// - `san`: Enable use of SAN.
///   
///   This is a per CPU package license.
/// - `iscsi`: Enable use of iSCSI.
///   
///   This is a per CPU package license.
/// - `nas`: Enable use of NAS.
///   
///   This is a per CPU package license.
/// - `vsmp`: Enable up to 4-way VSMP feature.
///   
///   This is a per CPU package license.
/// - `backup`: Enable ESX Server consolidated backup feature.
///   
///   This is a per CPU package
///   license.
/// - `vc`: The edition license for a VirtualCenter server, full edition.
///   
///   This license
///   is independent of the number of CPU packages for the VirtualCenter host.
/// - `vcExpress`: The edition license for a VirtualCenter server, starter edition.
///   
///   This license
///   limits the number of hosts (esxHost or serverHost) that can be managed by the
///   VirtualCenter product.
/// - `esxHost`: Enable VirtualCenter ESX Server host management functionality.
///   
///   This is a per
///   ESX server CPU package license.
/// - `gsxHost`: Enable VirtualCenter GSX Server host management functionality.
///   
///   This is a per
///   GSX server CPU package license.
/// - `serverHost`: Enable VirtualCenter VMware server host management functionality.
///   
///   This is a per
///   VMware server CPU package license.
/// - `drsPower`: Enable VirtualCenter DRS Power Management Functionality.
///   
///   This is a per CPU package
/// - `vmotion`: Enable VMotion.
///   
///   This is a per ESX server CPU package license.
/// - `drs`: Enable VirtualCenter Distributed Resource Scheduler.
///   
///   This is a per ESX server
///   CPU package license.
/// - `das`: Enable VirtualCenter HA.
///   
///   This is a per ESX server CPU package license.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum LicenseManagerLicenseKeyEnum {
    EsxFull,
    EsxVmtn,
    EsxExpress,
    San,
    Iscsi,
    Nas,
    Vsmp,
    Backup,
    Vc,
    VcExpress,
    EsxHost,
    GsxHost,
    ServerHost,
    DrsPower,
    Vmotion,
    Drs,
    Das,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Deprecated as of vSphere API 4.0, this is not used by the system.
/// 
/// State of licensing subsystem.
/// 
/// Possible values:
/// - `initializing`: Setting or resetting configuration in progress.
/// - `normal`: Running within operating parameters.
/// - `marginal`: License source unavailable, using license cache.
/// - `fault`: Initialization has failed or grace period expired.
///
/// ### How to access
/// - `LicenseManager::diagnostics.op_state`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum LicenseManagerStateEnum {
    Initializing,
    Normal,
    Marginal,
    Fault,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Describes the reservation state of a license.
/// 
/// Possible values:
/// - `notUsed`: This license is currently unused by the system, or the feature does not
///   apply.
///   
///   For example, a DRS license appears as NotUsed if the host is not
///   part of a DRS-enabled cluster.
/// - `noLicense`: This indicates that the license has expired or the system attempted to acquire
///   the license but was not successful in reserving it.
/// - `unlicensedUse`: The LicenseManager failed to acquire a license but the implementation
///   policy allows us to use the licensed feature anyway.
///   
///   This is possible, for
///   example, when a license server becomes unavailable after a license had been
///   successfully reserved from it.
/// - `licensed`: The required number of licenses have been acquired from the license source.
///
/// ### How to access
/// - `LicenseManager::query_license_usage().reservation_info?[*].state`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum LicenseReservationInfoStateEnum {
    NotUsed,
    NoLicense,
    UnlicensedUse,
    Licensed,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The Status enumeration defines a general "health" value for a managed entity.
/// 
/// Possible values:
/// - `gray`: The status is unknown.
/// - `green`: The entity is OK.
/// - `yellow`: The entity might have a problem.
/// - `red`: The entity definitely has a problem.
///
/// ### How to access
/// - `HostSystem::config_status`
/// - `HostSystem::overall_status`
/// - `HostSystem::declared_alarm_state.overall_status`
/// - `HostSystem::summary.overall_status`
/// - `HostSystem::triggered_alarm_state.overall_status`
/// - `Network::config_status`
/// - `Network::overall_status`
/// - `Network::declared_alarm_state.overall_status`
/// - `Network::triggered_alarm_state.overall_status`
/// - `DistributedVirtualPortgroup::config_status`
/// 
/// *(10 of 100 paths)*
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ManagedEntityStatusEnum {
    Gray,
    Green,
    Yellow,
    Red,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The type of an OST node.
/// 
/// Each OST node corresponds to an element in the OVF descriptor. See *OvfConsumerOstNode*
/// for a description of the different node types.
/// 
/// Possible values:
/// - `envelope`
/// - `virtualSystem`
/// - `virtualSystemCollection`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum OvfConsumerOstNodeTypeEnum {
    Envelope,
    VirtualSystem,
    VirtualSystemCollection,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Types of disk provisioning that can be set for the disk in the deployed OVF
/// package.
/// 
/// Possible values:
/// - `monolithicSparse`: A sparse (allocate on demand) monolithic disk.
///   
///   Disks in this format can
///   be used with other VMware products.
/// - `monolithicFlat`: A preallocated monolithic disk.
///   
///   Disks in this format can be used with
///   other VMware products.
/// - `twoGbMaxExtentSparse`: A sparse (allocate on demand) disk with 2GB maximum extent size.
///   
///   Disks in this format can be used with other VMware products. The 2GB
///   extent size makes these disks easier to burn to dvd or use on
///   filesystems that don't support large files.
/// - `twoGbMaxExtentFlat`: A preallocated disk with 2GB maximum extent size.
///   
///   Disks in this format
///   can be used with other VMware products. The 2GB extent size
///   makes these disks easier to burn to dvd or use on filesystems that
///   don't support large files.
/// - `thin`: Space required for thin-provisioned virtual disk is allocated and
///   zeroed on demand as the space is used.
/// - `thick`: A thick disk has all space allocated at creation time
///   and the space is zeroed on demand as the space is used.
/// - `seSparse`: A sparse (allocate on demand) format with additional space
///   optimizations.
/// - `eagerZeroedThick`: An eager zeroed thick disk has all space allocated and wiped clean
///   of any previous contents on the physical media at creation time.
///   
///   Such disks may take longer time during creation compared to other
///   disk formats.
/// - `sparse`: Depending on the host type, Sparse is mapped to either
///   MonolithicSparse or Thin.
/// - `flat`: Depending on the host type, Flat is mapped to either
///   MonolithicFlat or Thick.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum OvfCreateImportSpecParamsDiskProvisioningTypeEnum {
    MonolithicSparse,
    MonolithicFlat,
    TwoGbMaxExtentSparse,
    TwoGbMaxExtentFlat,
    Thin,
    Thick,
    SeSparse,
    EagerZeroedThick,
    Sparse,
    Flat,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Indicates how multiple samples of a specific counter type are
/// transformed into a single statistical value.
/// 
/// Possible values:
/// - `average`: The actual value collected or the average of all values collected
///   during the summary period.
/// - `maximum`: The maximum value of the performance counter value over the
///   summarization period.
/// - `minimum`: The minimum value of the performance counter value over the
///   summarization period.
/// - `latest`: The most recent value of the performance counter over the
///   summarization period.
/// - `summation`: The sum of all the values of the performance counter over the
///   summarization period.
/// - `none`: The counter is never rolled up.
///
/// ### How to access
/// - `PerformanceManager::perf_counter.rollup_type`
/// - `PerformanceManager::query_perf_counter().rollup_type`
/// - `PerformanceManager::query_perf_counter_by_level().rollup_type`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PerfSummaryTypeEnum {
    Average,
    Maximum,
    Minimum,
    Latest,
    Summation,
    None,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Indicates the type of statistical measurement that a counter&#146;s
/// value represents.
/// 
/// Valid types are &#147;absolute&#148;,
/// &#147;delta&#148;, or &#147;rate&#148;.
/// 
/// Possible values:
/// - `absolute`: Represents an actual value, level, or state of the counter.
///   
///   For
///   example, the &#147;uptime&#148; counter (**system** group)
///   represents the actual number of seconds since startup. The
///   &#147;capacity&#148; counter represents the actual configured size
///   of the specified datastore. In other words, number of samples,
///   samplingPeriod, and intervals have no bearing on an
///   &#147;absolute&#148; counter&#147;s value.
/// - `delta`: Represents an amount of change for the counter during the *PerfInterval.samplingPeriod* as compared to the previous
///   *interval*.
///   
///   The first sampling interval
/// - `rate`: Represents a value that has been normalized over the *PerfInterval.samplingPeriod*, enabling values for the same
///   counter type to be compared, regardless of interval.
///   
///   For example,
///   the number of reads per second.
///
/// ### How to access
/// - `PerformanceManager::perf_counter.stats_type`
/// - `PerformanceManager::query_perf_counter().stats_type`
/// - `PerformanceManager::query_perf_counter_by_level().stats_type`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PerfStatsTypeEnum {
    Absolute,
    Delta,
    Rate,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Indicates the unit of measure represented by a counter or statistical
/// value.
/// 
/// Possible values:
/// - `percent`: Percentage values in units of 1/100th of a percent.
///   
///   For example 100
///   represents 1%.
/// - `kiloBytes`: Kilobytes.
/// - `megaBytes`: Megabytes.
/// - `megaHertz`: Megahertz.
/// - `number`: A quantity of items, for example, the number of CPUs.
/// - `microsecond`: The time in microseconds.
/// - `millisecond`: The time in milliseconds.
/// - `second`: The time in seconds.
/// - `kiloBytesPerSecond`: Kilobytes per second.
/// - `megaBytesPerSecond`: Megabytes per second.
/// - `watt`: Watts
/// - `joule`: Joules
/// - `teraBytes`: Terabytes.
/// - `celsius`: Temperature in celsius.
/// - `nanosecond`: The time in nanoseconds.
///   
///   ***Since:*** vSphere API Release 8.0.0.1
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PerformanceManagerUnitEnum {
    Percent,
    KiloBytes,
    MegaBytes,
    MegaHertz,
    Number,
    Microsecond,
    Millisecond,
    Second,
    KiloBytesPerSecond,
    MegaBytesPerSecond,
    Watt,
    Joule,
    TeraBytes,
    Celsius,
    Nanosecond,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The format in which performance counter data is returned.
/// 
/// Possible values:
/// - `normal`: Counters returned in an array of data objects.
/// - `csv`: Counters returned in comma-separate value (CSV) format.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PerfFormatEnum {
    Normal,
    Csv,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines the type of placement
/// 
/// Possible values:
/// - `createAndPowerOn`: Create a new VM that should be powered-on in the near future.
/// - `reconfigure`: Reconfigure a powered-off or a powered-on VM.
/// - `relocate`: Relocate a powered-off or a powered-on VM.
///   
/// ***Since:*** vSphere API Release 9.0.0.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PlaceVmsXClusterSpecPlacementTypeEnum {
    CreateAndPowerOn,
    Reconfigure,
    Relocate,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `disabled`: Do not scale shares
/// - `scaleCpuAndMemoryShares`: Scale both CPU and memory shares
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ResourceConfigSpecScaleSharesBehaviorEnum {
    Disabled,
    ScaleCpuAndMemoryShares,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Types of a host's compatibility with a designated virtual machine
/// that is a candidate for VMotion.
/// 
/// Used with queryVMotionCompatibility
/// both as inputs (to designate which compatibility types to test for)
/// and as outputs (to specify which compatibility types apply for
/// each host).
/// 
/// Possible values:
/// - `cpu`: The host's CPU features are compatible with the
///   the virtual machine's requirements.
/// - `software`: The software platform on the host supports VMotion
///   and is compatible with the virtual machine.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VMotionCompatibilityTypeEnum {
    Cpu,
    Software,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Deprecated as of vSphere API 4.0, use *CheckTestType_enum* instead.
/// 
/// Types of tests available for validateMigration.
/// 
/// Possible values:
/// - `sourceTests`: Tests that examine only the configuration
///   of the virtual machine and its current host; the destination
///   resource pool and host or cluster are irrelevant.
/// - `compatibilityTests`: Tests that examine both the virtual
///   machine and the destination host or cluster; the destination
///   resource pool is irrelevant.
///   
///   This set excludes tests that fall
///   into the diskAccessibilityTests group.
/// - `diskAccessibilityTests`: Tests that check that the
///   destination host or cluster can see the datastores where the virtual
///   machine's virtual disks are currently located.
///   
///   The destination
///   resource pool is irrelevant. If you are planning to relocate the
///   virtual disks, do not use these tests; instead examine the relevant
///   datastore objects for your planned disk locations to see if they
///   are accessible to the destination host.
/// - `resourceTests`: Tests that check that the destination resource
///   pool can support the virtual machine if it is powered on.
///   
///   The
///   destination host or cluster is relevant because it will affect the
///   amount of overhead memory required to run the virtual machine.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ValidateMigrationTestTypeEnum {
    SourceTests,
    CompatibilityTests,
    DiskAccessibilityTests,
    ResourceTests,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `HttpNfcServiceTicket`: Ticket used for HttpNfc access to a file or disk on a datastore
/// - `HostServiceTicket`: Ticket used for service request on a host
/// - `VcServiceTicket`: Ticket used for service request on a VC
///   
/// ***Since:*** vSphere API Release 7.0.2.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum SessionManagerGenericServiceTicketTicketTypeEnum {
    HttpNfcServiceTicket,
    HostServiceTicket,
    VcServiceTicket,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// HTTP request methods.
/// 
/// Possible values:
/// - `httpOptions`
/// - `httpGet`
/// - `httpHead`
/// - `httpPost`
/// - `httpPut`
/// - `httpDelete`
/// - `httpTrace`
/// - `httpConnect`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum SessionManagerHttpServiceRequestSpecMethodEnum {
    HttpOptions,
    HttpGet,
    HttpHead,
    HttpPost,
    HttpPut,
    HttpDelete,
    HttpTrace,
    HttpConnect,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Simplified shares notation.
/// 
/// These designations have different meanings for different resources.
/// 
/// Possible values:
/// - `low`: For CPU: Shares = 500 \* number of virtual CPUs  
///   For Memory: Shares = 5 \* virtual machine memory size in megabytes  
///   For Disk: Shares = 500  
///   For Network: Shares = 0.25 \* *DVSFeatureCapability.networkResourcePoolHighShareValue*
/// - `normal`: For CPU: Shares = 1000 \* number of virtual CPUs  
///   For Memory: Shares = 10 \* virtual machine memory size in megabytes  
///   For Disk: Shares = 1000  
///   For Network: Shares = 0.5 \* *DVSFeatureCapability.networkResourcePoolHighShareValue*
/// - `high`: For CPU: Shares = 2000 \* number of virtual CPUs  
///   For Memory: Shares = 20 \* virtual machine memory size in megabytes  
///   For Disk: Shares = 2000  
///   For Network: Shares = *DVSFeatureCapability.networkResourcePoolHighShareValue*
/// - `custom`: If you specify <code>custom</code> for the *SharesInfo.level* property, when there is resource contention the Server uses the *SharesInfo.shares* value to determine resource allocation.
///
/// ### How to access
/// - `ClusterComputeResource::action_history.action→ClusterClusterInitialPlacementAction.config_spec?.cpu_allocation?.shares?.level`
/// - `ClusterComputeResource::action_history.action→ClusterClusterInitialPlacementAction.config_spec?.memory_allocation?.shares?.level`
/// - `ClusterComputeResource::recommendation.action?[*]→ClusterClusterInitialPlacementAction.config_spec?.cpu_allocation?.shares?.level`
/// - `ClusterComputeResource::recommendation.action?[*]→ClusterClusterInitialPlacementAction.config_spec?.memory_allocation?.shares?.level`
/// - `ClusterComputeResource::action_history.action→StoragePlacementAction.relocate_spec.device_change?[*].device→VirtualDisk.shares?.level`
/// - `DistributedVirtualSwitch::network_resource_pool.allocation_info.shares?.level`
/// - `DistributedVirtualSwitch::config.infrastructure_traffic_resource_config?[*].allocation_info.shares?.level`
/// - `DistributedVirtualSwitch::config.net_resource_pool_traffic_resource_config?[*].allocation_info.shares?.level`
/// - `Datastore::datastore_enter_maintenance_mode().recommendations?[*].action?[*]→ClusterClusterInitialPlacementAction.config_spec?.cpu_allocation?.shares?.level`
/// - `Datastore::datastore_enter_maintenance_mode().recommendations?[*].action?[*]→ClusterClusterInitialPlacementAction.config_spec?.memory_allocation?.shares?.level`
/// 
/// *(10 of 100 paths)*
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum SharesLevelEnum {
    Low,
    Normal,
    High,
    Custom,
    /// This variant handles values not known at compile time.
    Other_(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.
/// 
/// Possible values:
/// - `CSV`: Comma separated values
/// - `HEX`: Hex encoded binary data
/// - `STRING`
///
/// ### How to access
/// - `SimpleCommand::encoding_type`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum SimpleCommandEncodingEnum {
    Csv,
    Hex,
    String,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Deprecated as of vSphere8.0 U3, and there is no replacement for it.
/// 
/// User specification of congestion threshold mode on a given datastore
/// 
/// For more information, see
/// *StorageIORMInfo.congestionThreshold*
/// 
/// Possible values:
/// - `automatic`: Storagage IO Control will choose appropriate congestion threshold value
///   for that datastore to operate at given percentage of peak throughput.
///   
///   This is the default setting
/// - `manual`: Use user specified Storage IO Control congestion threshold value
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum StorageIormThresholdModeEnum {
    Automatic,
    Manual,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This option specifies how to select tasks based on child relationships
/// in the inventory hierarchy.
/// 
/// If a managed entity has children, their tasks
/// can be retrieved with this filter option.
/// 
/// Possible values:
/// - `self`: Returns tasks that pertain only to the specified managed entity,
///   and not its children.
/// - `children`: Returns tasks pertaining to child entities only.
///   
///   Excludes
///   tasks pertaining to the specified managed entity itself.
/// - `all`: Returns tasks pertaining either to the specified managed entity
///   or to its child entities.
///
/// ### How to access
/// - `TaskManager::read_next_tasks_by_view_spec(filter_spec).entity?.recursion`
/// - `TaskManager::create_collector_for_tasks(filter).entity?.recursion`
/// - `TaskManager::create_collector_with_info_filter_for_tasks(filter).entity?.recursion`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum TaskFilterSpecRecursionOptionEnum {
    Self_,
    Children,
    All,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This option specifies a time stamp governing the selection of tasks.
/// 
/// Possible values:
/// - `queuedTime`: The time stamp when the task was created and queued.
/// - `startedTime`: The time stamp when the task started.
/// - `completedTime`: The time stamp when the task finished.
///
/// ### How to access
/// - `TaskManager::read_next_tasks_by_view_spec(filter_spec).time?.time_type`
/// - `TaskManager::create_collector_for_tasks(filter).time?.time_type`
/// - `TaskManager::create_collector_with_info_filter_for_tasks(filter).time?.time_type`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum TaskFilterSpecTimeOptionEnum {
    QueuedTime,
    StartedTime,
    CompletedTime,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// List of possible states of a task.
/// 
/// Possible values:
/// - `queued`: When there are too many tasks for threads to handle.
/// - `running`: When the busy thread is freed from its current task by
///   finishing the task, it picks a queued task to run.
///   
///   Then the queued tasks are marked as running.
/// - `success`: When a running task has completed.
/// - `error`: When a running task has encountered an error.
///
/// ### How to access
/// - `Task::info.state`
/// - `ScheduledTask::info.state`
/// - `TaskHistoryCollector::latest_page.state`
/// - `Task::set_task_state(state)`
/// - `EventManager::post_event(task_info).state`
/// - `TaskHistoryCollector::read_next_tasks().state`
/// - `TaskHistoryCollector::read_previous_tasks().state`
/// - `TaskManager::read_next_tasks_by_view_spec().state`
/// - `TaskManager::read_next_tasks_by_view_spec(filter_spec).state?[*]`
/// - `TaskManager::create_collector_for_tasks(filter).state?[*]`
/// 
/// *(10 of 15 paths)*
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum TaskInfoStateEnum {
    Queued,
    Running,
    Success,
    Error,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The VAppState type defines the set of states a vApp can be
/// in.
/// 
/// The transitory states between started and stopped is modeled explicitly,
/// since the starting or stopping of a vApp is typically a time-consuming
/// process that might take minutes to complete.
/// 
/// Possible values:
/// - `started`: The vApp is currently powered on .
/// - `stopped`: The vApp is currently powered off or suspended.
/// - `starting`: The vApp is in the process of starting.
/// - `stopping`: The vApp is in the process of stopping.
///
/// ### How to access
/// - `ResourcePool::summary→VirtualAppSummary.v_app_state?`
/// - `VirtualApp::summary→VirtualAppSummary.v_app_state?`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualAppVAppStateEnum {
    Started,
    Stopped,
    Starting,
    Stopping,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The types of virtual disk adapters used by virtual disks
/// 
/// Possible values:
/// - `ide`: Use IDE emulation for the virtual disk
/// - `busLogic`: Use BusLogic emulation for the virtual disk
/// - `lsiLogic`: Use LSILogic emulation for the virtual disk
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualDiskAdapterTypeEnum {
    Ide,
    BusLogic,
    LsiLogic,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The types of virtual disks that can be created or cloned.
/// 
/// Possible values:
/// - `preallocated`: A preallocated disk has all space allocated at creation time
///   and the space is zeroed on demand as the space is used.
/// - `thin`: Space required for thin-provisioned virtual disk is allocated and
///   zeroed on demand as the space is used.
/// - `seSparse`: A sparse (allocate on demand) format with additional space
///   optimizations.
/// - `rdm`: Virtual compatibility mode raw disk mapping.
///   
///   An rdm virtual disk
///   grants access to the entire raw disk and the virtual disk can
///   participate in snapshots.
/// - `rdmp`: Physical compatibility mode (pass-through) raw disk mapping.
///   
///   An rdmp
///   virtual disk passes SCSI commands directly to the hardware, but the
///   virtual disk cannot participate in snapshots.
/// - `raw`: Raw device.
/// - `delta`: A redo log disk.
///   
///   This format is only applicable as a destination format
///   in a clone operation, and not usable for disk creation.
/// - `sparse2Gb`: A sparse disk with 2GB maximum extent size.
///   
///   Disks in this format
///   can be used with other VMware products. The 2GB extent size
///   makes these disks easier to burn to dvd or use on filesystems that
///   don't support large files. This format is only applicable as a
///   destination format in a clone operation, and not usable for disk
///   creation.
/// - `thick2Gb`: A thick disk with 2GB maximum extent size.
///   
///   Disks in this format
///   can be used with other VMware products. The 2GB extent size
///   makes these disks easier to burn to dvd or use on filesystems that
///   don't support large files. This format is only applicable as a
///   destination format in a clone operation, and not usable for disk
///   creation.
/// - `eagerZeroedThick`: An eager zeroed thick disk has all space allocated and wiped clean
///   of any previous contents on the physical media at creation time.
///   
///   Such disks may take longer time during creation compared to other
///   disk formats.
/// - `sparseMonolithic`: A sparse monolithic disk.
///   
///   Disks in this format can be used with other
///   VMware products. This format is only applicable as a destination
///   format in a clone operation, and not usable for disk creation.
/// - `flatMonolithic`: A preallocated monolithic disk.
///   
///   Disks in this format can be used with
///   other VMware products. This format is only applicable as a destination
///   format in a clone operation, and not usable for disk creation.
/// - `thick`: 
///   
///   Deprecated as of vSphere API 4.x, use *eagerZeroedThick* instead
///   for clustering application, and *preallocated* for other applications.
///   
///   A thick disk has all space allocated at creation time.
///   
///   This
///   space may contain stale data on the physical media. Thick disks
///   are primarily used for virtual machine clustering, but they are
///   generally insecure and should not be used. Due to better performance
///   and security properties, the use of the 'preallocated' format is
///   preferred over this format.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualDiskTypeEnum {
    Preallocated,
    Thin,
    SeSparse,
    Rdm,
    Rdmp,
    Raw,
    Delta,
    Sparse2Gb,
    Thick2Gb,
    EagerZeroedThick,
    SparseMonolithic,
    FlatMonolithic,
    Thick,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Application heartbeat status type.
/// 
/// Possible values:
/// - `appStatusGray`: Heartbeat status is disabled
/// - `appStatusGreen`: Heartbeat status is OK
/// - `appStatusRed`: Heartbeating has stopped
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineAppHeartbeatStatusTypeEnum {
    AppStatusGray,
    AppStatusGreen,
    AppStatusRed,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The connectivity state of a virtual machine.
/// 
/// When the API is provided directly by
/// a server product, such as ESX Server, then the disconnected state is not
/// possible. However, when accessed through VirtualCenter, the state of a virtual
/// machine is set to disconnected if the hosts that manage the virtual
/// machine becomes unavailable.
/// 
/// Possible values:
/// - `connected`: The server has access to the virtual machine.
/// - `disconnected`: The server is currently disconnected from the virtual machine, since its
///   host is disconnected.
///   
///   See general comment for this enumerated type for more
///   details.
/// - `orphaned`: The virtual machine is no longer registered on the host it is associated
///   with.
///   
///   For example, a virtual machine that is unregistered or deleted
///   directly on a host managed by VirtualCenter shows up in this state.
/// - `inaccessible`: One or more of the virtual machine configuration files are inaccessible.
///   
///   For
///   example, this can be due to transient disk failures. In this case, no
///   configuration can be returned for a virtual machine.
/// - `invalid`: The virtual machine configuration format is invalid.
///   
///   Thus, it is accessible
///   on disk, but corrupted in a way that does not allow the server to read the
///   content. In this case, no configuration can be returned for a virtual
///   machine.
///
/// ### How to access
/// - `VirtualMachine::runtime.connection_state`
/// - `VirtualMachine::summary.runtime.connection_state`
/// - `HostSystem::query_host_connection_info().vm?[*].runtime.connection_state`
/// - `Datacenter::query_connection_info().vm?[*].runtime.connection_state`
/// - `Datacenter::query_connection_info_via_spec().vm?[*].runtime.connection_state`
/// - `EnvironmentBrowser::query_config_target().usb?[*].summary?.runtime.connection_state`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineConnectionStateEnum {
    Connected,
    Disconnected,
    Orphaned,
    Inaccessible,
    Invalid,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The crypto state of a encrypted virtual machine.
/// 
/// Possible values:
/// - `unlocked`: The virtual machine is in unlocked state.
/// - `locked`: The virtual machine is in locked state for the configuration key missing
///   on the ESX host where the VM is registered.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineCryptoStateEnum {
    Unlocked,
    Locked,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The FaultToleranceState type defines a simple set of states for a
/// fault tolerant virtual machine:
/// disabled, starting, and enabled.
/// 
/// Possible values:
/// - `notConfigured`: This state indicates that the virtual machine has not been
///   configured for fault tolerance.
/// - `disabled`: For a virtual machine that is the primary in a fault tolerant group,
///   this state indicates that the virtual machine has at least one
///   registered secondary, but no secondary is enabled.
///   
///   For a virtual machine that is the secondary in a fault tolerant
///   group, this state indicates that the secondary is disabled.
/// - `enabled`: For a virtual machine that is the primary in a fault tolerant group,
///   this state indicates that the virtual machine is not currently
///   powered on, but has at least one enabled secondary
///   For a virtual machine that is the secondary in a fault tolerant
///   group, this state indicates that the secondary is enabled, but is
///   not currently powered on.
/// - `needSecondary`: For a virtual machine that is the primary in a fault tolerant group,
///   this state indicates that the virtual machine is powered on and
///   has at least one enabled secondary, but no secondary is currently
///   active.
///   
///   This state is not valid for a virtual machine that is a secondary
///   in a fault tolerant group.
/// - `starting`: For a virtual machine that is the primary in a fault tolerant group,
///   this state indicates that the virtual machine is powered on and has
///   at least one secondary that is synchronizing its state with the
///   primary.
///   
///   For a virtual machine that is the secondary in a fault tolerant
///   group, this state indicates that the secondary is powered on and is
///   synchronizing its state with the primary virtual machine.
/// - `running`: This state indicates that the virtual machine is running with fault
///   tolerance protection.
///
/// ### How to access
/// - `VirtualMachine::runtime.fault_tolerance_state`
/// - `VirtualMachine::summary.runtime.fault_tolerance_state`
/// - `HostSystem::query_host_connection_info().vm?[*].runtime.fault_tolerance_state`
/// - `Datacenter::query_connection_info().vm?[*].runtime.fault_tolerance_state`
/// - `Datacenter::query_connection_info_via_spec().vm?[*].runtime.fault_tolerance_state`
/// - `EnvironmentBrowser::query_config_target().usb?[*].summary?.runtime.fault_tolerance_state`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineFaultToleranceStateEnum {
    NotConfigured,
    Disabled,
    Enabled,
    NeedSecondary,
    Starting,
    Running,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The FaultToleranceType defines the type of fault tolerance, if any,
/// the virtual machine is configured for.
/// 
/// Possible values:
/// - `unset`: FT not set
/// - `recordReplay`: Record/replay
/// - `checkpointing`: Checkpointing
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineFaultToleranceTypeEnum {
    Unset,
    RecordReplay,
    Checkpointing,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// MovePriority is an enumeration of values that indicate the priority of the task
/// 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.
/// 
/// Possible values:
/// - `lowPriority`: The task of moving this virtual machine is low priority.
/// - `highPriority`: The task of moving this virtual machine is high priority.
/// - `defaultPriority`: The task of moving this virtual machine is the default priority.
///
/// ### How to access
/// - `VirtualMachine::migrate_vm_task(priority)`
/// - `VirtualMachine::relocate_vm_task(priority)`
/// - `ClusterComputeResource::place_vm(placement_spec).priority?`
/// - `StorageResourceManager::recommend_datastores(storage_spec).priority?`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineMovePriorityEnum {
    LowPriority,
    HighPriority,
    DefaultPriority,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The NeedSecondaryReason type defines all reasons a virtual machine is
/// in the needSecondary Fault Tolerance state following a failure.
/// 
/// Possible values:
/// - `initializing`: Initializing FT
/// - `divergence`: Divergence
/// - `lostConnection`: Lose connection to secondary
/// - `partialHardwareFailure`: Partial hardware failure
/// - `userAction`: Terminated by user
/// - `checkpointError`: Checkpoint error
/// - `other`: All other reasons
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineNeedSecondaryReasonEnum {
    Initializing,
    Divergence,
    LostConnection,
    PartialHardwareFailure,
    UserAction,
    CheckpointError,
    Other,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The PowerState type defines a simple set of states for a virtual machine:
/// poweredOn, poweredOff, and suspended.
/// 
/// This type does not model substates,
/// such as when a task is running to change the virtual machine state.
/// If the virtual machine is in a state with a task in progress, it
/// transitions to a new state when the task completes. For example, a virtual
/// machine continues to be in the poweredOn state while a suspend task
/// is running, and changes to the suspended state once the task finishes.
/// 
/// As a consequence of this approach, clients interested in monitoring
/// the status of a virtual machine should typically track the
/// *activeTask* data object in addition to the
/// *powerState* object.
/// 
/// Possible values:
/// - `poweredOff`: The virtual machine is currently powered off.
/// - `poweredOn`: The virtual machine is currently powered on.
/// - `suspended`: The virtual machine is currently suspended.
///
/// ### How to access
/// - `VirtualMachine::runtime.power_state`
/// - `VirtualMachine::snapshot.root_snapshot_list[*].state`
/// - `VirtualMachine::summary.runtime.power_state`
/// - `Agent::runtime.vm_power_state`
/// - `Agency::runtime→AgentRuntimeInfo.vm_power_state`
/// - `VirtualMachine::migrate_vm_task(state)`
/// - `HostSystem::query_host_connection_info().vm?[*].runtime.power_state`
/// - `Datacenter::query_connection_info().vm?[*].runtime.power_state`
/// - `Datacenter::query_connection_info_via_spec().vm?[*].runtime.power_state`
/// - `ServiceInstance::validate_migration(state)`
/// 
/// *(10 of 14 paths)*
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachinePowerStateEnum {
    PoweredOff,
    PoweredOn,
    Suspended,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Deprecated as of vSphere API 6.0.
/// 
/// The RecordReplayState type defines a simple set of record and replay
/// states for a virtual machine.
/// 
/// Possible values:
/// - `recording`: The virtual machine is recording.
/// - `replaying`: The virtual machine is replaying.
/// - `inactive`: The virtual machine is currently not participating
///   in record or replay.
///
/// ### How to access
/// - `VirtualMachine::runtime.record_replay_state`
/// - `VirtualMachine::summary.runtime.record_replay_state`
/// - `HostSystem::query_host_connection_info().vm?[*].runtime.record_replay_state`
/// - `Datacenter::query_connection_info().vm?[*].runtime.record_replay_state`
/// - `Datacenter::query_connection_info_via_spec().vm?[*].runtime.record_replay_state`
/// - `EnvironmentBrowser::query_config_target().usb?[*].summary?.runtime.record_replay_state`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineRecordReplayStateEnum {
    Recording,
    Replaying,
    Inactive,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The virtual machine ticket type.
/// 
/// Possible values:
/// - `mks`: 
///   
///   Deprecated as of vSphere API 8.0. Use *webmks* instead.
///   
///   Remote mouse-keyboard-screen ticket.
/// - `device`: 
///   
///   Deprecated as of vSphere 8.0 API. Use *webRemoteDevice*
///   instead.
///   
///   Remote device ticket.
/// - `guestControl`: 
///   
///   Deprecated as of vSphere 6.6.3 API. Use
///   *GuestOperationsManager* instead.
///   
///   Guest operation ticket.
/// - `webmks`: Mouse-keyboard-screen over WebSocket ticket.
///   
///   MKS protocol is VNC (a.k.a. RFB) protocol with
///   VMware extensions; the protocol gracefully degrades
///   to standard VNC if extensions are not available.
///   wss://{Ticket.host}/ticket/{Ticket.ticket}
/// - `guestIntegrity`: Guest Integrity over WebSocket ticket.
///   
///   This ticket grants the client read-only access to guest integrity
///   messages and alerts.
/// - `webRemoteDevice`: Remote device over WebSocket ticket.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineTicketTypeEnum {
    Mks,
    Device,
    GuestControl,
    Webmks,
    GuestIntegrity,
    WebRemoteDevice,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines the set operators that can be used to join the sets identified by nested
/// constraints in a *VsanCompositeConstraint* instance.
/// 
/// Possible values:
/// - `AND`: joins multiple VsanResourceConstraint with AND
/// - `OR`: joins multiple VsanResourceConstraint with OR
/// - `EXCEPT`: negate with multiple VsanResourceConstraint
/// - `VsanCompositeConstraintConjoinerEnum_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanCompositeConstraintConjoinerEnumEnum {
    And,
    Or,
    Except,
    VsanCompositeConstraintConjoinerEnumUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumerate the choice for specify the target ManagedObject.
/// 
/// It can be one of
/// the following:
/// 
/// Possible values:
/// - `ALL_HOSTS`: Retrieve properties for all HostSystem objects
/// - `ALL_VSAN_ENABLED_HOSTS`: Retrieve properties for all vSAN enabled HostSystem objects
/// - `ALL_CLUSTERS`: Retrieve properties for all ClusterComputeResource objects
/// - `ALL_VSAN_ENABLED_CLUSTERS`: Retrieve properties for all vSAN enabled ClusterComputeResource objects
/// - `VCENTER`: Retrieve properties for vCenter level objects like tasks, events etc
/// - `SERVICE_INSTANCE`: Retrieve properties for service content, such as vCenter instanceUuid, build number etc
/// - `ALL_VSAN_ENABLED_HOSTS_EXCEPT_WITNESS`: Retrieve properties for all vSAN enabled HostSystem objects except witness hosts
/// - `ALL_DATASTORES`
/// - `ALL_VSAN_DATASTORES`
/// - `ALL_VMFS_DATASTORES`
/// - `VsanMassCollectorObjectCollectionEnum_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanMassCollectorObjectCollectionEnumEnum {
    AllHosts,
    AllVsanEnabledHosts,
    AllClusters,
    AllVsanEnabledClusters,
    Vcenter,
    ServiceInstance,
    AllVsanEnabledHostsExceptWitness,
    AllDatastores,
    AllVsanDatastores,
    AllVmfsDatastores,
    VsanMassCollectorObjectCollectionEnumUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines the possible operators to use for comparison of the resource
/// model properties.
/// 
/// Possible values:
/// - `EQUALS`: Check for equality of values
/// - `GREATER`: Filters values if greater than specified constraint value.
/// - `SMALLER`: Filters values if smaller than specified constraint value.
/// - `POP`
/// - `CONTAINS`: Matches value to check if it contains the specified constraint value.
/// - `TEXTUALLY_MATCHES`: Uses Python regex re.match() function.
/// - `VsanPropertyConstraintComparatorEnum_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanPropertyConstraintComparatorEnumEnum {
    Equals,
    Greater,
    Smaller,
    Pop,
    Contains,
    TextuallyMatches,
    VsanPropertyConstraintComparatorEnumUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Type of disk group operation performed.
/// 
/// Possible values:
/// - `add`: Disk group is being (re-)added.
/// - `remove`: Disk group is being removed.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanUpgradeSystemUpgradeHistoryDiskGroupOpTypeEnum {
    Add,
    Remove,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// These constant strings can be used as parameters in user-specified
/// email subject and body templates as well as in scripts.
/// 
/// The action processor
/// in VirtualCenter substitutes the run-time values for the parameters.
/// For example, an email subject provided by the client could be the string:
/// `Alarm - {alarmName} Description:\n{eventDescription}`.
/// Or a script action provided could be: `myScript {alarmName}`.
/// 
/// Possible values:
/// - `targetName`: The name of the entity where the alarm is triggered.
/// - `alarmName`: The name of the triggering alarm.
/// - `oldStatus`: The status prior to the alarm being triggered.
/// - `newStatus`: The status after the alarm is triggered.
/// - `triggeringSummary`: A summary of information involved in triggering the alarm.
/// - `declaringSummary`: A summary of declarations made during the triggering of the alarm.
/// - `eventDescription`: The event description.
/// - `target`: The object of the entity where the alarm is associated.
/// - `alarm`: The object of the triggering alarm.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ActionParameterEnum {
    TargetName,
    AlarmName,
    OldStatus,
    NewStatus,
    TriggeringSummary,
    DeclaringSummary,
    EventDescription,
    Target,
    Alarm,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Alarm entity type
/// 
/// Possible values:
/// - `entityTypeAll`: Alarms on all entity types.
/// - `entityTypeHost`: Host alarms
/// - `entityTypeVm`: VM alarms
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum AlarmFilterSpecAlarmTypeByEntityEnum {
    EntityTypeAll,
    EntityTypeHost,
    EntityTypeVm,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Alarm triggering type.
/// 
/// The main divisions are event triggered and
/// metric- or state-based alarms.
/// 
/// Possible values:
/// - `triggerTypeAll`: All alarm types.
/// - `triggerTypeEvent`: Event based alarms
/// - `triggerTypeMetric`: Metric or state alarms
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum AlarmFilterSpecAlarmTypeByTriggerEnum {
    TriggerTypeAll,
    TriggerTypeEvent,
    TriggerTypeMetric,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Basic Comparison operators
/// 
/// Possible values:
/// - `equals`: attribute equals specified value
/// - `notEqualTo`: attribute does not equal specified value
/// - `startsWith`: attribute starts with specified value
/// - `doesNotStartWith`: attribute does not start with specified value
/// - `endsWith`: attribute ends with specified value
/// - `doesNotEndWith`: attribute does not end with specified value
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum EventAlarmExpressionComparisonOperatorEnum {
    Equals,
    NotEqualTo,
    StartsWith,
    DoesNotStartWith,
    EndsWith,
    DoesNotEndWith,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The operation on the target metric item.
/// 
/// Possible values:
/// - `isAbove`: Test if the target metric item is above the given red or yellow values.
/// - `isBelow`: Test if the target metric item is below the given red or yellow values.
///
/// ### How to access
/// - `AlarmManager::default_expression→MetricAlarmExpression.operator`
/// - `Alarm::reconfigure_alarm(spec).expression→MetricAlarmExpression.operator`
/// - `AlarmManager::create_alarm(spec).expression→MetricAlarmExpression.operator`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum MetricAlarmOperatorEnum {
    IsAbove,
    IsBelow,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The operation on the target state.
/// 
/// Possible values:
/// - `isEqual`: Test if the target state matches the given red or yellow states.
/// - `isUnequal`: Test if the target state does not match the given red or yellow states.
///
/// ### How to access
/// - `AlarmManager::default_expression→StateAlarmExpression.operator`
/// - `Alarm::reconfigure_alarm(spec).expression→StateAlarmExpression.operator`
/// - `AlarmManager::create_alarm(spec).expression→StateAlarmExpression.operator`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum StateAlarmOperatorEnum {
    IsEqual,
    IsUnequal,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Pre-defined constants for possible action types.
/// 
/// Virtual Center
/// uses this information to coordinate with the clients.
/// 
/// Possible values:
/// - `MigrationV1`: Migration action type
/// - `VmPowerV1`: Virtual machine power action type
/// - `HostPowerV1`: Host power action type
/// - `HostMaintenanceV1`: Host entering maintenance mode action type
/// - `StorageMigrationV1`: Storage migration action type
/// - `StoragePlacementV1`: Initial placement action for a virtual machine or a virtual disk
/// - `PlacementV1`: Initial placement action for a virtual machine and its virtual disks
/// - `HostInfraUpdateHaV1`: Host changing infrastructure update ha mode action type.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ActionTypeEnum {
    MigrationV1,
    VmPowerV1,
    HostPowerV1,
    HostMaintenanceV1,
    StorageMigrationV1,
    StoragePlacementV1,
    PlacementV1,
    HostInfraUpdateHaV1,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines the detailed cluster wide power action.
/// 
/// Possible values:
/// - `clusterPoweredOn`: indicate the cluster is in running state.
/// - `haDisabled`: vSphere HA is disabled.
/// - `supportedVMsPoweredOff`: the supported system VMs are powered off.
/// - `vcVMPoweredOff`: power off the VC VM if the VC VM is on vSAN.
/// - `vsanMemberShipUpdateDisabled`: vSAN membership updates is disabled.
/// - `vsanDOMPauseAllCCPsSet`: DOMPauseAllCCPs is set.
/// - `hostsInMM`: all hosts are in maintenance mode.
/// - `hostsPoweredOff`: power-off operations have been triggered on all hosts.
/// - `clusterPoweredOff`: indicate the cluster is in shutdown state.
/// - `hostsOutOfMM`: all hosts are out of maintenance mode.
/// - `vsanMemberShipUpdateEnabled`: vSAN membership updates is enabled.
/// - `vsanDOMPauseAllCCPsUnset`: DOMPauseAllCCPs is unset.
/// - `vcVMPoweredOn`: power on the VC VMs if it the VC VM is on vSAN.
/// - `supportedVMsPoweredOn`: the supported system VMs are powered on.
/// - `haEnabled`: vSphere HA is enabled.
/// - `infraVMsRecorded`
/// - `hostsInfraVMsPoweredoff`
/// - `hostsInfraVMsPoweredon`
/// - `ClusterPowerStatus_Unknown`: represent the value when the lower version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ClusterPowerStatusEnum {
    ClusterPoweredOn,
    HaDisabled,
    SupportedVMsPoweredOff,
    VcVmPoweredOff,
    VsanMemberShipUpdateDisabled,
    VsanDomPauseAllCcPsSet,
    HostsInMm,
    HostsPoweredOff,
    ClusterPoweredOff,
    HostsOutOfMm,
    VsanMemberShipUpdateEnabled,
    VsanDomPauseAllCcPsUnset,
    VcVmPoweredOn,
    SupportedVMsPoweredOn,
    HaEnabled,
    InfraVMsRecorded,
    HostsInfraVMsPoweredoff,
    HostsInfraVMsPoweredon,
    ClusterPowerStatusUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `onDemand`: Put each host into the crypto safe state automatically when needed.
/// - `forceEnable`: Put each host into the crypto safe state immediately.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ClusterCryptoConfigInfoCryptoModeEnum {
    OnDemand,
    ForceEnable,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The *ClusterDasAamNodeStateDasState_enum* enumerated type defines
/// values for host HA configuration and runtime state properties
/// (*ClusterDasAamNodeState.configState* and
/// *ClusterDasAamNodeState.runtimeState*).
/// 
/// Possible values:
/// - `uninitialized`: HA has never been enabled on the the host.
/// - `initialized`: HA agents have been installed but are not running on the the host.
/// - `configuring`: HA configuration is in progress.
/// - `unconfiguring`: HA configuration is being removed.
/// - `running`: HA agent is running on this host.
/// - `error`: There is an error condition.
///   
///   This can represent a configuration
///   error or a host agent runtime error.
/// - `agentShutdown`: The HA agent has been shut down.
/// - `nodeFailed`: The host is not reachable.
///   
///   This can represent a host failure
///   or an isolated host.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ClusterDasAamNodeStateDasStateEnum {
    Uninitialized,
    Initialized,
    Configuring,
    Unconfiguring,
    Running,
    Error,
    AgentShutdown,
    NodeFailed,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The policy to determine the candidates from which vCenter Server can
/// choose heartbeat datastores.
/// 
/// Possible values:
/// - `userSelectedDs`: vCenter Server chooses heartbeat datastores from the set specified
///   by the user (see *ClusterDasConfigInfo.heartbeatDatastore*).
///   
///   More specifically,
///   datastores not included in the set will not be chosen. Note that if
///   *ClusterDasConfigInfo.heartbeatDatastore* is empty, datastore heartbeating will
///   be disabled for HA.
/// - `allFeasibleDs`: vCenter Server chooses heartbeat datastores from all the feasible ones,
///   i.e., the datastores that are accessible to more than one host in
///   the cluster.
///   
///   The choice will be made without giving preference to those
///   specified by the user (see *ClusterDasConfigInfo.heartbeatDatastore*).
/// - `allFeasibleDsWithUserPreference`: vCenter Server chooses heartbeat datastores from all the feasible ones
///   while giving preference to those specified by the user (see *ClusterDasConfigInfo.heartbeatDatastore*).
///   
///   More specifically, the datastores not included in *ClusterDasConfigInfo.heartbeatDatastore* will be
///   chosen if and only if the specified ones are not sufficient.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ClusterDasConfigInfoHbDatastoreCandidateEnum {
    UserSelectedDs,
    AllFeasibleDs,
    AllFeasibleDsWithUserPreference,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible states of an HA service.
/// 
/// All services support the
/// disabled and enabled states.
/// 
/// Possible values:
/// - `disabled`: HA service is disabled.
/// - `enabled`: HA service is enabled.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ClusterDasConfigInfoServiceStateEnum {
    Disabled,
    Enabled,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The *ClusterDasConfigInfoVmMonitoringState_enum* enum defines values that indicate
/// the state of Virtual Machine Health Monitoring.
/// 
/// Health Monitoring
/// uses the vmTools (guest) and application agent heartbeat modules.
/// You can configure HA to respond to heartbeat failures of either one
/// or both modules. You can also disable the HA response to heartbeat failures.
/// - To set the cluster default for health monitoring, use the
///   ClusterConfigSpecEx.dasConfig.*ClusterDasConfigInfo.vmMonitoring* property.
/// - To set health monitoring for a virtual machine, use the
///   ClusterConfigSpecEx.dasVmConfigSpec.info.dasSettings.*ClusterDasVmSettings.vmToolsMonitoringSettings* property.
/// - To retrieve the current state of health monitoring (cluster setting), use the
///   ClusterConfigInfoEx.dasConfig.*ClusterDasConfigInfo.vmMonitoring*
///   property.
/// - To retrieve the current state of health monitoring for a virtual machine, use the
///   ClusterConfigInfoEx.dasVmConfig\[\].dasSettings.vmToolsMonitoringSettings.*ClusterVmToolsMonitoringSettings.vmMonitoring*
///   property.
///   
/// Possible values:
/// - `vmMonitoringDisabled`: Virtual machine health monitoring is disabled.
///   
///   In this state,
///   HA response to guest and application heartbeat failures are disabled.
/// - `vmMonitoringOnly`: HA response to guest heartbeat failure is enabled.
///   
///   To retrieve the guest heartbeat status, use the
///   *VirtualMachine*.*VirtualMachine.guestHeartbeatStatus*
///   property.
/// - `vmAndAppMonitoring`: HA response to both guest and application heartbeat failure is enabled.
///   - To retrieve the guest heartbeat status, use the
///     *VirtualMachine*.*VirtualMachine.guestHeartbeatStatus*
///     property.
///   - To retrieve the application heartbeat status, use the
///     *GuestInfo*.*GuestInfo.appHeartbeatStatus*
///     property.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ClusterDasConfigInfoVmMonitoringStateEnum {
    VmMonitoringDisabled,
    VmMonitoringOnly,
    VmAndAppMonitoring,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The *ClusterDasFdmAvailabilityState_enum* enumeration describes the
/// availability states of hosts in a vSphere HA cluster.
/// 
/// In the HA
/// architecture, a agent called the Fault Domain Manager runs on
/// each active host. These agents elect a master and the others become
/// its slaves. The availability state assigned to a given host is
/// determined from information reported by the Fault Domain Manager
/// running on the host, by a Fault Domain Manager that has been elected
/// master, and by vCenter Server. See *ClusterDasFdmHostState*
/// for more information about the vSphere HA architecture.
/// 
/// Possible values:
/// - `uninitialized`: The Fault Domain Manager for the host has not yet been
///   initialized.
///   
///   Hence the host is not part of a vSphere HA
///   fault domain. This state is reported by vCenter Server or
///   by the host itself.
/// - `election`: The Fault Domain Manager on the host has been initialized and
///   the host is either waiting to join the existing master or
///   is participating in an election for a new master.
///   
///   This state
///   is reported by vCenter Server or by the host itself.
/// - `master`: The Fault Domain Manager on the host has been elected a
///   master.
///   
///   This state is reported by the the host itself.
/// - `connectedToMaster`: The normal operating state for a slave host.
///   
///   In this state,
///   the host is exchanging heartbeats with a master over
///   the management network, and is thus connected to it. If
///   there is a management network partition, the slave will be
///   in this state only if it is in the same partition as the master.
///   This state is reported by the master of a slave host.
/// - `networkPartitionedFromMaster`: A slave host is alive and has management network connectivity, but
///   the management network has been partitioned.
///   
///   This state is reported
///   by masters that are in a partition other than the one containing the
///   slave host; the master in the slave's partition will report the slave state
///   as *connectedToMaster*.
/// - `networkIsolated`: A host is alive but is isolated from the management network.
///   
///   See *ClusterDasVmSettingsIsolationResponse_enum* for the criteria
///   used to determine whether a host is isolated.
/// - `hostDown`: The slave host appears to be down.
///   
///   This state is reported by the
///   master of a slave host.
/// - `initializationError`: An error occurred when initilizating the Fault Domain Manager
///   on a host due to a problem with installing the
///   agent or configuring it.
///   
///   This condition can often be cleared by
///   reconfiguring HA for the host. This state is reported by vCenter
///   Server.
/// - `uninitializationError`: An error occurred when unconfiguring the Fault Domain Manager
///   running on a host.
///   
///   In order to clear this condition the host might
///   need to be reconnected to the cluster and reconfigured first.
///   This state is reported by vCenter
///   Server.
/// - `fdmUnreachable`: The Fault Domain Manager (FDM) on the host cannot be reached.
///   
///   This
///   state is reported in two unlikely situations.
///   - First, it is reported by
///     a master if the host responds to ICMP pings sent by the master over the
///     management network but the FDM on the host cannot be reached by the master.
///     This situation will occur if the FDM is unable to run or exit the
///     uninitialized state.
///   - Second, it is reported by vCenter Server if it cannot connect to a
///     master nor the FDM for the host. This situation would occur if all hosts
///     in the cluster failed but vCenter Server is still running. It may also
///     occur if all FDMs are unable to run or exit the uninitialized state.
/// - `retry`: Config/Reconfig/upgrade operation has failed in first attempt and
///   a retry of these operations is scheduled.
///   
///   If any of the retry attempts succeed, the state is set to initialized.
///   If all retry attempts fail, the state is set to initializationError.
///   This state is reported by vCenter.
///   
///   ***Since:*** vSphere API Release 8.0.0.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ClusterDasFdmAvailabilityStateEnum {
    Uninitialized,
    Election,
    Master,
    ConnectedToMaster,
    NetworkPartitionedFromMaster,
    NetworkIsolated,
    HostDown,
    InitializationError,
    UninitializationError,
    FdmUnreachable,
    Retry,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Deprecated as of VI API 2.5, use *ClusterDasVmSettingsRestartPriority_enum*.
/// 
/// The priority of the virtual machine determines the preference
/// given to it if sufficient capacity is not available to power
/// on all failed virtual machines.
/// 
/// For example, high priority
/// virtual machines on a host get preference over low priority
/// virtual machines.
/// 
/// Possible values:
/// - `disabled`: vSphere HA is disabled for this virtual machine.
/// - `low`: Virtual machines with this priority have a lower chance of powering on after a
///   failure if there is insufficient capacity on hosts to meet all virtual machine
///   needs.
/// - `medium`: Virtual machines with this priority have an intermediate chance of powering
///   on after a failure if there is insufficient capacity on hosts to meet all
///   virtual machine needs.
/// - `high`: Virtual machines with this priority have a higher chance of powering on after a
///   failure if there is insufficient capacity on hosts to meet all virtual machine
///   needs.
///
/// ### How to access
/// - `ComputeResource::configuration_ex→ClusterConfigInfoEx.das_vm_config?[*].restart_priority?`
/// - `ClusterComputeResource::configuration.das_vm_config?[*].restart_priority?`
/// - `ClusterComputeResource::configuration_ex→ClusterConfigInfoEx.das_vm_config?[*].restart_priority?`
/// - `Folder::create_cluster(spec).das_vm_config_spec?[*].info?.restart_priority?`
/// - `Folder::create_cluster_ex(spec).das_vm_config_spec?[*].info?.restart_priority?`
/// - `Folder::add_standalone_host_task(comp_res_spec)→ClusterConfigSpecEx.das_vm_config_spec?[*].info?.restart_priority?`
/// - `Folder::batch_add_hosts_to_cluster_task(comp_res_spec)→ClusterConfigSpecEx.das_vm_config_spec?[*].info?.restart_priority?`
/// - `Folder::batch_add_standalone_hosts_task(comp_res_spec)→ClusterConfigSpecEx.das_vm_config_spec?[*].info?.restart_priority?`
/// - `StoragePod::create_cluster(spec).das_vm_config_spec?[*].info?.restart_priority?`
/// - `StoragePod::create_cluster_ex(spec).das_vm_config_spec?[*].info?.restart_priority?`
/// 
/// *(10 of 18 paths)*
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DasVmPriorityEnum {
    Disabled,
    Low,
    Medium,
    High,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The *ClusterDasVmSettingsIsolationResponse_enum* enum defines
/// values that indicate whether or not the virtual machine should be
/// powered off if a host determines that it is isolated from the rest of
/// the cluster.
/// 
/// Host network isolation occurs when a host is still running but it can no
/// longer communicate with other hosts in the cluster and it cannot ping
/// the configured isolation address(es). When the HA agent on a host loses
/// contact with the other hosts, it will ping the isolation addresses. If
/// the pings fail, the host will declare itself isolated.
/// 
/// Once the HA agent declares the host isolated, it will initiate the
/// isolation response workflow after a 30 second delay. You can use the FDM
/// advanced option fdm.isolationPolicyDelaySec to increase the delay. For
/// each virtual machine, the HA agent attempts to determine if a master is
/// responsible for restarting the virtual machine. If it cannot make the
/// determination, or there is a master that is responsible, the agent will
/// apply the configured isolation response. This workflow will continue
/// until the configuration policy, has been applied to all virtual
/// machines, the agent reconnects to another HA agent in the cluster, or
/// the isolation address pings start succeeding. If there is a master agent
/// in the cluster, it will attempt to restart the virtual machines that
/// were powered off during isolation.
/// 
/// By default, the isolated host leaves its virtual machines powered on.
/// You can override the isolation response default with a cluster-wide
/// setting (*ClusterDasConfigInfo.defaultVmSettings*)
/// or a virtual machine setting
/// (*ClusterDasVmSettings.isolationResponse*).
/// - All isolation response values are valid for the
///   *ClusterDasVmSettings.isolationResponse*
///   property specified in a single virtual machine HA configuration.
/// - All values except for <code>clusterIsolationResponse</code> are valid
///   for the cluster-wide default HA configuration for virtual machines
///   (*ClusterDasConfigInfo.defaultVmSettings*).
///   
/// If you ensure that your network infrastructure is sufficiently redundant
/// and that at least one network path is available at all times, host network
/// isolation should be a rare occurrence.
/// 
/// Possible values:
/// - `none`: Do not power off the virtual machine in the event of a host network
///   isolation.
/// - `powerOff`: Power off the virtual machine in the event of a host network
///   isolation.
/// - `shutdown`: Shut down the virtual machine guest operating system in the event of
///   a host network isolation.
///   
///   If the guest operating system fails to
///   shutdown within five minutes, HA will initiate a forced power off.
///   
///   When you use the shutdown isolation response, failover can take
///   longer (compared to the
///   *powerOff*
///   response) because the virtual machine cannot fail over until it is
///   shutdown.
/// - `clusterIsolationResponse`: Use the default isolation response defined for the cluster
///   that contains this virtual machine.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ClusterDasVmSettingsIsolationResponseEnum {
    None,
    PowerOff,
    Shutdown,
    ClusterIsolationResponse,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The *ClusterDasVmSettingsRestartPriority_enum* enum defines
/// virtual machine restart priority values to resolve resource contention.
/// 
/// The priority determines the preference that HA gives to a virtual
/// machine if sufficient capacity is not available to power on all failed
/// virtual machines. For example, high priority virtual machines on a host
/// get preference over low priority virtual machines.
/// 
/// All priority values are valid for the restart priority specified in a
/// single virtual machine HA configuration (*ClusterDasVmConfigInfo.dasSettings*).
/// All values except for <code>clusterRestartPriority</code> are valid for
/// the cluster-wide default HA configuration for virtual machines
/// (*ClusterDasConfigInfo.defaultVmSettings*).
/// 
/// Possible values:
/// - `disabled`: vSphere HA is disabled for this virtual machine.
/// - `lowest`: Virtual machines with this priority have the lowest chance of
///   powering on after a failure if there is insufficient capacity on
///   hosts to meet all virtual machine needs.
/// - `low`: Virtual machines with this priority have a lower chance of powering
///   on after a failure if there is insufficient capacity on hosts to meet
///   all virtual machine needs.
/// - `medium`: Virtual machines with this priority have an intermediate chance of
///   powering on after a failure if there is insufficient capacity on
///   hosts to meet all virtual machine needs.
/// - `high`: Virtual machines with this priority have a higher chance of powering
///   on after a failure if there is insufficient capacity on hosts to meet
///   all virtual machine needs.
/// - `highest`: Virtual machines with this priority have the highest chance of
///   powering on after a failure if there is insufficient capacity on
///   hosts to meet all virtual machine needs.
/// - `clusterRestartPriority`: Virtual machines with this priority use the default restart
///   priority defined for the cluster that contains this virtual machine.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ClusterDasVmSettingsRestartPriorityEnum {
    Disabled,
    Lowest,
    Low,
    Medium,
    High,
    Highest,
    ClusterRestartPriority,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `manual`: Specifies that VirtualCenter should generate recommendations
///   for host power operations, but should not execute the
///   recommendations automatically.
/// - `automated`: Specifies that VirtualCenter should generate recommendations
///   for host power operations, and should execute the
///   recommendations automatically.
///
/// ### How to access
/// - `ComputeResource::configuration_ex→ClusterConfigInfoEx.dpm_config_info?.default_dpm_behavior?`
/// - `ComputeResource::configuration_ex→ClusterConfigInfoEx.dpm_host_config?[*].behavior?`
/// - `ClusterComputeResource::configuration_ex→ClusterConfigInfoEx.dpm_config_info?.default_dpm_behavior?`
/// - `ClusterComputeResource::configuration_ex→ClusterConfigInfoEx.dpm_host_config?[*].behavior?`
/// - `Folder::create_cluster_ex(spec).dpm_config?.default_dpm_behavior?`
/// - `Folder::add_standalone_host_task(comp_res_spec)→ClusterConfigSpecEx.dpm_config?.default_dpm_behavior?`
/// - `Folder::batch_add_hosts_to_cluster_task(comp_res_spec)→ClusterConfigSpecEx.dpm_config?.default_dpm_behavior?`
/// - `Folder::batch_add_standalone_hosts_task(comp_res_spec)→ClusterConfigSpecEx.dpm_config?.default_dpm_behavior?`
/// - `Folder::create_cluster_ex(spec).dpm_host_config_spec?[*].info?.behavior?`
/// - `StoragePod::create_cluster_ex(spec).dpm_config?.default_dpm_behavior?`
/// 
/// *(10 of 28 paths)*
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DpmBehaviorEnum {
    Manual,
    Automated,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `manual`: Specifies that VirtualCenter should generate recommendations for
///   virtual machine migration and for placement with a host,
///   but should not implement the recommendations automatically.
/// - `partiallyAutomated`: Specifies that VirtualCenter should generate recommendations for
///   virtual machine migration and for placement with a host,
///   but should automatically implement only the placement at power on.
/// - `fullyAutomated`: Specifies that VirtualCenter should automate both the migration
///   of virtual machines and their placement with a host at power on.
///
/// ### How to access
/// - `ComputeResource::configuration_ex→ClusterConfigInfoEx.drs_config.default_vm_behavior?`
/// - `ComputeResource::configuration_ex→ClusterConfigInfoEx.drs_vm_config?[*].behavior?`
/// - `ClusterComputeResource::configuration.drs_config.default_vm_behavior?`
/// - `ClusterComputeResource::configuration.drs_vm_config?[*].behavior?`
/// - `ClusterComputeResource::configuration_ex→ClusterConfigInfoEx.drs_config.default_vm_behavior?`
/// - `ClusterComputeResource::configuration_ex→ClusterConfigInfoEx.drs_vm_config?[*].behavior?`
/// - `Folder::create_cluster(spec).drs_config?.default_vm_behavior?`
/// - `Folder::create_cluster_ex(spec).drs_config?.default_vm_behavior?`
/// - `Folder::add_standalone_host_task(comp_res_spec)→ClusterConfigSpecEx.drs_config?.default_vm_behavior?`
/// - `Folder::batch_add_hosts_to_cluster_task(comp_res_spec)→ClusterConfigSpecEx.drs_config?.default_vm_behavior?`
/// 
/// *(10 of 36 paths)*
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DrsBehaviorEnum {
    Manual,
    PartiallyAutomated,
    FullyAutomated,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Deprecated as of VI API 2.5 use *RecommendationReasonCode_enum*.
/// 
/// List of defined migration reason codes:
/// 
/// Possible values:
/// - `fairnessCpuAvg`: Balance average CPU utilization.
/// - `fairnessMemAvg`: Balance average memory utilization.
/// - `jointAffin`: Fulfill affinity rule.
/// - `antiAffin`: Fulfill anti-affinity rule.
/// - `hostMaint`: Host entering maintenance mode.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DrsRecommendationReasonCodeEnum {
    FairnessCpuAvg,
    FairnessMemAvg,
    JointAffin,
    AntiAffin,
    HostMaint,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Describes the operation type of the action.
/// 
/// enterexitQuarantine suggests
/// that the host is only exiting the quarantine state (i.e. not the
/// maintenance mode).
/// 
/// Possible values:
/// - `enterQuarantine`
/// - `exitQuarantine`
/// - `enterMaintenance`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ClusterHostInfraUpdateHaModeActionOperationTypeEnum {
    EnterQuarantine,
    ExitQuarantine,
    EnterMaintenance,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `powerOn`: Power On Operation
/// - `powerOff`: Power Off Operation.
///   
///   Power off operation puts the host in
///   a state that can be woken up remotely.
///
/// ### How to access
/// - `StoragePod::pod_storage_drs_entry.recommendation?[*].action?[*]→ClusterHostPowerAction.operation_type`
/// - `StoragePod::pod_storage_drs_entry.action_history?[*].action→ClusterHostPowerAction.operation_type`
/// - `ClusterComputeResource::action_history.action→ClusterHostPowerAction.operation_type`
/// - `ClusterComputeResource::recommendation.action?[*]→ClusterHostPowerAction.operation_type`
/// - `Datastore::datastore_enter_maintenance_mode().recommendations?[*].action?[*]→ClusterHostPowerAction.operation_type`
/// - `ClusterComputeResource::cluster_enter_maintenance_mode().recommendations?[*].action?[*]→ClusterHostPowerAction.operation_type`
/// - `ClusterComputeResource::place_vm().recommendations?[*].action?[*]→ClusterHostPowerAction.operation_type`
/// - `StorageResourceManager::recommend_datastores().recommendations?[*].action?[*]→ClusterHostPowerAction.operation_type`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostPowerOperationTypeEnum {
    PowerOn,
    PowerOff,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `Manual`: With this behavior configured, the proposed DRS recommendations
///   require manual approval before they are executed.
/// - `Automated`: With this behavior configured, the proposed DRS recommendations are
///   executed immediately.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ClusterInfraUpdateHaConfigInfoBehaviorTypeEnum {
    Manual,
    Automated,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `QuarantineMode`: With this behavior configured, a degraded host will be recommended
///   to be placed in Quarantine Mode.
/// - `MaintenanceMode`: With this behavior configured, a degraded host will be recommended
///   to be placed in Maintenance Mode.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ClusterInfraUpdateHaConfigInfoRemediationTypeEnum {
    QuarantineMode,
    MaintenanceMode,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines the type of placement
/// 
/// Possible values:
/// - `create`: Create a new VM
/// - `reconfigure`: Reconfigure a VM
/// - `relocate`: Relocate a VM
/// - `clone`: Clone a VM
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PlacementSpecPlacementTypeEnum {
    Create,
    Reconfigure,
    Relocate,
    Clone,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines the options for a Datacenter::powerOnVm() invocation.
/// 
/// Possible values:
/// - `OverrideAutomationLevel`: Override the DRS automation level.
///   
///   Value type: *DrsBehavior_enum*
///   Default value: current behavior
/// - `ReserveResources`: Reserve resources for the powering-on VMs throughout the
///   power-on session.
///   
///   When this option is set to true, the server
///   will return at most one recommended host per manual VM, and
///   the VM's reservations are held on the recommended host until
///   the VM is actually powered on (either by applying the
///   recommendation or by a power-on request on the VM), or until
///   the recommendation is cancelled, or until the recommendation
///   expires. The expiration time is currently set to 10
///   minutes. This option does not have an effect on automatic VMs
///   since their recommendations are executed immediately. This
///   option is effective on DRS clusters only.
///   Value type: boolean
///   Default value: false
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ClusterPowerOnVmOptionEnum {
    OverrideAutomationLevel,
    ReserveResources,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// List of defined migration reason codes:
/// 
/// Possible values:
/// - `fairnessCpuAvg`: Balance average CPU utilization.
/// - `fairnessMemAvg`: Balance average memory utilization.
/// - `jointAffin`: Fulfill affinity rule.
/// - `antiAffin`: Fulfill anti-affinity rule.
/// - `hostMaint`: Host entering maintenance mode.
/// - `enterStandby`: Host entering standby mode.
/// - `reservationCpu`: balance CPU reservations
/// - `reservationMem`: balance memory reservations
/// - `powerOnVm`: Power on virtual machine
/// - `powerSaving`: Power off host for power savings
/// - `increaseCapacity`: Power on host to increase cluster capacity
/// - `checkResource`: Sanity-check resource pool hierarchy
/// - `unreservedCapacity`: Maintain unreserved capacity
/// - `vmHostHardAffinity`: Fix hard VM/host affinity rule violation
/// - `vmHostSoftAffinity`: Fix soft VM/host affinity rule violation
/// - `balanceDatastoreSpaceUsage`: Balance datastore space usage.
/// - `balanceDatastoreIOLoad`: 
///   
///   Deprecated as of vSphere8.0 U3, and there is no replacement for it.
///   
///   Balance datastore I/O workload.
/// - `balanceDatastoreIOPSReservation`: 
///   
///   Deprecated as of vSphere8.0 U3, and there is no replacement for it.
///   
///   Balance datastore IOPS reservation
/// - `datastoreMaint`: Datastore entering maintenance mode.
/// - `virtualDiskJointAffin`: Fix virtual disk affinity rule violation.
/// - `virtualDiskAntiAffin`: Fix virtual disk anti-affinity rule violation.
/// - `datastoreSpaceOutage`: Fix the issue that a datastore run out of space.
/// - `storagePlacement`: Satisfy storage initial placement requests.
/// - `iolbDisabledInternal`: 
///   
///   Deprecated as of vSphere8.0 U3, and there is no replacement for it.
///   
///   IO load balancing was disabled internally.
/// - `xvmotionPlacement`: Satisfy unified vmotion placement requests.
/// - `networkBandwidthReservation`: Fix network bandwidth reservation violation
/// - `hostInDegradation`: Host is partially degraded.
/// - `hostExitDegradation`: Host is not degraded.
/// - `maxVmsConstraint`: Fix maxVms constraint violation
/// - `ftConstraints`: Fix ft maxVMs and maxVcpus constraint violations
/// - `vmHostAffinityPolicy`: Fix VM/host affinity policy violation
/// - `vmHostAntiAffinityPolicy`: Fix VM/host anti-affinity policy violation
/// - `vmAntiAffinityPolicy`: Fix VM-VM anti-affinity policy violations
/// - `balanceVsanUsage`: ***Since:*** vSphere API Release 7.0.2.0
/// - `ahPlacementOptimization`: Optimize assignable hardware resource orchestration
///   
///   ***Since:*** vSphere API Release 8.0.2.0
/// - `vmxUpgrade`: Upgrade virtual machine to new vmx binary
///   
///   ***Since:*** vSphere API Release 8.0.3.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum RecommendationReasonCodeEnum {
    FairnessCpuAvg,
    FairnessMemAvg,
    JointAffin,
    AntiAffin,
    HostMaint,
    EnterStandby,
    ReservationCpu,
    ReservationMem,
    PowerOnVm,
    PowerSaving,
    IncreaseCapacity,
    CheckResource,
    UnreservedCapacity,
    VmHostHardAffinity,
    VmHostSoftAffinity,
    BalanceDatastoreSpaceUsage,
    BalanceDatastoreIoLoad,
    BalanceDatastoreIopsReservation,
    DatastoreMaint,
    VirtualDiskJointAffin,
    VirtualDiskAntiAffin,
    DatastoreSpaceOutage,
    StoragePlacement,
    IolbDisabledInternal,
    XvmotionPlacement,
    NetworkBandwidthReservation,
    HostInDegradation,
    HostExitDegradation,
    MaxVmsConstraint,
    FtConstraints,
    VmHostAffinityPolicy,
    VmHostAntiAffinityPolicy,
    VmAntiAffinityPolicy,
    BalanceVsanUsage,
    AhPlacementOptimization,
    VmxUpgrade,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Pre-defined constants for possible recommendation types.
/// 
/// Virtual Center
/// uses this information to coordinate with the clients.
/// 
/// Possible values:
/// - `V1`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum RecommendationTypeEnum {
    V1,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines the set of status values for compliance operations.
/// 
/// Possible values:
/// - `compliant`: Entity is compliant.
/// - `nonCompliant`: Entity is not compliant.
/// - `unknown`: Compliance status of the entity is unknown.
/// - `notApplicable`: Compliance computation is not applicable for this entity, because it does not have any storage policy requirement for the datastore where the entity is placed.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanStorageComplianceStatusEnum {
    Compliant,
    NonCompliant,
    Unknown,
    NotApplicable,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `SYSTEM_MANAGED`: System VMs are fully managed by the system.
/// - `ABSENT`: System VMs are absent on the managed entity.
///   
/// ***Since:*** vSphere API Release 8.0.2.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ClusterSystemVMsConfigInfoDeploymentModeEnum {
    SystemManaged,
    Absent,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `ClusterWithoutOneWitnessHost`
/// - `ClusterWithoutTwoDataFaultDomains`
/// - `ClusterWithMultipleUnicastAgents`
/// - `WitnessPreferredFaultDomainInvalid`
/// - `WitnessPreferredFaultDomainNotExist`
/// - `WitnessInsideVcCluster`
/// - `WitnessFaultDomainInvalid`
/// - `HostUnicastAgentUnset`
/// - `WitnessWithNoDiskMapping`
/// - `HostWithNoStretchedClusterSupport`
/// - `HostWithInvalidUnicastAgent`
/// - `SharedWitnessClusterDataHostNumExceed`
/// - `SharedWitnessComponentLimitScaledDown`
/// - `VSANStretchedClusterConfigIssueEnum_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VimClusterVsanStretchedClusterConfigIssueEnumEnum {
    ClusterWithoutOneWitnessHost,
    ClusterWithoutTwoDataFaultDomains,
    ClusterWithMultipleUnicastAgents,
    WitnessPreferredFaultDomainInvalid,
    WitnessPreferredFaultDomainNotExist,
    WitnessInsideVcCluster,
    WitnessFaultDomainInvalid,
    HostUnicastAgentUnset,
    WitnessWithNoDiskMapping,
    HostWithNoStretchedClusterSupport,
    HostWithInvalidUnicastAgent,
    SharedWitnessClusterDataHostNumExceed,
    SharedWitnessComponentLimitScaledDown,
    VsanStretchedClusterConfigIssueEnumUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The VM policy settings that determine the response to
/// storage failures.
/// 
/// Possible values:
/// - `disabled`: VM Component Protection service will not monitor or react to
///   the component failure.
///   
///   This setting does not affect other vSphere
///   HA services such as Host Monitoring or VM Health Monitoring.
/// - `warning`: VM Component Protection service will monitor component failures but
///   will not restart an affected VM.
///   
///   Rather it will notify users about
///   the component failures. This setting does not affect other vSphere HA
///   services such as Host Monitoring or VM Health Monitoring.
/// - `restartConservative`: VM Component Protection service protects VMs conservatively.
///   
///   With this
///   setting, when the service can't determine that capacity is available to
///   restart a VM, it will favor keeping the VM running.
/// - `restartAggressive`: VM Component Protection service protects VMs aggressively.
///   
///   With this setting,
///   the service will terminate an affected VM even if it can't determine that
///   capacity exists to restart the VM.
/// - `clusterDefault`: VM will use the cluster default setting.
///   
///   This option is only meaningful for
///   per-VM settings.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ClusterVmComponentProtectionSettingsStorageVmReactionEnum {
    Disabled,
    Warning,
    RestartConservative,
    RestartAggressive,
    ClusterDefault,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// If an APD condition clears after an APD timeout condition has been declared and before
/// VM Component Protection service terminated the VM, the guestOS and application may
/// no longer be operational.
/// 
/// VM Component Protection may be configured to reset the
/// VM (*VirtualMachine.ResetVM_Task*) to restore the service of guest applications.
/// 
/// Possible values:
/// - `none`: VM Component Protection service will not react after APD condition is cleared.
/// - `reset`: VM Component Protection service will reset the VM after APD condition is cleared.
///   
///   Note this only applies if the subject VM is still powered on.
/// - `useClusterDefault`: VM will use the cluster default setting.
///   
///   This option is only meaningful for
///   per-VM settings.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ClusterVmComponentProtectionSettingsVmReactionOnApdClearedEnum {
    None,
    Reset,
    UseClusterDefault,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Condition for VM's readiness
/// 
/// Possible values:
/// - `none`: No ready condition specified.
///   
///   In case of vSphere HA, higher restart priority VMs are still
///   placed before lower priority VMs.
/// - `poweredOn`: VM is powered on.
/// - `guestHbStatusGreen`: VM guest operating system is up and responding normally (VM tools
///   heartbeat status is green).
/// - `appHbStatusGreen`: An application running inside the VM is responding normally.
///   
///   To enable Application Monitoring, you must first obtain the
///   appropriate SDK (or be using an application that supports VMware
///   Application Monitoring) and use it to set up customized heartbeats
///   for the applications you want to monitor.
///   See *ClusterDasConfigInfo.vmMonitoring*.
/// - `useClusterDefault`: VM will use the cluster default setting.
///   
///   This option is only
///   meaningful for per-VM settings.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ClusterVmReadinessReadyConditionEnum {
    None,
    PoweredOn,
    GuestHbStatusGreen,
    AppHbStatusGreen,
    UseClusterDefault,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Represents various baseline preference types.
/// 
/// Any patch or update release is considered part of the same "release family",
/// while both updates to the major version number (e.g. 7.0) or to the minor
/// version number (e.g. 7.1) would be considered different "release families".
/// 
/// Possible values:
/// - `latestRelease`: recommend latest release compatible with cluster hardware, it could be either new major release or update release in current release family.
///   
///   (eg. Consider ESXi 6.8 is released and current installed version is ESXi 6.7, then ESXi 6.8 would be recommended under this mode if hardware is compatible.)
/// - `latestPatch`: latest patch contains all bug fixes and updates for the current release family.
///   
///   In this mode recommendation engine wouldn't jump to other release family. (eg. Consider ESXi 6.8 is released and current installed version is ESXi 6.7, then ESXi 6.7 U1 instead of ESXi 6.8 would be recommended under this mode if hardware is compatible.)
/// - `noRecommendation`: do not generate baseline recommendation for current vSAN cluster.
/// - `VsanBaselinePreferenceType_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanBaselinePreferenceTypeEnum {
    LatestRelease,
    LatestPatch,
    NoRecommendation,
    VsanBaselinePreferenceTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Represents a condition that an object is in when retrieving capability on
/// it.
/// 
/// A host can be in multiple conditions at the same time. Currently we
/// have the following ones.
/// 
/// Possible values:
/// - `unknown`: Not able to get/calculate the host's capabilities, thus empty capability list returned.
/// - `oldversion`: Host version is before ESXi 6.0 U1.
/// - `disconnected`: Host is in disconnected state.
/// - `calculated`: Capabilities are not retrieved from the host but are calculated based on host's version.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanCapabilityStatusEnum {
    Unknown,
    Oldversion,
    Disconnected,
    Calculated,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Represents a feature capability (for 8.x and previous releases).
/// 
/// Possible values:
/// - `capability`: The current feature for retrieving Capabilities.
/// - `allflash`: Creating AllFlash disk groups.
/// - `stretchedcluster`: Creating a stretched cluster, adding and removing witness host.
/// - `dataefficiency`: Enabling/disabling Deduplication and Compression.
/// - `clusterconfig`: Create/Configure a vSAN cluster and related features with a single call.
/// - `upgrade`: Upgrade disk groups to a higher version.
/// - `objectidentities`: Retrieve a greater set of virtual objects.
/// - `iscsitargets`: iscsi feature provides iSCSI protocol on top of vSAN.
/// - `witnessmanagement`: The enable/disable vSAN operation and changing claiming policy.
/// - `perfsvcverbosemode`: Allow users to configure performance service to run in verbose mode, in which extra stats are collected for support cases and dev debugging.
/// - `encryption`: Software data at rest encryption for vSAN.
/// - `decomwhatif`: Query what-if result for decommissioning host or disk.
/// - `throttleresync`: Improve throttling options &amp; resumable resync.
/// - `unicastmode`: Enforce unicast mode in vSAN.
/// - `device4ksupport`: 4k disks supporting status in vSAN
/// - `nestedfd`: Nested fault domains for stretched clusters.
/// - `complianceprecheck`: Calculate required additional capacity to make all vms compliant.
/// - `vumintegration`: vSAN upgrades through VUM integration.
/// - `firmwareupdate`: vSAN firmware/driver update feature that allow users to remediate outdated driver or firmware in an automated and simple fashion for supported hardware.
/// - `fullStackFw`: (deprecated since vSphere 8.0) allows users to update full stack of firmware for vSAN hosts.
/// - `configassist`: Configuration Assist UI provided in vSphere Web Client to help vSAN deployment.
/// - `umap`: TRIM/UNMAP for space reclamation on vSAN.
/// - `localdataprotection`: Support for data protection on a vSAN cluster.
/// - `archivaldataprotection`: Support for data protection to NFS datastores.
/// - `pr1741414fixed`: GetPreferredfaultDomain on stretched cluster and VmdkLoadTest work correctly operation are automatically performed by the VsanVcClusterConfig API.
/// - `cloudhealth`: Enable/Disable Cloud Connected Analytics
/// - `perfanalysis`: Enable/Disable Performance Analytics
/// - `fcd`: Enable/Disable First Class Disk Support in vSAN
/// - `healthcheck2018q2`: Enable/Disable suites of health group checks on 2018q2 releases
/// - `enhancedresyncapi`: Support *VsanSystemEx.VsanQuerySyncingVsanObjects*.
/// - `genericnestedfd`: Nested fault domain for non-stretched cluster.
/// - `hostaffinity`: Support for Host Affinity
/// - `perfsvcautoconfig`: The capability of enable/disable vSAN performance service automatically when configure vSAN.
/// - `unicasttest`: For unicast performance test capability.
///   
///   (Obsoleted, DO NOT USE)
/// - `vsanrdma`
/// - `vumbaselinerecommendation`
/// - `supportinsight`
/// - `netperftest`: For network performance test capability.
/// - `masspropertycollector`: For vSAN mass property collector capability by extending property collector to collect multiple properties and APIs execution result as a batch mode
/// - `whatifcapacity`: For vSAN datastore What-If capacity report capability.
/// - `historicalcapacity`: For vSAN datastore historical capacity report capability.
/// - `policyassociation`: Support SPBM to use vSAN as source of truth for policy association.
/// - `policyhostapi`
/// - `diagnosticmode`: For vSAN diagnostic mode capability.
/// - `purgeinaccessiblevmswapobjects`: Support for purging inaccessible VM swap objects
/// - `recreatediskgroup`: Support for recreating disk groups
/// - `repairtimerinresyncstats`: Support for retrieving repair time runtime information
/// - `clusteradvancedoptions`: Support for cluster advanced options
/// - `updatevumreleasecatalogoffline`: Support for VUM release catalog offline update
/// - `performanceforsupport`: Capability of performance metrics collection for vSAN support
/// - `gethcllastupdateonvc`: Indicates if the cluster parameter is optional in the *VsanVcClusterHealthSystem.VsanVcClusterGetHclInfo* method.
/// - `automaticrebalance`
/// - `verbosemodeconfiguration`
/// - `resyncetaimprovement`
/// - `fileservices`
/// - `fileservicekerberos`
/// - `fileservicesmb`
/// - `fileservicenfsv3`
/// - `fileservicesc`
/// - `fileservicesnapshot`
/// - `fileserviceowe`
/// - `fileservice80`
/// - `fileservicescale`
/// - `resourceprecheck`
/// - `upgraderesourceprecheck`
/// - `vitonlineresize`
/// - `vitstretchedcluster`
/// - `largecapacitydrive`
/// - `nondatamovementdfc`
/// - `cnsvolumes`
/// - `filevolumes`
/// - `diagnosticsfeedback`
/// - `hostreservedcapacity`
/// - `vmlevelcapacity`
/// - `improvedcapacityscreen`
/// - `slackspacecapacity`
/// - `sharedwitness`
/// - `VsanCapabilityType_Unknown`
/// - `supportApiVersion`
/// - `vsanmetadatanode`
/// - `pmanintegration`
/// - `wcpappplatform`
/// - `diskresourceprecheck`
/// - `metricsconfig`
/// - `ioinsight`
/// - `apidevversionenabled`
/// - `nativelargeclustersupport`
/// - `historicalhealth`
/// - `dataintransitencryption`
/// - `perfsvctwoyaxisgraph`
/// - `compressiononly`
/// - `remotedatastore`
/// - `vsanmanagedvmfs`
/// - `capacityreservation`
/// - `securewipe`
/// - `validateconfigspec`
/// - `vsananalyticsevents`
/// - `vsandefaultgatewaysupported`
/// - `pspairgap`
/// - `vsanmanagedpmem`
/// - `capacityevaluationonvc`
/// - `readlocalitytodrs`
/// - `vsanencrkmx`
/// - `vsan2encr`
/// - `dit4sw`
/// - `vsanclient`
/// - `capacityoversubscription`
/// - `vsandiagnostics`
/// - `capacitycustomizablethresholds`
/// - `hcimeshpolicy`
/// - `topcontributors`
/// - `vsandirectdiskdecom`
/// - `diskmgmtredesign`
/// - `datapersistresourcecheck`
/// - `clusterpoweraction`
/// - `clusterpowerselfcontain`
/// - `duplicatepciidfix`
/// - `healthcorrelation`
/// - `volumerelocation`
/// - `iodiagnostics`
/// - `vsanrebuildtrim`
/// - `elasticpolicy`
/// - `vsanEsaConfigure`
/// - `hdcsintegration`
/// - `vsanesasingletier`
/// - `vsanperfhighresolution`
/// - `cnsreconfigpolicy`
/// - `vsanhostdomlatencysort`
/// - `sha256thumbprint`
/// - `minrebalancethreshold`
/// - `vsan2hcimesh`
/// - `dfcobjectsmanagement`
/// - `healthremediation`
/// - `hcimeshstretchedcluster`
/// - `vsanxvchcimesh`
/// - `vsan2deeprekey`
/// - `vsandsdefaultpolicy`
/// - `vsanperfsvc80u2`
/// - `vsankeyexpiration`
/// - `vsanxvchcimeshv2`
/// - `dhci`
/// - `snapservice`: ***Since:*** 8.0.0.4
/// - `vsan2disableencryption`: ***Since:*** 8.0.0.4
/// - `iodiagmultiplevms`: ***Since:*** 8.0.0.4
/// - `vsanxvchcimeshv3`: ***Since:*** 8.0.0.4
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanCapabilityTypeEnum {
    Capability,
    Allflash,
    Stretchedcluster,
    Dataefficiency,
    Clusterconfig,
    Upgrade,
    Objectidentities,
    Iscsitargets,
    Witnessmanagement,
    Perfsvcverbosemode,
    Encryption,
    Decomwhatif,
    Throttleresync,
    Unicastmode,
    Device4Ksupport,
    Nestedfd,
    Complianceprecheck,
    Vumintegration,
    Firmwareupdate,
    FullStackFw,
    Configassist,
    Umap,
    Localdataprotection,
    Archivaldataprotection,
    Pr1741414Fixed,
    Cloudhealth,
    Perfanalysis,
    Fcd,
    Healthcheck2018Q2,
    Enhancedresyncapi,
    Genericnestedfd,
    Hostaffinity,
    Perfsvcautoconfig,
    Unicasttest,
    Vsanrdma,
    Vumbaselinerecommendation,
    Supportinsight,
    Netperftest,
    Masspropertycollector,
    Whatifcapacity,
    Historicalcapacity,
    Policyassociation,
    Policyhostapi,
    Diagnosticmode,
    Purgeinaccessiblevmswapobjects,
    Recreatediskgroup,
    Repairtimerinresyncstats,
    Clusteradvancedoptions,
    Updatevumreleasecatalogoffline,
    Performanceforsupport,
    Gethcllastupdateonvc,
    Automaticrebalance,
    Verbosemodeconfiguration,
    Resyncetaimprovement,
    Fileservices,
    Fileservicekerberos,
    Fileservicesmb,
    Fileservicenfsv3,
    Fileservicesc,
    Fileservicesnapshot,
    Fileserviceowe,
    Fileservice80,
    Fileservicescale,
    Resourceprecheck,
    Upgraderesourceprecheck,
    Vitonlineresize,
    Vitstretchedcluster,
    Largecapacitydrive,
    Nondatamovementdfc,
    Cnsvolumes,
    Filevolumes,
    Diagnosticsfeedback,
    Hostreservedcapacity,
    Vmlevelcapacity,
    Improvedcapacityscreen,
    Slackspacecapacity,
    Sharedwitness,
    VsanCapabilityTypeUnknown,
    SupportApiVersion,
    Vsanmetadatanode,
    Pmanintegration,
    Wcpappplatform,
    Diskresourceprecheck,
    Metricsconfig,
    Ioinsight,
    Apidevversionenabled,
    Nativelargeclustersupport,
    Historicalhealth,
    Dataintransitencryption,
    Perfsvctwoyaxisgraph,
    Compressiononly,
    Remotedatastore,
    Vsanmanagedvmfs,
    Capacityreservation,
    Securewipe,
    Validateconfigspec,
    Vsananalyticsevents,
    Vsandefaultgatewaysupported,
    Pspairgap,
    Vsanmanagedpmem,
    Capacityevaluationonvc,
    Readlocalitytodrs,
    Vsanencrkmx,
    Vsan2Encr,
    Dit4Sw,
    Vsanclient,
    Capacityoversubscription,
    Vsandiagnostics,
    Capacitycustomizablethresholds,
    Hcimeshpolicy,
    Topcontributors,
    Vsandirectdiskdecom,
    Diskmgmtredesign,
    Datapersistresourcecheck,
    Clusterpoweraction,
    Clusterpowerselfcontain,
    Duplicatepciidfix,
    Healthcorrelation,
    Volumerelocation,
    Iodiagnostics,
    Vsanrebuildtrim,
    Elasticpolicy,
    VsanEsaConfigure,
    Hdcsintegration,
    Vsanesasingletier,
    Vsanperfhighresolution,
    Cnsreconfigpolicy,
    Vsanhostdomlatencysort,
    Sha256Thumbprint,
    Minrebalancethreshold,
    Vsan2Hcimesh,
    Dfcobjectsmanagement,
    Healthremediation,
    Hcimeshstretchedcluster,
    Vsanxvchcimesh,
    Vsan2Deeprekey,
    Vsandsdefaultpolicy,
    Vsanperfsvc80U2,
    Vsankeyexpiration,
    Vsanxvchcimeshv2,
    Dhci,
    Snapservice,
    Vsan2Disableencryption,
    Iodiagmultiplevms,
    Vsanxvchcimeshv3,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Represents a feature capability for 9.0 release.
/// 
/// Possible values:
/// - `vsanreplication`
/// - `vsandedicatedvmknic`
/// - `globaldedup`
/// - `vsanstretchedclient`
/// - `vsaniscsivip`
/// - `vsansitemaintenance`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanCapabilityType90Enum {
    Vsanreplication,
    Vsandedicatedvmknic,
    Globaldedup,
    Vsanstretchedclient,
    Vsaniscsivip,
    Vsansitemaintenance,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The vSAN cluster health action ID enumeration.
/// 
/// Actions are remediation operations user can take to resolve health issues.
/// Each action is identified by ID. The user performs the action by calling the
/// associated first-class API. But it's not always appropriate to trigger such
/// operation and user need to use judgment of the situation to decide. This is
/// why the action is not automatically executed, as it may be the wrong choice
/// in some situations.
/// Some actions don't directly correspond to an API, but rather a workflow, in
/// the case of the UI a wizard.
/// 
/// Possible values:
/// - `RepairClusterObjectsAction`: Mapped to *VsanVcClusterHealthSystem.VsanHealthRepairClusterObjectsImmediate* API.
/// - `UploadHclDb`: Mapped to *VsanVcClusterHealthSystem.VsanVcUploadHclDb* API.
/// - `UpdateHclDbFromInternet`: Mapped to *VsanVcClusterHealthSystem.VsanVcUpdateHclDbFromWeb* API.
/// - `EnableHealthService`: Deprecated.
/// - `DiskBalance`: Mapped to *VsanVcClusterHealthSystem.VsanRebalanceCluster* API.
/// - `StopDiskBalance`: Mapped to *VsanVcClusterHealthSystem.VsanStopRebalanceCluster* API.
/// - `RemediateDedup`: Mapped to *VsanUpgradeSystemEx.PerformVsanUpgradeEx* API.
/// - `UpgradeVsanDiskFormat`: Mapped to *VsanUpgradeSystemEx.PerformVsanUpgradeEx* API.
/// - `CreateDVS`: Mapped to UI workflow "Create VDS".
/// - `ConfigureHA`: Mapped to UI workflow "Configure HA".
/// - `ConfigureDRS`: Mapped to UI workflow "Configure DRS".
/// - `ConfigureVSAN`: Mapped to UI workflow "Configure vSAN".
/// - `ClaimVSANDisks`: Mapped to UI workflow "Claim vSAN Disks".
/// - `ClusterUpgrade`: Mapped to UI workflow "vSAN On-click Upgrade Wizard".
/// - `CreateVMKnic`: Mapped to UI workflow "Create vmknic Wizard".
/// - `CreateVMKnicWithVMotion`: Mapped to UI workflow "Create vmknic with vMotion Wizard".
/// - `RunBurnInTest`: Mapped to UI workflow "Run Storage performance test".
/// - `EnableIscsiTargetService`: Mapped to UI workflow "Enable vSAN iSCSI service".
/// - `EnablePerformanceServiceAction`: Mapped to *VsanPerformanceManager.VsanPerfCreateStatsObjectTask* API.
/// - `RemediateClusterConfig`: Mapped to UI workflow "Remediate inconsistent configuration".
/// - `EnableCeip`: Mapped to UI workflow "Customer Experience Improvement Program (CEIP) page".
/// - `LoginVumIsoDepot`: Mapped to *VsanVumSystem.FetchIsoDepotCookie* API.
/// - `PurgeInaccessSwapObjs`: Mapped to UI workflow "Purge Inaccessible VM Swap Objects".
/// - `UploadReleaseCatalog`: Mapped to UI workflow "Update release catalog from file".
/// - `ConfigureAutomaticRebalance`
/// - `RemediateFileService`
/// - `RelayoutVsanObjects`
/// - `RemediateFileServiceImbalance`
/// - `SelectNvme`
/// - `CreateFileServiceDomain`
/// - `RemediateIscsiLunsRuntimeStatus`
/// - `ShallowRekey`
/// - `VsanClusterHealthActionIdEnum_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanClusterHealthActionIdEnumEnum {
    RepairClusterObjectsAction,
    UploadHclDb,
    UpdateHclDbFromInternet,
    EnableHealthService,
    DiskBalance,
    StopDiskBalance,
    RemediateDedup,
    UpgradeVsanDiskFormat,
    CreateDvs,
    ConfigureHa,
    ConfigureDrs,
    ConfigureVsan,
    ClaimVsanDisks,
    ClusterUpgrade,
    CreateVmKnic,
    CreateVmKnicWithVMotion,
    RunBurnInTest,
    EnableIscsiTargetService,
    EnablePerformanceServiceAction,
    RemediateClusterConfig,
    EnableCeip,
    LoginVumIsoDepot,
    PurgeInaccessSwapObjs,
    UploadReleaseCatalog,
    ConfigureAutomaticRebalance,
    RemediateFileService,
    RelayoutVsanObjects,
    RemediateFileServiceImbalance,
    SelectNvme,
    CreateFileServiceDomain,
    RemediateIscsiLunsRuntimeStatus,
    ShallowRekey,
    VsanClusterHealthActionIdEnumUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The vSAN cluster health category enumeration.
/// 
/// Each of non-green health check belongs to a specific category
/// according to its actual user impact. The health score can be
/// calculated based on it.
/// 
/// Possible values:
/// - `DataAvailability`: The health category which impacts the vSAN object data availability and need user immediate action to avoid possible data loss.
/// - `InfraAvailability`: The health category which impacts the vSAN cluster infrastructure availability like host/network/disk health.
///   
///   Notice it may impact data availability eventually.
/// - `DataPerformance`: The health category which impacts the vSAN object data performance like congestion health.
/// - `InfraPerformance`: The health category which impacts the vSAN cluster infrastructure performance like network latency health.
///   
///   Notice it may impact user data performance eventually.
/// - `CapacityUtilization`: The health category which impacts the vSAN cluster capacity utilization.
/// - `SoftResourceUtilization`: The health category which impacts the vSAN software resource utilization like component health.
/// - `Compliance`: The health category of which health warning is not compliant with vSAN cluster requirement or recommendation.
///   
///   Notice the health warnings in this category have no immediate impact for the current vSAN cluster but it may have potential risk with unpredictable impact in future.
/// - `VsanClusterHealthCategoryEnum_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanClusterHealthCategoryEnumEnum {
    DataAvailability,
    InfraAvailability,
    DataPerformance,
    InfraPerformance,
    CapacityUtilization,
    SoftResourceUtilization,
    Compliance,
    VsanClusterHealthCategoryEnumUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The vSAN Datastore type.
/// 
/// It can be used in
/// *QueryVsanManagedStorageSpaceUsageSpec*.
/// 
/// Possible values:
/// - `vsan`: The vSAN storage type.
/// - `vsandirect`: The vSAN direct storage type.
/// - `pmem`: 
///   
///   Deprecated as of vSphere 9.0 APIs with no replacement.
///   
///   Do not use.
/// - `VsanDatastoreType_Unknown`: represent the value when the lower version client cannot recognize the
///   enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanDatastoreTypeEnum {
    Vsan,
    Vsandirect,
    Pmem,
    VsanDatastoreTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The type of the disk group to created.
/// 
/// Possible values:
/// - `allflash`
/// - `hybrid`
/// - `vsandirect`
/// - `pmem`: 
///   
///   Deprecated as of vSphere 9.0 APIs with no replacement.
///   
///   Do not use.
/// - `VsanDiskGroupCreationType_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VimClusterVsanDiskGroupCreationTypeEnum {
    Allflash,
    Hybrid,
    Vsandirect,
    Pmem,
    VsanDiskGroupCreationTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Type of ioinsight instance, which can be either running or completed.
/// 
/// Possible values:
/// - `running`: Indicate the query is only for ioinsight instance which is still running.
/// - `completed`: Query is for ioinsight instance which has stopped successfully.
/// - `crashed`: Indicate an ioinsight instance is crashed for some unexpected reason.
/// - `VsanIoInsightInstanceState_unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanIoInsightInstanceStateEnum {
    Running,
    Completed,
    Crashed,
    VsanIoInsightInstanceStateUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines iSCSI LUN status, supported values are Online, Offline.
/// 
/// Possible values:
/// - `Online`: LUN is a configuration status, which is a desired state.
///   
///   If LUN is online, initiators can discover the LUN after login to the target.
/// - `Offline`: LUN is a configuration status, which is a desired state.
///   
///   If LUN is offline, initiators can not discover the LUN after login to the target, all existing connections are closed.
/// - `VsanIscsiLUNStatus_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanIscsiLunStatusEnum {
    Online,
    Offline,
    VsanIscsiLunStatusUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines iSCSI LUN runtime status type for iSCSI target service.
/// 
/// Possible values:
/// - `Online`: LUN is loaded by vSAN iSCSI service successfully, if LUN runtime status is online, initiators can discover it after login to the target and it can provide IO service.
/// - `Offline`: LUN is not loaded in kernel.
///   
///   If LUN runtime status is offline, initiators can't discover it after login to the target.
/// - `VsanIscsiLUNRuntimeStatusType_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanIscsiLunRuntimeStatusTypeEnum {
    Online,
    Offline,
    VsanIscsiLunRuntimeStatusTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines iSCSI authentication type.
/// 
/// Possible values:
/// - `NoAuth`: No authentication is used, the target can be connected by any initiator.
/// - `CHAP`: The Challenge-Handshake Authentication Protocol (CHAP), user name and secret attached to the target is needed to provide for any initiator to authenticate to this target.
/// - `CHAP_Mutual`: The Challenge-Handshake Authentication Protocol (CHAP) with Mutual option enabled, not only user name and secret attached to the target is needed to provide for any initiator to authenticate to this target, but also user name and secret attached to the initiator is needed to provide for one initiator to authenticate to any target.
/// - `VsanIscsiTargetAuthType_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanIscsiTargetAuthTypeEnum {
    NoAuth,
    Chap,
    ChapMutual,
    VsanIscsiTargetAuthTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines iSCSI target service process status.
/// 
/// Possible values:
/// - `Running`: Process is running.
/// - `Stopped`: Process is stopped.
/// - `VsanIscsiTargetServiceProcessStatus_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanIscsiTargetServiceProcessStatusEnum {
    Running,
    Stopped,
    VsanIscsiTargetServiceProcessStatusUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines the possible types for the vSAN objects in 8.x and previous
/// releases.
/// 
/// Possible values:
/// - `vmswap`: The VM swap files.
/// - `vdisk`: The virtual disks.
/// - `namespace`: The VM home objects.
/// - `vmem`: The VM snapshot memory files.
/// - `statsdb`: The vSAN performance management objects.
/// - `iscsiTarget`: The vSAN iSCSI home and target objects.
/// - `iscsiLun`: The vSAN iSCSI LUNs.
/// - `other`: Other vSAN objects.
/// - `fileSystemOverhead`: vSAN File system overhead.
/// - `dedupOverhead`: Deduplication and compression overhead.
/// - `spaceUnderDedupConsideration`
/// - `checksumOverhead`: Checksum overhead.
/// - `improvedVirtualDisk`: First Class Disks.
/// - `transientSpace`
/// - `slackSpaceCapRequiredForHost`
/// - `resynPauseThresholdForHost`
/// - `minSpaceRequiredForVsanOp`
/// - `hostRebuildCapacity`
/// - `physicalTransientSpace`
/// - `haMetadataObject`
/// - `fileServiceRoot`
/// - `attachedCnsVolBlock`
/// - `detachedCnsVolBlock`
/// - `attachedCnsVolFile`
/// - `detachedCnsVolFile`
/// - `cnsVolFile`
/// - `fileShare`
/// - `extension`
/// - `hbrDisk`
/// - `hbrCfg`
/// - `hbrPersist`
/// - `traceobject`
/// - `esaObjectOverhead`
/// - `VsanObjectTypeEnum_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanObjectTypeEnumEnum {
    Vmswap,
    Vdisk,
    Namespace,
    Vmem,
    Statsdb,
    IscsiTarget,
    IscsiLun,
    Other,
    FileSystemOverhead,
    DedupOverhead,
    SpaceUnderDedupConsideration,
    ChecksumOverhead,
    ImprovedVirtualDisk,
    TransientSpace,
    SlackSpaceCapRequiredForHost,
    ResynPauseThresholdForHost,
    MinSpaceRequiredForVsanOp,
    HostRebuildCapacity,
    PhysicalTransientSpace,
    HaMetadataObject,
    FileServiceRoot,
    AttachedCnsVolBlock,
    DetachedCnsVolBlock,
    AttachedCnsVolFile,
    DetachedCnsVolFile,
    CnsVolFile,
    FileShare,
    Extension,
    HbrDisk,
    HbrCfg,
    HbrPersist,
    Traceobject,
    EsaObjectOverhead,
    VsanObjectTypeEnumUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines the possible types for the vSAN objects in 9.0 release.
/// 
/// Possible values:
/// - `dedupSharedUserData`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanObjectTypeEnum90Enum {
    DedupSharedUserData,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The query type indicating the goal of the vSAN performance diagnostic
/// query, with the following values.
/// 
/// Possible values:
/// - `tput`: This query type is for a benchmarking test diagnosing if the best throughput was achieved on the vSAN cluster.
/// - `iops`: This query type is for a benchmarking test diagnosing if the best IOPS was achieved on the vSAN cluster.
/// - `lat`: This query type is for a benchmarking test diagnosing if the best latency was achieved on the vSAN cluster.
/// - `eval`: This query type is for general evaluation of the cluster.
///   
///   This mode is available for experiments only and not certified for production use.
/// - `VsanPerfDiagnosticQueryType_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanPerfDiagnosticQueryTypeEnum {
    Tput,
    Iops,
    Lat,
    Eval,
    VsanPerfDiagnosticQueryTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Stats unit types indicate the unit display for UI
/// Valid types are:
/// 
/// Possible values:
/// - `number`: a number (int) without unit, like IOPS.
/// - `time_ms`: a time unit (int) measured by milliseconds.
/// - `percentage`: a number (int) between 0 and 100, representing the percentage.
/// - `size_bytes`: a unit for the size measured by bytes.
/// - `rate_bytes`: a rate unit for bytes per second.
/// - `permille`: a number (int) between 0 and 1000, representing the permille.
/// - `time_s`
/// - `time_us`
/// - `time_ns`
/// - `VsanPerfStatsUnitType_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanPerfStatsUnitTypeEnum {
    Number,
    TimeMs,
    Percentage,
    SizeBytes,
    RateBytes,
    Permille,
    TimeS,
    TimeUs,
    TimeNs,
    VsanPerfStatsUnitTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The type of statistical measurement that a metric value represents.
/// 
/// Valid types are:
/// 
/// Possible values:
/// - `absolute`: Represents an actual value, level, or state of the counter.
///   
///   For example, the capacity metric represents the actual configured size of the specified disk. In other words, number of samples, samplingPeriod, and intervals have no bearing on an absolute metric value.
/// - `delta`: Represents an amount of change for the metric during the sampling period as compared to the previous interval.
/// - `rate`: Represents a value that has been normalized over the sampling period, enabling values for the same counter type to be compared, regardless of interval.
///   
///   For example, the number of reads per second.
/// - `VsanPerfStatsType_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanPerfStatsTypeEnum {
    Absolute,
    Delta,
    Rate,
    VsanPerfStatsTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Stats summarization types indicate how multiple samples of a specific metric
/// are transformed or aggregated into a single statistical value.
/// 
/// Valid types are:
/// 
/// Possible values:
/// - `average`: The actual value collected or the average of all values collected during the summary period.
/// - `maximum`: The maximum value of the performance metric value over the summarization period.
/// - `minimum`: The minimum value of the performance metric value over the summarization period.
/// - `latest`: The most recent value of the performance metric over the summarization period.
/// - `summation`: The sum of all the values of the performance metric over the summarization period.
/// - `none`: The counter is never rolled up.
/// - `VsanPerfSummaryType_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanPerfSummaryTypeEnum {
    Average,
    Maximum,
    Minimum,
    Latest,
    Summation,
    None,
    VsanPerfSummaryTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The direction of threshold value indicates whether it is upper limit or
/// lower limit.
/// 
/// Possible values:
/// - `upper`: The threshold is an upper limit.
///   
///   When the performance metric value exceeds the threshold, it will display warnings in graph.
/// - `lower`: The threshold is a lower limit.
///   
///   When the performance metric value is lower than the threshold, it will display warnings in graph.
/// - `VsanPerfThresholdDirectionType_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanPerfThresholdDirectionTypeEnum {
    Upper,
    Lower,
    VsanPerfThresholdDirectionTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines the error code of *VsanObjectSystem.RelayoutObjects*.
/// 
/// Possible values:
/// - `outOfResources`: indicates resources are not enough.
/// - `generic`: indicates all failures not covered by the errors defined above.
/// - `VsanRelayoutObjectsErrorCode_Unknown`: represent the value when the lower version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanRelayoutObjectsErrorCodeEnum {
    OutOfResources,
    Generic,
    VsanRelayoutObjectsErrorCodeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The vSAN Entity type.
/// 
/// An Entity may include vSAN objects like
/// virtual machine or fault domain.
/// 
/// Possible values:
/// - `VM`: The virtual machine which may contain the vSAN objects like VMDK, swap etc
/// - `FileShare`: The file share which may be backed by one or more vSAN objects
/// - `Host`: The host which may contain the vSAN objects
/// - `FaultDomain`: The fault domain which may contain the vSAN objects
/// - `VsanSpaceReportingEntityType_Unknown`: represent the value when the lower version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanSpaceReportingEntityTypeEnum {
    Vm,
    FileShare,
    Host,
    FaultDomain,
    VsanSpaceReportingEntityTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The supported vSAN health log level enumeration for Storage Infrastructure / vSAN
/// 
/// Possible values:
/// - `INFO`
/// - `WARNING`
/// - `ERROR`
/// - `DEBUG`
/// - `CRITICAL`
/// - `VsanHealthLogLevelEnum_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanHealthLogLevelEnumEnum {
    Info,
    Warning,
    Error,
    Debug,
    Critical,
    VsanHealthLogLevelEnumUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumerates flavors of container orchestrator cluster for which
/// volume operations are being performed.
/// 
/// Possible values:
/// - `VANILLA`: represents vanilla flavor of container cluster.
/// - `WORKLOAD`: represents WCP or supervisor container cluster.
/// - `GUEST_CLUSTER`: represents container cluster deployed as a guest cluster within a WCP or supervisor cluster.
/// - `ClusterFlavor_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum CnsClusterFlavorEnum {
    Vanilla,
    Workload,
    GuestCluster,
    ClusterFlavorUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumerates types of container orchestrator cluster for which volume operations
/// are being performed.
/// 
///   
/// This is a list of supported container orchestrator cluster types. Also the
/// ClusterType value can be used to list all the volumes that exist for the
/// specified type of container orchestrator.
/// 
/// Possible values:
/// - `KUBERNETES`: for container orchestrator cluster of type Kubernetes.
/// - `ClusterType_Unknown`: represent the value when the lower version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum CnsClusterTypeEnum {
    Kubernetes,
    ClusterTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumerates types of Kubernetes entities for which CNS would be storing metadata for.
/// 
/// Possible values:
/// - `PERSISTENT_VOLUME`: represents persistent volume entity in Kubernetes
/// - `PERSISTENT_VOLUME_CLAIM`: represents persistent volume claim entity in Kubernetes
/// - `POD`: represents pod entity in Kubernetes
/// - `KubernetesEntityType_Unknown`: represent the value when the lower version client cannot recognize the enum value
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum CnsKubernetesEntityTypeEnum {
    PersistentVolume,
    PersistentVolumeClaim,
    Pod,
    KubernetesEntityTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumerates the metrics output format.
/// 
/// Possible values:
/// - `PROMETHEUS`: metrics are returned in Prometheus format
/// - `WAVEFRONT`: metrics are returned in Wavefront format
/// - `MetricFormat_Unknown`: represent the value when the lower version client cannot recognize the enum value
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum MetricFormatEnum {
    Prometheus,
    Wavefront,
    MetricFormatUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumerates types of metrics for 8.x and previous releases.
/// 
/// Possible values:
/// - `VOLUME`: represents volume metrics
/// - `DATASTORE`: represents datastore metrics
/// - `CLUSTER`: represents cluster metrics *CnsClusterType_enum*
/// - `DISTRIBUTION`
/// - `STORAGE_POLICY`
/// - `OP_STATS`: represents operation statistics
/// - `SAAS_METRICS`
/// - `MetricType_Unknown`: represent the value when the lower version client cannot recognize the enum value
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum MetricTypeEnum {
    Volume,
    Datastore,
    Cluster,
    Distribution,
    StoragePolicy,
    OpStats,
    SaasMetrics,
    MetricTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumerates types of query selection name.
/// 
/// This is a reflection of the
/// attributes in *CnsVolume*.
/// 
/// Possible values:
/// - `VOLUME_METADATA`
/// - `DATASTORE_URL`
/// - `POLICY_ID`
/// - `VOLUME_TYPE`: Select *CnsVolume.volumeType*.
/// - `VOLUME_NAME`: Select *CnsVolume.name*.
/// - `BACKING_OBJECT_DETAILS`: Select *CnsVolume.backingObjectDetails*.
/// - `COMPLIANCE_STATUS`: Select *CnsVolume.complianceStatus*
/// - `DATASTORE_ACCESSIBILITY_STATUS`: Select *CnsVolume.datastoreAccessibilityStatus*
/// - `HEALTH_STATUS`
/// - `QuerySelectionNameType_Unknown`: represent the value when the lower version client cannot recognize the enum value
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum QuerySelectionNameTypeEnum {
    VolumeMetadata,
    DatastoreUrl,
    PolicyId,
    VolumeType,
    VolumeName,
    BackingObjectDetails,
    ComplianceStatus,
    DatastoreAccessibilityStatus,
    HealthStatus,
    QuerySelectionNameTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumerate types of container volume based on the type of backing for the
/// volume.
/// 
/// Possible values:
/// - `BLOCK`: for volume backed by a block device.
/// - `FILE`
/// - `VolumeType_Unknown`: represent the value when the older version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum CnsVolumeTypeEnum {
    Block,
    File,
    VolumeTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Network Filter on Failure Type.
/// 
/// It specifies whether all the
/// packets will be allowed or all the packets will be denied when
/// Filter fails to configure.
/// 
/// Possible values:
/// - `failOpen`: Allows all the packets when the Filter fails to configure.
/// - `failClosed`: Denies all the packets when the Filter fails to configure.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DvsFilterOnFailureEnum {
    FailOpen,
    FailClosed,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Set of possible values for
/// *DVPortStatus*.*DVPortStatus.vmDirectPathGen2InactiveReasonNetwork*.
/// 
/// Possible values:
/// - `portNptIncompatibleDvs`: The switch for which this port is defined does not support VMDirectPath Gen 2.
///   
///   See
///   *DVSFeatureCapability*.*DVSFeatureCapability.vmDirectPathGen2Supported*.
/// - `portNptNoCompatibleNics`: None of the physical NICs used as uplinks for this port support
///   VMDirectPath Gen 2.
///   
///   See also *PhysicalNic.vmDirectPathGen2Supported*.
/// - `portNptNoVirtualFunctionsAvailable`: At least some of the physical NICs used as uplinks for this port
///   support VMDirectPath Gen 2, but all available network-passthrough
///   resources are in use by other ports.
/// - `portNptDisabledForPort`: VMDirectPath Gen 2 has been explicitly disabled for this port.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DvPortStatusVmDirectPathGen2InactiveReasonNetworkEnum {
    PortNptIncompatibleDvs,
    PortNptNoCompatibleNics,
    PortNptNoVirtualFunctionsAvailable,
    PortNptDisabledForPort,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Set of possible values for
/// *DVPortStatus*.*DVPortStatus.vmDirectPathGen2InactiveReasonOther*.
/// 
/// Possible values:
/// - `portNptIncompatibleHost`: The host for which this port is defined does not support VMDirectPath Gen 2.
///   
///   See *HostCapability*.*HostCapability.vmDirectPathGen2Supported*
/// - `portNptIncompatibleConnectee`: Configuration or state of the port's connectee prevents
///   VMDirectPath Gen 2.
///   
///   See
///   *VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeState.vmDirectPathGen2InactiveReasonVm*
///   and/or
///   *VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeState.vmDirectPathGen2InactiveReasonExtended*
///   in the appropriate element of the RuntimeInfo.device array of the
///   virtual machine connected to this port.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DvPortStatusVmDirectPathGen2InactiveReasonOtherEnum {
    PortNptIncompatibleHost,
    PortNptIncompatibleConnectee,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The *DistributedVirtualPortgroupBackingType_enum* enum defines
/// the distributed virtual portgroup backing type.
/// 
/// Possible values:
/// - `standard`: The portgroup is created by vCenter.
/// - `nsx`: The portgroup is created by NSX manager.
///   
///   For NSX backing type, We only support ephemeral portgroup type.
///   If *DistributedVirtualPortgroupPortgroupType_enum* is
///   ephemeral, A *DistributedVirtualPort* will be
///   dynamicly created by NSX when the virtual machine is reconfigured
///   to connect to the portgroup.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DistributedVirtualPortgroupBackingTypeEnum {
    Standard,
    Nsx,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The meta tag names recognizable in the
/// *DVPortgroupConfigInfo.portNameFormat* string.
/// 
/// Possible values:
/// - `dvsName`: This tag will be expanded to the name of the switch.
/// - `portgroupName`: This tag will be expanded to the name of the portgroup.
/// - `portIndex`: This tag will be expanded to the current index of the port.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DistributedVirtualPortgroupMetaTagNameEnum {
    DvsName,
    PortgroupName,
    PortIndex,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The *DistributedVirtualPortgroupPortgroupType_enum* enum defines
/// the distributed virtual portgroup types
/// (*DistributedVirtualPortgroup*.*DistributedVirtualPortgroup.config*.*DVPortgroupConfigInfo.type*).
/// 
/// Early binding specifies a static set of ports that are created
/// when you create the distributed virtual portgroup. An ephemeral portgroup uses dynamic
/// ports that are created when you power on a virtual machine.
/// 
/// Possible values:
/// - `earlyBinding`: A free *DistributedVirtualPort* will be selected and assigned to
///   a *VirtualMachine* when the virtual machine is reconfigured to
///   connect to the portgroup.
/// - `lateBinding`: 
///   
///   Deprecated as of vSphere API 5.0.
///   
///   A free *DistributedVirtualPort* will be selected and
///   assigned to a *VirtualMachine* when the virtual machine is
///   powered on.
/// - `ephemeral`: A *DistributedVirtualPort* will be created and assigned to a
///   *VirtualMachine* when the virtual machine is powered on, and will
///   be deleted when the virtual machine is powered off.
///   
///   An ephemeral portgroup has
///   no limit on the number of ports that can be a part of this portgroup.
///   In cases where the vCenter Server is unavailable the host can
///   create conflict ports in this portgroup to be used by a virtual machine
///   at power on.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DistributedVirtualPortgroupPortgroupTypeEnum {
    EarlyBinding,
    LateBinding,
    Ephemeral,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The *EntityType_enum* enum identifies
/// the type of entity that was exported
/// (*DistributedVirtualSwitchManager.DVSManagerExportEntity_Task*).
/// 
/// Possible values:
/// - `distributedVirtualSwitch`: Indicates the exported entity is a *DistributedVirtualSwitch*.
/// - `distributedVirtualPortgroup`: Indicates the exported entity is a *DistributedVirtualPortgroup*.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum EntityTypeEnum {
    DistributedVirtualSwitch,
    DistributedVirtualPortgroup,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The *EntityImportType_enum* enum defines the import type for a
/// *DistributedVirtualSwitchManager*.*DistributedVirtualSwitchManager.DVSManagerImportEntity_Task*
/// operation.
/// 
/// Possible values:
/// - `createEntityWithNewIdentifier`: Create the entity with new identifiers.
///   
///   Specify the
///   *EntityBackupConfig*.*EntityBackupConfig.name* and
///   *EntityBackupConfig*.*EntityBackupConfig.container*
///   properties.
///   
///   The Server ignores any value for the
///   *EntityBackupConfig*.*EntityBackupConfig.key*
///   property.
/// - `createEntityWithOriginalIdentifier`: Recreate the entities with the original identifiers of the entity from which backup was created.
///   
///   The Server throws an exception if an entity with the same identifier already exists.
///   This option will also add the host members to the *DistributedVirtualSwitch* and will
///   try to get the virtual machine networking back with the same *DistributedVirtualPortgroup*.
///   Specify a *Folder* as the
///   *EntityBackupConfig*.*EntityBackupConfig.container*
///   for *EntityBackupConfig*.*EntityBackupConfig.entityType*
///   "distributedVirtualSwitch".
///   
///   The Server ignores any values for the
///   *EntityBackupConfig*.*EntityBackupConfig.key* and
///   *EntityBackupConfig*.*EntityBackupConfig.name*
///   properties.
/// - `applyToEntitySpecified`: Apply the configuration specified in the
///   *EntityBackupConfig*.*EntityBackupConfig.configBlob*
///   property to the entity specified in the
///   *EntityBackupConfig*.*EntityBackupConfig.entityType* and
///   *EntityBackupConfig*.*EntityBackupConfig.key*
///   properties.
///   
///   If you specify
///   *EntityBackupConfig*.*EntityBackupConfig.name*,
///   the Server uses the specified name to rename the entity.
///   
///   The Server ignores any value for the
///   *EntityBackupConfig*.*EntityBackupConfig.container*
///   property.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum EntityImportTypeEnum {
    CreateEntityWithNewIdentifier,
    CreateEntityWithOriginalIdentifier,
    ApplyToEntitySpecified,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `blocked`: The port link state: blocked.
/// - `unblocked`: The port link state: unblocked.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DvsFilterSpecLinkConfigEnum {
    Blocked,
    Unblocked,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `down`: The port link state: down.
/// - `up`: The port link state: up.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DvsFilterSpecLinkStateEnum {
    Down,
    Up,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The enum defines the distributed virtual switch mode.
/// 
/// Possible values:
/// - `normal`: traditional package processing mode.
/// - `mux`: ENS mode which skips packet parsing and flow table lookup.
///   
/// ***Since:*** vSphere API Release 8.0.0.1
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostDvsConfigSpecSwitchModeEnum {
    Normal,
    Mux,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The reason for DPU failover.
/// 
/// Possible values:
/// - `crash`: The failover is caused by DPU crash.
/// - `linkDown`: The failover is caused by DPU's vmnic(s) link down.
/// - `userInitiated`: The failover is triggered by the user.
///   
/// ***Since:*** vSphere API Release 8.0.3.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostDistributedVirtualSwitchManagerFailoverReasonEnum {
    Crash,
    LinkDown,
    UserInitiated,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The stage of DPU failover.
/// 
/// Possible values:
/// - `STAGE_1`
/// 
/// ***Since:*** vSphere API Release 8.0.3.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostDistributedVirtualSwitchManagerFailoverStageEnum {
    Stage1,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Describes the state of the host proxy switch.
/// 
/// Possible values:
/// - `up`: The host proxy switch is up and running.
/// - `pending`: The host proxy switch is waiting to be initialized.
/// - `outOfSync`: The proxy switch configuration is not the same as the
///   distributed virtual switch configuration in the vCenter Server.
/// - `warning`: The host requires attention.
/// - `disconnected`: The host is disconnected or it is not responding.
/// - `down`: The host proxy is down.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DistributedVirtualSwitchHostMemberHostComponentStateEnum {
    Up,
    Pending,
    OutOfSync,
    Warning,
    Disconnected,
    Down,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Describe the runtime state of the uplink.
/// 
/// Possible values:
/// - `active`
/// - `standby`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DistributedVirtualSwitchHostMemberHostUplinkStateStateEnum {
    Active,
    Standby,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Transport zone type.
/// 
/// Possible values:
/// - `vlan`: VLAN based networking
/// - `overlay`: VXLAN based networking
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DistributedVirtualSwitchHostMemberTransportZoneTypeEnum {
    Vlan,
    Overlay,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The connectee types.
/// 
/// Possible values:
/// - `pnic`: The port connects to a Physical NIC.
/// - `vmVnic`: The port connects to a Virtual NIC in a Virtual Machine.
/// - `hostConsoleVnic`: The port connects to a console Virtual NIC on a host.
/// - `hostVmkVnic`: The port connects to a VMkernel Virtual NIC on a host.
/// - `systemCrxVnic`: The port connects to a Virtual NIC in a System CRX VM.
///   
///   ***Since:*** vSphere API Release 8.0.1.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DistributedVirtualSwitchPortConnecteeConnecteeTypeEnum {
    Pnic,
    VmVnic,
    HostConsoleVnic,
    HostVmkVnic,
    SystemCrxVnic,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Network Traffic Rule direction types.
/// 
/// It specifies whether rule
/// needs to be applied for packets which are incoming/outgoing or both.
/// 
/// Possible values:
/// - `incomingPackets`: This specifies that the network rule has to be applied only for
///   incoming packets.
/// - `outgoingPackets`: This specifies that the network rule has to be applied only for
///   outgoing packets.
/// - `both`: This specifies that the network rule has to be applied only for
///   both incoming and outgoing packets.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DvsNetworkRuleDirectionTypeEnum {
    IncomingPackets,
    OutgoingPackets,
    Both,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Link Aggregation Control Protocol API versions.
/// 
/// Possible values:
/// - `singleLag`: 
///   
///   Deprecated as of vSphere API 7.0u1.
///   
///   One Link Aggregation Control Protocol group in the switch
/// - `multipleLag`: Multiple Link Aggregation Control Protocol in the switch.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VMwareDvsLacpApiVersionEnum {
    SingleLag,
    MultipleLag,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Load balance algorithm in a Link Aggregation Control Protocol group.
/// 
/// Possible values:
/// - `srcMac`: Source MAC address
/// - `destMac`: Destination MAC address
/// - `srcDestMac`: Source and destination MAC address
/// - `destIpVlan`: Destination IP and VLAN
/// - `srcIpVlan`: Source IP and VLAN
/// - `srcDestIpVlan`: Source and destination IP and VLAN
/// - `destTcpUdpPort`: Destination TCP/UDP port number
/// - `srcTcpUdpPort`: Source TCP/UDP port number
/// - `srcDestTcpUdpPort`: Source and destination TCP/UDP port number
/// - `destIpTcpUdpPort`: Destination IP and TCP/UDP port number
/// - `srcIpTcpUdpPort`: Source IP and TCP/UDP port number
/// - `srcDestIpTcpUdpPort`: Source and destination IP and TCP/UDP port number
/// - `destIpTcpUdpPortVlan`: Destination IP, TCP/UDP port number and VLAN
/// - `srcIpTcpUdpPortVlan`: Source IP, TCP/UDP port number and VLAN
/// - `srcDestIpTcpUdpPortVlan`: Source and destination IP,
///   source and destination TCP/UDP port number and VLAN.
/// - `destIp`: Destination IP
/// - `srcIp`: Source IP
/// - `srcDestIp`: Source and Destination IP
/// - `vlan`: VLAN only
/// - `srcPortId`: Source Virtual Port Id
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VMwareDvsLacpLoadBalanceAlgorithmEnum {
    SrcMac,
    DestMac,
    SrcDestMac,
    DestIpVlan,
    SrcIpVlan,
    SrcDestIpVlan,
    DestTcpUdpPort,
    SrcTcpUdpPort,
    SrcDestTcpUdpPort,
    DestIpTcpUdpPort,
    SrcIpTcpUdpPort,
    SrcDestIpTcpUdpPort,
    DestIpTcpUdpPortVlan,
    SrcIpTcpUdpPortVlan,
    SrcDestIpTcpUdpPortVlan,
    DestIp,
    SrcIp,
    SrcDestIp,
    Vlan,
    SrcPortId,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `allow`
/// - `drop`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DvsMacLimitPolicyTypeEnum {
    Allow,
    Drop,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Multicast Filtering mode.
/// 
/// Possible values:
/// - `legacyFiltering`: Legacy filtering mode
/// - `snooping`: IGMP/MLD snooping mode
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VMwareDvsMulticastFilteringModeEnum {
    LegacyFiltering,
    Snooping,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The PVLAN port types.
/// 
/// Possible values:
/// - `promiscuous`: The port can communicate with all other ports within the same PVLAN,
///   including the isolated and community ports .
/// - `isolated`: The port can only communicate with the promiscuous ports within the
///   same PVLAN, any other traffics are blocked.
/// - `community`: The ports communicates with other community ports and with
///   promiscuous ports within the same PVLAN.
///   
///   any other traffics are
///   blocked.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VmwareDistributedVirtualSwitchPvlanPortTypeEnum {
    Promiscuous,
    Isolated,
    Community,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The teaming health check match status.
/// 
/// Possible values:
/// - `iphashMatch`: The value of 'loadbalance\_ip' is used in a uplink teaming policy
///   *VmwareUplinkPortTeamingPolicy.policy*
///   in the vSphere Distributed Switch, and the external physical switch
///   has the matching EtherChannel configuration.
/// - `nonIphashMatch`: The value of 'loadbalance\_ip' is not used in a uplink teaming policy
///   *VmwareUplinkPortTeamingPolicy.policy*
///   in the vSphere Distributed Switch, and the external physical switch
///   does not have EtherChannel configuration.
/// - `iphashMismatch`: The value of 'loadbalance\_ip' is used in a uplink teaming policy
///   *VmwareUplinkPortTeamingPolicy.policy*
///   in the vSphere Distributed Switch, but the external physical switch
///   does not have the matching EtherChannel configuration.
/// - `nonIphashMismatch`: The value of 'loadbalance\_ip' is not used in a uplink teaming policy
///   *VmwareUplinkPortTeamingPolicy.policy*
///   in the vSphere Distributed Switch, but the external physical switch
///   has EtherChannel configuration.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VMwareDvsTeamingMatchStatusEnum {
    IphashMatch,
    NonIphashMatch,
    IphashMismatch,
    NonIphashMismatch,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Link Aggregation Control Protocol policy modes.
/// 
/// Possible values:
/// - `active`: Link Aggregation Control Protocol always sends frames along the configured uplinks
/// - `passive`: Link Aggregation Control Protocol acts as "speak when spoken to".
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VMwareUplinkLacpModeEnum {
    Active,
    Passive,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Link Aggregation Control Protocol timeout policy modes.
/// 
/// Possible values:
/// - `fast`: Set long timeout for vmnics in one LACP LAG.
///   
///   Device send fast LACPDUs
/// - `slow`: Set short timeout for vmnics in one LACP LAG.
///   
///   Device send slow LACPDUs
/// 
/// ***Since:*** vSphere API Release 7.0.2.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VMwareUplinkLacpTimeoutModeEnum {
    Fast,
    Slow,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Distributed Port Mirroring session Encapsulation types.
/// 
/// Possible values:
/// - `gre`: Encapsulate original packets with GRE protocol
/// - `erspan2`: Encapsulate original packets with ERSPAN Type2 protocol
/// - `erspan3`: Encapsulate original packets with ERSPAN Type3 protocol
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VMwareDvsVspanSessionEncapTypeEnum {
    Gre,
    Erspan2,
    Erspan3,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Distributed Port Mirroring session types.
/// 
/// Possible values:
/// - `mixedDestMirror`: 
///   
///   Deprecated as of vSphere API 5.1.
///   
///   In mixedDestMirror session, Distributed Ports can be used as source entities,
///   and both Distributed Ports and Uplink Ports Name can be used as destination entities.
/// - `dvPortMirror`: In dvPortMirror session, Distributed Ports can be used as both source
///   and destination entities.
/// - `remoteMirrorSource`: In remoteMirrorSource session, Distributed Ports can be used as source entities,
///   and uplink ports name can be used as destination entities.
/// - `remoteMirrorDest`: In remoteMirrorDest session, vlan Ids can be used as source entities,
///   and Distributed Ports can be used as destination entities.
/// - `encapsulatedRemoteMirrorSource`: In encapsulatedRemoteMirrorSource session, Distributed Ports can be used as source entities,
///   and Ip address can be used as destination entities.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VMwareDvsVspanSessionTypeEnum {
    MixedDestMirror,
    DvPortMirror,
    RemoteMirrorSource,
    RemoteMirrorDest,
    EncapsulatedRemoteMirrorSource,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Key management type.
/// 
/// Possible values:
/// - `unknown`
/// - `internal`
/// - `external`
/// 
/// ***Since:*** vSphere API Release 8.0.1.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum CryptoManagerHostKeyManagementTypeEnum {
    Unknown,
    Internal,
    External,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `KeyStateMissingInCache`: Key not found in VC cache and does not specify a provider
/// - `KeyStateClusterInvalid`: Key provider is invalid
/// - `KeyStateClusterUnreachable`: Can not reach the key provider
/// - `KeyStateMissingInKMS`: Key not found in KMS
/// - `KeyStateNotActiveOrEnabled`: Key not active or enabled
/// - `KeyStateManagedByTrustAuthority`: Key is managed by Trust Authority
/// - `KeyStateManagedByNKP`: Key is managed by Native Key Provider
///   
///   ***Since:*** vSphere API Release 8.0.3.0
/// - `NoPermissionToAccessKeyProvider`: No permission to access key provider
///   
///   ***Since:*** vSphere API Release 8.0.3.0
/// - `WrappingKeyMissingInKMS`: Wrapping Key not found in KMS
///   
///   ***Since:*** vSphere API Release 9.0.0.0
/// - `WrappingKeyNotActiveOrEnabled`: Wrapping Key not active or enabled
///   
///   ***Since:*** vSphere API Release 9.0.0.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum {
    KeyStateMissingInCache,
    KeyStateClusterInvalid,
    KeyStateClusterUnreachable,
    KeyStateMissingInKms,
    KeyStateNotActiveOrEnabled,
    KeyStateManagedByTrustAuthority,
    KeyStateManagedByNkp,
    NoPermissionToAccessKeyProvider,
    WrappingKeyMissingInKms,
    WrappingKeyNotActiveOrEnabled,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Key type.
/// 
/// Possible values:
/// - `rawKey`: Key is fetched directly from KMS.
/// - `wrappedKey`: Key is wrapped by a wrapping key from KMS.
///   
///   The wrapping key details are specified in
///   *KmipClusterInfoWrappingKeyIdKeyInfo*
///   or
///   *KmipClusterInfoWrappingRotationIntervalKeyInfo*.
/// 
/// ***Since:*** vSphere API Release 9.0.0.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum KmipClusterInfoKeyTypeEnum {
    RawKey,
    WrappedKey,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Key provider management type.
/// 
/// Possible values:
/// - `unknown`
/// - `vCenter`
/// - `trustAuthority`
/// - `nativeProvider`: ***Since:*** vSphere API Release 7.0.2.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum KmipClusterInfoKmsManagementTypeEnum {
    Unknown,
    VCenter,
    TrustAuthority,
    NativeProvider,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `userDefinedScriptDisabled`: The user defined script is disabled during customization
/// - `customizationDisabled`: The guest customization is disabled by VMware Tools
///   
///   ***Since:*** vSphere API Release 7.0.1.0
/// - `rawDataIsNotSupported`: The cloud-init version is too old to support cloud-init raw data
///   
///   ***Since:*** vSphere API Release 7.0.3.0
/// - `wrongMetadataFormat`: The cloud-init meta data is not valid format
///   
///   ***Since:*** vSphere API Release 7.0.3.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum CustomizationFailedReasonCodeEnum {
    UserDefinedScriptDisabled,
    CustomizationDisabled,
    RawDataIsNotSupported,
    WrongMetadataFormat,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The port blocked/unblocked state.
/// 
/// Possible values:
/// - `unset`: The dvs port is in unset state
/// - `blocked`: The dvs port is in blocked state
/// - `unblocked`: The dvs port is in unblocked state
/// - `unknown`: The dvs port is in unknown state
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DvsEventPortBlockStateEnum {
    Unset,
    Blocked,
    Unblocked,
    Unknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Severity level constants.
/// 
/// Possible values:
/// - `error`: Something that must be corrected
/// - `warning`: Should be corrected, but the system can continue operating normally
/// - `info`: An informational message
/// - `user`: A user-related message
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum EventEventSeverityEnum {
    Error,
    Warning,
    Info,
    User,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `info`: Returns informational events.
/// - `warning`: Returns warning events.
/// - `error`: Returns error events.
/// - `user`: Returns events pertaining to users.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum EventCategoryEnum {
    Info,
    Warning,
    Error,
    User,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This option specifies how to select events based on child relationships
/// in the inventory hierarchy.
/// 
/// If a managed entity has children, their events
/// can be retrieved with this filter option.
/// 
/// Possible values:
/// - `self`: Returns events that pertain only to the specified managed entity,
///   and not its children.
/// - `children`: Returns events pertaining to child entities only.
///   
///   Excludes
///   events pertaining to the specified managed entity itself.
/// - `all`: Returns events pertaining either to the specified managed entity
///   or to its child entities.
///
/// ### How to access
/// - `EventManager::query_events(filter).entity?.recursion`
/// - `EventManager::create_collector_for_events(filter).entity?.recursion`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum EventFilterSpecRecursionOptionEnum {
    Self_,
    Children,
    All,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `configFailed`: Error while configuring/unconfiguring HA
/// - `timeout`: Timeout while communicating with HA agent
/// - `communicationInitFailed`: HA communication initialization failed
/// - `healthCheckScriptFailed`: Health check script failed
/// - `agentFailed`: HA agent has an error
/// - `agentShutdown`: HA agent was shutdown
/// - `isolationAddressUnpingable`: HA isolation address unpingable
/// - `other`: Other reason
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostDasErrorEventHostDasErrorReasonEnum {
    ConfigFailed,
    Timeout,
    CommunicationInitFailed,
    HealthCheckScriptFailed,
    AgentFailed,
    AgentShutdown,
    IsolationAddressUnpingable,
    Other,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `sslThumbprintVerifyFailed`: Failed to verify SSL thumbprint
/// - `licenseExpired`: License expired for the host
/// - `agentUpgrade`: Agent is being upgraded
/// - `userRequest`: User requested disconnect
/// - `insufficientLicenses`: License not available after host upgrade
/// - `agentOutOfDate`: Agent is out of date
/// - `passwordDecryptFailure`: Failed to decrypt password
/// - `unknown`: Unknown reason
/// - `vcVRAMCapacityExceeded`: The vRAM capacity of vCenter will be exceeded
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostDisconnectedEventReasonCodeEnum {
    SslThumbprintVerifyFailed,
    LicenseExpired,
    AgentUpgrade,
    UserRequest,
    InsufficientLicenses,
    AgentOutOfDate,
    PasswordDecryptFailure,
    Unknown,
    VcVramCapacityExceeded,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `vmtoolsHeartbeatFailure`: vmtools heartbeat failure
/// - `appHeartbeatFailure`: application heartbeat failure
/// - `appImmediateResetRequest`: immediate reset request
/// - `vmcpResetApdCleared`: reset issued by VMCP when APD cleared
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VmDasBeingResetEventReasonCodeEnum {
    VmtoolsHeartbeatFailure,
    AppHeartbeatFailure,
    AppImmediateResetRequest,
    VmcpResetApdCleared,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The reason for the failure.
/// 
/// Possible values:
/// - `incompatibleHost`: Remote host is incompatible for secondary virtual machine.
///   
///   For instance, the host doesn't have access to the virtual machine's
///   network or datastore.
/// - `loginFailed`: Login to remote host failed.
/// - `registerVmFailed`: Registration of the secondary virtual machine
///   on the remote host failed.
/// - `migrateFailed`: Migration failed.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VmFailedStartingSecondaryEventFailureReasonEnum {
    IncompatibleHost,
    LoginFailed,
    RegisterVmFailed,
    MigrateFailed,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `shutdown`: The virtual machine was shut down
/// - `poweredOff`: The virtual machine was powered off because shut down failed
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VmShutdownOnIsolationEventOperationEnum {
    Shutdown,
    PoweredOff,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Types of affinities.
/// 
/// Possible values:
/// - `memory`
/// - `cpu`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum AffinityTypeEnum {
    Memory,
    Cpu,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `NotEnoughSpaceOnDevice`: There is not enough storage space on the host to install the agent.
/// - `PrepareToUpgradeFailed`: Failed to initialize the upgrade directory on the host.
/// - `AgentNotRunning`: The agent was installed but is not running.
/// - `AgentNotReachable`: The agent was installed but did not respond to requests.
/// - `InstallTimedout`: The agent install took too long.
/// - `SignatureVerificationFailed`: The signature verification for the installer failed.
/// - `AgentUploadFailed`: Failed to upload the agent installer.
/// - `AgentUploadTimedout`: The agent upload took too long.
/// - `UnknownInstallerError`: The agent installer failed for an unknown reason.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum AgentInstallFailedReasonEnum {
    NotEnoughSpaceOnDevice,
    PrepareToUpgradeFailed,
    AgentNotRunning,
    AgentNotReachable,
    InstallTimedout,
    SignatureVerificationFailed,
    AgentUploadFailed,
    AgentUploadTimedout,
    UnknownInstallerError,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `APDTimeoutDisabled`: APD timeout has been disabled on one of the host
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum CannotEnableVmcpForClusterReasonEnum {
    ApdTimeoutDisabled,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `resourcePool`: Move out of the resouce pool
/// - `cluster`: Move out of the cluster
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum CannotMoveFaultToleranceVmMoveTypeEnum {
    ResourcePool,
    Cluster,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `suspend`: suspend
/// - `powerOff`: power off
/// - `guestShutdown`: guest shutdown
/// - `guestSuspend`: guest suspend
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum CannotPowerOffVmInClusterOperationEnum {
    Suspend,
    PowerOff,
    GuestShutdown,
    GuestSuspend,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `NetworkReservationNotSupported`: Network does not support reservation
/// - `MismatchedNetworkPolicies`: Source and destination networks do not have same security policies
/// - `MismatchedDvsVersionOrVendor`: Source and destination DVS do not have same version or vendor
/// - `VMotionToUnsupportedNetworkType`: VMotion to unsupported destination network type
/// - `NetworkUnderMaintenance`: The network is under maintenance
/// - `MismatchedEnsMode`: Source and destination networks do not have same ENS(Enhanced Network Stack) mode
/// - `MismatchedRealTimeDvs`: Source and destination networks do not have the same real-time flag
///   
///   ***Since:*** vSphere API Release 8.0.3.1
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum CannotUseNetworkReasonEnum {
    NetworkReservationNotSupported,
    MismatchedNetworkPolicies,
    MismatchedDvsVersionOrVendor,
    VMotionToUnsupportedNetworkType,
    NetworkUnderMaintenance,
    MismatchedEnsMode,
    MismatchedRealTimeDvs,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `HostNetworkMisconfiguration`: There is a problem with the host network configuration.
/// - `HostMisconfiguration`: There is a problem with the host configuration.
/// - `InsufficientPrivileges`: The privileges were insuffient for the operation.
/// - `NoPrimaryAgentAvailable`: There was no running primary agent available to contact.
///   
///   Check that your other hosts don't have HA errors
/// - `Other`: The HA configuration failed for other reasons.
/// - `NoDatastoresConfigured`: No datastores defined for this host
/// - `CreateConfigVvolFailed`: Failure to create config vvol
/// - `VSanNotSupportedOnHost`: Host in vSAN cluster does not support vSAN.
/// - `DasNetworkMisconfiguration`: There is a problem with the cluster network configuration.
/// - `SetDesiredImageSpecFailed`: Setting desired imageSpec in Personality Manager failed
/// - `ApplyHAVibsOnClusterFailed`: The ApplyHA call to Personality Manager failed
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DasConfigFaultDasConfigFaultReasonEnum {
    HostNetworkMisconfiguration,
    HostMisconfiguration,
    InsufficientPrivileges,
    NoPrimaryAgentAvailable,
    Other,
    NoDatastoresConfigured,
    CreateConfigVvolFailed,
    VSanNotSupportedOnHost,
    DasNetworkMisconfiguration,
    SetDesiredImageSpecFailed,
    ApplyHaVibsOnClusterFailed,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Reasons why a virtual device would not be supported on a host.
/// 
/// Possible values:
/// - `host`: The host does not support this virtual device at all.
/// - `guest`: The device is supported by the host in general, but not for
///   the specific guest OS the virtual machine is using.
/// - `ft`: The device is supported by the host and guest OS, but not for
///   the vSphere Fault Tolerance.
///   
///   ***Since:*** vSphere API Release 8.0.3.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DeviceNotSupportedReasonEnum {
    Host,
    Guest,
    Ft,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The disallowed change type.
/// 
/// Possible values:
/// - `hotExtendDisk`: Online extend disk operation.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DisallowedChangeByServiceDisallowedChangeEnum {
    HotExtendDisk,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// HostSelectionType defines how the host was selected
/// 
/// Possible values:
/// - `user`: The host was specified by the user
/// - `vc`: The host was selected by Virtual Center
/// - `drs`: The host was selected by DRS
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum FtIssuesOnHostHostSelectionTypeEnum {
    User,
    Vc,
    Drs,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `Datastore`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostHasComponentFailureHostComponentTypeEnum {
    Datastore,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Reasons why fault tolerance is not supported on the host.
/// 
/// Possible values:
/// - `product`: The product does not support fault tolerance.
/// - `processor`: The product supports fault tolerance but the host CPU does not.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostIncompatibleForFaultToleranceReasonEnum {
    Product,
    Processor,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Reasons why record/replay is not supported on a host.
/// 
/// Possible values:
/// - `product`: The product does not support record/replay.
/// - `processor`: The product supports record/replay but the host CPU does not.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostIncompatibleForRecordReplayReasonEnum {
    Product,
    Processor,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `rpo`: Host does not support the RPO configured for VM replication.
/// - `netCompression`: Host does not support network compression configured for VM
///   replication.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum IncompatibleHostForVmReplicationIncompatibleReasonEnum {
    Rpo,
    NetCompression,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `admissionControl`: Policies for admission control
/// - `userHeartbeatDs`: User-specified heartbeat datastores
/// - `vmConfig`: VM override
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum InvalidDasConfigArgumentEntryForInvalidArgumentEnum {
    AdmissionControl,
    UserHeartbeatDs,
    VmConfig,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `incompatibleVersion`: The associated host and profile version are incompatible.
/// - `missingReferenceHost`: There is no reference host associated with the profile.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum InvalidProfileReferenceHostReasonEnum {
    IncompatibleVersion,
    MissingReferenceHost,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `keyEntityMismatch`: The license and the entity to which it is to be assigned are not compatible.
/// - `downgradeDisallowed`: The license downgrade is disallowed because some features are in use.
/// - `inventoryNotManageableByVirtualCenter`: The inventory has hosts which are not manageable by vCenter unless in evaluation.
/// - `hostsUnmanageableByVirtualCenterWithoutLicenseServer`: The inventory has hosts that need the license server to be configured unless vCenter is in evaluation
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum LicenseAssignmentFailedReasonEnum {
    KeyEntityMismatch,
    DowngradeDisallowed,
    InventoryNotManageableByVirtualCenter,
    HostsUnmanageableByVirtualCenterWithoutLicenseServer,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `virtualVmxnet3`: vmxnet3 virtual Ethernet adapter
/// - `paraVirtualSCSIController`: paravirtualized SCSI controller
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum NotSupportedDeviceForFtDeviceTypeEnum {
    VirtualVmxnet3,
    ParaVirtualScsiController,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Reasons why the number of virtual CPUs is incompatible.
/// 
/// Possible values:
/// - `recordReplay`: 
///   
///   Deprecated as of vSphere API 6.0.
///   
///   The virtual machine needs to support record/replay functionality.
/// - `faultTolerance`: The virtual machine is enabled for fault tolerance.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum NumVirtualCpusIncompatibleReasonEnum {
    RecordReplay,
    FaultTolerance,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `NoCompatibleNonQuarantinedHost`: The cluster does not contain any non-quarantined host satisfying the
///   VM/host affinity rules for the VM.
/// - `CorrectionDisallowed`: The current DRS migration priority setting disallows generating a
///   recommendation to prevent VMs on quarantined hosts.
///   
///   Thus, the
///   violation will not be corrected.
/// - `CorrectionImpact`: DRS has determined that evacuation of VMs from quarantined hosts
///   impacts respecting cluster constraints or performance goals so they
///   are not evacuated.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum QuarantineModeFaultFaultTypeEnum {
    NoCompatibleNonQuarantinedHost,
    CorrectionDisallowed,
    CorrectionImpact,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `diskNotFound`: Could not look up device by key
/// - `diskTypeNotSupported`: Replication not supported for disk type or backend
/// - `invalidDiskKey`: Invalid key value
/// - `invalidDiskReplicationId`: Invalid disk replication ID string
/// - `duplicateDiskReplicationId`: Another disk in the VM has the same replication ID
/// - `invalidPersistentFilePath`: Invalid path (string) for the persistent file
/// - `reconfigureDiskReplicationIdNotAllowed`: Attempting to re-configure the disk's replication ID
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ReplicationDiskConfigFaultReasonForFaultEnum {
    DiskNotFound,
    DiskTypeNotSupported,
    InvalidDiskKey,
    InvalidDiskReplicationId,
    DuplicateDiskReplicationId,
    InvalidPersistentFilePath,
    ReconfigureDiskReplicationIdNotAllowed,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `incompatibleHwVersion`: Incompatible VM hardware version
/// - `invalidVmReplicationId`: Invalid VM Replication ID string
/// - `invalidGenerationNumber`: Invalid generation number in VM's configuration
/// - `outOfBoundsRpoValue`: Invalid RPO value (out of bounds)
/// - `invalidDestinationIpAddress`: Invalid destination IP address
/// - `invalidDestinationPort`: Invalid destination port
/// - `invalidExtraVmOptions`: Malformed extra options list
/// - `staleGenerationNumber`: Mis-matching generation number (stale)
/// - `reconfigureVmReplicationIdNotAllowed`: Attempting to re-configure the VM replication ID
/// - `cannotRetrieveVmReplicationConfiguration`: Could not retrieve the VM configuration
/// - `replicationAlreadyEnabled`: Attempting to re-enable replication for the VM
/// - `invalidPriorConfiguration`: The existing replication configuration of the VM is broken
///   (applicable to re-configuration only).
/// - `replicationNotEnabled`: Attempting to re-configure or disable replication for a VM
///   for which replication has not been enabled.
/// - `replicationConfigurationFailed`: Failed to commit the new replication properties for the VM.
/// - `encryptedVm`: VM is encrypted
/// - `invalidThumbprint`: Remote certificate thumbprint is invalid
/// - `incompatibleDevice`: VM hardware contains devices incompatible with replication
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ReplicationVmConfigFaultReasonForFaultEnum {
    IncompatibleHwVersion,
    InvalidVmReplicationId,
    InvalidGenerationNumber,
    OutOfBoundsRpoValue,
    InvalidDestinationIpAddress,
    InvalidDestinationPort,
    InvalidExtraVmOptions,
    StaleGenerationNumber,
    ReconfigureVmReplicationIdNotAllowed,
    CannotRetrieveVmReplicationConfiguration,
    ReplicationAlreadyEnabled,
    InvalidPriorConfiguration,
    ReplicationNotEnabled,
    ReplicationConfigurationFailed,
    EncryptedVm,
    InvalidThumbprint,
    IncompatibleDevice,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `notConfigured`: *VirtualMachine* is not configured for replication
/// - `poweredOff`: *VirtualMachine* is powered off (and is not undergoing
///   offline replication)
/// - `suspended`: *VirtualMachine* is suspended (and is not undergoing
///   offline replication)
/// - `poweredOn`: *VirtualMachine* is powered on
/// - `offlineReplicating`: *VirtualMachine* is in the process of creating an
///   an offline instance.
/// - `invalidState`: *VirtualMachine* is in an invalid state
/// - `invalidInstanceId`: The specified instanceId does not match the *VirtualMachine*
///   instanceId
/// - `closeDiskError`: *VirtualMachine* is in the process of creating an
///   offline instance and we are trying to disable it.
///   
///   The first step is to close the offline disk. If closing disks
///   is not successful, throw this fault.
/// - `groupExist`: *VirtualMachine* is trying to create a group already
///   owned by another VM.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ReplicationVmFaultReasonForFaultEnum {
    NotConfigured,
    PoweredOff,
    Suspended,
    PoweredOn,
    OfflineReplicating,
    InvalidState,
    InvalidInstanceId,
    CloseDiskError,
    GroupExist,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `fullSync`: Initial synchronization with the remote site
/// - `delta`: Delta updates to generate a consistent instance
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ReplicationVmInProgressFaultActivityEnum {
    FullSync,
    Delta,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `licenseAssignmentFailed`: A general failure has occurred during assigning license to the 3rd party module
/// - `moduleNotInstalled`: The 3rd party module we are trying to license is not installed.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ThirdPartyLicenseAssignmentFailedReasonEnum {
    LicenseAssignmentFailed,
    ModuleNotInstalled,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `CacheModeNotSupported`
/// - `CacheConsistencyTypeNotSupported`
/// - `CacheBlockSizeNotSupported`
/// - `CacheReservationNotSupported`
/// - `DiskSizeNotSupported`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VFlashModuleNotSupportedReasonEnum {
    CacheModeNotSupported,
    CacheConsistencyTypeNotSupported,
    CacheBlockSizeNotSupported,
    CacheReservationNotSupported,
    DiskSizeNotSupported,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `haNotEnabled`: HA is not enabled on the cluster
/// - `moreThanOneSecondary`: There is already a secondary virtual machine for the primary
///   virtual machine
/// - `recordReplayNotSupported`: 
///   
///   Deprecated as of vSphere API 6.0.
///   
///   The virtual machine does not support record/replay.
///   
///   Vm::Capability.RecordReplaySupported is false.
/// - `replayNotSupported`: 
///   
///   Deprecated as of vSphere API 6.0.
///   
///   It is not possible to turn on Fault Tolerance on this powered-on VM.
///   
///   The support for record/replay should be enabled or Fault Tolerance
///   turned on, when this VM is powered off.
/// - `templateVm`: The virtual machine is a template
/// - `multipleVCPU`: The virtual machine has more than one virtual CPU
/// - `hostInactive`: The host is not active
/// - `ftUnsupportedHardware`: The host ftSupported flag is not set because of hardware issues
/// - `ftUnsupportedProduct`: The host ftSupported flag is not set because of it is a
///   VMware Server 2.0
/// - `missingVMotionNic`: No VMotion license or VMotion nic is not configured on the host
/// - `missingFTLoggingNic`: FT logging nic is not configured on the host
/// - `thinDisk`: The virtual machine has thin provisioned disks
/// - `verifySSLCertificateFlagNotSet`: The "check host certificate" flag is not set
/// - `hasSnapshots`: The virtual machine has one or more snapshots
/// - `noConfig`: No configuration information is available for the virtual machine
/// - `ftSecondaryVm`: The virtual machine is a fault tolerance secondary virtual machine
/// - `hasLocalDisk`: The virtual machine has one or more disks on local datastore
/// - `esxAgentVm`: The virtual machine is an ESX agent VM
/// - `video3dEnabled`: The virtual machine video device has 3D enabled
/// - `hasUnsupportedDisk`
/// - `insufficientBandwidth`: FT logging nic does not have desired bandwidth
/// - `hasNestedHVConfiguration`: The host does not support fault tolerant VM with nested HV or VBS
///   enabled.
/// - `hasVFlashConfiguration`: The virtual machine has a vFlash memory device or/and disks with
///   vFlash cache configured.
/// - `unsupportedProduct`: VMware product installed on the host does not support
///   fault tolerance
/// - `cpuHvUnsupported`: Host CPU does not support hardware virtualization
/// - `cpuHwmmuUnsupported`: Host CPU does not support hardware MMU virtualization
/// - `cpuHvDisabled`: Host CPU is compatible for replay-based FT, but hardware
///   virtualization has been disabled in the BIOS.
/// - `hasEFIFirmware`: The virtual machine firmware is of type EFI
/// - `tooManyVCPUs`: The host does not support fault tolerance virtual machines
///   with the specified number of virtual CPUs.
/// - `tooMuchMemory`: The host does not support fault tolerance virtual machines
///   with the specified amount of memory.
/// - `vMotionNotLicensed`: No VMotion license
///   
///   ***Since:*** vSphere API Release 8.0.3.0
/// - `ftNotLicensed`: Host does not have proper FT license
///   
///   ***Since:*** vSphere API Release 8.0.3.0
/// - `haAgentIssue`: Host does not have HA agent running properly
///   
///   ***Since:*** vSphere API Release 8.0.3.0
/// - `unsupportedSPBM`: The VM has unsupported storage policy
///   
///   ***Since:*** vSphere API Release 8.0.3.0
/// - `hasLinkedCloneDisk`: The virtual machine has virtual disk in linked-clone mode
///   
///   ***Since:*** vSphere API Release 8.0.3.0
/// - `unsupportedPMemHAFailOver`: Virtual Machine with Pmem HA Failover is not supported
///   
///   ***Since:*** vSphere API Release 7.0.2.0
/// - `unsupportedEncryptedDisk`: Virtual Machine with encrypted virtual disk is not supported.
///   
///   ***Since:*** vSphere API Release 8.0.3.0
/// - `ftMetroClusterNotEditable`: The virtual machine does not allow to enable or disable FT Metro
///   Cluster while FT is turned on.
///   
///   ***Since:*** vSphere API Release 8.0.3.0
/// - `noHostGroupConfigured`: Cannot turn on vSphere Fault Tolerance on a FT Metro Cluster enabled VM
///   with no Host Group configured.
///   
///   ***Since:*** vSphere API Release 8.0.3.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VmFaultToleranceConfigIssueReasonForIssueEnum {
    HaNotEnabled,
    MoreThanOneSecondary,
    RecordReplayNotSupported,
    ReplayNotSupported,
    TemplateVm,
    MultipleVcpu,
    HostInactive,
    FtUnsupportedHardware,
    FtUnsupportedProduct,
    MissingVMotionNic,
    MissingFtLoggingNic,
    ThinDisk,
    VerifySslCertificateFlagNotSet,
    HasSnapshots,
    NoConfig,
    FtSecondaryVm,
    HasLocalDisk,
    EsxAgentVm,
    Video3DEnabled,
    HasUnsupportedDisk,
    InsufficientBandwidth,
    HasNestedHvConfiguration,
    HasVFlashConfiguration,
    UnsupportedProduct,
    CpuHvUnsupported,
    CpuHwmmuUnsupported,
    CpuHvDisabled,
    HasEfiFirmware,
    TooManyVcpUs,
    TooMuchMemory,
    VMotionNotLicensed,
    FtNotLicensed,
    HaAgentIssue,
    UnsupportedSpbm,
    HasLinkedCloneDisk,
    UnsupportedPMemHaFailOver,
    UnsupportedEncryptedDisk,
    FtMetroClusterNotEditable,
    NoHostGroupConfigured,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `virtualFloppy`: virtual floppy
/// - `virtualCdrom`: virtual Cdrom
/// - `virtualSerialPort`: virtual serial port
/// - `virtualParallelPort`: virtual parallel port
/// - `virtualDisk`: virtual disk
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VmFaultToleranceInvalidFileBackingDeviceTypeEnum {
    VirtualFloppy,
    VirtualCdrom,
    VirtualSerialPort,
    VirtualParallelPort,
    VirtualDisk,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `svmotion`: storage vmotion resolution
/// - `relocate`: relocate resolution
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum WillLoseHaProtectionResolutionEnum {
    Svmotion,
    Relocate,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `SHA1`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostActiveDirectoryAuthenticationCertificateDigestEnum {
    Sha1,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `unknown`: The Active Directory integration provider does not support
///   domain trust checks.
/// - `ok`: No problems with the domain membership.
/// - `noServers`: The host thinks it's part of a domain,
///   but no domain controllers could be reached to confirm.
/// - `clientTrustBroken`: The client side of the trust relationship is broken.
/// - `serverTrustBroken`: The server side of the trust relationship is broken
///   (or bad machine password).
/// - `inconsistentTrust`: Unexpected domain controller responded.
/// - `otherProblem`: There's some problem with the domain membership.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostActiveDirectoryInfoDomainMembershipStatusEnum {
    Unknown,
    Ok,
    NoServers,
    ClientTrustBroken,
    ServerTrustBroken,
    InconsistentTrust,
    OtherProblem,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `none`: No action is taken for this virtual machine.
///   
///   This virtual machine is
///   not a part of the auto-start sequence. This can be used for both auto-start
///   and auto-start settings.
/// - `systemDefault`: The default system action is taken for this virtual machine when it is next in
///   the auto-start order.
///   
///   This can be used for both auto-start and auto-start
///   settings.
/// - `powerOn`: This virtual machine is powered on when it is next in the auto-start order.
/// - `powerOff`: This virtual machine is powered off when it is next in the auto-stop order.
///   
///   This is the default stopAction.
/// - `guestShutdown`: The guest operating system for a virtual machine is shut down when that
///   virtual machine in next in the auto-stop order.
/// - `suspend`: This virtual machine is suspended when it is next in the auto-stop order.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum AutoStartActionEnum {
    None,
    SystemDefault,
    PowerOn,
    PowerOff,
    GuestShutdown,
    Suspend,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Determines if the virtual machine should start after receiving a heartbeat,
/// ignore heartbeats and start after the startDelay has elapsed, or follow the
/// system default before powering on.
/// 
/// When a virtual machine is next in the start
/// order, the system either waits a specified period of time for a virtual
/// 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.
/// 
/// Possible values:
/// - `yes`: The system waits until receiving a heartbeat before powering on the next
///   machine in the order.
/// - `no`: The system does not wait to receive a heartbeat before powering on the next
///   machine in the order.
///   
///   This is the default setting.
/// - `systemDefault`: The system uses the default value to determine whether or not to wait to
///   receive a heartbeat before powering on the next machine in the order.
///
/// ### How to access
/// - `HostSystem::config.auto_start?.power_info?[*].wait_for_heartbeat`
/// - `HostAutoStartManager::config.power_info?[*].wait_for_heartbeat`
/// - `HostAutoStartManager::reconfigure_autostart(spec).power_info?[*].wait_for_heartbeat`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum AutoStartWaitHeartbeatSettingEnum {
    Yes,
    No,
    SystemDefault,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration of the supported firmware types.
/// 
/// Possible values:
/// - `BIOS`
/// - `UEFI`
/// 
/// ***Since:*** vSphere API Release 8.0.2.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostBiosInfoFirmwareTypeEnum {
    Bios,
    Uefi,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Deprecated as of vSphere API 7.0, use
/// *VmFaultToleranceConfigIssueReasonForIssue_enum*.
/// 
/// Set of possible values for
/// *HostCapability.ftCompatibilityIssues*
/// 
/// Possible values:
/// - `vMotionNotLicensed`: No VMotion license
/// - `missingVMotionNic`: VMotion nic is not configured on the host
/// - `missingFTLoggingNic`: FT logging nic is not configured on the host
/// - `ftNotLicensed`: Host does not have proper FT license
/// - `haAgentIssue`: Host does not have HA agent running properly
/// - `unsupportedProduct`: VMware product installed on the host does not support
///   fault tolerance
/// - `cpuHvUnsupported`: Host CPU does not support hardware virtualization
/// - `cpuHwmmuUnsupported`: Host CPU does not support hardware MMU virtualization
/// - `cpuHvDisabled`: Host CPU is compatible for replay-based FT, but hardware
///   virtualization has been disabled in the BIOS.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostCapabilityFtUnsupportedReasonEnum {
    VMotionNotLicensed,
    MissingVMotionNic,
    MissingFtLoggingNic,
    FtNotLicensed,
    HaAgentIssue,
    UnsupportedProduct,
    CpuHvUnsupported,
    CpuHwmmuUnsupported,
    CpuHvDisabled,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Deprecated as of vSphere API 6.0.
/// 
/// Set of possible values for
/// *HostCapability.replayUnsupportedReason* and
/// *HostCapability.replayCompatibilityIssues*.
/// 
/// Possible values:
/// - `incompatibleProduct`
/// - `incompatibleCpu`
/// - `hvDisabled`
/// - `cpuidLimitSet`
/// - `oldBIOS`
/// - `unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostReplayUnsupportedReasonEnum {
    IncompatibleProduct,
    IncompatibleCpu,
    HvDisabled,
    CpuidLimitSet,
    OldBios,
    Unknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Set of VMFS unmap API version.
/// 
/// Possible values:
/// - `priority`: only the unmap priority is supported
/// - `fixed`: the unmap bandwidth can be set as a fixed value
/// - `dynamic`: the unmap bandwidth can be set as a range, where the actual
///   bandwidth will be dynamically throttled by the backened
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostCapabilityUnmapMethodSupportedEnum {
    Priority,
    Fixed,
    Dynamic,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Set of possible values for *HostCapability.vmDirectPathGen2UnsupportedReason*.
/// 
/// Possible values:
/// - `hostNptIncompatibleProduct`: The host software does not support VMDirectPath Gen 2.
/// - `hostNptIncompatibleHardware`: The host hardware does not support VMDirectPath Gen 2.
///   
///   Note that
///   this is a general capability for the host and is independent of
///   support by a given physical NIC.
/// - `hostNptDisabled`: The host is configured to disable VMDirectPath Gen 2.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostCapabilityVmDirectPathGen2UnsupportedReasonEnum {
    HostNptIncompatibleProduct,
    HostNptIncompatibleHardware,
    HostNptDisabled,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The status of a given certificate as computed per the soft and the hard
/// thresholds in vCenter Server.
/// 
///   
///   
/// There are two different thresholds for the host certificate
/// expirations; a soft threshold (which constitutes of two phases) and a
/// hard threshold.
///   
///   
/// Soft Threshold:
///   
/// Phase One: vCenter Server will publish an event at
/// this time to let the user know about the status, but, no alarms or
/// warnings are raised.
///   
/// Phase Two: During this phase, vCenter Server will publish an event and
/// indicate the certificate status as expiring in the UI.
///   
///   
/// Hard Threshold:
///   
/// vCenter Server will publish an alarm and indicate via the UI that the
/// certificate expiration is imminent.
/// 
/// Possible values:
/// - `unknown`: The certificate status is unknown.
/// - `expired`: The certificate has expired.
/// - `expiring`: The certificate is expiring shortly.
///   
///   (soft threshold - 1)
/// - `expiringShortly`: The certificate is expiring shortly.
///   
///   (soft threshold - 2)
/// - `expirationImminent`: The certificate expiration is imminent.
///   
///   (hard threshold)
/// - `good`: The certificate is good.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostCertificateManagerCertificateInfoCertificateStatusEnum {
    Unknown,
    Expired,
    Expiring,
    ExpiringShortly,
    ExpirationImminent,
    Good,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Certificate type supported by Host
/// 
/// Possible values:
/// - `Machine`: Machine certificate of the Host
/// - `VASAClient`: VASA Client certificate used for communication with VASA Provider
///   
/// ***Since:*** vSphere API Release 8.0.1.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostCertificateManagerCertificateKindEnum {
    Machine,
    VasaClient,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This is a global mode on a configuration specification indicating
/// whether the structure represents the desired state or the set of
/// operations to apply on the managed object.
/// 
/// Possible values:
/// - `modify`: Indicates that the structure represents the
///   set of operations to apply on the managed object.
/// - `replace`: Indicates that the structure represents the
///   desired state of the managed object.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostConfigChangeModeEnum {
    Modify,
    Replace,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This list indicates the operation that should be performed for an
/// entity.
/// 
/// Possible values:
/// - `add`: Indicates the addition of an entity to the configuration.
/// - `remove`: Indicates the removal of an entity from the configuration.
/// - `edit`: Indicates changes on the entity.
///   
///   The entity must exist or a
///   *NotFound* error will be thrown.
/// - `ignore`: Indicates that an entity will be ignored: it won't be added when it
///   doesn't exist, or removed/changed when it exists.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostConfigChangeOperationEnum {
    Add,
    Remove,
    Edit,
    Ignore,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This list indicates the owner of an entity.
/// 
/// Possible values:
/// - `NSX`: The owner is NSX (Network Virtualization and Security).
/// - `VSAN`: The owner is vSAN (VMware Virtual Storage Area Network).
///   
/// ***Since:*** vSphere API Release 9.0.0.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostConfigChangeOwnerEnum {
    Nsx,
    Vsan,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `unknown`
/// - `intel`
/// - `amd`
/// - `hygon`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostCpuPackageVendorEnum {
    Unknown,
    Intel,
    Amd,
    Hygon,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values for Current CPU power management policy
/// 
/// Possible values:
/// - `off`
/// - `staticPolicy`
/// - `dynamicPolicy`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostCpuPowerManagementInfoPolicyTypeEnum {
    Off,
    StaticPolicy,
    DynamicPolicy,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `systemDefault`: The CPU scheduler on this host is running without any modifications
///   or mitigations.
/// - `scav1`: The CPU scheduler on this host is using only one hyperthread per
///   core to mitigate a security vulnerability.
/// - `scav2`: The CPU scheduler on this host is using hyperthreads, with
///   Side-Channel aware scheduling to mitigate a security vulnerability.
///   
/// ***Since:*** vSphere API Release 8.0.3.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostCpuSchedulerInfoCpuSchedulerPolicyInfoEnum {
    SystemDefault,
    Scav1,
    Scav2,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Types of time synchronization protocols.
/// 
/// Possible values:
/// - `ntp`: Network Time Protocol (NTP).
/// - `ptp`: Precision Time Protocol (PTP).
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostDateTimeInfoProtocolEnum {
    Ntp,
    Ptp,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The type of diagnostic partition.
/// 
/// Private diagnostic partition has one
/// slot, so can only be used by one host. Shared diagnostic parititon
/// needs multiple slots so to be usable by multiple hosts.
/// 
/// Possible values:
/// - `singleHost`
/// - `multiHost`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DiagnosticPartitionTypeEnum {
    SingleHost,
    MultiHost,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Type of partition indicating the type of storage on which the partition
/// resides.
/// 
/// If the diagnostic partition is local only, it will only need
/// 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.
/// 
/// Possible values:
/// - `directAttached`
/// - `networkAttached`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DiagnosticPartitionStorageTypeEnum {
    DirectAttached,
    NetworkAttached,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The set of digest methods that can be used by TPM to calculate the PCR
/// values.
/// 
/// Possible values:
/// - `SHA1`
/// - `MD5`: 
///   
///   Deprecated as of vSphere API 6.7.
///   
///   MD5.
/// - `SHA256`
/// - `SHA384`
/// - `SHA512`
/// - `SM3_256`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostDigestInfoDigestMethodTypeEnum {
    Sha1,
    Md5,
    Sha256,
    Sha384,
    Sha512,
    Sm3256,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This enum specifies the supported digest verification settings.
/// 
/// For NVMe over TCP connections, both header and data digests may be
/// requested during the process of establishing the connection.
/// For details, see:
/// - NVM Express Technical Proposal 8000 - NVMe/TCP Transport,
///   Section 7.4.6, "PDU Header and Data Digests"
///   
/// Possible values:
/// - `digestDisabled`: Both header and data digest verification are disabled.
/// - `headerOnly`: Only header digest verification is enabled.
/// - `dataOnly`: Only data digest verification is enabled.
/// - `headerAndData`: Both header and data digest verification are enabled.
///   
/// ***Since:*** vSphere API Release 7.0.3.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostDigestVerificationSettingEnum {
    DigestDisabled,
    HeaderOnly,
    DataOnly,
    HeaderAndData,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// List of partition format types.
/// 
/// This denotes the partition table layout.
/// 
/// Possible values:
/// - `gpt`
/// - `mbr`
/// - `unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostDiskPartitionInfoPartitionFormatEnum {
    Gpt,
    Mbr,
    Unknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// List of symbol partition types
/// 
/// Possible values:
/// - `none`
/// - `vmfs`
/// - `linuxNative`
/// - `linuxSwap`
/// - `extended`
/// - `ntfs`
/// - `vmkDiagnostic`
/// - `vffs`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostDiskPartitionInfoTypeEnum {
    None,
    Vmfs,
    LinuxNative,
    LinuxSwap,
    Extended,
    Ntfs,
    VmkDiagnostic,
    Vffs,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Set of possible values for
/// *HostFeatureVersionInfo.key*, which
/// is a unique key that identifies a feature.
/// 
/// Possible values:
/// - `faultTolerance`: VMware Fault Tolerance feature.
///   
///   For pre-4.1 hosts, the
///   version value reported will be empty in which case
///   *AboutInfo.build* should be used. For all
///   other hosts, the version number reported will be a component-specific
///   version identifier of the form X.Y.Z, where:
///   X refers to host agent Fault Tolerance version number,
///   Y refers to VMX Fault Tolerance version number,
///   Z refers to VMkernal Fault Tolerance version
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostFeatureVersionKeyEnum {
    FaultTolerance,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The operating mode of the adapter.
/// 
/// Possible values:
/// - `fabric`
/// - `loop`
/// - `pointToPoint`
/// - `unknown`
///
/// ### How to access
/// - `HostSystem::config.storage_device?.host_bus_adapter?[*]⇒HostFibreChannelHbaTrait.port_type`
/// - `HostStorageSystem::storage_device_info.host_bus_adapter?[*]⇒HostFibreChannelHbaTrait.port_type`
/// - `HostProfileManager::apply_host_config_task(config_spec).storage_device?.host_bus_adapter?[*]⇒HostFibreChannelHbaTrait.port_type`
/// - `HostProfileManager::generate_config_task_list(config_spec).storage_device?.host_bus_adapter?[*]⇒HostFibreChannelHbaTrait.port_type`
/// - `HostProfileManager::generate_host_profile_task_list_task(config_spec).storage_device?.host_bus_adapter?[*]⇒HostFibreChannelHbaTrait.port_type`
/// - `HostProfile::execute_host_profile().config_spec?.storage_device?.host_bus_adapter?[*]⇒HostFibreChannelHbaTrait.port_type`
/// - `HostProfileManager::generate_config_task_list().config_spec?.storage_device?.host_bus_adapter?[*]⇒HostFibreChannelHbaTrait.port_type`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum FibreChannelPortTypeEnum {
    Fabric,
    Loop,
    PointToPoint,
    Unknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Status of volume's support for vStorage hardware acceleration.
/// 
/// The ESX Server determines the status based on the capabilities
/// of the devices that support the file system volume.
/// When a host boots, the support status is unknown.
/// As the ESX host attempts hardware-accelerated operations,
/// it determines whether the storage device supports hardware
/// acceleration and sets the *HostFileSystemMountInfo.vStorageSupport*
/// property accordingly.
/// 
/// Possible values:
/// - `vStorageSupported`: Storage device supports hardware acceleration.
///   
///   The ESX host will use the feature to offload certain
///   storage-related operations to the device.
/// - `vStorageUnsupported`: Storage device does not support hardware acceleration.
///   
///   The ESX host will handle all storage-related operations.
/// - `vStorageUnknown`: Initial support status value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum FileSystemMountInfoVStorageSupportStatusEnum {
    VStorageSupported,
    VStorageUnsupported,
    VStorageUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Type of file system volume.
/// 
/// Possible values:
/// - `VMFS`: VMware File System (ESX Server only).
///   
///   If this is set,
///   the type of the file system volume is VMFS.
/// - `NFS`: Network file system v3 linux &amp; esx servers only.
///   
///   If this is
///   set, the type of the file system volume is NFS v3.
/// - `NFS41`: Network file system v4.1 linux &amp; esx servers only.
///   
///   If this is
///   set, the type of the file system volume is NFS v4.1 or later.
/// - `CIFS`: Common Internet File System.
///   
///   If this is set, the type of the
///   file system volume is Common Internet File System.
/// - `vsan`: VSAN File System (ESX Server only).
/// - `VFFS`: vFlash File System (ESX Server only).
///   
///   If this is set, the type of the file system volume is VFFS.
/// - `VVOL`: vvol File System (ESX Server only).
/// - `PMEM`: 
///   
///   Deprecated as of vSphere 9.0 APIs with no replacement.
///   
///   Persistent Memory File System (ESX Server only).
/// - `vsanD`: VSAN direct file system.
///   
///   ***Since:*** vSphere API Release 7.0.1.0
/// - `OTHER`: Used if the file system is not one of the specified file systems.
///   
///   Used mostly for reporting purposes. The other types are described
///   by the otherType property.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostFileSystemVolumeFileSystemTypeEnum {
    Vmfs,
    Nfs,
    Nfs41,
    Cifs,
    Vsan,
    Vffs,
    Vvol,
    Pmem,
    VsanD,
    Other,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// List of available firewall ruleset ids
/// 
/// Possible values:
/// - `faultTolerance`
/// - `fdm`
/// - `updateManager`
/// - `vpxHeartbeats`
/// 
/// ***Since:*** vSphere API Release 8.0.2.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostFirewallSystemRuleSetIdEnum {
    FaultTolerance,
    Fdm,
    UpdateManager,
    VpxHeartbeats,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// List of available service names
/// 
/// Possible values:
/// - `vpxa`
/// 
/// ***Since:*** vSphere API Release 8.0.2.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostFirewallSystemServiceNameEnum {
    Vpxa,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The vendor definition for type of Field Replaceable Unit (FRU).
/// 
/// Possible values:
/// - `undefined`
/// - `board`
/// - `product`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostFruFruTypeEnum {
    Undefined,
    Board,
    Product,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Supported values for graphics type.
/// 
/// Possible values:
/// - `shared`: Shared graphics (ex.
///   
///   virtual shared graphics acceleration).
/// - `sharedDirect`: Shared direct graphics (ex.
///   
///   vendor vGPU shared passthrough).
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostGraphicsConfigGraphicsTypeEnum {
    Shared,
    SharedDirect,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Supported values for shared passthrough assignment policy
/// 
/// Possible values:
/// - `performance`: Performance policy: assign VM to GPU with fewest VMs.
/// - `consolidation`: Consolidation policy: group like VMs on GPU until fully loaded.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostGraphicsConfigSharedPassthruAssignmentPolicyEnum {
    Performance,
    Consolidation,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Supported values for vGPU mode.
/// 
/// Possible values:
/// - `sameSize`: vGPU time-sliced same size.
/// - `mixedSize`: vGPU time-sliced mixed size.
///   
/// ***Since:*** vSphere API Release 8.0.3.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostGraphicsConfigVgpuModeEnum {
    SameSize,
    MixedSize,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values for graphics type.
/// 
/// Possible values:
/// - `basic`: Basic graphics when no host driver is available.
/// - `shared`: Shared graphics (ex.
///   
///   virtual shared graphics acceleration).
/// - `direct`: Direct graphics (ex.
///   
///   passthrough).
/// - `sharedDirect`: Shared direct graphics (ex.
///   
///   vGPU shared passthrough).
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostGraphicsInfoGraphicsTypeEnum {
    Basic,
    Shared,
    Direct,
    SharedDirect,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values for vGPU mode.
/// 
/// Possible values:
/// - `none`: vGPU mode not applicable.
/// - `sameSize`: vGPU time-sliced same size.
/// - `mixedSize`: vGPU time-sliced mixed size.
/// - `multiInstanceGpu`: vGPU multi-instance GPU.
///   
/// ***Since:*** vSphere API Release 8.0.3.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostGraphicsInfoVgpuModeEnum {
    None,
    SameSize,
    MixedSize,
    MultiInstanceGpu,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The current status of the hardware
/// 
/// Possible values:
/// - `Unknown`: The implementation cannot report on the current status of the
///   physical element
/// - `Green`: The physical element is functioning as expected
/// - `Yellow`: All functionality is available but some might be degraded.
/// - `Red`: The physical element is failing.
///   
///   It is possible that some or all
///   functionalities of this physical element is degraded or not working.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostHardwareElementStatusEnum {
    Unknown,
    Green,
    Yellow,
    Red,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines different access modes that a user may have on the host for
/// direct host connections.
/// 
/// The assumption here is that when the host is managed by vCenter,
/// we don't need fine-grained control on local user permissions like the
/// interface provided by *AuthorizationManager*.
/// 
/// Possible values:
/// - `accessNone`: Indicates that the user has no explicitly defined permissions or roles.
///   
///   This is used when we want to remove all permissions for some user.
///   
///   Note that this is not the same as *accessNoAccess*.
/// - `accessAdmin`: Describes a propagating Admin role on the root inventory object
///   (root folder) on the host, and no other non-Admin role on any other
///   object.
///   
///   The same permissions are needed to login to local or remote
///   shell (ESXiShell or SSH).
/// - `accessNoAccess`: Describes a propagating NoAccess role on the root inventory object
///   (root folder) on the host, and no other roles.
///   
///   Even if the user has another (redundant) NoAccess role on some other
///   inventory object, then the access mode for this user will be
///   classified as *accessOther*.
///   
///   This mode may be used to restrict a specific user account without
///   restricting the access mode for the group to which the user belongs.
/// - `accessReadOnly`: Describes a propagating ReadOnly role on the root inventory object
///   (root folder) on the host, and no other roles.
///   
///   Even if the user has another (redundant) ReadOnly role on some other
///   inventory object, then the access mode for this user will be
///   *accessOther*.
/// - `accessOther`: Describes a combination of one or more roles/permissions which are
///   none of the above.
///
/// ### How to access
/// - `HostAccessManager::change_access_mode(access_mode)`
/// - `HostAccessManager::retrieve_host_access_control_entries().access_mode`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostAccessModeEnum {
    AccessNone,
    AccessAdmin,
    AccessNoAccess,
    AccessReadOnly,
    AccessOther,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines the possible states of lockdown mode.
/// 
/// Possible values:
/// - `lockdownDisabled`: Indicates that lockdown mode is disabled.
/// - `lockdownNormal`: Indicates that lockdown mode is enabled with service DCUI
///   (Direct Console User Interface) running.
/// - `lockdownStrict`: Indicates that lockdown mode is enabled with service DCUI stopped.
///   
///   If the host is in "strict" lockdown mode then no one will be able
///   to exit lockdown mode through DCUI in emergency situations,
///   i.e. when the connection to vCenter server is permanently lost.
///
/// ### How to access
/// - `HostSystem::config.lockdown_mode?`
/// - `ClusterComputeResource::hci_config.host_config_profile?.lockdown_mode?`
/// - `HostAccessManager::lockdown_mode`
/// - `HostSystem::reconnect_host_task(cnx_spec).lockdown_mode?`
/// - `Folder::add_standalone_host_task(spec).lockdown_mode?`
/// - `Folder::batch_add_hosts_to_cluster_task(new_hosts).host_cnx_spec.lockdown_mode?`
/// - `Folder::batch_add_standalone_hosts_task(new_hosts).host_cnx_spec.lockdown_mode?`
/// - `Folder::add_standalone_host_task(comp_res_spec).host_seed_spec?.single_host_spec.new_host_cnx_spec?.lockdown_mode?`
/// - `Folder::batch_add_hosts_to_cluster_task(comp_res_spec).host_seed_spec?.single_host_spec.new_host_cnx_spec?.lockdown_mode?`
/// - `Datacenter::batch_query_connect_info(host_specs).lockdown_mode?`
/// 
/// *(10 of 27 paths)*
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostLockdownModeEnum {
    LockdownDisabled,
    LockdownNormal,
    LockdownStrict,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Acceptance level definitions
/// 
/// Possible values:
/// - `vmware_certified`: "VMware-certified"
/// - `vmware_accepted`: "VMware-accepted"
/// - `partner`: "Partner-supported"
/// - `community`: "Community-supported"
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostImageAcceptanceLevelEnum {
    VmwareCertified,
    VmwareAccepted,
    Partner,
    Community,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The type of CHAP authentication setting to use.
/// 
/// prohibited : do not use CHAP.
/// preferred : use CHAP if successfully negotiated,
/// but allow non-CHAP connections as fallback
/// discouraged : use non-CHAP, but allow CHAP connectsion as fallback
/// required : use CHAP for connection strictly, and fail if CHAP
/// negotiation fails.
/// Defaults to preferred on first configuration if unspecified.
/// 
/// Possible values:
/// - `chapProhibited`
/// - `chapDiscouraged`
/// - `chapPreferred`
/// - `chapRequired`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostInternetScsiHbaChapAuthenticationTypeEnum {
    ChapProhibited,
    ChapDiscouraged,
    ChapPreferred,
    ChapRequired,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The type of integrity checks to use.
/// 
/// The digest setting for header
/// and data traffic can be separately configured.
/// prohibited : do not use digest.
/// preferred : use digest if successfully negotiated, but skip the use
/// of digest otherwise.
/// discouraged : do not use digest if target allows, otherwise use digest.
/// required : use digest strictly, and fail if target does not support
/// digest.
/// Defaults to preferred on first configuration if unspecified.
/// 
/// Possible values:
/// - `digestProhibited`
/// - `digestDiscouraged`
/// - `digestPreferred`
/// - `digestRequired`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostInternetScsiHbaDigestTypeEnum {
    DigestProhibited,
    DigestDiscouraged,
    DigestPreferred,
    DigestRequired,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The available iSNS discovery methods.
/// 
/// Possible values:
/// - `isnsStatic`
/// - `isnsDhcp`
/// - `isnsSlp`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum InternetScsiSnsDiscoveryMethodEnum {
    IsnsStatic,
    IsnsDhcp,
    IsnsSlp,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The available SLP discovery methods.
/// 
/// Possible values:
/// - `slpDhcp`: Use DHCP to find the SLP DAs.
/// - `slpAutoUnicast`: Use broadcasting to find SLP DAs.
///   
///   Only DAs on the current subnet will be found.
/// - `slpAutoMulticast`: Use the well known multicast address to find DAs.
/// - `slpManual`: User specified address for a DA.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum SlpDiscoveryMethodEnum {
    SlpDhcp,
    SlpAutoUnicast,
    SlpAutoMulticast,
    SlpManual,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// enum listing possible IPv6 address configuration methods.
/// 
/// Possible values:
/// - `DHCP`: DHCP
/// - `AutoConfigured`: Auto configured.
///   
///   Auto configured Link local address and Router Advertisement addresses
///   would be of this type.
/// - `Static`: Static address.
///   
///   Typically user specified addresses will be static addresses.
///   User can specify link local address. Only Static addresses can be added or removed.
/// - `Other`: Other or unknown type.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostInternetScsiHbaIscsiIpv6AddressAddressConfigurationTypeEnum {
    Dhcp,
    AutoConfigured,
    Static,
    Other,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// enum listing IPv6 address operations.
/// 
/// Possible values:
/// - `add`
/// - `remove`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostInternetScsiHbaIscsiIpv6AddressIPv6AddressOperationEnum {
    Add,
    Remove,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The binding mode of the adapter.
/// 
/// Possible values:
/// - `notsupported`
/// - `optional`
/// - `required`
///
/// ### How to access
/// - `HostSystem::config.storage_device?.host_bus_adapter?[*]→HostInternetScsiHba.network_binding_support?`
/// - `HostStorageSystem::storage_device_info.host_bus_adapter?[*]→HostInternetScsiHba.network_binding_support?`
/// - `HostProfileManager::apply_host_config_task(config_spec).storage_device?.host_bus_adapter?[*]→HostInternetScsiHba.network_binding_support?`
/// - `HostProfileManager::generate_config_task_list(config_spec).storage_device?.host_bus_adapter?[*]→HostInternetScsiHba.network_binding_support?`
/// - `HostProfileManager::generate_host_profile_task_list_task(config_spec).storage_device?.host_bus_adapter?[*]→HostInternetScsiHba.network_binding_support?`
/// - `HostProfile::execute_host_profile().config_spec?.storage_device?.host_bus_adapter?[*]→HostInternetScsiHba.network_binding_support?`
/// - `HostProfileManager::generate_config_task_list().config_spec?.storage_device?.host_bus_adapter?[*]→HostInternetScsiHba.network_binding_support?`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostInternetScsiHbaNetworkBindingSupportTypeEnum {
    Notsupported,
    Optional,
    Required,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The method of discovery of an iScsi target.
/// 
/// staticMethod: static discovery
/// sendTargetsMethod: sendtarget discovery
/// slpMethod: Service Location Protocol discovery
/// isnsMethod: Internet Storage Name Service discovery
/// unknownMethod: discovery method not identified by iscsi stack
/// 
/// Possible values:
/// - `staticMethod`
/// - `sendTargetMethod`
/// - `slpMethod`
/// - `isnsMethod`
/// - `unknownMethod`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostInternetScsiHbaStaticTargetTargetDiscoveryMethodEnum {
    StaticMethod,
    SendTargetMethod,
    SlpMethod,
    IsnsMethod,
    UnknownMethod,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This specifies how the ipv6 address is configured for the interface.
/// 
/// We follow rfc4293 in defining the values for the configType.
/// 
/// Possible values:
/// - `other`: Any other type of address configuration other than the below
///   mentioned ones will fall under this category.
///   
///   For e.g., automatic
///   address configuration for the link local address falls under
///   this type.
/// - `manual`: The address is configured manually.
/// - `dhcp`: The address is configured through dhcp.
/// - `linklayer`: The address is obtained through stateless autoconfiguration.
/// - `random`: The address is chosen by the system at random
///   e.g., an IPv4 address within 169.254/16, or an RFC
///   3041 privacy address.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostIpConfigIpV6AddressConfigTypeEnum {
    Other,
    Manual,
    Dhcp,
    Linklayer,
    Random,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `preferred`: Indicates that this is a valid address.
/// - `deprecated`: Indicates that this is a valid but deprecated address
///   that should no longer be used as a source address.
/// - `invalid`: Indicates that this isn't a valid.
/// - `inaccessible`: Indicates that the address is not accessible because
///   interface is not operational.
/// - `unknown`: Indicates that the status cannot be determined.
/// - `tentative`: Indicates that the uniqueness of the
///   address on the link is presently being verified.
/// - `duplicate`: Indicates the address has been determined to be non-unique
///   on the link, this address will not be reachable.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostIpConfigIpV6AddressStatusEnum {
    Preferred,
    Deprecated,
    Invalid,
    Inaccessible,
    Unknown,
    Tentative,
    Duplicate,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `notUsed`: There are no paths on this Virtual NIC
/// - `active`: All paths on this Virtual NIC are standby paths from SCSI stack
///   perspective.
/// - `standBy`: One or more paths on the Virtual NIC are active paths to
///   storage.
///   
///   Unbinding this Virtual NIC will cause storage path
///   transitions.
/// - `lastActive`: One or more paths on the Virtual NIC is the last active
///   path to a particular storage device.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum IscsiPortInfoPathStatusEnum {
    NotUsed,
    Active,
    StandBy,
    LastActive,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The Discovery Protocol operation.
/// 
/// Possible values:
/// - `none`: Don't listen for incoming discovery packets and don't sent discover
///   packets for the switch either.
/// - `listen`: Listen for incoming discovery packets but don't sent discovery packet
///   for the switch.
/// - `advertise`: Sent discovery packets for the switch, but don't listen for incoming
///   discovery packets.
/// - `both`: Sent discovery packets for the switch and listen for incoming
///   discovery packets.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum LinkDiscoveryProtocolConfigOperationTypeEnum {
    None,
    Listen,
    Advertise,
    Both,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The Discovery Protocol types.
/// 
/// Possible values:
/// - `cdp`: Cisco Discovery Protocol
/// - `lldp`: Link Layer Discovery Protocol
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum LinkDiscoveryProtocolConfigProtocolTypeEnum {
    Cdp,
    Lldp,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This enum defines the possible types of file types that can be reserved
/// or deleted
/// 
/// Possible values:
/// - `File`
/// - `VirtualDisk`
/// - `Directory`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostLowLevelProvisioningManagerFileTypeEnum {
    File,
    VirtualDisk,
    Directory,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The target of the disk reload.
/// 
/// Possible values:
/// - `currentConfig`: Specifies the reload of the current config of the virtual machine.
/// - `snapshotConfig`: Specifies the reload of the snapshot config of the virtual machine.
///   
///   If the virtual machine has multiple snapshots, all of the snapshot's
///   config will be reloaded.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostLowLevelProvisioningManagerReloadTargetEnum {
    CurrentConfig,
    SnapshotConfig,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `hostUpgrade`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostMaintenanceSpecPurposeEnum {
    HostUpgrade,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Means for allocating additional memory for virtual machines.
/// 
/// Possible values:
/// - `swapNone`: Fit all virtual machine memory into reserved host memory.
/// - `swapSome`: Allow some virtual machine memory to be swapped.
/// - `swapMost`: Allow most virtual machine memory to be swapped.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineMemoryAllocationPolicyEnum {
    SwapNone,
    SwapSome,
    SwapMost,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration of flags pertaining to a memory tier.
/// 
/// Here are some examples of what the flags will look like for various memory
/// configurations:
/// - Traditional memory (*noTiering*): The host has a DRAM tier
///   for the main memory and nothing else. The DRAM tier will have the
///   *memoryTier* flag.
/// - App Direct mode (*noTiering*): The host has a DRAM tier
///   and a PMem tier, but the two are independent and unrelated. The PMem tier is
///   non-volatile and is exposed as an NVDIMM device. Applications can decide whether to
///   direct the reads and writes to DRAM or PMem by using the appropriate system call. The
///   DRAM tier will have the *memoryTier* flag and the PMem tier will
///   have the *persistentTier* flag.
/// - Memory mode (*hardwareTiering*): The host has a DRAM tier
///   and a PMem tier, but the DRAM is hidden from applications and is just a cache
///   for the PMem main memory. The PMem tier is volatile, and is abstracted by the hardware
///   layer to look like traditional memory. Applications can read from/write to memory
///   using the traditional memory system calls. The memory controller in the hardware will
///   internally direct those to the DRAM cache first, and on a cache miss redirect them to
///   the PMem main memory. The DRAM tier will have the *cachingTier*
///   flag and the PMem tier will have the *memoryTier* flag.
///   
/// Possible values:
/// - `memoryTier`: Flag indicating that the tier is the primary memory tier visible from the
///   host.
/// - `persistentTier`: 
///   
///   Deprecated as of vSphere 9.0 APIs with no replacement.
///   
///   Flag indicating that the tier is used as non-volatile storage, e.g.
///   
///   PMem in
///   App Direct mode.
/// - `cachingTier`: Flag indicating that the tier is a cache for main memory.
/// - `unmappableTier`: ***Since:*** vSphere API Release 8.0.3.0
/// 
/// ***Since:*** vSphere API Release 7.0.3.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostMemoryTierFlagsEnum {
    MemoryTier,
    PersistentTier,
    CachingTier,
    UnmappableTier,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration of supported types of memory tiers.
/// 
/// Possible values:
/// - `DRAM`: Dynamic random-access memory.
/// - `PMem`: 
///   
///   Deprecated as of vSphere 9.0 APIs with no replacement.
///   
///   Persistent memory.
/// - `NVMe`: NVMe memory.
///   
///   ***Since:*** vSphere API Release 8.0.3.0
/// 
/// ***Since:*** vSphere API Release 7.0.3.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostMemoryTierTypeEnum {
    Dram,
    PMem,
    NvMe,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration of the supported kinds of memory tiering configurations.
/// 
/// Possible values:
/// - `noTiering`: The traditional memory configuration without any tiers.
/// - `hardwareTiering`: The memory configuration where a tier is hardware-controlled and invisible to
///   applications, e.g.
///   
///   Intel's Memory Mode.
/// - `softwareTiering`: The memory configuration where all memory tiers are managed by software (ESX).
///   
///   ***Since:*** vSphere API Release 8.0.3.0
/// 
/// ***Since:*** vSphere API Release 7.0.3.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostMemoryTieringTypeEnum {
    NoTiering,
    HardwareTiering,
    SoftwareTiering,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines the access mode of the datastore.
/// 
/// Possible values:
/// - `readWrite`: The host system has read/write access to the file system.
/// - `readOnly`: The host system has read-only access to the file system.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostMountModeEnum {
    ReadWrite,
    ReadOnly,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// A datastore can become inaccessible due to a number of reasons as
/// defined in this enum *HostMountInfoInaccessibleReason_enum*.
/// 
/// The reason for a datastore being inaccessible is reported in
/// *HostMountInfo.inaccessibleReason*.
/// APD ("All Paths Down") is a condition where a SAN or NFS storage has
/// become inaccessible for unknown reasons. It only indicates loss of
/// connectivity and does not indicate storage device failure or
/// LUN removal (Permanent Device Loss or PDL)
/// A difference between APD and PDL is that APD may recover
/// in which case all use cases will start to work as before. In case of PDL
/// the failed datastore/device is unlikely to recover and hence the device
/// path information and data cache will be emptied. If the PDL condition
/// recovers, the failed datastores have to be added back to the host. Once
/// in PDL a datastore cannot be added back until there are no longer any
/// open files on the datastore.
/// PDL is not linked to the APD and can happen at any time with or without APD
/// preceding. If APD and PDL occur at the same time, APD will be reported first.
/// Once (and if) the APD condition clears, PermanentDataLoss will be reported if
/// PDL condition still exists.
/// 
/// Possible values:
/// - `AllPathsDown_Start`: AllPathsDown\_Start value is reported when all paths down state is detected
/// - `AllPathsDown_Timeout`: After a wait for a system default time (which is user modifiable)
///   to ascertain the state is indeed an APD, AllPathsDown\_Timeout property
///   is reported.
///   
///   The host advanced option used to set timeout period
///   is "/Misc/APDTimeout"
///   After the datastore property is set to AllPathsDown\_Timeout, all data i/o
///   to the datastore will be fast-failed (failed immediately).
/// - `PermanentDeviceLoss`: A PDL condition is reported as PermanentDeviceLoss.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostMountInfoInaccessibleReasonEnum {
    AllPathsDownStart,
    AllPathsDownTimeout,
    PermanentDeviceLoss,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// NFS mount request can be failed due to a number of reasons as
/// defined in this enum *HostMountInfoMountFailedReason_enum*.
/// 
/// The reason for the mount failure is reported in
/// *HostMountInfo.mountFailedReason*. This is applicable only for those
/// datastores to which mount retry is configured.
/// 
/// Possible values:
/// - `CONNECT_FAILURE`: Failed to get port or connect.
///   
///   Or MOUNT/FSINFO RPC failed.
/// - `MOUNT_NOT_SUPPORTED`: Server doesn't support MOUNT\_PROGRAM/MOUNT\_PROGRAM\_VERSION.
/// - `NFS_NOT_SUPPORTED`: Server doesn't support NFS\_PROGRAM/NFS\_PROGRAM\_VERSION.
/// - `MOUNT_DENIED`: No permission to mount the remote volume or it doesn't exist.
/// - `MOUNT_NOT_DIR`: Remote path not a directory.
/// - `VOLUME_LIMIT_EXCEEDED`: Maximum NFS volumes have been mounted.
/// - `CONN_LIMIT_EXCEEDED`: Maximum connections for NFS has been reached.
/// - `MOUNT_EXISTS`: Volume already mounted or a different mount exists with same label.
/// - `OTHERS`: Any other reason which is not present in above list.
///   
/// ***Since:*** vSphere API Release 8.0.0.1
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostMountInfoMountFailedReasonEnum {
    ConnectFailure,
    MountNotSupported,
    NfsNotSupported,
    MountDenied,
    MountNotDir,
    VolumeLimitExceeded,
    ConnLimitExceeded,
    MountExists,
    Others,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Set of constants defining the possible states of a multipath path.
/// 
/// Possible values:
/// - `standby`
/// - `active`
/// - `disabled`
/// - `dead`
/// - `unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum MultipathStateEnum {
    Standby,
    Active,
    Disabled,
    Dead,
    Unknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Security type supported.
/// 
/// Possible values:
/// - `AUTH_SYS`: Authentication based on traditional UNIX identifiers (UID and GID).
///   
///   Server trusts the IDs sent by the client for each request and uses them
///   to perform access control. Current implementation only supports
///   AUTH\_SYS with root user.
/// - `SEC_KRB5`: Ensures RPC header authentication using Kerberos session keys.
///   
///   When
///   this option is enabled, the client uses the information specified in
///   *HostNasVolumeUserInfo* to establish shared keys with the server using
///   Kerberos. These shared keys are used to generate and verify message
///   authentication codes for RPC header of NFS requests and responses,
///   respectively. This method does not secure NFS file data.
/// - `SEC_KRB5I`: Extends SEC\_KRB5 to generate and verify message authentication codes
///   for the payload of NFS requests and responses respectively.
///   
///   This
///   ensures the integrity of the NFS file data.
/// - `SEC_KRB5P`: Extends *SEC_KRB5I* to send and receive encrypted NFS packets over
///   the wire.
///   
///   *SEC_KRB5P* provides data privacy in addition to data
///   integrity for NFS files. To date, SEC\_KRB5P provides the highest form of
///   security for NFS payload.
///   
///   ***Since:*** vSphere API Release 9.0.0.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostNasVolumeSecurityTypeEnum {
    AuthSys,
    SecKrb5,
    SecKrb5I,
    SecKrb5P,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Define TCP congestion control algorithm used by an instance
/// 
/// Possible values:
/// - `newreno`: New Reno Algorithm.
///   
///   See http://tools.ietf.org/html/rfc3782 for detail.
/// - `cubic`: Cubic Algorithm.
///   
///   See http://tools.ietf.org/id/draft-rhee-tcp-cubic-00.txt for detail.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostNetStackInstanceCongestionControlAlgorithmTypeEnum {
    Newreno,
    Cubic,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Define the instance identifier for different traffic type
/// 
/// Possible values:
/// - `defaultTcpipStack`: The default stack used by applications
/// - `vmotion`: Stack key used for vMotion applications
/// - `vSphereProvisioning`: Stack key used for vSphere provisioning NFC traffic
/// - `mirror`: Stack key used for port mirroring
///   
///   ***Since:*** vSphere API Release 8.0.0.1
/// - `ops`: Stack key used for ops applications
///   
///   ***Since:*** vSphere API Release 8.0.0.1
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostNetStackInstanceSystemStackKeyEnum {
    DefaultTcpipStack,
    Vmotion,
    VSphereProvisioning,
    Mirror,
    Ops,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Health state of the numeric sensor as reported by the sensor probes.
/// 
/// Same data reported using command line: esxcli hardware ipmi sdr list
/// 
/// Possible values:
/// - `unknown`: The implementation cannot report on the current health state of the
///   physical element
/// - `green`: The sensor is operating under normal conditions
/// - `yellow`: The sensor is operating under conditions that are non-critical.
/// - `red`: The sensor is operating under critical or fatal conditions.
///   
///   This may
///   directly affect the functioning of both the sensor and related
///   components.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostNumericSensorHealthStateEnum {
    Unknown,
    Green,
    Yellow,
    Red,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Sensor Types for specific hardware component are either based on
/// class of sensor or what the sensor monitors to allow for grouping
/// 
/// Possible values:
/// - `fan`: Fan sensor
/// - `power`: Power sensor
/// - `temperature`: Temperature sensor
/// - `voltage`: Voltage Sensor
/// - `other`: Other sensor.
/// - `processor`: Processor sensor.
/// - `memory`: Memory sensor.
/// - `storage`: disk/storage sensor.
/// - `systemBoard`: system board sensor.
/// - `battery`: Battery sensor.
/// - `bios`: BIOS/firmware related sensor.
/// - `cable`: cable related sensor.
/// - `watchdog`: Watchdog related sensor.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostNumericSensorTypeEnum {
    Fan,
    Power,
    Temperature,
    Voltage,
    Other,
    Processor,
    Memory,
    Storage,
    SystemBoard,
    Battery,
    Bios,
    Cable,
    Watchdog,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Overall state of NVDIMM
/// 
/// Possible values:
/// - `normal`: NVDIMM state is normal
/// - `error`: Error in NVDIMM state.
///   
///   Potential data loss.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum NvdimmNvdimmHealthInfoStateEnum {
    Normal,
    Error,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// State of interleave set
/// 
/// Possible values:
/// - `invalid`: Interleave set is invalid
/// - `active`: Interleave set is valid and active
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum NvdimmInterleaveSetStateEnum {
    Invalid,
    Active,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Overall health state for a namespace
/// 
/// Possible values:
/// - `normal`: Namespace health is normal
/// - `missing`: Namespace health is missing
/// - `labelMissing`: Namespace health label is missing
/// - `interleaveBroken`: Namespace health interleave broken
/// - `labelInconsistent`: Namespace health label is inconsistent
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum NvdimmNamespaceDetailsHealthStatusEnum {
    Normal,
    Missing,
    LabelMissing,
    InterleaveBroken,
    LabelInconsistent,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// State of Namespace
/// 
/// Possible values:
/// - `invalid`: Namespace is invalid
/// - `notInUse`: Namespace is valid but not in use
/// - `inUse`: Namespace is valid and is in use
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum NvdimmNamespaceDetailsStateEnum {
    Invalid,
    NotInUse,
    InUse,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Overall health state for a namespace
/// 
/// Possible values:
/// - `normal`: Namespace health is normal
/// - `missing`: Namespace health is missing
/// - `labelMissing`: Namespace health label is missing
/// - `interleaveBroken`: Namespace health interleave broken
/// - `labelInconsistent`: Namespace health label is inconsistent
/// - `bttCorrupt`: Namespace health BTT is corrupt
/// - `badBlockSize`: Namespace health encountered bad block
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum NvdimmNamespaceHealthStatusEnum {
    Normal,
    Missing,
    LabelMissing,
    InterleaveBroken,
    LabelInconsistent,
    BttCorrupt,
    BadBlockSize,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// State of Namespace
/// 
/// Possible values:
/// - `invalid`: Namespace is invalid
/// - `notInUse`: Namespace is valid but not in use
/// - `inUse`: Namespace is valid and is in use
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum NvdimmNamespaceStateEnum {
    Invalid,
    NotInUse,
    InUse,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Type of namespace.
/// 
/// Possible values:
/// - `blockNamespace`: Block mode namespace
/// - `persistentNamespace`: Persistent mode namespace
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum NvdimmNamespaceTypeEnum {
    BlockNamespace,
    PersistentNamespace,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// An indicator of how a memory range is being used
/// 
/// Possible values:
/// - `volatileRange`: Identifies the region to be volatile
/// - `persistentRange`: Identifies the region to be persistent
/// - `controlRange`: NVDIMM control region
/// - `blockRange`: NVDIMM block data window region
/// - `volatileVirtualDiskRange`: NVDIMM volatile virtual disk region
/// - `volatileVirtualCDRange`: NVDIMM volatile virtual CD region
/// - `persistentVirtualDiskRange`: NVDIMM persistent virtual disk region
/// - `persistentVirtualCDRange`: NVDIMM persistent virtual CD region
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum NvdimmRangeTypeEnum {
    VolatileRange,
    PersistentRange,
    ControlRange,
    BlockRange,
    VolatileVirtualDiskRange,
    VolatileVirtualCdRange,
    PersistentVirtualDiskRange,
    PersistentVirtualCdRange,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This enum represents the supported NVM subsystem types.
/// 
/// Possible values:
/// - `discovery`: A Discovery service, composed of Discovery controllers.
/// - `nvm`: An NVM subsystem whose controllers may have attached namespaces.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostNvmeDiscoveryLogSubsystemTypeEnum {
    Discovery,
    Nvm,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This enum represents the supported types of transport requirements.
/// 
/// Possible values:
/// - `secureChannelRequired`: A fabric secure channel is required.
/// - `secureChannelNotRequired`: A fabric secure channel is not required.
/// - `requirementsNotSpecified`: Requirements are not specified
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostNvmeDiscoveryLogTransportRequirementsEnum {
    SecureChannelRequired,
    SecureChannelNotRequired,
    RequirementsNotSpecified,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This enum specifies the supported address families for
/// NVME over Fabrics.
/// 
/// For details, see:
/// - "NVM Express over Fabrics 1.0", Section 5.3, Figure 34,
///   "Discovery Log Page Entry"
///   
/// Possible values:
/// - `ipv4`: IPv4 address, format specified in IETF RFC 791.
/// - `ipv6`: IPv6 address, format specified in IETF RFC 2373.
/// - `infiniBand`: InfiniBand address family.
/// - `fc`: Fibre Channel address family.
/// - `loopback`: Intra-host transport.
/// - `unknown`: Unrecognized address family.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostNvmeTransportParametersNvmeAddressFamilyEnum {
    Ipv4,
    Ipv6,
    InfiniBand,
    Fc,
    Loopback,
    Unknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The set of NVM Express over Fabrics transport types.
/// 
/// For details, see:
/// - "NVM Express over Fabrics 1.0", Section 1.5.1,
///   "Fabrics and Transports".
///   
/// Possible values:
/// - `pcie`: PCI Express transport type
/// - `fibreChannel`: Fibre Channel transport type
/// - `rdma`: Remote Direct Memory Access transport type
/// - `tcp`: Transmission Control Protocol transport type
///   
///   ***Since:*** vSphere API Release 7.0.3.0
/// - `loopback`: Intra-host transport.
/// - `unsupported`: The transport type is not among the currently supported ones.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostNvmeTransportTypeEnum {
    Pcie,
    FibreChannel,
    Rdma,
    Tcp,
    Loopback,
    Unsupported,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `up`: The opaque switch is up and running.
/// - `warning`: The opaque switch requires attention.
/// - `down`: The opaque switch is down.
/// - `maintenance`: The opaque switch is under upgrade.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostOpaqueSwitchOpaqueSwitchStateEnum {
    Up,
    Warning,
    Down,
    Maintenance,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The following enum describes some common kinds of partial maintenance modes,
/// as well as their special semantics.
/// 
/// Possible values:
/// - `quickPatchPartialMM`: When the host is in the quick patch partial maintenance mode, it is safe to
///   perform a quick patch.
///   
///   When the host is in this partial maintenance mode, any virtual machines
///   and/or pods placed on it will continue to run but operations which may
///   lead to new workloads starting on the host such as power on or incoming
///   vmotions may be blocked.
///   It is generally unsafe to reboot the host in this state.
///   
///   ***Since:*** vSphere API Release 8.0.3.0
/// 
/// ***Since:*** vSphere API Release 8.0.3.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostPartialMaintenanceModeIdEnum {
    QuickPatchPartialMm,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The following enum contains the list of possible statuses associated
/// with each partial maintenance mode.
/// 
/// Possible values:
/// - `notInPartialMM`: The host is not in the particular partial maintenance mode.
/// - `enteringPartialMM`: The host is in the process of entering the particular partial maintenance
///   mode.
/// - `exitingPartialMM`: The host is in the process of exiting the particular partial maintenance
///   mode.
/// - `inPartialMM`: The host is in the particular partial maintenance mode.
///   
/// ***Since:*** vSphere API Release 8.0.3.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostPartialMaintenanceModeStatusEnum {
    NotInPartialMm,
    EnteringPartialMm,
    ExitingPartialMm,
    InPartialMm,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The installation state if the update is installed on the server.
/// 
/// Possible values:
/// - `hostRestarted`: The server has been restarted since the update installation.
/// - `imageActive`: Indicates if the newly installed image is active on the server
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostPatchManagerInstallStateEnum {
    HostRestarted,
    ImageActive,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The integrity validation status.
/// 
/// Possible values:
/// - `validated`: The update is successfully validated.
/// - `keyNotFound`: The integrity can not be verified since a public key to
///   verify the update cannot be found.
/// - `keyRevoked`: A public key to verify the update has been revoked.
/// - `keyExpired`: A public key to verify the update is expired.
/// - `digestMismatch`: A digital signature of the update does not match.
/// - `notEnoughSignatures`: Not enough signed signatures on the update.
/// - `validationError`: The integrity validation failed.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostPatchManagerIntegrityStatusEnum {
    Validated,
    KeyNotFound,
    KeyRevoked,
    KeyExpired,
    DigestMismatch,
    NotEnoughSignatures,
    ValidationError,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Reasons why an update is not applicable to the ESX host.
/// 
/// Possible values:
/// - `obsoleted`: The update is made obsolete by other patches installed on the host.
/// - `missingPatch`: The update depends on another update that is neither installed
///   nor in the scanned list of updates.
/// - `missingLib`: The update depends on certain libraries or RPMs that are not
///   available.
/// - `hasDependentPatch`: The update depends on an update that is not installed but is
///   in the scanned list of updates.
/// - `conflictPatch`: The update conflicts with certain updates that are already
///   installed on the host.
/// - `conflictLib`: The update conflicts with RPMs or libraries installed on the
///   host.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostPatchManagerReasonEnum {
    Obsoleted,
    MissingPatch,
    MissingLib,
    HasDependentPatch,
    ConflictPatch,
    ConflictLib,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `userOptOut`: Indicates that the user has opted out the Physical NIC from resource pool
///   based scheduling.
/// - `hardwareUnsupported`: Indicates that the NIC device does is not capable of resource pool
///   based scheduling.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PhysicalNicResourcePoolSchedulerDisallowedReasonEnum {
    UserOptOut,
    HardwareUnsupported,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Set of possible values for *PhysicalNic.vmDirectPathGen2SupportedMode*.
/// 
/// Possible values:
/// - `upt`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PhysicalNicVmDirectPathGen2SupportedModeEnum {
    Upt,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The type of component connected to a port group.
/// 
/// Possible values:
/// - `virtualMachine`: A virtual machine is connected to this port group.
/// - `systemManagement`: A system management entity (service console)
///   is connected to this port group.
/// - `host`: The VMkernel is connected to this port group.
/// - `unknown`: This port group serves an entity of unspecified kind.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PortGroupConnecteeTypeEnum {
    VirtualMachine,
    SystemManagement,
    Host,
    Unknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Deprecated from all vmodl version above @released("6.0").
/// 
/// ProtocolEndpoint Type.
/// 
/// Possible values:
/// - `block`
/// - `nas`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostProtocolEndpointPeTypeEnum {
    Block,
    Nas,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// ProtocolEndpoint type.
/// 
/// Possible values:
/// - `scsi`
/// - `nfs`
/// - `nfs4x`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostProtocolEndpointProtocolEndpointTypeEnum {
    Scsi,
    Nfs,
    Nfs4X,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// PTP capable network device type.
/// 
/// Possible values:
/// - `none`: No device.
/// - `virtualNic`: Virtual network adapter.
/// - `pciPassthruNic`: A network PCI device capable of PTP hardware timestamping,
///   enabled for passthru.
///   
///   See *HostPciPassthruSystem*
///   for information on PCI devices enabled for passthru available
///   on the host.
/// 
/// ***Since:*** vSphere API Release 7.0.3.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostPtpConfigDeviceTypeEnum {
    None,
    VirtualNic,
    PciPassthruNic,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `nvmeQualifiedName`: The NVMe Qualified Name (NQN) of this host.
/// - `vvolNvmeQualifiedName`: The NVMe Qualified Name (NQN) of this host used by Vvol.
///   
///   ***Since:*** vSphere API Release 8.0.0.0
/// 
/// ***Since:*** vSphere API Release 7.0.3.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostQualifiedNameTypeEnum {
    NvmeQualifiedName,
    VvolNvmeQualifiedName,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible RDMA device connection states.
/// 
/// These correspond
/// to possible link states as defined by the
/// Infiniband (TM) specification.
/// 
/// Further details can be found in:
/// - "Infiniband (TM) Architecture Specification, Volume 1"
///   section 7.2 "Link states"
///   
/// Possible values:
/// - `unknown`: Connection state unknown.
///   
///   Indicates that the driver returned
///   unexpected or no connection state information.
/// - `down`: Device down.
///   
///   Indicates that both the logical link and
///   underlying physical link are down. Packets
///   are discarded.
/// - `init`: Device initializing.
///   
///   Indicates that the physical link is up, but
///   the logical link is still initializing.
///   Only subnet management and flow control link
///   packets can be received and transmitted.
/// - `armed`: Device armed.
///   
///   Indicates that the physical link is up, but
///   the logical link is not yet fully configured.
///   Packets can be received, but non-SMPs
///   (subnet management packets) to be sent are discarded.
/// - `active`: Device active.
///   
///   Indicates that both the physical and logical
///   link are up. Packets can be transmitted and received.
/// - `activeDefer`: Device in active defer state.
///   
///   Indicates that the logical link was active, but the
///   physical link has suffered a failure. If it recovers
///   within a timeout, the connection state will return to active,
///   otherwise it will move to down.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostRdmaDeviceConnectionStateEnum {
    Unknown,
    Down,
    Init,
    Armed,
    Active,
    ActiveDefer,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration of network protocols supported by RDMA capable NIC.
/// 
/// Possible values:
/// - `RoCEv2`: Supported protocol is RDMA over Converged Ethernet (RoCEv2) version 2.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum RdmaProtocolEnum {
    RoCEv2,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration of port directions.
/// 
/// Possible values:
/// - `inbound`
/// - `outbound`
///
/// ### How to access
/// - `HostSystem::config.firewall?.ruleset?[*].rule[*].direction`
/// - `HostFirewallSystem::firewall_info.ruleset?[*].rule[*].direction`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostFirewallRuleDirectionEnum {
    Inbound,
    Outbound,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration of port types.
/// 
/// Possible values:
/// - `src`
/// - `dst`
///
/// ### How to access
/// - `HostSystem::config.firewall?.ruleset?[*].rule[*].port_type?`
/// - `HostFirewallSystem::firewall_info.ruleset?[*].rule[*].port_type?`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostFirewallRulePortTypeEnum {
    Src,
    Dst,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Set of valid port protocols.
/// 
/// Possible values:
/// - `tcp`
/// - `udp`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostFirewallRuleProtocolEnum {
    Tcp,
    Udp,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Define the instance state type
/// 
/// Possible values:
/// - `inactive`: The instance is deleted or not running
/// - `active`: The instance is running
/// - `deactivating`: The instance is in the progress of asynchronous deletion
/// - `activating`: Reserved state for future proofing asynchronous creation
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostRuntimeInfoNetStackInstanceRuntimeInfoStateEnum {
    Inactive,
    Active,
    Deactivating,
    Activating,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Valid protection modes for persistent state encryption.
/// 
/// Possible values:
/// - `none`: Encryption is not protected.
/// - `tpm`: Encryption is TPM protected.
///   
/// ***Since:*** vSphere API Release 7.0.3.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostRuntimeInfoStateEncryptionInfoProtectionModeEnum {
    None,
    Tpm,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines if the host is ready for NVDS to VDS migration.
/// 
/// Possible values:
/// - `ready`: The host is ready for NVDS to VDS migration.
/// - `notNeeded`: The host does not need NVDS to VDS migration
/// - `unknown`: The host is disconnected from VC.
///   
/// ***Since:*** vSphere API Release 7.0.2.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostRuntimeInfoStatelessNvdsMigrationStateEnum {
    Ready,
    NotNeeded,
    Unknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The types of disk drives.
/// 
/// Possible values:
/// - `native512`: 512 native sector size drive.
/// - `emulated512`: 4K sector size drive in 512 emulation mode.
/// - `native4k`: 4K native sector size drive.
/// - `SoftwareEmulated4k`: Software emulated 4k.
/// - `unknown`: Unknown type.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ScsiDiskTypeEnum {
    Native512,
    Emulated512,
    Native4K,
    SoftwareEmulated4K,
    Unknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// An indicator of the utility of Descriptor in being used as an
/// identifier that is stable, unique, and correlatable.
/// 
/// Possible values:
/// - `highQuality`: The Descriptor has an identifier that is useful for identification
///   and correlation across hosts.
/// - `mediumQuality`: The Descriptor has an identifier that may be used for identification
///   and correlation across hosts.
/// - `lowQuality`: The Descriptor has an identifier that should not be used for
///   identification and correlation across hosts.
/// - `unknownQuality`: The Descriptor has an identifier that may or may not be useful for
///   identification and correlation across hosts.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ScsiLunDescriptorQualityEnum {
    HighQuality,
    MediumQuality,
    LowQuality,
    UnknownQuality,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The list of Device Protocols.
/// 
/// Device protocol could be either NVMe or SCSI
/// 
/// Possible values:
/// - `NVMe`
/// - `SCSI`
/// 
/// ***Since:*** vSphere API Release 8.0.1.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DeviceProtocolEnum {
    NvMe,
    Scsi,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `LUN_RESERVED_UNKNOWN`
/// - `LUN_RESERVED_YES`
/// - `LUN_RESERVED_NO`
/// - `LUN_RESERVED_NOT_SUPPORTED`
/// 
/// ***Since:*** vSphere API Release 8.0.3.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ScsiLunLunReservationStatusEnum {
    LunReservedUnknown,
    LunReservedYes,
    LunReservedNo,
    LunReservedNotSupported,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The list of SCSI device types.
/// 
/// These values correspond to values
/// published in the SCSI specification.
/// 
/// Possible values:
/// - `disk`
/// - `tape`
/// - `printer`
/// - `processor`
/// - `worm`
/// - `cdrom`
/// - `scanner`
/// - `opticalDevice`
/// - `mediaChanger`
/// - `communications`
/// - `storageArrayController`
/// - `enclosure`
/// - `unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ScsiLunTypeEnum {
    Disk,
    Tape,
    Printer,
    Processor,
    Worm,
    Cdrom,
    Scanner,
    OpticalDevice,
    MediaChanger,
    Communications,
    StorageArrayController,
    Enclosure,
    Unknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The Operational state of the LUN
/// 
/// Possible values:
/// - `unknownState`: The LUN state is unknown.
/// - `ok`: The LUN is on and available.
/// - `error`: The LUN is dead and/or not reachable.
/// - `off`: The LUN is off.
/// - `quiesced`: The LUN is inactive.
/// - `degraded`: One or more paths to the LUN are down, but I/O
///   is still possible.
///   
///   Further path failures may
///   result in lost connectivity.
/// - `lostCommunication`: No more paths are available to the LUN.
/// - `timeout`: All Paths have been down for the timeout condition
///   determined by a user-configurable host advanced option.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ScsiLunStateEnum {
    UnknownState,
    Ok,
    Error,
    Off,
    Quiesced,
    Degraded,
    LostCommunication,
    Timeout,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Storage array hardware acceleration support status.
/// 
/// When a host boots, the support status is unknown.
/// As a host attempts hardware-accelerated operations,
/// it determines whether the storage device supports hardware acceleration
/// and sets the *ScsiLun.vStorageSupport* property accordingly.
/// 
/// Possible values:
/// - `vStorageSupported`: Storage device supports hardware acceleration.
///   
///   The ESX host will use the feature to offload certain
///   storage-related operations to the device.
/// - `vStorageUnsupported`: Storage device does not support hardware acceleration.
///   
///   The ESX host will handle all storage-related operations.
/// - `vStorageUnknown`: Initial support status value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ScsiLunVStorageSupportStatusEnum {
    VStorageSupported,
    VStorageUnsupported,
    VStorageUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Set of valid service policy strings.
/// 
/// Possible values:
/// - `on`: Service should be started when the host starts up.
/// - `automatic`: Service should run if and only if it has open firewall ports.
/// - `off`: Service should not be started when the host starts up.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostServicePolicyEnum {
    On,
    Automatic,
    Off,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `uninitialized`
/// - `initialized`
/// - `working`
/// 
/// ***Since:*** vSphere API Release 7.0.1.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostSevInfoSevStateEnum {
    Uninitialized,
    Initialized,
    Working,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Flexible Launch Enclave (FLC) modes.
/// 
/// Possible values:
/// - `off`: Flexible Launch Enclave (FLC) is not available on the host.
///   
///   The
///   "launch enclave MSRs" are initialized with Intel's public key hash.
/// - `locked`: FLC is available and the "launch Enclave MSRs" are locked and
///   initialized with the provided public key hash.
/// - `unlocked`: FLC is available and the "launch enclave MSRs" are writeable and
///   initialized with Intel's public key hash.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostSgxInfoFlcModesEnum {
    Off,
    Locked,
    Unlocked,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Host SGX states.
/// 
/// Possible values:
/// - `notPresent`: SGX is not present in the CPU.
/// - `disabledBIOS`: SGX is disabled in the BIOS.
/// - `disabledCFW101`: SGX is disabled because CPU erratum CFW101 is present.
/// - `disabledCPUMismatch`: SGX is disabled due to a mismatch in the SGX capabilities
///   exposed by different CPUs.
/// - `disabledNoFLC`: SGX is disabled because the CPU does not support FLC.
/// - `disabledNUMAUnsup`: SGX is disabled because the host uses NUMA, which is not
///   supported with SGX.
/// - `disabledMaxEPCRegs`: SGX is disabled because the host exceeds the maximum supported
///   number of EPC regions.
/// - `enabled`: SGX is enabled.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostSgxInfoSgxStatesEnum {
    NotPresent,
    DisabledBios,
    DisabledCfw101,
    DisabledCpuMismatch,
    DisabledNoFlc,
    DisabledNumaUnsup,
    DisabledMaxEpcRegs,
    Enabled,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// SGX registration status for ESX host.
/// 
/// Possible values:
/// - `notApplicable`: SGX is not available or the host is unisocket.
/// - `incomplete`: SGX registration is incomplete.
/// - `complete`: SGX registration is complete.
///   
/// ***Since:*** vSphere API Release 8.0.0.1
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostSgxRegistrationInfoRegistrationStatusEnum {
    NotApplicable,
    Incomplete,
    Complete,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// SGX host registration type.
/// 
/// Possible values:
/// - `manifest`: Indicates that an Initial Platform Establishment
///   or TCB recovery registration is pending.
/// - `addPackage`: Indicates that new CPU package was added.
///   
/// ***Since:*** vSphere API Release 8.0.0.1
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostSgxRegistrationInfoRegistrationTypeEnum {
    Manifest,
    AddPackage,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// SNMP Agent supported capabilities enum
/// 
/// Possible values:
/// - `COMPLETE`: Implements test notifications and allows agent configuration
/// - `DIAGNOSTICS`: Implements only test notification capability only
/// - `CONFIGURATION`: Allows for agent configuration only
///
/// ### How to access
/// - `HostSnmpSystem::limits.capability`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostSnmpAgentCapabilityEnum {
    Complete,
    Diagnostics,
    Configuration,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// These are the constraint relationships between software packages.
/// 
/// Possible values:
/// - `equals`
/// - `lessThan`
/// - `lessThanEqual`
/// - `greaterThanEqual`
/// - `greaterThan`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum SoftwarePackageConstraintEnum {
    Equals,
    LessThan,
    LessThanEqual,
    GreaterThanEqual,
    GreaterThan,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `bootbank`: This package is installed into bootbank in storage.
/// - `tools`: This package is installed into tools partition in storage.
/// - `meta`: This package contains install related data without
///   content to install.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum SoftwarePackageVibTypeEnum {
    Bootbank,
    Tools,
    Meta,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The set of supported host bus adapter protocols.
/// 
/// Possible values:
/// - `scsi`: The Small Computer System Interface (SCSI) protocol.
/// - `nvme`: The Non-Volatile Memory Express (NVME) protocol.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostStorageProtocolEnum {
    Scsi,
    Nvme,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `AssetTag`: The Asset tag of the system
/// - `ServiceTag`: The Service tag of the system
/// - `OemSpecificString`: OEM specific string
/// - `EnclosureSerialNumberTag`: The Enclosure Serial Number tag of the system
/// - `SerialNumberTag`: The Serial Number tag of the system
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostSystemIdentificationInfoIdentifierEnum {
    AssetTag,
    ServiceTag,
    OemSpecificString,
    EnclosureSerialNumberTag,
    SerialNumberTag,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `initializing`
/// - `initialized`
/// - `configured`
/// - `ready`
/// 
/// ***Since:*** vSphere API Release 9.0.0.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostTdxInfoTdxStateEnum {
    Initializing,
    Initialized,
    Configured,
    Ready,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Status constants of TPM attestation.
/// 
/// Possible values:
/// - `notAccepted`: TPM attestation failed.
/// - `accepted`: TPM attestation succeeded.
///
/// ### How to access
/// - `HostSystem::summary.tpm_attestation?.status`
/// - `HostSystem::query_host_connection_info().host.tpm_attestation?.status`
/// - `Datacenter::query_connection_info().host.tpm_attestation?.status`
/// - `Datacenter::query_connection_info_via_spec().host.tpm_attestation?.status`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostTpmAttestationInfoAcceptanceStatusEnum {
    NotAccepted,
    Accepted,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `attested`: Attestation succeeded.
/// - `notAttested`: Attestation failed.
/// - `unknown`: Attestation status is unknown.
///   
/// ***Since:*** vSphere API Release 7.0.1.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostTrustAuthorityAttestationInfoAttestationStatusEnum {
    Attested,
    NotAttested,
    Unknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Reasons for identifying the disk extent
/// as copy of VMFS volume extent.
/// 
/// Possible values:
/// - `diskIdMismatch`: The VMFS detected 'diskid' does not match with
///   LVM detected 'diskId'
/// - `uuidConflict`: VMFS 'uuid' does not match
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostUnresolvedVmfsExtentUnresolvedReasonEnum {
    DiskIdMismatch,
    UuidConflict,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `resignature`: Resignature the Unresolved VMFS volume.
///   
///   In the event the volume to be resignatured contains multiple
///   extents but only a single copy of each extent exists, only the
///   head extent needs to be specified.
/// - `forceMount`: Keep the original Uuid of the VMFS volume and mount it
///   
///   In the event the volume to be force mounted contains multiple
///   extents but only a single copy of each extent exists, only the
///   head extent needs to be specified.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostUnresolvedVmfsResolutionSpecVmfsUuidResolutionEnum {
    Resignature,
    ForceMount,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `vmotion`: The VirtualNic is used for VMotion.
/// - `faultToleranceLogging`: The VirtualNic is used for Fault Tolerance logging.
/// - `vSphereReplication`: The VirtualNic is used for vSphere Replication LWD traffic
///   (i.e From the primary host to the VR server).
/// - `vSphereReplicationNFC`: The VirtualNic is used for vSphere Replication NFC traffic (i.e.
///   
///   From
///   the VR server to the secondary host).
/// - `management`: The VirtualNic is used for management network traffic .
///   
///   This nicType is available only when the system does not
///   support service console adapters.
///   
///   See also *HostNetCapabilities.usesServiceConsoleNic*.
/// - `vsan`: The VirtualNic is used for Virtual SAN data traffic.
///   
///   To enable or disable a VirtualNic for VSAN networking,
///   use *HostVsanSystem.UpdateVsan_Task*.
///   
///   See also *HostVsanSystem*, *HostVsanSystem.UpdateVsan_Task*, *ComputeResource.ReconfigureComputeResource_Task*.
/// - `vSphereProvisioning`: The VirtualNic is used for vSphere provisioning NFC traffic
///   (i.e.
///   
///   the NFC traffic between ESX hosts as a part of a VC initiated
///   provisioning operations like cold-migrations, clones, snapshot and
///   cold data in hot migration).
/// - `vsanWitness`: The VirtualNic is used for Virtual SAN witness traffic.
///   
///   Witness traffic vmknic is required for Virtual SAN stretched cluster,
///   to help on communication between Virtual SAN data node and witness
///   node.
///   To enable or disable a VirtualNic for Virtual SAN networking,
///   use *HostVsanSystem.UpdateVsan_Task*.
///   
///   See also *HostVsanSystem*, *HostVsanSystem.UpdateVsan_Task*.
/// - `vSphereBackupNFC`: The VirtualNic is used for vSphere backup NFC traffic
///   (i.e.
///   
///   the NFC traffic between backup appliance and ESX hosts).
/// - `ptp`: The VirtualNic is used for Precision Time Protocol (PTP).
/// - `nvmeTcp`: The VirtualNic is used for NVMe over TCP traffic.
///   
///   ***Since:*** vSphere API Release 7.0.3.0
/// - `nvmeRdma`: The VirtualNic is used for NVMe over RDMA traffic.
///   
///   ***Since:*** vSphere API Release 7.0.3.0
/// - `vsanExternal`: The VirtualNic is used for external vSAN traffic.
///   
///   ***Since:*** vSphere API Release 9.0.0.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostVirtualNicManagerNicTypeEnum {
    Vmotion,
    FaultToleranceLogging,
    VSphereReplication,
    VSphereReplicationNfc,
    Management,
    Vsan,
    VSphereProvisioning,
    VsanWitness,
    VSphereBackupNfc,
    Ptp,
    NvmeTcp,
    NvmeRdma,
    VsanExternal,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Set of possible values for mode field in AccessSpec.
/// 
/// Possible values:
/// - `grant`: Grant access to specified services in addition to existing services.
/// - `replace`: Replace existing services with specified services.
/// - `revoke`: Revoke the specified services.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostVmciAccessManagerModeEnum {
    Grant,
    Replace,
    Revoke,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// VMFS unmap bandwidth policy.
/// 
/// VMFS unmap reclaims unused storage space.
/// This specifies the bandwidth policy option of unmaps.
/// 
/// Possible values:
/// - `fixed`: Unmap bandwidth is a fixed value.
/// - `dynamic`: Unmaps bandwidth is a dynamic value with lower and upper limits
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostVmfsVolumeUnmapBandwidthPolicyEnum {
    Fixed,
    Dynamic,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// VMFS unmap priority.
/// 
/// VMFS unmap reclaims unused storage space.
/// This specifies the processing rate of unmaps.
/// 
/// Possible values:
/// - `none`: Unmap is disabled.
/// - `low`: Unmaps are processed at low rate.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostVmfsVolumeUnmapPriorityEnum {
    None,
    Low,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration indicates the vSAN disk controller type.
/// 
/// Possible values:
/// - `NVMe`: The controller is an NVMe controller.
/// - `SCSI`: The controller is a SCSI controller.
/// - `VsanControllerType_Unknown`: Represent the value when the lower version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanControllerTypeEnum {
    NvMe,
    Scsi,
    VsanControllerTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The vSAN disk balance state enumeration.
/// 
/// Possible values:
/// - `rebalanceoff`: Rebalancing needed but is turned off.
/// - `rebalanceentitydecom`: Disk/diskgroup or related node is decommissioning or rebalancing temporarily disabled.
/// - `rebalancediskunhealthy`: Disk that needs rebalancing is unhealthy.
/// - `imbalancewithintolerance`: Imbalance is within reactive/proactive tolerance.
/// - `reactiverebalanceinprogress`: Reactive rebalancing in progress.
/// - `reactiverebalancefailed`: Reactive rebalancing needed but failed due to lack of resources or failing to find components that can be moved due to policy restrictions.
/// - `proactiveneededbutdisabled`: Proactive rebalancing needed but disabled.
/// - `proactiverebalanceinprogress`: Proactive rebalancing in progress.
/// - `proactiverebalancefailed`: Proactive rebalancing needed but failed due to lack of resources or failing to find components that can be moved due to policy restrictions.
/// - `proactivenotmustdo`: Proactive rebalancing can be activated but it's not a must do like due to no enough resource
/// - `VsanDiskBalanceState_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanDiskBalanceStateEnum {
    Rebalanceoff,
    Rebalanceentitydecom,
    Rebalancediskunhealthy,
    Imbalancewithintolerance,
    Reactiverebalanceinprogress,
    Reactiverebalancefailed,
    Proactiveneededbutdisabled,
    Proactiverebalanceinprogress,
    Proactiverebalancefailed,
    Proactivenotmustdo,
    VsanDiskBalanceStateUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The vSAN encryption issue enumeration.
/// 
/// Possible values:
/// - `enabledwhenclusterdisabled`: Encryption is enabled on the host/disk when the cluster has encryption disabled.
/// - `disabledwhenclusterenabled`: Encryption is disabled on the host/disk when the cluster has encryption enabled.
/// - `keyencryptionkeyinconsistent`: The Encryption Key on the host/disk is inconsistent with the cluster encryption configuration.
/// - `dataencryptionkeyinconsistent`: The Data Encryption Key generation number on the host/disk is inconsistent with the cluster encryption configuration but may be consistent with the cluster old Data Encryption Key.
/// - `kmsinfoinconsistent`: The Key Management Servers information on the host/disk is inconsistent with the cluster encryption configuration.
/// - `servercertificatesinconsistent`: The server certifications on the host is inconsistent with the cluster encryption configuration.
/// - `clientcertificateinconsistent`: The client certification on the host is inconsistent with the cluster encryption configuration.
/// - `clientkeyinconsistent`: The client private key on the host is inconsistent with the cluster encryption configuration.
/// - `hostkeyinconsistent`: The host key for host core dump encryption is inconsistent with the cluster encryption configuration.
/// - `erasedisksbeforeuseinconsistent`: The configuration of erasing disks before use on the host is inconsistent with the cluster encryption configuration.
/// - `cmknotinenabledstate`
/// - `cmkcannotretrieve`
/// - `hostkeynotavailable`
/// - `keknotavailable`
/// - `hostencryptiondekidinconsistent`
/// - `objectencryptioninconsistent`
/// - `keyencryptionkeyverifierinconsistent`
/// - `dataencryptionkeyverifierinconsistent`
/// - `olddataencryptionkeyinconsistent`
/// - `hosthaswrongdekid`
/// - `hosthaswrongolddekid`
/// - `hosthaspendingdeeprekey`
/// - `diskhaswrongdekid`
/// - `diskhaswrongpendingdekid`
/// - `diskhaspendingdeeprekey`
/// - `dataencryptionkeyverifierofdiskmetainconsistent`
/// - `changingstateinconsistent`: ***Since:*** 8.0.0.4
/// - `changingstatenotfinished`: ***Since:*** 8.0.0.4
/// - `VsanEncryptionIssue_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanEncryptionIssueEnum {
    Enabledwhenclusterdisabled,
    Disabledwhenclusterenabled,
    Keyencryptionkeyinconsistent,
    Dataencryptionkeyinconsistent,
    Kmsinfoinconsistent,
    Servercertificatesinconsistent,
    Clientcertificateinconsistent,
    Clientkeyinconsistent,
    Hostkeyinconsistent,
    Erasedisksbeforeuseinconsistent,
    Cmknotinenabledstate,
    Cmkcannotretrieve,
    Hostkeynotavailable,
    Keknotavailable,
    Hostencryptiondekidinconsistent,
    Objectencryptioninconsistent,
    Keyencryptionkeyverifierinconsistent,
    Dataencryptionkeyverifierinconsistent,
    Olddataencryptionkeyinconsistent,
    Hosthaswrongdekid,
    Hosthaswrongolddekid,
    Hosthaspendingdeeprekey,
    Diskhaswrongdekid,
    Diskhaswrongpendingdekid,
    Diskhaspendingdeeprekey,
    Dataencryptionkeyverifierofdiskmetainconsistent,
    Changingstateinconsistent,
    Changingstatenotfinished,
    VsanEncryptionIssueUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The vSAN host QueryCheckLimits option type.
/// 
/// it is used to query more detailed
/// data aggregated at host level from disks or disk groups.
/// 
/// Possible values:
/// - `logicalCapacity`: The logical capacity at host level
/// - `logicalCapacityUsed`: The logical capacity used at host level
/// - `diskTransientCapacityUsed`: The disk transient capacity used at host level
/// - `dgTransientCapacityUsed`: The disk group transient capacity used at host level
/// - `dedupMetadata`: The dedup metadata size
/// - `VsanHostQueryCheckLimitsOptionType_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanHostQueryCheckLimitsOptionTypeEnum {
    LogicalCapacity,
    LogicalCapacityUsed,
    DiskTransientCapacityUsed,
    DgTransientCapacityUsed,
    DedupMetadata,
    VsanHostQueryCheckLimitsOptionTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// State of ioinsight tool on ESXi host, which is designed to monitor and
/// collect all virtual disks I/O performance metrics of target virtual
/// machines.
/// 
/// Currently ioinsight state includes the following values, and
/// running/stopped are normal state.
/// 
/// Possible values:
/// - `running`: ioinsight is in running for VMDKs I/O performance metrics monitor.
/// - `stopped`: ioinsight is stopped and doesn't monitor any VMDK.
/// - `notFound`: ioinsight binary is not found on this host.
/// - `VsanIoInsightState_unknown`: represent the value when the lower version client cannot recognize the enum value
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanIoInsightStateEnum {
    Running,
    Stopped,
    NotFound,
    VsanIoInsightStateUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The vSAN object health state enumeration.
/// 
/// Possible values:
/// - `inaccessible`: An object has suffered more failures (permanent or temporary) than it was configured to tolerate, and is currently unavailable and inaccessible.
/// - `reducedavailabilitywithnorebuild`: The object has suffered a failure or its policy was recently changed to have higher availability requirement but vSAN was able to tolerate it.
///   
///   The object is accessible and I/O is flowing.
/// - `reducedavailabilitywithnorebuilddelaytimer`: The object has suffered a failure, but vSAN was able to tolerate it.
///   
///   However, vSAN is not yet working on re-protecting the object, as it is waiting for the 60-minute (default) delay timer to expire before issuing the re-protect.
/// - `reducedavailabilitywithactiverebuild`: The object has suffered a failure, but it was configured to be able to tolerate the failure.
/// - `datamove`: Objects in this state are fully compliant with their policy and are healthy, but vSAN is actively rebuilding them.
/// - `nonavailabilityrelatedreconfig`: The object is fully in compliance with the NumberOfFailuresToTolerate policy and the data movement is to satisfy another policy change.
/// - `nonavailabilityrelatedincompliance`: This is a catch all state when none of the other states apply.
///   
///   An object with this state is not compliant with its current policy, but is meeting the availablity (NumberOfFailuresToTolerate) policy. The object might be in this state because vSAN is not able to meet a non-availability related policy such as NumberOfDiskStripesPerObject because of lack of available resources. User need check the vSAN system resources like the number of fault domains and hosts, free capacity to make it compliant.
/// - `healthy`: The object is in perfect condition, exactly aligned with its policy, and is not currently being moved or otherwise worked on.
/// - `reducedavailabilitywithpolicypending`
/// - `reducedavailabilitywithpolicypendingfailed`
/// - `reducedavailabilitywithpausedrebuild`
/// - `nonavailabilityrelatedincompliancewithpolicypending`
/// - `nonavailabilityrelatedincompliancewithpolicypendingfailed`
/// - `nonavailabilityrelatedincompliancewithpausedrebuild`
/// - `remoteAccessible`
/// - `VsanObjectHealthState_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanObjectHealthStateEnum {
    Inaccessible,
    Reducedavailabilitywithnorebuild,
    Reducedavailabilitywithnorebuilddelaytimer,
    Reducedavailabilitywithactiverebuild,
    Datamove,
    Nonavailabilityrelatedreconfig,
    Nonavailabilityrelatedincompliance,
    Healthy,
    Reducedavailabilitywithpolicypending,
    Reducedavailabilitywithpolicypendingfailed,
    Reducedavailabilitywithpausedrebuild,
    Nonavailabilityrelatedincompliancewithpolicypending,
    Nonavailabilityrelatedincompliancewithpolicypendingfailed,
    Nonavailabilityrelatedincompliancewithpausedrebuild,
    RemoteAccessible,
    VsanObjectHealthStateUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The vSAN interhost connectivity health state.
/// 
/// Possible values:
/// - `STATE_GOOD`: connection to peer is healthy.
/// - `STATE_SSL_ERROR`: connection to peer failed with ssl error.
/// - `STATE_CONNECTION_REFUSED_ERROR`: connection to peer failed with connection refused error.
/// - `STATE_SOCKET_TIMEOUT`: connection to peer failed with socket timeout error.
/// - `STATE_HTTP_EXCEPTION`: connection to peer failed with http exception.
/// - `STATE_MEMORY_ERROR`: connection to peer failed with memory error.
/// - `STATE_SYSTEM_ERROR`: connection to peer failed with system rrror.
/// - `STATE_OS_ERROR`: connection to peer failed with os error.
/// - `STATE_GENERAL_EXCEPTION`: connection to peer failed with general exception.
/// - `STATE_UNKNOWN`: connectino to peer failed with unknown issue.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanPeerHostConnectivityHealthStateEnum {
    StateGood,
    StateSslError,
    StateConnectionRefusedError,
    StateSocketTimeout,
    StateHttpException,
    StateMemoryError,
    StateSystemError,
    StateOsError,
    StateGeneralException,
    StateUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The vSAN S.M.A.R.T.
/// 
/// parameter enumeration.
/// 
/// Possible values:
/// - `smarthealthstatus`: Health Status.
/// - `smartmediawearoutindicator`: Media Wearout Indicator.
/// - `smartwriteerrorcount`: Write Error Count.
/// - `smartreaderrorcount`: Read Error Count.
/// - `smartpoweronhours`: Power-on Hours.
/// - `smartpowercyclecount`: Power Cycle Count.
/// - `smartreallocatedsectorct`: Reallocated Sector Count.
/// - `smartrawreaderrorrate`: Raw Read Error Rate.
/// - `smartdrivetemperature`: Drive Temperature.
/// - `smartdriveratedmaxtemperature`: Driver Rated Max Temperature.
/// - `smartwritesectorstotct`: Write Sectors TOT Count.
/// - `smartreadsectorstotct`: Read Sectors TOT Count.
/// - `smartinitialbadblockcount`: Initial Bad Block Count.
/// - `VsanSmartParameterType_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanSmartParameterTypeEnum {
    Smarthealthstatus,
    Smartmediawearoutindicator,
    Smartwriteerrorcount,
    Smartreaderrorcount,
    Smartpoweronhours,
    Smartpowercyclecount,
    Smartreallocatedsectorct,
    Smartrawreaderrorrate,
    Smartdrivetemperature,
    Smartdriveratedmaxtemperature,
    Smartwritesectorstotct,
    Smartreadsectorstotct,
    Smartinitialbadblockcount,
    VsanSmartParameterTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This specifies how an IP address was obtained for a given interface.
/// 
/// See RFC 4293 IpAddressOriginTC.
/// 
/// Possible values:
/// - `other`: Any other type of address configuration other than the below
///   mentioned ones will fall under this category.
///   
///   For e.g., automatic
///   address configuration for the link local address falls under
///   this type.
/// - `manual`: The address is configured manually.
///   
///   The term 'static' is a synonym.
/// - `dhcp`: The address is configured through dhcp.
/// - `linklayer`: The address is obtained through stateless autoconfiguration (autoconf).
///   
///   See RFC 4862, IPv6 Stateless Address Autoconfiguration.
/// - `random`: The address is chosen by the system at random
///   e.g., an IPv4 address within 169.254/16, or an RFC 3041 privacy address.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum NetIpConfigInfoIpAddressOriginEnum {
    Other,
    Manual,
    Dhcp,
    Linklayer,
    Random,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `preferred`: Indicates that this is a valid address.
/// - `deprecated`: Indicates that this is a valid but deprecated address
///   that should no longer be used as a source address.
/// - `invalid`: Indicates that this isn't a valid.
/// - `inaccessible`: Indicates that the address is not accessible because
///   interface is not operational.
/// - `unknown`: Indicates that the status cannot be determined.
/// - `tentative`: Indicates that the uniqueness of the
///   address on the link is presently being verified.
/// - `duplicate`: Indicates the address has been determined to be non-unique
///   on the link, this address will not be reachable.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum NetIpConfigInfoIpAddressStatusEnum {
    Preferred,
    Deprecated,
    Invalid,
    Inaccessible,
    Unknown,
    Tentative,
    Duplicate,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// IP Stack keeps state on entries in IpNetToMedia table to perform
/// physical address lookups for IP addresses.
/// 
/// Here are the standard
/// states per @see RFC 4293 ipNetToMediaType.
/// 
/// Possible values:
/// - `other`: This implementation is reporting something other than
///   what states are listed below.
/// - `invalid`: The IP Stack has marked this entry as not useable.
/// - `dynamic`: This entry has been learned using ARP or NDP.
/// - `manual`: This entry was set manually.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum NetIpStackInfoEntryTypeEnum {
    Other,
    Invalid,
    Dynamic,
    Manual,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The set of values used to determine ordering of default routers.
/// 
/// See RFC 4293 ipDefaultRouterPreference.
/// 
/// Possible values:
/// - `reserved`
/// - `low`
/// - `medium`
/// - `high`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum NetIpStackInfoPreferenceEnum {
    Reserved,
    Low,
    Medium,
    High,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// NetBIOS configuration mode.
/// 
/// Possible values:
/// - `unknown`: Mode of NetBIOS is unknown.
/// - `enabled`: NetBIOS is enabled.
/// - `disabled`: NetBIOS is disabled.
/// - `enabledViaDHCP`: DHCP server decides whether or not to use NetBIOS.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum NetBiosConfigInfoModeEnum {
    Unknown,
    Enabled,
    Disabled,
    EnabledViaDhcp,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This list specifies the type of operation being performed on the array.
/// 
/// Possible values:
/// - `add`: indicates an addition to the array.
/// - `remove`: indicates the removal of an element in the
///   array.
///   
///   In this case the key field must contain the key of the element
///   to be removed.
/// - `edit`: indicates changes to an element in the array.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ArrayUpdateOperationEnum {
    Add,
    Remove,
    Edit,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `compliant`: Entity is in Compliance
/// - `nonCompliant`: Entity is out of Compliance
/// - `unknown`: Compliance status of the entity is not known
/// - `running`: Compliance check on this host is running.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ComplianceResultStatusEnum {
    Compliant,
    NonCompliant,
    Unknown,
    Running,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumerates different operations supported for comparing
/// numerical values.
/// 
/// Possible values:
/// - `lessThan`
/// - `lessThanEqual`
/// - `equal`
/// - `notEqual`
/// - `greaterThanEqual`
/// - `greaterThan`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ProfileNumericComparatorEnum {
    LessThan,
    LessThanEqual,
    Equal,
    NotEqual,
    GreaterThanEqual,
    GreaterThan,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The relation type to be supported.
/// 
/// Possible values:
/// - `dynamic_relation`: The relation to a subprofile or a parameter.
/// - `extensible_relation`: The values from sources other than the parameter/profile or the static
///   value list are allowed.
/// - `localizable_relation`: The value list contains localization keys instead of values.
/// - `static_relation`: The relation is defined by static valid value list.
/// - `validation_relation`: The relation is defined for validation purpose.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ProfileParameterMetadataRelationTypeEnum {
    DynamicRelation,
    ExtensibleRelation,
    LocalizableRelation,
    StaticRelation,
    ValidationRelation,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Type of services for which Profile can be requested for
/// 
/// Possible values:
/// - `DRS`: Distributed Resource Scheduling
/// - `HA`: High Availability
/// - `DPM`: Distributed Power Management
/// - `FT`: Fault tolerance
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ClusterProfileServiceTypeEnum {
    Drs,
    Ha,
    Dpm,
    Ft,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines the result status values for a
/// *HostProfile*.*HostProfile.ExecuteHostProfile*
/// operation.
/// 
/// The result data is contained in the
/// *ProfileExecuteResult* data object.
/// 
/// Possible values:
/// - `success`: Profile execution was successful.
///   
///   You can use the output configuration data
///   to apply the profile to a host.
/// - `needInput`: Additional data is required to complete the operation.
///   
///   The data requirements are defined in the list of policy options for the profile
///   (*ApplyProfile*.*ApplyProfile.policy*\[\]).
/// - `error`: Profile execution generated an error.
///   
///   See *ProfileExecuteResult*.*ProfileExecuteResult.error*.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ProfileExecuteResultStatusEnum {
    Success,
    NeedInput,
    Error,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Types of host profile update.
/// 
/// Possible values:
/// - `HostBased`: Update host profile from host.
/// - `Import`: Import host profile.
/// - `Edit`: Edit host profile.
/// - `Compose`: Compose setting from host profile.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostProfileValidationFailureInfoUpdateTypeEnum {
    HostBased,
    Import,
    Edit,
    Compose,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This defines validation state values for host profile.
/// 
/// Possible values:
/// - `Ready`
/// - `Running`
/// - `Failed`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostProfileValidationStateEnum {
    Ready,
    Running,
    Failed,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The *HostProfileManagerAnswerFileStatus_enum* enum
/// defines possible values for answer file status.
/// 
/// Possible values:
/// - `valid`: Answer file is valid.
/// - `invalid`: Answer file is not valid.
///   
///   The file is either missing or incomplete.
///   - To produce an answer file, pass host-specific data (user input) to the
///     *HostProfileManager*.*HostProfileManager.ApplyHostConfig_Task*
///     method.
///   - To produce a complete answer file, call the
///     *HostProfile*.*HostProfile.ExecuteHostProfile*
///     method and fill in any missing parameters in the returned
///     *ProfileExecuteResult*.*ProfileExecuteResult.requireInput*
///     list. After you execute the profile successfully, you can pass the complete required
///     input list to the apply method.
/// - `unknown`: Answer file status is not known.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostProfileManagerAnswerFileStatusEnum {
    Valid,
    Invalid,
    Unknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `success`: Remediation succeeded.
/// - `failed`: Remediation failed.
/// - `reboot_failed`: Remediation succeeded but reboot after remediation failed.
///   
///   May treat this as a warning.
/// - `stateless_reboot_failed`: Stateless reboot for remediation failed.
/// - `check_compliance_failed`: Remediation and reboot succeeded but check compliance after reboot
///   failed.
///   
///   May treat this as a warning.
/// - `state_not_satisfied`: The required state is not satisfied so host profiel apply cannot
///   be done.
/// - `exit_maintenancemode_failed`: Exit maintenance mode failed.
/// - `canceled`: The remediation was canceled.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ApplyHostProfileConfigurationResultStatusEnum {
    Success,
    Failed,
    RebootFailed,
    StatelessRebootFailed,
    CheckComplianceFailed,
    StateNotSatisfied,
    ExitMaintenancemodeFailed,
    Canceled,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The composition status class.
/// 
/// Possible values:
/// - `success`
/// - `error`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostProfileManagerCompositionResultResultElementStatusEnum {
    Success,
    Error,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The composition validation status class.
/// 
/// Possible values:
/// - `success`
/// - `error`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostProfileManagerCompositionValidationResultResultElementStatusEnum {
    Success,
    Error,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The *HostProfileManagerTaskListRequirement_enum* enum
/// defines possible values for requirements when applying a *HostConfigSpec*
/// object returned as part of a <code>generateConfigTaskList</code>
/// operation.
/// 
/// Possible values:
/// - `maintenanceModeRequired`: The ESXi host must be in maintenance mode before the task list can be
///   applied.
/// - `rebootRequired`: The ESXi host must be rebooted after the task list is applied in order
///   for the new settings in the *HostConfigSpec* to take
///   effect on the host.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HostProfileManagerTaskListRequirementEnum {
    MaintenanceModeRequired,
    RebootRequired,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines the result status values for a validating answer file.
/// 
/// Possible values:
/// - `success`: Answer File validation was successful.
/// - `failed`: Answer File validation failed.
/// - `failed_defaults`: Answer File validation failed to generate default.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum AnswerFileValidationInfoStatusEnum {
    Success,
    Failed,
    FailedDefaults,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `sunday`
/// - `monday`
/// - `tuesday`
/// - `wednesday`
/// - `thursday`
/// - `friday`
/// - `saturday`
///
/// ### How to access
/// - `ScheduledTask::reconfigure_scheduled_task(spec).scheduler→MonthlyByWeekdayTaskScheduler.weekday`
/// - `ScheduledTaskManager::create_scheduled_task(spec).scheduler→MonthlyByWeekdayTaskScheduler.weekday`
/// - `ScheduledTaskManager::create_object_scheduled_task(spec).scheduler→MonthlyByWeekdayTaskScheduler.weekday`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum DayOfWeekEnum {
    Sunday,
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `first`
/// - `second`
/// - `third`
/// - `fourth`
/// - `last`
///
/// ### How to access
/// - `ScheduledTask::reconfigure_scheduled_task(spec).scheduler→MonthlyByWeekdayTaskScheduler.offset`
/// - `ScheduledTaskManager::create_scheduled_task(spec).scheduler→MonthlyByWeekdayTaskScheduler.offset`
/// - `ScheduledTaskManager::create_object_scheduled_task(spec).scheduler→MonthlyByWeekdayTaskScheduler.offset`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum WeekOfMonthEnum {
    First,
    Second,
    Third,
    Fourth,
    Last,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Rule scope determines conditions when an affinity rule is
/// satisfied.
/// 
/// The following uses affinity rule as example.
/// cluster: All Vms in the rule list are placed in a single cluster.
/// host: All Vms in the rule list are placed in a single host.
/// storagePod: All Vms in the rule list are placed in a single storagePod.
/// datastore: All Vms in the rule list are placed in a single datastore.
/// 
/// Possible values:
/// - `cluster`: clusters are the scope
/// - `host`: individual hosts are the scope
/// - `storagePod`: datastore cluster is teh scope
/// - `datastore`: individual datastores are the scope
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PlacementAffinityRuleRuleScopeEnum {
    Cluster,
    Host,
    StoragePod,
    Datastore,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Rule type determines how the affinity rule is to be enforced:
/// affinity: Vms in the list are kept together within the rule
/// scope.
/// 
/// anti-affinity: Vms in the rule list are kept separate
/// across the objects in the rule scope.
/// soft rule: The enforcement is best effort.
/// 
/// Possible values:
/// - `affinity`: Affinity
/// - `antiAffinity`: Anti-Affinity
/// - `softAffinity`: Best-effort affinity
/// - `softAntiAffinity`: Best-effort anti-affinity
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PlacementAffinityRuleRuleTypeEnum {
    Affinity,
    AntiAffinity,
    SoftAffinity,
    SoftAntiAffinity,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Storage DRS behavior.
/// 
/// Possible values:
/// - `manual`: Specifies that VirtualCenter should generate recommendations for
///   virtual disk migration and for placement with a datastore,
///   but should not execute the recommendations automatically.
/// - `automated`: Specifies that VirtualCenter should generate recommendations
///   for virtual disk migration and for placement with a
///   datastore.
///   
///   The recommendations for virtual disk migrations
///   will be executed automatically, but the placement
///   recommendations will be done manually.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum StorageDrsPodConfigInfoBehaviorEnum {
    Manual,
    Automated,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines the two ways a space utilization threshold can be specified.
/// 
/// Possible values:
/// - `utilization`: Default mode: threshold as a percentage of datastore capacity
/// - `freeSpace`: Threshold as an absolute value of free space in GBs
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum StorageDrsSpaceLoadBalanceConfigSpaceThresholdModeEnum {
    Utilization,
    FreeSpace,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines the storage placement operation type.
/// 
/// Possible values:
/// - `create`: Create a VM.
/// - `reconfigure`: Reconfigure a VM.
/// - `relocate`: Relocate a VM.
/// - `clone`: Clone a VM.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum StoragePlacementSpecPlacementTypeEnum {
    Create,
    Reconfigure,
    Relocate,
    Clone,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Rule type determines how the virtual disks in a vm can be grouped
/// together.
/// 
/// Possible values:
/// - `affinity`: Virtual disks in the list are grouped together and placed on
///   the same data store.
/// - `antiAffinity`: Virtual disks in the list are placed on different data stores.
/// - `disabled`: SDRS will be disabled for the disks in the list.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualDiskRuleSpecRuleTypeEnum {
    Affinity,
    AntiAffinity,
    Disabled,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The cloned VMs can either be provisioned the same way as the VMs
/// they are a clone of, thin provisioned or thick provisioned, or
/// linked clones (i.e., using delta disks).
/// 
/// Possible values:
/// - `sameAsSource`: Each disk in the cloned virtual machines will have the same
///   type of disk as the source vApp.
/// - `thin`: Each disk in the cloned virtual machines is allocated in full
///   size now and committed on demand.
///   
///   This is only supported on
///   VMFS-3 and newer datastores. Other types of datastores may
///   create thick disks.
/// - `thick`: Each disk in the cloned virtual machines are allocated and
///   committed in full size immediately.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VAppCloneSpecProvisioningTypeEnum {
    SameAsSource,
    Thin,
    Thick,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `none`: No action is taken for this virtual machine.
///   
///   This virtual machine is
///   not a part of the auto-start sequence. This can be used for both auto-start
///   and auto-start settings.
/// - `powerOn`: This virtual machine is powered on when it is next in the auto-start order.
/// - `powerOff`: This virtual machine is powered off when it is next in the auto-stop order.
///   
///   This is the default stopAction.
/// - `guestShutdown`: The guest operating system for a virtual machine is shut down when that
///   virtual machine in next in the auto-stop order.
/// - `suspend`: This virtual machine is suspended when it is next in the auto-stop order.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VAppAutoStartActionEnum {
    None,
    PowerOn,
    PowerOff,
    GuestShutdown,
    Suspend,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// IP allocation schemes supported by the guest.
/// 
/// Possible values:
/// - `dhcp`: The vApp supports DHCP to acquire IP configuration.
/// - `ovfenv`: The vApp supports setting the IP configuration through the
///   properties provided in the OVF environment.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VAppIpAssignmentInfoAllocationSchemesEnum {
    Dhcp,
    Ovfenv,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// IP allocation policy for a deployment.
/// 
/// Possible values:
/// - `dhcpPolicy`: Specifies that DHCP must be used to allocate IP addresses to the vApp
/// - `transientPolicy`: Specifies that IP allocation is done through the range managed by the
///   vSphere platform.
///   
///   The IP addresses are allocated when needed, typically at
///   power-on, and deallocated during power-off. There is no guarantee that a
///   vApp will get the same IP address when restarted.
/// - `fixedPolicy`: Specifies that IP addresses are configured manually when the vApp is deployed
///   and will be kept until reconfigured or the vApp destroyed.
///   
///   This will ensure
///   that a vApp gets a consistent IP for its life-time.
/// - `fixedAllocatedPolicy`: Specifies that IP allocation is done through the range managed by the VI
///   platform.
///   
///   The IP addresses are allocated at first power-on, and remain
///   allocated at power-off. This will ensure that a vApp gets a consistent
///   IP for its life-time.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VAppIpAssignmentInfoIpAllocationPolicyEnum {
    DhcpPolicy,
    TransientPolicy,
    FixedPolicy,
    FixedAllocatedPolicy,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// IP protocols supported by the guest.
/// 
/// Possible values:
/// - `IPv4`: The vApp supports IPv4 protocol.
/// - `IPv6`: The vApp supports IPv6 protocol.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VAppIpAssignmentInfoProtocolsEnum {
    IPv4,
    IPv6,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `configured`: VCHA cluster is configured.
/// - `notConfigured`: VCHA cluster is not configured.
/// - `invalid`: VCHA cluster is in an invalid/dirty state.
/// - `prepared`: VC appliance has been prepared for VCHA cluster configuration.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VchaStateEnum {
    Configured,
    NotConfigured,
    Invalid,
    Prepared,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// VchaClusterMode enum defines the possible modes for a VCHA Cluster.
/// 
/// Possible values:
/// - `enabled`: VCHA Cluster is enabled.
///   
///   State replication between the Active and
///   Passive node is enabled and automatic failover is allowed.
/// - `disabled`: VCHA Cluster is disabled.
///   
///   State replication between the Active and
///   Passive node is disabled and automatic failover is not allowed.
/// - `maintenance`: VCHA Cluster is in maintenance mode.
///   
///   State replication between the
///   Active and Passive node is enabled but automatic failover
///   is not allowed.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VchaClusterModeEnum {
    Enabled,
    Disabled,
    Maintenance,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// VchaClusterState enum defines the possible states for a VCHA Cluster.
/// 
/// Possible values:
/// - `healthy`: All three nodes in a VCHA Cluster are healthy and connected.
///   
///   State
///   replication between Active and Passive node is working and both
///   nodes are in sync.
/// - `degraded`: A VCHA Cluster is said to be in a degraded state for
///   either or all of the following reasons:
///   \- There is a node loss.
///   
///   \- State replication between the Active and Passive node fails.
/// - `isolated`: All three nodes are isolated from each other.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VchaClusterStateEnum {
    Healthy,
    Degraded,
    Isolated,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `active`: Node is having a role of Active.
///   
///   In this role, node runs a vCenter
///   Server that serves client requests.
/// - `passive`: Node is having a role of Passive.
///   
///   In this role node, runs as a standby
///   for the Active vCenter Server and receives state updates. This node
///   takes over the role of Active vCenter Server upon failover.
/// - `witness`: Node is having a role of Witness.
///   
///   In this role, node acts as a quorom
///   node for avoiding the classic split-brain problem.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VchaNodeRoleEnum {
    Active,
    Passive,
    Witness,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// VchaNodeState enum defines possible state a node can be in a
/// VCHA Cluster.
/// 
/// Possible values:
/// - `up`: Node is up and has joined the VCHA Cluster.
/// - `down`: Node is down and has left the VCHA Cluster.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VchaNodeStateEnum {
    Up,
    Down,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `ipv4`: PXE (or Apple NetBoot) over IPv4.
///   
///   The default.
/// - `ipv6`: PXE over IPv6.
///   
///   Only meaningful for EFI virtual machines.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineBootOptionsNetworkBootProtocolTypeEnum {
    Ipv4,
    Ipv6,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Set of supported hash algorithms for thumbprints.
/// 
/// Possible values:
/// - `sha256`: SHA256
///   
/// ***Since:*** vSphere API Release 7.0.3.1
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineCertThumbprintHashAlgorithmEnum {
    Sha256,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// TPM provisioning policies used when cloning a VM with a virtual TPM
/// device.
/// 
/// Possible values:
/// - `copy`: The virtual TPM is copied.
///   
///   The virtual machine clone will have access
///   to the original virtual machine's TPM secrets.
/// - `replace`: The virtual TPM is replaced with a new one.
///   
///   The virtual machine clone
///   will not have access to the original virtual machine's TPM secrets.
/// 
/// ***Since:*** vSphere API Release 8.0.0.1
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineCloneSpecTpmProvisionPolicyEnum {
    Copy,
    Replace,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The NPIV WWN source type.
/// 
/// Possible values:
/// - `vc`: This set of WWNs is generated by VC server.
/// - `host`: This set of WWNs is generated by Host Agent.
/// - `external`: This set of WWNs is provided by the client.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineConfigInfoNpivWwnTypeEnum {
    Vc,
    Host,
    External,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Available choices for virtual machine swapfile placement policy.
/// 
/// This is
/// the set of legal values for the virtual machine configuration's
/// *swapPlacement* property. All
/// values except for "inherit" and "vmConfigured" are also valid values for
/// a compute resource configuration's
/// *vmSwapPlacement*
/// property.
/// 
/// Possible values:
/// - `inherit`: Honor the virtual machine swapfile placement policy of the compute
///   resource that contains this virtual machine.
/// - `vmDirectory`: Store the swapfile in the same directory as the virtual machine.
/// - `hostLocal`: Store the swapfile in the datastore specified by the
///   *localSwapDatastore*
///   property of the virtual machine's host, if that property is set and
///   indicates a datastore with sufficient free space.
///   
///   Otherwise store the
///   swapfile in the same directory as the virtual machine.
///   
///   Note: This setting may degrade VMotion performance.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineConfigInfoSwapPlacementTypeEnum {
    Inherit,
    VmDirectory,
    HostLocal,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The set of valid encrypted Fault Tolerance modes for a VM.
/// 
/// If the VM is encrypted, its encrypted Fault Tolerance mode
/// will be required.
/// 
/// Possible values:
/// - `ftEncryptionDisabled`: Do not use encrypted Fault Tolerance, even if available.
/// - `ftEncryptionOpportunistic`: Use encrypted Fault Tolerance if source and destination hosts
///   support it, fall back to unencrypted Fault Tolerance otherwise.
///   
///   This is the default option.
/// - `ftEncryptionRequired`: Allow only encrypted Fault Tolerance.
///   
///   If either the source or
///   destination host does not support encrypted Fault Tolerance,
///   do not allow the Fault Tolerance to occur.
/// 
/// ***Since:*** vSphere API Release 7.0.2.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineConfigSpecEncryptedFtModesEnum {
    FtEncryptionDisabled,
    FtEncryptionOpportunistic,
    FtEncryptionRequired,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The set of valid encrypted vMotion modes for a VM.
/// 
/// If the VM is encrypted, its encrypted vMotion mode will be required.
/// 
/// Possible values:
/// - `disabled`: Do not use encrypted vMotion, even if available.
/// - `opportunistic`: Use encrypted vMotion if source and destination hosts support it,
///   fall back to unencrypted vMotion otherwise.
///   
///   This is the default option.
/// - `required`: Allow only encrypted vMotion.
///   
///   If the source or destination host does
///   not support vMotion encryption, do not allow the vMotion to occur.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineConfigSpecEncryptedVMotionModesEnum {
    Disabled,
    Opportunistic,
    Required,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The root WWN operation mode.
/// 
/// Possible values:
/// - `generate`: Generate a new set of WWNs and assign it to the virtual machine.
/// - `set`: Take a client-specified set of WWNs (specified in "wwn" property) and
///   assign them to the virtual machine.
///   
///   If the new WWN quntity are more
///   than existing then we will append them to the existing list of WWNs.
/// - `remove`: Remove the currently assigned WWNs from the virtual machine.
/// - `extend`: Generate a new set of WWNs and append them to the existing list
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineConfigSpecNpivWwnOpEnum {
    Generate,
    Set,
    Remove,
    Extend,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The list of possible default power operations available for the virtual machine
/// 
/// Possible values:
/// - `soft`
/// - `hard`
/// - `preset`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachinePowerOpTypeEnum {
    Soft,
    Hard,
    Preset,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The list of possible standby actions that the virtual machine can take
/// for S1 ACPI.
/// 
/// Possible values:
/// - `checkpoint`
/// - `powerOnSuspend`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineStandbyActionTypeEnum {
    Checkpoint,
    PowerOnSuspend,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `vmNptIncompatibleHost`: The virtual machine's host does not support VMDirectPath Gen 2.
///   
///   See also *HostCapability.vmDirectPathGen2Supported*.
/// - `vmNptIncompatibleNetwork`: The configuration or state of the attached network prevents
///   VMDirectPath Gen 2.
///   
///   Refer to
///   *vmDirectPathGen2InactiveReasonNetwork*
///   and/or
///   *vmDirectPathGen2InactiveReasonExtended*
///   in the RuntimeInfo of the DistributedVirtualPort connected to this
///   device.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOtherEnum {
    VmNptIncompatibleHost,
    VmNptIncompatibleNetwork,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `vmNptIncompatibleGuest`: The virtual machine's guest OS does not support
///   VMDirectPath Gen 2.
/// - `vmNptIncompatibleGuestDriver`: The virtual machine's guest network driver does not support
///   VMDirectPath Gen 2.
/// - `vmNptIncompatibleAdapterType`: The device type does not support VMDirectPath Gen 2.
///   
///   See also *VirtualEthernetCardOption.vmDirectPathGen2Supported*.
/// - `vmNptDisabledOrDisconnectedAdapter`: The virtual machine's network adapter is disabled or
///   disconnected, and thus is not participating in VMDirectPath Gen 2.
/// - `vmNptIncompatibleAdapterFeatures`: The virtual machine's network adapter has features enabled
///   which preclude it participating in VMDirectPath Gen 2 such
///   as INT-x or PXE booting.
/// - `vmNptIncompatibleBackingType`: The device backing is not a DistributedVirtualPortBacking.
/// - `vmNptInsufficientMemoryReservation`: The virtual machine does not have full memory reservation
///   required to activate VMDirectPath Gen 2.
/// - `vmNptFaultToleranceOrRecordReplayConfigured`: 
///   
///   Deprecated as of vSphere API 6.0.
///   
///   The virtual machine is configured for Fault Tolerance or
///   Record &amp; Replay, which prevents VMDirectPath Gen 2.
/// - `vmNptConflictingIOChainConfigured`: Some networking feature has placed a conflicting IOChain on
///   the network adapter, which prevents VMDirectPath Gen 2.
///   
///   Examples
///   include DVFilter.
/// - `vmNptMonitorBlocks`: The virtual machine monitor is exercising functionality which
///   which prevents VMDirectPath Gen 2.
/// - `vmNptConflictingOperationInProgress`: VMDirectPath Gen 2 is temporarily suspended while the virtual
///   machine executes an operation such as suspend.
/// - `vmNptRuntimeError`: VMDirectPath Gen 2 is unavailable due to an unforeseen runtime error
///   in the virtualization platform (typically resource constraints.)
/// - `vmNptOutOfIntrVector`: VMDirectPath Gen 2 is unavailable due to host run out of intr
///   vector in host.
///   
///   Guest can configure the vNIC to use less rx/tx
///   queues or use MSI instead of MSIX.
/// - `vmNptVMCIActive`: VMDirectPath Gen 2 is unavailable due to Incompatibe feature
///   VMCI is active in the current VM.
///   
///   Kill the relevant VMCI
///   application(s) and restart the VM will allow the vNIC(s) to enter
///   passthrough mode.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum {
    VmNptIncompatibleGuest,
    VmNptIncompatibleGuestDriver,
    VmNptIncompatibleAdapterType,
    VmNptDisabledOrDisconnectedAdapter,
    VmNptIncompatibleAdapterFeatures,
    VmNptIncompatibleBackingType,
    VmNptInsufficientMemoryReservation,
    VmNptFaultToleranceOrRecordReplayConfigured,
    VmNptConflictingIoChainConfigured,
    VmNptMonitorBlocks,
    VmNptConflictingOperationInProgress,
    VmNptRuntimeError,
    VmNptOutOfIntrVector,
    VmNptVmciActive,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// File-type constants.
/// 
/// Possible values:
/// - `config`: Config (vmx) file.
/// - `extendedConfig`: Extended config (vmxf) file.
/// - `diskDescriptor`: Disk descriptor (vmdk) file.
/// - `diskExtent`: Disk extent (-flat/-delta/-s/-rdm/-rdmp.vmdk) file.
/// - `digestDescriptor`: Disk digest descriptor file.
/// - `digestExtent`: Disk digest extent file.
/// - `diskReplicationState`: Host based replicated disk persistent state (psf) file.
/// - `log`: Log (log) file.
/// - `stat`: Virtual machine statistics (stat) file.
/// - `namespaceData`: Namespace data file.
/// - `dataSetsDiskModeStore`: DataSets disk mode store (dsd) file.
///   
///   ***Since:*** vSphere API Release 8.0.0.0
/// - `dataSetsVmModeStore`: DataSets vm mode store (dsv) file.
///   
///   ***Since:*** vSphere API Release 8.0.0.0
/// - `nvram`: Non-volatile RAM (nvram) file.
/// - `snapshotData`: Snapshot data (vmsn) file.
/// - `snapshotMemory`: Snapshot memory (vmem) file.
/// - `snapshotList`: Snapshot metadata (vmsd) file.
/// - `snapshotManifestList`: Snapshot manifest metadata (-aux.xml) file.
///   
///   This file is still being created but is no longer necessary since
///   the manifest metadata is now available in the snapshot metadata
///   (vmsd) file in vSphere 5.0. This type will be deprecated when
///   vSphere 4.1 is no longer supported.
/// - `suspend`: Suspend (vmss) file.
/// - `suspendMemory`: Suspend (vmem) file.
/// - `swap`: Swap (vswp) file.
/// - `uwswap`: File generated by VMware ESX kernel for a running virtual
///   machine.
/// - `core`: Core (core) file.
/// - `screenshot`: Screenshot file.
/// - `ftMetadata`: Fault Tolerance metadata file.
/// - `guestCustomization`: Guest image customization file.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineFileLayoutExFileTypeEnum {
    Config,
    ExtendedConfig,
    DiskDescriptor,
    DiskExtent,
    DigestDescriptor,
    DigestExtent,
    DiskReplicationState,
    Log,
    Stat,
    NamespaceData,
    DataSetsDiskModeStore,
    DataSetsVmModeStore,
    Nvram,
    SnapshotData,
    SnapshotMemory,
    SnapshotList,
    SnapshotManifestList,
    Suspend,
    SuspendMemory,
    Swap,
    Uwswap,
    Core,
    Screenshot,
    FtMetadata,
    GuestCustomization,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Deprecated as of vSphere API 6.7.
/// 
/// Set of possible values for *VirtualMachineFlagInfo.htSharing*.
/// 
/// Possible values:
/// - `any`: VCPUs may freely share cores at any time with any other
///   VCPUs (default for all virtual machines on a hyperthreaded
///   system).
/// - `none`: VCPUs should not share cores with each other or with VCPUs
///   from other virtual machines.
///   
///   That is, each VCPU from this
///   virtual machine should always get a whole core to itself,
///   with the other logical CPU on that core being placed into
///   the "halted" state.
/// - `internal`: Similar to "none", in that VCPUs from this virtual machine
///   will not be allowed to share cores with VCPUs from other
///   virtual machines.
///   
///   However, other VCPUs from the same virtual
///   machine will be allowed to share cores together. This
///   configuration option is only permitted for SMP virtual
///   machines. If applied to a uniprocessor virtual machine, it
///   will be converted to the "none" sharing option.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineHtSharingEnum {
    Any,
    None,
    Internal,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Set of possible values for *VirtualMachineFlagInfo.monitorType*.
/// 
/// Possible values:
/// - `release`: Run vmx in default mode, matching the build type of vmkernel.
/// - `debug`: Run vmx in debug mode.
/// - `stats`: Run vmx in stats mode.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineFlagInfoMonitorTypeEnum {
    Release,
    Debug,
    Stats,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Set of possible values for *VirtualMachineFlagInfo.snapshotPowerOffBehavior*.
/// 
/// Possible values:
/// - `powerOff`: Just power off the virtual machine.
/// - `revert`: Revert to the snapshot.
/// - `prompt`: Prompt the user for instructions at power-off time.
/// - `take`: Take a new snapshot.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachinePowerOffBehaviorEnum {
    PowerOff,
    Revert,
    Prompt,
    Take,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Set of possible values for *VirtualMachineFlagInfo.virtualExecUsage*.
/// 
/// Possible values:
/// - `hvAuto`: Determine automatically whether to use hardware virtualization (HV) support.
/// - `hvOn`: Use hardware virtualization (HV) support if the physical hardware supports it.
/// - `hvOff`: Do not use hardware virtualization (HV) support.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineFlagInfoVirtualExecUsageEnum {
    HvAuto,
    HvOn,
    HvOff,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Set of possible values for *VirtualMachineFlagInfo.virtualMmuUsage*.
/// 
/// Possible values:
/// - `automatic`: Determine automatically whether to use nested page table hardware support.
/// - `on`: Use nested paging hardware support if the physical hardware supports it.
/// - `off`: Do not use nested page table hardware support.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineFlagInfoVirtualMmuUsageEnum {
    Automatic,
    On,
    Off,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Fork child type.
/// 
/// A child could be type of none, persistent, or
/// nonpersistent.
/// 
/// Possible values:
/// - `none`: The virtual machine is not a child.
/// - `persistent`: The virtual machine is a persistent child.
/// - `nonpersistent`: The virtual machine is a non-persistent child.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineForkConfigInfoChildTypeEnum {
    None,
    Persistent,
    Nonpersistent,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Application state type.
/// 
/// Possible values:
/// - `none`: The application state wasn't set from the guest by the application agent.
///   
///   This is the default.
/// - `appStateOk`: The guest's application agent declared its state as normal and doesn't
///   require any action
/// - `appStateNeedReset`: Guest's application agent asks for immediate reset
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum GuestInfoAppStateTypeEnum {
    None,
    AppStateOk,
    AppStateNeedReset,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Guest customization status
/// 
/// Possible values:
/// - `TOOLSDEPLOYPKG_IDLE`: No guest customizationSpec has been applied for the VM
/// - `TOOLSDEPLOYPKG_PENDING`: The guest customizationSpec has been applied for the VM,
///   but the customization process has not yet started inside the guest OS
/// - `TOOLSDEPLOYPKG_RUNNING`: The customization process is currently running inside the guest OS
/// - `TOOLSDEPLOYPKG_SUCCEEDED`: The customization process has completed successfully inside the
///   guest OS
/// - `TOOLSDEPLOYPKG_FAILED`: The customizatio process has failed inside the guest OS
///   
/// ***Since:*** vSphere API Release 7.0.2.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum GuestInfoCustomizationStatusEnum {
    ToolsdeploypkgIdle,
    ToolsdeploypkgPending,
    ToolsdeploypkgRunning,
    ToolsdeploypkgSucceeded,
    ToolsdeploypkgFailed,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The possible hints that the guest could display about current tasks
/// inside the guest.
/// 
/// Possible values:
/// - `running`
/// - `shuttingDown`
/// - `resetting`
/// - `standby`
/// - `notRunning`
/// - `unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineGuestStateEnum {
    Running,
    ShuttingDown,
    Resetting,
    Standby,
    NotRunning,
    Unknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The installation type of tools in the VM.
/// 
/// Possible values:
/// - `guestToolsTypeUnknown`: Installation type is not known.
///   
///   Most likely tools have been
///   installed by OSPs or open-vm-tools, but a version that does
///   not report its install type or an install type that we do
///   not recognize.
/// - `guestToolsTypeMSI`: MSI is the installation type used for VMware Tools on Windows.
/// - `guestToolsTypeTar`: Tools have been installed by the tar installer.
/// - `guestToolsTypeOSP`: OSPs are RPM or Debian packages tailored for the OS in the VM.
///   
///   See http://packages.vmware.com
/// - `guestToolsTypeOpenVMTools`: open-vm-tools are the open-source version of VMware Tools, may have
///   been packaged by the OS vendor.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineToolsInstallTypeEnum {
    GuestToolsTypeUnknown,
    GuestToolsTypeMsi,
    GuestToolsTypeTar,
    GuestToolsTypeOsp,
    GuestToolsTypeOpenVmTools,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Current running status of VMware Tools running in the guest
/// operating system.
/// 
/// Possible values:
/// - `guestToolsNotRunning`: VMware Tools is not running.
/// - `guestToolsRunning`: VMware Tools is running.
/// - `guestToolsExecutingScripts`: VMware Tools is starting.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineToolsRunningStatusEnum {
    GuestToolsNotRunning,
    GuestToolsRunning,
    GuestToolsExecutingScripts,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Deprecated as of vSphere API 4.0 use *VirtualMachineToolsVersionStatus_enum*
/// and *VirtualMachineToolsRunningStatus_enum*.
/// 
/// Current status of VMware Tools running in the guest operating system.
/// 
/// Possible values:
/// - `toolsNotInstalled`: VMware Tools has never been installed
///   or has not run in the virtual machine.
/// - `toolsNotRunning`: VMware Tools is not running.
/// - `toolsOld`: VMware Tools is running, but the version is not current.
/// - `toolsOk`: VMware Tools is running and the version is current.
///
/// ### How to access
/// - `VirtualMachine::guest.tools_status?`
/// - `VirtualMachine::summary.guest?.tools_status?`
/// - `HostSystem::query_host_connection_info().vm?[*].guest?.tools_status?`
/// - `Datacenter::query_connection_info().vm?[*].guest?.tools_status?`
/// - `Datacenter::query_connection_info_via_spec().vm?[*].guest?.tools_status?`
/// - `EnvironmentBrowser::query_config_target().usb?[*].summary?.guest?.tools_status?`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineToolsStatusEnum {
    ToolsNotInstalled,
    ToolsNotRunning,
    ToolsOld,
    ToolsOk,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Current version status of VMware Tools installed in the guest operating
/// system.
/// 
/// Possible values:
/// - `guestToolsNotInstalled`: VMware Tools has never been installed.
/// - `guestToolsNeedUpgrade`: 
///   
///   Deprecated as of vSphere API 5.1 value is not reported by
///   toolsVersionStatus2, instead more detailed status is reported.
///   
///   VMware Tools is installed, but the version is not current.
/// - `guestToolsCurrent`: VMware Tools is installed, and the version is current.
/// - `guestToolsUnmanaged`: VMware Tools is installed, but it is not managed by VMWare.
/// - `guestToolsTooOld`: VMware Tools is installed, but the version is too old.
/// - `guestToolsSupportedOld`: VMware Tools is installed, supported, but a newer version is available.
/// - `guestToolsSupportedNew`: VMware Tools is installed, supported, and newer
///   than the version available on the host.
/// - `guestToolsTooNew`: VMware Tools is installed, and the version is known to be
///   too new to work correctly with this virtual machine.
/// - `guestToolsBlacklisted`: VMware Tools is installed, but the installed version is
///   known to have a grave bug and should be immediately upgraded.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineToolsVersionStatusEnum {
    GuestToolsNotInstalled,
    GuestToolsNeedUpgrade,
    GuestToolsCurrent,
    GuestToolsUnmanaged,
    GuestToolsTooOld,
    GuestToolsSupportedOld,
    GuestToolsSupportedNew,
    GuestToolsTooNew,
    GuestToolsBlacklisted,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Firmware types
/// 
/// Possible values:
/// - `bios`: BIOS firmware
/// - `efi`: Extensible Firmware Interface
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum GuestOsDescriptorFirmwareTypeEnum {
    Bios,
    Efi,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Guest operating system family constants.
/// 
/// Possible values:
/// - `windowsGuest`: Windows operating system
/// - `linuxGuest`: Linux operating system
/// - `netwareGuest`: Novell Netware
/// - `solarisGuest`: Solaris operating system
/// - `darwinGuestFamily`: Mac OS operating system
/// - `otherGuestFamily`: Other operating systems
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineGuestOsFamilyEnum {
    WindowsGuest,
    LinuxGuest,
    NetwareGuest,
    SolarisGuest,
    DarwinGuestFamily,
    OtherGuestFamily,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Guest operating system identifier.
/// 
/// Possible values:
/// - `dosGuest`: MS-DOS.
/// - `win31Guest`: Windows 3.1
/// - `win95Guest`: Windows 95
/// - `win98Guest`: Windows 98
/// - `winMeGuest`: Windows Millennium Edition
/// - `winNTGuest`: Windows NT 4
/// - `win2000ProGuest`: Windows 2000 Professional
/// - `win2000ServGuest`: Windows 2000 Server
/// - `win2000AdvServGuest`: Windows 2000 Advanced Server
/// - `winXPHomeGuest`: Windows XP Home Edition
/// - `winXPProGuest`: Windows XP Professional
/// - `winXPPro64Guest`: Windows XP Professional Edition (64 bit)
/// - `winNetWebGuest`: Windows Server 2003, Web Edition
/// - `winNetStandardGuest`: Windows Server 2003, Standard Edition
/// - `winNetEnterpriseGuest`: Windows Server 2003, Enterprise Edition
/// - `winNetDatacenterGuest`: Windows Server 2003, Datacenter Edition
/// - `winNetBusinessGuest`: Windows Small Business Server 2003
/// - `winNetStandard64Guest`: Windows Server 2003, Standard Edition (64 bit)
/// - `winNetEnterprise64Guest`: Windows Server 2003, Enterprise Edition (64 bit)
/// - `winLonghornGuest`: Windows Longhorn
/// - `winLonghorn64Guest`: Windows Longhorn (64 bit)
/// - `winNetDatacenter64Guest`: Windows Server 2003, Datacenter Edition (64 bit)
/// - `winVistaGuest`: Windows Vista
/// - `winVista64Guest`: Windows Vista (64 bit)
/// - `windows7Guest`: Windows 7
/// - `windows7_64Guest`: Windows 7 (64 bit)
/// - `windows7Server64Guest`: Windows Server 2008 R2 (64 bit)
/// - `windows8Guest`: Windows 8
/// - `windows8_64Guest`: Windows 8 (64 bit)
/// - `windows8Server64Guest`: Windows 8 Server (64 bit)
/// - `windows9Guest`: Windows 10
/// - `windows9_64Guest`: Windows 10 (64 bit)
/// - `windows9Server64Guest`: Windows 10 Server (64 bit)
/// - `windows11_64Guest`: Windows 11
///   
///   ***Since:*** vSphere API Release 8.0.0.1
/// - `windows12_64Guest`: Windows 12
///   
///   ***Since:*** vSphere API Release 8.0.0.1
/// - `windowsHyperVGuest`: Windows Hyper-V
/// - `windows2019srv_64Guest`: Windows Server 2019
/// - `windows2019srvNext_64Guest`: Windows Server 2022
///   
///   ***Since:*** vSphere API Release 7.0.1.0
/// - `windows2022srvNext_64Guest`: Windows Server 2025
///   
///   ***Since:*** vSphere API Release 8.0.0.1
/// - `freebsdGuest`: FreeBSD
/// - `freebsd64Guest`: FreeBSD x64
/// - `freebsd11Guest`: FreeBSD 11
/// - `freebsd11_64Guest`: FreeBSD 11 x64
/// - `freebsd12Guest`: FreeBSD 12
/// - `freebsd12_64Guest`: FreeBSD 12 x64
/// - `freebsd13Guest`: FreeBSD 13
///   
///   ***Since:*** vSphere API Release 7.0.1.0
/// - `freebsd13_64Guest`: FreeBSD 13 x64
///   
///   ***Since:*** vSphere API Release 7.0.1.0
/// - `freebsd14Guest`: FreeBSD 14
///   
///   ***Since:*** vSphere API Release 8.0.0.1
/// - `freebsd14_64Guest`: FreeBSD 14 x64
///   
///   ***Since:*** vSphere API Release 8.0.0.1
/// - `freebsd15Guest`: FreeBSD 15
///   
///   ***Since:*** vSphere API Release 9.0.0.0
/// - `freebsd15_64Guest`: FreeBSD 15 x64
///   
///   ***Since:*** vSphere API Release 9.0.0.0
/// - `redhatGuest`: Red Hat Linux 2.1
/// - `rhel2Guest`: Red Hat Enterprise Linux 2
/// - `rhel3Guest`: Red Hat Enterprise Linux 3
/// - `rhel3_64Guest`: Red Hat Enterprise Linux 3 (64 bit)
/// - `rhel4Guest`: Red Hat Enterprise Linux 4
/// - `rhel4_64Guest`: Red Hat Enterprise Linux 4 (64 bit)
/// - `rhel5Guest`: Red Hat Enterprise Linux 5
/// - `rhel5_64Guest`: Red Hat Enterprise Linux 5 (64 bit)
/// - `rhel6Guest`: Red Hat Enterprise Linux 6
/// - `rhel6_64Guest`: Red Hat Enterprise Linux 6 (64 bit)
/// - `rhel7Guest`: Red Hat Enterprise Linux 7
/// - `rhel7_64Guest`: Red Hat Enterprise Linux 7 (64 bit)
/// - `rhel8_64Guest`: Red Hat Enterprise Linux 8 (64 bit)
/// - `rhel9_64Guest`: Red Hat Enterprise Linux 9 (64 bit)
///   
///   ***Since:*** vSphere API Release 7.0.1.0
/// - `rhel10_64Guest`: Red Hat Enterprise Linux 10 (64 bit)
///   
///   ***Since:*** vSphere API Release 9.0.0.0
/// - `centosGuest`: CentOS 4/5
/// - `centos64Guest`: CentOS 4/5 (64-bit)
/// - `centos6Guest`: CentOS 6
/// - `centos6_64Guest`: CentOS 6 (64-bit)
/// - `centos7Guest`: CentOS 7
/// - `centos7_64Guest`: CentOS 7 (64-bit)
/// - `centos8_64Guest`: CentOS 8 (64-bit)
/// - `centos9_64Guest`: CentOS 9 (64-bit)
///   
///   ***Since:*** vSphere API Release 7.0.1.0
/// - `oracleLinuxGuest`: Oracle Linux 4/5
/// - `oracleLinux64Guest`: Oracle Linux 4/5 (64-bit)
/// - `oracleLinux6Guest`: Oracle 6
/// - `oracleLinux6_64Guest`: Oracle 6 (64-bit)
/// - `oracleLinux7Guest`: Oracle 7
/// - `oracleLinux7_64Guest`: Oracle 7 (64-bit)
/// - `oracleLinux8_64Guest`: Oracle 8 (64-bit)
/// - `oracleLinux9_64Guest`: Oracle 9 (64-bit)
///   
///   ***Since:*** vSphere API Release 7.0.1.0
/// - `oracleLinux10_64Guest`: Oracle 10 (64-bit)
///   
///   ***Since:*** vSphere API Release 9.0.0.0
/// - `suseGuest`: Suse Linux
/// - `suse64Guest`: Suse Linux (64 bit)
/// - `slesGuest`: Suse Linux Enterprise Server 9
/// - `sles64Guest`: Suse Linux Enterprise Server 9 (64 bit)
/// - `sles10Guest`: Suse linux Enterprise Server 10
/// - `sles10_64Guest`: Suse Linux Enterprise Server 10 (64 bit)
/// - `sles11Guest`: Suse linux Enterprise Server 11
/// - `sles11_64Guest`: Suse Linux Enterprise Server 11 (64 bit)
/// - `sles12Guest`: Suse linux Enterprise Server 12
/// - `sles12_64Guest`: Suse Linux Enterprise Server 12 (64 bit)
/// - `sles15_64Guest`: Suse Linux Enterprise Server 15 (64 bit)
/// - `sles16_64Guest`: Suse Linux Enterprise Server 16 (64 bit)
///   
///   ***Since:*** vSphere API Release 7.0.1.0
/// - `nld9Guest`: Novell Linux Desktop 9
/// - `oesGuest`: Open Enterprise Server
/// - `sjdsGuest`: Sun Java Desktop System
/// - `mandrakeGuest`: Mandrake Linux
/// - `mandrivaGuest`: Mandriva Linux
/// - `mandriva64Guest`: Mandriva Linux (64 bit)
/// - `turboLinuxGuest`: Turbolinux
/// - `turboLinux64Guest`: Turbolinux (64 bit)
/// - `ubuntuGuest`: Ubuntu Linux
/// - `ubuntu64Guest`: Ubuntu Linux (64 bit)
/// - `debian4Guest`: Debian GNU/Linux 4
/// - `debian4_64Guest`: Debian GNU/Linux 4 (64 bit)
/// - `debian5Guest`: Debian GNU/Linux 5
/// - `debian5_64Guest`: Debian GNU/Linux 5 (64 bit)
/// - `debian6Guest`: Debian GNU/Linux 6
/// - `debian6_64Guest`: Debian GNU/Linux 6 (64 bit)
/// - `debian7Guest`: Debian GNU/Linux 7
/// - `debian7_64Guest`: Debian GNU/Linux 7 (64 bit)
/// - `debian8Guest`: Debian GNU/Linux 8
/// - `debian8_64Guest`: Debian GNU/Linux 8 (64 bit)
/// - `debian9Guest`: Debian GNU/Linux 9
/// - `debian9_64Guest`: Debian GNU/Linux 9 (64 bit)
/// - `debian10Guest`: Debian GNU/Linux 10
/// - `debian10_64Guest`: Debian GNU/Linux 10 (64 bit)
/// - `debian11Guest`: Debian GNU/Linux 11
/// - `debian11_64Guest`: Debian GNU/Linux 11 (64 bit)
/// - `debian12Guest`: Debian GNU/Linux 12
///   
///   ***Since:*** vSphere API Release 8.0.0.1
/// - `debian12_64Guest`: Debian GNU/Linux 12 (64 bit)
///   
///   ***Since:*** vSphere API Release 8.0.0.1
/// - `debian13Guest`: Debian GNU/Linux 13
///   
///   ***Since:*** vSphere API Release 9.0.0.0
/// - `debian13_64Guest`: Debian GNU/Linux 13 (64 bit)
///   
///   ***Since:*** vSphere API Release 9.0.0.0
/// - `asianux3Guest`: Asianux Server 3
/// - `asianux3_64Guest`: Asianux Server 3 (64 bit)
/// - `asianux4Guest`: Asianux Server 4
/// - `asianux4_64Guest`: Asianux Server 4 (64 bit)
/// - `asianux5_64Guest`: Asianux Server 5 (64 bit)
/// - `asianux7_64Guest`: Asianux Server 7 (64 bit)
/// - `asianux8_64Guest`: Asianux Server 8 (64 bit)
/// - `asianux9_64Guest`: Asianux Server 9 (64 bit)
///   
///   ***Since:*** vSphere API Release 7.0.1.0
/// - `miraclelinux_64Guest`: MIRACLE LINUX (64-bit)
///   
///   ***Since:*** vSphere API Release 9.0.0.0
/// - `pardus_64Guest`: Pardus (64-bit)
///   
///   ***Since:*** vSphere API Release 9.0.0.0
/// - `opensuseGuest`: OpenSUSE Linux
/// - `opensuse64Guest`: OpenSUSE Linux (64 bit)
/// - `fedoraGuest`: Fedora Linux
/// - `fedora64Guest`: Fedora Linux (64 bit)
/// - `coreos64Guest`: CoreOS Linux (64 bit)
/// - `vmwarePhoton64Guest`: VMware Photon (64 bit)
/// - `other24xLinuxGuest`: Linux 2.4x Kernel
/// - `other26xLinuxGuest`: Linux 2.6x Kernel
/// - `otherLinuxGuest`: Linux 2.2x Kernel
/// - `other3xLinuxGuest`: Linux 3.x Kernel
/// - `other4xLinuxGuest`: Linux 4.x Kernel
/// - `other5xLinuxGuest`: Linux 5.x Kernel
///   
///   ***Since:*** vSphere API Release 7.0.1.0
/// - `other6xLinuxGuest`: Linux 6.x Kernel
///   
///   ***Since:*** vSphere API Release 8.0.0.1
/// - `other7xLinuxGuest`: Linux 7.x Kernel
///   
///   ***Since:*** vSphere API Release 9.0.0.0
/// - `genericLinuxGuest`: Other Linux
/// - `other24xLinux64Guest`: Linux 2.4.x Kernel (64 bit)
/// - `other26xLinux64Guest`: Linux 2.6.x Kernel (64 bit)
/// - `other3xLinux64Guest`: Linux 3.x Kernel (64 bit)
/// - `other4xLinux64Guest`: Linux 4.x Kernel (64 bit)
/// - `other5xLinux64Guest`: Linux 5.x Kernel (64 bit)
///   
///   ***Since:*** vSphere API Release 7.0.1.0
/// - `other6xLinux64Guest`: Linux 6.x Kernel (64 bit)
///   
///   ***Since:*** vSphere API Release 8.0.0.1
/// - `other7xLinux64Guest`: Linux 7.x Kernel (64 bit)
///   
///   ***Since:*** vSphere API Release 9.0.0.0
/// - `otherLinux64Guest`: Linux (64 bit)
/// - `solaris6Guest`: Solaris 6
/// - `solaris7Guest`: Solaris 7
/// - `solaris8Guest`: Solaris 8
/// - `solaris9Guest`: Solaris 9
/// - `solaris10Guest`: Solaris 10 (32 bit)
/// - `solaris10_64Guest`: Solaris 10 (64 bit)
/// - `solaris11_64Guest`: Solaris 11 (64 bit)
/// - `fusionos_64Guest`: FusionOS (64 bit)
///   
///   ***Since:*** vSphere API Release 9.0.0.0
/// - `prolinux_64Guest`: ProLinux (64 bit)
///   
///   ***Since:*** vSphere API Release 9.0.0.0
/// - `kylinlinux_64Guest`: Kylinlinux (64 bit)
///   
///   ***Since:*** vSphere API Release 9.0.0.0
/// - `os2Guest`: OS/2
/// - `eComStationGuest`: eComStation 1.x
/// - `eComStation2Guest`: eComStation 2.0
/// - `netware4Guest`: Novell NetWare 4
/// - `netware5Guest`: Novell NetWare 5.1
/// - `netware6Guest`: Novell NetWare 6.x
/// - `openServer5Guest`: SCO OpenServer 5
/// - `openServer6Guest`: SCO OpenServer 6
/// - `unixWare7Guest`: SCO UnixWare 7
/// - `darwinGuest`: Mac OS 10.5
/// - `darwin64Guest`: Mac OS 10.5 (64 bit)
/// - `darwin10Guest`: Mac OS 10.6
/// - `darwin10_64Guest`: Mac OS 10.6 (64 bit)
/// - `darwin11Guest`: Mac OS 10.7
/// - `darwin11_64Guest`: Mac OS 10.7 (64 bit)
/// - `darwin12_64Guest`: Mac OS 10.8 (64 bit)
/// - `darwin13_64Guest`: Mac OS 10.9 (64 bit)
/// - `darwin14_64Guest`: Mac OS 10.10 (64 bit)
/// - `darwin15_64Guest`: Mac OS 10.11 (64 bit)
/// - `darwin16_64Guest`: Mac OS 10.12 (64 bit)
/// - `darwin17_64Guest`: macOS 10.13 (64 bit)
/// - `darwin18_64Guest`: macOS 10.14 (64 bit)
/// - `darwin19_64Guest`: macOS 10.15 (64 bit)
/// - `darwin20_64Guest`: macOS 11 (64 bit)
///   
///   ***Since:*** vSphere API Release 7.0.1.0
/// - `darwin21_64Guest`: macOS 12 (64 bit)
///   
///   ***Since:*** vSphere API Release 7.0.1.0
/// - `darwin22_64Guest`: macOS 13 (64 bit)
///   
///   ***Since:*** vSphere API Release 8.0.0.1
/// - `darwin23_64Guest`: macOS 14 (64 bit)
///   
///   ***Since:*** vSphere API Release 8.0.0.1
/// - `vmkernelGuest`: VMware ESX 4
/// - `vmkernel5Guest`: VMware ESX 5
/// - `vmkernel6Guest`: VMware ESX 6
/// - `vmkernel65Guest`: VMware ESXi 6.5 AND ESXi 6.7.
/// - `vmkernel7Guest`: VMware ESX 7
/// - `vmkernel8Guest`: VMware ESX 8
///   
///   ***Since:*** vSphere API Release 8.0.0.1
/// - `vmkernel9Guest`: VMware ESX 9
///   
///   ***Since:*** vSphere API Release 9.0.0.0
/// - `amazonlinux2_64Guest`: Amazon Linux 2 (64 bit)
/// - `amazonlinux3_64Guest`: Amazon Linux 3 (64 bit)
///   
///   ***Since:*** vSphere API Release 7.0.1.0
/// - `crxPod1Guest`: CRX Pod 1
/// - `crxSys1Guest`: CRX Sys 1
///   
///   ***Since:*** vSphere API Release 8.0.3.0
/// - `rockylinux_64Guest`: Rocky Linux (64-bit)
///   
///   ***Since:*** vSphere API Release 8.0.0.1
/// - `almalinux_64Guest`: AlmaLinux (64-bit)
///   
///   ***Since:*** vSphere API Release 8.0.0.1
/// - `otherGuest`: Other Operating System
/// - `otherGuest64`: Other Operating System (64 bit)
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineGuestOsIdentifierEnum {
    DosGuest,
    Win31Guest,
    Win95Guest,
    Win98Guest,
    WinMeGuest,
    WinNtGuest,
    Win2000ProGuest,
    Win2000ServGuest,
    Win2000AdvServGuest,
    WinXpHomeGuest,
    WinXpProGuest,
    WinXpPro64Guest,
    WinNetWebGuest,
    WinNetStandardGuest,
    WinNetEnterpriseGuest,
    WinNetDatacenterGuest,
    WinNetBusinessGuest,
    WinNetStandard64Guest,
    WinNetEnterprise64Guest,
    WinLonghornGuest,
    WinLonghorn64Guest,
    WinNetDatacenter64Guest,
    WinVistaGuest,
    WinVista64Guest,
    Windows7Guest,
    Windows764Guest,
    Windows7Server64Guest,
    Windows8Guest,
    Windows864Guest,
    Windows8Server64Guest,
    Windows9Guest,
    Windows964Guest,
    Windows9Server64Guest,
    Windows1164Guest,
    Windows1264Guest,
    WindowsHyperVGuest,
    Windows2019Srv64Guest,
    Windows2019SrvNext64Guest,
    Windows2022SrvNext64Guest,
    FreebsdGuest,
    Freebsd64Guest,
    Freebsd11Guest,
    Freebsd1164Guest,
    Freebsd12Guest,
    Freebsd1264Guest,
    Freebsd13Guest,
    Freebsd1364Guest,
    Freebsd14Guest,
    Freebsd1464Guest,
    Freebsd15Guest,
    Freebsd1564Guest,
    RedhatGuest,
    Rhel2Guest,
    Rhel3Guest,
    Rhel364Guest,
    Rhel4Guest,
    Rhel464Guest,
    Rhel5Guest,
    Rhel564Guest,
    Rhel6Guest,
    Rhel664Guest,
    Rhel7Guest,
    Rhel764Guest,
    Rhel864Guest,
    Rhel964Guest,
    Rhel1064Guest,
    CentosGuest,
    Centos64Guest,
    Centos6Guest,
    Centos664Guest,
    Centos7Guest,
    Centos764Guest,
    Centos864Guest,
    Centos964Guest,
    OracleLinuxGuest,
    OracleLinux64Guest,
    OracleLinux6Guest,
    OracleLinux664Guest,
    OracleLinux7Guest,
    OracleLinux764Guest,
    OracleLinux864Guest,
    OracleLinux964Guest,
    OracleLinux1064Guest,
    SuseGuest,
    Suse64Guest,
    SlesGuest,
    Sles64Guest,
    Sles10Guest,
    Sles1064Guest,
    Sles11Guest,
    Sles1164Guest,
    Sles12Guest,
    Sles1264Guest,
    Sles1564Guest,
    Sles1664Guest,
    Nld9Guest,
    OesGuest,
    SjdsGuest,
    MandrakeGuest,
    MandrivaGuest,
    Mandriva64Guest,
    TurboLinuxGuest,
    TurboLinux64Guest,
    UbuntuGuest,
    Ubuntu64Guest,
    Debian4Guest,
    Debian464Guest,
    Debian5Guest,
    Debian564Guest,
    Debian6Guest,
    Debian664Guest,
    Debian7Guest,
    Debian764Guest,
    Debian8Guest,
    Debian864Guest,
    Debian9Guest,
    Debian964Guest,
    Debian10Guest,
    Debian1064Guest,
    Debian11Guest,
    Debian1164Guest,
    Debian12Guest,
    Debian1264Guest,
    Debian13Guest,
    Debian1364Guest,
    Asianux3Guest,
    Asianux364Guest,
    Asianux4Guest,
    Asianux464Guest,
    Asianux564Guest,
    Asianux764Guest,
    Asianux864Guest,
    Asianux964Guest,
    Miraclelinux64Guest,
    Pardus64Guest,
    OpensuseGuest,
    Opensuse64Guest,
    FedoraGuest,
    Fedora64Guest,
    Coreos64Guest,
    VmwarePhoton64Guest,
    Other24XLinuxGuest,
    Other26XLinuxGuest,
    OtherLinuxGuest,
    Other3XLinuxGuest,
    Other4XLinuxGuest,
    Other5XLinuxGuest,
    Other6XLinuxGuest,
    Other7XLinuxGuest,
    GenericLinuxGuest,
    Other24XLinux64Guest,
    Other26XLinux64Guest,
    Other3XLinux64Guest,
    Other4XLinux64Guest,
    Other5XLinux64Guest,
    Other6XLinux64Guest,
    Other7XLinux64Guest,
    OtherLinux64Guest,
    Solaris6Guest,
    Solaris7Guest,
    Solaris8Guest,
    Solaris9Guest,
    Solaris10Guest,
    Solaris1064Guest,
    Solaris1164Guest,
    Fusionos64Guest,
    Prolinux64Guest,
    Kylinlinux64Guest,
    Os2Guest,
    EComStationGuest,
    EComStation2Guest,
    Netware4Guest,
    Netware5Guest,
    Netware6Guest,
    OpenServer5Guest,
    OpenServer6Guest,
    UnixWare7Guest,
    DarwinGuest,
    Darwin64Guest,
    Darwin10Guest,
    Darwin1064Guest,
    Darwin11Guest,
    Darwin1164Guest,
    Darwin1264Guest,
    Darwin1364Guest,
    Darwin1464Guest,
    Darwin1564Guest,
    Darwin1664Guest,
    Darwin1764Guest,
    Darwin1864Guest,
    Darwin1964Guest,
    Darwin2064Guest,
    Darwin2164Guest,
    Darwin2264Guest,
    Darwin2364Guest,
    VmkernelGuest,
    Vmkernel5Guest,
    Vmkernel6Guest,
    Vmkernel65Guest,
    Vmkernel7Guest,
    Vmkernel8Guest,
    Vmkernel9Guest,
    Amazonlinux264Guest,
    Amazonlinux364Guest,
    CrxPod1Guest,
    CrxSys1Guest,
    Rockylinux64Guest,
    Almalinux64Guest,
    OtherGuest,
    OtherGuest64,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Guest OS support level
/// 
/// Possible values:
/// - `experimental`: This operating system is not supported,
///   but may be supported in the future.
/// - `legacy`: This operating system is not fully supported,
///   but may have been supported in the past.
/// - `terminated`: No longer supported.
/// - `supported`: Fully supported.
/// - `unsupported`: This operating system is not supported.
/// - `deprecated`: Support for this operating system will be terminated in the future.
///   
///   Please migrate to using a different operating system.
/// - `techPreview`: This operating system may not be supported yet,
///   please check VMware compatibility guide.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum GuestOsDescriptorSupportLevelEnum {
    Experimental,
    Legacy,
    Terminated,
    Supported,
    Unsupported,
    Deprecated,
    TechPreview,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// End guest quiesce phase error types.
/// 
/// Possible values:
/// - `failure`: Fail the end phase of guest quiesce creation.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum GuestQuiesceEndGuestQuiesceErrorEnum {
    Failure,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This enum represents the set of legal operations
/// 
/// Possible values:
/// - `Update`: Create or update the Metadata for the specified VM
/// - `Remove`: Remove the Metadata for the specified VM
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineMetadataManagerVmMetadataOpEnum {
    Update,
    Remove,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This enum contains a list of valid owner values for
/// the name field
/// 
/// Possible values:
/// - `ComVmwareVsphereHA`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineMetadataManagerVmMetadataOwnerOwnerEnum {
    ComVmwareVsphereHa,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Specifies how a virtual disk is moved or copied to a
/// datastore.
/// 
/// In all cases after the move or copy the virtual machine's current running point
/// will be placed on the target datastore. The current running point is defined
/// as the disk backing which the virtual machine is currently
/// writing to. This end state can be achieved in multiple
/// ways, and the supported options are described in this
/// enumeration.
/// 
/// These options are only relevant when the backing of the
/// specified disk is a *file backing*.
/// 
/// Since disk backings may become shared as the result of
/// either a *clone operation* or
/// a *relocate operation*,
/// *VirtualMachine.PromoteDisks_Task* has been provided as
/// a way to unshare such disk backings.
/// 
/// See also *VirtualDiskSparseVer1BackingInfo.parent*, *VirtualDiskSparseVer2BackingInfo.parent*, *VirtualDiskFlatVer1BackingInfo.parent*, *VirtualDiskFlatVer2BackingInfo.parent*, *VirtualDiskRawDiskMappingVer1BackingInfo.parent*, *VirtualMachineRelocateSpec.diskMoveType*, *VirtualMachineRelocateSpecDiskLocator.diskMoveType*.
/// 
/// Possible values:
/// - `moveAllDiskBackingsAndAllowSharing`: All of the virtual disk's backings should be moved to the new datastore.
///   
///   If a disk backing is not the child-most backing of this virtual machine,
///   and there exists a read-only disk backing with the same content ID
///   on the target datastore, then this disk backing may not be copied. Instead
///   it is acceptable to attach to the read-only disk backing at the target
///   datastore. A read-only disk backing is defined as a virtual disk
///   backing which no virtual machine is currently writing to.
///   
///   See also *VirtualDiskSparseVer1BackingInfo.contentId*, *VirtualDiskSparseVer2BackingInfo.contentId*, *VirtualDiskFlatVer1BackingInfo.contentId*, *VirtualDiskFlatVer2BackingInfo.contentId*, *VirtualDiskRawDiskMappingVer1BackingInfo.contentId*.
/// - `moveAllDiskBackingsAndDisallowSharing`: All of the virtual disk's backings should be moved to the new datastore.
///   
///   It is not acceptable to attach to a disk backing with the same content ID
///   on the destination datastore. During a *clone operation* any delta disk backings will be consolidated.
/// - `moveChildMostDiskBacking`: Move only the child-most disk backing.
///   
///   Any parent disk backings should
///   be left in their current locations.
///   
///   This option only differs from *moveAllDiskBackingsAndAllowSharing* and
///   *moveAllDiskBackingsAndDisallowSharing* when the virtual
///   disk has a parent backing.
///   
///   Note that in the case of a *clone operation*,
///   this means that the parent disks will now be shared. This is safe as any
///   parent disks are always read-only.
///   Note that in the case of a *VirtualMachine.RelocateVM_Task* operation,
///   only the virtual disks in the current virtual machine configuration are moved.
/// - `createNewChildDiskBacking`: Create a new child disk backing on the destination datastore.
///   
///   None of the
///   virtual disk's existing files should be moved from their current locations.
///   
///   Note that in the case of a *clone operation*,
///   this means that the original virtual machine's disks are now all being shared.
///   This is only safe if the clone was taken from a snapshot point, because
///   snapshot points are always read-only. Thus for a clone this
///   option is only valid *when cloning from a snapshot*.
///   createNewChildDiskBacking is not a supported operation for
///   *VirtualMachine.RelocateVM_Task* operations unless all disks are moving.
/// - `moveAllDiskBackingsAndConsolidate`: All of the virtual disk's backings should be moved to the new datastore.
///   
///   During a *clone operation* or a
///   *VirtualMachine.MigrateVM_Task*, any delta disk backings will be
///   consolidated.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineRelocateDiskMoveOptionsEnum {
    MoveAllDiskBackingsAndAllowSharing,
    MoveAllDiskBackingsAndDisallowSharing,
    MoveChildMostDiskBacking,
    CreateNewChildDiskBacking,
    MoveAllDiskBackingsAndConsolidate,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Deprecated as of vSphere API 5.0.
/// 
/// The set of tranformations that can be performed on the virtual disks
/// as part of the copy.
/// 
/// Possible values:
/// - `flat`
/// - `sparse`
///
/// ### How to access
/// - `StoragePod::pod_storage_drs_entry.recommendation?[*].action?[*]→StoragePlacementAction.relocate_spec.transform?`
/// - `StoragePod::pod_storage_drs_entry.recommendation?[*].action?[*]→StorageMigrationAction.relocate_spec.transform?`
/// - `StoragePod::pod_storage_drs_entry.recommendation?[*].action?[*]→PlacementAction.relocate_spec?.transform?`
/// - `StoragePod::pod_storage_drs_entry.action_history?[*].action→StoragePlacementAction.relocate_spec.transform?`
/// - `StoragePod::pod_storage_drs_entry.action_history?[*].action→StorageMigrationAction.relocate_spec.transform?`
/// - `ClusterComputeResource::action_history.action→StoragePlacementAction.relocate_spec.transform?`
/// - `ClusterComputeResource::action_history.action→StorageMigrationAction.relocate_spec.transform?`
/// - `ClusterComputeResource::action_history.action→PlacementAction.relocate_spec?.transform?`
/// - `ClusterComputeResource::recommendation.action?[*]→StoragePlacementAction.relocate_spec.transform?`
/// - `ClusterComputeResource::recommendation.action?[*]→StorageMigrationAction.relocate_spec.transform?`
/// 
/// *(10 of 34 paths)*
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineRelocateTransformationEnum {
    Flat,
    Sparse,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The policy setting used to determine when to perform scheduled
/// upgrades for a virtual machine.
/// 
/// Possible values:
/// - `never`: No scheduled upgrades.
/// - `onSoftPowerOff`: Run scheduled upgrades only on normal guest OS shutdown.
/// - `always`: Always run scheduled upgrades.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ScheduledHardwareUpgradeInfoHardwareUpgradePolicyEnum {
    Never,
    OnSoftPowerOff,
    Always,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Status for last attempt to run scheduled hardware upgrade.
/// 
/// Possible values:
/// - `none`: No scheduled upgrade ever happened.
/// - `pending`: Upgrade is scheduled, but was not run yet.
/// - `success`: Upgrade succeeded.
/// - `failed`: Upgrade failed.
///   
///   For more information about the failure
///   
///   See also *ScheduledHardwareUpgradeInfo.fault*.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ScheduledHardwareUpgradeInfoHardwareUpgradeStatusEnum {
    None,
    Pending,
    Success,
    Failed,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible SCSI classes.
/// 
/// Possible values:
/// - `disk`
/// - `tape`
/// - `printer`
/// - `processor`
/// - `worm`
/// - `cdrom`
/// - `scanner`
/// - `optical`
/// - `media`
/// - `com`
/// - `raid`
/// - `unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineScsiPassthroughTypeEnum {
    Disk,
    Tape,
    Printer,
    Processor,
    Worm,
    Cdrom,
    Scanner,
    Optical,
    Media,
    Com,
    Raid,
    Unknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Flexible Launch Enclave (FLC) modes.
/// 
/// Possible values:
/// - `locked`: FLC is available in the guest.
///   
///   The "launch Enclave MSRs" are locked and
///   initialized with the provided public key hash.
/// - `unlocked`: FLC is available in the guest.
///   
///   The "launch enclave MSRs" are writeable
///   and initialized with Intel's public key hash.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineSgxInfoFlcModesEnum {
    Locked,
    Unlocked,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Describes how widely the endpoint is available in a cluster.
/// 
/// Note that these fields are not necessarily mutual-exclusive.
/// 
/// Possible values:
/// - `compliant`: Indicates that this device is part of the cluster compliant
///   specification.
/// - `clusterWide`: Indicates that this is available for all hosts in the cluster.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineTargetInfoConfigurationTagEnum {
    Compliant,
    ClusterWide,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The policy setting used to determine when tools are auto-upgraded for
/// a virtual machine
/// 
/// Possible values:
/// - `manual`: No auto-upgrades for tools will be performed for this
///   virtual machine.
///   
///   Users must manually invoke the UpgradeTools
///   operation to update the tools.
/// - `upgradeAtPowerCycle`: When the virtual machine is power-cycled, the system checks
///   for a newer version of tools when the VM comes back up.
///   
///   If it
///   is available, a tools upgrade is automatically performed on the
///   virtual machine and it is rebooted if necessary.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum UpgradePolicyEnum {
    Manual,
    UpgradeAtPowerCycle,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Device class family.
/// 
/// Possible values:
/// - `audio`: Audio capable device.
/// - `hid`: Human interface device.
/// - `hid_bootable`: Bootable human interface device, this is a subset of HID devices.
/// - `physical`: Physical interface device.
/// - `communication`: Communication device.
/// - `imaging`: Still imaging device.
/// - `printer`: Printer device.
/// - `storage`: Mass storage device.
/// - `hub`: USB hubs.
/// - `smart_card`: Smart card device.
/// - `security`: Content security device.
/// - `video`: Video device.
/// - `wireless`: Wireless controller.
/// - `bluetooth`: Standard bluetooth adapter that uses HCI protocol,
///   this is a subset of wireless controllers.
/// - `wusb`: Wireless device related to the Wireless USB standard,
///   this is a subset of wireless controllers,
/// - `pda`: Palm PDA, and Micorsoft ActiveSync PDA.
/// - `vendor_specific`: Device that has an interface using a vendor-specific protocol.
/// - `other`: Other miscellaneous device.
/// - `unknownFamily`: There was an error in determining this device's classes
///   accurately.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineUsbInfoFamilyEnum {
    Audio,
    Hid,
    HidBootable,
    Physical,
    Communication,
    Imaging,
    Printer,
    Storage,
    Hub,
    SmartCard,
    Security,
    Video,
    Wireless,
    Bluetooth,
    Wusb,
    Pda,
    VendorSpecific,
    Other,
    UnknownFamily,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Device speed.
/// 
/// Possible values:
/// - `low`: This device operates at low speed (1.5Mb/s).
/// - `full`: This device operates at full speed (12Mb/s).
/// - `high`: This device can operate at high speed (480Mb/s)
/// - `superSpeed`: This device can operate at super speed (4.8Gb/s)
/// - `superSpeedPlus`: This device can operate at super speed plus (10Gb/s)
/// - `superSpeed20Gbps`: This device can operate at super speed gen 2x2 (20Gb/s)
///   
///   ***Since:*** vSphere API Release 7.0.3.2
/// - `unknownSpeed`: This device's speed is unknown.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineUsbInfoSpeedEnum {
    Low,
    Full,
    High,
    SuperSpeed,
    SuperSpeedPlus,
    SuperSpeed20Gbps,
    UnknownSpeed,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Type of component device.
/// 
/// Possible values:
/// - `pciPassthru`
/// - `nvidiaVgpu`
/// - `sriovNic`
/// - `dvx`
/// 
/// ***Since:*** vSphere API Release 8.0.0.1
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineVendorDeviceGroupInfoComponentDeviceInfoComponentTypeEnum {
    PciPassthru,
    NvidiaVgpu,
    SriovNic,
    Dvx,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values for profile class.
/// 
/// Possible values:
/// - `compute`
/// - `quadro`
/// 
/// ***Since:*** vSphere API Release 7.0.3.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineVgpuProfileInfoProfileClassEnum {
    Compute,
    Quadro,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values for profile sharing.
/// 
/// Possible values:
/// - `timeSliced`: Time-sliced
/// - `mig`: Multi-instance GPU partitioning
///   
/// ***Since:*** vSphere API Release 7.0.3.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineVgpuProfileInfoProfileSharingEnum {
    TimeSliced,
    Mig,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `none`: No operation active.
/// - `scheduled`: Device swap will be performed on next restart.
/// - `inprogress`: Device swap is in progress.
/// - `failed`: Device swap failed.
/// - `completed`: Device swap successfully completed.
///   
/// ***Since:*** vSphere API Release 8.0.0.1
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineVirtualDeviceSwapDeviceSwapStatusEnum {
    None,
    Scheduled,
    Inprogress,
    Failed,
    Completed,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Motherboard layout of the VM.
/// 
/// Possible values:
/// - `i440bxHostBridge`: Single i440BX host bridge.
/// - `acpiHostBridges`: Multiple ACPI host bridges.
///   
/// ***Since:*** vSphere API Release 8.0.0.1
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualHardwareMotherboardLayoutEnum {
    I440BxHostBridge,
    AcpiHostBridges,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The set of supported snapshot modes for VMs configured with NVDIMMs.
/// 
/// Possible values:
/// - `independent_persistent`: The data on virtual NVDIMMs are not affected by snapshot reverts.
///   
///   Writes to virtual NVDIMMs after a snapshot is taken cannot be
///   reverted to the snapshotted state.
/// - `independent_eraseonrevert`: Virtual NVDIMMs are erased and recreated upon snapshot reverts.
///   
/// ***Since:*** vSphere API Release 7.0.3.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineVirtualPMemSnapshotModeEnum {
    IndependentPersistent,
    IndependentEraseonrevert,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The VSS Snapshot Context
/// VSS\_SNAPSHOT\_CONTEXT values not listed below are not implemented.
/// 
/// Possible values:
/// - `ctx_auto`: The context value indicates auto selection of VSS snapshot context.
///   
///   The ctx\_backup may make Windows VSS-aware applications quiescing during
///   backup. The ctx\_auto makes VMTools select ctx\_file\_share\_backup context
///   if ctx\_backup is not available.
/// - `ctx_backup`: Indicate VSS\_CTX\_BACKUP.
/// - `ctx_file_share_backup`: Indicate VSS\_CTX\_FILE\_SHARE\_BACKUP.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineWindowsQuiesceSpecVssBackupContextEnum {
    CtxAuto,
    CtxBackup,
    CtxFileShareBackup,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The types of tests which can requested by any of the methods in either
/// *VirtualMachineCompatibilityChecker* or *VirtualMachineProvisioningChecker*.
/// 
/// Possible values:
/// - `sourceTests`: Tests that examine only the configuration
///   of the virtual machine and its current host; the destination
///   resource pool and host or cluster are irrelevant.
/// - `hostTests`: Tests that examine both the virtual
///   machine and the destination host or cluster; the destination
///   resource pool is irrelevant.
///   
///   This set excludes tests that fall
///   into the datastoreTests group.
/// - `resourcePoolTests`: Tests that check that the destination resource
///   pool can support the virtual machine if it is powered on.
///   
///   The
///   destination host or cluster is relevant because it will affect the
///   amount of overhead memory required to run the virtual machine.
/// - `datastoreTests`: Tests that check that the
///   destination host or cluster can see the datastores where the virtual
///   machine's virtual disks are going to be located.
///   
///   The destination
///   resource pool is irrelevant.
/// - `networkTests`: Tests that check that the
///   destination host or cluster can see the networks that the virtual
///   machine's virtual nic devices are going to be connected.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum CheckTestTypeEnum {
    SourceTests,
    HostTests,
    ResourcePoolTests,
    DatastoreTests,
    NetworkTests,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// NetBIOS setting for Windows.
/// 
/// Possible values:
/// - `enableNetBIOSViaDhcp`: DHCP server decides whether or not to use NetBIOS.
/// - `enableNetBIOS`: Always use NetBIOS.
/// - `disableNetBIOS`: Never use NetBIOS.
///
/// ### How to access
/// - `VirtualMachine::check_customization_spec(spec).nic_setting_map?[*].adapter.net_bios?`
/// - `VirtualMachine::customize_vm_task(spec).nic_setting_map?[*].adapter.net_bios?`
/// - `VirtualMachine::clone_vm_task(spec).customization?.nic_setting_map?[*].adapter.net_bios?`
/// - `ClusterComputeResource::place_vm(placement_spec).clone_spec?.customization?.nic_setting_map?[*].adapter.net_bios?`
/// - `FailoverClusterConfigurator::create_passive_node_task(passive_deployment_spec).failover_ip_settings?.net_bios?`
/// - `FailoverClusterConfigurator::create_witness_node_task(witness_deployment_spec).ip_settings.net_bios?`
/// - `FailoverClusterConfigurator::create_witness_node_task(witness_deployment_spec)→PassiveNodeDeploymentSpec.failover_ip_settings?.net_bios?`
/// - `FailoverClusterConfigurator::deploy_vcha_task(deployment_spec).passive_deployment_spec.failover_ip_settings?.net_bios?`
/// - `FailoverClusterConfigurator::deploy_vcha_task(deployment_spec).witness_deployment_spec.ip_settings.net_bios?`
/// - `VirtualMachineGuestCustomizationManager::customize_guest_task(spec).nic_setting_map?[*].adapter.net_bios?`
/// 
/// *(10 of 27 paths)*
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum CustomizationNetBiosModeEnum {
    EnableNetBiosViaDhcp,
    EnableNetBios,
    DisableNetBios,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration of AutoMode values.
/// 
/// Possible values:
/// - `perServer`: Indicates that client access licenses have been purchased for the server,
///   allowing a certain number of concurrent connections to the VirtualCenter
///   server.
/// - `perSeat`: Indicates that a client access license has been purchased for each computer
///   that accesses the VirtualCenter server.
///
/// ### How to access
/// - `VirtualMachine::check_customization_spec(spec).identity→CustomizationSysprep.license_file_print_data?.auto_mode`
/// - `VirtualMachine::customize_vm_task(spec).identity→CustomizationSysprep.license_file_print_data?.auto_mode`
/// - `VirtualMachine::clone_vm_task(spec).customization?.identity→CustomizationSysprep.license_file_print_data?.auto_mode`
/// - `ClusterComputeResource::place_vm(placement_spec).clone_spec?.customization?.identity→CustomizationSysprep.license_file_print_data?.auto_mode`
/// - `VirtualMachineGuestCustomizationManager::customize_guest_task(spec).identity→CustomizationSysprep.license_file_print_data?.auto_mode`
/// - `CustomizationSpecManager::create_customization_spec(item).spec.identity→CustomizationSysprep.license_file_print_data?.auto_mode`
/// - `CustomizationSpecManager::get_customization_spec().spec.identity→CustomizationSysprep.license_file_print_data?.auto_mode`
/// - `CustomizationSpecManager::overwrite_customization_spec(item).spec.identity→CustomizationSysprep.license_file_print_data?.auto_mode`
/// - `CustomizationSpecManager::customization_spec_item_to_xml(item).spec.identity→CustomizationSysprep.license_file_print_data?.auto_mode`
/// - `CustomizationSpecManager::xml_to_customization_spec_item().spec.identity→CustomizationSysprep.license_file_print_data?.auto_mode`
/// 
/// *(10 of 12 paths)*
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum CustomizationLicenseDataModeEnum {
    PerServer,
    PerSeat,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// A enum constant specifying what should be done to the guest vm after running
/// sysprep.
/// 
/// Possible values:
/// - `reboot`: Reboot the machine after running sysprep.
///   
///   This will cause values
///   specified in the sysprep.xml to be applied immediately.
/// - `noreboot`: Take no action.
///   
///   Leave the guest os running after running sysprep. This
///   option can be used to look at values for debugging purposes after
///   running sysprep.
/// - `shutdown`: Shutdown the machine after running sysprep.
///   
///   This puts the vm in a
///   sealed state.
///
/// ### How to access
/// - `VirtualMachine::check_customization_spec(spec).options?→CustomizationWinOptions.reboot?`
/// - `VirtualMachine::customize_vm_task(spec).options?→CustomizationWinOptions.reboot?`
/// - `VirtualMachine::clone_vm_task(spec).customization?.options?→CustomizationWinOptions.reboot?`
/// - `ClusterComputeResource::place_vm(placement_spec).clone_spec?.customization?.options?→CustomizationWinOptions.reboot?`
/// - `VirtualMachineGuestCustomizationManager::customize_guest_task(spec).options?→CustomizationWinOptions.reboot?`
/// - `CustomizationSpecManager::create_customization_spec(item).spec.options?→CustomizationWinOptions.reboot?`
/// - `CustomizationSpecManager::get_customization_spec().spec.options?→CustomizationWinOptions.reboot?`
/// - `CustomizationSpecManager::overwrite_customization_spec(item).spec.options?→CustomizationWinOptions.reboot?`
/// - `CustomizationSpecManager::customization_spec_item_to_xml(item).spec.options?→CustomizationWinOptions.reboot?`
/// - `CustomizationSpecManager::xml_to_customization_spec_item().spec.options?→CustomizationWinOptions.reboot?`
/// 
/// *(10 of 12 paths)*
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum CustomizationSysprepRebootOptionEnum {
    Reboot,
    Noreboot,
    Shutdown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Contains information about connectable virtual devices when
/// the virtual machine restores from a migration.
/// 
/// Possible values:
/// - `connect`: Attempt to connect the virtual device when the virtual machine
///   restores from a migration.
///   
///   This property has no effect if it
///   is set on a device that is already connected.
/// - `disconnect`: Attempt to disconnect the virtual device when the virtual machine
///   restores from a migration.
///   
///   This property has no effect if it
///   is set on a device that is already disconnected.
/// - `unset`: Unset the property, which resets the device to its default state.
///   
///   Under most circumstances, a device will return to the same
///   connection state before the migration was initiated.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualDeviceConnectInfoMigrateConnectOpEnum {
    Connect,
    Disconnect,
    Unset,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Specifies the connectable virtual device status.
/// 
/// Possible values:
/// - `ok`: The device is working correctly.
/// - `recoverableError`: The device has reported a recoverable error.
///   
///   For example,
///   attempting to connect to floppy device that is being used by
///   another virtual machine or some other program would result in
///   this status.
/// - `unrecoverableError`: The device cannot be used.
///   
///   For example, attempting to connect to
///   a floppy device that does not exist would result in this status.
/// - `untried`: The device status is unknown, or it has not been requested to
///   connect when the VM is powered on.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualDeviceConnectInfoStatusEnum {
    Ok,
    RecoverableError,
    UnrecoverableError,
    Untried,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// All known file extensions.
/// 
/// Valid ones are:
/// 
/// Possible values:
/// - `iso`: CD ISO Image backings
/// - `flp`: Floppy File Backings
/// - `vmdk`: virtual disks
/// - `dsk`: legacy virtual disks
/// - `rdm`: pre 3.0 virtual disks using Raw Disk Maps
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualDeviceFileExtensionEnum {
    Iso,
    Flp,
    Vmdk,
    Dsk,
    Rdm,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The <code>VirtualDeviceURIBackingOptionDirection</code> enum type
/// provides values for the direction of a network connection.
/// 
/// Possible values:
/// - `server`: Indicates that the virtual machine can listen for a connection
///   on the specified *VirtualDeviceURIBackingInfo.serviceURI*.
/// - `client`: Indicates that the virtual machine can initiate a connection
///   with a system on the network using the specified
///   *VirtualDeviceURIBackingInfo.serviceURI*.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualDeviceUriBackingOptionDirectionEnum {
    Server,
    Client,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Describes the change mode of the device.
/// 
/// Applies only to virtual disks during VirtualDeviceSpec.Operation "add"
/// that have no VirtualDeviceSpec.FileOperation set.
/// 
/// Possible values:
/// - `fail`
/// - `skip`
/// 
/// ***Since:*** vSphere API Release 8.0.0.1
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualDeviceConfigSpecChangeModeEnum {
    Fail,
    Skip,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The type of operation being performed on the backing of a virtual device.
/// 
/// Valid values are:
/// 
/// Possible values:
/// - `create`: Specifies the creation of the device backing; for example,
///   the creation of a virtual disk or floppy image file.
/// - `destroy`: Specifies the destruction of a device backing.
/// - `replace`: Specifies the deletion of the existing backing for a virtual device
///   and the creation of a new backing.
///
/// ### How to access
/// - `StoragePod::pod_storage_drs_entry.recommendation?[*].action?[*]→StoragePlacementAction.relocate_spec.device_change?[*].file_operation?`
/// - `StoragePod::pod_storage_drs_entry.recommendation?[*].action?[*]→StorageMigrationAction.relocate_spec.device_change?[*].file_operation?`
/// - `StoragePod::pod_storage_drs_entry.recommendation?[*].action?[*]→PlacementAction.relocate_spec?.device_change?[*].file_operation?`
/// - `StoragePod::pod_storage_drs_entry.recommendation?[*].action?[*]→ClusterClusterInitialPlacementAction.config_spec?.device_change?[*].file_operation?`
/// - `StoragePod::pod_storage_drs_entry.action_history?[*].action→StoragePlacementAction.relocate_spec.device_change?[*].file_operation?`
/// - `ClusterComputeResource::action_history.action→StoragePlacementAction.relocate_spec.device_change?[*].file_operation?`
/// - `ClusterComputeResource::action_history.action→StorageMigrationAction.relocate_spec.device_change?[*].file_operation?`
/// - `ClusterComputeResource::action_history.action→PlacementAction.relocate_spec?.device_change?[*].file_operation?`
/// - `ClusterComputeResource::action_history.action→ClusterClusterInitialPlacementAction.config_spec?.device_change?[*].file_operation?`
/// - `ClusterComputeResource::recommendation.action?[*]→StoragePlacementAction.relocate_spec.device_change?[*].file_operation?`
/// 
/// *(10 of 57 paths)*
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualDeviceConfigSpecFileOperationEnum {
    Create,
    Destroy,
    Replace,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The type of operation being performed on the specified virtual device.
/// 
/// Valid values are:
/// 
/// Possible values:
/// - `add`: Specifies the addition of a virtual device to the configuration.
/// - `remove`: Specifies the removal of a virtual device.
/// - `edit`: Specifies changes to the virtual device specification.
///
/// ### How to access
/// - `StoragePod::pod_storage_drs_entry.recommendation?[*].action?[*]→StoragePlacementAction.relocate_spec.device_change?[*].operation?`
/// - `StoragePod::pod_storage_drs_entry.recommendation?[*].action?[*]→StorageMigrationAction.relocate_spec.device_change?[*].operation?`
/// - `StoragePod::pod_storage_drs_entry.recommendation?[*].action?[*]→PlacementAction.relocate_spec?.device_change?[*].operation?`
/// - `StoragePod::pod_storage_drs_entry.recommendation?[*].action?[*]→ClusterClusterInitialPlacementAction.config_spec?.device_change?[*].operation?`
/// - `StoragePod::pod_storage_drs_entry.action_history?[*].action→StoragePlacementAction.relocate_spec.device_change?[*].operation?`
/// - `ClusterComputeResource::action_history.action→StoragePlacementAction.relocate_spec.device_change?[*].operation?`
/// - `ClusterComputeResource::action_history.action→StorageMigrationAction.relocate_spec.device_change?[*].operation?`
/// - `ClusterComputeResource::action_history.action→PlacementAction.relocate_spec?.device_change?[*].operation?`
/// - `ClusterComputeResource::action_history.action→ClusterClusterInitialPlacementAction.config_spec?.device_change?[*].operation?`
/// - `ClusterComputeResource::recommendation.action?[*]→StoragePlacementAction.relocate_spec.device_change?[*].operation?`
/// 
/// *(10 of 57 paths)*
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualDeviceConfigSpecOperationEnum {
    Add,
    Remove,
    Edit,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The delta disk format constants
/// 
/// Possible values:
/// - `redoLogFormat`: redo-log based format
/// - `nativeFormat`: native snapshot format
/// - `seSparseFormat`: Flex-SE redo-log based format
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualDiskDeltaDiskFormatEnum {
    RedoLogFormat,
    NativeFormat,
    SeSparseFormat,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The delta disk format variant constants
/// 
/// Possible values:
/// - `vmfsSparseVariant`: vmfsSparse based redo-log format
/// - `vsanSparseVariant`: vsanSparse based redo-log format
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualDiskDeltaDiskFormatVariantEnum {
    VmfsSparseVariant,
    VsanSparseVariant,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The sharing mode of the virtual disk.
/// 
/// Setting the value to sharingMultiWriter means that multiple virtual
/// machines can write to the virtual disk. This sharing mode is allowed
/// only for eagerly zeroed thick virtual disks.
/// 
/// Possible values:
/// - `sharingNone`: The virtual disk is not shared.
/// - `sharingMultiWriter`: The virtual disk is shared between multiple virtual machines.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualDiskSharingEnum {
    SharingNone,
    SharingMultiWriter,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Pre-defined constants for cache consistency types
/// 
/// Possible values:
/// - `strong`: With strong consistency, it ensures that
///   a crash will leave the cache data consistent.
/// - `weak`: Cache data consistency is not guaranteed after a crash.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualDiskVFlashCacheConfigInfoCacheConsistencyTypeEnum {
    Strong,
    Weak,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Pre-defined constants for cache modes.
/// 
/// Possible values:
/// - `write_thru`: In write-through cache mode, writes to the cache cause writes
///   to the underlying storage.
///   
///   The cache acts as a facade to the underlying
///   storage.
/// - `write_back`: In write-back mode, writes to the cache do not go to the underlying storage
///   right away.
///   
///   Cache holds data temporarily till it can be permanently saved or
///   otherwise modified.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualDiskVFlashCacheConfigInfoCacheModeEnum {
    WriteThru,
    WriteBack,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// All known compatibility modes for raw disk mappings.
/// 
/// Valid compatibility
/// modes are:
/// - virtualMode
/// - physicalMode
///   
/// Possible values:
/// - `virtualMode`: A disk device backed by a virtual compatibility mode raw disk mapping can
///   use disk modes.
///   
///   See also *VirtualDiskMode_enum*.
/// - `physicalMode`: A disk device backed by a physical compatibility mode raw disk mapping cannot
///   use disk modes, and commands are passed straight through to the LUN
///   indicated by the raw disk mapping.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualDiskCompatibilityModeEnum {
    VirtualMode,
    PhysicalMode,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The list of known disk modes.
/// 
/// The list of supported disk modes varies by the backing type. The "persistent"
/// mode is supported by every backing type.
/// 
/// Possible values:
/// - `persistent`: Changes are immediately and permanently written to the virtual disk.
/// - `nonpersistent`: Changes to virtual disk are made to a redo log and discarded at power off.
/// - `undoable`: Changes are made to a redo log, but you are given the option to commit or undo.
/// - `independent_persistent`: Same as persistent, but not affected by snapshots.
/// - `independent_nonpersistent`: Same as nonpersistent, but not affected by snapshots.
/// - `append`: Changes are appended to the redo log; you revoke changes by removing the undo log.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualDiskModeEnum {
    Persistent,
    Nonpersistent,
    Undoable,
    IndependentPersistent,
    IndependentNonpersistent,
    Append,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible device names for legacy network backing option are listed below.
/// 
/// Note: This is not an exhaustive list. It is possible to specify
/// a specific device as well.
/// For example, on ESX hosts, the device name could be specified as "vmnic\[0-9\]"
/// or vmnet\_\[0-9\].
/// For VMware Server Windows hosts, the device name could be specified as "vmnet\[0-9\]"
/// 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.
/// 
/// Possible values:
/// - `bridged`
/// - `nat`
/// - `hostonly`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualEthernetCardLegacyNetworkDeviceNameEnum {
    Bridged,
    Nat,
    Hostonly,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The enumeration of all known valid MAC address types.
/// 
/// Possible values:
/// - `manual`: A statistically assigned MAC address.
/// - `generated`: An automatically generated MAC address.
/// - `assigned`: A MAC address assigned by VirtualCenter.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualEthernetCardMacTypeEnum {
    Manual,
    Generated,
    Assigned,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `noSharing`
/// - `physicalSharing`
/// 
/// ***Since:*** vSphere API Release 8.0.2.0
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualNvmeControllerSharingEnum {
    NoSharing,
    PhysicalSharing,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The valid choices for host pointing devices are:
/// 
/// Possible values:
/// - `autodetect`: Automatically detects the host mouse type.
/// - `intellimouseExplorer`: The Microsoft IntelliMouse Explorer.
/// - `intellimousePs2`: The Microsoft Intellimouse with a PS2 connection.
/// - `logitechMouseman`: The Logitech MouseMan.
/// - `microsoft_serial`: The Microsoft Serial Mouse.
/// - `mouseSystems`: The Mouse Systems Mouse.
/// - `mousemanSerial`: The Logitech MouseMan Serial Bus Mouse.
/// - `ps2`: A generic mouse with a PS2 connection.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualPointingDeviceHostChoiceEnum {
    Autodetect,
    IntellimouseExplorer,
    IntellimousePs2,
    LogitechMouseman,
    MicrosoftSerial,
    MouseSystems,
    MousemanSerial,
    Ps2,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Sharing describes three possible ways of sharing the SCSI bus:
/// One of these values is assigned to the sharedBus object to determine
/// if or how the SCSI bus is shared.
/// 
/// Possible values:
/// - `noSharing`: The virtual SCSI bus is not shared.
/// - `virtualSharing`: The virtual SCSI bus is shared between two or more virtual machines.
///   
///   In this case, no physical machine is involved.
/// - `physicalSharing`: The virtual SCSI bus is shared between two or more virtual machines
///   residing on different physical hosts.
///
/// ### How to access
/// - `VirtualMachine::config.hardware.device?[*]⇒VirtualScsiControllerTrait.shared_bus`
/// - `StoragePod::pod_storage_drs_entry.recommendation?[*].action?[*]→StoragePlacementAction.relocate_spec.device_change?[*].device⇒VirtualScsiControllerTrait.shared_bus`
/// - `StoragePod::pod_storage_drs_entry.recommendation?[*].action?[*]→StorageMigrationAction.relocate_spec.device_change?[*].device⇒VirtualScsiControllerTrait.shared_bus`
/// - `StoragePod::pod_storage_drs_entry.recommendation?[*].action?[*]→PlacementAction.relocate_spec?.device_change?[*].device⇒VirtualScsiControllerTrait.shared_bus`
/// - `StoragePod::pod_storage_drs_entry.recommendation?[*].action?[*]→ClusterClusterInitialPlacementAction.config_spec?.device_change?[*].device⇒VirtualScsiControllerTrait.shared_bus`
/// - `StoragePod::pod_storage_drs_entry.action_history?[*].action→StoragePlacementAction.relocate_spec.device_change?[*].device⇒VirtualScsiControllerTrait.shared_bus`
/// - `ClusterComputeResource::action_history.action→StoragePlacementAction.relocate_spec.device_change?[*].device⇒VirtualScsiControllerTrait.shared_bus`
/// - `ClusterComputeResource::action_history.action→StorageMigrationAction.relocate_spec.device_change?[*].device⇒VirtualScsiControllerTrait.shared_bus`
/// - `ClusterComputeResource::action_history.action→PlacementAction.relocate_spec?.device_change?[*].device⇒VirtualScsiControllerTrait.shared_bus`
/// - `ClusterComputeResource::action_history.action→ClusterClusterInitialPlacementAction.config_spec?.device_change?[*].device⇒VirtualScsiControllerTrait.shared_bus`
/// 
/// *(10 of 67 paths)*
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualScsiSharingEnum {
    NoSharing,
    VirtualSharing,
    PhysicalSharing,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The <code>*VirtualSerialPortEndPoint_enum* enum defines
/// endpoint values for virtual serial port pipe backing.
/// 
/// When you use serial port pipe backing to connect a virtual machine
/// to another process, you must define the endpoints.
/// See the <code>*VirtualSerialPortPipeBackingInfo.endpoint*</code>
/// property for the virtual serial port pipe backing information data object.
/// 
/// The possible endpoint values are:
/// - client
/// - server
///   
/// For the supported choices, see the
/// <code>*VirtualSerialPortPipeBackingOption.endpoint*</code>
/// property for the virtual serial port pipe backing option data object.
/// 
/// Possible values:
/// - `client`
/// - `server`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualSerialPortEndPointEnum {
    Client,
    Server,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Set of possible values for action field in FilterSpec.
/// 
/// Determines whether traffic is allowed or denied.
/// 
/// Possible values:
/// - `allow`: Allow communication.
/// - `deny`: Deny communication.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineVmciDeviceActionEnum {
    Allow,
    Deny,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Set of possible values for direction field in FilterSpec.
/// 
/// Possible values:
/// - `guest`: from host to guest
/// - `host`: from guest to host
/// - `anyDirection`: all of the above
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineVmciDeviceDirectionEnum {
    Guest,
    Host,
    AnyDirection,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Set of possible values for protocol field in FilterSpec.
/// 
/// Possible values:
/// - `hypervisor`: VMCI hypervisor datagram send op.
///   
///   Direction code is not applicable to this one.
/// - `doorbell`: VMCI doorbell notification
/// - `queuepair`: VMCI queue pair alloc operation.
///   
///   Direction code not applicable to this one.
/// - `datagram`: VMCI and VMCI Socket datagram send op.
///   
///   Since VMCI Socket datagrams map ports directly to resources,
///   there is no need to distinguish between the two.
/// - `stream`: VMCI Stream Socket connect op.
/// - `anyProtocol`: All of the above.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineVmciDeviceProtocolEnum {
    Hypervisor,
    Doorbell,
    Queuepair,
    Datagram,
    Stream,
    AnyProtocol,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Set of possible values for *VirtualMachineVideoCard.use3dRenderer*.
/// 
/// Possible values:
/// - `automatic`: Determine automatically whether to render 3D with software or hardware.
/// - `software`: Render 3D with software.
/// - `hardware`: Render 3D with graphics hardware.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualMachineVideoCardUse3DRendererEnum {
    Automatic,
    Software,
    Hardware,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// TSO (TCP Segmentation Offload) and LRO (Large Receive Offload)
/// are both offloading techniques that improve network performance
/// by reducing CPU overhead associated with packet segmentation
/// and aggregation, respectively.
/// 
/// They are commonly used in modern
/// networking environments to optimize data transmission and
/// reception processes. This is the type of disable offload on a
/// network adapter.
/// 
/// Possible values:
/// - `NONE`: Do not disable.
/// - `TSO`: Disable TCP Segmentation Offload (TSO).
/// - `LRO`: Disable Large Receive Offload (LRO).
/// - `TSO_LRO`: Disable both TSO and LRO.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualVmxnet3StrictLatencyConfigDisableOffloadEnum {
    None,
    Tso,
    Lro,
    TsoLro,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The enumeration of all known valid VRDMA device protocols.
/// 
/// Possible values:
/// - `rocev1`: A RoCEv1 device.
/// - `rocev2`: A RoCEv2 device.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VirtualVmxnet3VrdmaOptionDeviceProtocolsEnum {
    Rocev1,
    Rocev2,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `file`: Regular files, and on Posix filesystems, unix domain sockets
///   and devices.
/// - `directory`: directory
/// - `symlink`: symbolic link
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum GuestFileTypeEnum {
    File,
    Directory,
    Symlink,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This describes the bitness (32-bit or 64-bit) of a registry view in a
/// Windows OS that supports WOW64.
/// 
/// WOW64 (short for Windows 32-bit on Windows 64-bit) is the x86 emulator
/// that allows 32-bit Windows-based applications to run seamlessly on
/// 64-bit Windows. Please refer to these MSDN sites for more details:
/// 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
/// 
/// Possible values:
/// - `WOWNative`: Access the key from the native view of the
///   Registry (32-bit on 32-bit versions of Windows,
///   64-bit on 64-bit versions of Windows).
/// - `WOW32`: Access the key from the 32-bit view of the Registry.
/// - `WOW64`: Access the key from the 64-bit view of the Registry.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum GuestRegKeyWowSpecEnum {
    WowNative,
    Wow32,
    Wow64,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Capacity reservation state.
/// 
/// Possible values:
/// - `State_Unknown`: Represent the value when the lower version client cannot recognize the enum value.
/// - `Enforced`: Capacity reservation threshold is reported and enforced.
/// - `Reported`: Capacity reservation threshold is reported but is not enforced.
/// - `Disabled`: Capacity reservation threshold is not reported and is not enforced.
/// - `Unsupported`: Capacity reservation is not supported.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanCapacityReservationStateEnum {
    StateUnknown,
    Enforced,
    Reported,
    Disabled,
    Unsupported,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration of the allowed access type.
/// 
/// Possible values:
/// - `CleanAffinityLocation`: clean site affinity if the cluster is converted from a stretched cluster to a standard cluster.
/// - `FileServiceConfigOpType_Unknown`: indicates the value cannot be recognized.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanFileServiceConfigOpTypeEnum {
    CleanAffinityLocation,
    FileServiceConfigOpTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration of preflight check scope.
/// 
/// Possible values:
/// - `basic`: Scope indicates preflight check covers:
///   - Network partition check
///   - vSAN datastore presence to each host
///   - The versions of the ESXi hosts match in this cluster
///   - NTP configuration check in ESXi hosts if vSAN file service version is 8.0 or newer
///   - Domain configuration format check
///   - Running OVF information check
///   - If a DVS portgroup is passed as network, it checks if DVS version is older than 6.6
/// - `advanced`: Scope indicates preflight check covers:
///   - Checks covered in 'basic' scope
///   - File server domain configuration validation in live environment when vSAN file service has been enabled
/// - `FileServicePreflightCheckScope_Unknown`: represents the value when the lower version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanFileServicePreflightCheckScopeEnum {
    Basic,
    Advanced,
    FileServicePreflightCheckScopeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration of the allowed access type.
/// 
/// Possible values:
/// - `running`: File service VM is up and running
/// - `upgrading`: File service VM is in process of upgrading
/// - `FileServiceVMStatus_Unknown`: represent the value when the lower version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanFileServiceVmStatusEnum {
    Running,
    Upgrading,
    FileServiceVmStatusUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration of the allowed access type.
/// 
/// Possible values:
/// - `READ_ONLY`: Allows only read operations.
/// - `READ_WRITE`: Allows both read and write operations.
/// - `NO_ACCESS`: Does not allow any operations
/// - `FileShareAccessType_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanFileShareAccessTypeEnum {
    ReadOnly,
    ReadWrite,
    NoAccess,
    FileShareAccessTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration of the file share owner type.
/// 
/// Possible values:
/// - `cns`
/// - `user`
/// - `FileShareManagingEntity_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanFileShareManagingEntityEnum {
    Cns,
    User,
    FileShareManagingEntityUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration of the allowed NFS share security type.
/// 
/// This field is not applicable for SMB file share.
/// Kerberos security types is based on following RFC:
/// https://tools.ietf.org/html/rfc2203.
/// 
/// Possible values:
/// - `SYS`: AUTH\_SYS or unmanaged authentication from server.
///   
///   Where server trust the uid/gid sent from clients and make no attemp to validate the same.
/// - `KRB5`: RPCSEC\_GSS None (Only Authentication)
/// - `KRB5I`: RPCSEC\_GSS Integrity (With checksum)
/// - `KRB5P`: RPCSEC\_GSS Privacy (With Encryption)
/// - `FileShareNfsSecType_Unknown`: represent the value when the lower version client cannot recognize the enum value
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanFileShareNfsSecTypeEnum {
    Sys,
    Krb5,
    Krb5I,
    Krb5P,
    FileShareNfsSecTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration of the allowed file share protocol.
/// 
/// Possible values:
/// - `NFSv3`: NFSv3 protocol
/// - `NFSv4`: NFSv4.0 and NFSv4.1 protocol
/// - `SMB`: SMB2/SMB3 protocol.
/// - `FileShareProtocol_Unknown`: represent the value when the lower version client cannot recognize the enum value
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanFileProtocolEnum {
    NfSv3,
    NfSv4,
    Smb,
    FileShareProtocolUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration of the SMB file share encryption type.
/// 
/// Possible values:
/// - `disabled`: Disable the encryption for a share
/// - `mandatory`: Traffic to a share must be encrypted.
///   
///   Clients that do not support encryption will be denied on accessing the share
/// - `FileShareSmbEncryptionType_Unknown`: represent the value when the lower version client cannot recognize the enum value
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanFileShareSmbEncryptionTypeEnum {
    Disabled,
    Mandatory,
    FileShareSmbEncryptionTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The operation type to update Hci Mesh client info.
/// 
/// Possible values:
/// - `dryrunDs`: Dry run for precheck Datastore Source for a remote vCenter.
/// - `updateDs`: Create or update Datastore Source for a remote vCenter.
/// - `destroyDs`: Destroy Datastore Source for a remote vCenter.
/// - `dryrun`: Dry run.
/// - `mount`: Mount clients to server cluster.
/// - `update`: Update clients to server cluster.
/// - `unmount`: Unmount clients from server cluster.
/// - `HciMeshClientOperation_unknown`: Unknown operation type.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum HciMeshClientOperationEnum {
    DryrunDs,
    UpdateDs,
    DestroyDs,
    Dryrun,
    Mount,
    Update,
    Unmount,
    HciMeshClientOperationUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This list defines the types of vSAN IO diagnostics failed checks
/// in 8.x and previous releases.
/// 
/// Possible values:
/// - `perfsvcdisabled`: means the vSAN performance service is not enabled.
/// - `vsandisabled`: means vSAN is not enabled.
/// - `runninginstance`: means that there is already a running instance.
/// - `stretchedcluster`: means the vSAN stretched cluster is not supported.
/// - `nestedfaultdomain`: means the vSAN nested fault domain is not supported.
/// - `computeonlycluster`: means the vSAN HCI mesh compute-only cluster is not supported.
/// - `networkpartition`
/// - `vmnotpoweredon`: means the target virtual machine is not powered on.
/// - `vsanobjectinremotedatastore`: means the target virtual machine is in the remote datastore.
/// - `invalidtarget`: means the target is not valid.
/// - `invalidobjuuid`: means the object UUID is not valid.
/// - `invalidduration`: means the duration is not valid.
/// - `runninginstanceontarget`: ***Since:*** 8.0.0.4
/// - `toomanytargets`: ***Since:*** 8.0.0.4
/// - `toomanyobjects`: ***Since:*** 8.0.0.4
/// - `VsanIODiagnosticsFailedCheckType_Unknown`: represents the value when the lower version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanIoDiagnosticsFailedCheckTypeEnum {
    Perfsvcdisabled,
    Vsandisabled,
    Runninginstance,
    Stretchedcluster,
    Nestedfaultdomain,
    Computeonlycluster,
    Networkpartition,
    Vmnotpoweredon,
    Vsanobjectinremotedatastore,
    Invalidtarget,
    Invalidobjuuid,
    Invalidduration,
    Runninginstanceontarget,
    Toomanytargets,
    Toomanyobjects,
    VsanIoDiagnosticsFailedCheckTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This list defines the type of event which happens in the vSAN IO
/// diagnostics instance for 8.x and previous releases.
/// 
/// Possible values:
/// - `objectOwnerTransfer`: represents the object Owner transfer event.
/// - `primaryHostTransfer`: represents the primary host transfer event.
/// - `vsanmgmtdRestart`: represents the vsanmgmt daemon restart event.
/// - `objectComponentsLayoutChange`: represents the components layout change event.
/// - `objectProxyOwnerTransfer`
/// - `objectRemoval`: ***Since:*** 8.0.0.4
/// - `VsanIODiagnosticsInstanceEventType_Unknown`: represents the value when the lower version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanIoDiagnosticsInstanceEventTypeEnum {
    ObjectOwnerTransfer,
    PrimaryHostTransfer,
    VsanmgmtdRestart,
    ObjectComponentsLayoutChange,
    ObjectProxyOwnerTransfer,
    ObjectRemoval,
    VsanIoDiagnosticsInstanceEventTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This data object defines the state of vSAN IO diagnostics instance.
/// 
/// Valid types are:
/// 
/// Possible values:
/// - `VsanIODiagnosticsInstanceCompleted`: represents the completed instance.
/// - `VsanIODiagnosticsInstanceRunning`: represents the running instance.
/// - `VsanIODiagnosticsInstanceState_Unknown`: represents the value when the lower version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanIoDiagnosticsInstanceStateEnum {
    VsanIoDiagnosticsInstanceCompleted,
    VsanIoDiagnosticsInstanceRunning,
    VsanIoDiagnosticsInstanceStateUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This data object defines the types that support vSAN IO diagnostics.
/// 
/// Valid types are:
/// 
/// Possible values:
/// - `VirtualMachine`: with this type IO diagnostics task will be run against the vmdks associated with the virtual machine.
/// - `VsanIODiagnosticsTargetType_Unknown`: represents the value when the lower version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanIoDiagnosticsTargetTypeEnum {
    VirtualMachine,
    VsanIoDiagnosticsTargetTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This data object defines the type of the vSAN IO latency in the whole vSAN IO
/// stack from DOM owner to the DOM component manager and LSOM.
/// 
/// Possible values:
/// - `DomOwnerLatency`: Defines the latency spent at DOM owner layer.
/// - `NetworkLatency`: Defines the latency spent over the network.
/// - `LsomLatency`: Defines the latency spent at LSOM layer.
/// - `VsanIOLatencyType_Unknown`: The fallback version for an unknown vSAN IO latency type.
/// - `ZdomLatency`
/// - `PerfDomOwnerLatency`
/// - `CapacityDomOwnerLatency`
/// - `PerfNetworkLatency`
/// - `CapacityNetworkLatency`
/// - `PerfLsomLatency`
/// - `CapacityLsomLatency`
/// - `CrossSiteNetworkLatency`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanIoLatencyTypeEnum {
    DomOwnerLatency,
    NetworkLatency,
    LsomLatency,
    VsanIoLatencyTypeUnknown,
    ZdomLatency,
    PerfDomOwnerLatency,
    CapacityDomOwnerLatency,
    PerfNetworkLatency,
    CapacityNetworkLatency,
    PerfLsomLatency,
    CapacityLsomLatency,
    CrossSiteNetworkLatency,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The lifecycle operation types required by lifecycle manager/vLCM.
/// 
/// Possible values:
/// - `noChecks`: No checks, only return configuration details.
/// - `LifecycleCheckOperation_unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VimVsanLifecycleCheckOperationEnum {
    NoChecks,
    LifecycleCheckOperationUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The lifecycle cluster types required by lifecycle manager/vLCM.
/// 
/// Possible values:
/// - `single`: Single site cluster.
/// - `stretched`: Stretched cluster.
/// - `metadata`: Metadata mode cluster.
/// - `LifecycleClusterType_unknown`: Unknown cluster type.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VimVsanLifecycleClusterTypeEnum {
    Single,
    Stretched,
    Metadata,
    LifecycleClusterTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The lifecycle check types required by lifecycle manager/vLCM.
/// 
/// Possible values:
/// - `supportedWitnessVersion`: Check to cover that the witness host software version is 7.0 or higher.
/// - `virtualWitnessHost`: Check to cover that the witness host is a virtual host and not a physical host.
/// - `sharedWitnessHost`: Check to cover that the witness host is not shared.
/// - `PreCheckType_unknown`: Unknown precheck type.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VimVsanLifecyclePreCheckTypeEnum {
    SupportedWitnessVersion,
    VirtualWitnessHost,
    SharedWitnessHost,
    PreCheckTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Mode for the vSAN cluster.
/// 
/// If mode is not specified, then vSAN is running
/// in default vSAN mode.
/// 
/// Possible values:
/// - `Mode_None`: Represents the value for vSAN mode not being set.
///   
///   Any mode can be disabled by setting this value.
/// - `Mode_Compute`: Compute mode for vSAN.
///   
///   This mode can only be set if vSAN is not enabled on the cluster. To disable this mode, the mode value needs to be set to 'Mode\_None'. This mode allows the cluster to mount any remote vSAN datastore on this cluster. This cluster acts as a client cluster for the mounted vSAN datastore
/// - `Mode_Storage`
/// - `Mode_Unknown`: Represents the value when the lower version client cannot recognize the enum value
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanModeEnum {
    ModeNone,
    ModeCompute,
    ModeStorage,
    ModeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This indicates the precheck type when mounting a remote vSAN datastore
/// (for 8.x and previous releases).
/// 
/// Possible values:
/// - `supportedConfiguration`: General checks to cover following items, 1.
///   
///   vSAN is enabled on client cluster and server cluster. 2. Neither of client cluster nor server cluster is stretched/ROBO cluster. 3. Server cluster have only one vsan vmknics. 4. Data in transit encryption is off. 5. Client and server vSAN clusters should be same type (both OSA or ESA). 6: Compute only client cluster should mount only the same type (OSA or ESA) of the server clusters.
/// - `localVsanDatastore`: Check if given datastore is local vSAN datastore.
/// - `datastoreType`: Check if remote datastore is a vSAN datastore.
/// - `datacenter`: Check if given datastore and cluster are from different datacenters.
/// - `vsanFormatVersion`: Check vSAN format version can support mounting remote vSAN datastore.
/// - `serverClusterHealth`: Check if the cluster which owns given vSAN datastore is healthy.
/// - `datastorePolicy`: Check if given datastore can provision objects using default datastore policy.
/// - `remoteDatastoreLimit`: Check number of remote vSAN datastores which are mounted by a client cluster doesn't exceed limit.
/// - `clientClusterLimit`: Check number of client clusters which mount to a server cluster doesn't exceed limit.
/// - `serverClusterLimit`: Check number of server clusters which a client cluster mounts to doesn't exceed limit.
/// - `connectivity`: Check network connectivity between client hosts and server hosts.
/// - `networkLatency`: Check network latency between client hosts and server hosts.
/// - `license`: Check if all client hosts and server hosts have remote datastore license.
/// - `precheck_unknown`: Unknown precheck type.
/// - `serverVersionForComputeMode`
/// - `remoteVcConnection`
/// - `datastoreExists`
/// - `serverVcenterLimit`
/// - `clientVcenterLimit`
/// - `vcApiVersion`
/// - `vcenterIdValid`
/// - `checkServerVcenter`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VimVsanMountPrecheckTypeEnum {
    SupportedConfiguration,
    LocalVsanDatastore,
    DatastoreType,
    Datacenter,
    VsanFormatVersion,
    ServerClusterHealth,
    DatastorePolicy,
    RemoteDatastoreLimit,
    ClientClusterLimit,
    ServerClusterLimit,
    Connectivity,
    NetworkLatency,
    License,
    PrecheckUnknown,
    ServerVersionForComputeMode,
    RemoteVcConnection,
    DatastoreExists,
    ServerVcenterLimit,
    ClientVcenterLimit,
    VcApiVersion,
    VcenterIdValid,
    CheckServerVcenter,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Remediate action type.
/// 
/// When vSAN cluster remediate, vSAN will check the performance service configuration and
/// performance service status. If the vSAN performance service configuration is enable but
/// the vSAN performance service is not running, it will return "enable" to remediate vSAN
/// performance service. If the vSAN performance service configuration is disable but the
/// vSAN performance service is not running, it will return "disable" to remediate vSAN
/// performance service. If the vSAN performance service configuration is enable, the vSAN
/// performance service is running, but the profile of performance service is not match
/// the configuration, it will return "update\_profile" to remediate vSAN performance service.
/// Others will return "no\_action" which means no need to remediate vSAN performance service.
/// Valid types are:
/// 
/// Possible values:
/// - `enable`: remediate action is create stats object.
/// - `disable`: remediate action is delete stats object.
/// - `update_profile`: remediate action is update stats object policy.
/// - `no_action`: remediate action will do no action.
/// - `PerfsvcRemediateAction_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanPerfsvcRemediateActionEnum {
    Enable,
    Disable,
    UpdateProfile,
    NoAction,
    PerfsvcRemediateActionUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Related operations for PrecheckDatastoreSource.
/// 
/// Possible values:
/// - `checkCreateDs`: Run precheck for creating Datastore Source.
/// - `checkUpdateDs`: Run precheck for updating Datastore Source.
/// - `checkDestroyDs`: Run precheck for destroying Datastore Source.
/// - `PrecheckDatastoreSourceOperation_unknown`: Unknown operation type.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PrecheckDatastoreSourceOperationEnum {
    CheckCreateDs,
    CheckUpdateDs,
    CheckDestroyDs,
    PrecheckDatastoreSourceOperationUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The link type of a remote vCenter.
/// 
/// Possible values:
/// - `standalone`: Remote vCenter is standalone.
/// - `VsanRemoteVcLinkType_unknown`: Unsupported link type.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanRemoteVcLinkTypeEnum {
    Standalone,
    VsanRemoteVcLinkTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Network topology between the client and server cluster in a HCI Mesh
/// configuration.
/// 
/// Possible values:
/// - `Topology_Unknown`: Represent the value when the lower version client cannot recognize the enum value.
/// - `Symmetric`: Hosts in client and server clusters have homogenous network connectivity with similar network properties like bandwidth and latency.
/// - `Asymmetric`: Hosts in the client cluster have asymmetric network connectivity with different server cluster sites, such that hosts in a client site have a high bandwidth low latency link to one server site and a low bandwidth high lantency link to the other server site.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum RemoteVsanNetworkTopologyEnum {
    TopologyUnknown,
    Symmetric,
    Asymmetric,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration of the types for resource check component result.
/// 
/// Possible values:
/// - `vSAN`: The resource check result for regular vSAN.
/// - `DataPersistence`: The resource check result for vSphere data persistence platform.
/// - `ResourceCheckComponentType_Unknown`: represent the value when the lower version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanResourceCheckComponentTypeEnum {
    VSan,
    DataPersistence,
    ResourceCheckComponentTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// \* The dedup store health category enumeration used in resource check.
/// 
/// Possible values:
/// - `Inaccessible`: The dedup store is inaccessible which means the dedup store
///   has inaccessible sub objects.
/// - `Noncompliant`: The dedup store is noncompliant which means the dedup store
///   has no inaccessible sub objects but has noncompliant sub objects.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ResourceCheckDedupStoreHealthStateEnum {
    Inaccessible,
    Noncompliant,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration of the types for resource check status.
/// 
/// Possible values:
/// - `resourceCheckUninitialized`: The resource check has never run yet, or it just starts but the task has not been launched yet (i.e.
///   
///   still in initialization stage).
/// - `resourceCheckRunning`: The resource check is currently running.
/// - `resourceCheckFailed`: The resource check has failed.
/// - `resourceCheckCancelled`: The resource check has been cancelled by user.
/// - `resourceCheckCompleted`: The resource check has completed successfully.
/// - `resourceCheckNoRecentValue`: The last resource check completed successfully but then it has not run again for a while (e.g.
///   
///   60 min) and the result of the last check becomes stale.
/// - `resourceCheckNotSupported`: The resource check is not supported by one or more host in cluster.
/// - `ResourceCheckStatusType_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanResourceCheckStatusTypeEnum {
    ResourceCheckUninitialized,
    ResourceCheckRunning,
    ResourceCheckFailed,
    ResourceCheckCancelled,
    ResourceCheckCompleted,
    ResourceCheckNoRecentValue,
    ResourceCheckNotSupported,
    ResourceCheckStatusTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The creator of snapshot.
/// 
/// Possible values:
/// - `SnapService`: Snapshot is created by Snapshot Service.
/// - `SnapshotCreator_Unknown`: Represent the value when the lower version client cannot recognize the enum value.
///   
/// ***Since:*** 8.0.0.4
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanSnapshotCreatorEnum {
    SnapService,
    SnapshotCreatorUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The type of snapshot.
/// 
/// Possible values:
/// - `Managed`: Snapshot is a managed snapshot.
/// - `Unmanaged`: Snapshot is an unmanaged snapshot.
/// - `SnapshotType_Unknown`: Represent the value when the lower version client cannot recognize the enum value.
///   
/// ***Since:*** 8.0.0.4
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanSnapshotTypeEnum {
    Managed,
    Unmanaged,
    SnapshotTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration type for associating event with managed object
///   
/// This is a list of supported locations to associate an event.
/// 
/// The event
/// could be related to disk, hosts or cluster.
/// 
/// Possible values:
/// - `CLUSTER`
/// - `HOST`
/// - `DISK`
/// - `EVENT_LOCATION_UNKNOWN`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanAnalyticsEventLocationTypeEnum {
    Cluster,
    Host,
    Disk,
    EventLocationUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration type for snapshot types
///   
/// This is a list of supported snapshot types.
/// 
/// Possible values:
/// - `OBJECT_SNAPSHOT`
/// - `HOST_SNAPSHOT`
/// - `DISK_SNAPSHOT`
/// - `POLICY_SNAPSHOT`
/// - `SNAPSHOT_TYPE_UNKNOWN`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanAnalyticsEventSnapshotTypeEnum {
    ObjectSnapshot,
    HostSnapshot,
    DiskSnapshot,
    PolicySnapshot,
    SnapshotTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration type for events currently subscribed.
/// 
///   
/// This is a list of supported supported events vSAN analytics will collect.
/// 
/// Possible values:
/// - `STORAGE_OBJECT_UNAVAILABLE`
/// - `STORAGE_OBJECT_AVAILABLE`
/// - `STORAGE_OBJECT_REPL_CHANGE`
/// - `STORAGE_OBJECT_LOST`
/// - `STORAGE_OBJECT_CREATED`
/// - `STORAGE_OBJECT_DELETED`
/// - `STORAGE_DOM_OBJECT_CHANGE`
/// - `REPAIR_START`
/// - `REPAIR_END`
/// - `REBUILD_START`
/// - `REBUILD_END`
/// - `RESYNC_IN_PROGRESS`
/// - `RESYNC_END`
/// - `PATCH_START`
/// - `PATCH_END`
/// - `DG_DECOM_START`
/// - `DG_DECOM_END`
/// - `HOST_DECOM_START`
/// - `HOST_DECOM_FAIL`
/// - `HOST_DECOM_END`
/// - `CLUSTER_CREATED`
/// - `CLUSTER_DELETED`
/// - `SDDC_CREATED`
/// - `SDDC_DELETED`
/// - `HOST_CREATED`
/// - `HOST_DELETED`
/// - `CLUSTER_MEMBERSHIP_CHANGED`
/// - `DEVICE_FAILURE`
/// - `DEVICE_NORMAL`
/// - `DEVICE_OFFLINE`
/// - `DEVICE_ERROR`
/// - `HOST_FAILURE`
/// - `HOST_NORMAL`
/// - `EVENT_TYPE_UNKNOWN`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanAnalyticsEventTypeEnum {
    StorageObjectUnavailable,
    StorageObjectAvailable,
    StorageObjectReplChange,
    StorageObjectLost,
    StorageObjectCreated,
    StorageObjectDeleted,
    StorageDomObjectChange,
    RepairStart,
    RepairEnd,
    RebuildStart,
    RebuildEnd,
    ResyncInProgress,
    ResyncEnd,
    PatchStart,
    PatchEnd,
    DgDecomStart,
    DgDecomEnd,
    HostDecomStart,
    HostDecomFail,
    HostDecomEnd,
    ClusterCreated,
    ClusterDeleted,
    SddcCreated,
    SddcDeleted,
    HostCreated,
    HostDeleted,
    ClusterMembershipChanged,
    DeviceFailure,
    DeviceNormal,
    DeviceOffline,
    DeviceError,
    HostFailure,
    HostNormal,
    EventTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// It's used to declare the vSAN configuration types that the hardware
/// components like CPU, memory, disk and physical NIC is compatible with.
/// 
/// Possible values:
/// - `vsan`: represent the regular vSAN.
/// - `vsanEsa`: represent vSAN ESA.
/// - `VsanConfigType_Unknown`: represent the value when the lower version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanConfigTypeEnum {
    Vsan,
    VsanEsa,
    VsanConfigTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Values indicate the vSAN storage types that the disk is compatible with.
/// 
/// Possible values:
/// - `diskGroup`: represent disk group for regular vSAN.
/// - `singleTier`: represent vSAN ESA storage pool.
/// - `VsanDiskCompatibilityType_Unknown`: represent the value when the lower version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanDiskCompatibilityTypeEnum {
    DiskGroup,
    SingleTier,
    VsanDiskCompatibilityTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The total amount of health checks is split into multiple different
/// perspectives.
/// 
/// This list defines sets labels for sets of health checks
/// in 8.x and previous releases.
/// 
/// Possible values:
/// - `defaultView`: The default set, core "health checks".
/// - `deployAssist`: Health checks to aid the user in configuring all aspects of vSphere required for production vSAN clusters, including vDS, DRS, HA, etc.
///   
///   The checks represent best practices, and so ignoring failures is generally acceptable.
/// - `CreateExtendClusterView`: Health checks during creating/extending vSAN cluster which only include HCL check.
/// - `beforeConfigureHost`: Health checks before configuring host which includes the advanced config option consistent check, software version compatibility check, HCL check, etc.
/// - `upgradePreCheck`: Health checks before upgrade which includes some tests from HCL, network and physical disks checks.
/// - `vsanUpgradePreCheck`: Health checks before vsan upgrade which includes some tests from HCL, network and physical disks checks.
/// - `upgradeBeforeExitMM`: Health checks before exiting maintenance mode during upgrading which includes HCL, network and physical disk checks.
/// - `upgradeAfterExitMM`: Health checks after exiting maintenance mode during upgrading which includes HCL, network and physical disk checks.
/// - `vsanUpgradeBeforeExitMM`: Health checks before exiting maintenance mode during performing vSAN recommended upgrade which includes some tests in HCL, network and physical disk checks.
/// - `vsanUpgradeAfterExitMM`: Health checks after exiting maintenance mode during performing vSAN recommended upgrade which includes some tests in HCL, network and physical disk checks.
/// - `vmcUpgradePreChecks`: Health checks during POD upgrade
/// - `upgradePreCheckPman`
/// - `upgradeBeforeExitMMPman`
/// - `upgradeAfterExitMMPman`
/// - `inPlaceUpgradeServiceMode`
/// - `upgradePreCheckPmanForVMC`
/// - `upgradeBeforeExitMMPmanForVMC`
/// - `upgradeAfterExitMMPmanForVMC`
/// - `clusterPowerOffPrecheck`
/// - `VsanEsaPreChecks`
/// - `vcsaInstallerForVsanEsa`
/// - `upgradePreCheckForVCF`
/// - `VsanHealthPerspective_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanHealthPerspectiveEnum {
    DefaultView,
    DeployAssist,
    CreateExtendClusterView,
    BeforeConfigureHost,
    UpgradePreCheck,
    VsanUpgradePreCheck,
    UpgradeBeforeExitMm,
    UpgradeAfterExitMm,
    VsanUpgradeBeforeExitMm,
    VsanUpgradeAfterExitMm,
    VmcUpgradePreChecks,
    UpgradePreCheckPman,
    UpgradeBeforeExitMmPman,
    UpgradeAfterExitMmPman,
    InPlaceUpgradeServiceMode,
    UpgradePreCheckPmanForVmc,
    UpgradeBeforeExitMmPmanForVmc,
    UpgradeAfterExitMmPmanForVmc,
    ClusterPowerOffPrecheck,
    VsanEsaPreChecks,
    VcsaInstallerForVsanEsa,
    UpgradePreCheckForVcf,
    VsanHealthPerspectiveUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This list defines sets labels of multiple different perspectives
/// for sets of health checks in 9.0 release.
/// 
/// Possible values:
/// - `siteEnterMaintenance`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanHealthPerspective90Enum {
    SiteEnterMaintenance,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines health status states applicable to various vSAN system entities.
/// 
/// An entity in vSAN health system can have one of the following state.
/// Each state represent the health status of entity in terms of vSAN health
/// perspective.
/// Each system can define its notion of each health status. For example, status
/// 'red' for capacity means cluster is running very close to datastore full but
/// status 'red' for for an object mean it is already 'inaccessible'.
/// 
/// Possible values:
/// - `unknown`: Health status in not known for the entity.
///   
///   This might imply that : 1. Underlying entity do not support the mechanism to calculate the health status. 2. Status is not yet calculated.
/// - `yellow`: Shows a warning status for the entity.
///   
///   This might imply that : 1. Entity is currently available but running in degraded mode so some of the functionalities might not be available. 2. Potential configuration issue of recommendation which need user action to be resolved.
/// - `red`: Shows an alert for the system.
///   
///   This might imply that: 1. Entity is currently running in error state. 2. Potentially harm the cluster status is not fixed soon.
/// - `green`: Shows entity is in healthy state and no issues found.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanHealthStatusTypeEnum {
    Unknown,
    Yellow,
    Red,
    Green,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The vSAN threshold target type.
/// 
/// it is used in
/// *VsanHealthThreshold*, to indicate the thresholds are applied
/// on which target. A target could be a part of one health check, or just one
/// entire health check.
/// For below targets, a valid threshold should be a percentage, e.g., an
/// integer value which is in range \[0, 100\].
/// 
/// Possible values:
/// - `diskspace_vsan_datastore`: The vSAN datastore part of "Disk space"
/// - `diskspace_vsan_direct`: The vSAN direct part of "Disk space"
/// - `diskspace_vsan_pmem`
/// - `VsanHealthThresholdTarget_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanHealthThresholdTargetEnum {
    DiskspaceVsanDatastore,
    DiskspaceVsanDirect,
    DiskspaceVsanPmem,
    VsanHealthThresholdTargetUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The vSAN IO trip analyzer scheduler recurrence status type.
/// 
/// Possible values:
/// - `recurrenceEnabled`: The scheduler recurrence is enabled.
///   
///   Tasks will be triggered based on the settings.
/// - `recurrenceDisabled`: The scheduler recurrence is disabled.
///   
///   No task will be triggered.
/// - `VsanIOTripAnalyzerRecurrenceStatus_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanIoTripAnalyzerRecurrenceStatusEnum {
    RecurrenceEnabled,
    RecurrenceDisabled,
    VsanIoTripAnalyzerRecurrenceStatusUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// vSAN policy regulation check operators.
/// 
/// Possible values:
/// - `equal`: Equals to.
/// - `greater`: Greater than.
/// - `nogreater`: No greater than.
/// - `less`: Less than.
/// - `noless`: No less than.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanPolicyRegulationCheckOpEnumEnum {
    Equal,
    Greater,
    Nogreater,
    Less,
    Noless,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The Issue Type:
/// BROKEN\_CHAIN - The object is part of a snapshot chain that can't be
/// opened
/// LEAKED\_OBJECT - The object has no descriptor file
/// UNKNOWN - An unknown issue was detected trying to identify this object
/// 
/// Possible values:
/// - `BROKEN_CHAIN`
/// - `LEAKED_OBJECT`
/// - `UNKNOWN`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VimVsanVsanScanObjectsIssueTypeEnum {
    BrokenChain,
    LeakedObject,
    Unknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines the status of vSAN service.
/// 
/// Possible values:
/// - `started`: Stands for vSAN service is started.
/// - `stopped`: Stands for vSAN service is stopped.
/// - `VsanServiceStatus_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanServiceStatusEnum {
    Started,
    Stopped,
    VsanServiceStatusUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines vSAN site location type.
/// 
/// Possible values:
/// - `None`: No specific site location in stretched cluster.
/// - `Preferred`: Identify the preferred site in stretched cluster.
/// - `NonPreferred`: Identify the non-preferred site of stretched cluster.
/// - `VsanSiteLocationType_Unknown`: represent the value when the lower version client cannot recognize the enum value
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanSiteLocationTypeEnum {
    None,
    Preferred,
    NonPreferred,
    VsanSiteLocationTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// It's used to declare the health types of the received stats from the
/// vSAN SnapService Appliance.
/// 
/// Possible values:
/// - `applianceHealth`: represent the health stats of the data protection appliance.
/// - `pgSnapshotsHealth`: represent the snapshot health stats of the protection groups.
/// - `vmSnapshotsHealth`: represent the snapshot health stats of the virtual machines.
/// - `vmMembershipChanges`: represent the stats of VM membership changes.
/// - `VsanSnapHealthType_Unknown`: represent the value when the lower version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanSnapHealthTypeEnum {
    ApplianceHealth,
    PgSnapshotsHealth,
    VmSnapshotsHealth,
    VmMembershipChanges,
    VsanSnapHealthTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// It's used to declare the expiration types of the received stats from the
/// vSAN SnapService Appliance.
/// 
/// Possible values:
/// - `afterSet`: represent the stats will expire once the new value has been set.
/// - `afterGet`: represent the stats will expire once it has been queried.
/// - `afterTtl`: represent the stats will expire after a specific TTL.
/// - `never`: represent the stats will never expire.
/// - `VsanSnapStatsExpirationType_Unknown`: represent the value when the lower version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanSnapStatsExpirationTypeEnum {
    AfterSet,
    AfterGet,
    AfterTtl,
    Never,
    VsanSnapStatsExpirationTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// It's used to declare the virtual machine membership change status.
/// 
/// Possible values:
/// - `added`: represent the virtual machine is newly added to the protection group.
/// - `removed`: represent the virtual machine has been removed from the protection group.
/// - `VsanSnapVmMembershipChangeStatus_Unknown`: represent the value when the lower version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanSnapVmMembershipChangeStatusEnum {
    Added,
    Removed,
    VsanSnapVmMembershipChangeStatusUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The reasons why a vSAN component went into syncing state.
/// 
/// Possible values:
/// - `repair`: The component is created and resyncing to repair a bad component.
/// - `evacuate`: The component is created and resyncing after evacuate disk group or host to ensure accessibility and full data evacuation.
/// - `rebalance`: The component is created and resyncing for rebalancing.
/// - `reconfigure`: The component is created and resyncing after vSAN object was resized or its policy was changed.
/// - `dying_evacuate`: The component is being moved out when a disk is going to die.
/// - `stale`: The component is syncing because it was stale.
/// - `merge_concat`: The component is created and resyncing to merge concatenations.
/// - `object_format_change`
/// - `VsanSyncReason_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanSyncReasonEnum {
    Repair,
    Evacuate,
    Rebalance,
    Reconfigure,
    DyingEvacuate,
    Stale,
    MergeConcat,
    ObjectFormatChange,
    VsanSyncReasonUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The status of syncing vSAN component.
/// 
/// Components which need recovery
/// can be in one of the three status.
/// 
/// Possible values:
/// - `active`: The component which is actively syncing.
/// - `queued`: The component which is in queue for sync to start.
///   
///   Status change from queue to active could be due to reasons like availability of space in the cluster.
/// - `suspended`: The component which is in suspended state.
///   
///   This implies that once this component was actively syncing but now the sync is stopped by the cluster. Suspended state can be due to the disk on which component resides is close to full.
/// - `VsanSyncStatus_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanSyncStatusEnum {
    Active,
    Queued,
    Suspended,
    VsanSyncStatusUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Lists the impact on the node after applying update item.
/// 
/// Possible values:
/// - `reboot`: Host needs a reboot for this updateItem which also implies that it will enter maintenance mode before a reboot.
/// - `VsanUpdateItemImpactType_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanUpdateItemImpactTypeEnum {
    Reboot,
    VsanUpdateItemImpactTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Type of VsanUpdateItem.
/// 
/// Possible values:
/// - `vib`: A ESX VIB.
/// - `offlinebundle`: A ESX Offline Bundle containing ESXi VIB(s).
/// - `vmhbaFirmware`: Firmware of a SCSI/RAID controller.
/// - `fullStackFirmware`: (Deprecated since vSphere 8.0) Firmware of various components on host.
/// - `VsanUpdateItemType_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanUpdateItemTypeEnum {
    Vib,
    Offlinebundle,
    VmhbaFirmware,
    FullStackFirmware,
    VsanUpdateItemTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Phase of deployment.
/// 
/// Possible values:
/// - `initializing`: Deployment just started.
/// - `validation`: Deployment spec is being validated.
/// - `vsanbootstrap`: 1-Node vSAN cluster is being created.
/// - `ovaunpack`: VCSA OVA is being verified and unpacked.
/// - `vcsadeploy`: VCSA is being deployed (booted and configured).
/// - `vcconfig`: Post-install configuration of vCenter, like creation of datacenter, cluster objects and configuration of DRS, HA, vSAN and other features.
/// - `done`: deployment completed successfully.
/// - `failed`: Deployment failed.
/// - `VsanVcsaDeploymentPhase_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VimVsanVsanVcsaDeploymentPhaseEnum {
    Initializing,
    Validation,
    Vsanbootstrap,
    Ovaunpack,
    Vcsadeploy,
    Vcconfig,
    Done,
    Failed,
    VsanVcsaDeploymentPhaseUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Type of VsanVibSpec.
/// 
/// Possible values:
/// - `tool`: A management tool.
/// - `driver`: A management driver.
/// - `VsanVibType_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanVibTypeEnum {
    Tool,
    Driver,
    VsanVibTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines the possible operators to use when comparing the values of
/// individual property.
/// 
/// Possible values:
/// - `Equal`: Equality operator.
/// - `NotEqual`: Inequality operator.
/// - `Greater`: Greater than operator.
/// - `GreaterOrEqual`: Greater than or equal to operator.
/// - `Less`: Less than operator.
/// - `LessOrEqual`: Less than or equal to operator.
/// - `In`: Checks for equality with at least one of a list of values.
/// - `NotIn`: Checks for inequality with all values in a list.
/// - `Like`: Pattern matching operator applicable to string properties.
/// - `NotLike`: Opposite of operator Like.
/// - `Unset`: Used in conjunction with comparableValue to see if a property is set or not.
/// - `VsanXvcQueryCriteriaOperator_unknown`: Unknown operation type.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanXvcQueryCriteriaOperatorEnum {
    Equal,
    NotEqual,
    Greater,
    GreaterOrEqual,
    Less,
    LessOrEqual,
    In,
    NotIn,
    Like,
    NotLike,
    Unset,
    VsanXvcQueryCriteriaOperatorUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines operator types for query filter.
/// 
/// Possible values:
/// - `And`: The operator is evaluated to true only if all its operands are true.
/// - `Or`: The operator is evaluated to true if at least one of its operands is true.
/// - `Op_unknown`: Unknown operator.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanXvcQueryFilterOperatorEnum {
    And,
    Or,
    OpUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines the type of status for the Compliance Resource Check Query.
/// 
/// The status is one of the four inProgress/aborted/completed/uninitialized.
/// 
/// Possible values:
/// - `inProgress`: The Compliance Resource Check Query task is in progress.
/// - `aborted`: The Compliance Resource Check Query task is aborted due to some error etc.
/// - `completed`: The Compliance Resource Check Query is completed and data can be fetchd.
/// - `uninitialized`: The Compliance Resource Check Query is never called and the result cannot be get.
/// - `ComplianceResourceCheckStatusType_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VimVsanClusterComplianceResourceCheckStatusTypeEnum {
    InProgress,
    Aborted,
    Completed,
    Uninitialized,
    ComplianceResourceCheckStatusTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// vSAN managed storage types.
/// 
/// Possible values:
/// - `vsandirect`: Represents vSAN direct datastore managed by vSAN
/// - `pmem`: 
///   
///   Deprecated as of vSphere 9.0 APIs with no replacement.
///   
///   Represents PMem datastore managed by vSAN.
/// - `VsanManagedStorageType_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VimVsanClusterVsanManagedStorageTypeEnum {
    Vsandirect,
    Pmem,
    VsanManagedStorageTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines the high level cluster power state..
/// 
/// Possible values:
/// - `poweredOn`: indicates the cluster is powered on.
/// - `poweredOff`: indicates the cluster is powered off.
/// - `poweringOn`: indicates the cluster is in the progress of powering on.
/// - `poweringOff`: indicates the cluster is in the progress of powering off.
/// - `ClusterPowerState_Unknown`: represent the value when the lower version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ClusterPowerStateEnum {
    PoweredOn,
    PoweredOff,
    PoweringOn,
    PoweringOff,
    ClusterPowerStateUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Defines the set of status values for compliance operations.
/// 
/// Possible values:
/// - `compliant`: Entity is compliant.
/// - `nonCompliant`: Entity is not compliant.
/// - `unknown`: Compliance status of the entity is unknown.
/// - `notApplicable`: Compliance computation is not applicable for this entity, because it does not have any storage policy requirement for the datastore where the entity is placed.
/// - `outOfDate`: Compliance status of the entity is out of date when the policy associated with the entity is edited and not applied.
///   
///   The compliance status will remain in out-of-date status until the latest policy is applied to the entity.
/// - `ComplianceStatus_Unknown`: Represent the value when the lower version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanComplianceStatusEnum {
    Compliant,
    NonCompliant,
    Unknown,
    NotApplicable,
    OutOfDate,
    ComplianceStatusUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The action to take with regard to storage objects upon decommissioning
/// a host from use with the VSAN service.
/// 
/// Possible values:
/// - `noAction`: No special action should take place regarding VSAN data.
/// - `ensureObjectAccessibility`: VSAN data reconfiguration should be performed to ensure storage
///   object accessibility.
/// - `evacuateAllData`: VSAN data evacuation should be performed such that all storage
///   object data is removed from the host.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanHostDecommissionModeObjectActionEnum {
    NoAction,
    EnsureObjectAccessibility,
    EvacuateAllData,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Disk group types to create.
/// 
/// Possible values:
/// - `hybrid`: Consumes SSD as cache tier, and HDD as capacity tier.
/// - `allFlash`: Uses SSD for both cache tier and capacity tier.
///   
///   vSAN optimizes the on-disk format on all flash disk group, to support more features, such as deduplication and compression, etc.
/// - `vsandirect`
/// - `pmem`: 
///   
///   Deprecated as of vSphere 9.0 APIs with no replacement.
///   
///   Do not use.
/// - `DiskMappingCreationType_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VimVsanHostDiskMappingCreationTypeEnum {
    Hybrid,
    AllFlash,
    Vsandirect,
    Pmem,
    DiskMappingCreationTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Values used for indicating a disk's status for use by the VSAN service.
/// 
/// See also *VsanHostDiskResult.state*.
/// 
/// Possible values:
/// - `inUse`: Disk is currently in use by the VSAN service.
///   
///   A disk may be considered in use by the VSAN service regardless of
///   whether the VSAN service is enabled. As long as a disk is in use
///   by VSAN, it is reserved exclusively for VSAN and may not be used
///   for other purposes.
///   
///   See also *VsanHostDiskResult.error*.
/// - `eligible`: Disk is considered eligible for use by the VSAN service,
///   but is not currently in use.
/// - `ineligible`: Disk is considered ineligible for use by the VSAN service,
///   and is not currently in use.
///   
///   See also *VsanHostDiskResult.error*.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanHostDiskResultStateEnum {
    InUse,
    Eligible,
    Ineligible,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The rekey operation type of vSAN2 encryption.
/// 
/// Possible values:
/// - `enablement`: Enable encryption.
/// - `shallowRekey`: Only replace KEK and keep DEK not changed.
/// - `deepRekey`: Replace both KEK and DEK.
/// - `disablement`
/// - `EncryptionOperation_Unknown`: Represent the value when the lower version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanEncryptionOperationEnum {
    Enablement,
    ShallowRekey,
    DeepRekey,
    Disablement,
    EncryptionOperationUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The state of host during data-in-transit encryption configuration
/// change for a vSAN cluster.
/// 
/// The final configuration whether to
/// turn on or turn off encryption for the cluster is defined in
/// *VsanHostConfigInfoEx.dataInTransitEncryptionInfo*.
/// 
/// Possible values:
/// - `settled`: Stable state.
///   
///   Host enforces all sessions to be encrypted or non-encrypted according to the encryption configuration.
/// - `preparing`: Host accepts both encrypted and non-encrypted messages.
///   
///   For enable process, host transfers non-encrypted messages; for disable process, host transfers encrypted messages.
/// - `prepared`: Host accepts both encrypted and non-encrypted messages.
///   
///   For enable process, host transfers encrypted messages; for disable process, host transfers non-encrypted messages.
/// - `EncryptionTransitionState_Unknown`: Represent the value when the lower version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanEncryptionTransitionStateEnum {
    Settled,
    Preparing,
    Prepared,
    EncryptionTransitionStateUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// A *VsanHostHealthState_enum* represents the state of a participating
/// host in the VSAN service.
/// 
/// See also *VsanHostClusterStatus*.
/// 
/// Possible values:
/// - `unknown`: Node health is unknown.
/// - `healthy`: Node is considered healthy.
/// - `unhealthy`: Node is considered unhealthy.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanHostHealthStateEnum {
    Unknown,
    Healthy,
    Unhealthy,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// A *VsanHostNodeState_enum* represents the state of participation of a host
/// in the VSAN service.
/// 
/// See also *VsanHostClusterStatus*, *VsanHostClusterStatusState*.
/// 
/// Possible values:
/// - `error`: The node is enabled for the VSAN service but has some configuration
///   error which prevents participation.
/// - `disabled`: The node is disabled for the VSAN service.
/// - `agent`: The node is enabled for the VSAN service and is serving as an agent.
/// - `master`: The node is enabled for the VSAN service and is serving as the master.
/// - `backup`: The node is enabled for the VSAN service and is serving as the backup.
/// - `starting`: The node is starting the VSAN service; this state is considered
///   transitory.
/// - `stopping`: The node is stopping the VSAN service; this state is considered
///   transitory.
/// - `enteringMaintenanceMode`: The node is entering maintenance mode; this state is considered
///   transitory.
///   
///   See also *HostSystem.EnterMaintenanceMode_Task*.
/// - `exitingMaintenanceMode`: The node is exiting maintenance mode; this state is considered
///   transitory.
///   
///   See also *HostSystem.ExitMaintenanceMode_Task*.
/// - `decommissioning`: The node is being decommissioned from the VSAN service; this state is
///   considered transitory.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanHostNodeStateEnum {
    Error,
    Disabled,
    Agent,
    Master,
    Backup,
    Starting,
    Stopping,
    EnteringMaintenanceMode,
    ExitingMaintenanceMode,
    Decommissioning,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Network transmission type of vSAN traffic through
/// a virtual network adapter for 8.x and previous releases.
/// 
/// Possible values:
/// - `vsan`: This vmknic is used for general vSAN data transmission.
///   
///   If no vSAN vmknic configured with 'witness' traffic type, witness data transmission will be handled by vmknic with 'vsan' traffic type.
/// - `witness`: This vmknic is dedicated for vSAN witness data transmission.
///   
///   For vSAN stretched cluster, this traffic type is recommended for vSAN vmknics to be used for witness transmission.
/// - `TrafficType_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VimVsanHostTrafficTypeEnum {
    Vsan,
    Witness,
    TrafficTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Network transmission type of vSAN traffic through
/// a virtual network adapter for 9.0 release
/// 
/// Possible values:
/// - `vsanExternal`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VimVsanHostTrafficType90Enum {
    VsanExternal,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Remote server node type
/// 
/// Possible values:
/// - `NodeType_Unknown`: Represent the value when the lower version client cannot recognize the enum value.
/// - `REMOTE_NODE`: remote server is a normal data node
/// - `REMOTE_WITNESS_NODE`: remote server is a witness node
/// - `REMOTE_METADATA_NODE`: remote server is a metadata node
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ServerNodeTypeEnum {
    NodeTypeUnknown,
    RemoteNode,
    RemoteWitnessNode,
    RemoteMetadataNode,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Declaration of all supported vSAN runtime stats types.
/// 
/// It is used
/// to retrieve vSAN runtime stats through
/// *VsanSystemEx.VsanHostGetRuntimeStats*
/// 
/// Possible values:
/// - `resyncIopsInfo`
/// - `configGeneration`
/// - `supportedClusterSize`
/// - `repairTimerInfo`
/// - `componentLimitPerCluster`
/// - `maxWitnessClusters`
/// - `StatsType_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanHostStatsTypeEnum {
    ResyncIopsInfo,
    ConfigGeneration,
    SupportedClusterSize,
    RepairTimerInfo,
    ComponentLimitPerCluster,
    MaxWitnessClusters,
    StatsTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Represents type of disk in storage pool.
/// 
/// Possible values:
/// - `singleTier`: Represents devices belonging to single tier storage pool.
/// - `StoragePoolDiskType_Unknown`: Represents the value when lower version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum StoragePoolDiskTypeEnum {
    SingleTier,
    StoragePoolDiskTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This class represents a disk type in trimming.
/// 
/// Possible values:
/// - `cacheDisk`: means the disk is performed as a cache disk.
/// - `capacityDisk`: means the disk is performed as a capacity disk.
/// - `TrimDiskType_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum TrimDiskTypeEnum {
    CacheDisk,
    CapacityDisk,
    TrimDiskTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Disk evacuation reason
/// 
/// Possible values:
/// - `User`: Evacuated by user
/// - `Ure`: Unrecoverable error
/// - `SmartDiskFailures`: Smart disk failures
/// - `Latency`: I/O Latency
/// - `Congestion`: I/O congestion
/// - `TransientDeviceError`: Disk transient device error
/// - `VsanDiskEvacReason_Unknow`: represents the value when the lower version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanDiskEvacReasonEnum {
    User,
    Ure,
    SmartDiskFailures,
    Latency,
    Congestion,
    TransientDeviceError,
    VsanDiskEvacReasonUnknow,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This class represents a list of supported vSAN disk trim options.
/// 
/// Possible values:
/// - `metaDataOnly`: means only the metadata area on disk will be trimmed.
/// - `fullDisk`: means the full disk will be trimmed.
/// - `VsanDiskTrimOption_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanDiskTrimOptionEnum {
    MetaDataOnly,
    FullDisk,
    VsanDiskTrimOptionUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// vSAN disk types.
/// 
/// Possible values:
/// - `diskGroup`: Represents disk belonging to disk group model.
/// - `storagePool`: Represents disk belonging to storage pool model.
/// - `directDisk`: Represents disk belonging to vSAN direct disks.
/// - `VsanDiskType_Unknown`: Represents the value when lower version client cannot recognize the enum value.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanDiskTypeEnum {
    DiskGroup,
    StoragePool,
    DirectDisk,
    VsanDiskTypeUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// This class represents a list of supported vSAN diskgroup capability types.
/// 
/// Possible values:
/// - `supportLargerThan16TB`: Stands for diskgroups supporting large capacity drives, i.e., any capacity disk will be formatted to support larger than 16TB logical space.
/// - `VsanDiskgroupCapability_Unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanDiskgroupCapabilityEnum {
    SupportLargerThan16Tb,
    VsanDiskgroupCapabilityUnknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The list of disk issues.
/// 
/// Possible values:
/// - `nonExist`
/// - `stampMismatch`
/// - `unknown`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanDiskIssueTypeEnum {
    NonExist,
    StampMismatch,
    Unknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Wipe disk eligible.
/// 
/// Possible values:
/// - `WipeDiskEligible_Unknown`: Represent the value when the lower version client cannot recognize the enum value.
/// - `Yes`: This disk is eligible for wipe.
/// - `No`: This disk is ineligible for wipe.
/// - `Unknown`: Whether the disk is eligible for wipe is unknown.
///   
///   Because whether the disk support wipe or not is unknown.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanHostWipeDiskEligibleEnum {
    WipeDiskEligibleUnknown,
    Yes,
    No,
    Unknown,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Wipe disk state.
/// 
/// Possible values:
/// - `WipeDiskState_Unknown`: Represent the value when the lower version client cannot recognize the enum value.
/// - `Wiping`: This disk is being wiped.
/// - `Success`: This disk has been wiped successfully.
/// - `Failure`: This disk has failed to wipe.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VsanHostWipeDiskStateEnum {
    WipeDiskStateUnknown,
    Wiping,
    Success,
    Failure,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Provisioning type constants.
/// 
/// Possible values:
/// - `thin`: Space required for thin-provisioned virtual disk is allocated
///   and zeroed on demand as the space is used.
/// - `eagerZeroedThick`: An eager zeroed thick virtual disk has all space allocated and
///   wiped clean of any previous contents on the physical media at
///   creation time.
///   
///   Such virtual disk may take longer time
///   during creation compared to other provisioning formats.
/// - `lazyZeroedThick`: A thick virtual disk has all space allocated at creation time.
///   
///   This space may contain stale data on the physical media.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum BaseConfigInfoDiskFileBackingInfoProvisioningTypeEnum {
    Thin,
    EagerZeroedThick,
    LazyZeroedThick,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Flags representing the different information of a disk.
/// 
/// Possible values:
/// - `id`: ID of virtual storage object.
/// - `descriptorVersion`: The disk descriptor version of the virtual storage object.
///   
///   ***Since:*** vSphere API Release 8.0.1.0
/// - `backingObjectId`: ID of object backing the virtual storage object.
/// - `path`: File path of virtual storage object.
/// - `parentPath`: Parent file path of virtual storage object file.
/// - `name`: Name of virtual storage object.
/// - `deviceName`: Canonical name of the LUN used for virtual storage object.
/// - `capacity`: Logical size of virtual storage object.
/// - `allocated`: Size allocated by the file system for the virtual storage object
///   file/chain/link/extent only.
/// - `type`: Provisioning type of virtual storage object.
/// - `consumers`: IDs of the consumers of virtual storage object.
/// - `tentativeState`: If virtual storage object is in tentative state.
/// - `createTime`: Date and time of creation of virtual storage object.
/// - `ioFilter`: IOFilter associated with virtual storage object.
/// - `controlFlags`: Control flags of virtual storage object.
/// - `keepAfterVmDelete`: Deletion behaviour of virtual storage object after VM deletion.
/// - `relocationDisabled`: If relocation is disabled for virtual storage object.
/// - `keyId`: Key ID used to encrypt the virtual storage object.
/// - `keyProviderId`: Crypto key provider ID used to encrypt the virtual storage object.
/// - `nativeSnapshotSupported`: If virtual storage object supports native snapshot.
/// - `cbtEnabled`: If virtual storage object has changed block tracking enabled.
/// - `virtualDiskFormat`: The type of VirtualDisk for 4k native disk/array support.
///   
///   ***Since:*** vSphere API Release 9.0.0.0
/// 
/// ***Since:*** vSphere API Release 8.0.0.1
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VslmDiskInfoFlagEnum {
    Id,
    DescriptorVersion,
    BackingObjectId,
    Path,
    ParentPath,
    Name,
    DeviceName,
    Capacity,
    Allocated,
    Type,
    Consumers,
    TentativeState,
    CreateTime,
    IoFilter,
    ControlFlags,
    KeepAfterVmDelete,
    RelocationDisabled,
    KeyId,
    KeyProviderId,
    NativeSnapshotSupported,
    CbtEnabled,
    VirtualDiskFormat,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Consumption type constants.
/// 
/// Consumption type describes how the virtual storage object is connected and
/// consumed for data by the clients.
/// 
/// Possible values:
/// - `disk`: Disk type.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VStorageObjectConsumptionTypeEnum {
    Disk,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `keepAfterDeleteVm`: Choice of the deletion behavior of this virtual storage object.
///   
///   If not set, the default value is false.
/// - `disableRelocation`: Is virtual storage object relocation disabled.
///   
///   If not set, the default value is false.
/// - `enableChangedBlockTracking`: Is Virtual storage object has changed blocked tracking enabled.
///   
///   If not set, default value is false.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VslmVStorageObjectControlFlagEnum {
    KeepAfterDeleteVm,
    DisableRelocation,
    EnableChangedBlockTracking,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration of possible changes to a property.
/// 
/// Possible values:
/// - `add`
/// - `remove`
/// - `assign`
/// - `indirectRemove`
///
/// ### How to access
/// - `PropertyCollector::check_for_updates().filter_set?[*].object_set?[*].change_set?[*].op`
/// - `PropertyCollector::wait_for_updates().filter_set?[*].object_set?[*].change_set?[*].op`
/// - `PropertyCollector::wait_for_updates_ex().filter_set?[*].object_set?[*].change_set?[*].op`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum PropertyChangeOpEnum {
    Add,
    Remove,
    Assign,
    IndirectRemove,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Enumeration of different kinds of updates.
/// 
/// Possible values:
/// - `modify`: A property of the managed object changed its value.
/// - `enter`: A managed object became visible to a filter for the first time.
///   
///   For instance, this can happen if a virtual machine is added to a
///   folder.
/// - `leave`: A managed object left the set of objects visible to a filter.
///   
///   For
///   instance, this can happen when a virtual machine is destroyed.
///
/// ### How to access
/// - `PropertyCollector::check_for_updates().filter_set?[*].object_set?[*].kind`
/// - `PropertyCollector::wait_for_updates().filter_set?[*].object_set?[*].kind`
/// - `PropertyCollector::wait_for_updates_ex().filter_set?[*].object_set?[*].kind`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum ObjectUpdateKindEnum {
    Modify,
    Enter,
    Leave,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// List of possible states of a task.
/// 
/// Possible values:
/// - `queued`: When there are too many tasks for threads to handle.
/// - `running`: When the busy thread is freed from its current task by
///   finishing the task, it picks a queued task to run.
///   
///   Then the queued tasks are marked as running.
/// - `success`: When a running task has completed.
/// - `error`: When a running task has encountered an error.
///
/// ### How to access
/// - `VslmTask::vslm_query_info().state`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VslmTaskInfoStateEnum {
    Queued,
    Running,
    Success,
    Error,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// Possible values:
/// - `preFcdMigrateEvent`: Event type used to notify that FCD is going to be relocated.
/// - `postFcdMigrateEvent`: Event type used to notify FCD has been relocated.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VslmEventTypeEnum {
    PreFcdMigrateEvent,
    PostFcdMigrateEvent,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The possible states of the vlsm event processing.
/// 
/// Possible values:
/// - `success`: When the event has been successfully processed.
/// - `error`: When there is error while processing the event.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VslmEventVslmEventInfoStateEnum {
    Success,
    Error,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The *VslmVsoVStorageObjectQuerySpecQueryFieldEnum_enum* enumerated
/// type defines the searchable fields.
/// 
/// Possible values:
/// - `id`: Indicates *BaseConfigInfo.id* as the searchable field.
/// - `name`: Indicates *BaseConfigInfo.name* as the searchable
///   field.
/// - `capacity`: Indicates *VStorageObjectConfigInfo.capacityInMB* as the
///   searchable field.
/// - `createTime`: Indicates *BaseConfigInfo.createTime* as the searchable
///   field.
/// - `backingObjectId`: Indicates
///   *BaseConfigInfoFileBackingInfo.backingObjectId* as the
///   searchable field.
/// - `datastoreMoId`: Indicates *BaseConfigInfoBackingInfo.datastore* as the
///   searchable field.
/// - `metadataKey`: Indicates it as the searchable field.
/// - `metadataValue`: Indicates it as the searchable field.
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum {
    Id,
    Name,
    Capacity,
    CreateTime,
    BackingObjectId,
    DatastoreMoId,
    MetadataKey,
    MetadataValue,
    /// This variant handles values not known at compile time.
    Other_(String),
}

/// The *VslmVsoVStorageObjectQuerySpecQueryOperatorEnum_enum* enumerated
/// type defines the operators to use for constructing the query criteria.
/// 
/// Possible values:
/// - `equals`
/// - `notEquals`
/// - `lessThan`
/// - `greaterThan`
/// - `lessThanOrEqual`
/// - `greaterThanOrEqual`
/// - `contains`
/// - `startsWith`
/// - `endsWith`
#[derive(Clone, PartialEq, Eq, Hash)]
pub enum VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum {
    Equals,
    NotEquals,
    LessThan,
    GreaterThan,
    LessThanOrEqual,
    GreaterThanOrEqual,
    Contains,
    StartsWith,
    EndsWith,
    /// This variant handles values not known at compile time.
    Other_(String),
}


miniserde::make_place!(Place);

static MO_TYPES_ENUM_MAP: phf::Map<&'static str, MoTypesEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 86),
        (0, 1),
        (0, 12),
        (0, 40),
        (0, 0),
        (0, 94),
        (1, 50),
        (0, 25),
        (0, 159),
        (12, 6),
        (5, 71),
        (0, 24),
        (0, 10),
        (0, 8),
        (12, 1),
        (0, 118),
        (0, 3),
        (0, 49),
        (2, 23),
        (0, 0),
        (2, 20),
        (5, 120),
        (2, 4),
        (0, 0),
        (0, 0),
        (19, 79),
        (0, 28),
        (16, 121),
        (0, 105),
        (0, 17),
        (0, 159),
        (0, 4),
        (1, 0),
        (0, 65),
        (0, 53),
        (0, 3),
        (2, 47),
        (8, 132),
        (83, 136),
    ],
    entries: &[
        ("VslmSessionManager", MoTypesEnum::VslmSessionManager),
        ("ManagedEntity", MoTypesEnum::ManagedEntity),
        ("HostServiceSystem", MoTypesEnum::HostServiceSystem),
        ("VirtualMachineGuestCustomizationManager", MoTypesEnum::VirtualMachineGuestCustomizationManager),
        ("SmsStorageManager", MoTypesEnum::SmsStorageManager),
        ("LicenseManager", MoTypesEnum::LicenseManager),
        ("Datacenter", MoTypesEnum::Datacenter),
        ("VsanIoInsightManager", MoTypesEnum::VsanIoInsightManager),
        ("HostBootDeviceSystem", MoTypesEnum::HostBootDeviceSystem),
        ("ResourcePool", MoTypesEnum::ResourcePool),
        ("ExtensibleManagedObject", MoTypesEnum::ExtensibleManagedObject),
        ("PbmServiceInstance", MoTypesEnum::PbmServiceInstance),
        ("VsanFileServiceSystem", MoTypesEnum::VsanFileServiceSystem),
        ("SearchIndex", MoTypesEnum::SearchIndex),
        ("HostCpuSchedulerSystem", MoTypesEnum::HostCpuSchedulerSystem),
        ("HostHealthStatusSystem", MoTypesEnum::HostHealthStatusSystem),
        ("HostDatastoreSystem", MoTypesEnum::HostDatastoreSystem),
        ("ManagedObject", MoTypesEnum::ManagedObject),
        ("HostProfileManager", MoTypesEnum::HostProfileManager),
        ("HostDatastoreBrowser", MoTypesEnum::HostDatastoreBrowser),
        ("View", MoTypesEnum::View),
        ("CnsVolumeManager", MoTypesEnum::CnsVolumeManager),
        ("HostLocalAccountManager", MoTypesEnum::HostLocalAccountManager),
        ("HostVFlashManager", MoTypesEnum::HostVFlashManager),
        ("DatastoreNamespaceManager", MoTypesEnum::DatastoreNamespaceManager),
        ("VsanPolicyManager", MoTypesEnum::VsanPolicyManager),
        ("HostEsxAgentHostManager", MoTypesEnum::HostEsxAgentHostManager),
        ("FailoverClusterConfigurator", MoTypesEnum::FailoverClusterConfigurator),
        ("PbmPlacementSolver", MoTypesEnum::PbmPlacementSolver),
        ("ContainerView", MoTypesEnum::ContainerView),
        ("HostAutoStartManager", MoTypesEnum::HostAutoStartManager),
        ("HostVStorageObjectManager", MoTypesEnum::HostVStorageObjectManager),
        ("ComputeResource", MoTypesEnum::ComputeResource),
        ("PbmCapabilityMetadataManager", MoTypesEnum::PbmCapabilityMetadataManager),
        ("HttpNfcLease", MoTypesEnum::HttpNfcLease),
        ("VirtualDiskManager", MoTypesEnum::VirtualDiskManager),
        ("SessionManager", MoTypesEnum::SessionManager),
        ("CustomizationSpecManager", MoTypesEnum::CustomizationSpecManager),
        ("DiagnosticManager", MoTypesEnum::DiagnosticManager),
        ("ProfileManager", MoTypesEnum::ProfileManager),
        ("HostMemorySystem", MoTypesEnum::HostMemorySystem),
        ("StorageResourceManager", MoTypesEnum::StorageResourceManager),
        ("GuestAuthManager", MoTypesEnum::GuestAuthManager),
        ("HostSpbm", MoTypesEnum::HostSpbm),
        ("OvfManager", MoTypesEnum::OvfManager),
        ("HostPowerSystem", MoTypesEnum::HostPowerSystem),
        ("FailoverClusterManager", MoTypesEnum::FailoverClusterManager),
        ("VasaProvider", MoTypesEnum::VasaProvider),
        ("FileManager", MoTypesEnum::FileManager),
        ("OptionManager", MoTypesEnum::OptionManager),
        ("CertificateManager", MoTypesEnum::CertificateManager),
        ("HostDirectoryStore", MoTypesEnum::HostDirectoryStore),
        ("ClusterComputeResource", MoTypesEnum::ClusterComputeResource),
        ("HostProfile", MoTypesEnum::HostProfile),
        ("PerformanceManager", MoTypesEnum::PerformanceManager),
        ("UserDirectory", MoTypesEnum::UserDirectory),
        ("VimClusterVsanVcDiskManagementSystem", MoTypesEnum::VimClusterVsanVcDiskManagementSystem),
        ("HostCertificateManager", MoTypesEnum::HostCertificateManager),
        ("VsanUpgradeSystem", MoTypesEnum::VsanUpgradeSystem),
        ("OpaqueNetwork", MoTypesEnum::OpaqueNetwork),
        ("HostDiagnosticSystem", MoTypesEnum::HostDiagnosticSystem),
        ("VslmStorageLifecycleManager", MoTypesEnum::VslmStorageLifecycleManager),
        ("CryptoManagerKmip", MoTypesEnum::CryptoManagerKmip),
        ("HostSystem", MoTypesEnum::HostSystem),
        ("DirectPathProfileManager", MoTypesEnum::DirectPathProfileManager),
        ("HostAccessManager", MoTypesEnum::HostAccessManager),
        ("VsanVcClusterHealthSystem", MoTypesEnum::VsanVcClusterHealthSystem),
        ("EventHistoryCollector", MoTypesEnum::EventHistoryCollector),
        ("StorageQueryManager", MoTypesEnum::StorageQueryManager),
        ("VsanVumSystem", MoTypesEnum::VsanVumSystem),
        ("VsanUpgradeSystemEx", MoTypesEnum::VsanUpgradeSystemEx),
        ("VirtualizationManager", MoTypesEnum::VirtualizationManager),
        ("TaskHistoryCollector", MoTypesEnum::TaskHistoryCollector),
        ("AuthorizationManager", MoTypesEnum::AuthorizationManager),
        ("IoFilterManager", MoTypesEnum::IoFilterManager),
        ("ManagedObjectView", MoTypesEnum::ManagedObjectView),
        ("LicenseAssignmentManager", MoTypesEnum::LicenseAssignmentManager),
        ("MessageBusProxy", MoTypesEnum::MessageBusProxy),
        ("HostDateTimeSystem", MoTypesEnum::HostDateTimeSystem),
        ("GuestWindowsRegistryManager", MoTypesEnum::GuestWindowsRegistryManager),
        ("AlarmManager", MoTypesEnum::AlarmManager),
        ("HostVirtualNicManager", MoTypesEnum::HostVirtualNicManager),
        ("Task", MoTypesEnum::Task),
        ("VsanUpdateManager", MoTypesEnum::VsanUpdateManager),
        ("PbmSessionManager", MoTypesEnum::PbmSessionManager),
        ("ScheduledTask", MoTypesEnum::ScheduledTask),
        ("Network", MoTypesEnum::Network),
        ("InventoryView", MoTypesEnum::InventoryView),
        ("Datastore", MoTypesEnum::Datastore),
        ("VsanClusterPowerSystem", MoTypesEnum::VsanClusterPowerSystem),
        ("HostAssignableHardwareManager", MoTypesEnum::HostAssignableHardwareManager),
        ("OverheadMemoryManager", MoTypesEnum::OverheadMemoryManager),
        ("ListView", MoTypesEnum::ListView),
        ("VslmTask", MoTypesEnum::VslmTask),
        ("GuestOperationsManager", MoTypesEnum::GuestOperationsManager),
        ("VimClusterVsanVcStretchedClusterSystem", MoTypesEnum::VimClusterVsanVcStretchedClusterSystem),
        ("CryptoManagerHost", MoTypesEnum::CryptoManagerHost),
        ("VirtualMachineSnapshot", MoTypesEnum::VirtualMachineSnapshot),
        ("VsanClusterMgmtInternalSystem", MoTypesEnum::VsanClusterMgmtInternalSystem),
        ("PropertyFilter", MoTypesEnum::PropertyFilter),
        ("Agency", MoTypesEnum::Agency),
        ("HostSnmpSystem", MoTypesEnum::HostSnmpSystem),
        ("SmsTask", MoTypesEnum::SmsTask),
        ("VsanVdsSystem", MoTypesEnum::VsanVdsSystem),
        ("CryptoManagerHostKMS", MoTypesEnum::CryptoManagerHostKms),
        ("SmsProvider", MoTypesEnum::SmsProvider),
        ("EamTask", MoTypesEnum::EamTask),
        ("ServiceManager", MoTypesEnum::ServiceManager),
        ("DistributedVirtualSwitch", MoTypesEnum::DistributedVirtualSwitch),
        ("VsanMassCollector", MoTypesEnum::VsanMassCollector),
        ("VsanResourceCheckSystem", MoTypesEnum::VsanResourceCheckSystem),
        ("EnvironmentBrowser", MoTypesEnum::EnvironmentBrowser),
        ("HostImageConfigManager", MoTypesEnum::HostImageConfigManager),
        ("HostLocalAuthentication", MoTypesEnum::HostLocalAuthentication),
        ("ClusterEVCManager", MoTypesEnum::ClusterEvcManager),
        ("VsanObjectManager", MoTypesEnum::VsanObjectManager),
        ("ClusterProfileManager", MoTypesEnum::ClusterProfileManager),
        ("PbmReplicationManager", MoTypesEnum::PbmReplicationManager),
        ("SimpleCommand", MoTypesEnum::SimpleCommand),
        ("CryptoManager", MoTypesEnum::CryptoManager),
        ("VslmVStorageObjectManager", MoTypesEnum::VslmVStorageObjectManager),
        ("VirtualMachineCompatibilityChecker", MoTypesEnum::VirtualMachineCompatibilityChecker),
        ("EventManager", MoTypesEnum::EventManager),
        ("Profile", MoTypesEnum::Profile),
        ("VsanSystemEx", MoTypesEnum::VsanSystemEx),
        ("HostStorageSystem", MoTypesEnum::HostStorageSystem),
        ("PbmProvider", MoTypesEnum::PbmProvider),
        ("EamObject", MoTypesEnum::EamObject),
        ("ClusterProfile", MoTypesEnum::ClusterProfile),
        ("DistributedVirtualPortgroup", MoTypesEnum::DistributedVirtualPortgroup),
        ("Agent", MoTypesEnum::Agent),
        ("HostAuthenticationManager", MoTypesEnum::HostAuthenticationManager),
        ("HostPatchManager", MoTypesEnum::HostPatchManager),
        ("StoragePod", MoTypesEnum::StoragePod),
        ("HostAuthenticationStore", MoTypesEnum::HostAuthenticationStore),
        ("ServiceInstance", MoTypesEnum::ServiceInstance),
        ("HostNetworkSystem", MoTypesEnum::HostNetworkSystem),
        ("ResourcePlanningManager", MoTypesEnum::ResourcePlanningManager),
        ("HistoryCollector", MoTypesEnum::HistoryCollector),
        ("VslmServiceInstance", MoTypesEnum::VslmServiceInstance),
        ("HostVMotionSystem", MoTypesEnum::HostVMotionSystem),
        ("SmsServiceInstance", MoTypesEnum::SmsServiceInstance),
        ("HostKernelModuleSystem", MoTypesEnum::HostKernelModuleSystem),
        ("HostGraphicsManager", MoTypesEnum::HostGraphicsManager),
        ("GuestFileManager", MoTypesEnum::GuestFileManager),
        ("VStorageObjectManagerBase", MoTypesEnum::VStorageObjectManagerBase),
        ("HostSpecificationManager", MoTypesEnum::HostSpecificationManager),
        ("HealthUpdateManager", MoTypesEnum::HealthUpdateManager),
        ("IpPoolManager", MoTypesEnum::IpPoolManager),
        ("VsanVcClusterConfigSystem", MoTypesEnum::VsanVcClusterConfigSystem),
        ("VmwareDistributedVirtualSwitch", MoTypesEnum::VmwareDistributedVirtualSwitch),
        ("EsxAgentManager", MoTypesEnum::EsxAgentManager),
        ("DistributedVirtualSwitchManager", MoTypesEnum::DistributedVirtualSwitchManager),
        ("TenantTenantManager", MoTypesEnum::TenantTenantManager),
        ("VsanObjectSystem", MoTypesEnum::VsanObjectSystem),
        ("VsanHostVdsSystem", MoTypesEnum::VsanHostVdsSystem),
        ("HostFirmwareSystem", MoTypesEnum::HostFirmwareSystem),
        ("HostCacheConfigurationManager", MoTypesEnum::HostCacheConfigurationManager),
        ("VsanPerformanceManager", MoTypesEnum::VsanPerformanceManager),
        ("VsanSpaceReportSystem", MoTypesEnum::VsanSpaceReportSystem),
        ("PbmProfileProfileManager", MoTypesEnum::PbmProfileProfileManager),
        ("VsanRemoteDatastoreSystem", MoTypesEnum::VsanRemoteDatastoreSystem),
        ("HostFirewallSystem", MoTypesEnum::HostFirewallSystem),
        ("PropertyCollector", MoTypesEnum::PropertyCollector),
        ("LocalizationManager", MoTypesEnum::LocalizationManager),
        ("TaskManager", MoTypesEnum::TaskManager),
        ("VirtualMachineProvisioningChecker", MoTypesEnum::VirtualMachineProvisioningChecker),
        ("HostNvdimmSystem", MoTypesEnum::HostNvdimmSystem),
        ("HostVsanInternalSystem", MoTypesEnum::HostVsanInternalSystem),
        ("ViewManager", MoTypesEnum::ViewManager),
        ("HostVsanSystem", MoTypesEnum::HostVsanSystem),
        ("VsanIscsiTargetSystem", MoTypesEnum::VsanIscsiTargetSystem),
        ("VsanPhoneHomeSystem", MoTypesEnum::VsanPhoneHomeSystem),
        ("CustomFieldsManager", MoTypesEnum::CustomFieldsManager),
        ("GuestProcessManager", MoTypesEnum::GuestProcessManager),
        ("SiteInfoManager", MoTypesEnum::SiteInfoManager),
        ("SmsSessionManager", MoTypesEnum::SmsSessionManager),
        ("ExtensionManager", MoTypesEnum::ExtensionManager),
        ("VirtualMachine", MoTypesEnum::VirtualMachine),
        ("VsanVcsaDeployerSystem", MoTypesEnum::VsanVcsaDeployerSystem),
        ("Alarm", MoTypesEnum::Alarm),
        ("HostVsanHealthSystem", MoTypesEnum::HostVsanHealthSystem),
        ("GuestAliasManager", MoTypesEnum::GuestAliasManager),
        ("HostActiveDirectoryAuthentication", MoTypesEnum::HostActiveDirectoryAuthentication),
        ("Folder", MoTypesEnum::Folder),
        ("VcenterVStorageObjectManager", MoTypesEnum::VcenterVStorageObjectManager),
        ("VsanDiagnosticsSystem", MoTypesEnum::VsanDiagnosticsSystem),
        ("IscsiManager", MoTypesEnum::IscsiManager),
        ("ProfileComplianceManager", MoTypesEnum::ProfileComplianceManager),
        ("ScheduledTaskManager", MoTypesEnum::ScheduledTaskManager),
        ("VsanClusterHealthSystem", MoTypesEnum::VsanClusterHealthSystem),
        ("HostPciPassthruSystem", MoTypesEnum::HostPciPassthruSystem),
        ("PbmComplianceManager", MoTypesEnum::PbmComplianceManager),
        ("VsanCapabilitySystem", MoTypesEnum::VsanCapabilitySystem),
        ("VirtualApp", MoTypesEnum::VirtualApp),
    ],
};

impl MoTypesEnum {
    pub fn as_str(&self) -> &str {
        match self {
            MoTypesEnum::Alarm => "Alarm",
            MoTypesEnum::AlarmManager => "AlarmManager",
            MoTypesEnum::AuthorizationManager => "AuthorizationManager",
            MoTypesEnum::CertificateManager => "CertificateManager",
            MoTypesEnum::ClusterComputeResource => "ClusterComputeResource",
            MoTypesEnum::ClusterEvcManager => "ClusterEVCManager",
            MoTypesEnum::ClusterProfile => "ClusterProfile",
            MoTypesEnum::ClusterProfileManager => "ClusterProfileManager",
            MoTypesEnum::ComputeResource => "ComputeResource",
            MoTypesEnum::ContainerView => "ContainerView",
            MoTypesEnum::CryptoManager => "CryptoManager",
            MoTypesEnum::CryptoManagerHost => "CryptoManagerHost",
            MoTypesEnum::CryptoManagerHostKms => "CryptoManagerHostKMS",
            MoTypesEnum::CryptoManagerKmip => "CryptoManagerKmip",
            MoTypesEnum::CustomFieldsManager => "CustomFieldsManager",
            MoTypesEnum::CustomizationSpecManager => "CustomizationSpecManager",
            MoTypesEnum::Datacenter => "Datacenter",
            MoTypesEnum::Datastore => "Datastore",
            MoTypesEnum::DatastoreNamespaceManager => "DatastoreNamespaceManager",
            MoTypesEnum::DiagnosticManager => "DiagnosticManager",
            MoTypesEnum::DirectPathProfileManager => "DirectPathProfileManager",
            MoTypesEnum::DistributedVirtualPortgroup => "DistributedVirtualPortgroup",
            MoTypesEnum::DistributedVirtualSwitch => "DistributedVirtualSwitch",
            MoTypesEnum::DistributedVirtualSwitchManager => "DistributedVirtualSwitchManager",
            MoTypesEnum::EnvironmentBrowser => "EnvironmentBrowser",
            MoTypesEnum::EventHistoryCollector => "EventHistoryCollector",
            MoTypesEnum::EventManager => "EventManager",
            MoTypesEnum::ExtensibleManagedObject => "ExtensibleManagedObject",
            MoTypesEnum::ExtensionManager => "ExtensionManager",
            MoTypesEnum::FailoverClusterConfigurator => "FailoverClusterConfigurator",
            MoTypesEnum::FailoverClusterManager => "FailoverClusterManager",
            MoTypesEnum::FileManager => "FileManager",
            MoTypesEnum::Folder => "Folder",
            MoTypesEnum::GuestAliasManager => "GuestAliasManager",
            MoTypesEnum::GuestAuthManager => "GuestAuthManager",
            MoTypesEnum::GuestFileManager => "GuestFileManager",
            MoTypesEnum::GuestOperationsManager => "GuestOperationsManager",
            MoTypesEnum::GuestProcessManager => "GuestProcessManager",
            MoTypesEnum::GuestWindowsRegistryManager => "GuestWindowsRegistryManager",
            MoTypesEnum::HealthUpdateManager => "HealthUpdateManager",
            MoTypesEnum::HistoryCollector => "HistoryCollector",
            MoTypesEnum::HostAccessManager => "HostAccessManager",
            MoTypesEnum::HostActiveDirectoryAuthentication => "HostActiveDirectoryAuthentication",
            MoTypesEnum::HostAssignableHardwareManager => "HostAssignableHardwareManager",
            MoTypesEnum::HostAuthenticationManager => "HostAuthenticationManager",
            MoTypesEnum::HostAuthenticationStore => "HostAuthenticationStore",
            MoTypesEnum::HostAutoStartManager => "HostAutoStartManager",
            MoTypesEnum::HostBootDeviceSystem => "HostBootDeviceSystem",
            MoTypesEnum::HostCacheConfigurationManager => "HostCacheConfigurationManager",
            MoTypesEnum::HostCertificateManager => "HostCertificateManager",
            MoTypesEnum::HostCpuSchedulerSystem => "HostCpuSchedulerSystem",
            MoTypesEnum::HostDatastoreBrowser => "HostDatastoreBrowser",
            MoTypesEnum::HostDatastoreSystem => "HostDatastoreSystem",
            MoTypesEnum::HostDateTimeSystem => "HostDateTimeSystem",
            MoTypesEnum::HostDiagnosticSystem => "HostDiagnosticSystem",
            MoTypesEnum::HostDirectoryStore => "HostDirectoryStore",
            MoTypesEnum::HostEsxAgentHostManager => "HostEsxAgentHostManager",
            MoTypesEnum::HostFirewallSystem => "HostFirewallSystem",
            MoTypesEnum::HostFirmwareSystem => "HostFirmwareSystem",
            MoTypesEnum::HostGraphicsManager => "HostGraphicsManager",
            MoTypesEnum::HostHealthStatusSystem => "HostHealthStatusSystem",
            MoTypesEnum::HostImageConfigManager => "HostImageConfigManager",
            MoTypesEnum::HostKernelModuleSystem => "HostKernelModuleSystem",
            MoTypesEnum::HostLocalAccountManager => "HostLocalAccountManager",
            MoTypesEnum::HostLocalAuthentication => "HostLocalAuthentication",
            MoTypesEnum::HostMemorySystem => "HostMemorySystem",
            MoTypesEnum::HostNetworkSystem => "HostNetworkSystem",
            MoTypesEnum::HostNvdimmSystem => "HostNvdimmSystem",
            MoTypesEnum::HostPatchManager => "HostPatchManager",
            MoTypesEnum::HostPciPassthruSystem => "HostPciPassthruSystem",
            MoTypesEnum::HostPowerSystem => "HostPowerSystem",
            MoTypesEnum::HostProfile => "HostProfile",
            MoTypesEnum::HostProfileManager => "HostProfileManager",
            MoTypesEnum::HostServiceSystem => "HostServiceSystem",
            MoTypesEnum::HostSnmpSystem => "HostSnmpSystem",
            MoTypesEnum::HostSpecificationManager => "HostSpecificationManager",
            MoTypesEnum::HostStorageSystem => "HostStorageSystem",
            MoTypesEnum::HostSystem => "HostSystem",
            MoTypesEnum::HostVFlashManager => "HostVFlashManager",
            MoTypesEnum::HostVMotionSystem => "HostVMotionSystem",
            MoTypesEnum::HostVStorageObjectManager => "HostVStorageObjectManager",
            MoTypesEnum::HostVirtualNicManager => "HostVirtualNicManager",
            MoTypesEnum::HostVsanHealthSystem => "HostVsanHealthSystem",
            MoTypesEnum::HostVsanInternalSystem => "HostVsanInternalSystem",
            MoTypesEnum::HostVsanSystem => "HostVsanSystem",
            MoTypesEnum::HttpNfcLease => "HttpNfcLease",
            MoTypesEnum::InventoryView => "InventoryView",
            MoTypesEnum::IoFilterManager => "IoFilterManager",
            MoTypesEnum::IpPoolManager => "IpPoolManager",
            MoTypesEnum::IscsiManager => "IscsiManager",
            MoTypesEnum::LicenseAssignmentManager => "LicenseAssignmentManager",
            MoTypesEnum::LicenseManager => "LicenseManager",
            MoTypesEnum::ListView => "ListView",
            MoTypesEnum::LocalizationManager => "LocalizationManager",
            MoTypesEnum::ManagedEntity => "ManagedEntity",
            MoTypesEnum::ManagedObjectView => "ManagedObjectView",
            MoTypesEnum::MessageBusProxy => "MessageBusProxy",
            MoTypesEnum::Network => "Network",
            MoTypesEnum::OpaqueNetwork => "OpaqueNetwork",
            MoTypesEnum::OptionManager => "OptionManager",
            MoTypesEnum::OverheadMemoryManager => "OverheadMemoryManager",
            MoTypesEnum::OvfManager => "OvfManager",
            MoTypesEnum::PerformanceManager => "PerformanceManager",
            MoTypesEnum::Profile => "Profile",
            MoTypesEnum::ProfileComplianceManager => "ProfileComplianceManager",
            MoTypesEnum::ProfileManager => "ProfileManager",
            MoTypesEnum::PropertyCollector => "PropertyCollector",
            MoTypesEnum::PropertyFilter => "PropertyFilter",
            MoTypesEnum::ResourcePlanningManager => "ResourcePlanningManager",
            MoTypesEnum::ResourcePool => "ResourcePool",
            MoTypesEnum::ScheduledTask => "ScheduledTask",
            MoTypesEnum::ScheduledTaskManager => "ScheduledTaskManager",
            MoTypesEnum::SearchIndex => "SearchIndex",
            MoTypesEnum::ServiceInstance => "ServiceInstance",
            MoTypesEnum::ServiceManager => "ServiceManager",
            MoTypesEnum::SessionManager => "SessionManager",
            MoTypesEnum::SimpleCommand => "SimpleCommand",
            MoTypesEnum::SiteInfoManager => "SiteInfoManager",
            MoTypesEnum::StoragePod => "StoragePod",
            MoTypesEnum::StorageQueryManager => "StorageQueryManager",
            MoTypesEnum::StorageResourceManager => "StorageResourceManager",
            MoTypesEnum::Task => "Task",
            MoTypesEnum::TaskHistoryCollector => "TaskHistoryCollector",
            MoTypesEnum::TaskManager => "TaskManager",
            MoTypesEnum::TenantTenantManager => "TenantTenantManager",
            MoTypesEnum::UserDirectory => "UserDirectory",
            MoTypesEnum::VStorageObjectManagerBase => "VStorageObjectManagerBase",
            MoTypesEnum::VcenterVStorageObjectManager => "VcenterVStorageObjectManager",
            MoTypesEnum::View => "View",
            MoTypesEnum::ViewManager => "ViewManager",
            MoTypesEnum::VimClusterVsanVcDiskManagementSystem => "VimClusterVsanVcDiskManagementSystem",
            MoTypesEnum::VimClusterVsanVcStretchedClusterSystem => "VimClusterVsanVcStretchedClusterSystem",
            MoTypesEnum::VirtualApp => "VirtualApp",
            MoTypesEnum::VirtualDiskManager => "VirtualDiskManager",
            MoTypesEnum::VirtualMachine => "VirtualMachine",
            MoTypesEnum::VirtualMachineCompatibilityChecker => "VirtualMachineCompatibilityChecker",
            MoTypesEnum::VirtualMachineGuestCustomizationManager => "VirtualMachineGuestCustomizationManager",
            MoTypesEnum::VirtualMachineProvisioningChecker => "VirtualMachineProvisioningChecker",
            MoTypesEnum::VirtualMachineSnapshot => "VirtualMachineSnapshot",
            MoTypesEnum::VirtualizationManager => "VirtualizationManager",
            MoTypesEnum::VmwareDistributedVirtualSwitch => "VmwareDistributedVirtualSwitch",
            MoTypesEnum::VsanCapabilitySystem => "VsanCapabilitySystem",
            MoTypesEnum::VsanClusterHealthSystem => "VsanClusterHealthSystem",
            MoTypesEnum::VsanClusterMgmtInternalSystem => "VsanClusterMgmtInternalSystem",
            MoTypesEnum::VsanIscsiTargetSystem => "VsanIscsiTargetSystem",
            MoTypesEnum::VsanObjectSystem => "VsanObjectSystem",
            MoTypesEnum::VsanPerformanceManager => "VsanPerformanceManager",
            MoTypesEnum::VsanSpaceReportSystem => "VsanSpaceReportSystem",
            MoTypesEnum::VsanSystemEx => "VsanSystemEx",
            MoTypesEnum::VsanUpgradeSystem => "VsanUpgradeSystem",
            MoTypesEnum::VsanUpgradeSystemEx => "VsanUpgradeSystemEx",
            MoTypesEnum::VsanVcClusterConfigSystem => "VsanVcClusterConfigSystem",
            MoTypesEnum::VsanVcClusterHealthSystem => "VsanVcClusterHealthSystem",
            MoTypesEnum::VsanVcsaDeployerSystem => "VsanVcsaDeployerSystem",
            MoTypesEnum::Agency => "Agency",
            MoTypesEnum::Agent => "Agent",
            MoTypesEnum::EamObject => "EamObject",
            MoTypesEnum::EamTask => "EamTask",
            MoTypesEnum::EsxAgentManager => "EsxAgentManager",
            MoTypesEnum::PbmCapabilityMetadataManager => "PbmCapabilityMetadataManager",
            MoTypesEnum::PbmComplianceManager => "PbmComplianceManager",
            MoTypesEnum::PbmPlacementSolver => "PbmPlacementSolver",
            MoTypesEnum::PbmProfileProfileManager => "PbmProfileProfileManager",
            MoTypesEnum::PbmProvider => "PbmProvider",
            MoTypesEnum::PbmReplicationManager => "PbmReplicationManager",
            MoTypesEnum::PbmServiceInstance => "PbmServiceInstance",
            MoTypesEnum::PbmSessionManager => "PbmSessionManager",
            MoTypesEnum::SmsProvider => "SmsProvider",
            MoTypesEnum::SmsServiceInstance => "SmsServiceInstance",
            MoTypesEnum::SmsSessionManager => "SmsSessionManager",
            MoTypesEnum::SmsStorageManager => "SmsStorageManager",
            MoTypesEnum::SmsTask => "SmsTask",
            MoTypesEnum::VasaProvider => "VasaProvider",
            MoTypesEnum::ManagedObject => "ManagedObject",
            MoTypesEnum::CnsVolumeManager => "CnsVolumeManager",
            MoTypesEnum::HostSpbm => "HostSpbm",
            MoTypesEnum::VsanClusterPowerSystem => "VsanClusterPowerSystem",
            MoTypesEnum::VsanDiagnosticsSystem => "VsanDiagnosticsSystem",
            MoTypesEnum::VsanFileServiceSystem => "VsanFileServiceSystem",
            MoTypesEnum::VsanHostVdsSystem => "VsanHostVdsSystem",
            MoTypesEnum::VsanIoInsightManager => "VsanIoInsightManager",
            MoTypesEnum::VsanMassCollector => "VsanMassCollector",
            MoTypesEnum::VsanObjectManager => "VsanObjectManager",
            MoTypesEnum::VsanPhoneHomeSystem => "VsanPhoneHomeSystem",
            MoTypesEnum::VsanPolicyManager => "VsanPolicyManager",
            MoTypesEnum::VsanRemoteDatastoreSystem => "VsanRemoteDatastoreSystem",
            MoTypesEnum::VsanResourceCheckSystem => "VsanResourceCheckSystem",
            MoTypesEnum::VsanUpdateManager => "VsanUpdateManager",
            MoTypesEnum::VsanVdsSystem => "VsanVdsSystem",
            MoTypesEnum::VsanVumSystem => "VsanVumSystem",
            MoTypesEnum::VslmServiceInstance => "VslmServiceInstance",
            MoTypesEnum::VslmSessionManager => "VslmSessionManager",
            MoTypesEnum::VslmStorageLifecycleManager => "VslmStorageLifecycleManager",
            MoTypesEnum::VslmTask => "VslmTask",
            MoTypesEnum::VslmVStorageObjectManager => "VslmVStorageObjectManager",
            MoTypesEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        MO_TYPES_ENUM_MAP.get(s).cloned().unwrap_or_else(|| MoTypesEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for MoTypesEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for MoTypesEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<MoTypesEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(MoTypesEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for MoTypesEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for MoTypesEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a MoTypesEnum> for &'a str {
    fn from(value: &'a MoTypesEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for MoTypesEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DP_INVALID_PROTECTION_REASON_ENUM_MAP: phf::Map<&'static str, DpInvalidProtectionReasonEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("invalidProtectionReasonUnknown", DpInvalidProtectionReasonEnum::InvalidProtectionReasonUnknown),
        ("notProtected", DpInvalidProtectionReasonEnum::NotProtected),
        ("protectionDegraded", DpInvalidProtectionReasonEnum::ProtectionDegraded),
    ],
};

impl DpInvalidProtectionReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DpInvalidProtectionReasonEnum::ProtectionDegraded => "protectionDegraded",
            DpInvalidProtectionReasonEnum::NotProtected => "notProtected",
            DpInvalidProtectionReasonEnum::InvalidProtectionReasonUnknown => "invalidProtectionReasonUnknown",
            DpInvalidProtectionReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DP_INVALID_PROTECTION_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DpInvalidProtectionReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DpInvalidProtectionReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DpInvalidProtectionReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DpInvalidProtectionReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DpInvalidProtectionReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DpInvalidProtectionReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DpInvalidProtectionReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DpInvalidProtectionReasonEnum> for &'a str {
    fn from(value: &'a DpInvalidProtectionReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DpInvalidProtectionReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DP_MIGRATION_TYPE_ENUM_MAP: phf::Map<&'static str, DpMigrationTypeEnum> = ::phf::Map {
    key: 12213676231523076107,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("coldMigration", DpMigrationTypeEnum::ColdMigration),
        ("hotMigration", DpMigrationTypeEnum::HotMigration),
        ("migrationTypeUnknown", DpMigrationTypeEnum::MigrationTypeUnknown),
    ],
};

impl DpMigrationTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DpMigrationTypeEnum::ColdMigration => "coldMigration",
            DpMigrationTypeEnum::HotMigration => "hotMigration",
            DpMigrationTypeEnum::MigrationTypeUnknown => "migrationTypeUnknown",
            DpMigrationTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DP_MIGRATION_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DpMigrationTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DpMigrationTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DpMigrationTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DpMigrationTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DpMigrationTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DpMigrationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DpMigrationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DpMigrationTypeEnum> for &'a str {
    fn from(value: &'a DpMigrationTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DpMigrationTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DP_PROTECTION_STATUS_TYPE_ENUM_MAP: phf::Map<&'static str, DpProtectionStatusTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (3, 0),
    ],
    entries: &[
        ("pe_unprotected", DpProtectionStatusTypeEnum::PeUnprotected),
        ("ProtectionStatusType_unknown", DpProtectionStatusTypeEnum::ProtectionStatusTypeUnknown),
        ("pe_partially_protected", DpProtectionStatusTypeEnum::PePartiallyProtected),
        ("pe_protected", DpProtectionStatusTypeEnum::PeProtected),
    ],
};

impl DpProtectionStatusTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DpProtectionStatusTypeEnum::PeProtected => "pe_protected",
            DpProtectionStatusTypeEnum::PeUnprotected => "pe_unprotected",
            DpProtectionStatusTypeEnum::PePartiallyProtected => "pe_partially_protected",
            DpProtectionStatusTypeEnum::ProtectionStatusTypeUnknown => "ProtectionStatusType_unknown",
            DpProtectionStatusTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DP_PROTECTION_STATUS_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DpProtectionStatusTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DpProtectionStatusTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DpProtectionStatusTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DpProtectionStatusTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DpProtectionStatusTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DpProtectionStatusTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DpProtectionStatusTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DpProtectionStatusTypeEnum> for &'a str {
    fn from(value: &'a DpProtectionStatusTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DpProtectionStatusTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DP_PROTECTION_SUPPORT_TYPE_ENUM_MAP: phf::Map<&'static str, DpProtectionSupportTypeEnum> = ::phf::Map {
    key: 8694567506910003252,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("supported", DpProtectionSupportTypeEnum::Supported),
        ("partially_supported", DpProtectionSupportTypeEnum::PartiallySupported),
        ("not_supported", DpProtectionSupportTypeEnum::NotSupported),
        ("ProtectionSupportType_unknown", DpProtectionSupportTypeEnum::ProtectionSupportTypeUnknown),
    ],
};

impl DpProtectionSupportTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DpProtectionSupportTypeEnum::Supported => "supported",
            DpProtectionSupportTypeEnum::PartiallySupported => "partially_supported",
            DpProtectionSupportTypeEnum::NotSupported => "not_supported",
            DpProtectionSupportTypeEnum::ProtectionSupportTypeUnknown => "ProtectionSupportType_unknown",
            DpProtectionSupportTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DP_PROTECTION_SUPPORT_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DpProtectionSupportTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DpProtectionSupportTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DpProtectionSupportTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DpProtectionSupportTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DpProtectionSupportTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DpProtectionSupportTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DpProtectionSupportTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DpProtectionSupportTypeEnum> for &'a str {
    fn from(value: &'a DpProtectionSupportTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DpProtectionSupportTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DP_SNAPSHOT_TYPE_ENUM_MAP: phf::Map<&'static str, DpSnapshotTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 1),
        (2, 0),
    ],
    entries: &[
        ("crashConsistent", DpSnapshotTypeEnum::CrashConsistent),
        ("vssAppConsistent", DpSnapshotTypeEnum::VssAppConsistent),
        ("vssAppConsistentCopy", DpSnapshotTypeEnum::VssAppConsistentCopy),
        ("snapshotTypeUnknown", DpSnapshotTypeEnum::SnapshotTypeUnknown),
        ("metadataOnly", DpSnapshotTypeEnum::MetadataOnly),
        ("vssAppConsistentFull", DpSnapshotTypeEnum::VssAppConsistentFull),
        ("applicationConsistent", DpSnapshotTypeEnum::ApplicationConsistent),
    ],
};

impl DpSnapshotTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DpSnapshotTypeEnum::CrashConsistent => "crashConsistent",
            DpSnapshotTypeEnum::ApplicationConsistent => "applicationConsistent",
            DpSnapshotTypeEnum::VssAppConsistentFull => "vssAppConsistentFull",
            DpSnapshotTypeEnum::VssAppConsistentCopy => "vssAppConsistentCopy",
            DpSnapshotTypeEnum::MetadataOnly => "metadataOnly",
            DpSnapshotTypeEnum::VssAppConsistent => "vssAppConsistent",
            DpSnapshotTypeEnum::SnapshotTypeUnknown => "snapshotTypeUnknown",
            DpSnapshotTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DP_SNAPSHOT_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DpSnapshotTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DpSnapshotTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DpSnapshotTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DpSnapshotTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DpSnapshotTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DpSnapshotTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DpSnapshotTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DpSnapshotTypeEnum> for &'a str {
    fn from(value: &'a DpSnapshotTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DpSnapshotTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DP_SYNC_TYPE_ENUM_MAP: phf::Map<&'static str, DpSyncTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("deltaSync", DpSyncTypeEnum::DeltaSync),
        ("fullSync", DpSyncTypeEnum::FullSync),
        ("syncTypeUnknown", DpSyncTypeEnum::SyncTypeUnknown),
    ],
};

impl DpSyncTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DpSyncTypeEnum::FullSync => "fullSync",
            DpSyncTypeEnum::DeltaSync => "deltaSync",
            DpSyncTypeEnum::SyncTypeUnknown => "syncTypeUnknown",
            DpSyncTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DP_SYNC_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DpSyncTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DpSyncTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DpSyncTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DpSyncTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DpSyncTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DpSyncTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DpSyncTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DpSyncTypeEnum> for &'a str {
    fn from(value: &'a DpSyncTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DpSyncTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DP_V_SPHERE_DATA_PROTECTION_CAPABILITIES_ENUM_MAP: phf::Map<&'static str, DpVSphereDataProtectionCapabilitiesEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (7, 2),
        (0, 0),
    ],
    entries: &[
        ("SparseDiskEnhancement", DpVSphereDataProtectionCapabilitiesEnum::SparseDiskEnhancement),
        ("PerDiskBaseSnapshotId", DpVSphereDataProtectionCapabilitiesEnum::PerDiskBaseSnapshotId),
        ("PreservedExtents", DpVSphereDataProtectionCapabilitiesEnum::PreservedExtents),
        ("VsanNativeSnapshot", DpVSphereDataProtectionCapabilitiesEnum::VsanNativeSnapshot),
        ("RuntimeStats", DpVSphereDataProtectionCapabilitiesEnum::RuntimeStats),
        ("VSphereDpCapabilities_Unknown", DpVSphereDataProtectionCapabilitiesEnum::VSphereDpCapabilitiesUnknown),
        ("MultiPe", DpVSphereDataProtectionCapabilitiesEnum::MultiPe),
        ("QuiescedSnapshot", DpVSphereDataProtectionCapabilitiesEnum::QuiescedSnapshot),
        ("QueryPeInfo", DpVSphereDataProtectionCapabilitiesEnum::QueryPeInfo),
    ],
};

impl DpVSphereDataProtectionCapabilitiesEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DpVSphereDataProtectionCapabilitiesEnum::QueryPeInfo => "QueryPeInfo",
            DpVSphereDataProtectionCapabilitiesEnum::PerDiskBaseSnapshotId => "PerDiskBaseSnapshotId",
            DpVSphereDataProtectionCapabilitiesEnum::QuiescedSnapshot => "QuiescedSnapshot",
            DpVSphereDataProtectionCapabilitiesEnum::RuntimeStats => "RuntimeStats",
            DpVSphereDataProtectionCapabilitiesEnum::PreservedExtents => "PreservedExtents",
            DpVSphereDataProtectionCapabilitiesEnum::MultiPe => "MultiPe",
            DpVSphereDataProtectionCapabilitiesEnum::VsanNativeSnapshot => "VsanNativeSnapshot",
            DpVSphereDataProtectionCapabilitiesEnum::SparseDiskEnhancement => "SparseDiskEnhancement",
            DpVSphereDataProtectionCapabilitiesEnum::VSphereDpCapabilitiesUnknown => "VSphereDpCapabilities_Unknown",
            DpVSphereDataProtectionCapabilitiesEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DP_V_SPHERE_DATA_PROTECTION_CAPABILITIES_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DpVSphereDataProtectionCapabilitiesEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DpVSphereDataProtectionCapabilitiesEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DpVSphereDataProtectionCapabilitiesEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DpVSphereDataProtectionCapabilitiesEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DpVSphereDataProtectionCapabilitiesEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DpVSphereDataProtectionCapabilitiesEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DpVSphereDataProtectionCapabilitiesEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DpVSphereDataProtectionCapabilitiesEnum> for &'a str {
    fn from(value: &'a DpVSphereDataProtectionCapabilitiesEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DpVSphereDataProtectionCapabilitiesEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DP_VSS_BACKUP_CONTEXT_ENUM_MAP: phf::Map<&'static str, DpVssBackupContextEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("vssBackupContextAuto", DpVssBackupContextEnum::VssBackupContextAuto),
        ("vssBackupContextFileShareBackup", DpVssBackupContextEnum::VssBackupContextFileShareBackup),
        ("vssBackupContextBackup", DpVssBackupContextEnum::VssBackupContextBackup),
        ("vssBackupContextUnknown", DpVssBackupContextEnum::VssBackupContextUnknown),
    ],
};

impl DpVssBackupContextEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DpVssBackupContextEnum::VssBackupContextAuto => "vssBackupContextAuto",
            DpVssBackupContextEnum::VssBackupContextBackup => "vssBackupContextBackup",
            DpVssBackupContextEnum::VssBackupContextFileShareBackup => "vssBackupContextFileShareBackup",
            DpVssBackupContextEnum::VssBackupContextUnknown => "vssBackupContextUnknown",
            DpVssBackupContextEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DP_VSS_BACKUP_CONTEXT_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DpVssBackupContextEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DpVssBackupContextEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DpVssBackupContextEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DpVssBackupContextEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DpVssBackupContextEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DpVssBackupContextEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DpVssBackupContextEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DpVssBackupContextEnum> for &'a str {
    fn from(value: &'a DpVssBackupContextEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DpVssBackupContextEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DP_VSS_BACKUP_TYPE_ENUM_MAP: phf::Map<&'static str, DpVssBackupTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("vssBackupTypeCopy", DpVssBackupTypeEnum::VssBackupTypeCopy),
        ("vssBackupTypeFull", DpVssBackupTypeEnum::VssBackupTypeFull),
        ("vssBackupTypeUnknown", DpVssBackupTypeEnum::VssBackupTypeUnknown),
    ],
};

impl DpVssBackupTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DpVssBackupTypeEnum::VssBackupTypeFull => "vssBackupTypeFull",
            DpVssBackupTypeEnum::VssBackupTypeCopy => "vssBackupTypeCopy",
            DpVssBackupTypeEnum::VssBackupTypeUnknown => "vssBackupTypeUnknown",
            DpVssBackupTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DP_VSS_BACKUP_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DpVssBackupTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DpVssBackupTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DpVssBackupTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DpVssBackupTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DpVssBackupTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DpVssBackupTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DpVssBackupTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DpVssBackupTypeEnum> for &'a str {
    fn from(value: &'a DpVssBackupTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DpVssBackupTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DP_CAPABILITY_SUPPORT_LEVEL_ENUM_MAP: phf::Map<&'static str, DpCapabilitySupportLevelEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (3, 0),
    ],
    entries: &[
        ("CapabilitySupportLevel_unknown", DpCapabilitySupportLevelEnum::CapabilitySupportLevelUnknown),
        ("partially_supported", DpCapabilitySupportLevelEnum::PartiallySupported),
        ("not_supported", DpCapabilitySupportLevelEnum::NotSupported),
        ("supported", DpCapabilitySupportLevelEnum::Supported),
    ],
};

impl DpCapabilitySupportLevelEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DpCapabilitySupportLevelEnum::Supported => "supported",
            DpCapabilitySupportLevelEnum::PartiallySupported => "partially_supported",
            DpCapabilitySupportLevelEnum::NotSupported => "not_supported",
            DpCapabilitySupportLevelEnum::CapabilitySupportLevelUnknown => "CapabilitySupportLevel_unknown",
            DpCapabilitySupportLevelEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DP_CAPABILITY_SUPPORT_LEVEL_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DpCapabilitySupportLevelEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DpCapabilitySupportLevelEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DpCapabilitySupportLevelEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DpCapabilitySupportLevelEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DpCapabilitySupportLevelEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DpCapabilitySupportLevelEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DpCapabilitySupportLevelEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DpCapabilitySupportLevelEnum> for &'a str {
    fn from(value: &'a DpCapabilitySupportLevelEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DpCapabilitySupportLevelEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DP_DR_SRM_WORKFLOW_ENUM_MAP: phf::Map<&'static str, DpDrSrmWorkflowEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("cleanup_test", DpDrSrmWorkflowEnum::CleanupTest),
        ("srmWorkflowUnknown", DpDrSrmWorkflowEnum::SrmWorkflowUnknown),
        ("reprotect", DpDrSrmWorkflowEnum::Reprotect),
        ("failover", DpDrSrmWorkflowEnum::Failover),
        ("test_failover", DpDrSrmWorkflowEnum::TestFailover),
    ],
};

impl DpDrSrmWorkflowEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DpDrSrmWorkflowEnum::TestFailover => "test_failover",
            DpDrSrmWorkflowEnum::CleanupTest => "cleanup_test",
            DpDrSrmWorkflowEnum::Failover => "failover",
            DpDrSrmWorkflowEnum::Reprotect => "reprotect",
            DpDrSrmWorkflowEnum::SrmWorkflowUnknown => "srmWorkflowUnknown",
            DpDrSrmWorkflowEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DP_DR_SRM_WORKFLOW_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DpDrSrmWorkflowEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DpDrSrmWorkflowEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DpDrSrmWorkflowEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DpDrSrmWorkflowEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DpDrSrmWorkflowEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DpDrSrmWorkflowEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DpDrSrmWorkflowEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DpDrSrmWorkflowEnum> for &'a str {
    fn from(value: &'a DpDrSrmWorkflowEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DpDrSrmWorkflowEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static AGENCY_VM_PLACEMENT_POLICY_VM_ANTI_AFFINITY_ENUM_MAP: phf::Map<&'static str, AgencyVmPlacementPolicyVmAntiAffinityEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("none", AgencyVmPlacementPolicyVmAntiAffinityEnum::None),
        ("soft", AgencyVmPlacementPolicyVmAntiAffinityEnum::Soft),
    ],
};

impl AgencyVmPlacementPolicyVmAntiAffinityEnum {
    pub fn as_str(&self) -> &str {
        match self {
            AgencyVmPlacementPolicyVmAntiAffinityEnum::None => "none",
            AgencyVmPlacementPolicyVmAntiAffinityEnum::Soft => "soft",
            AgencyVmPlacementPolicyVmAntiAffinityEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        AGENCY_VM_PLACEMENT_POLICY_VM_ANTI_AFFINITY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| AgencyVmPlacementPolicyVmAntiAffinityEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for AgencyVmPlacementPolicyVmAntiAffinityEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for AgencyVmPlacementPolicyVmAntiAffinityEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<AgencyVmPlacementPolicyVmAntiAffinityEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(AgencyVmPlacementPolicyVmAntiAffinityEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for AgencyVmPlacementPolicyVmAntiAffinityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for AgencyVmPlacementPolicyVmAntiAffinityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a AgencyVmPlacementPolicyVmAntiAffinityEnum> for &'a str {
    fn from(value: &'a AgencyVmPlacementPolicyVmAntiAffinityEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for AgencyVmPlacementPolicyVmAntiAffinityEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static AGENCY_VM_PLACEMENT_POLICY_VM_DATA_AFFINITY_ENUM_MAP: phf::Map<&'static str, AgencyVmPlacementPolicyVmDataAffinityEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("none", AgencyVmPlacementPolicyVmDataAffinityEnum::None),
        ("soft", AgencyVmPlacementPolicyVmDataAffinityEnum::Soft),
    ],
};

impl AgencyVmPlacementPolicyVmDataAffinityEnum {
    pub fn as_str(&self) -> &str {
        match self {
            AgencyVmPlacementPolicyVmDataAffinityEnum::None => "none",
            AgencyVmPlacementPolicyVmDataAffinityEnum::Soft => "soft",
            AgencyVmPlacementPolicyVmDataAffinityEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        AGENCY_VM_PLACEMENT_POLICY_VM_DATA_AFFINITY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| AgencyVmPlacementPolicyVmDataAffinityEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for AgencyVmPlacementPolicyVmDataAffinityEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for AgencyVmPlacementPolicyVmDataAffinityEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<AgencyVmPlacementPolicyVmDataAffinityEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(AgencyVmPlacementPolicyVmDataAffinityEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for AgencyVmPlacementPolicyVmDataAffinityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for AgencyVmPlacementPolicyVmDataAffinityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a AgencyVmPlacementPolicyVmDataAffinityEnum> for &'a str {
    fn from(value: &'a AgencyVmPlacementPolicyVmDataAffinityEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for AgencyVmPlacementPolicyVmDataAffinityEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static AGENT_CONFIG_INFO_AUTHENTICATION_SCHEME_ENUM_MAP: phf::Map<&'static str, AgentConfigInfoAuthenticationSchemeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("VMWARE_SESSION_ID", AgentConfigInfoAuthenticationSchemeEnum::VmwareSessionId),
        ("NONE", AgentConfigInfoAuthenticationSchemeEnum::None),
    ],
};

impl AgentConfigInfoAuthenticationSchemeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            AgentConfigInfoAuthenticationSchemeEnum::None => "NONE",
            AgentConfigInfoAuthenticationSchemeEnum::VmwareSessionId => "VMWARE_SESSION_ID",
            AgentConfigInfoAuthenticationSchemeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        AGENT_CONFIG_INFO_AUTHENTICATION_SCHEME_ENUM_MAP.get(s).cloned().unwrap_or_else(|| AgentConfigInfoAuthenticationSchemeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for AgentConfigInfoAuthenticationSchemeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for AgentConfigInfoAuthenticationSchemeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<AgentConfigInfoAuthenticationSchemeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(AgentConfigInfoAuthenticationSchemeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for AgentConfigInfoAuthenticationSchemeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for AgentConfigInfoAuthenticationSchemeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a AgentConfigInfoAuthenticationSchemeEnum> for &'a str {
    fn from(value: &'a AgentConfigInfoAuthenticationSchemeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for AgentConfigInfoAuthenticationSchemeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static AGENT_CONFIG_INFO_OVF_DISK_PROVISIONING_ENUM_MAP: phf::Map<&'static str, AgentConfigInfoOvfDiskProvisioningEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("none", AgentConfigInfoOvfDiskProvisioningEnum::None),
        ("thin", AgentConfigInfoOvfDiskProvisioningEnum::Thin),
        ("thick", AgentConfigInfoOvfDiskProvisioningEnum::Thick),
    ],
};

impl AgentConfigInfoOvfDiskProvisioningEnum {
    pub fn as_str(&self) -> &str {
        match self {
            AgentConfigInfoOvfDiskProvisioningEnum::None => "none",
            AgentConfigInfoOvfDiskProvisioningEnum::Thin => "thin",
            AgentConfigInfoOvfDiskProvisioningEnum::Thick => "thick",
            AgentConfigInfoOvfDiskProvisioningEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        AGENT_CONFIG_INFO_OVF_DISK_PROVISIONING_ENUM_MAP.get(s).cloned().unwrap_or_else(|| AgentConfigInfoOvfDiskProvisioningEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for AgentConfigInfoOvfDiskProvisioningEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for AgentConfigInfoOvfDiskProvisioningEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<AgentConfigInfoOvfDiskProvisioningEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(AgentConfigInfoOvfDiskProvisioningEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for AgentConfigInfoOvfDiskProvisioningEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for AgentConfigInfoOvfDiskProvisioningEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a AgentConfigInfoOvfDiskProvisioningEnum> for &'a str {
    fn from(value: &'a AgentConfigInfoOvfDiskProvisioningEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for AgentConfigInfoOvfDiskProvisioningEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static AGENT_VM_HOOK_VM_STATE_ENUM_MAP: phf::Map<&'static str, AgentVmHookVmStateEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("prePowerOn", AgentVmHookVmStateEnum::PrePowerOn),
        ("provisioned", AgentVmHookVmStateEnum::Provisioned),
        ("poweredOn", AgentVmHookVmStateEnum::PoweredOn),
    ],
};

impl AgentVmHookVmStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            AgentVmHookVmStateEnum::Provisioned => "provisioned",
            AgentVmHookVmStateEnum::PoweredOn => "poweredOn",
            AgentVmHookVmStateEnum::PrePowerOn => "prePowerOn",
            AgentVmHookVmStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        AGENT_VM_HOOK_VM_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| AgentVmHookVmStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for AgentVmHookVmStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for AgentVmHookVmStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<AgentVmHookVmStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(AgentVmHookVmStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for AgentVmHookVmStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for AgentVmHookVmStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a AgentVmHookVmStateEnum> for &'a str {
    fn from(value: &'a AgentVmHookVmStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for AgentVmHookVmStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static EAM_OBJECT_RUNTIME_INFO_GOAL_STATE_ENUM_MAP: phf::Map<&'static str, EamObjectRuntimeInfoGoalStateEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("disabled", EamObjectRuntimeInfoGoalStateEnum::Disabled),
        ("enabled", EamObjectRuntimeInfoGoalStateEnum::Enabled),
        ("uninstalled", EamObjectRuntimeInfoGoalStateEnum::Uninstalled),
    ],
};

impl EamObjectRuntimeInfoGoalStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            EamObjectRuntimeInfoGoalStateEnum::Enabled => "enabled",
            EamObjectRuntimeInfoGoalStateEnum::Disabled => "disabled",
            EamObjectRuntimeInfoGoalStateEnum::Uninstalled => "uninstalled",
            EamObjectRuntimeInfoGoalStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        EAM_OBJECT_RUNTIME_INFO_GOAL_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| EamObjectRuntimeInfoGoalStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for EamObjectRuntimeInfoGoalStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for EamObjectRuntimeInfoGoalStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<EamObjectRuntimeInfoGoalStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(EamObjectRuntimeInfoGoalStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for EamObjectRuntimeInfoGoalStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for EamObjectRuntimeInfoGoalStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a EamObjectRuntimeInfoGoalStateEnum> for &'a str {
    fn from(value: &'a EamObjectRuntimeInfoGoalStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for EamObjectRuntimeInfoGoalStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static EAM_OBJECT_RUNTIME_INFO_STATUS_ENUM_MAP: phf::Map<&'static str, EamObjectRuntimeInfoStatusEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("red", EamObjectRuntimeInfoStatusEnum::Red),
        ("green", EamObjectRuntimeInfoStatusEnum::Green),
        ("yellow", EamObjectRuntimeInfoStatusEnum::Yellow),
    ],
};

impl EamObjectRuntimeInfoStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            EamObjectRuntimeInfoStatusEnum::Green => "green",
            EamObjectRuntimeInfoStatusEnum::Yellow => "yellow",
            EamObjectRuntimeInfoStatusEnum::Red => "red",
            EamObjectRuntimeInfoStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        EAM_OBJECT_RUNTIME_INFO_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| EamObjectRuntimeInfoStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for EamObjectRuntimeInfoStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for EamObjectRuntimeInfoStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<EamObjectRuntimeInfoStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(EamObjectRuntimeInfoStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for EamObjectRuntimeInfoStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for EamObjectRuntimeInfoStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a EamObjectRuntimeInfoStatusEnum> for &'a str {
    fn from(value: &'a EamObjectRuntimeInfoStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for EamObjectRuntimeInfoStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static ESX_AGENT_MANAGER_MAINTENANCE_MODE_POLICY_ENUM_MAP: phf::Map<&'static str, EsxAgentManagerMaintenanceModePolicyEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("singleHost", EsxAgentManagerMaintenanceModePolicyEnum::SingleHost),
        ("multipleHosts", EsxAgentManagerMaintenanceModePolicyEnum::MultipleHosts),
    ],
};

impl EsxAgentManagerMaintenanceModePolicyEnum {
    pub fn as_str(&self) -> &str {
        match self {
            EsxAgentManagerMaintenanceModePolicyEnum::SingleHost => "singleHost",
            EsxAgentManagerMaintenanceModePolicyEnum::MultipleHosts => "multipleHosts",
            EsxAgentManagerMaintenanceModePolicyEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        ESX_AGENT_MANAGER_MAINTENANCE_MODE_POLICY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| EsxAgentManagerMaintenanceModePolicyEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for EsxAgentManagerMaintenanceModePolicyEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for EsxAgentManagerMaintenanceModePolicyEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<EsxAgentManagerMaintenanceModePolicyEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(EsxAgentManagerMaintenanceModePolicyEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for EsxAgentManagerMaintenanceModePolicyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for EsxAgentManagerMaintenanceModePolicyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a EsxAgentManagerMaintenanceModePolicyEnum> for &'a str {
    fn from(value: &'a EsxAgentManagerMaintenanceModePolicyEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for EsxAgentManagerMaintenanceModePolicyEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOOKS_HOOK_TYPE_ENUM_MAP: phf::Map<&'static str, HooksHookTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("POST_PROVISIONING", HooksHookTypeEnum::PostProvisioning),
        ("POST_POWER_ON", HooksHookTypeEnum::PostPowerOn),
    ],
};

impl HooksHookTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HooksHookTypeEnum::PostProvisioning => "POST_PROVISIONING",
            HooksHookTypeEnum::PostPowerOn => "POST_POWER_ON",
            HooksHookTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOOKS_HOOK_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HooksHookTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HooksHookTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HooksHookTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HooksHookTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HooksHookTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HooksHookTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HooksHookTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HooksHookTypeEnum> for &'a str {
    fn from(value: &'a HooksHookTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HooksHookTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static SOLUTIONS_INVALID_REASON_ENUM_MAP: phf::Map<&'static str, SolutionsInvalidReasonEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 3),
        (3, 0),
    ],
    entries: &[
        ("INVALID_DATASTORES", SolutionsInvalidReasonEnum::InvalidDatastores),
        ("INVALID_OVF_DESCRIPTOR", SolutionsInvalidReasonEnum::InvalidOvfDescriptor),
        ("INVALID_RESOURCE_POOL", SolutionsInvalidReasonEnum::InvalidResourcePool),
        ("INVALID_PROPERTIES", SolutionsInvalidReasonEnum::InvalidProperties),
        ("INVALID_NETWORKS", SolutionsInvalidReasonEnum::InvalidNetworks),
        ("INACCESSBLE_VM_SOURCE", SolutionsInvalidReasonEnum::InaccessbleVmSource),
        ("INVALID_TRANSITION", SolutionsInvalidReasonEnum::InvalidTransition),
        ("INVALID_FOLDER", SolutionsInvalidReasonEnum::InvalidFolder),
    ],
};

impl SolutionsInvalidReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            SolutionsInvalidReasonEnum::InvalidOvfDescriptor => "INVALID_OVF_DESCRIPTOR",
            SolutionsInvalidReasonEnum::InaccessbleVmSource => "INACCESSBLE_VM_SOURCE",
            SolutionsInvalidReasonEnum::InvalidNetworks => "INVALID_NETWORKS",
            SolutionsInvalidReasonEnum::InvalidDatastores => "INVALID_DATASTORES",
            SolutionsInvalidReasonEnum::InvalidResourcePool => "INVALID_RESOURCE_POOL",
            SolutionsInvalidReasonEnum::InvalidFolder => "INVALID_FOLDER",
            SolutionsInvalidReasonEnum::InvalidProperties => "INVALID_PROPERTIES",
            SolutionsInvalidReasonEnum::InvalidTransition => "INVALID_TRANSITION",
            SolutionsInvalidReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        SOLUTIONS_INVALID_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| SolutionsInvalidReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for SolutionsInvalidReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for SolutionsInvalidReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<SolutionsInvalidReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(SolutionsInvalidReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for SolutionsInvalidReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for SolutionsInvalidReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a SolutionsInvalidReasonEnum> for &'a str {
    fn from(value: &'a SolutionsInvalidReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for SolutionsInvalidReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static SOLUTIONS_NON_COMPLIANCE_REASON_ENUM_MAP: phf::Map<&'static str, SolutionsNonComplianceReasonEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (3, 0),
    ],
    entries: &[
        ("WORKING", SolutionsNonComplianceReasonEnum::Working),
        ("OBSOLETE_SPEC", SolutionsNonComplianceReasonEnum::ObsoleteSpec),
        ("IN_HOOK", SolutionsNonComplianceReasonEnum::InHook),
        ("NO_SPEC", SolutionsNonComplianceReasonEnum::NoSpec),
        ("ISSUE", SolutionsNonComplianceReasonEnum::Issue),
    ],
};

impl SolutionsNonComplianceReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            SolutionsNonComplianceReasonEnum::Working => "WORKING",
            SolutionsNonComplianceReasonEnum::Issue => "ISSUE",
            SolutionsNonComplianceReasonEnum::InHook => "IN_HOOK",
            SolutionsNonComplianceReasonEnum::ObsoleteSpec => "OBSOLETE_SPEC",
            SolutionsNonComplianceReasonEnum::NoSpec => "NO_SPEC",
            SolutionsNonComplianceReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        SOLUTIONS_NON_COMPLIANCE_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| SolutionsNonComplianceReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for SolutionsNonComplianceReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for SolutionsNonComplianceReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<SolutionsNonComplianceReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(SolutionsNonComplianceReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for SolutionsNonComplianceReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for SolutionsNonComplianceReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a SolutionsNonComplianceReasonEnum> for &'a str {
    fn from(value: &'a SolutionsNonComplianceReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for SolutionsNonComplianceReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static SOLUTIONS_VM_DEPLOYMENT_OPTIMIZATION_ENUM_MAP: phf::Map<&'static str, SolutionsVmDeploymentOptimizationEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("NO_CLONES", SolutionsVmDeploymentOptimizationEnum::NoClones),
        ("ALL_CLONES", SolutionsVmDeploymentOptimizationEnum::AllClones),
        ("FULL_CLONES_ONLY", SolutionsVmDeploymentOptimizationEnum::FullClonesOnly),
    ],
};

impl SolutionsVmDeploymentOptimizationEnum {
    pub fn as_str(&self) -> &str {
        match self {
            SolutionsVmDeploymentOptimizationEnum::AllClones => "ALL_CLONES",
            SolutionsVmDeploymentOptimizationEnum::FullClonesOnly => "FULL_CLONES_ONLY",
            SolutionsVmDeploymentOptimizationEnum::NoClones => "NO_CLONES",
            SolutionsVmDeploymentOptimizationEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        SOLUTIONS_VM_DEPLOYMENT_OPTIMIZATION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| SolutionsVmDeploymentOptimizationEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for SolutionsVmDeploymentOptimizationEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for SolutionsVmDeploymentOptimizationEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<SolutionsVmDeploymentOptimizationEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(SolutionsVmDeploymentOptimizationEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for SolutionsVmDeploymentOptimizationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for SolutionsVmDeploymentOptimizationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a SolutionsVmDeploymentOptimizationEnum> for &'a str {
    fn from(value: &'a SolutionsVmDeploymentOptimizationEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for SolutionsVmDeploymentOptimizationEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static SOLUTIONS_VM_DISK_PROVISIONING_ENUM_MAP: phf::Map<&'static str, SolutionsVmDiskProvisioningEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("THIN", SolutionsVmDiskProvisioningEnum::Thin),
        ("THICK", SolutionsVmDiskProvisioningEnum::Thick),
    ],
};

impl SolutionsVmDiskProvisioningEnum {
    pub fn as_str(&self) -> &str {
        match self {
            SolutionsVmDiskProvisioningEnum::Thin => "THIN",
            SolutionsVmDiskProvisioningEnum::Thick => "THICK",
            SolutionsVmDiskProvisioningEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        SOLUTIONS_VM_DISK_PROVISIONING_ENUM_MAP.get(s).cloned().unwrap_or_else(|| SolutionsVmDiskProvisioningEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for SolutionsVmDiskProvisioningEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for SolutionsVmDiskProvisioningEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<SolutionsVmDiskProvisioningEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(SolutionsVmDiskProvisioningEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for SolutionsVmDiskProvisioningEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for SolutionsVmDiskProvisioningEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a SolutionsVmDiskProvisioningEnum> for &'a str {
    fn from(value: &'a SolutionsVmDiskProvisioningEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for SolutionsVmDiskProvisioningEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static SOLUTIONS_VM_PLACEMENT_POLICY_ENUM_MAP: phf::Map<&'static str, SolutionsVmPlacementPolicyEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("VM_VM_ANTI_AFFINITY", SolutionsVmPlacementPolicyEnum::VmVmAntiAffinity),
    ],
};

impl SolutionsVmPlacementPolicyEnum {
    pub fn as_str(&self) -> &str {
        match self {
            SolutionsVmPlacementPolicyEnum::VmVmAntiAffinity => "VM_VM_ANTI_AFFINITY",
            SolutionsVmPlacementPolicyEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        SOLUTIONS_VM_PLACEMENT_POLICY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| SolutionsVmPlacementPolicyEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for SolutionsVmPlacementPolicyEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for SolutionsVmPlacementPolicyEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<SolutionsVmPlacementPolicyEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(SolutionsVmPlacementPolicyEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for SolutionsVmPlacementPolicyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for SolutionsVmPlacementPolicyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a SolutionsVmPlacementPolicyEnum> for &'a str {
    fn from(value: &'a SolutionsVmPlacementPolicyEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for SolutionsVmPlacementPolicyEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PBM_LOGGING_CONFIGURATION_COMPONENT_ENUM_MAP: phf::Map<&'static str, PbmLoggingConfigurationComponentEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (3, 0),
        (0, 7),
    ],
    entries: &[
        ("sps", PbmLoggingConfigurationComponentEnum::Sps),
        ("httpclient_content", PbmLoggingConfigurationComponentEnum::HttpclientContent),
        ("spbm", PbmLoggingConfigurationComponentEnum::Spbm),
        ("sms", PbmLoggingConfigurationComponentEnum::Sms),
        ("vslm", PbmLoggingConfigurationComponentEnum::Vslm),
        ("httpclient_header", PbmLoggingConfigurationComponentEnum::HttpclientHeader),
        ("vmomi", PbmLoggingConfigurationComponentEnum::Vmomi),
        ("pbm", PbmLoggingConfigurationComponentEnum::Pbm),
    ],
};

impl PbmLoggingConfigurationComponentEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PbmLoggingConfigurationComponentEnum::Pbm => "pbm",
            PbmLoggingConfigurationComponentEnum::Vslm => "vslm",
            PbmLoggingConfigurationComponentEnum::Sms => "sms",
            PbmLoggingConfigurationComponentEnum::Spbm => "spbm",
            PbmLoggingConfigurationComponentEnum::Sps => "sps",
            PbmLoggingConfigurationComponentEnum::HttpclientHeader => "httpclient_header",
            PbmLoggingConfigurationComponentEnum::HttpclientContent => "httpclient_content",
            PbmLoggingConfigurationComponentEnum::Vmomi => "vmomi",
            PbmLoggingConfigurationComponentEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PBM_LOGGING_CONFIGURATION_COMPONENT_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PbmLoggingConfigurationComponentEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PbmLoggingConfigurationComponentEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PbmLoggingConfigurationComponentEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PbmLoggingConfigurationComponentEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PbmLoggingConfigurationComponentEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PbmLoggingConfigurationComponentEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PbmLoggingConfigurationComponentEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PbmLoggingConfigurationComponentEnum> for &'a str {
    fn from(value: &'a PbmLoggingConfigurationComponentEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PbmLoggingConfigurationComponentEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PBM_LOGGING_CONFIGURATION_LOG_LEVEL_ENUM_MAP: phf::Map<&'static str, PbmLoggingConfigurationLogLevelEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("DEBUG", PbmLoggingConfigurationLogLevelEnum::Debug),
        ("INFO", PbmLoggingConfigurationLogLevelEnum::Info),
        ("TRACE", PbmLoggingConfigurationLogLevelEnum::Trace),
    ],
};

impl PbmLoggingConfigurationLogLevelEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PbmLoggingConfigurationLogLevelEnum::Info => "INFO",
            PbmLoggingConfigurationLogLevelEnum::Debug => "DEBUG",
            PbmLoggingConfigurationLogLevelEnum::Trace => "TRACE",
            PbmLoggingConfigurationLogLevelEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PBM_LOGGING_CONFIGURATION_LOG_LEVEL_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PbmLoggingConfigurationLogLevelEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PbmLoggingConfigurationLogLevelEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PbmLoggingConfigurationLogLevelEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PbmLoggingConfigurationLogLevelEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PbmLoggingConfigurationLogLevelEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PbmLoggingConfigurationLogLevelEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PbmLoggingConfigurationLogLevelEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PbmLoggingConfigurationLogLevelEnum> for &'a str {
    fn from(value: &'a PbmLoggingConfigurationLogLevelEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PbmLoggingConfigurationLogLevelEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PBM_DEBUG_MANAGER_KEYSTORE_NAME_ENUM_MAP: phf::Map<&'static str, PbmDebugManagerKeystoreNameEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("TRUSTED_ROOTS", PbmDebugManagerKeystoreNameEnum::TrustedRoots),
        ("SMS", PbmDebugManagerKeystoreNameEnum::Sms),
    ],
};

impl PbmDebugManagerKeystoreNameEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PbmDebugManagerKeystoreNameEnum::Sms => "SMS",
            PbmDebugManagerKeystoreNameEnum::TrustedRoots => "TRUSTED_ROOTS",
            PbmDebugManagerKeystoreNameEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PBM_DEBUG_MANAGER_KEYSTORE_NAME_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PbmDebugManagerKeystoreNameEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PbmDebugManagerKeystoreNameEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PbmDebugManagerKeystoreNameEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PbmDebugManagerKeystoreNameEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PbmDebugManagerKeystoreNameEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PbmDebugManagerKeystoreNameEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PbmDebugManagerKeystoreNameEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PbmDebugManagerKeystoreNameEnum> for &'a str {
    fn from(value: &'a PbmDebugManagerKeystoreNameEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PbmDebugManagerKeystoreNameEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PBM_OBJECT_TYPE_ENUM_MAP: phf::Map<&'static str, PbmObjectTypeEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (0, 0),
        (1, 3),
    ],
    entries: &[
        ("virtualMachineAndDisks", PbmObjectTypeEnum::VirtualMachineAndDisks),
        ("virtualMachine", PbmObjectTypeEnum::VirtualMachine),
        ("unknown", PbmObjectTypeEnum::Unknown),
        ("virtualDiskUUID", PbmObjectTypeEnum::VirtualDiskUuid),
        ("virtualDiskId", PbmObjectTypeEnum::VirtualDiskId),
        ("vsanObjectId", PbmObjectTypeEnum::VsanObjectId),
        ("datastore", PbmObjectTypeEnum::Datastore),
        ("fileShareId", PbmObjectTypeEnum::FileShareId),
    ],
};

impl PbmObjectTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PbmObjectTypeEnum::VirtualMachine => "virtualMachine",
            PbmObjectTypeEnum::VirtualMachineAndDisks => "virtualMachineAndDisks",
            PbmObjectTypeEnum::VirtualDiskId => "virtualDiskId",
            PbmObjectTypeEnum::VirtualDiskUuid => "virtualDiskUUID",
            PbmObjectTypeEnum::Datastore => "datastore",
            PbmObjectTypeEnum::VsanObjectId => "vsanObjectId",
            PbmObjectTypeEnum::FileShareId => "fileShareId",
            PbmObjectTypeEnum::Unknown => "unknown",
            PbmObjectTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PBM_OBJECT_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PbmObjectTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PbmObjectTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PbmObjectTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PbmObjectTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PbmObjectTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PbmObjectTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PbmObjectTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PbmObjectTypeEnum> for &'a str {
    fn from(value: &'a PbmObjectTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PbmObjectTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PBM_VVOL_TYPE_ENUM_MAP: phf::Map<&'static str, PbmVvolTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("Config", PbmVvolTypeEnum::Config),
        ("Swap", PbmVvolTypeEnum::Swap),
        ("Data", PbmVvolTypeEnum::Data),
    ],
};

impl PbmVvolTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PbmVvolTypeEnum::Config => "Config",
            PbmVvolTypeEnum::Data => "Data",
            PbmVvolTypeEnum::Swap => "Swap",
            PbmVvolTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PBM_VVOL_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PbmVvolTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PbmVvolTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PbmVvolTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PbmVvolTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PbmVvolTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PbmVvolTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PbmVvolTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PbmVvolTypeEnum> for &'a str {
    fn from(value: &'a PbmVvolTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PbmVvolTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PBM_CAPABILITY_OPERATOR_ENUM_MAP: phf::Map<&'static str, PbmCapabilityOperatorEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("NOT", PbmCapabilityOperatorEnum::Not),
    ],
};

impl PbmCapabilityOperatorEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PbmCapabilityOperatorEnum::Not => "NOT",
            PbmCapabilityOperatorEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PBM_CAPABILITY_OPERATOR_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PbmCapabilityOperatorEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PbmCapabilityOperatorEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PbmCapabilityOperatorEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PbmCapabilityOperatorEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PbmCapabilityOperatorEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PbmCapabilityOperatorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PbmCapabilityOperatorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PbmCapabilityOperatorEnum> for &'a str {
    fn from(value: &'a PbmCapabilityOperatorEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PbmCapabilityOperatorEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PBM_CAPABILITY_SCHEMA_CAPABILITY_CATEGORY_ENUM_MAP: phf::Map<&'static str, PbmCapabilitySchemaCapabilityCategoryEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("datastoreSpecific", PbmCapabilitySchemaCapabilityCategoryEnum::DatastoreSpecific),
        ("common", PbmCapabilitySchemaCapabilityCategoryEnum::Common),
    ],
};

impl PbmCapabilitySchemaCapabilityCategoryEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PbmCapabilitySchemaCapabilityCategoryEnum::Common => "common",
            PbmCapabilitySchemaCapabilityCategoryEnum::DatastoreSpecific => "datastoreSpecific",
            PbmCapabilitySchemaCapabilityCategoryEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PBM_CAPABILITY_SCHEMA_CAPABILITY_CATEGORY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PbmCapabilitySchemaCapabilityCategoryEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PbmCapabilitySchemaCapabilityCategoryEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PbmCapabilitySchemaCapabilityCategoryEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PbmCapabilitySchemaCapabilityCategoryEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PbmCapabilitySchemaCapabilityCategoryEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PbmCapabilitySchemaCapabilityCategoryEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PbmCapabilitySchemaCapabilityCategoryEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PbmCapabilitySchemaCapabilityCategoryEnum> for &'a str {
    fn from(value: &'a PbmCapabilitySchemaCapabilityCategoryEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PbmCapabilitySchemaCapabilityCategoryEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PBM_LINE_OF_SERVICE_INFO_LINE_OF_SERVICE_ENUM_ENUM_MAP: phf::Map<&'static str, PbmLineOfServiceInfoLineOfServiceEnumEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 8),
        (3, 0),
    ],
    entries: &[
        ("STRETCHED_CLUSTER", PbmLineOfServiceInfoLineOfServiceEnumEnum::StretchedCluster),
        ("DATASTORE_IO_CONTROL", PbmLineOfServiceInfoLineOfServiceEnumEnum::DatastoreIoControl),
        ("DATA_PROTECTION", PbmLineOfServiceInfoLineOfServiceEnumEnum::DataProtection),
        ("PERSISTENCE", PbmLineOfServiceInfoLineOfServiceEnumEnum::Persistence),
        ("COMPRESSION", PbmLineOfServiceInfoLineOfServiceEnumEnum::Compression),
        ("REPLICATION", PbmLineOfServiceInfoLineOfServiceEnumEnum::Replication),
        ("CACHING", PbmLineOfServiceInfoLineOfServiceEnumEnum::Caching),
        ("INSPECTION", PbmLineOfServiceInfoLineOfServiceEnumEnum::Inspection),
        ("ENCRYPTION", PbmLineOfServiceInfoLineOfServiceEnumEnum::Encryption),
        ("DATA_PROVIDER", PbmLineOfServiceInfoLineOfServiceEnumEnum::DataProvider),
    ],
};

impl PbmLineOfServiceInfoLineOfServiceEnumEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PbmLineOfServiceInfoLineOfServiceEnumEnum::Inspection => "INSPECTION",
            PbmLineOfServiceInfoLineOfServiceEnumEnum::Compression => "COMPRESSION",
            PbmLineOfServiceInfoLineOfServiceEnumEnum::Encryption => "ENCRYPTION",
            PbmLineOfServiceInfoLineOfServiceEnumEnum::Replication => "REPLICATION",
            PbmLineOfServiceInfoLineOfServiceEnumEnum::Caching => "CACHING",
            PbmLineOfServiceInfoLineOfServiceEnumEnum::Persistence => "PERSISTENCE",
            PbmLineOfServiceInfoLineOfServiceEnumEnum::DataProvider => "DATA_PROVIDER",
            PbmLineOfServiceInfoLineOfServiceEnumEnum::DatastoreIoControl => "DATASTORE_IO_CONTROL",
            PbmLineOfServiceInfoLineOfServiceEnumEnum::DataProtection => "DATA_PROTECTION",
            PbmLineOfServiceInfoLineOfServiceEnumEnum::StretchedCluster => "STRETCHED_CLUSTER",
            PbmLineOfServiceInfoLineOfServiceEnumEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PBM_LINE_OF_SERVICE_INFO_LINE_OF_SERVICE_ENUM_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PbmLineOfServiceInfoLineOfServiceEnumEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PbmLineOfServiceInfoLineOfServiceEnumEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PbmLineOfServiceInfoLineOfServiceEnumEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PbmLineOfServiceInfoLineOfServiceEnumEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PbmLineOfServiceInfoLineOfServiceEnumEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PbmLineOfServiceInfoLineOfServiceEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PbmLineOfServiceInfoLineOfServiceEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PbmLineOfServiceInfoLineOfServiceEnumEnum> for &'a str {
    fn from(value: &'a PbmLineOfServiceInfoLineOfServiceEnumEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PbmLineOfServiceInfoLineOfServiceEnumEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PBM_BUILTIN_GENERIC_TYPE_ENUM_MAP: phf::Map<&'static str, PbmBuiltinGenericTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("VMW_RANGE", PbmBuiltinGenericTypeEnum::VmwRange),
        ("VMW_SET", PbmBuiltinGenericTypeEnum::VmwSet),
    ],
};

impl PbmBuiltinGenericTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PbmBuiltinGenericTypeEnum::VmwRange => "VMW_RANGE",
            PbmBuiltinGenericTypeEnum::VmwSet => "VMW_SET",
            PbmBuiltinGenericTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PBM_BUILTIN_GENERIC_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PbmBuiltinGenericTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PbmBuiltinGenericTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PbmBuiltinGenericTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PbmBuiltinGenericTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PbmBuiltinGenericTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PbmBuiltinGenericTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PbmBuiltinGenericTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PbmBuiltinGenericTypeEnum> for &'a str {
    fn from(value: &'a PbmBuiltinGenericTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PbmBuiltinGenericTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PBM_BUILTIN_TYPE_ENUM_MAP: phf::Map<&'static str, PbmBuiltinTypeEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (2, 2),
        (3, 0),
    ],
    entries: &[
        ("VMW_TIMESPAN", PbmBuiltinTypeEnum::VmwTimespan),
        ("XSD_INT", PbmBuiltinTypeEnum::XsdInt),
        ("XSD_DATETIME", PbmBuiltinTypeEnum::XsdDatetime),
        ("VMW_POLICY", PbmBuiltinTypeEnum::VmwPolicy),
        ("XSD_LONG", PbmBuiltinTypeEnum::XsdLong),
        ("XSD_STRING", PbmBuiltinTypeEnum::XsdString),
        ("XSD_INTEGER", PbmBuiltinTypeEnum::XsdInteger),
        ("XSD_DOUBLE", PbmBuiltinTypeEnum::XsdDouble),
        ("XSD_SHORT", PbmBuiltinTypeEnum::XsdShort),
        ("XSD_BOOLEAN", PbmBuiltinTypeEnum::XsdBoolean),
    ],
};

impl PbmBuiltinTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PbmBuiltinTypeEnum::XsdLong => "XSD_LONG",
            PbmBuiltinTypeEnum::XsdShort => "XSD_SHORT",
            PbmBuiltinTypeEnum::XsdInteger => "XSD_INTEGER",
            PbmBuiltinTypeEnum::XsdInt => "XSD_INT",
            PbmBuiltinTypeEnum::XsdString => "XSD_STRING",
            PbmBuiltinTypeEnum::XsdBoolean => "XSD_BOOLEAN",
            PbmBuiltinTypeEnum::XsdDouble => "XSD_DOUBLE",
            PbmBuiltinTypeEnum::XsdDatetime => "XSD_DATETIME",
            PbmBuiltinTypeEnum::VmwTimespan => "VMW_TIMESPAN",
            PbmBuiltinTypeEnum::VmwPolicy => "VMW_POLICY",
            PbmBuiltinTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PBM_BUILTIN_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PbmBuiltinTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PbmBuiltinTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PbmBuiltinTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PbmBuiltinTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PbmBuiltinTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PbmBuiltinTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PbmBuiltinTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PbmBuiltinTypeEnum> for &'a str {
    fn from(value: &'a PbmBuiltinTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PbmBuiltinTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PBM_CAPABILITY_TIME_UNIT_TYPE_ENUM_MAP: phf::Map<&'static str, PbmCapabilityTimeUnitTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (5, 4),
        (0, 0),
    ],
    entries: &[
        ("WEEKS", PbmCapabilityTimeUnitTypeEnum::Weeks),
        ("MINUTES", PbmCapabilityTimeUnitTypeEnum::Minutes),
        ("HOURS", PbmCapabilityTimeUnitTypeEnum::Hours),
        ("YEARS", PbmCapabilityTimeUnitTypeEnum::Years),
        ("MONTHS", PbmCapabilityTimeUnitTypeEnum::Months),
        ("DAYS", PbmCapabilityTimeUnitTypeEnum::Days),
        ("SECONDS", PbmCapabilityTimeUnitTypeEnum::Seconds),
    ],
};

impl PbmCapabilityTimeUnitTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PbmCapabilityTimeUnitTypeEnum::Seconds => "SECONDS",
            PbmCapabilityTimeUnitTypeEnum::Minutes => "MINUTES",
            PbmCapabilityTimeUnitTypeEnum::Hours => "HOURS",
            PbmCapabilityTimeUnitTypeEnum::Days => "DAYS",
            PbmCapabilityTimeUnitTypeEnum::Weeks => "WEEKS",
            PbmCapabilityTimeUnitTypeEnum::Months => "MONTHS",
            PbmCapabilityTimeUnitTypeEnum::Years => "YEARS",
            PbmCapabilityTimeUnitTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PBM_CAPABILITY_TIME_UNIT_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PbmCapabilityTimeUnitTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PbmCapabilityTimeUnitTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PbmCapabilityTimeUnitTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PbmCapabilityTimeUnitTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PbmCapabilityTimeUnitTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PbmCapabilityTimeUnitTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PbmCapabilityTimeUnitTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PbmCapabilityTimeUnitTypeEnum> for &'a str {
    fn from(value: &'a PbmCapabilityTimeUnitTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PbmCapabilityTimeUnitTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PBM_COMPLIANCE_STATUS_ENUM_MAP: phf::Map<&'static str, PbmComplianceStatusEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("nonCompliant", PbmComplianceStatusEnum::NonCompliant),
        ("compliant", PbmComplianceStatusEnum::Compliant),
        ("outOfDate", PbmComplianceStatusEnum::OutOfDate),
        ("notApplicable", PbmComplianceStatusEnum::NotApplicable),
        ("unknown", PbmComplianceStatusEnum::Unknown),
    ],
};

impl PbmComplianceStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PbmComplianceStatusEnum::Compliant => "compliant",
            PbmComplianceStatusEnum::NonCompliant => "nonCompliant",
            PbmComplianceStatusEnum::Unknown => "unknown",
            PbmComplianceStatusEnum::NotApplicable => "notApplicable",
            PbmComplianceStatusEnum::OutOfDate => "outOfDate",
            PbmComplianceStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PBM_COMPLIANCE_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PbmComplianceStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PbmComplianceStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PbmComplianceStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PbmComplianceStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PbmComplianceStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PbmComplianceStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PbmComplianceStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PbmComplianceStatusEnum> for &'a str {
    fn from(value: &'a PbmComplianceStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PbmComplianceStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PBM_COMPLIANCE_RESULT_COMPLIANCE_TASK_STATUS_ENUM_MAP: phf::Map<&'static str, PbmComplianceResultComplianceTaskStatusEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("inProgress", PbmComplianceResultComplianceTaskStatusEnum::InProgress),
        ("success", PbmComplianceResultComplianceTaskStatusEnum::Success),
        ("failed", PbmComplianceResultComplianceTaskStatusEnum::Failed),
    ],
};

impl PbmComplianceResultComplianceTaskStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PbmComplianceResultComplianceTaskStatusEnum::InProgress => "inProgress",
            PbmComplianceResultComplianceTaskStatusEnum::Success => "success",
            PbmComplianceResultComplianceTaskStatusEnum::Failed => "failed",
            PbmComplianceResultComplianceTaskStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PBM_COMPLIANCE_RESULT_COMPLIANCE_TASK_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PbmComplianceResultComplianceTaskStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PbmComplianceResultComplianceTaskStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PbmComplianceResultComplianceTaskStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PbmComplianceResultComplianceTaskStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PbmComplianceResultComplianceTaskStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PbmComplianceResultComplianceTaskStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PbmComplianceResultComplianceTaskStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PbmComplianceResultComplianceTaskStatusEnum> for &'a str {
    fn from(value: &'a PbmComplianceResultComplianceTaskStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PbmComplianceResultComplianceTaskStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PBM_HEALTH_STATUS_FOR_ENTITY_ENUM_MAP: phf::Map<&'static str, PbmHealthStatusForEntityEnum> = ::phf::Map {
    key: 351906021642186605,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("red", PbmHealthStatusForEntityEnum::Red),
        ("yellow", PbmHealthStatusForEntityEnum::Yellow),
        ("unknown", PbmHealthStatusForEntityEnum::Unknown),
        ("green", PbmHealthStatusForEntityEnum::Green),
    ],
};

impl PbmHealthStatusForEntityEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PbmHealthStatusForEntityEnum::Red => "red",
            PbmHealthStatusForEntityEnum::Yellow => "yellow",
            PbmHealthStatusForEntityEnum::Green => "green",
            PbmHealthStatusForEntityEnum::Unknown => "unknown",
            PbmHealthStatusForEntityEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PBM_HEALTH_STATUS_FOR_ENTITY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PbmHealthStatusForEntityEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PbmHealthStatusForEntityEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PbmHealthStatusForEntityEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PbmHealthStatusForEntityEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PbmHealthStatusForEntityEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PbmHealthStatusForEntityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PbmHealthStatusForEntityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PbmHealthStatusForEntityEnum> for &'a str {
    fn from(value: &'a PbmHealthStatusForEntityEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PbmHealthStatusForEntityEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PBM_ASSOCIATE_AND_APPLY_POLICY_STATUS_POLICY_STATUS_ENUM_MAP: phf::Map<&'static str, PbmAssociateAndApplyPolicyStatusPolicyStatusEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("invalid", PbmAssociateAndApplyPolicyStatusPolicyStatusEnum::Invalid),
        ("success", PbmAssociateAndApplyPolicyStatusPolicyStatusEnum::Success),
        ("failed", PbmAssociateAndApplyPolicyStatusPolicyStatusEnum::Failed),
    ],
};

impl PbmAssociateAndApplyPolicyStatusPolicyStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PbmAssociateAndApplyPolicyStatusPolicyStatusEnum::Success => "success",
            PbmAssociateAndApplyPolicyStatusPolicyStatusEnum::Failed => "failed",
            PbmAssociateAndApplyPolicyStatusPolicyStatusEnum::Invalid => "invalid",
            PbmAssociateAndApplyPolicyStatusPolicyStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PBM_ASSOCIATE_AND_APPLY_POLICY_STATUS_POLICY_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PbmAssociateAndApplyPolicyStatusPolicyStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PbmAssociateAndApplyPolicyStatusPolicyStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PbmAssociateAndApplyPolicyStatusPolicyStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PbmAssociateAndApplyPolicyStatusPolicyStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PbmAssociateAndApplyPolicyStatusPolicyStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PbmAssociateAndApplyPolicyStatusPolicyStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PbmAssociateAndApplyPolicyStatusPolicyStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PbmAssociateAndApplyPolicyStatusPolicyStatusEnum> for &'a str {
    fn from(value: &'a PbmAssociateAndApplyPolicyStatusPolicyStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PbmAssociateAndApplyPolicyStatusPolicyStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PBM_PROFILE_CATEGORY_ENUM_ENUM_MAP: phf::Map<&'static str, PbmProfileCategoryEnumEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("REQUIREMENT", PbmProfileCategoryEnumEnum::Requirement),
        ("DATA_SERVICE_POLICY", PbmProfileCategoryEnumEnum::DataServicePolicy),
        ("RESOURCE", PbmProfileCategoryEnumEnum::Resource),
    ],
};

impl PbmProfileCategoryEnumEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PbmProfileCategoryEnumEnum::Requirement => "REQUIREMENT",
            PbmProfileCategoryEnumEnum::Resource => "RESOURCE",
            PbmProfileCategoryEnumEnum::DataServicePolicy => "DATA_SERVICE_POLICY",
            PbmProfileCategoryEnumEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PBM_PROFILE_CATEGORY_ENUM_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PbmProfileCategoryEnumEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PbmProfileCategoryEnumEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PbmProfileCategoryEnumEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PbmProfileCategoryEnumEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PbmProfileCategoryEnumEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PbmProfileCategoryEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PbmProfileCategoryEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PbmProfileCategoryEnumEnum> for &'a str {
    fn from(value: &'a PbmProfileCategoryEnumEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PbmProfileCategoryEnumEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PBM_SYSTEM_CREATED_PROFILE_TYPE_ENUM_MAP: phf::Map<&'static str, PbmSystemCreatedProfileTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (3, 0),
    ],
    entries: &[
        ("PmemDefaultProfile", PbmSystemCreatedProfileTypeEnum::PmemDefaultProfile),
        ("VVolDefaultProfile", PbmSystemCreatedProfileTypeEnum::VVolDefaultProfile),
        ("VmcManagementProfile", PbmSystemCreatedProfileTypeEnum::VmcManagementProfile),
        ("VsanDefaultProfile", PbmSystemCreatedProfileTypeEnum::VsanDefaultProfile),
        ("VsanMaxDefaultProfile", PbmSystemCreatedProfileTypeEnum::VsanMaxDefaultProfile),
    ],
};

impl PbmSystemCreatedProfileTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PbmSystemCreatedProfileTypeEnum::VsanDefaultProfile => "VsanDefaultProfile",
            PbmSystemCreatedProfileTypeEnum::VVolDefaultProfile => "VVolDefaultProfile",
            PbmSystemCreatedProfileTypeEnum::PmemDefaultProfile => "PmemDefaultProfile",
            PbmSystemCreatedProfileTypeEnum::VmcManagementProfile => "VmcManagementProfile",
            PbmSystemCreatedProfileTypeEnum::VsanMaxDefaultProfile => "VsanMaxDefaultProfile",
            PbmSystemCreatedProfileTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PBM_SYSTEM_CREATED_PROFILE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PbmSystemCreatedProfileTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PbmSystemCreatedProfileTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PbmSystemCreatedProfileTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PbmSystemCreatedProfileTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PbmSystemCreatedProfileTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PbmSystemCreatedProfileTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PbmSystemCreatedProfileTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PbmSystemCreatedProfileTypeEnum> for &'a str {
    fn from(value: &'a PbmSystemCreatedProfileTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PbmSystemCreatedProfileTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PBM_OPERATION_ENUM_MAP: phf::Map<&'static str, PbmOperationEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("RECONFIGURE", PbmOperationEnum::Reconfigure),
        ("CREATE", PbmOperationEnum::Create),
        ("MIGRATE", PbmOperationEnum::Migrate),
        ("CLONE", PbmOperationEnum::Clone),
        ("REGISTER", PbmOperationEnum::Register),
    ],
};

impl PbmOperationEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PbmOperationEnum::Create => "CREATE",
            PbmOperationEnum::Register => "REGISTER",
            PbmOperationEnum::Reconfigure => "RECONFIGURE",
            PbmOperationEnum::Migrate => "MIGRATE",
            PbmOperationEnum::Clone => "CLONE",
            PbmOperationEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PBM_OPERATION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PbmOperationEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PbmOperationEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PbmOperationEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PbmOperationEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PbmOperationEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PbmOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PbmOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PbmOperationEnum> for &'a str {
    fn from(value: &'a PbmOperationEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PbmOperationEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PBM_IOFILTER_INFO_FILTER_TYPE_ENUM_MAP: phf::Map<&'static str, PbmIofilterInfoFilterTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (4, 0),
        (3, 0),
    ],
    entries: &[
        ("CACHE", PbmIofilterInfoFilterTypeEnum::Cache),
        ("DATASTOREIOCONTROL", PbmIofilterInfoFilterTypeEnum::Datastoreiocontrol),
        ("INSPECTION", PbmIofilterInfoFilterTypeEnum::Inspection),
        ("COMPRESSION", PbmIofilterInfoFilterTypeEnum::Compression),
        ("DATAPROVIDER", PbmIofilterInfoFilterTypeEnum::Dataprovider),
        ("REPLICATION", PbmIofilterInfoFilterTypeEnum::Replication),
        ("ENCRYPTION", PbmIofilterInfoFilterTypeEnum::Encryption),
    ],
};

impl PbmIofilterInfoFilterTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PbmIofilterInfoFilterTypeEnum::Inspection => "INSPECTION",
            PbmIofilterInfoFilterTypeEnum::Compression => "COMPRESSION",
            PbmIofilterInfoFilterTypeEnum::Encryption => "ENCRYPTION",
            PbmIofilterInfoFilterTypeEnum::Replication => "REPLICATION",
            PbmIofilterInfoFilterTypeEnum::Cache => "CACHE",
            PbmIofilterInfoFilterTypeEnum::Dataprovider => "DATAPROVIDER",
            PbmIofilterInfoFilterTypeEnum::Datastoreiocontrol => "DATASTOREIOCONTROL",
            PbmIofilterInfoFilterTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PBM_IOFILTER_INFO_FILTER_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PbmIofilterInfoFilterTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PbmIofilterInfoFilterTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PbmIofilterInfoFilterTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PbmIofilterInfoFilterTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PbmIofilterInfoFilterTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PbmIofilterInfoFilterTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PbmIofilterInfoFilterTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PbmIofilterInfoFilterTypeEnum> for &'a str {
    fn from(value: &'a PbmIofilterInfoFilterTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PbmIofilterInfoFilterTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PBM_POLICY_ASSOCIATION_VOLUME_ALLOCATION_TYPE_ENUM_MAP: phf::Map<&'static str, PbmPolicyAssociationVolumeAllocationTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("FullyInitialized", PbmPolicyAssociationVolumeAllocationTypeEnum::FullyInitialized),
        ("ConserveSpaceWhenPossible", PbmPolicyAssociationVolumeAllocationTypeEnum::ConserveSpaceWhenPossible),
        ("ReserveSpace", PbmPolicyAssociationVolumeAllocationTypeEnum::ReserveSpace),
    ],
};

impl PbmPolicyAssociationVolumeAllocationTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PbmPolicyAssociationVolumeAllocationTypeEnum::FullyInitialized => "FullyInitialized",
            PbmPolicyAssociationVolumeAllocationTypeEnum::ReserveSpace => "ReserveSpace",
            PbmPolicyAssociationVolumeAllocationTypeEnum::ConserveSpaceWhenPossible => "ConserveSpaceWhenPossible",
            PbmPolicyAssociationVolumeAllocationTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PBM_POLICY_ASSOCIATION_VOLUME_ALLOCATION_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PbmPolicyAssociationVolumeAllocationTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PbmPolicyAssociationVolumeAllocationTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PbmPolicyAssociationVolumeAllocationTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PbmPolicyAssociationVolumeAllocationTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PbmPolicyAssociationVolumeAllocationTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PbmPolicyAssociationVolumeAllocationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PbmPolicyAssociationVolumeAllocationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PbmPolicyAssociationVolumeAllocationTypeEnum> for &'a str {
    fn from(value: &'a PbmPolicyAssociationVolumeAllocationTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PbmPolicyAssociationVolumeAllocationTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PBM_PROFILE_RESOURCE_TYPE_ENUM_ENUM_MAP: phf::Map<&'static str, PbmProfileResourceTypeEnumEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("STORAGE", PbmProfileResourceTypeEnumEnum::Storage),
    ],
};

impl PbmProfileResourceTypeEnumEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PbmProfileResourceTypeEnumEnum::Storage => "STORAGE",
            PbmProfileResourceTypeEnumEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PBM_PROFILE_RESOURCE_TYPE_ENUM_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PbmProfileResourceTypeEnumEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PbmProfileResourceTypeEnumEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PbmProfileResourceTypeEnumEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PbmProfileResourceTypeEnumEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PbmProfileResourceTypeEnumEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PbmProfileResourceTypeEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PbmProfileResourceTypeEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PbmProfileResourceTypeEnumEnum> for &'a str {
    fn from(value: &'a PbmProfileResourceTypeEnumEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PbmProfileResourceTypeEnumEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PBM_VM_OPERATION_ENUM_MAP: phf::Map<&'static str, PbmVmOperationEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("CLONE", PbmVmOperationEnum::Clone),
        ("MIGRATE", PbmVmOperationEnum::Migrate),
        ("RECONFIGURE", PbmVmOperationEnum::Reconfigure),
        ("CREATE", PbmVmOperationEnum::Create),
    ],
};

impl PbmVmOperationEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PbmVmOperationEnum::Create => "CREATE",
            PbmVmOperationEnum::Reconfigure => "RECONFIGURE",
            PbmVmOperationEnum::Migrate => "MIGRATE",
            PbmVmOperationEnum::Clone => "CLONE",
            PbmVmOperationEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PBM_VM_OPERATION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PbmVmOperationEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PbmVmOperationEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PbmVmOperationEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PbmVmOperationEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PbmVmOperationEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PbmVmOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PbmVmOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PbmVmOperationEnum> for &'a str {
    fn from(value: &'a PbmVmOperationEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PbmVmOperationEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static ENTITY_REFERENCE_ENTITY_TYPE_ENUM_MAP: phf::Map<&'static str, EntityReferenceEntityTypeEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (4, 0),
        (6, 12),
        (3, 3),
    ],
    entries: &[
        ("scsiAdapter", EntityReferenceEntityTypeEnum::ScsiAdapter),
        ("vm", EntityReferenceEntityTypeEnum::Vm),
        ("storagePod", EntityReferenceEntityTypeEnum::StoragePod),
        ("scsiVolume", EntityReferenceEntityTypeEnum::ScsiVolume),
        ("datastore", EntityReferenceEntityTypeEnum::Datastore),
        ("scsiTarget", EntityReferenceEntityTypeEnum::ScsiTarget),
        ("scsiPath", EntityReferenceEntityTypeEnum::ScsiPath),
        ("cluster", EntityReferenceEntityTypeEnum::Cluster),
        ("nasMount", EntityReferenceEntityTypeEnum::NasMount),
        ("resourcePool", EntityReferenceEntityTypeEnum::ResourcePool),
        ("vmFile", EntityReferenceEntityTypeEnum::VmFile),
        ("host", EntityReferenceEntityTypeEnum::Host),
        ("datacenter", EntityReferenceEntityTypeEnum::Datacenter),
    ],
};

impl EntityReferenceEntityTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            EntityReferenceEntityTypeEnum::Datacenter => "datacenter",
            EntityReferenceEntityTypeEnum::ResourcePool => "resourcePool",
            EntityReferenceEntityTypeEnum::StoragePod => "storagePod",
            EntityReferenceEntityTypeEnum::Cluster => "cluster",
            EntityReferenceEntityTypeEnum::Vm => "vm",
            EntityReferenceEntityTypeEnum::Datastore => "datastore",
            EntityReferenceEntityTypeEnum::Host => "host",
            EntityReferenceEntityTypeEnum::VmFile => "vmFile",
            EntityReferenceEntityTypeEnum::ScsiPath => "scsiPath",
            EntityReferenceEntityTypeEnum::ScsiTarget => "scsiTarget",
            EntityReferenceEntityTypeEnum::ScsiVolume => "scsiVolume",
            EntityReferenceEntityTypeEnum::ScsiAdapter => "scsiAdapter",
            EntityReferenceEntityTypeEnum::NasMount => "nasMount",
            EntityReferenceEntityTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        ENTITY_REFERENCE_ENTITY_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| EntityReferenceEntityTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for EntityReferenceEntityTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for EntityReferenceEntityTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<EntityReferenceEntityTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(EntityReferenceEntityTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for EntityReferenceEntityTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for EntityReferenceEntityTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a EntityReferenceEntityTypeEnum> for &'a str {
    fn from(value: &'a EntityReferenceEntityTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for EntityReferenceEntityTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static SMS_TASK_STATE_ENUM_MAP: phf::Map<&'static str, SmsTaskStateEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("running", SmsTaskStateEnum::Running),
        ("error", SmsTaskStateEnum::Error),
        ("success", SmsTaskStateEnum::Success),
        ("queued", SmsTaskStateEnum::Queued),
    ],
};

impl SmsTaskStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            SmsTaskStateEnum::Queued => "queued",
            SmsTaskStateEnum::Running => "running",
            SmsTaskStateEnum::Success => "success",
            SmsTaskStateEnum::Error => "error",
            SmsTaskStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        SMS_TASK_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| SmsTaskStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for SmsTaskStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for SmsTaskStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<SmsTaskStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(SmsTaskStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for SmsTaskStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for SmsTaskStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a SmsTaskStateEnum> for &'a str {
    fn from(value: &'a SmsTaskStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for SmsTaskStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VP_CATEGORY_ENUM_MAP: phf::Map<&'static str, VpCategoryEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("internal", VpCategoryEnum::Internal),
        ("external", VpCategoryEnum::External),
    ],
};

impl VpCategoryEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VpCategoryEnum::Internal => "internal",
            VpCategoryEnum::External => "external",
            VpCategoryEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VP_CATEGORY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VpCategoryEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VpCategoryEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VpCategoryEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VpCategoryEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VpCategoryEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VpCategoryEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VpCategoryEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VpCategoryEnum> for &'a str {
    fn from(value: &'a VpCategoryEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VpCategoryEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VASA_PROVIDER_CERTIFICATE_STATUS_ENUM_MAP: phf::Map<&'static str, VasaProviderCertificateStatusEnum> = ::phf::Map {
    key: 8694567506910003252,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("expiryHardLimitReached", VasaProviderCertificateStatusEnum::ExpiryHardLimitReached),
        ("expirySoftLimitReached", VasaProviderCertificateStatusEnum::ExpirySoftLimitReached),
        ("valid", VasaProviderCertificateStatusEnum::Valid),
        ("expired", VasaProviderCertificateStatusEnum::Expired),
        ("invalid", VasaProviderCertificateStatusEnum::Invalid),
    ],
};

impl VasaProviderCertificateStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VasaProviderCertificateStatusEnum::Valid => "valid",
            VasaProviderCertificateStatusEnum::ExpirySoftLimitReached => "expirySoftLimitReached",
            VasaProviderCertificateStatusEnum::ExpiryHardLimitReached => "expiryHardLimitReached",
            VasaProviderCertificateStatusEnum::Expired => "expired",
            VasaProviderCertificateStatusEnum::Invalid => "invalid",
            VasaProviderCertificateStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VASA_PROVIDER_CERTIFICATE_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VasaProviderCertificateStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VasaProviderCertificateStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VasaProviderCertificateStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VasaProviderCertificateStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VasaProviderCertificateStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VasaProviderCertificateStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VasaProviderCertificateStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VasaProviderCertificateStatusEnum> for &'a str {
    fn from(value: &'a VasaProviderCertificateStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VasaProviderCertificateStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PROVIDER_PROFILE_ENUM_MAP: phf::Map<&'static str, ProviderProfileEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("Replication", ProviderProfileEnum::Replication),
        ("ProfileBasedManagement", ProviderProfileEnum::ProfileBasedManagement),
    ],
};

impl ProviderProfileEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ProviderProfileEnum::ProfileBasedManagement => "ProfileBasedManagement",
            ProviderProfileEnum::Replication => "Replication",
            ProviderProfileEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PROVIDER_PROFILE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ProviderProfileEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ProviderProfileEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ProviderProfileEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ProviderProfileEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ProviderProfileEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ProviderProfileEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ProviderProfileEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ProviderProfileEnum> for &'a str {
    fn from(value: &'a ProviderProfileEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ProviderProfileEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VP_TYPE_ENUM_MAP: phf::Map<&'static str, VpTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("DATASERVICE", VpTypeEnum::Dataservice),
        ("PERSISTENCE", VpTypeEnum::Persistence),
        ("UNKNOWN", VpTypeEnum::Unknown),
    ],
};

impl VpTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VpTypeEnum::Persistence => "PERSISTENCE",
            VpTypeEnum::Dataservice => "DATASERVICE",
            VpTypeEnum::Unknown => "UNKNOWN",
            VpTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VP_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VpTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VpTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VpTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VpTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VpTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VpTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VpTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VpTypeEnum> for &'a str {
    fn from(value: &'a VpTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VpTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VASA_PROVIDER_PROFILE_ENUM_MAP: phf::Map<&'static str, VasaProviderProfileEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("blockDevice", VasaProviderProfileEnum::BlockDevice),
        ("fileSystem", VasaProviderProfileEnum::FileSystem),
        ("capability", VasaProviderProfileEnum::Capability),
    ],
};

impl VasaProviderProfileEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VasaProviderProfileEnum::BlockDevice => "blockDevice",
            VasaProviderProfileEnum::FileSystem => "fileSystem",
            VasaProviderProfileEnum::Capability => "capability",
            VasaProviderProfileEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VASA_PROVIDER_PROFILE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VasaProviderProfileEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VasaProviderProfileEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VasaProviderProfileEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VasaProviderProfileEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VasaProviderProfileEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VasaProviderProfileEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VasaProviderProfileEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VasaProviderProfileEnum> for &'a str {
    fn from(value: &'a VasaProviderProfileEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VasaProviderProfileEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VASA_PROVIDER_STATUS_ENUM_MAP: phf::Map<&'static str, VasaProviderStatusEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
        (0, 5),
    ],
    entries: &[
        ("disconnected", VasaProviderStatusEnum::Disconnected),
        ("syncError", VasaProviderStatusEnum::SyncError),
        ("offline", VasaProviderStatusEnum::Offline),
        ("online", VasaProviderStatusEnum::Online),
        ("unknown", VasaProviderStatusEnum::Unknown),
        ("connected", VasaProviderStatusEnum::Connected),
    ],
};

impl VasaProviderStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VasaProviderStatusEnum::Online => "online",
            VasaProviderStatusEnum::Offline => "offline",
            VasaProviderStatusEnum::SyncError => "syncError",
            VasaProviderStatusEnum::Unknown => "unknown",
            VasaProviderStatusEnum::Connected => "connected",
            VasaProviderStatusEnum::Disconnected => "disconnected",
            VasaProviderStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VASA_PROVIDER_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VasaProviderStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VasaProviderStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VasaProviderStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VasaProviderStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VasaProviderStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VasaProviderStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VasaProviderStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VasaProviderStatusEnum> for &'a str {
    fn from(value: &'a VasaProviderStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VasaProviderStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VASA_AUTHENTICATION_TYPE_ENUM_MAP: phf::Map<&'static str, VasaAuthenticationTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("UseSessionId", VasaAuthenticationTypeEnum::UseSessionId),
        ("LoginByToken", VasaAuthenticationTypeEnum::LoginByToken),
    ],
};

impl VasaAuthenticationTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VasaAuthenticationTypeEnum::LoginByToken => "LoginByToken",
            VasaAuthenticationTypeEnum::UseSessionId => "UseSessionId",
            VasaAuthenticationTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VASA_AUTHENTICATION_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VasaAuthenticationTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VasaAuthenticationTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VasaAuthenticationTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VasaAuthenticationTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VasaAuthenticationTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VasaAuthenticationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VasaAuthenticationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VasaAuthenticationTypeEnum> for &'a str {
    fn from(value: &'a VasaAuthenticationTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VasaAuthenticationTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static SMS_ALARM_STATUS_ENUM_MAP: phf::Map<&'static str, SmsAlarmStatusEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("Red", SmsAlarmStatusEnum::Red),
        ("Yellow", SmsAlarmStatusEnum::Yellow),
        ("Green", SmsAlarmStatusEnum::Green),
    ],
};

impl SmsAlarmStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            SmsAlarmStatusEnum::Red => "Red",
            SmsAlarmStatusEnum::Green => "Green",
            SmsAlarmStatusEnum::Yellow => "Yellow",
            SmsAlarmStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        SMS_ALARM_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| SmsAlarmStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for SmsAlarmStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for SmsAlarmStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<SmsAlarmStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(SmsAlarmStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for SmsAlarmStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for SmsAlarmStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a SmsAlarmStatusEnum> for &'a str {
    fn from(value: &'a SmsAlarmStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for SmsAlarmStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static ALARM_TYPE_ENUM_MAP: phf::Map<&'static str, AlarmTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
        (5, 5),
    ],
    entries: &[
        ("CapabilityAlarm", AlarmTypeEnum::CapabilityAlarm),
        ("SpaceCapacityAlarm", AlarmTypeEnum::SpaceCapacityAlarm),
        ("CertificateAlarm", AlarmTypeEnum::CertificateAlarm),
        ("ObjectAlarm", AlarmTypeEnum::ObjectAlarm),
        ("ComplianceAlarm", AlarmTypeEnum::ComplianceAlarm),
        ("ManageabilityAlarm", AlarmTypeEnum::ManageabilityAlarm),
        ("StorageObjectAlarm", AlarmTypeEnum::StorageObjectAlarm),
        ("ReplicationAlarm", AlarmTypeEnum::ReplicationAlarm),
    ],
};

impl AlarmTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            AlarmTypeEnum::SpaceCapacityAlarm => "SpaceCapacityAlarm",
            AlarmTypeEnum::CapabilityAlarm => "CapabilityAlarm",
            AlarmTypeEnum::StorageObjectAlarm => "StorageObjectAlarm",
            AlarmTypeEnum::ObjectAlarm => "ObjectAlarm",
            AlarmTypeEnum::ComplianceAlarm => "ComplianceAlarm",
            AlarmTypeEnum::ManageabilityAlarm => "ManageabilityAlarm",
            AlarmTypeEnum::ReplicationAlarm => "ReplicationAlarm",
            AlarmTypeEnum::CertificateAlarm => "CertificateAlarm",
            AlarmTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        ALARM_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| AlarmTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for AlarmTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for AlarmTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<AlarmTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(AlarmTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for AlarmTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for AlarmTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a AlarmTypeEnum> for &'a str {
    fn from(value: &'a AlarmTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for AlarmTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static BACKING_STORAGE_POOL_TYPE_ENUM_MAP: phf::Map<&'static str, BackingStoragePoolTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("deduplicationPool", BackingStoragePoolTypeEnum::DeduplicationPool),
        ("thinAndDeduplicationCombinedPool", BackingStoragePoolTypeEnum::ThinAndDeduplicationCombinedPool),
        ("thinProvisioningPool", BackingStoragePoolTypeEnum::ThinProvisioningPool),
    ],
};

impl BackingStoragePoolTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            BackingStoragePoolTypeEnum::ThinProvisioningPool => "thinProvisioningPool",
            BackingStoragePoolTypeEnum::DeduplicationPool => "deduplicationPool",
            BackingStoragePoolTypeEnum::ThinAndDeduplicationCombinedPool => "thinAndDeduplicationCombinedPool",
            BackingStoragePoolTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        BACKING_STORAGE_POOL_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| BackingStoragePoolTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for BackingStoragePoolTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for BackingStoragePoolTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<BackingStoragePoolTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(BackingStoragePoolTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for BackingStoragePoolTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for BackingStoragePoolTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a BackingStoragePoolTypeEnum> for &'a str {
    fn from(value: &'a BackingStoragePoolTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for BackingStoragePoolTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static SMS_ENTITY_TYPE_ENUM_MAP: phf::Map<&'static str, SmsEntityTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 1),
        (2, 0),
        (1, 1),
        (0, 9),
    ],
    entries: &[
        ("ProtocolEndpointEntity", SmsEntityTypeEnum::ProtocolEndpointEntity),
        ("StorageProcessorEntity", SmsEntityTypeEnum::StorageProcessorEntity),
        ("ResourceAssociationEntity", SmsEntityTypeEnum::ResourceAssociationEntity),
        ("StorageCapabilityEntity", SmsEntityTypeEnum::StorageCapabilityEntity),
        ("StorageObjectEntity", SmsEntityTypeEnum::StorageObjectEntity),
        ("StorageContainerEntity", SmsEntityTypeEnum::StorageContainerEntity),
        ("StoragePortEntity", SmsEntityTypeEnum::StoragePortEntity),
        ("ReplicationGroupEntity", SmsEntityTypeEnum::ReplicationGroupEntity),
        ("StorageLunEntity", SmsEntityTypeEnum::StorageLunEntity),
        ("BackingStoragePoolEntity", SmsEntityTypeEnum::BackingStoragePoolEntity),
        ("DefaultProfileEntity", SmsEntityTypeEnum::DefaultProfileEntity),
        ("StorageFileSystemEntity", SmsEntityTypeEnum::StorageFileSystemEntity),
        ("VirtualVolumeInfoEntity", SmsEntityTypeEnum::VirtualVolumeInfoEntity),
        ("CapabilitySchemaEntity", SmsEntityTypeEnum::CapabilitySchemaEntity),
        ("FaultDomainEntity", SmsEntityTypeEnum::FaultDomainEntity),
        ("CapabilityProfileEntity", SmsEntityTypeEnum::CapabilityProfileEntity),
        ("StorageArrayEntity", SmsEntityTypeEnum::StorageArrayEntity),
        ("MessageCatalogEntity", SmsEntityTypeEnum::MessageCatalogEntity),
    ],
};

impl SmsEntityTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            SmsEntityTypeEnum::StorageArrayEntity => "StorageArrayEntity",
            SmsEntityTypeEnum::StorageProcessorEntity => "StorageProcessorEntity",
            SmsEntityTypeEnum::StoragePortEntity => "StoragePortEntity",
            SmsEntityTypeEnum::StorageLunEntity => "StorageLunEntity",
            SmsEntityTypeEnum::StorageFileSystemEntity => "StorageFileSystemEntity",
            SmsEntityTypeEnum::StorageCapabilityEntity => "StorageCapabilityEntity",
            SmsEntityTypeEnum::CapabilitySchemaEntity => "CapabilitySchemaEntity",
            SmsEntityTypeEnum::CapabilityProfileEntity => "CapabilityProfileEntity",
            SmsEntityTypeEnum::DefaultProfileEntity => "DefaultProfileEntity",
            SmsEntityTypeEnum::ResourceAssociationEntity => "ResourceAssociationEntity",
            SmsEntityTypeEnum::StorageContainerEntity => "StorageContainerEntity",
            SmsEntityTypeEnum::StorageObjectEntity => "StorageObjectEntity",
            SmsEntityTypeEnum::MessageCatalogEntity => "MessageCatalogEntity",
            SmsEntityTypeEnum::ProtocolEndpointEntity => "ProtocolEndpointEntity",
            SmsEntityTypeEnum::VirtualVolumeInfoEntity => "VirtualVolumeInfoEntity",
            SmsEntityTypeEnum::BackingStoragePoolEntity => "BackingStoragePoolEntity",
            SmsEntityTypeEnum::FaultDomainEntity => "FaultDomainEntity",
            SmsEntityTypeEnum::ReplicationGroupEntity => "ReplicationGroupEntity",
            SmsEntityTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        SMS_ENTITY_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| SmsEntityTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for SmsEntityTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for SmsEntityTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<SmsEntityTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(SmsEntityTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for SmsEntityTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for SmsEntityTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a SmsEntityTypeEnum> for &'a str {
    fn from(value: &'a SmsEntityTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for SmsEntityTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static BLOCK_DEVICE_INTERFACE_ENUM_MAP: phf::Map<&'static str, BlockDeviceInterfaceEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("fcoe", BlockDeviceInterfaceEnum::Fcoe),
        ("fc", BlockDeviceInterfaceEnum::Fc),
        ("otherBlock", BlockDeviceInterfaceEnum::OtherBlock),
        ("iscsi", BlockDeviceInterfaceEnum::Iscsi),
    ],
};

impl BlockDeviceInterfaceEnum {
    pub fn as_str(&self) -> &str {
        match self {
            BlockDeviceInterfaceEnum::Fc => "fc",
            BlockDeviceInterfaceEnum::Iscsi => "iscsi",
            BlockDeviceInterfaceEnum::Fcoe => "fcoe",
            BlockDeviceInterfaceEnum::OtherBlock => "otherBlock",
            BlockDeviceInterfaceEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        BLOCK_DEVICE_INTERFACE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| BlockDeviceInterfaceEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for BlockDeviceInterfaceEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for BlockDeviceInterfaceEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<BlockDeviceInterfaceEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(BlockDeviceInterfaceEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for BlockDeviceInterfaceEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for BlockDeviceInterfaceEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a BlockDeviceInterfaceEnum> for &'a str {
    fn from(value: &'a BlockDeviceInterfaceEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for BlockDeviceInterfaceEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static FILE_SYSTEM_INTERFACE_ENUM_MAP: phf::Map<&'static str, FileSystemInterfaceEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("nfs", FileSystemInterfaceEnum::Nfs),
        ("otherFileSystem", FileSystemInterfaceEnum::OtherFileSystem),
    ],
};

impl FileSystemInterfaceEnum {
    pub fn as_str(&self) -> &str {
        match self {
            FileSystemInterfaceEnum::Nfs => "nfs",
            FileSystemInterfaceEnum::OtherFileSystem => "otherFileSystem",
            FileSystemInterfaceEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        FILE_SYSTEM_INTERFACE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| FileSystemInterfaceEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for FileSystemInterfaceEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for FileSystemInterfaceEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<FileSystemInterfaceEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(FileSystemInterfaceEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for FileSystemInterfaceEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for FileSystemInterfaceEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a FileSystemInterfaceEnum> for &'a str {
    fn from(value: &'a FileSystemInterfaceEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for FileSystemInterfaceEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VASA_PROFILE_ENUM_MAP: phf::Map<&'static str, VasaProfileEnum> = ::phf::Map {
    key: 14108922650502679131,
    disps: &[
        (4, 3),
        (6, 0),
    ],
    entries: &[
        ("policy", VasaProfileEnum::Policy),
        ("capability", VasaProfileEnum::Capability),
        ("object", VasaProfileEnum::Object),
        ("fileSystem", VasaProfileEnum::FileSystem),
        ("storageDrsFileSystem", VasaProfileEnum::StorageDrsFileSystem),
        ("statistics", VasaProfileEnum::Statistics),
        ("storageDrsBlockDevice", VasaProfileEnum::StorageDrsBlockDevice),
        ("blockDevice", VasaProfileEnum::BlockDevice),
    ],
};

impl VasaProfileEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VasaProfileEnum::BlockDevice => "blockDevice",
            VasaProfileEnum::FileSystem => "fileSystem",
            VasaProfileEnum::Capability => "capability",
            VasaProfileEnum::Policy => "policy",
            VasaProfileEnum::Object => "object",
            VasaProfileEnum::Statistics => "statistics",
            VasaProfileEnum::StorageDrsBlockDevice => "storageDrsBlockDevice",
            VasaProfileEnum::StorageDrsFileSystem => "storageDrsFileSystem",
            VasaProfileEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VASA_PROFILE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VasaProfileEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VasaProfileEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VasaProfileEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VasaProfileEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VasaProfileEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VasaProfileEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VasaProfileEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VasaProfileEnum> for &'a str {
    fn from(value: &'a VasaProfileEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VasaProfileEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static STORAGE_CONTAINER_VVOL_CONTAINER_TYPE_ENUM_ENUM_MAP: phf::Map<&'static str, StorageContainerVvolContainerTypeEnumEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("NFS4x", StorageContainerVvolContainerTypeEnumEnum::Nfs4X),
        ("NVMe", StorageContainerVvolContainerTypeEnumEnum::NvMe),
        ("SCSI", StorageContainerVvolContainerTypeEnumEnum::Scsi),
        ("NFS", StorageContainerVvolContainerTypeEnumEnum::Nfs),
    ],
};

impl StorageContainerVvolContainerTypeEnumEnum {
    pub fn as_str(&self) -> &str {
        match self {
            StorageContainerVvolContainerTypeEnumEnum::Nfs => "NFS",
            StorageContainerVvolContainerTypeEnumEnum::Nfs4X => "NFS4x",
            StorageContainerVvolContainerTypeEnumEnum::Scsi => "SCSI",
            StorageContainerVvolContainerTypeEnumEnum::NvMe => "NVMe",
            StorageContainerVvolContainerTypeEnumEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        STORAGE_CONTAINER_VVOL_CONTAINER_TYPE_ENUM_ENUM_MAP.get(s).cloned().unwrap_or_else(|| StorageContainerVvolContainerTypeEnumEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for StorageContainerVvolContainerTypeEnumEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for StorageContainerVvolContainerTypeEnumEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<StorageContainerVvolContainerTypeEnumEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(StorageContainerVvolContainerTypeEnumEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for StorageContainerVvolContainerTypeEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for StorageContainerVvolContainerTypeEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a StorageContainerVvolContainerTypeEnumEnum> for &'a str {
    fn from(value: &'a StorageContainerVvolContainerTypeEnumEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for StorageContainerVvolContainerTypeEnumEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static FILE_SYSTEM_INTERFACE_VERSION_ENUM_MAP: phf::Map<&'static str, FileSystemInterfaceVersionEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("NFSV3_0", FileSystemInterfaceVersionEnum::Nfsv30),
    ],
};

impl FileSystemInterfaceVersionEnum {
    pub fn as_str(&self) -> &str {
        match self {
            FileSystemInterfaceVersionEnum::Nfsv30 => "NFSV3_0",
            FileSystemInterfaceVersionEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        FILE_SYSTEM_INTERFACE_VERSION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| FileSystemInterfaceVersionEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for FileSystemInterfaceVersionEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for FileSystemInterfaceVersionEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<FileSystemInterfaceVersionEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(FileSystemInterfaceVersionEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for FileSystemInterfaceVersionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for FileSystemInterfaceVersionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a FileSystemInterfaceVersionEnum> for &'a str {
    fn from(value: &'a FileSystemInterfaceVersionEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for FileSystemInterfaceVersionEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static THIN_PROVISIONING_STATUS_ENUM_MAP: phf::Map<&'static str, ThinProvisioningStatusEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("YELLOW", ThinProvisioningStatusEnum::Yellow),
        ("RED", ThinProvisioningStatusEnum::Red),
        ("GREEN", ThinProvisioningStatusEnum::Green),
    ],
};

impl ThinProvisioningStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ThinProvisioningStatusEnum::Red => "RED",
            ThinProvisioningStatusEnum::Yellow => "YELLOW",
            ThinProvisioningStatusEnum::Green => "GREEN",
            ThinProvisioningStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        THIN_PROVISIONING_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ThinProvisioningStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ThinProvisioningStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ThinProvisioningStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ThinProvisioningStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ThinProvisioningStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ThinProvisioningStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ThinProvisioningStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ThinProvisioningStatusEnum> for &'a str {
    fn from(value: &'a ThinProvisioningStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ThinProvisioningStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static REPLICATION_REPLICATION_STATE_ENUM_MAP: phf::Map<&'static str, ReplicationReplicationStateEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("SOURCE", ReplicationReplicationStateEnum::Source),
        ("FAILEDOVER", ReplicationReplicationStateEnum::Failedover),
        ("INTEST", ReplicationReplicationStateEnum::Intest),
        ("TARGET", ReplicationReplicationStateEnum::Target),
        ("REMOTE_FAILEDOVER", ReplicationReplicationStateEnum::RemoteFailedover),
    ],
};

impl ReplicationReplicationStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ReplicationReplicationStateEnum::Source => "SOURCE",
            ReplicationReplicationStateEnum::Target => "TARGET",
            ReplicationReplicationStateEnum::Failedover => "FAILEDOVER",
            ReplicationReplicationStateEnum::Intest => "INTEST",
            ReplicationReplicationStateEnum::RemoteFailedover => "REMOTE_FAILEDOVER",
            ReplicationReplicationStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        REPLICATION_REPLICATION_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ReplicationReplicationStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ReplicationReplicationStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ReplicationReplicationStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ReplicationReplicationStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ReplicationReplicationStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ReplicationReplicationStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ReplicationReplicationStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ReplicationReplicationStateEnum> for &'a str {
    fn from(value: &'a ReplicationReplicationStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ReplicationReplicationStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static BATCH_RESULT_RESULT_ENUM_MAP: phf::Map<&'static str, BatchResultResultEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("success", BatchResultResultEnum::Success),
        ("fail", BatchResultResultEnum::Fail),
    ],
};

impl BatchResultResultEnum {
    pub fn as_str(&self) -> &str {
        match self {
            BatchResultResultEnum::Success => "success",
            BatchResultResultEnum::Fail => "fail",
            BatchResultResultEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        BATCH_RESULT_RESULT_ENUM_MAP.get(s).cloned().unwrap_or_else(|| BatchResultResultEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for BatchResultResultEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for BatchResultResultEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<BatchResultResultEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(BatchResultResultEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for BatchResultResultEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for BatchResultResultEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a BatchResultResultEnum> for &'a str {
    fn from(value: &'a BatchResultResultEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for BatchResultResultEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CLUSTER_COMPUTE_RESOURCE_HCI_WORKFLOW_STATE_ENUM_MAP: phf::Map<&'static str, ClusterComputeResourceHciWorkflowStateEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("done", ClusterComputeResourceHciWorkflowStateEnum::Done),
        ("in_progress", ClusterComputeResourceHciWorkflowStateEnum::InProgress),
        ("invalid", ClusterComputeResourceHciWorkflowStateEnum::Invalid),
    ],
};

impl ClusterComputeResourceHciWorkflowStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ClusterComputeResourceHciWorkflowStateEnum::InProgress => "in_progress",
            ClusterComputeResourceHciWorkflowStateEnum::Done => "done",
            ClusterComputeResourceHciWorkflowStateEnum::Invalid => "invalid",
            ClusterComputeResourceHciWorkflowStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CLUSTER_COMPUTE_RESOURCE_HCI_WORKFLOW_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ClusterComputeResourceHciWorkflowStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ClusterComputeResourceHciWorkflowStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ClusterComputeResourceHciWorkflowStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ClusterComputeResourceHciWorkflowStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ClusterComputeResourceHciWorkflowStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ClusterComputeResourceHciWorkflowStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ClusterComputeResourceHciWorkflowStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ClusterComputeResourceHciWorkflowStateEnum> for &'a str {
    fn from(value: &'a ClusterComputeResourceHciWorkflowStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ClusterComputeResourceHciWorkflowStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CLUSTER_COMPUTE_RESOURCE_VCS_HEALTH_STATUS_ENUM_MAP: phf::Map<&'static str, ClusterComputeResourceVcsHealthStatusEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("degraded", ClusterComputeResourceVcsHealthStatusEnum::Degraded),
        ("healthy", ClusterComputeResourceVcsHealthStatusEnum::Healthy),
        ("nonhealthy", ClusterComputeResourceVcsHealthStatusEnum::Nonhealthy),
    ],
};

impl ClusterComputeResourceVcsHealthStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ClusterComputeResourceVcsHealthStatusEnum::Healthy => "healthy",
            ClusterComputeResourceVcsHealthStatusEnum::Degraded => "degraded",
            ClusterComputeResourceVcsHealthStatusEnum::Nonhealthy => "nonhealthy",
            ClusterComputeResourceVcsHealthStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CLUSTER_COMPUTE_RESOURCE_VCS_HEALTH_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ClusterComputeResourceVcsHealthStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ClusterComputeResourceVcsHealthStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ClusterComputeResourceVcsHealthStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ClusterComputeResourceVcsHealthStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ClusterComputeResourceVcsHealthStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ClusterComputeResourceVcsHealthStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ClusterComputeResourceVcsHealthStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ClusterComputeResourceVcsHealthStatusEnum> for &'a str {
    fn from(value: &'a ClusterComputeResourceVcsHealthStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ClusterComputeResourceVcsHealthStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static COMPUTE_RESOURCE_HOST_SPBM_LICENSE_INFO_HOST_SPBM_LICENSE_STATE_ENUM_MAP: phf::Map<&'static str, ComputeResourceHostSpbmLicenseInfoHostSpbmLicenseStateEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("unlicensed", ComputeResourceHostSpbmLicenseInfoHostSpbmLicenseStateEnum::Unlicensed),
        ("licensed", ComputeResourceHostSpbmLicenseInfoHostSpbmLicenseStateEnum::Licensed),
        ("unknown", ComputeResourceHostSpbmLicenseInfoHostSpbmLicenseStateEnum::Unknown),
    ],
};

impl ComputeResourceHostSpbmLicenseInfoHostSpbmLicenseStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ComputeResourceHostSpbmLicenseInfoHostSpbmLicenseStateEnum::Licensed => "licensed",
            ComputeResourceHostSpbmLicenseInfoHostSpbmLicenseStateEnum::Unlicensed => "unlicensed",
            ComputeResourceHostSpbmLicenseInfoHostSpbmLicenseStateEnum::Unknown => "unknown",
            ComputeResourceHostSpbmLicenseInfoHostSpbmLicenseStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        COMPUTE_RESOURCE_HOST_SPBM_LICENSE_INFO_HOST_SPBM_LICENSE_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ComputeResourceHostSpbmLicenseInfoHostSpbmLicenseStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ComputeResourceHostSpbmLicenseInfoHostSpbmLicenseStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ComputeResourceHostSpbmLicenseInfoHostSpbmLicenseStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ComputeResourceHostSpbmLicenseInfoHostSpbmLicenseStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ComputeResourceHostSpbmLicenseInfoHostSpbmLicenseStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ComputeResourceHostSpbmLicenseInfoHostSpbmLicenseStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ComputeResourceHostSpbmLicenseInfoHostSpbmLicenseStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ComputeResourceHostSpbmLicenseInfoHostSpbmLicenseStateEnum> for &'a str {
    fn from(value: &'a ComputeResourceHostSpbmLicenseInfoHostSpbmLicenseStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ComputeResourceHostSpbmLicenseInfoHostSpbmLicenseStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static COMPUTE_RESOURCE_NETWORK_BOOT_MODE_ENUM_MAP: phf::Map<&'static str, ComputeResourceNetworkBootModeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("stateless", ComputeResourceNetworkBootModeEnum::Stateless),
        ("bootstrap", ComputeResourceNetworkBootModeEnum::Bootstrap),
    ],
};

impl ComputeResourceNetworkBootModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ComputeResourceNetworkBootModeEnum::Bootstrap => "bootstrap",
            ComputeResourceNetworkBootModeEnum::Stateless => "stateless",
            ComputeResourceNetworkBootModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        COMPUTE_RESOURCE_NETWORK_BOOT_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ComputeResourceNetworkBootModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ComputeResourceNetworkBootModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ComputeResourceNetworkBootModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ComputeResourceNetworkBootModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ComputeResourceNetworkBootModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ComputeResourceNetworkBootModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ComputeResourceNetworkBootModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ComputeResourceNetworkBootModeEnum> for &'a str {
    fn from(value: &'a ComputeResourceNetworkBootModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ComputeResourceNetworkBootModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CONFIG_SPEC_OPERATION_ENUM_MAP: phf::Map<&'static str, ConfigSpecOperationEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("add", ConfigSpecOperationEnum::Add),
        ("edit", ConfigSpecOperationEnum::Edit),
        ("remove", ConfigSpecOperationEnum::Remove),
    ],
};

impl ConfigSpecOperationEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ConfigSpecOperationEnum::Add => "add",
            ConfigSpecOperationEnum::Edit => "edit",
            ConfigSpecOperationEnum::Remove => "remove",
            ConfigSpecOperationEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CONFIG_SPEC_OPERATION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ConfigSpecOperationEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ConfigSpecOperationEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ConfigSpecOperationEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ConfigSpecOperationEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ConfigSpecOperationEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ConfigSpecOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ConfigSpecOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ConfigSpecOperationEnum> for &'a str {
    fn from(value: &'a ConfigSpecOperationEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ConfigSpecOperationEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DATASTORE_ACCESSIBLE_ENUM_MAP: phf::Map<&'static str, DatastoreAccessibleEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("False", DatastoreAccessibleEnum::False),
        ("True", DatastoreAccessibleEnum::True),
    ],
};

impl DatastoreAccessibleEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DatastoreAccessibleEnum::True => "True",
            DatastoreAccessibleEnum::False => "False",
            DatastoreAccessibleEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DATASTORE_ACCESSIBLE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DatastoreAccessibleEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DatastoreAccessibleEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DatastoreAccessibleEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DatastoreAccessibleEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DatastoreAccessibleEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DatastoreAccessibleEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DatastoreAccessibleEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DatastoreAccessibleEnum> for &'a str {
    fn from(value: &'a DatastoreAccessibleEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DatastoreAccessibleEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DATASTORE_SECTOR_FORMAT_ENUM_MAP: phf::Map<&'static str, DatastoreSectorFormatEnum> = ::phf::Map {
    key: 12213676231523076107,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("native_4k", DatastoreSectorFormatEnum::Native4K),
        ("native_512", DatastoreSectorFormatEnum::Native512),
        ("emulated_512", DatastoreSectorFormatEnum::Emulated512),
    ],
};

impl DatastoreSectorFormatEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DatastoreSectorFormatEnum::Native512 => "native_512",
            DatastoreSectorFormatEnum::Emulated512 => "emulated_512",
            DatastoreSectorFormatEnum::Native4K => "native_4k",
            DatastoreSectorFormatEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DATASTORE_SECTOR_FORMAT_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DatastoreSectorFormatEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DatastoreSectorFormatEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DatastoreSectorFormatEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DatastoreSectorFormatEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DatastoreSectorFormatEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DatastoreSectorFormatEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DatastoreSectorFormatEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DatastoreSectorFormatEnum> for &'a str {
    fn from(value: &'a DatastoreSectorFormatEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DatastoreSectorFormatEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DATASTORE_SUMMARY_MAINTENANCE_MODE_STATE_ENUM_MAP: phf::Map<&'static str, DatastoreSummaryMaintenanceModeStateEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("inMaintenance", DatastoreSummaryMaintenanceModeStateEnum::InMaintenance),
        ("normal", DatastoreSummaryMaintenanceModeStateEnum::Normal),
        ("enteringMaintenance", DatastoreSummaryMaintenanceModeStateEnum::EnteringMaintenance),
    ],
};

impl DatastoreSummaryMaintenanceModeStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DatastoreSummaryMaintenanceModeStateEnum::Normal => "normal",
            DatastoreSummaryMaintenanceModeStateEnum::EnteringMaintenance => "enteringMaintenance",
            DatastoreSummaryMaintenanceModeStateEnum::InMaintenance => "inMaintenance",
            DatastoreSummaryMaintenanceModeStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DATASTORE_SUMMARY_MAINTENANCE_MODE_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DatastoreSummaryMaintenanceModeStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DatastoreSummaryMaintenanceModeStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DatastoreSummaryMaintenanceModeStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DatastoreSummaryMaintenanceModeStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DatastoreSummaryMaintenanceModeStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DatastoreSummaryMaintenanceModeStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DatastoreSummaryMaintenanceModeStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DatastoreSummaryMaintenanceModeStateEnum> for &'a str {
    fn from(value: &'a DatastoreSummaryMaintenanceModeStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DatastoreSummaryMaintenanceModeStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DIAGNOSTIC_MANAGER_LOG_CREATOR_ENUM_MAP: phf::Map<&'static str, DiagnosticManagerLogCreatorEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
        (0, 4),
    ],
    entries: &[
        ("recordLog", DiagnosticManagerLogCreatorEnum::RecordLog),
        ("hostd", DiagnosticManagerLogCreatorEnum::Hostd),
        ("serverd", DiagnosticManagerLogCreatorEnum::Serverd),
        ("vpxClient", DiagnosticManagerLogCreatorEnum::VpxClient),
        ("vpxa", DiagnosticManagerLogCreatorEnum::Vpxa),
        ("install", DiagnosticManagerLogCreatorEnum::Install),
        ("vpxd", DiagnosticManagerLogCreatorEnum::Vpxd),
    ],
};

impl DiagnosticManagerLogCreatorEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DiagnosticManagerLogCreatorEnum::Vpxd => "vpxd",
            DiagnosticManagerLogCreatorEnum::Vpxa => "vpxa",
            DiagnosticManagerLogCreatorEnum::Hostd => "hostd",
            DiagnosticManagerLogCreatorEnum::Serverd => "serverd",
            DiagnosticManagerLogCreatorEnum::Install => "install",
            DiagnosticManagerLogCreatorEnum::VpxClient => "vpxClient",
            DiagnosticManagerLogCreatorEnum::RecordLog => "recordLog",
            DiagnosticManagerLogCreatorEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DIAGNOSTIC_MANAGER_LOG_CREATOR_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DiagnosticManagerLogCreatorEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DiagnosticManagerLogCreatorEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DiagnosticManagerLogCreatorEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DiagnosticManagerLogCreatorEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DiagnosticManagerLogCreatorEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DiagnosticManagerLogCreatorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DiagnosticManagerLogCreatorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DiagnosticManagerLogCreatorEnum> for &'a str {
    fn from(value: &'a DiagnosticManagerLogCreatorEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DiagnosticManagerLogCreatorEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DIAGNOSTIC_MANAGER_LOG_FORMAT_ENUM_MAP: phf::Map<&'static str, DiagnosticManagerLogFormatEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("plain", DiagnosticManagerLogFormatEnum::Plain),
    ],
};

impl DiagnosticManagerLogFormatEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DiagnosticManagerLogFormatEnum::Plain => "plain",
            DiagnosticManagerLogFormatEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DIAGNOSTIC_MANAGER_LOG_FORMAT_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DiagnosticManagerLogFormatEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DiagnosticManagerLogFormatEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DiagnosticManagerLogFormatEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DiagnosticManagerLogFormatEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DiagnosticManagerLogFormatEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DiagnosticManagerLogFormatEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DiagnosticManagerLogFormatEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DiagnosticManagerLogFormatEnum> for &'a str {
    fn from(value: &'a DiagnosticManagerLogFormatEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DiagnosticManagerLogFormatEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DISTRIBUTED_VIRTUAL_SWITCH_HOST_INFRASTRUCTURE_TRAFFIC_CLASS_ENUM_MAP: phf::Map<&'static str, DistributedVirtualSwitchHostInfrastructureTrafficClassEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 11),
        (3, 0),
        (3, 4),
    ],
    entries: &[
        ("virtualMachine", DistributedVirtualSwitchHostInfrastructureTrafficClassEnum::VirtualMachine),
        ("nfs", DistributedVirtualSwitchHostInfrastructureTrafficClassEnum::Nfs),
        ("vsan", DistributedVirtualSwitchHostInfrastructureTrafficClassEnum::Vsan),
        ("faultTolerance", DistributedVirtualSwitchHostInfrastructureTrafficClassEnum::FaultTolerance),
        ("backupNfc", DistributedVirtualSwitchHostInfrastructureTrafficClassEnum::BackupNfc),
        ("iSCSI", DistributedVirtualSwitchHostInfrastructureTrafficClassEnum::IScsi),
        ("management", DistributedVirtualSwitchHostInfrastructureTrafficClassEnum::Management),
        ("vdp", DistributedVirtualSwitchHostInfrastructureTrafficClassEnum::Vdp),
        ("provisioning", DistributedVirtualSwitchHostInfrastructureTrafficClassEnum::Provisioning),
        ("nvmetcp", DistributedVirtualSwitchHostInfrastructureTrafficClassEnum::Nvmetcp),
        ("vmotion", DistributedVirtualSwitchHostInfrastructureTrafficClassEnum::Vmotion),
        ("hbr", DistributedVirtualSwitchHostInfrastructureTrafficClassEnum::Hbr),
    ],
};

impl DistributedVirtualSwitchHostInfrastructureTrafficClassEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DistributedVirtualSwitchHostInfrastructureTrafficClassEnum::Management => "management",
            DistributedVirtualSwitchHostInfrastructureTrafficClassEnum::FaultTolerance => "faultTolerance",
            DistributedVirtualSwitchHostInfrastructureTrafficClassEnum::Vmotion => "vmotion",
            DistributedVirtualSwitchHostInfrastructureTrafficClassEnum::VirtualMachine => "virtualMachine",
            DistributedVirtualSwitchHostInfrastructureTrafficClassEnum::IScsi => "iSCSI",
            DistributedVirtualSwitchHostInfrastructureTrafficClassEnum::Nfs => "nfs",
            DistributedVirtualSwitchHostInfrastructureTrafficClassEnum::Hbr => "hbr",
            DistributedVirtualSwitchHostInfrastructureTrafficClassEnum::Vsan => "vsan",
            DistributedVirtualSwitchHostInfrastructureTrafficClassEnum::Vdp => "vdp",
            DistributedVirtualSwitchHostInfrastructureTrafficClassEnum::BackupNfc => "backupNfc",
            DistributedVirtualSwitchHostInfrastructureTrafficClassEnum::Nvmetcp => "nvmetcp",
            DistributedVirtualSwitchHostInfrastructureTrafficClassEnum::Provisioning => "provisioning",
            DistributedVirtualSwitchHostInfrastructureTrafficClassEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DISTRIBUTED_VIRTUAL_SWITCH_HOST_INFRASTRUCTURE_TRAFFIC_CLASS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DistributedVirtualSwitchHostInfrastructureTrafficClassEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DistributedVirtualSwitchHostInfrastructureTrafficClassEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DistributedVirtualSwitchHostInfrastructureTrafficClassEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DistributedVirtualSwitchHostInfrastructureTrafficClassEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DistributedVirtualSwitchHostInfrastructureTrafficClassEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DistributedVirtualSwitchHostInfrastructureTrafficClassEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DistributedVirtualSwitchHostInfrastructureTrafficClassEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DistributedVirtualSwitchHostInfrastructureTrafficClassEnum> for &'a str {
    fn from(value: &'a DistributedVirtualSwitchHostInfrastructureTrafficClassEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DistributedVirtualSwitchHostInfrastructureTrafficClassEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DISTRIBUTED_VIRTUAL_SWITCH_NETWORK_RESOURCE_CONTROL_VERSION_ENUM_MAP: phf::Map<&'static str, DistributedVirtualSwitchNetworkResourceControlVersionEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("version2", DistributedVirtualSwitchNetworkResourceControlVersionEnum::Version2),
        ("version3", DistributedVirtualSwitchNetworkResourceControlVersionEnum::Version3),
    ],
};

impl DistributedVirtualSwitchNetworkResourceControlVersionEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DistributedVirtualSwitchNetworkResourceControlVersionEnum::Version2 => "version2",
            DistributedVirtualSwitchNetworkResourceControlVersionEnum::Version3 => "version3",
            DistributedVirtualSwitchNetworkResourceControlVersionEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DISTRIBUTED_VIRTUAL_SWITCH_NETWORK_RESOURCE_CONTROL_VERSION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DistributedVirtualSwitchNetworkResourceControlVersionEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DistributedVirtualSwitchNetworkResourceControlVersionEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DistributedVirtualSwitchNetworkResourceControlVersionEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DistributedVirtualSwitchNetworkResourceControlVersionEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DistributedVirtualSwitchNetworkResourceControlVersionEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DistributedVirtualSwitchNetworkResourceControlVersionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DistributedVirtualSwitchNetworkResourceControlVersionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DistributedVirtualSwitchNetworkResourceControlVersionEnum> for &'a str {
    fn from(value: &'a DistributedVirtualSwitchNetworkResourceControlVersionEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DistributedVirtualSwitchNetworkResourceControlVersionEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DISTRIBUTED_VIRTUAL_SWITCH_NIC_TEAMING_POLICY_MODE_ENUM_MAP: phf::Map<&'static str, DistributedVirtualSwitchNicTeamingPolicyModeEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("failover_explicit", DistributedVirtualSwitchNicTeamingPolicyModeEnum::FailoverExplicit),
        ("loadbalance_loadbased", DistributedVirtualSwitchNicTeamingPolicyModeEnum::LoadbalanceLoadbased),
        ("loadbalance_srcmac", DistributedVirtualSwitchNicTeamingPolicyModeEnum::LoadbalanceSrcmac),
        ("loadbalance_ip", DistributedVirtualSwitchNicTeamingPolicyModeEnum::LoadbalanceIp),
        ("loadbalance_srcid", DistributedVirtualSwitchNicTeamingPolicyModeEnum::LoadbalanceSrcid),
    ],
};

impl DistributedVirtualSwitchNicTeamingPolicyModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DistributedVirtualSwitchNicTeamingPolicyModeEnum::LoadbalanceIp => "loadbalance_ip",
            DistributedVirtualSwitchNicTeamingPolicyModeEnum::LoadbalanceSrcmac => "loadbalance_srcmac",
            DistributedVirtualSwitchNicTeamingPolicyModeEnum::LoadbalanceSrcid => "loadbalance_srcid",
            DistributedVirtualSwitchNicTeamingPolicyModeEnum::FailoverExplicit => "failover_explicit",
            DistributedVirtualSwitchNicTeamingPolicyModeEnum::LoadbalanceLoadbased => "loadbalance_loadbased",
            DistributedVirtualSwitchNicTeamingPolicyModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DISTRIBUTED_VIRTUAL_SWITCH_NIC_TEAMING_POLICY_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DistributedVirtualSwitchNicTeamingPolicyModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DistributedVirtualSwitchNicTeamingPolicyModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DistributedVirtualSwitchNicTeamingPolicyModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DistributedVirtualSwitchNicTeamingPolicyModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DistributedVirtualSwitchNicTeamingPolicyModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DistributedVirtualSwitchNicTeamingPolicyModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DistributedVirtualSwitchNicTeamingPolicyModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DistributedVirtualSwitchNicTeamingPolicyModeEnum> for &'a str {
    fn from(value: &'a DistributedVirtualSwitchNicTeamingPolicyModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DistributedVirtualSwitchNicTeamingPolicyModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DISTRIBUTED_VIRTUAL_SWITCH_PRODUCT_SPEC_OPERATION_TYPE_ENUM_MAP: phf::Map<&'static str, DistributedVirtualSwitchProductSpecOperationTypeEnum> = ::phf::Map {
    key: 14108922650502679131,
    disps: &[
        (3, 0),
    ],
    entries: &[
        ("notifyAvailableUpgrade", DistributedVirtualSwitchProductSpecOperationTypeEnum::NotifyAvailableUpgrade),
        ("updateBundleInfo", DistributedVirtualSwitchProductSpecOperationTypeEnum::UpdateBundleInfo),
        ("proceedWithUpgrade", DistributedVirtualSwitchProductSpecOperationTypeEnum::ProceedWithUpgrade),
        ("upgrade", DistributedVirtualSwitchProductSpecOperationTypeEnum::Upgrade),
        ("preInstall", DistributedVirtualSwitchProductSpecOperationTypeEnum::PreInstall),
    ],
};

impl DistributedVirtualSwitchProductSpecOperationTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DistributedVirtualSwitchProductSpecOperationTypeEnum::PreInstall => "preInstall",
            DistributedVirtualSwitchProductSpecOperationTypeEnum::Upgrade => "upgrade",
            DistributedVirtualSwitchProductSpecOperationTypeEnum::NotifyAvailableUpgrade => "notifyAvailableUpgrade",
            DistributedVirtualSwitchProductSpecOperationTypeEnum::ProceedWithUpgrade => "proceedWithUpgrade",
            DistributedVirtualSwitchProductSpecOperationTypeEnum::UpdateBundleInfo => "updateBundleInfo",
            DistributedVirtualSwitchProductSpecOperationTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DISTRIBUTED_VIRTUAL_SWITCH_PRODUCT_SPEC_OPERATION_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DistributedVirtualSwitchProductSpecOperationTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DistributedVirtualSwitchProductSpecOperationTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DistributedVirtualSwitchProductSpecOperationTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DistributedVirtualSwitchProductSpecOperationTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DistributedVirtualSwitchProductSpecOperationTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DistributedVirtualSwitchProductSpecOperationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DistributedVirtualSwitchProductSpecOperationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DistributedVirtualSwitchProductSpecOperationTypeEnum> for &'a str {
    fn from(value: &'a DistributedVirtualSwitchProductSpecOperationTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DistributedVirtualSwitchProductSpecOperationTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DRS_INJECTOR_WORKLOAD_CORRELATION_STATE_ENUM_MAP: phf::Map<&'static str, DrsInjectorWorkloadCorrelationStateEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("Uncorrelated", DrsInjectorWorkloadCorrelationStateEnum::Uncorrelated),
        ("Correlated", DrsInjectorWorkloadCorrelationStateEnum::Correlated),
    ],
};

impl DrsInjectorWorkloadCorrelationStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DrsInjectorWorkloadCorrelationStateEnum::Correlated => "Correlated",
            DrsInjectorWorkloadCorrelationStateEnum::Uncorrelated => "Uncorrelated",
            DrsInjectorWorkloadCorrelationStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DRS_INJECTOR_WORKLOAD_CORRELATION_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DrsInjectorWorkloadCorrelationStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DrsInjectorWorkloadCorrelationStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DrsInjectorWorkloadCorrelationStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DrsInjectorWorkloadCorrelationStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DrsInjectorWorkloadCorrelationStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DrsInjectorWorkloadCorrelationStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DrsInjectorWorkloadCorrelationStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DrsInjectorWorkloadCorrelationStateEnum> for &'a str {
    fn from(value: &'a DrsInjectorWorkloadCorrelationStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DrsInjectorWorkloadCorrelationStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static FOLDER_DESIRED_HOST_STATE_ENUM_MAP: phf::Map<&'static str, FolderDesiredHostStateEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("maintenance", FolderDesiredHostStateEnum::Maintenance),
        ("non_maintenance", FolderDesiredHostStateEnum::NonMaintenance),
    ],
};

impl FolderDesiredHostStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            FolderDesiredHostStateEnum::Maintenance => "maintenance",
            FolderDesiredHostStateEnum::NonMaintenance => "non_maintenance",
            FolderDesiredHostStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        FOLDER_DESIRED_HOST_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| FolderDesiredHostStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for FolderDesiredHostStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for FolderDesiredHostStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<FolderDesiredHostStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(FolderDesiredHostStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for FolderDesiredHostStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for FolderDesiredHostStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a FolderDesiredHostStateEnum> for &'a str {
    fn from(value: &'a FolderDesiredHostStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for FolderDesiredHostStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static FOLDER_EXTERNALLY_MANAGED_FOLDER_TYPE_ENUM_MAP: phf::Map<&'static str, FolderExternallyManagedFolderTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (5, 0),
        (3, 1),
    ],
    entries: &[
        ("VSPHERE_POD", FolderExternallyManagedFolderTypeEnum::VspherePod),
        ("SUPERVISOR", FolderExternallyManagedFolderTypeEnum::Supervisor),
        ("VPC", FolderExternallyManagedFolderTypeEnum::Vpc),
        ("PROJECT", FolderExternallyManagedFolderTypeEnum::Project),
        ("SUBNET", FolderExternallyManagedFolderTypeEnum::Subnet),
        ("PROJECT_ROOT", FolderExternallyManagedFolderTypeEnum::ProjectRoot),
        ("SEGMENT", FolderExternallyManagedFolderTypeEnum::Segment),
        ("VPC_ROOT", FolderExternallyManagedFolderTypeEnum::VpcRoot),
    ],
};

impl FolderExternallyManagedFolderTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            FolderExternallyManagedFolderTypeEnum::ProjectRoot => "PROJECT_ROOT",
            FolderExternallyManagedFolderTypeEnum::Project => "PROJECT",
            FolderExternallyManagedFolderTypeEnum::VpcRoot => "VPC_ROOT",
            FolderExternallyManagedFolderTypeEnum::Vpc => "VPC",
            FolderExternallyManagedFolderTypeEnum::Subnet => "SUBNET",
            FolderExternallyManagedFolderTypeEnum::Segment => "SEGMENT",
            FolderExternallyManagedFolderTypeEnum::Supervisor => "SUPERVISOR",
            FolderExternallyManagedFolderTypeEnum::VspherePod => "VSPHERE_POD",
            FolderExternallyManagedFolderTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        FOLDER_EXTERNALLY_MANAGED_FOLDER_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| FolderExternallyManagedFolderTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for FolderExternallyManagedFolderTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for FolderExternallyManagedFolderTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<FolderExternallyManagedFolderTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(FolderExternallyManagedFolderTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for FolderExternallyManagedFolderTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for FolderExternallyManagedFolderTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a FolderExternallyManagedFolderTypeEnum> for &'a str {
    fn from(value: &'a FolderExternallyManagedFolderTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for FolderExternallyManagedFolderTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static REPLICATION_VM_STATE_ENUM_MAP: phf::Map<&'static str, ReplicationVmStateEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (2, 0),
        (1, 4),
    ],
    entries: &[
        ("idle", ReplicationVmStateEnum::Idle),
        ("error", ReplicationVmStateEnum::Error),
        ("none", ReplicationVmStateEnum::None),
        ("paused", ReplicationVmStateEnum::Paused),
        ("active", ReplicationVmStateEnum::Active),
        ("syncing", ReplicationVmStateEnum::Syncing),
    ],
};

impl ReplicationVmStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ReplicationVmStateEnum::None => "none",
            ReplicationVmStateEnum::Paused => "paused",
            ReplicationVmStateEnum::Syncing => "syncing",
            ReplicationVmStateEnum::Idle => "idle",
            ReplicationVmStateEnum::Active => "active",
            ReplicationVmStateEnum::Error => "error",
            ReplicationVmStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        REPLICATION_VM_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ReplicationVmStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ReplicationVmStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ReplicationVmStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ReplicationVmStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ReplicationVmStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ReplicationVmStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ReplicationVmStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ReplicationVmStateEnum> for &'a str {
    fn from(value: &'a ReplicationVmStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ReplicationVmStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static QUIESCE_MODE_ENUM_MAP: phf::Map<&'static str, QuiesceModeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("filesystem", QuiesceModeEnum::Filesystem),
        ("application", QuiesceModeEnum::Application),
        ("none", QuiesceModeEnum::None),
    ],
};

impl QuiesceModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            QuiesceModeEnum::Application => "application",
            QuiesceModeEnum::Filesystem => "filesystem",
            QuiesceModeEnum::None => "none",
            QuiesceModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        QUIESCE_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| QuiesceModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for QuiesceModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for QuiesceModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<QuiesceModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(QuiesceModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for QuiesceModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for QuiesceModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a QuiesceModeEnum> for &'a str {
    fn from(value: &'a QuiesceModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for QuiesceModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HEALTH_UPDATE_INFO_COMPONENT_TYPE_ENUM_MAP: phf::Map<&'static str, HealthUpdateInfoComponentTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("Network", HealthUpdateInfoComponentTypeEnum::Network),
        ("Storage", HealthUpdateInfoComponentTypeEnum::Storage),
        ("Fan", HealthUpdateInfoComponentTypeEnum::Fan),
        ("Memory", HealthUpdateInfoComponentTypeEnum::Memory),
        ("Power", HealthUpdateInfoComponentTypeEnum::Power),
    ],
};

impl HealthUpdateInfoComponentTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HealthUpdateInfoComponentTypeEnum::Memory => "Memory",
            HealthUpdateInfoComponentTypeEnum::Power => "Power",
            HealthUpdateInfoComponentTypeEnum::Fan => "Fan",
            HealthUpdateInfoComponentTypeEnum::Network => "Network",
            HealthUpdateInfoComponentTypeEnum::Storage => "Storage",
            HealthUpdateInfoComponentTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HEALTH_UPDATE_INFO_COMPONENT_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HealthUpdateInfoComponentTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HealthUpdateInfoComponentTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HealthUpdateInfoComponentTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HealthUpdateInfoComponentTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HealthUpdateInfoComponentTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HealthUpdateInfoComponentTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HealthUpdateInfoComponentTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HealthUpdateInfoComponentTypeEnum> for &'a str {
    fn from(value: &'a HealthUpdateInfoComponentTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HealthUpdateInfoComponentTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_SYSTEM_CONNECTION_STATE_ENUM_MAP: phf::Map<&'static str, HostSystemConnectionStateEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("disconnected", HostSystemConnectionStateEnum::Disconnected),
        ("connected", HostSystemConnectionStateEnum::Connected),
        ("notResponding", HostSystemConnectionStateEnum::NotResponding),
    ],
};

impl HostSystemConnectionStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostSystemConnectionStateEnum::Connected => "connected",
            HostSystemConnectionStateEnum::NotResponding => "notResponding",
            HostSystemConnectionStateEnum::Disconnected => "disconnected",
            HostSystemConnectionStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_SYSTEM_CONNECTION_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostSystemConnectionStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostSystemConnectionStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostSystemConnectionStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostSystemConnectionStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostSystemConnectionStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostSystemConnectionStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostSystemConnectionStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostSystemConnectionStateEnum> for &'a str {
    fn from(value: &'a HostSystemConnectionStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostSystemConnectionStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_CRYPTO_STATE_ENUM_MAP: phf::Map<&'static str, HostCryptoStateEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("safe", HostCryptoStateEnum::Safe),
        ("pendingIncapable", HostCryptoStateEnum::PendingIncapable),
        ("prepared", HostCryptoStateEnum::Prepared),
        ("incapable", HostCryptoStateEnum::Incapable),
    ],
};

impl HostCryptoStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostCryptoStateEnum::Incapable => "incapable",
            HostCryptoStateEnum::Prepared => "prepared",
            HostCryptoStateEnum::Safe => "safe",
            HostCryptoStateEnum::PendingIncapable => "pendingIncapable",
            HostCryptoStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_CRYPTO_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostCryptoStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostCryptoStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostCryptoStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostCryptoStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostCryptoStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostCryptoStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostCryptoStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostCryptoStateEnum> for &'a str {
    fn from(value: &'a HostCryptoStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostCryptoStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_SYSTEM_POWER_STATE_ENUM_MAP: phf::Map<&'static str, HostSystemPowerStateEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("standBy", HostSystemPowerStateEnum::StandBy),
        ("poweredOff", HostSystemPowerStateEnum::PoweredOff),
        ("poweredOn", HostSystemPowerStateEnum::PoweredOn),
        ("unknown", HostSystemPowerStateEnum::Unknown),
    ],
};

impl HostSystemPowerStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostSystemPowerStateEnum::PoweredOn => "poweredOn",
            HostSystemPowerStateEnum::PoweredOff => "poweredOff",
            HostSystemPowerStateEnum::StandBy => "standBy",
            HostSystemPowerStateEnum::Unknown => "unknown",
            HostSystemPowerStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_SYSTEM_POWER_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostSystemPowerStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostSystemPowerStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostSystemPowerStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostSystemPowerStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostSystemPowerStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostSystemPowerStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostSystemPowerStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostSystemPowerStateEnum> for &'a str {
    fn from(value: &'a HostSystemPowerStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostSystemPowerStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_SYSTEM_REMEDIATION_STATE_STATE_ENUM_MAP: phf::Map<&'static str, HostSystemRemediationStateStateEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
        (0, 1),
    ],
    entries: &[
        ("precheckRemediationComplete", HostSystemRemediationStateStateEnum::PrecheckRemediationComplete),
        ("precheckRemediationFailed", HostSystemRemediationStateStateEnum::PrecheckRemediationFailed),
        ("remediationReady", HostSystemRemediationStateStateEnum::RemediationReady),
        ("precheckRemediationRunning", HostSystemRemediationStateStateEnum::PrecheckRemediationRunning),
        ("remediationFailed", HostSystemRemediationStateStateEnum::RemediationFailed),
        ("remediationRunning", HostSystemRemediationStateStateEnum::RemediationRunning),
    ],
};

impl HostSystemRemediationStateStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostSystemRemediationStateStateEnum::RemediationReady => "remediationReady",
            HostSystemRemediationStateStateEnum::PrecheckRemediationRunning => "precheckRemediationRunning",
            HostSystemRemediationStateStateEnum::PrecheckRemediationComplete => "precheckRemediationComplete",
            HostSystemRemediationStateStateEnum::PrecheckRemediationFailed => "precheckRemediationFailed",
            HostSystemRemediationStateStateEnum::RemediationRunning => "remediationRunning",
            HostSystemRemediationStateStateEnum::RemediationFailed => "remediationFailed",
            HostSystemRemediationStateStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_SYSTEM_REMEDIATION_STATE_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostSystemRemediationStateStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostSystemRemediationStateStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostSystemRemediationStateStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostSystemRemediationStateStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostSystemRemediationStateStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostSystemRemediationStateStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostSystemRemediationStateStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostSystemRemediationStateStateEnum> for &'a str {
    fn from(value: &'a HostSystemRemediationStateStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostSystemRemediationStateStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_STANDBY_MODE_ENUM_MAP: phf::Map<&'static str, HostStandbyModeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("exiting", HostStandbyModeEnum::Exiting),
        ("none", HostStandbyModeEnum::None),
        ("in", HostStandbyModeEnum::In),
        ("entering", HostStandbyModeEnum::Entering),
    ],
};

impl HostStandbyModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostStandbyModeEnum::Entering => "entering",
            HostStandbyModeEnum::Exiting => "exiting",
            HostStandbyModeEnum::In => "in",
            HostStandbyModeEnum::None => "none",
            HostStandbyModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_STANDBY_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostStandbyModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostStandbyModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostStandbyModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostStandbyModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostStandbyModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostStandbyModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostStandbyModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostStandbyModeEnum> for &'a str {
    fn from(value: &'a HostStandbyModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostStandbyModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HTTP_NFC_LEASE_MANIFEST_ENTRY_CHECKSUM_TYPE_ENUM_MAP: phf::Map<&'static str, HttpNfcLeaseManifestEntryChecksumTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("sha1", HttpNfcLeaseManifestEntryChecksumTypeEnum::Sha1),
        ("sha256", HttpNfcLeaseManifestEntryChecksumTypeEnum::Sha256),
    ],
};

impl HttpNfcLeaseManifestEntryChecksumTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HttpNfcLeaseManifestEntryChecksumTypeEnum::Sha1 => "sha1",
            HttpNfcLeaseManifestEntryChecksumTypeEnum::Sha256 => "sha256",
            HttpNfcLeaseManifestEntryChecksumTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HTTP_NFC_LEASE_MANIFEST_ENTRY_CHECKSUM_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HttpNfcLeaseManifestEntryChecksumTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HttpNfcLeaseManifestEntryChecksumTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HttpNfcLeaseManifestEntryChecksumTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HttpNfcLeaseManifestEntryChecksumTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HttpNfcLeaseManifestEntryChecksumTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HttpNfcLeaseManifestEntryChecksumTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HttpNfcLeaseManifestEntryChecksumTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HttpNfcLeaseManifestEntryChecksumTypeEnum> for &'a str {
    fn from(value: &'a HttpNfcLeaseManifestEntryChecksumTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HttpNfcLeaseManifestEntryChecksumTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HTTP_NFC_LEASE_MODE_ENUM_MAP: phf::Map<&'static str, HttpNfcLeaseModeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("pull", HttpNfcLeaseModeEnum::Pull),
        ("pushOrGet", HttpNfcLeaseModeEnum::PushOrGet),
    ],
};

impl HttpNfcLeaseModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HttpNfcLeaseModeEnum::PushOrGet => "pushOrGet",
            HttpNfcLeaseModeEnum::Pull => "pull",
            HttpNfcLeaseModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HTTP_NFC_LEASE_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HttpNfcLeaseModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HttpNfcLeaseModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HttpNfcLeaseModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HttpNfcLeaseModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HttpNfcLeaseModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HttpNfcLeaseModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HttpNfcLeaseModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HttpNfcLeaseModeEnum> for &'a str {
    fn from(value: &'a HttpNfcLeaseModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HttpNfcLeaseModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HTTP_NFC_LEASE_STATE_ENUM_MAP: phf::Map<&'static str, HttpNfcLeaseStateEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("initializing", HttpNfcLeaseStateEnum::Initializing),
        ("done", HttpNfcLeaseStateEnum::Done),
        ("ready", HttpNfcLeaseStateEnum::Ready),
        ("error", HttpNfcLeaseStateEnum::Error),
    ],
};

impl HttpNfcLeaseStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HttpNfcLeaseStateEnum::Initializing => "initializing",
            HttpNfcLeaseStateEnum::Ready => "ready",
            HttpNfcLeaseStateEnum::Done => "done",
            HttpNfcLeaseStateEnum::Error => "error",
            HttpNfcLeaseStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HTTP_NFC_LEASE_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HttpNfcLeaseStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HttpNfcLeaseStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HttpNfcLeaseStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HttpNfcLeaseStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HttpNfcLeaseStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HttpNfcLeaseStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HttpNfcLeaseStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HttpNfcLeaseStateEnum> for &'a str {
    fn from(value: &'a HttpNfcLeaseStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HttpNfcLeaseStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static IO_FILTER_TYPE_ENUM_MAP: phf::Map<&'static str, IoFilterTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (6, 0),
        (1, 0),
    ],
    entries: &[
        ("replication", IoFilterTypeEnum::Replication),
        ("datastoreIoControl", IoFilterTypeEnum::DatastoreIoControl),
        ("dataCapture", IoFilterTypeEnum::DataCapture),
        ("dataProvider", IoFilterTypeEnum::DataProvider),
        ("encryption", IoFilterTypeEnum::Encryption),
        ("cache", IoFilterTypeEnum::Cache),
        ("compression", IoFilterTypeEnum::Compression),
        ("inspection", IoFilterTypeEnum::Inspection),
    ],
};

impl IoFilterTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            IoFilterTypeEnum::Cache => "cache",
            IoFilterTypeEnum::Replication => "replication",
            IoFilterTypeEnum::Encryption => "encryption",
            IoFilterTypeEnum::Compression => "compression",
            IoFilterTypeEnum::Inspection => "inspection",
            IoFilterTypeEnum::DatastoreIoControl => "datastoreIoControl",
            IoFilterTypeEnum::DataProvider => "dataProvider",
            IoFilterTypeEnum::DataCapture => "dataCapture",
            IoFilterTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        IO_FILTER_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| IoFilterTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for IoFilterTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for IoFilterTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<IoFilterTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(IoFilterTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for IoFilterTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for IoFilterTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a IoFilterTypeEnum> for &'a str {
    fn from(value: &'a IoFilterTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for IoFilterTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static IO_FILTER_OPERATION_ENUM_MAP: phf::Map<&'static str, IoFilterOperationEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("upgrade", IoFilterOperationEnum::Upgrade),
        ("install", IoFilterOperationEnum::Install),
        ("uninstall", IoFilterOperationEnum::Uninstall),
    ],
};

impl IoFilterOperationEnum {
    pub fn as_str(&self) -> &str {
        match self {
            IoFilterOperationEnum::Install => "install",
            IoFilterOperationEnum::Uninstall => "uninstall",
            IoFilterOperationEnum::Upgrade => "upgrade",
            IoFilterOperationEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        IO_FILTER_OPERATION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| IoFilterOperationEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for IoFilterOperationEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for IoFilterOperationEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<IoFilterOperationEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(IoFilterOperationEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for IoFilterOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for IoFilterOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a IoFilterOperationEnum> for &'a str {
    fn from(value: &'a IoFilterOperationEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for IoFilterOperationEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static LATENCY_SENSITIVITY_SENSITIVITY_LEVEL_ENUM_MAP: phf::Map<&'static str, LatencySensitivitySensitivityLevelEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("custom", LatencySensitivitySensitivityLevelEnum::Custom),
        ("normal", LatencySensitivitySensitivityLevelEnum::Normal),
        ("medium", LatencySensitivitySensitivityLevelEnum::Medium),
        ("high", LatencySensitivitySensitivityLevelEnum::High),
        ("low", LatencySensitivitySensitivityLevelEnum::Low),
    ],
};

impl LatencySensitivitySensitivityLevelEnum {
    pub fn as_str(&self) -> &str {
        match self {
            LatencySensitivitySensitivityLevelEnum::Low => "low",
            LatencySensitivitySensitivityLevelEnum::Normal => "normal",
            LatencySensitivitySensitivityLevelEnum::Medium => "medium",
            LatencySensitivitySensitivityLevelEnum::High => "high",
            LatencySensitivitySensitivityLevelEnum::Custom => "custom",
            LatencySensitivitySensitivityLevelEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        LATENCY_SENSITIVITY_SENSITIVITY_LEVEL_ENUM_MAP.get(s).cloned().unwrap_or_else(|| LatencySensitivitySensitivityLevelEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for LatencySensitivitySensitivityLevelEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for LatencySensitivitySensitivityLevelEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<LatencySensitivitySensitivityLevelEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(LatencySensitivitySensitivityLevelEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for LatencySensitivitySensitivityLevelEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for LatencySensitivitySensitivityLevelEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a LatencySensitivitySensitivityLevelEnum> for &'a str {
    fn from(value: &'a LatencySensitivitySensitivityLevelEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for LatencySensitivitySensitivityLevelEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static LICENSE_FEATURE_INFO_UNIT_ENUM_MAP: phf::Map<&'static str, LicenseFeatureInfoUnitEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("cpuCore", LicenseFeatureInfoUnitEnum::CpuCore),
        ("host", LicenseFeatureInfoUnitEnum::Host),
        ("server", LicenseFeatureInfoUnitEnum::Server),
        ("cpuPackage", LicenseFeatureInfoUnitEnum::CpuPackage),
        ("vm", LicenseFeatureInfoUnitEnum::Vm),
    ],
};

impl LicenseFeatureInfoUnitEnum {
    pub fn as_str(&self) -> &str {
        match self {
            LicenseFeatureInfoUnitEnum::Host => "host",
            LicenseFeatureInfoUnitEnum::CpuCore => "cpuCore",
            LicenseFeatureInfoUnitEnum::CpuPackage => "cpuPackage",
            LicenseFeatureInfoUnitEnum::Server => "server",
            LicenseFeatureInfoUnitEnum::Vm => "vm",
            LicenseFeatureInfoUnitEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        LICENSE_FEATURE_INFO_UNIT_ENUM_MAP.get(s).cloned().unwrap_or_else(|| LicenseFeatureInfoUnitEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for LicenseFeatureInfoUnitEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for LicenseFeatureInfoUnitEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<LicenseFeatureInfoUnitEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(LicenseFeatureInfoUnitEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for LicenseFeatureInfoUnitEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for LicenseFeatureInfoUnitEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a LicenseFeatureInfoUnitEnum> for &'a str {
    fn from(value: &'a LicenseFeatureInfoUnitEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for LicenseFeatureInfoUnitEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static LICENSE_FEATURE_INFO_SOURCE_RESTRICTION_ENUM_MAP: phf::Map<&'static str, LicenseFeatureInfoSourceRestrictionEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("served", LicenseFeatureInfoSourceRestrictionEnum::Served),
        ("unrestricted", LicenseFeatureInfoSourceRestrictionEnum::Unrestricted),
        ("file", LicenseFeatureInfoSourceRestrictionEnum::File),
    ],
};

impl LicenseFeatureInfoSourceRestrictionEnum {
    pub fn as_str(&self) -> &str {
        match self {
            LicenseFeatureInfoSourceRestrictionEnum::Unrestricted => "unrestricted",
            LicenseFeatureInfoSourceRestrictionEnum::Served => "served",
            LicenseFeatureInfoSourceRestrictionEnum::File => "file",
            LicenseFeatureInfoSourceRestrictionEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        LICENSE_FEATURE_INFO_SOURCE_RESTRICTION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| LicenseFeatureInfoSourceRestrictionEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for LicenseFeatureInfoSourceRestrictionEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for LicenseFeatureInfoSourceRestrictionEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<LicenseFeatureInfoSourceRestrictionEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(LicenseFeatureInfoSourceRestrictionEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for LicenseFeatureInfoSourceRestrictionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for LicenseFeatureInfoSourceRestrictionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a LicenseFeatureInfoSourceRestrictionEnum> for &'a str {
    fn from(value: &'a LicenseFeatureInfoSourceRestrictionEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for LicenseFeatureInfoSourceRestrictionEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static LICENSE_FEATURE_INFO_STATE_ENUM_MAP: phf::Map<&'static str, LicenseFeatureInfoStateEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("disabled", LicenseFeatureInfoStateEnum::Disabled),
        ("enabled", LicenseFeatureInfoStateEnum::Enabled),
        ("optional", LicenseFeatureInfoStateEnum::Optional),
    ],
};

impl LicenseFeatureInfoStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            LicenseFeatureInfoStateEnum::Enabled => "enabled",
            LicenseFeatureInfoStateEnum::Disabled => "disabled",
            LicenseFeatureInfoStateEnum::Optional => "optional",
            LicenseFeatureInfoStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        LICENSE_FEATURE_INFO_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| LicenseFeatureInfoStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for LicenseFeatureInfoStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for LicenseFeatureInfoStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<LicenseFeatureInfoStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(LicenseFeatureInfoStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for LicenseFeatureInfoStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for LicenseFeatureInfoStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a LicenseFeatureInfoStateEnum> for &'a str {
    fn from(value: &'a LicenseFeatureInfoStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for LicenseFeatureInfoStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_LICENSABLE_RESOURCE_KEY_ENUM_MAP: phf::Map<&'static str, HostLicensableResourceKeyEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 5),
        (6, 0),
    ],
    entries: &[
        ("numVmsStarted", HostLicensableResourceKeyEnum::NumVmsStarted),
        ("memorySize", HostLicensableResourceKeyEnum::MemorySize),
        ("numCpuCores", HostLicensableResourceKeyEnum::NumCpuCores),
        ("numCpuPackages", HostLicensableResourceKeyEnum::NumCpuPackages),
        ("vsanCapacity", HostLicensableResourceKeyEnum::VsanCapacity),
        ("memoryForVms", HostLicensableResourceKeyEnum::MemoryForVms),
        ("numVmsStarting", HostLicensableResourceKeyEnum::NumVmsStarting),
    ],
};

impl HostLicensableResourceKeyEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostLicensableResourceKeyEnum::NumCpuPackages => "numCpuPackages",
            HostLicensableResourceKeyEnum::NumCpuCores => "numCpuCores",
            HostLicensableResourceKeyEnum::MemorySize => "memorySize",
            HostLicensableResourceKeyEnum::MemoryForVms => "memoryForVms",
            HostLicensableResourceKeyEnum::NumVmsStarted => "numVmsStarted",
            HostLicensableResourceKeyEnum::NumVmsStarting => "numVmsStarting",
            HostLicensableResourceKeyEnum::VsanCapacity => "vsanCapacity",
            HostLicensableResourceKeyEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_LICENSABLE_RESOURCE_KEY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostLicensableResourceKeyEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostLicensableResourceKeyEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostLicensableResourceKeyEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostLicensableResourceKeyEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostLicensableResourceKeyEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostLicensableResourceKeyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostLicensableResourceKeyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostLicensableResourceKeyEnum> for &'a str {
    fn from(value: &'a HostLicensableResourceKeyEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostLicensableResourceKeyEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static LICENSE_MANAGER_LICENSE_KEY_ENUM_MAP: phf::Map<&'static str, LicenseManagerLicenseKeyEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
        (7, 0),
        (4, 10),
        (4, 15),
    ],
    entries: &[
        ("esxExpress", LicenseManagerLicenseKeyEnum::EsxExpress),
        ("das", LicenseManagerLicenseKeyEnum::Das),
        ("esxHost", LicenseManagerLicenseKeyEnum::EsxHost),
        ("esxFull", LicenseManagerLicenseKeyEnum::EsxFull),
        ("iscsi", LicenseManagerLicenseKeyEnum::Iscsi),
        ("vcExpress", LicenseManagerLicenseKeyEnum::VcExpress),
        ("san", LicenseManagerLicenseKeyEnum::San),
        ("nas", LicenseManagerLicenseKeyEnum::Nas),
        ("esxVmtn", LicenseManagerLicenseKeyEnum::EsxVmtn),
        ("vc", LicenseManagerLicenseKeyEnum::Vc),
        ("serverHost", LicenseManagerLicenseKeyEnum::ServerHost),
        ("vsmp", LicenseManagerLicenseKeyEnum::Vsmp),
        ("drs", LicenseManagerLicenseKeyEnum::Drs),
        ("vmotion", LicenseManagerLicenseKeyEnum::Vmotion),
        ("backup", LicenseManagerLicenseKeyEnum::Backup),
        ("gsxHost", LicenseManagerLicenseKeyEnum::GsxHost),
        ("drsPower", LicenseManagerLicenseKeyEnum::DrsPower),
    ],
};

impl LicenseManagerLicenseKeyEnum {
    pub fn as_str(&self) -> &str {
        match self {
            LicenseManagerLicenseKeyEnum::EsxFull => "esxFull",
            LicenseManagerLicenseKeyEnum::EsxVmtn => "esxVmtn",
            LicenseManagerLicenseKeyEnum::EsxExpress => "esxExpress",
            LicenseManagerLicenseKeyEnum::San => "san",
            LicenseManagerLicenseKeyEnum::Iscsi => "iscsi",
            LicenseManagerLicenseKeyEnum::Nas => "nas",
            LicenseManagerLicenseKeyEnum::Vsmp => "vsmp",
            LicenseManagerLicenseKeyEnum::Backup => "backup",
            LicenseManagerLicenseKeyEnum::Vc => "vc",
            LicenseManagerLicenseKeyEnum::VcExpress => "vcExpress",
            LicenseManagerLicenseKeyEnum::EsxHost => "esxHost",
            LicenseManagerLicenseKeyEnum::GsxHost => "gsxHost",
            LicenseManagerLicenseKeyEnum::ServerHost => "serverHost",
            LicenseManagerLicenseKeyEnum::DrsPower => "drsPower",
            LicenseManagerLicenseKeyEnum::Vmotion => "vmotion",
            LicenseManagerLicenseKeyEnum::Drs => "drs",
            LicenseManagerLicenseKeyEnum::Das => "das",
            LicenseManagerLicenseKeyEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        LICENSE_MANAGER_LICENSE_KEY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| LicenseManagerLicenseKeyEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for LicenseManagerLicenseKeyEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for LicenseManagerLicenseKeyEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<LicenseManagerLicenseKeyEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(LicenseManagerLicenseKeyEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for LicenseManagerLicenseKeyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for LicenseManagerLicenseKeyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a LicenseManagerLicenseKeyEnum> for &'a str {
    fn from(value: &'a LicenseManagerLicenseKeyEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for LicenseManagerLicenseKeyEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static LICENSE_MANAGER_STATE_ENUM_MAP: phf::Map<&'static str, LicenseManagerStateEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("normal", LicenseManagerStateEnum::Normal),
        ("fault", LicenseManagerStateEnum::Fault),
        ("marginal", LicenseManagerStateEnum::Marginal),
        ("initializing", LicenseManagerStateEnum::Initializing),
    ],
};

impl LicenseManagerStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            LicenseManagerStateEnum::Initializing => "initializing",
            LicenseManagerStateEnum::Normal => "normal",
            LicenseManagerStateEnum::Marginal => "marginal",
            LicenseManagerStateEnum::Fault => "fault",
            LicenseManagerStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        LICENSE_MANAGER_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| LicenseManagerStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for LicenseManagerStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for LicenseManagerStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<LicenseManagerStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(LicenseManagerStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for LicenseManagerStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for LicenseManagerStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a LicenseManagerStateEnum> for &'a str {
    fn from(value: &'a LicenseManagerStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for LicenseManagerStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static LICENSE_RESERVATION_INFO_STATE_ENUM_MAP: phf::Map<&'static str, LicenseReservationInfoStateEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("unlicensedUse", LicenseReservationInfoStateEnum::UnlicensedUse),
        ("notUsed", LicenseReservationInfoStateEnum::NotUsed),
        ("licensed", LicenseReservationInfoStateEnum::Licensed),
        ("noLicense", LicenseReservationInfoStateEnum::NoLicense),
    ],
};

impl LicenseReservationInfoStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            LicenseReservationInfoStateEnum::NotUsed => "notUsed",
            LicenseReservationInfoStateEnum::NoLicense => "noLicense",
            LicenseReservationInfoStateEnum::UnlicensedUse => "unlicensedUse",
            LicenseReservationInfoStateEnum::Licensed => "licensed",
            LicenseReservationInfoStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        LICENSE_RESERVATION_INFO_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| LicenseReservationInfoStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for LicenseReservationInfoStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for LicenseReservationInfoStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<LicenseReservationInfoStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(LicenseReservationInfoStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for LicenseReservationInfoStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for LicenseReservationInfoStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a LicenseReservationInfoStateEnum> for &'a str {
    fn from(value: &'a LicenseReservationInfoStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for LicenseReservationInfoStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static MANAGED_ENTITY_STATUS_ENUM_MAP: phf::Map<&'static str, ManagedEntityStatusEnum> = ::phf::Map {
    key: 2980949210194914378,
    disps: &[
        (3, 0),
    ],
    entries: &[
        ("gray", ManagedEntityStatusEnum::Gray),
        ("green", ManagedEntityStatusEnum::Green),
        ("red", ManagedEntityStatusEnum::Red),
        ("yellow", ManagedEntityStatusEnum::Yellow),
    ],
};

impl ManagedEntityStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ManagedEntityStatusEnum::Gray => "gray",
            ManagedEntityStatusEnum::Green => "green",
            ManagedEntityStatusEnum::Yellow => "yellow",
            ManagedEntityStatusEnum::Red => "red",
            ManagedEntityStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        MANAGED_ENTITY_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ManagedEntityStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ManagedEntityStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ManagedEntityStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ManagedEntityStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ManagedEntityStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ManagedEntityStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ManagedEntityStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ManagedEntityStatusEnum> for &'a str {
    fn from(value: &'a ManagedEntityStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ManagedEntityStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static OVF_CONSUMER_OST_NODE_TYPE_ENUM_MAP: phf::Map<&'static str, OvfConsumerOstNodeTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("envelope", OvfConsumerOstNodeTypeEnum::Envelope),
        ("virtualSystemCollection", OvfConsumerOstNodeTypeEnum::VirtualSystemCollection),
        ("virtualSystem", OvfConsumerOstNodeTypeEnum::VirtualSystem),
    ],
};

impl OvfConsumerOstNodeTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            OvfConsumerOstNodeTypeEnum::Envelope => "envelope",
            OvfConsumerOstNodeTypeEnum::VirtualSystem => "virtualSystem",
            OvfConsumerOstNodeTypeEnum::VirtualSystemCollection => "virtualSystemCollection",
            OvfConsumerOstNodeTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        OVF_CONSUMER_OST_NODE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| OvfConsumerOstNodeTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for OvfConsumerOstNodeTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for OvfConsumerOstNodeTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<OvfConsumerOstNodeTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(OvfConsumerOstNodeTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for OvfConsumerOstNodeTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for OvfConsumerOstNodeTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a OvfConsumerOstNodeTypeEnum> for &'a str {
    fn from(value: &'a OvfConsumerOstNodeTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for OvfConsumerOstNodeTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static OVF_CREATE_IMPORT_SPEC_PARAMS_DISK_PROVISIONING_TYPE_ENUM_MAP: phf::Map<&'static str, OvfCreateImportSpecParamsDiskProvisioningTypeEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (3, 0),
        (8, 6),
    ],
    entries: &[
        ("twoGbMaxExtentFlat", OvfCreateImportSpecParamsDiskProvisioningTypeEnum::TwoGbMaxExtentFlat),
        ("thick", OvfCreateImportSpecParamsDiskProvisioningTypeEnum::Thick),
        ("seSparse", OvfCreateImportSpecParamsDiskProvisioningTypeEnum::SeSparse),
        ("sparse", OvfCreateImportSpecParamsDiskProvisioningTypeEnum::Sparse),
        ("monolithicSparse", OvfCreateImportSpecParamsDiskProvisioningTypeEnum::MonolithicSparse),
        ("monolithicFlat", OvfCreateImportSpecParamsDiskProvisioningTypeEnum::MonolithicFlat),
        ("flat", OvfCreateImportSpecParamsDiskProvisioningTypeEnum::Flat),
        ("eagerZeroedThick", OvfCreateImportSpecParamsDiskProvisioningTypeEnum::EagerZeroedThick),
        ("thin", OvfCreateImportSpecParamsDiskProvisioningTypeEnum::Thin),
        ("twoGbMaxExtentSparse", OvfCreateImportSpecParamsDiskProvisioningTypeEnum::TwoGbMaxExtentSparse),
    ],
};

impl OvfCreateImportSpecParamsDiskProvisioningTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            OvfCreateImportSpecParamsDiskProvisioningTypeEnum::MonolithicSparse => "monolithicSparse",
            OvfCreateImportSpecParamsDiskProvisioningTypeEnum::MonolithicFlat => "monolithicFlat",
            OvfCreateImportSpecParamsDiskProvisioningTypeEnum::TwoGbMaxExtentSparse => "twoGbMaxExtentSparse",
            OvfCreateImportSpecParamsDiskProvisioningTypeEnum::TwoGbMaxExtentFlat => "twoGbMaxExtentFlat",
            OvfCreateImportSpecParamsDiskProvisioningTypeEnum::Thin => "thin",
            OvfCreateImportSpecParamsDiskProvisioningTypeEnum::Thick => "thick",
            OvfCreateImportSpecParamsDiskProvisioningTypeEnum::SeSparse => "seSparse",
            OvfCreateImportSpecParamsDiskProvisioningTypeEnum::EagerZeroedThick => "eagerZeroedThick",
            OvfCreateImportSpecParamsDiskProvisioningTypeEnum::Sparse => "sparse",
            OvfCreateImportSpecParamsDiskProvisioningTypeEnum::Flat => "flat",
            OvfCreateImportSpecParamsDiskProvisioningTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        OVF_CREATE_IMPORT_SPEC_PARAMS_DISK_PROVISIONING_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| OvfCreateImportSpecParamsDiskProvisioningTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for OvfCreateImportSpecParamsDiskProvisioningTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for OvfCreateImportSpecParamsDiskProvisioningTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<OvfCreateImportSpecParamsDiskProvisioningTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(OvfCreateImportSpecParamsDiskProvisioningTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for OvfCreateImportSpecParamsDiskProvisioningTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for OvfCreateImportSpecParamsDiskProvisioningTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a OvfCreateImportSpecParamsDiskProvisioningTypeEnum> for &'a str {
    fn from(value: &'a OvfCreateImportSpecParamsDiskProvisioningTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for OvfCreateImportSpecParamsDiskProvisioningTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PERF_SUMMARY_TYPE_ENUM_MAP: phf::Map<&'static str, PerfSummaryTypeEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (1, 0),
        (0, 5),
    ],
    entries: &[
        ("latest", PerfSummaryTypeEnum::Latest),
        ("maximum", PerfSummaryTypeEnum::Maximum),
        ("minimum", PerfSummaryTypeEnum::Minimum),
        ("average", PerfSummaryTypeEnum::Average),
        ("none", PerfSummaryTypeEnum::None),
        ("summation", PerfSummaryTypeEnum::Summation),
    ],
};

impl PerfSummaryTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PerfSummaryTypeEnum::Average => "average",
            PerfSummaryTypeEnum::Maximum => "maximum",
            PerfSummaryTypeEnum::Minimum => "minimum",
            PerfSummaryTypeEnum::Latest => "latest",
            PerfSummaryTypeEnum::Summation => "summation",
            PerfSummaryTypeEnum::None => "none",
            PerfSummaryTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PERF_SUMMARY_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PerfSummaryTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PerfSummaryTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PerfSummaryTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PerfSummaryTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PerfSummaryTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PerfSummaryTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PerfSummaryTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PerfSummaryTypeEnum> for &'a str {
    fn from(value: &'a PerfSummaryTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PerfSummaryTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PERF_STATS_TYPE_ENUM_MAP: phf::Map<&'static str, PerfStatsTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("rate", PerfStatsTypeEnum::Rate),
        ("absolute", PerfStatsTypeEnum::Absolute),
        ("delta", PerfStatsTypeEnum::Delta),
    ],
};

impl PerfStatsTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PerfStatsTypeEnum::Absolute => "absolute",
            PerfStatsTypeEnum::Delta => "delta",
            PerfStatsTypeEnum::Rate => "rate",
            PerfStatsTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PERF_STATS_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PerfStatsTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PerfStatsTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PerfStatsTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PerfStatsTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PerfStatsTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PerfStatsTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PerfStatsTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PerfStatsTypeEnum> for &'a str {
    fn from(value: &'a PerfStatsTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PerfStatsTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PERFORMANCE_MANAGER_UNIT_ENUM_MAP: phf::Map<&'static str, PerformanceManagerUnitEnum> = ::phf::Map {
    key: 8694567506910003252,
    disps: &[
        (4, 0),
        (0, 0),
        (14, 3),
    ],
    entries: &[
        ("joule", PerformanceManagerUnitEnum::Joule),
        ("number", PerformanceManagerUnitEnum::Number),
        ("percent", PerformanceManagerUnitEnum::Percent),
        ("megaBytes", PerformanceManagerUnitEnum::MegaBytes),
        ("celsius", PerformanceManagerUnitEnum::Celsius),
        ("microsecond", PerformanceManagerUnitEnum::Microsecond),
        ("second", PerformanceManagerUnitEnum::Second),
        ("watt", PerformanceManagerUnitEnum::Watt),
        ("megaHertz", PerformanceManagerUnitEnum::MegaHertz),
        ("kiloBytes", PerformanceManagerUnitEnum::KiloBytes),
        ("kiloBytesPerSecond", PerformanceManagerUnitEnum::KiloBytesPerSecond),
        ("megaBytesPerSecond", PerformanceManagerUnitEnum::MegaBytesPerSecond),
        ("millisecond", PerformanceManagerUnitEnum::Millisecond),
        ("nanosecond", PerformanceManagerUnitEnum::Nanosecond),
        ("teraBytes", PerformanceManagerUnitEnum::TeraBytes),
    ],
};

impl PerformanceManagerUnitEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PerformanceManagerUnitEnum::Percent => "percent",
            PerformanceManagerUnitEnum::KiloBytes => "kiloBytes",
            PerformanceManagerUnitEnum::MegaBytes => "megaBytes",
            PerformanceManagerUnitEnum::MegaHertz => "megaHertz",
            PerformanceManagerUnitEnum::Number => "number",
            PerformanceManagerUnitEnum::Microsecond => "microsecond",
            PerformanceManagerUnitEnum::Millisecond => "millisecond",
            PerformanceManagerUnitEnum::Second => "second",
            PerformanceManagerUnitEnum::KiloBytesPerSecond => "kiloBytesPerSecond",
            PerformanceManagerUnitEnum::MegaBytesPerSecond => "megaBytesPerSecond",
            PerformanceManagerUnitEnum::Watt => "watt",
            PerformanceManagerUnitEnum::Joule => "joule",
            PerformanceManagerUnitEnum::TeraBytes => "teraBytes",
            PerformanceManagerUnitEnum::Celsius => "celsius",
            PerformanceManagerUnitEnum::Nanosecond => "nanosecond",
            PerformanceManagerUnitEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PERFORMANCE_MANAGER_UNIT_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PerformanceManagerUnitEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PerformanceManagerUnitEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PerformanceManagerUnitEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PerformanceManagerUnitEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PerformanceManagerUnitEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PerformanceManagerUnitEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PerformanceManagerUnitEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PerformanceManagerUnitEnum> for &'a str {
    fn from(value: &'a PerformanceManagerUnitEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PerformanceManagerUnitEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PERF_FORMAT_ENUM_MAP: phf::Map<&'static str, PerfFormatEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("csv", PerfFormatEnum::Csv),
        ("normal", PerfFormatEnum::Normal),
    ],
};

impl PerfFormatEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PerfFormatEnum::Normal => "normal",
            PerfFormatEnum::Csv => "csv",
            PerfFormatEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PERF_FORMAT_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PerfFormatEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PerfFormatEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PerfFormatEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PerfFormatEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PerfFormatEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PerfFormatEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PerfFormatEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PerfFormatEnum> for &'a str {
    fn from(value: &'a PerfFormatEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PerfFormatEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PLACE_VMS_X_CLUSTER_SPEC_PLACEMENT_TYPE_ENUM_MAP: phf::Map<&'static str, PlaceVmsXClusterSpecPlacementTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("createAndPowerOn", PlaceVmsXClusterSpecPlacementTypeEnum::CreateAndPowerOn),
        ("reconfigure", PlaceVmsXClusterSpecPlacementTypeEnum::Reconfigure),
        ("relocate", PlaceVmsXClusterSpecPlacementTypeEnum::Relocate),
    ],
};

impl PlaceVmsXClusterSpecPlacementTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PlaceVmsXClusterSpecPlacementTypeEnum::CreateAndPowerOn => "createAndPowerOn",
            PlaceVmsXClusterSpecPlacementTypeEnum::Reconfigure => "reconfigure",
            PlaceVmsXClusterSpecPlacementTypeEnum::Relocate => "relocate",
            PlaceVmsXClusterSpecPlacementTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PLACE_VMS_X_CLUSTER_SPEC_PLACEMENT_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PlaceVmsXClusterSpecPlacementTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PlaceVmsXClusterSpecPlacementTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PlaceVmsXClusterSpecPlacementTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PlaceVmsXClusterSpecPlacementTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PlaceVmsXClusterSpecPlacementTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PlaceVmsXClusterSpecPlacementTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PlaceVmsXClusterSpecPlacementTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PlaceVmsXClusterSpecPlacementTypeEnum> for &'a str {
    fn from(value: &'a PlaceVmsXClusterSpecPlacementTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PlaceVmsXClusterSpecPlacementTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static RESOURCE_CONFIG_SPEC_SCALE_SHARES_BEHAVIOR_ENUM_MAP: phf::Map<&'static str, ResourceConfigSpecScaleSharesBehaviorEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("scaleCpuAndMemoryShares", ResourceConfigSpecScaleSharesBehaviorEnum::ScaleCpuAndMemoryShares),
        ("disabled", ResourceConfigSpecScaleSharesBehaviorEnum::Disabled),
    ],
};

impl ResourceConfigSpecScaleSharesBehaviorEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ResourceConfigSpecScaleSharesBehaviorEnum::Disabled => "disabled",
            ResourceConfigSpecScaleSharesBehaviorEnum::ScaleCpuAndMemoryShares => "scaleCpuAndMemoryShares",
            ResourceConfigSpecScaleSharesBehaviorEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        RESOURCE_CONFIG_SPEC_SCALE_SHARES_BEHAVIOR_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ResourceConfigSpecScaleSharesBehaviorEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ResourceConfigSpecScaleSharesBehaviorEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ResourceConfigSpecScaleSharesBehaviorEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ResourceConfigSpecScaleSharesBehaviorEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ResourceConfigSpecScaleSharesBehaviorEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ResourceConfigSpecScaleSharesBehaviorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ResourceConfigSpecScaleSharesBehaviorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ResourceConfigSpecScaleSharesBehaviorEnum> for &'a str {
    fn from(value: &'a ResourceConfigSpecScaleSharesBehaviorEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ResourceConfigSpecScaleSharesBehaviorEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static V_MOTION_COMPATIBILITY_TYPE_ENUM_MAP: phf::Map<&'static str, VMotionCompatibilityTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("software", VMotionCompatibilityTypeEnum::Software),
        ("cpu", VMotionCompatibilityTypeEnum::Cpu),
    ],
};

impl VMotionCompatibilityTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VMotionCompatibilityTypeEnum::Cpu => "cpu",
            VMotionCompatibilityTypeEnum::Software => "software",
            VMotionCompatibilityTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        V_MOTION_COMPATIBILITY_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VMotionCompatibilityTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VMotionCompatibilityTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VMotionCompatibilityTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VMotionCompatibilityTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VMotionCompatibilityTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VMotionCompatibilityTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VMotionCompatibilityTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VMotionCompatibilityTypeEnum> for &'a str {
    fn from(value: &'a VMotionCompatibilityTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VMotionCompatibilityTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VALIDATE_MIGRATION_TEST_TYPE_ENUM_MAP: phf::Map<&'static str, ValidateMigrationTestTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (3, 0),
    ],
    entries: &[
        ("sourceTests", ValidateMigrationTestTypeEnum::SourceTests),
        ("compatibilityTests", ValidateMigrationTestTypeEnum::CompatibilityTests),
        ("diskAccessibilityTests", ValidateMigrationTestTypeEnum::DiskAccessibilityTests),
        ("resourceTests", ValidateMigrationTestTypeEnum::ResourceTests),
    ],
};

impl ValidateMigrationTestTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ValidateMigrationTestTypeEnum::SourceTests => "sourceTests",
            ValidateMigrationTestTypeEnum::CompatibilityTests => "compatibilityTests",
            ValidateMigrationTestTypeEnum::DiskAccessibilityTests => "diskAccessibilityTests",
            ValidateMigrationTestTypeEnum::ResourceTests => "resourceTests",
            ValidateMigrationTestTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VALIDATE_MIGRATION_TEST_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ValidateMigrationTestTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ValidateMigrationTestTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ValidateMigrationTestTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ValidateMigrationTestTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ValidateMigrationTestTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ValidateMigrationTestTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ValidateMigrationTestTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ValidateMigrationTestTypeEnum> for &'a str {
    fn from(value: &'a ValidateMigrationTestTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ValidateMigrationTestTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static SESSION_MANAGER_GENERIC_SERVICE_TICKET_TICKET_TYPE_ENUM_MAP: phf::Map<&'static str, SessionManagerGenericServiceTicketTicketTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("VcServiceTicket", SessionManagerGenericServiceTicketTicketTypeEnum::VcServiceTicket),
        ("HttpNfcServiceTicket", SessionManagerGenericServiceTicketTicketTypeEnum::HttpNfcServiceTicket),
        ("HostServiceTicket", SessionManagerGenericServiceTicketTicketTypeEnum::HostServiceTicket),
    ],
};

impl SessionManagerGenericServiceTicketTicketTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            SessionManagerGenericServiceTicketTicketTypeEnum::HttpNfcServiceTicket => "HttpNfcServiceTicket",
            SessionManagerGenericServiceTicketTicketTypeEnum::HostServiceTicket => "HostServiceTicket",
            SessionManagerGenericServiceTicketTicketTypeEnum::VcServiceTicket => "VcServiceTicket",
            SessionManagerGenericServiceTicketTicketTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        SESSION_MANAGER_GENERIC_SERVICE_TICKET_TICKET_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| SessionManagerGenericServiceTicketTicketTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for SessionManagerGenericServiceTicketTicketTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for SessionManagerGenericServiceTicketTicketTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<SessionManagerGenericServiceTicketTicketTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(SessionManagerGenericServiceTicketTicketTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for SessionManagerGenericServiceTicketTicketTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for SessionManagerGenericServiceTicketTicketTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a SessionManagerGenericServiceTicketTicketTypeEnum> for &'a str {
    fn from(value: &'a SessionManagerGenericServiceTicketTicketTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for SessionManagerGenericServiceTicketTicketTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static SESSION_MANAGER_HTTP_SERVICE_REQUEST_SPEC_METHOD_ENUM_MAP: phf::Map<&'static str, SessionManagerHttpServiceRequestSpecMethodEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (3, 2),
        (2, 0),
    ],
    entries: &[
        ("httpOptions", SessionManagerHttpServiceRequestSpecMethodEnum::HttpOptions),
        ("httpConnect", SessionManagerHttpServiceRequestSpecMethodEnum::HttpConnect),
        ("httpHead", SessionManagerHttpServiceRequestSpecMethodEnum::HttpHead),
        ("httpPut", SessionManagerHttpServiceRequestSpecMethodEnum::HttpPut),
        ("httpDelete", SessionManagerHttpServiceRequestSpecMethodEnum::HttpDelete),
        ("httpTrace", SessionManagerHttpServiceRequestSpecMethodEnum::HttpTrace),
        ("httpPost", SessionManagerHttpServiceRequestSpecMethodEnum::HttpPost),
        ("httpGet", SessionManagerHttpServiceRequestSpecMethodEnum::HttpGet),
    ],
};

impl SessionManagerHttpServiceRequestSpecMethodEnum {
    pub fn as_str(&self) -> &str {
        match self {
            SessionManagerHttpServiceRequestSpecMethodEnum::HttpOptions => "httpOptions",
            SessionManagerHttpServiceRequestSpecMethodEnum::HttpGet => "httpGet",
            SessionManagerHttpServiceRequestSpecMethodEnum::HttpHead => "httpHead",
            SessionManagerHttpServiceRequestSpecMethodEnum::HttpPost => "httpPost",
            SessionManagerHttpServiceRequestSpecMethodEnum::HttpPut => "httpPut",
            SessionManagerHttpServiceRequestSpecMethodEnum::HttpDelete => "httpDelete",
            SessionManagerHttpServiceRequestSpecMethodEnum::HttpTrace => "httpTrace",
            SessionManagerHttpServiceRequestSpecMethodEnum::HttpConnect => "httpConnect",
            SessionManagerHttpServiceRequestSpecMethodEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        SESSION_MANAGER_HTTP_SERVICE_REQUEST_SPEC_METHOD_ENUM_MAP.get(s).cloned().unwrap_or_else(|| SessionManagerHttpServiceRequestSpecMethodEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for SessionManagerHttpServiceRequestSpecMethodEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for SessionManagerHttpServiceRequestSpecMethodEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<SessionManagerHttpServiceRequestSpecMethodEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(SessionManagerHttpServiceRequestSpecMethodEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for SessionManagerHttpServiceRequestSpecMethodEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for SessionManagerHttpServiceRequestSpecMethodEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a SessionManagerHttpServiceRequestSpecMethodEnum> for &'a str {
    fn from(value: &'a SessionManagerHttpServiceRequestSpecMethodEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for SessionManagerHttpServiceRequestSpecMethodEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static SHARES_LEVEL_ENUM_MAP: phf::Map<&'static str, SharesLevelEnum> = ::phf::Map {
    key: 2980949210194914378,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("high", SharesLevelEnum::High),
        ("low", SharesLevelEnum::Low),
        ("custom", SharesLevelEnum::Custom),
        ("normal", SharesLevelEnum::Normal),
    ],
};

impl SharesLevelEnum {
    pub fn as_str(&self) -> &str {
        match self {
            SharesLevelEnum::Low => "low",
            SharesLevelEnum::Normal => "normal",
            SharesLevelEnum::High => "high",
            SharesLevelEnum::Custom => "custom",
            SharesLevelEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        SHARES_LEVEL_ENUM_MAP.get(s).cloned().unwrap_or_else(|| SharesLevelEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for SharesLevelEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for SharesLevelEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<SharesLevelEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(SharesLevelEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for SharesLevelEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for SharesLevelEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a SharesLevelEnum> for &'a str {
    fn from(value: &'a SharesLevelEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for SharesLevelEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static SIMPLE_COMMAND_ENCODING_ENUM_MAP: phf::Map<&'static str, SimpleCommandEncodingEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("CSV", SimpleCommandEncodingEnum::Csv),
        ("HEX", SimpleCommandEncodingEnum::Hex),
        ("STRING", SimpleCommandEncodingEnum::String),
    ],
};

impl SimpleCommandEncodingEnum {
    pub fn as_str(&self) -> &str {
        match self {
            SimpleCommandEncodingEnum::Csv => "CSV",
            SimpleCommandEncodingEnum::Hex => "HEX",
            SimpleCommandEncodingEnum::String => "STRING",
            SimpleCommandEncodingEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        SIMPLE_COMMAND_ENCODING_ENUM_MAP.get(s).cloned().unwrap_or_else(|| SimpleCommandEncodingEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for SimpleCommandEncodingEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for SimpleCommandEncodingEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<SimpleCommandEncodingEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(SimpleCommandEncodingEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for SimpleCommandEncodingEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for SimpleCommandEncodingEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a SimpleCommandEncodingEnum> for &'a str {
    fn from(value: &'a SimpleCommandEncodingEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for SimpleCommandEncodingEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static STORAGE_IORM_THRESHOLD_MODE_ENUM_MAP: phf::Map<&'static str, StorageIormThresholdModeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("automatic", StorageIormThresholdModeEnum::Automatic),
        ("manual", StorageIormThresholdModeEnum::Manual),
    ],
};

impl StorageIormThresholdModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            StorageIormThresholdModeEnum::Automatic => "automatic",
            StorageIormThresholdModeEnum::Manual => "manual",
            StorageIormThresholdModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        STORAGE_IORM_THRESHOLD_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| StorageIormThresholdModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for StorageIormThresholdModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for StorageIormThresholdModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<StorageIormThresholdModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(StorageIormThresholdModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for StorageIormThresholdModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for StorageIormThresholdModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a StorageIormThresholdModeEnum> for &'a str {
    fn from(value: &'a StorageIormThresholdModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for StorageIormThresholdModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static TASK_FILTER_SPEC_RECURSION_OPTION_ENUM_MAP: phf::Map<&'static str, TaskFilterSpecRecursionOptionEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("self", TaskFilterSpecRecursionOptionEnum::Self_),
        ("children", TaskFilterSpecRecursionOptionEnum::Children),
        ("all", TaskFilterSpecRecursionOptionEnum::All),
    ],
};

impl TaskFilterSpecRecursionOptionEnum {
    pub fn as_str(&self) -> &str {
        match self {
            TaskFilterSpecRecursionOptionEnum::Self_ => "self",
            TaskFilterSpecRecursionOptionEnum::Children => "children",
            TaskFilterSpecRecursionOptionEnum::All => "all",
            TaskFilterSpecRecursionOptionEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        TASK_FILTER_SPEC_RECURSION_OPTION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| TaskFilterSpecRecursionOptionEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for TaskFilterSpecRecursionOptionEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for TaskFilterSpecRecursionOptionEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<TaskFilterSpecRecursionOptionEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(TaskFilterSpecRecursionOptionEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for TaskFilterSpecRecursionOptionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for TaskFilterSpecRecursionOptionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a TaskFilterSpecRecursionOptionEnum> for &'a str {
    fn from(value: &'a TaskFilterSpecRecursionOptionEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for TaskFilterSpecRecursionOptionEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static TASK_FILTER_SPEC_TIME_OPTION_ENUM_MAP: phf::Map<&'static str, TaskFilterSpecTimeOptionEnum> = ::phf::Map {
    key: 8694567506910003252,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("queuedTime", TaskFilterSpecTimeOptionEnum::QueuedTime),
        ("completedTime", TaskFilterSpecTimeOptionEnum::CompletedTime),
        ("startedTime", TaskFilterSpecTimeOptionEnum::StartedTime),
    ],
};

impl TaskFilterSpecTimeOptionEnum {
    pub fn as_str(&self) -> &str {
        match self {
            TaskFilterSpecTimeOptionEnum::QueuedTime => "queuedTime",
            TaskFilterSpecTimeOptionEnum::StartedTime => "startedTime",
            TaskFilterSpecTimeOptionEnum::CompletedTime => "completedTime",
            TaskFilterSpecTimeOptionEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        TASK_FILTER_SPEC_TIME_OPTION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| TaskFilterSpecTimeOptionEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for TaskFilterSpecTimeOptionEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for TaskFilterSpecTimeOptionEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<TaskFilterSpecTimeOptionEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(TaskFilterSpecTimeOptionEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for TaskFilterSpecTimeOptionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for TaskFilterSpecTimeOptionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a TaskFilterSpecTimeOptionEnum> for &'a str {
    fn from(value: &'a TaskFilterSpecTimeOptionEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for TaskFilterSpecTimeOptionEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static TASK_INFO_STATE_ENUM_MAP: phf::Map<&'static str, TaskInfoStateEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("running", TaskInfoStateEnum::Running),
        ("error", TaskInfoStateEnum::Error),
        ("success", TaskInfoStateEnum::Success),
        ("queued", TaskInfoStateEnum::Queued),
    ],
};

impl TaskInfoStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            TaskInfoStateEnum::Queued => "queued",
            TaskInfoStateEnum::Running => "running",
            TaskInfoStateEnum::Success => "success",
            TaskInfoStateEnum::Error => "error",
            TaskInfoStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        TASK_INFO_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| TaskInfoStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for TaskInfoStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for TaskInfoStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<TaskInfoStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(TaskInfoStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for TaskInfoStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for TaskInfoStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a TaskInfoStateEnum> for &'a str {
    fn from(value: &'a TaskInfoStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for TaskInfoStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_APP_V_APP_STATE_ENUM_MAP: phf::Map<&'static str, VirtualAppVAppStateEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("starting", VirtualAppVAppStateEnum::Starting),
        ("stopped", VirtualAppVAppStateEnum::Stopped),
        ("started", VirtualAppVAppStateEnum::Started),
        ("stopping", VirtualAppVAppStateEnum::Stopping),
    ],
};

impl VirtualAppVAppStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualAppVAppStateEnum::Started => "started",
            VirtualAppVAppStateEnum::Stopped => "stopped",
            VirtualAppVAppStateEnum::Starting => "starting",
            VirtualAppVAppStateEnum::Stopping => "stopping",
            VirtualAppVAppStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_APP_V_APP_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualAppVAppStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualAppVAppStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualAppVAppStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualAppVAppStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualAppVAppStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualAppVAppStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualAppVAppStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualAppVAppStateEnum> for &'a str {
    fn from(value: &'a VirtualAppVAppStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualAppVAppStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_DISK_ADAPTER_TYPE_ENUM_MAP: phf::Map<&'static str, VirtualDiskAdapterTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("lsiLogic", VirtualDiskAdapterTypeEnum::LsiLogic),
        ("busLogic", VirtualDiskAdapterTypeEnum::BusLogic),
        ("ide", VirtualDiskAdapterTypeEnum::Ide),
    ],
};

impl VirtualDiskAdapterTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualDiskAdapterTypeEnum::Ide => "ide",
            VirtualDiskAdapterTypeEnum::BusLogic => "busLogic",
            VirtualDiskAdapterTypeEnum::LsiLogic => "lsiLogic",
            VirtualDiskAdapterTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_DISK_ADAPTER_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualDiskAdapterTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualDiskAdapterTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualDiskAdapterTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualDiskAdapterTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualDiskAdapterTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualDiskAdapterTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualDiskAdapterTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualDiskAdapterTypeEnum> for &'a str {
    fn from(value: &'a VirtualDiskAdapterTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualDiskAdapterTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_DISK_TYPE_ENUM_MAP: phf::Map<&'static str, VirtualDiskTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 11),
        (5, 0),
        (0, 1),
    ],
    entries: &[
        ("rdm", VirtualDiskTypeEnum::Rdm),
        ("seSparse", VirtualDiskTypeEnum::SeSparse),
        ("rdmp", VirtualDiskTypeEnum::Rdmp),
        ("eagerZeroedThick", VirtualDiskTypeEnum::EagerZeroedThick),
        ("sparse2Gb", VirtualDiskTypeEnum::Sparse2Gb),
        ("preallocated", VirtualDiskTypeEnum::Preallocated),
        ("thick2Gb", VirtualDiskTypeEnum::Thick2Gb),
        ("delta", VirtualDiskTypeEnum::Delta),
        ("sparseMonolithic", VirtualDiskTypeEnum::SparseMonolithic),
        ("thin", VirtualDiskTypeEnum::Thin),
        ("flatMonolithic", VirtualDiskTypeEnum::FlatMonolithic),
        ("thick", VirtualDiskTypeEnum::Thick),
        ("raw", VirtualDiskTypeEnum::Raw),
    ],
};

impl VirtualDiskTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualDiskTypeEnum::Preallocated => "preallocated",
            VirtualDiskTypeEnum::Thin => "thin",
            VirtualDiskTypeEnum::SeSparse => "seSparse",
            VirtualDiskTypeEnum::Rdm => "rdm",
            VirtualDiskTypeEnum::Rdmp => "rdmp",
            VirtualDiskTypeEnum::Raw => "raw",
            VirtualDiskTypeEnum::Delta => "delta",
            VirtualDiskTypeEnum::Sparse2Gb => "sparse2Gb",
            VirtualDiskTypeEnum::Thick2Gb => "thick2Gb",
            VirtualDiskTypeEnum::EagerZeroedThick => "eagerZeroedThick",
            VirtualDiskTypeEnum::SparseMonolithic => "sparseMonolithic",
            VirtualDiskTypeEnum::FlatMonolithic => "flatMonolithic",
            VirtualDiskTypeEnum::Thick => "thick",
            VirtualDiskTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_DISK_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualDiskTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualDiskTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualDiskTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualDiskTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualDiskTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualDiskTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualDiskTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualDiskTypeEnum> for &'a str {
    fn from(value: &'a VirtualDiskTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualDiskTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_APP_HEARTBEAT_STATUS_TYPE_ENUM_MAP: phf::Map<&'static str, VirtualMachineAppHeartbeatStatusTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("appStatusRed", VirtualMachineAppHeartbeatStatusTypeEnum::AppStatusRed),
        ("appStatusGray", VirtualMachineAppHeartbeatStatusTypeEnum::AppStatusGray),
        ("appStatusGreen", VirtualMachineAppHeartbeatStatusTypeEnum::AppStatusGreen),
    ],
};

impl VirtualMachineAppHeartbeatStatusTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineAppHeartbeatStatusTypeEnum::AppStatusGray => "appStatusGray",
            VirtualMachineAppHeartbeatStatusTypeEnum::AppStatusGreen => "appStatusGreen",
            VirtualMachineAppHeartbeatStatusTypeEnum::AppStatusRed => "appStatusRed",
            VirtualMachineAppHeartbeatStatusTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_APP_HEARTBEAT_STATUS_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineAppHeartbeatStatusTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineAppHeartbeatStatusTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineAppHeartbeatStatusTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineAppHeartbeatStatusTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineAppHeartbeatStatusTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineAppHeartbeatStatusTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineAppHeartbeatStatusTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineAppHeartbeatStatusTypeEnum> for &'a str {
    fn from(value: &'a VirtualMachineAppHeartbeatStatusTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineAppHeartbeatStatusTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_CONNECTION_STATE_ENUM_MAP: phf::Map<&'static str, VirtualMachineConnectionStateEnum> = ::phf::Map {
    key: 471159234146692604,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("invalid", VirtualMachineConnectionStateEnum::Invalid),
        ("inaccessible", VirtualMachineConnectionStateEnum::Inaccessible),
        ("disconnected", VirtualMachineConnectionStateEnum::Disconnected),
        ("connected", VirtualMachineConnectionStateEnum::Connected),
        ("orphaned", VirtualMachineConnectionStateEnum::Orphaned),
    ],
};

impl VirtualMachineConnectionStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineConnectionStateEnum::Connected => "connected",
            VirtualMachineConnectionStateEnum::Disconnected => "disconnected",
            VirtualMachineConnectionStateEnum::Orphaned => "orphaned",
            VirtualMachineConnectionStateEnum::Inaccessible => "inaccessible",
            VirtualMachineConnectionStateEnum::Invalid => "invalid",
            VirtualMachineConnectionStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_CONNECTION_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineConnectionStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineConnectionStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineConnectionStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineConnectionStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineConnectionStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineConnectionStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineConnectionStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineConnectionStateEnum> for &'a str {
    fn from(value: &'a VirtualMachineConnectionStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineConnectionStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_CRYPTO_STATE_ENUM_MAP: phf::Map<&'static str, VirtualMachineCryptoStateEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("unlocked", VirtualMachineCryptoStateEnum::Unlocked),
        ("locked", VirtualMachineCryptoStateEnum::Locked),
    ],
};

impl VirtualMachineCryptoStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineCryptoStateEnum::Unlocked => "unlocked",
            VirtualMachineCryptoStateEnum::Locked => "locked",
            VirtualMachineCryptoStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_CRYPTO_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineCryptoStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineCryptoStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineCryptoStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineCryptoStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineCryptoStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineCryptoStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineCryptoStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineCryptoStateEnum> for &'a str {
    fn from(value: &'a VirtualMachineCryptoStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineCryptoStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_FAULT_TOLERANCE_STATE_ENUM_MAP: phf::Map<&'static str, VirtualMachineFaultToleranceStateEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 3),
        (0, 0),
    ],
    entries: &[
        ("notConfigured", VirtualMachineFaultToleranceStateEnum::NotConfigured),
        ("running", VirtualMachineFaultToleranceStateEnum::Running),
        ("needSecondary", VirtualMachineFaultToleranceStateEnum::NeedSecondary),
        ("starting", VirtualMachineFaultToleranceStateEnum::Starting),
        ("enabled", VirtualMachineFaultToleranceStateEnum::Enabled),
        ("disabled", VirtualMachineFaultToleranceStateEnum::Disabled),
    ],
};

impl VirtualMachineFaultToleranceStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineFaultToleranceStateEnum::NotConfigured => "notConfigured",
            VirtualMachineFaultToleranceStateEnum::Disabled => "disabled",
            VirtualMachineFaultToleranceStateEnum::Enabled => "enabled",
            VirtualMachineFaultToleranceStateEnum::NeedSecondary => "needSecondary",
            VirtualMachineFaultToleranceStateEnum::Starting => "starting",
            VirtualMachineFaultToleranceStateEnum::Running => "running",
            VirtualMachineFaultToleranceStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_FAULT_TOLERANCE_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineFaultToleranceStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineFaultToleranceStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineFaultToleranceStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineFaultToleranceStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineFaultToleranceStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineFaultToleranceStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineFaultToleranceStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineFaultToleranceStateEnum> for &'a str {
    fn from(value: &'a VirtualMachineFaultToleranceStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineFaultToleranceStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_FAULT_TOLERANCE_TYPE_ENUM_MAP: phf::Map<&'static str, VirtualMachineFaultToleranceTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("recordReplay", VirtualMachineFaultToleranceTypeEnum::RecordReplay),
        ("checkpointing", VirtualMachineFaultToleranceTypeEnum::Checkpointing),
        ("unset", VirtualMachineFaultToleranceTypeEnum::Unset),
    ],
};

impl VirtualMachineFaultToleranceTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineFaultToleranceTypeEnum::Unset => "unset",
            VirtualMachineFaultToleranceTypeEnum::RecordReplay => "recordReplay",
            VirtualMachineFaultToleranceTypeEnum::Checkpointing => "checkpointing",
            VirtualMachineFaultToleranceTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_FAULT_TOLERANCE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineFaultToleranceTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineFaultToleranceTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineFaultToleranceTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineFaultToleranceTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineFaultToleranceTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineFaultToleranceTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineFaultToleranceTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineFaultToleranceTypeEnum> for &'a str {
    fn from(value: &'a VirtualMachineFaultToleranceTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineFaultToleranceTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_MOVE_PRIORITY_ENUM_MAP: phf::Map<&'static str, VirtualMachineMovePriorityEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("highPriority", VirtualMachineMovePriorityEnum::HighPriority),
        ("lowPriority", VirtualMachineMovePriorityEnum::LowPriority),
        ("defaultPriority", VirtualMachineMovePriorityEnum::DefaultPriority),
    ],
};

impl VirtualMachineMovePriorityEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineMovePriorityEnum::LowPriority => "lowPriority",
            VirtualMachineMovePriorityEnum::HighPriority => "highPriority",
            VirtualMachineMovePriorityEnum::DefaultPriority => "defaultPriority",
            VirtualMachineMovePriorityEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_MOVE_PRIORITY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineMovePriorityEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineMovePriorityEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineMovePriorityEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineMovePriorityEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineMovePriorityEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineMovePriorityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineMovePriorityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineMovePriorityEnum> for &'a str {
    fn from(value: &'a VirtualMachineMovePriorityEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineMovePriorityEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_NEED_SECONDARY_REASON_ENUM_MAP: phf::Map<&'static str, VirtualMachineNeedSecondaryReasonEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 5),
        (2, 0),
    ],
    entries: &[
        ("lostConnection", VirtualMachineNeedSecondaryReasonEnum::LostConnection),
        ("userAction", VirtualMachineNeedSecondaryReasonEnum::UserAction),
        ("other", VirtualMachineNeedSecondaryReasonEnum::Other),
        ("divergence", VirtualMachineNeedSecondaryReasonEnum::Divergence),
        ("checkpointError", VirtualMachineNeedSecondaryReasonEnum::CheckpointError),
        ("initializing", VirtualMachineNeedSecondaryReasonEnum::Initializing),
        ("partialHardwareFailure", VirtualMachineNeedSecondaryReasonEnum::PartialHardwareFailure),
    ],
};

impl VirtualMachineNeedSecondaryReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineNeedSecondaryReasonEnum::Initializing => "initializing",
            VirtualMachineNeedSecondaryReasonEnum::Divergence => "divergence",
            VirtualMachineNeedSecondaryReasonEnum::LostConnection => "lostConnection",
            VirtualMachineNeedSecondaryReasonEnum::PartialHardwareFailure => "partialHardwareFailure",
            VirtualMachineNeedSecondaryReasonEnum::UserAction => "userAction",
            VirtualMachineNeedSecondaryReasonEnum::CheckpointError => "checkpointError",
            VirtualMachineNeedSecondaryReasonEnum::Other => "other",
            VirtualMachineNeedSecondaryReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_NEED_SECONDARY_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineNeedSecondaryReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineNeedSecondaryReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineNeedSecondaryReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineNeedSecondaryReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineNeedSecondaryReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineNeedSecondaryReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineNeedSecondaryReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineNeedSecondaryReasonEnum> for &'a str {
    fn from(value: &'a VirtualMachineNeedSecondaryReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineNeedSecondaryReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_POWER_STATE_ENUM_MAP: phf::Map<&'static str, VirtualMachinePowerStateEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("poweredOff", VirtualMachinePowerStateEnum::PoweredOff),
        ("suspended", VirtualMachinePowerStateEnum::Suspended),
        ("poweredOn", VirtualMachinePowerStateEnum::PoweredOn),
    ],
};

impl VirtualMachinePowerStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachinePowerStateEnum::PoweredOff => "poweredOff",
            VirtualMachinePowerStateEnum::PoweredOn => "poweredOn",
            VirtualMachinePowerStateEnum::Suspended => "suspended",
            VirtualMachinePowerStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_POWER_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachinePowerStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachinePowerStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachinePowerStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachinePowerStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachinePowerStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachinePowerStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachinePowerStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachinePowerStateEnum> for &'a str {
    fn from(value: &'a VirtualMachinePowerStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachinePowerStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_RECORD_REPLAY_STATE_ENUM_MAP: phf::Map<&'static str, VirtualMachineRecordReplayStateEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("recording", VirtualMachineRecordReplayStateEnum::Recording),
        ("inactive", VirtualMachineRecordReplayStateEnum::Inactive),
        ("replaying", VirtualMachineRecordReplayStateEnum::Replaying),
    ],
};

impl VirtualMachineRecordReplayStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineRecordReplayStateEnum::Recording => "recording",
            VirtualMachineRecordReplayStateEnum::Replaying => "replaying",
            VirtualMachineRecordReplayStateEnum::Inactive => "inactive",
            VirtualMachineRecordReplayStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_RECORD_REPLAY_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineRecordReplayStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineRecordReplayStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineRecordReplayStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineRecordReplayStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineRecordReplayStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineRecordReplayStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineRecordReplayStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineRecordReplayStateEnum> for &'a str {
    fn from(value: &'a VirtualMachineRecordReplayStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineRecordReplayStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_TICKET_TYPE_ENUM_MAP: phf::Map<&'static str, VirtualMachineTicketTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
        (1, 0),
    ],
    entries: &[
        ("device", VirtualMachineTicketTypeEnum::Device),
        ("guestIntegrity", VirtualMachineTicketTypeEnum::GuestIntegrity),
        ("webmks", VirtualMachineTicketTypeEnum::Webmks),
        ("webRemoteDevice", VirtualMachineTicketTypeEnum::WebRemoteDevice),
        ("guestControl", VirtualMachineTicketTypeEnum::GuestControl),
        ("mks", VirtualMachineTicketTypeEnum::Mks),
    ],
};

impl VirtualMachineTicketTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineTicketTypeEnum::Mks => "mks",
            VirtualMachineTicketTypeEnum::Device => "device",
            VirtualMachineTicketTypeEnum::GuestControl => "guestControl",
            VirtualMachineTicketTypeEnum::Webmks => "webmks",
            VirtualMachineTicketTypeEnum::GuestIntegrity => "guestIntegrity",
            VirtualMachineTicketTypeEnum::WebRemoteDevice => "webRemoteDevice",
            VirtualMachineTicketTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_TICKET_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineTicketTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineTicketTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineTicketTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineTicketTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineTicketTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineTicketTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineTicketTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineTicketTypeEnum> for &'a str {
    fn from(value: &'a VirtualMachineTicketTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineTicketTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_COMPOSITE_CONSTRAINT_CONJOINER_ENUM_ENUM_MAP: phf::Map<&'static str, VsanCompositeConstraintConjoinerEnumEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("OR", VsanCompositeConstraintConjoinerEnumEnum::Or),
        ("AND", VsanCompositeConstraintConjoinerEnumEnum::And),
        ("VsanCompositeConstraintConjoinerEnum_Unknown", VsanCompositeConstraintConjoinerEnumEnum::VsanCompositeConstraintConjoinerEnumUnknown),
        ("EXCEPT", VsanCompositeConstraintConjoinerEnumEnum::Except),
    ],
};

impl VsanCompositeConstraintConjoinerEnumEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanCompositeConstraintConjoinerEnumEnum::And => "AND",
            VsanCompositeConstraintConjoinerEnumEnum::Or => "OR",
            VsanCompositeConstraintConjoinerEnumEnum::Except => "EXCEPT",
            VsanCompositeConstraintConjoinerEnumEnum::VsanCompositeConstraintConjoinerEnumUnknown => "VsanCompositeConstraintConjoinerEnum_Unknown",
            VsanCompositeConstraintConjoinerEnumEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_COMPOSITE_CONSTRAINT_CONJOINER_ENUM_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanCompositeConstraintConjoinerEnumEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanCompositeConstraintConjoinerEnumEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanCompositeConstraintConjoinerEnumEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanCompositeConstraintConjoinerEnumEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanCompositeConstraintConjoinerEnumEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanCompositeConstraintConjoinerEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanCompositeConstraintConjoinerEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanCompositeConstraintConjoinerEnumEnum> for &'a str {
    fn from(value: &'a VsanCompositeConstraintConjoinerEnumEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanCompositeConstraintConjoinerEnumEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_MASS_COLLECTOR_OBJECT_COLLECTION_ENUM_ENUM_MAP: phf::Map<&'static str, VsanMassCollectorObjectCollectionEnumEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 4),
        (1, 6),
        (0, 0),
    ],
    entries: &[
        ("ALL_DATASTORES", VsanMassCollectorObjectCollectionEnumEnum::AllDatastores),
        ("VsanMassCollectorObjectCollectionEnum_Unknown", VsanMassCollectorObjectCollectionEnumEnum::VsanMassCollectorObjectCollectionEnumUnknown),
        ("ALL_VMFS_DATASTORES", VsanMassCollectorObjectCollectionEnumEnum::AllVmfsDatastores),
        ("ALL_VSAN_DATASTORES", VsanMassCollectorObjectCollectionEnumEnum::AllVsanDatastores),
        ("ALL_VSAN_ENABLED_CLUSTERS", VsanMassCollectorObjectCollectionEnumEnum::AllVsanEnabledClusters),
        ("ALL_CLUSTERS", VsanMassCollectorObjectCollectionEnumEnum::AllClusters),
        ("ALL_VSAN_ENABLED_HOSTS", VsanMassCollectorObjectCollectionEnumEnum::AllVsanEnabledHosts),
        ("ALL_HOSTS", VsanMassCollectorObjectCollectionEnumEnum::AllHosts),
        ("SERVICE_INSTANCE", VsanMassCollectorObjectCollectionEnumEnum::ServiceInstance),
        ("ALL_VSAN_ENABLED_HOSTS_EXCEPT_WITNESS", VsanMassCollectorObjectCollectionEnumEnum::AllVsanEnabledHostsExceptWitness),
        ("VCENTER", VsanMassCollectorObjectCollectionEnumEnum::Vcenter),
    ],
};

impl VsanMassCollectorObjectCollectionEnumEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanMassCollectorObjectCollectionEnumEnum::AllHosts => "ALL_HOSTS",
            VsanMassCollectorObjectCollectionEnumEnum::AllVsanEnabledHosts => "ALL_VSAN_ENABLED_HOSTS",
            VsanMassCollectorObjectCollectionEnumEnum::AllClusters => "ALL_CLUSTERS",
            VsanMassCollectorObjectCollectionEnumEnum::AllVsanEnabledClusters => "ALL_VSAN_ENABLED_CLUSTERS",
            VsanMassCollectorObjectCollectionEnumEnum::Vcenter => "VCENTER",
            VsanMassCollectorObjectCollectionEnumEnum::ServiceInstance => "SERVICE_INSTANCE",
            VsanMassCollectorObjectCollectionEnumEnum::AllVsanEnabledHostsExceptWitness => "ALL_VSAN_ENABLED_HOSTS_EXCEPT_WITNESS",
            VsanMassCollectorObjectCollectionEnumEnum::AllDatastores => "ALL_DATASTORES",
            VsanMassCollectorObjectCollectionEnumEnum::AllVsanDatastores => "ALL_VSAN_DATASTORES",
            VsanMassCollectorObjectCollectionEnumEnum::AllVmfsDatastores => "ALL_VMFS_DATASTORES",
            VsanMassCollectorObjectCollectionEnumEnum::VsanMassCollectorObjectCollectionEnumUnknown => "VsanMassCollectorObjectCollectionEnum_Unknown",
            VsanMassCollectorObjectCollectionEnumEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_MASS_COLLECTOR_OBJECT_COLLECTION_ENUM_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanMassCollectorObjectCollectionEnumEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanMassCollectorObjectCollectionEnumEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanMassCollectorObjectCollectionEnumEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanMassCollectorObjectCollectionEnumEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanMassCollectorObjectCollectionEnumEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanMassCollectorObjectCollectionEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanMassCollectorObjectCollectionEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanMassCollectorObjectCollectionEnumEnum> for &'a str {
    fn from(value: &'a VsanMassCollectorObjectCollectionEnumEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanMassCollectorObjectCollectionEnumEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_PROPERTY_CONSTRAINT_COMPARATOR_ENUM_ENUM_MAP: phf::Map<&'static str, VsanPropertyConstraintComparatorEnumEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (3, 5),
        (0, 0),
    ],
    entries: &[
        ("POP", VsanPropertyConstraintComparatorEnumEnum::Pop),
        ("SMALLER", VsanPropertyConstraintComparatorEnumEnum::Smaller),
        ("EQUALS", VsanPropertyConstraintComparatorEnumEnum::Equals),
        ("CONTAINS", VsanPropertyConstraintComparatorEnumEnum::Contains),
        ("VsanPropertyConstraintComparatorEnum_Unknown", VsanPropertyConstraintComparatorEnumEnum::VsanPropertyConstraintComparatorEnumUnknown),
        ("GREATER", VsanPropertyConstraintComparatorEnumEnum::Greater),
        ("TEXTUALLY_MATCHES", VsanPropertyConstraintComparatorEnumEnum::TextuallyMatches),
    ],
};

impl VsanPropertyConstraintComparatorEnumEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanPropertyConstraintComparatorEnumEnum::Equals => "EQUALS",
            VsanPropertyConstraintComparatorEnumEnum::Greater => "GREATER",
            VsanPropertyConstraintComparatorEnumEnum::Smaller => "SMALLER",
            VsanPropertyConstraintComparatorEnumEnum::Pop => "POP",
            VsanPropertyConstraintComparatorEnumEnum::Contains => "CONTAINS",
            VsanPropertyConstraintComparatorEnumEnum::TextuallyMatches => "TEXTUALLY_MATCHES",
            VsanPropertyConstraintComparatorEnumEnum::VsanPropertyConstraintComparatorEnumUnknown => "VsanPropertyConstraintComparatorEnum_Unknown",
            VsanPropertyConstraintComparatorEnumEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_PROPERTY_CONSTRAINT_COMPARATOR_ENUM_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanPropertyConstraintComparatorEnumEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanPropertyConstraintComparatorEnumEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanPropertyConstraintComparatorEnumEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanPropertyConstraintComparatorEnumEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanPropertyConstraintComparatorEnumEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanPropertyConstraintComparatorEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanPropertyConstraintComparatorEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanPropertyConstraintComparatorEnumEnum> for &'a str {
    fn from(value: &'a VsanPropertyConstraintComparatorEnumEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanPropertyConstraintComparatorEnumEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_UPGRADE_SYSTEM_UPGRADE_HISTORY_DISK_GROUP_OP_TYPE_ENUM_MAP: phf::Map<&'static str, VsanUpgradeSystemUpgradeHistoryDiskGroupOpTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("add", VsanUpgradeSystemUpgradeHistoryDiskGroupOpTypeEnum::Add),
        ("remove", VsanUpgradeSystemUpgradeHistoryDiskGroupOpTypeEnum::Remove),
    ],
};

impl VsanUpgradeSystemUpgradeHistoryDiskGroupOpTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanUpgradeSystemUpgradeHistoryDiskGroupOpTypeEnum::Add => "add",
            VsanUpgradeSystemUpgradeHistoryDiskGroupOpTypeEnum::Remove => "remove",
            VsanUpgradeSystemUpgradeHistoryDiskGroupOpTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_UPGRADE_SYSTEM_UPGRADE_HISTORY_DISK_GROUP_OP_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanUpgradeSystemUpgradeHistoryDiskGroupOpTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanUpgradeSystemUpgradeHistoryDiskGroupOpTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanUpgradeSystemUpgradeHistoryDiskGroupOpTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanUpgradeSystemUpgradeHistoryDiskGroupOpTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanUpgradeSystemUpgradeHistoryDiskGroupOpTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanUpgradeSystemUpgradeHistoryDiskGroupOpTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanUpgradeSystemUpgradeHistoryDiskGroupOpTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanUpgradeSystemUpgradeHistoryDiskGroupOpTypeEnum> for &'a str {
    fn from(value: &'a VsanUpgradeSystemUpgradeHistoryDiskGroupOpTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanUpgradeSystemUpgradeHistoryDiskGroupOpTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static ACTION_PARAMETER_ENUM_MAP: phf::Map<&'static str, ActionParameterEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (4, 0),
        (0, 2),
    ],
    entries: &[
        ("target", ActionParameterEnum::Target),
        ("oldStatus", ActionParameterEnum::OldStatus),
        ("newStatus", ActionParameterEnum::NewStatus),
        ("triggeringSummary", ActionParameterEnum::TriggeringSummary),
        ("alarm", ActionParameterEnum::Alarm),
        ("declaringSummary", ActionParameterEnum::DeclaringSummary),
        ("eventDescription", ActionParameterEnum::EventDescription),
        ("alarmName", ActionParameterEnum::AlarmName),
        ("targetName", ActionParameterEnum::TargetName),
    ],
};

impl ActionParameterEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ActionParameterEnum::TargetName => "targetName",
            ActionParameterEnum::AlarmName => "alarmName",
            ActionParameterEnum::OldStatus => "oldStatus",
            ActionParameterEnum::NewStatus => "newStatus",
            ActionParameterEnum::TriggeringSummary => "triggeringSummary",
            ActionParameterEnum::DeclaringSummary => "declaringSummary",
            ActionParameterEnum::EventDescription => "eventDescription",
            ActionParameterEnum::Target => "target",
            ActionParameterEnum::Alarm => "alarm",
            ActionParameterEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        ACTION_PARAMETER_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ActionParameterEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ActionParameterEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ActionParameterEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ActionParameterEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ActionParameterEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ActionParameterEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ActionParameterEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ActionParameterEnum> for &'a str {
    fn from(value: &'a ActionParameterEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ActionParameterEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static ALARM_FILTER_SPEC_ALARM_TYPE_BY_ENTITY_ENUM_MAP: phf::Map<&'static str, AlarmFilterSpecAlarmTypeByEntityEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("entityTypeAll", AlarmFilterSpecAlarmTypeByEntityEnum::EntityTypeAll),
        ("entityTypeHost", AlarmFilterSpecAlarmTypeByEntityEnum::EntityTypeHost),
        ("entityTypeVm", AlarmFilterSpecAlarmTypeByEntityEnum::EntityTypeVm),
    ],
};

impl AlarmFilterSpecAlarmTypeByEntityEnum {
    pub fn as_str(&self) -> &str {
        match self {
            AlarmFilterSpecAlarmTypeByEntityEnum::EntityTypeAll => "entityTypeAll",
            AlarmFilterSpecAlarmTypeByEntityEnum::EntityTypeHost => "entityTypeHost",
            AlarmFilterSpecAlarmTypeByEntityEnum::EntityTypeVm => "entityTypeVm",
            AlarmFilterSpecAlarmTypeByEntityEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        ALARM_FILTER_SPEC_ALARM_TYPE_BY_ENTITY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| AlarmFilterSpecAlarmTypeByEntityEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for AlarmFilterSpecAlarmTypeByEntityEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for AlarmFilterSpecAlarmTypeByEntityEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<AlarmFilterSpecAlarmTypeByEntityEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(AlarmFilterSpecAlarmTypeByEntityEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for AlarmFilterSpecAlarmTypeByEntityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for AlarmFilterSpecAlarmTypeByEntityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a AlarmFilterSpecAlarmTypeByEntityEnum> for &'a str {
    fn from(value: &'a AlarmFilterSpecAlarmTypeByEntityEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for AlarmFilterSpecAlarmTypeByEntityEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static ALARM_FILTER_SPEC_ALARM_TYPE_BY_TRIGGER_ENUM_MAP: phf::Map<&'static str, AlarmFilterSpecAlarmTypeByTriggerEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("triggerTypeEvent", AlarmFilterSpecAlarmTypeByTriggerEnum::TriggerTypeEvent),
        ("triggerTypeMetric", AlarmFilterSpecAlarmTypeByTriggerEnum::TriggerTypeMetric),
        ("triggerTypeAll", AlarmFilterSpecAlarmTypeByTriggerEnum::TriggerTypeAll),
    ],
};

impl AlarmFilterSpecAlarmTypeByTriggerEnum {
    pub fn as_str(&self) -> &str {
        match self {
            AlarmFilterSpecAlarmTypeByTriggerEnum::TriggerTypeAll => "triggerTypeAll",
            AlarmFilterSpecAlarmTypeByTriggerEnum::TriggerTypeEvent => "triggerTypeEvent",
            AlarmFilterSpecAlarmTypeByTriggerEnum::TriggerTypeMetric => "triggerTypeMetric",
            AlarmFilterSpecAlarmTypeByTriggerEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        ALARM_FILTER_SPEC_ALARM_TYPE_BY_TRIGGER_ENUM_MAP.get(s).cloned().unwrap_or_else(|| AlarmFilterSpecAlarmTypeByTriggerEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for AlarmFilterSpecAlarmTypeByTriggerEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for AlarmFilterSpecAlarmTypeByTriggerEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<AlarmFilterSpecAlarmTypeByTriggerEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(AlarmFilterSpecAlarmTypeByTriggerEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for AlarmFilterSpecAlarmTypeByTriggerEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for AlarmFilterSpecAlarmTypeByTriggerEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a AlarmFilterSpecAlarmTypeByTriggerEnum> for &'a str {
    fn from(value: &'a AlarmFilterSpecAlarmTypeByTriggerEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for AlarmFilterSpecAlarmTypeByTriggerEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static EVENT_ALARM_EXPRESSION_COMPARISON_OPERATOR_ENUM_MAP: phf::Map<&'static str, EventAlarmExpressionComparisonOperatorEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (1, 0),
        (0, 1),
    ],
    entries: &[
        ("notEqualTo", EventAlarmExpressionComparisonOperatorEnum::NotEqualTo),
        ("endsWith", EventAlarmExpressionComparisonOperatorEnum::EndsWith),
        ("equals", EventAlarmExpressionComparisonOperatorEnum::Equals),
        ("doesNotEndWith", EventAlarmExpressionComparisonOperatorEnum::DoesNotEndWith),
        ("startsWith", EventAlarmExpressionComparisonOperatorEnum::StartsWith),
        ("doesNotStartWith", EventAlarmExpressionComparisonOperatorEnum::DoesNotStartWith),
    ],
};

impl EventAlarmExpressionComparisonOperatorEnum {
    pub fn as_str(&self) -> &str {
        match self {
            EventAlarmExpressionComparisonOperatorEnum::Equals => "equals",
            EventAlarmExpressionComparisonOperatorEnum::NotEqualTo => "notEqualTo",
            EventAlarmExpressionComparisonOperatorEnum::StartsWith => "startsWith",
            EventAlarmExpressionComparisonOperatorEnum::DoesNotStartWith => "doesNotStartWith",
            EventAlarmExpressionComparisonOperatorEnum::EndsWith => "endsWith",
            EventAlarmExpressionComparisonOperatorEnum::DoesNotEndWith => "doesNotEndWith",
            EventAlarmExpressionComparisonOperatorEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        EVENT_ALARM_EXPRESSION_COMPARISON_OPERATOR_ENUM_MAP.get(s).cloned().unwrap_or_else(|| EventAlarmExpressionComparisonOperatorEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for EventAlarmExpressionComparisonOperatorEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for EventAlarmExpressionComparisonOperatorEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<EventAlarmExpressionComparisonOperatorEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(EventAlarmExpressionComparisonOperatorEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for EventAlarmExpressionComparisonOperatorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for EventAlarmExpressionComparisonOperatorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a EventAlarmExpressionComparisonOperatorEnum> for &'a str {
    fn from(value: &'a EventAlarmExpressionComparisonOperatorEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for EventAlarmExpressionComparisonOperatorEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static METRIC_ALARM_OPERATOR_ENUM_MAP: phf::Map<&'static str, MetricAlarmOperatorEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("isBelow", MetricAlarmOperatorEnum::IsBelow),
        ("isAbove", MetricAlarmOperatorEnum::IsAbove),
    ],
};

impl MetricAlarmOperatorEnum {
    pub fn as_str(&self) -> &str {
        match self {
            MetricAlarmOperatorEnum::IsAbove => "isAbove",
            MetricAlarmOperatorEnum::IsBelow => "isBelow",
            MetricAlarmOperatorEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        METRIC_ALARM_OPERATOR_ENUM_MAP.get(s).cloned().unwrap_or_else(|| MetricAlarmOperatorEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for MetricAlarmOperatorEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for MetricAlarmOperatorEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<MetricAlarmOperatorEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(MetricAlarmOperatorEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for MetricAlarmOperatorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for MetricAlarmOperatorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a MetricAlarmOperatorEnum> for &'a str {
    fn from(value: &'a MetricAlarmOperatorEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for MetricAlarmOperatorEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static STATE_ALARM_OPERATOR_ENUM_MAP: phf::Map<&'static str, StateAlarmOperatorEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("isUnequal", StateAlarmOperatorEnum::IsUnequal),
        ("isEqual", StateAlarmOperatorEnum::IsEqual),
    ],
};

impl StateAlarmOperatorEnum {
    pub fn as_str(&self) -> &str {
        match self {
            StateAlarmOperatorEnum::IsEqual => "isEqual",
            StateAlarmOperatorEnum::IsUnequal => "isUnequal",
            StateAlarmOperatorEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        STATE_ALARM_OPERATOR_ENUM_MAP.get(s).cloned().unwrap_or_else(|| StateAlarmOperatorEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for StateAlarmOperatorEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for StateAlarmOperatorEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<StateAlarmOperatorEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(StateAlarmOperatorEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for StateAlarmOperatorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for StateAlarmOperatorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a StateAlarmOperatorEnum> for &'a str {
    fn from(value: &'a StateAlarmOperatorEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for StateAlarmOperatorEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static ACTION_TYPE_ENUM_MAP: phf::Map<&'static str, ActionTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
        (1, 5),
    ],
    entries: &[
        ("StorageMigrationV1", ActionTypeEnum::StorageMigrationV1),
        ("HostInfraUpdateHaV1", ActionTypeEnum::HostInfraUpdateHaV1),
        ("HostMaintenanceV1", ActionTypeEnum::HostMaintenanceV1),
        ("MigrationV1", ActionTypeEnum::MigrationV1),
        ("VmPowerV1", ActionTypeEnum::VmPowerV1),
        ("PlacementV1", ActionTypeEnum::PlacementV1),
        ("HostPowerV1", ActionTypeEnum::HostPowerV1),
        ("StoragePlacementV1", ActionTypeEnum::StoragePlacementV1),
    ],
};

impl ActionTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ActionTypeEnum::MigrationV1 => "MigrationV1",
            ActionTypeEnum::VmPowerV1 => "VmPowerV1",
            ActionTypeEnum::HostPowerV1 => "HostPowerV1",
            ActionTypeEnum::HostMaintenanceV1 => "HostMaintenanceV1",
            ActionTypeEnum::StorageMigrationV1 => "StorageMigrationV1",
            ActionTypeEnum::StoragePlacementV1 => "StoragePlacementV1",
            ActionTypeEnum::PlacementV1 => "PlacementV1",
            ActionTypeEnum::HostInfraUpdateHaV1 => "HostInfraUpdateHaV1",
            ActionTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        ACTION_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ActionTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ActionTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ActionTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ActionTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ActionTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ActionTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ActionTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ActionTypeEnum> for &'a str {
    fn from(value: &'a ActionTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ActionTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CLUSTER_POWER_STATUS_ENUM_MAP: phf::Map<&'static str, ClusterPowerStatusEnum> = ::phf::Map {
    key: 4066803471364472071,
    disps: &[
        (11, 0),
        (0, 3),
        (0, 3),
        (0, 0),
    ],
    entries: &[
        ("hostsInfraVMsPoweredon", ClusterPowerStatusEnum::HostsInfraVMsPoweredon),
        ("hostsInfraVMsPoweredoff", ClusterPowerStatusEnum::HostsInfraVMsPoweredoff),
        ("infraVMsRecorded", ClusterPowerStatusEnum::InfraVMsRecorded),
        ("clusterPoweredOff", ClusterPowerStatusEnum::ClusterPoweredOff),
        ("vsanDOMPauseAllCCPsSet", ClusterPowerStatusEnum::VsanDomPauseAllCcPsSet),
        ("supportedVMsPoweredOn", ClusterPowerStatusEnum::SupportedVMsPoweredOn),
        ("ClusterPowerStatus_Unknown", ClusterPowerStatusEnum::ClusterPowerStatusUnknown),
        ("vsanMemberShipUpdateDisabled", ClusterPowerStatusEnum::VsanMemberShipUpdateDisabled),
        ("clusterPoweredOn", ClusterPowerStatusEnum::ClusterPoweredOn),
        ("vcVMPoweredOff", ClusterPowerStatusEnum::VcVmPoweredOff),
        ("vsanDOMPauseAllCCPsUnset", ClusterPowerStatusEnum::VsanDomPauseAllCcPsUnset),
        ("hostsInMM", ClusterPowerStatusEnum::HostsInMm),
        ("supportedVMsPoweredOff", ClusterPowerStatusEnum::SupportedVMsPoweredOff),
        ("hostsOutOfMM", ClusterPowerStatusEnum::HostsOutOfMm),
        ("vcVMPoweredOn", ClusterPowerStatusEnum::VcVmPoweredOn),
        ("haDisabled", ClusterPowerStatusEnum::HaDisabled),
        ("vsanMemberShipUpdateEnabled", ClusterPowerStatusEnum::VsanMemberShipUpdateEnabled),
        ("hostsPoweredOff", ClusterPowerStatusEnum::HostsPoweredOff),
        ("haEnabled", ClusterPowerStatusEnum::HaEnabled),
    ],
};

impl ClusterPowerStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ClusterPowerStatusEnum::ClusterPoweredOn => "clusterPoweredOn",
            ClusterPowerStatusEnum::HaDisabled => "haDisabled",
            ClusterPowerStatusEnum::SupportedVMsPoweredOff => "supportedVMsPoweredOff",
            ClusterPowerStatusEnum::VcVmPoweredOff => "vcVMPoweredOff",
            ClusterPowerStatusEnum::VsanMemberShipUpdateDisabled => "vsanMemberShipUpdateDisabled",
            ClusterPowerStatusEnum::VsanDomPauseAllCcPsSet => "vsanDOMPauseAllCCPsSet",
            ClusterPowerStatusEnum::HostsInMm => "hostsInMM",
            ClusterPowerStatusEnum::HostsPoweredOff => "hostsPoweredOff",
            ClusterPowerStatusEnum::ClusterPoweredOff => "clusterPoweredOff",
            ClusterPowerStatusEnum::HostsOutOfMm => "hostsOutOfMM",
            ClusterPowerStatusEnum::VsanMemberShipUpdateEnabled => "vsanMemberShipUpdateEnabled",
            ClusterPowerStatusEnum::VsanDomPauseAllCcPsUnset => "vsanDOMPauseAllCCPsUnset",
            ClusterPowerStatusEnum::VcVmPoweredOn => "vcVMPoweredOn",
            ClusterPowerStatusEnum::SupportedVMsPoweredOn => "supportedVMsPoweredOn",
            ClusterPowerStatusEnum::HaEnabled => "haEnabled",
            ClusterPowerStatusEnum::InfraVMsRecorded => "infraVMsRecorded",
            ClusterPowerStatusEnum::HostsInfraVMsPoweredoff => "hostsInfraVMsPoweredoff",
            ClusterPowerStatusEnum::HostsInfraVMsPoweredon => "hostsInfraVMsPoweredon",
            ClusterPowerStatusEnum::ClusterPowerStatusUnknown => "ClusterPowerStatus_Unknown",
            ClusterPowerStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CLUSTER_POWER_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ClusterPowerStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ClusterPowerStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ClusterPowerStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ClusterPowerStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ClusterPowerStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ClusterPowerStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ClusterPowerStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ClusterPowerStatusEnum> for &'a str {
    fn from(value: &'a ClusterPowerStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ClusterPowerStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CLUSTER_CRYPTO_CONFIG_INFO_CRYPTO_MODE_ENUM_MAP: phf::Map<&'static str, ClusterCryptoConfigInfoCryptoModeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("onDemand", ClusterCryptoConfigInfoCryptoModeEnum::OnDemand),
        ("forceEnable", ClusterCryptoConfigInfoCryptoModeEnum::ForceEnable),
    ],
};

impl ClusterCryptoConfigInfoCryptoModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ClusterCryptoConfigInfoCryptoModeEnum::OnDemand => "onDemand",
            ClusterCryptoConfigInfoCryptoModeEnum::ForceEnable => "forceEnable",
            ClusterCryptoConfigInfoCryptoModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CLUSTER_CRYPTO_CONFIG_INFO_CRYPTO_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ClusterCryptoConfigInfoCryptoModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ClusterCryptoConfigInfoCryptoModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ClusterCryptoConfigInfoCryptoModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ClusterCryptoConfigInfoCryptoModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ClusterCryptoConfigInfoCryptoModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ClusterCryptoConfigInfoCryptoModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ClusterCryptoConfigInfoCryptoModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ClusterCryptoConfigInfoCryptoModeEnum> for &'a str {
    fn from(value: &'a ClusterCryptoConfigInfoCryptoModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ClusterCryptoConfigInfoCryptoModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CLUSTER_DAS_AAM_NODE_STATE_DAS_STATE_ENUM_MAP: phf::Map<&'static str, ClusterDasAamNodeStateDasStateEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (5, 2),
        (1, 0),
    ],
    entries: &[
        ("initialized", ClusterDasAamNodeStateDasStateEnum::Initialized),
        ("uninitialized", ClusterDasAamNodeStateDasStateEnum::Uninitialized),
        ("unconfiguring", ClusterDasAamNodeStateDasStateEnum::Unconfiguring),
        ("error", ClusterDasAamNodeStateDasStateEnum::Error),
        ("running", ClusterDasAamNodeStateDasStateEnum::Running),
        ("configuring", ClusterDasAamNodeStateDasStateEnum::Configuring),
        ("nodeFailed", ClusterDasAamNodeStateDasStateEnum::NodeFailed),
        ("agentShutdown", ClusterDasAamNodeStateDasStateEnum::AgentShutdown),
    ],
};

impl ClusterDasAamNodeStateDasStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ClusterDasAamNodeStateDasStateEnum::Uninitialized => "uninitialized",
            ClusterDasAamNodeStateDasStateEnum::Initialized => "initialized",
            ClusterDasAamNodeStateDasStateEnum::Configuring => "configuring",
            ClusterDasAamNodeStateDasStateEnum::Unconfiguring => "unconfiguring",
            ClusterDasAamNodeStateDasStateEnum::Running => "running",
            ClusterDasAamNodeStateDasStateEnum::Error => "error",
            ClusterDasAamNodeStateDasStateEnum::AgentShutdown => "agentShutdown",
            ClusterDasAamNodeStateDasStateEnum::NodeFailed => "nodeFailed",
            ClusterDasAamNodeStateDasStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CLUSTER_DAS_AAM_NODE_STATE_DAS_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ClusterDasAamNodeStateDasStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ClusterDasAamNodeStateDasStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ClusterDasAamNodeStateDasStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ClusterDasAamNodeStateDasStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ClusterDasAamNodeStateDasStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ClusterDasAamNodeStateDasStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ClusterDasAamNodeStateDasStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ClusterDasAamNodeStateDasStateEnum> for &'a str {
    fn from(value: &'a ClusterDasAamNodeStateDasStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ClusterDasAamNodeStateDasStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CLUSTER_DAS_CONFIG_INFO_HB_DATASTORE_CANDIDATE_ENUM_MAP: phf::Map<&'static str, ClusterDasConfigInfoHbDatastoreCandidateEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("allFeasibleDsWithUserPreference", ClusterDasConfigInfoHbDatastoreCandidateEnum::AllFeasibleDsWithUserPreference),
        ("allFeasibleDs", ClusterDasConfigInfoHbDatastoreCandidateEnum::AllFeasibleDs),
        ("userSelectedDs", ClusterDasConfigInfoHbDatastoreCandidateEnum::UserSelectedDs),
    ],
};

impl ClusterDasConfigInfoHbDatastoreCandidateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ClusterDasConfigInfoHbDatastoreCandidateEnum::UserSelectedDs => "userSelectedDs",
            ClusterDasConfigInfoHbDatastoreCandidateEnum::AllFeasibleDs => "allFeasibleDs",
            ClusterDasConfigInfoHbDatastoreCandidateEnum::AllFeasibleDsWithUserPreference => "allFeasibleDsWithUserPreference",
            ClusterDasConfigInfoHbDatastoreCandidateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CLUSTER_DAS_CONFIG_INFO_HB_DATASTORE_CANDIDATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ClusterDasConfigInfoHbDatastoreCandidateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ClusterDasConfigInfoHbDatastoreCandidateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ClusterDasConfigInfoHbDatastoreCandidateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ClusterDasConfigInfoHbDatastoreCandidateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ClusterDasConfigInfoHbDatastoreCandidateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ClusterDasConfigInfoHbDatastoreCandidateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ClusterDasConfigInfoHbDatastoreCandidateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ClusterDasConfigInfoHbDatastoreCandidateEnum> for &'a str {
    fn from(value: &'a ClusterDasConfigInfoHbDatastoreCandidateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ClusterDasConfigInfoHbDatastoreCandidateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CLUSTER_DAS_CONFIG_INFO_SERVICE_STATE_ENUM_MAP: phf::Map<&'static str, ClusterDasConfigInfoServiceStateEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("enabled", ClusterDasConfigInfoServiceStateEnum::Enabled),
        ("disabled", ClusterDasConfigInfoServiceStateEnum::Disabled),
    ],
};

impl ClusterDasConfigInfoServiceStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ClusterDasConfigInfoServiceStateEnum::Disabled => "disabled",
            ClusterDasConfigInfoServiceStateEnum::Enabled => "enabled",
            ClusterDasConfigInfoServiceStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CLUSTER_DAS_CONFIG_INFO_SERVICE_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ClusterDasConfigInfoServiceStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ClusterDasConfigInfoServiceStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ClusterDasConfigInfoServiceStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ClusterDasConfigInfoServiceStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ClusterDasConfigInfoServiceStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ClusterDasConfigInfoServiceStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ClusterDasConfigInfoServiceStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ClusterDasConfigInfoServiceStateEnum> for &'a str {
    fn from(value: &'a ClusterDasConfigInfoServiceStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ClusterDasConfigInfoServiceStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CLUSTER_DAS_CONFIG_INFO_VM_MONITORING_STATE_ENUM_MAP: phf::Map<&'static str, ClusterDasConfigInfoVmMonitoringStateEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("vmAndAppMonitoring", ClusterDasConfigInfoVmMonitoringStateEnum::VmAndAppMonitoring),
        ("vmMonitoringOnly", ClusterDasConfigInfoVmMonitoringStateEnum::VmMonitoringOnly),
        ("vmMonitoringDisabled", ClusterDasConfigInfoVmMonitoringStateEnum::VmMonitoringDisabled),
    ],
};

impl ClusterDasConfigInfoVmMonitoringStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ClusterDasConfigInfoVmMonitoringStateEnum::VmMonitoringDisabled => "vmMonitoringDisabled",
            ClusterDasConfigInfoVmMonitoringStateEnum::VmMonitoringOnly => "vmMonitoringOnly",
            ClusterDasConfigInfoVmMonitoringStateEnum::VmAndAppMonitoring => "vmAndAppMonitoring",
            ClusterDasConfigInfoVmMonitoringStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CLUSTER_DAS_CONFIG_INFO_VM_MONITORING_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ClusterDasConfigInfoVmMonitoringStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ClusterDasConfigInfoVmMonitoringStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ClusterDasConfigInfoVmMonitoringStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ClusterDasConfigInfoVmMonitoringStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ClusterDasConfigInfoVmMonitoringStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ClusterDasConfigInfoVmMonitoringStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ClusterDasConfigInfoVmMonitoringStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ClusterDasConfigInfoVmMonitoringStateEnum> for &'a str {
    fn from(value: &'a ClusterDasConfigInfoVmMonitoringStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ClusterDasConfigInfoVmMonitoringStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CLUSTER_DAS_FDM_AVAILABILITY_STATE_ENUM_MAP: phf::Map<&'static str, ClusterDasFdmAvailabilityStateEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 2),
        (0, 0),
        (1, 7),
    ],
    entries: &[
        ("fdmUnreachable", ClusterDasFdmAvailabilityStateEnum::FdmUnreachable),
        ("networkIsolated", ClusterDasFdmAvailabilityStateEnum::NetworkIsolated),
        ("master", ClusterDasFdmAvailabilityStateEnum::Master),
        ("election", ClusterDasFdmAvailabilityStateEnum::Election),
        ("retry", ClusterDasFdmAvailabilityStateEnum::Retry),
        ("hostDown", ClusterDasFdmAvailabilityStateEnum::HostDown),
        ("initializationError", ClusterDasFdmAvailabilityStateEnum::InitializationError),
        ("connectedToMaster", ClusterDasFdmAvailabilityStateEnum::ConnectedToMaster),
        ("uninitialized", ClusterDasFdmAvailabilityStateEnum::Uninitialized),
        ("networkPartitionedFromMaster", ClusterDasFdmAvailabilityStateEnum::NetworkPartitionedFromMaster),
        ("uninitializationError", ClusterDasFdmAvailabilityStateEnum::UninitializationError),
    ],
};

impl ClusterDasFdmAvailabilityStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ClusterDasFdmAvailabilityStateEnum::Uninitialized => "uninitialized",
            ClusterDasFdmAvailabilityStateEnum::Election => "election",
            ClusterDasFdmAvailabilityStateEnum::Master => "master",
            ClusterDasFdmAvailabilityStateEnum::ConnectedToMaster => "connectedToMaster",
            ClusterDasFdmAvailabilityStateEnum::NetworkPartitionedFromMaster => "networkPartitionedFromMaster",
            ClusterDasFdmAvailabilityStateEnum::NetworkIsolated => "networkIsolated",
            ClusterDasFdmAvailabilityStateEnum::HostDown => "hostDown",
            ClusterDasFdmAvailabilityStateEnum::InitializationError => "initializationError",
            ClusterDasFdmAvailabilityStateEnum::UninitializationError => "uninitializationError",
            ClusterDasFdmAvailabilityStateEnum::FdmUnreachable => "fdmUnreachable",
            ClusterDasFdmAvailabilityStateEnum::Retry => "retry",
            ClusterDasFdmAvailabilityStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CLUSTER_DAS_FDM_AVAILABILITY_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ClusterDasFdmAvailabilityStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ClusterDasFdmAvailabilityStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ClusterDasFdmAvailabilityStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ClusterDasFdmAvailabilityStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ClusterDasFdmAvailabilityStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ClusterDasFdmAvailabilityStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ClusterDasFdmAvailabilityStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ClusterDasFdmAvailabilityStateEnum> for &'a str {
    fn from(value: &'a ClusterDasFdmAvailabilityStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ClusterDasFdmAvailabilityStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DAS_VM_PRIORITY_ENUM_MAP: phf::Map<&'static str, DasVmPriorityEnum> = ::phf::Map {
    key: 2980949210194914378,
    disps: &[
        (3, 0),
    ],
    entries: &[
        ("high", DasVmPriorityEnum::High),
        ("low", DasVmPriorityEnum::Low),
        ("disabled", DasVmPriorityEnum::Disabled),
        ("medium", DasVmPriorityEnum::Medium),
    ],
};

impl DasVmPriorityEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DasVmPriorityEnum::Disabled => "disabled",
            DasVmPriorityEnum::Low => "low",
            DasVmPriorityEnum::Medium => "medium",
            DasVmPriorityEnum::High => "high",
            DasVmPriorityEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DAS_VM_PRIORITY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DasVmPriorityEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DasVmPriorityEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DasVmPriorityEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DasVmPriorityEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DasVmPriorityEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DasVmPriorityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DasVmPriorityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DasVmPriorityEnum> for &'a str {
    fn from(value: &'a DasVmPriorityEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DasVmPriorityEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CLUSTER_DAS_VM_SETTINGS_ISOLATION_RESPONSE_ENUM_MAP: phf::Map<&'static str, ClusterDasVmSettingsIsolationResponseEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("none", ClusterDasVmSettingsIsolationResponseEnum::None),
        ("clusterIsolationResponse", ClusterDasVmSettingsIsolationResponseEnum::ClusterIsolationResponse),
        ("powerOff", ClusterDasVmSettingsIsolationResponseEnum::PowerOff),
        ("shutdown", ClusterDasVmSettingsIsolationResponseEnum::Shutdown),
    ],
};

impl ClusterDasVmSettingsIsolationResponseEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ClusterDasVmSettingsIsolationResponseEnum::None => "none",
            ClusterDasVmSettingsIsolationResponseEnum::PowerOff => "powerOff",
            ClusterDasVmSettingsIsolationResponseEnum::Shutdown => "shutdown",
            ClusterDasVmSettingsIsolationResponseEnum::ClusterIsolationResponse => "clusterIsolationResponse",
            ClusterDasVmSettingsIsolationResponseEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CLUSTER_DAS_VM_SETTINGS_ISOLATION_RESPONSE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ClusterDasVmSettingsIsolationResponseEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ClusterDasVmSettingsIsolationResponseEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ClusterDasVmSettingsIsolationResponseEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ClusterDasVmSettingsIsolationResponseEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ClusterDasVmSettingsIsolationResponseEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ClusterDasVmSettingsIsolationResponseEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ClusterDasVmSettingsIsolationResponseEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ClusterDasVmSettingsIsolationResponseEnum> for &'a str {
    fn from(value: &'a ClusterDasVmSettingsIsolationResponseEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ClusterDasVmSettingsIsolationResponseEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CLUSTER_DAS_VM_SETTINGS_RESTART_PRIORITY_ENUM_MAP: phf::Map<&'static str, ClusterDasVmSettingsRestartPriorityEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (4, 1),
        (2, 0),
    ],
    entries: &[
        ("disabled", ClusterDasVmSettingsRestartPriorityEnum::Disabled),
        ("low", ClusterDasVmSettingsRestartPriorityEnum::Low),
        ("high", ClusterDasVmSettingsRestartPriorityEnum::High),
        ("medium", ClusterDasVmSettingsRestartPriorityEnum::Medium),
        ("highest", ClusterDasVmSettingsRestartPriorityEnum::Highest),
        ("lowest", ClusterDasVmSettingsRestartPriorityEnum::Lowest),
        ("clusterRestartPriority", ClusterDasVmSettingsRestartPriorityEnum::ClusterRestartPriority),
    ],
};

impl ClusterDasVmSettingsRestartPriorityEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ClusterDasVmSettingsRestartPriorityEnum::Disabled => "disabled",
            ClusterDasVmSettingsRestartPriorityEnum::Lowest => "lowest",
            ClusterDasVmSettingsRestartPriorityEnum::Low => "low",
            ClusterDasVmSettingsRestartPriorityEnum::Medium => "medium",
            ClusterDasVmSettingsRestartPriorityEnum::High => "high",
            ClusterDasVmSettingsRestartPriorityEnum::Highest => "highest",
            ClusterDasVmSettingsRestartPriorityEnum::ClusterRestartPriority => "clusterRestartPriority",
            ClusterDasVmSettingsRestartPriorityEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CLUSTER_DAS_VM_SETTINGS_RESTART_PRIORITY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ClusterDasVmSettingsRestartPriorityEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ClusterDasVmSettingsRestartPriorityEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ClusterDasVmSettingsRestartPriorityEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ClusterDasVmSettingsRestartPriorityEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ClusterDasVmSettingsRestartPriorityEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ClusterDasVmSettingsRestartPriorityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ClusterDasVmSettingsRestartPriorityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ClusterDasVmSettingsRestartPriorityEnum> for &'a str {
    fn from(value: &'a ClusterDasVmSettingsRestartPriorityEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ClusterDasVmSettingsRestartPriorityEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DPM_BEHAVIOR_ENUM_MAP: phf::Map<&'static str, DpmBehaviorEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("manual", DpmBehaviorEnum::Manual),
        ("automated", DpmBehaviorEnum::Automated),
    ],
};

impl DpmBehaviorEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DpmBehaviorEnum::Manual => "manual",
            DpmBehaviorEnum::Automated => "automated",
            DpmBehaviorEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DPM_BEHAVIOR_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DpmBehaviorEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DpmBehaviorEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DpmBehaviorEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DpmBehaviorEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DpmBehaviorEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DpmBehaviorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DpmBehaviorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DpmBehaviorEnum> for &'a str {
    fn from(value: &'a DpmBehaviorEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DpmBehaviorEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DRS_BEHAVIOR_ENUM_MAP: phf::Map<&'static str, DrsBehaviorEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("manual", DrsBehaviorEnum::Manual),
        ("partiallyAutomated", DrsBehaviorEnum::PartiallyAutomated),
        ("fullyAutomated", DrsBehaviorEnum::FullyAutomated),
    ],
};

impl DrsBehaviorEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DrsBehaviorEnum::Manual => "manual",
            DrsBehaviorEnum::PartiallyAutomated => "partiallyAutomated",
            DrsBehaviorEnum::FullyAutomated => "fullyAutomated",
            DrsBehaviorEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DRS_BEHAVIOR_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DrsBehaviorEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DrsBehaviorEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DrsBehaviorEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DrsBehaviorEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DrsBehaviorEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DrsBehaviorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DrsBehaviorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DrsBehaviorEnum> for &'a str {
    fn from(value: &'a DrsBehaviorEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DrsBehaviorEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DRS_RECOMMENDATION_REASON_CODE_ENUM_MAP: phf::Map<&'static str, DrsRecommendationReasonCodeEnum> = ::phf::Map {
    key: 14108922650502679131,
    disps: &[
        (4, 0),
    ],
    entries: &[
        ("jointAffin", DrsRecommendationReasonCodeEnum::JointAffin),
        ("fairnessCpuAvg", DrsRecommendationReasonCodeEnum::FairnessCpuAvg),
        ("fairnessMemAvg", DrsRecommendationReasonCodeEnum::FairnessMemAvg),
        ("hostMaint", DrsRecommendationReasonCodeEnum::HostMaint),
        ("antiAffin", DrsRecommendationReasonCodeEnum::AntiAffin),
    ],
};

impl DrsRecommendationReasonCodeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DrsRecommendationReasonCodeEnum::FairnessCpuAvg => "fairnessCpuAvg",
            DrsRecommendationReasonCodeEnum::FairnessMemAvg => "fairnessMemAvg",
            DrsRecommendationReasonCodeEnum::JointAffin => "jointAffin",
            DrsRecommendationReasonCodeEnum::AntiAffin => "antiAffin",
            DrsRecommendationReasonCodeEnum::HostMaint => "hostMaint",
            DrsRecommendationReasonCodeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DRS_RECOMMENDATION_REASON_CODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DrsRecommendationReasonCodeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DrsRecommendationReasonCodeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DrsRecommendationReasonCodeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DrsRecommendationReasonCodeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DrsRecommendationReasonCodeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DrsRecommendationReasonCodeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DrsRecommendationReasonCodeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DrsRecommendationReasonCodeEnum> for &'a str {
    fn from(value: &'a DrsRecommendationReasonCodeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DrsRecommendationReasonCodeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CLUSTER_HOST_INFRA_UPDATE_HA_MODE_ACTION_OPERATION_TYPE_ENUM_MAP: phf::Map<&'static str, ClusterHostInfraUpdateHaModeActionOperationTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("enterQuarantine", ClusterHostInfraUpdateHaModeActionOperationTypeEnum::EnterQuarantine),
        ("exitQuarantine", ClusterHostInfraUpdateHaModeActionOperationTypeEnum::ExitQuarantine),
        ("enterMaintenance", ClusterHostInfraUpdateHaModeActionOperationTypeEnum::EnterMaintenance),
    ],
};

impl ClusterHostInfraUpdateHaModeActionOperationTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ClusterHostInfraUpdateHaModeActionOperationTypeEnum::EnterQuarantine => "enterQuarantine",
            ClusterHostInfraUpdateHaModeActionOperationTypeEnum::ExitQuarantine => "exitQuarantine",
            ClusterHostInfraUpdateHaModeActionOperationTypeEnum::EnterMaintenance => "enterMaintenance",
            ClusterHostInfraUpdateHaModeActionOperationTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CLUSTER_HOST_INFRA_UPDATE_HA_MODE_ACTION_OPERATION_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ClusterHostInfraUpdateHaModeActionOperationTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ClusterHostInfraUpdateHaModeActionOperationTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ClusterHostInfraUpdateHaModeActionOperationTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ClusterHostInfraUpdateHaModeActionOperationTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ClusterHostInfraUpdateHaModeActionOperationTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ClusterHostInfraUpdateHaModeActionOperationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ClusterHostInfraUpdateHaModeActionOperationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ClusterHostInfraUpdateHaModeActionOperationTypeEnum> for &'a str {
    fn from(value: &'a ClusterHostInfraUpdateHaModeActionOperationTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ClusterHostInfraUpdateHaModeActionOperationTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_POWER_OPERATION_TYPE_ENUM_MAP: phf::Map<&'static str, HostPowerOperationTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("powerOff", HostPowerOperationTypeEnum::PowerOff),
        ("powerOn", HostPowerOperationTypeEnum::PowerOn),
    ],
};

impl HostPowerOperationTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostPowerOperationTypeEnum::PowerOn => "powerOn",
            HostPowerOperationTypeEnum::PowerOff => "powerOff",
            HostPowerOperationTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_POWER_OPERATION_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostPowerOperationTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostPowerOperationTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostPowerOperationTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostPowerOperationTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostPowerOperationTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostPowerOperationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostPowerOperationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostPowerOperationTypeEnum> for &'a str {
    fn from(value: &'a HostPowerOperationTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostPowerOperationTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CLUSTER_INFRA_UPDATE_HA_CONFIG_INFO_BEHAVIOR_TYPE_ENUM_MAP: phf::Map<&'static str, ClusterInfraUpdateHaConfigInfoBehaviorTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("Manual", ClusterInfraUpdateHaConfigInfoBehaviorTypeEnum::Manual),
        ("Automated", ClusterInfraUpdateHaConfigInfoBehaviorTypeEnum::Automated),
    ],
};

impl ClusterInfraUpdateHaConfigInfoBehaviorTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ClusterInfraUpdateHaConfigInfoBehaviorTypeEnum::Manual => "Manual",
            ClusterInfraUpdateHaConfigInfoBehaviorTypeEnum::Automated => "Automated",
            ClusterInfraUpdateHaConfigInfoBehaviorTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CLUSTER_INFRA_UPDATE_HA_CONFIG_INFO_BEHAVIOR_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ClusterInfraUpdateHaConfigInfoBehaviorTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ClusterInfraUpdateHaConfigInfoBehaviorTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ClusterInfraUpdateHaConfigInfoBehaviorTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ClusterInfraUpdateHaConfigInfoBehaviorTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ClusterInfraUpdateHaConfigInfoBehaviorTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ClusterInfraUpdateHaConfigInfoBehaviorTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ClusterInfraUpdateHaConfigInfoBehaviorTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ClusterInfraUpdateHaConfigInfoBehaviorTypeEnum> for &'a str {
    fn from(value: &'a ClusterInfraUpdateHaConfigInfoBehaviorTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ClusterInfraUpdateHaConfigInfoBehaviorTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CLUSTER_INFRA_UPDATE_HA_CONFIG_INFO_REMEDIATION_TYPE_ENUM_MAP: phf::Map<&'static str, ClusterInfraUpdateHaConfigInfoRemediationTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("MaintenanceMode", ClusterInfraUpdateHaConfigInfoRemediationTypeEnum::MaintenanceMode),
        ("QuarantineMode", ClusterInfraUpdateHaConfigInfoRemediationTypeEnum::QuarantineMode),
    ],
};

impl ClusterInfraUpdateHaConfigInfoRemediationTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ClusterInfraUpdateHaConfigInfoRemediationTypeEnum::QuarantineMode => "QuarantineMode",
            ClusterInfraUpdateHaConfigInfoRemediationTypeEnum::MaintenanceMode => "MaintenanceMode",
            ClusterInfraUpdateHaConfigInfoRemediationTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CLUSTER_INFRA_UPDATE_HA_CONFIG_INFO_REMEDIATION_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ClusterInfraUpdateHaConfigInfoRemediationTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ClusterInfraUpdateHaConfigInfoRemediationTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ClusterInfraUpdateHaConfigInfoRemediationTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ClusterInfraUpdateHaConfigInfoRemediationTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ClusterInfraUpdateHaConfigInfoRemediationTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ClusterInfraUpdateHaConfigInfoRemediationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ClusterInfraUpdateHaConfigInfoRemediationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ClusterInfraUpdateHaConfigInfoRemediationTypeEnum> for &'a str {
    fn from(value: &'a ClusterInfraUpdateHaConfigInfoRemediationTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ClusterInfraUpdateHaConfigInfoRemediationTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PLACEMENT_SPEC_PLACEMENT_TYPE_ENUM_MAP: phf::Map<&'static str, PlacementSpecPlacementTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("clone", PlacementSpecPlacementTypeEnum::Clone),
        ("reconfigure", PlacementSpecPlacementTypeEnum::Reconfigure),
        ("relocate", PlacementSpecPlacementTypeEnum::Relocate),
        ("create", PlacementSpecPlacementTypeEnum::Create),
    ],
};

impl PlacementSpecPlacementTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PlacementSpecPlacementTypeEnum::Create => "create",
            PlacementSpecPlacementTypeEnum::Reconfigure => "reconfigure",
            PlacementSpecPlacementTypeEnum::Relocate => "relocate",
            PlacementSpecPlacementTypeEnum::Clone => "clone",
            PlacementSpecPlacementTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PLACEMENT_SPEC_PLACEMENT_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PlacementSpecPlacementTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PlacementSpecPlacementTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PlacementSpecPlacementTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PlacementSpecPlacementTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PlacementSpecPlacementTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PlacementSpecPlacementTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PlacementSpecPlacementTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PlacementSpecPlacementTypeEnum> for &'a str {
    fn from(value: &'a PlacementSpecPlacementTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PlacementSpecPlacementTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CLUSTER_POWER_ON_VM_OPTION_ENUM_MAP: phf::Map<&'static str, ClusterPowerOnVmOptionEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("ReserveResources", ClusterPowerOnVmOptionEnum::ReserveResources),
        ("OverrideAutomationLevel", ClusterPowerOnVmOptionEnum::OverrideAutomationLevel),
    ],
};

impl ClusterPowerOnVmOptionEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ClusterPowerOnVmOptionEnum::OverrideAutomationLevel => "OverrideAutomationLevel",
            ClusterPowerOnVmOptionEnum::ReserveResources => "ReserveResources",
            ClusterPowerOnVmOptionEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CLUSTER_POWER_ON_VM_OPTION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ClusterPowerOnVmOptionEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ClusterPowerOnVmOptionEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ClusterPowerOnVmOptionEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ClusterPowerOnVmOptionEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ClusterPowerOnVmOptionEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ClusterPowerOnVmOptionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ClusterPowerOnVmOptionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ClusterPowerOnVmOptionEnum> for &'a str {
    fn from(value: &'a ClusterPowerOnVmOptionEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ClusterPowerOnVmOptionEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static RECOMMENDATION_REASON_CODE_ENUM_MAP: phf::Map<&'static str, RecommendationReasonCodeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 25),
        (0, 13),
        (1, 2),
        (15, 0),
        (0, 16),
        (1, 6),
        (0, 21),
        (2, 26),
    ],
    entries: &[
        ("balanceDatastoreSpaceUsage", RecommendationReasonCodeEnum::BalanceDatastoreSpaceUsage),
        ("ahPlacementOptimization", RecommendationReasonCodeEnum::AhPlacementOptimization),
        ("vmHostHardAffinity", RecommendationReasonCodeEnum::VmHostHardAffinity),
        ("iolbDisabledInternal", RecommendationReasonCodeEnum::IolbDisabledInternal),
        ("storagePlacement", RecommendationReasonCodeEnum::StoragePlacement),
        ("unreservedCapacity", RecommendationReasonCodeEnum::UnreservedCapacity),
        ("vmxUpgrade", RecommendationReasonCodeEnum::VmxUpgrade),
        ("datastoreSpaceOutage", RecommendationReasonCodeEnum::DatastoreSpaceOutage),
        ("powerOnVm", RecommendationReasonCodeEnum::PowerOnVm),
        ("powerSaving", RecommendationReasonCodeEnum::PowerSaving),
        ("hostInDegradation", RecommendationReasonCodeEnum::HostInDegradation),
        ("checkResource", RecommendationReasonCodeEnum::CheckResource),
        ("reservationCpu", RecommendationReasonCodeEnum::ReservationCpu),
        ("maxVmsConstraint", RecommendationReasonCodeEnum::MaxVmsConstraint),
        ("ftConstraints", RecommendationReasonCodeEnum::FtConstraints),
        ("increaseCapacity", RecommendationReasonCodeEnum::IncreaseCapacity),
        ("balanceDatastoreIOLoad", RecommendationReasonCodeEnum::BalanceDatastoreIoLoad),
        ("virtualDiskJointAffin", RecommendationReasonCodeEnum::VirtualDiskJointAffin),
        ("balanceDatastoreIOPSReservation", RecommendationReasonCodeEnum::BalanceDatastoreIopsReservation),
        ("vmAntiAffinityPolicy", RecommendationReasonCodeEnum::VmAntiAffinityPolicy),
        ("fairnessMemAvg", RecommendationReasonCodeEnum::FairnessMemAvg),
        ("vmHostAffinityPolicy", RecommendationReasonCodeEnum::VmHostAffinityPolicy),
        ("datastoreMaint", RecommendationReasonCodeEnum::DatastoreMaint),
        ("vmHostSoftAffinity", RecommendationReasonCodeEnum::VmHostSoftAffinity),
        ("antiAffin", RecommendationReasonCodeEnum::AntiAffin),
        ("virtualDiskAntiAffin", RecommendationReasonCodeEnum::VirtualDiskAntiAffin),
        ("fairnessCpuAvg", RecommendationReasonCodeEnum::FairnessCpuAvg),
        ("hostMaint", RecommendationReasonCodeEnum::HostMaint),
        ("jointAffin", RecommendationReasonCodeEnum::JointAffin),
        ("xvmotionPlacement", RecommendationReasonCodeEnum::XvmotionPlacement),
        ("vmHostAntiAffinityPolicy", RecommendationReasonCodeEnum::VmHostAntiAffinityPolicy),
        ("balanceVsanUsage", RecommendationReasonCodeEnum::BalanceVsanUsage),
        ("enterStandby", RecommendationReasonCodeEnum::EnterStandby),
        ("networkBandwidthReservation", RecommendationReasonCodeEnum::NetworkBandwidthReservation),
        ("reservationMem", RecommendationReasonCodeEnum::ReservationMem),
        ("hostExitDegradation", RecommendationReasonCodeEnum::HostExitDegradation),
    ],
};

impl RecommendationReasonCodeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            RecommendationReasonCodeEnum::FairnessCpuAvg => "fairnessCpuAvg",
            RecommendationReasonCodeEnum::FairnessMemAvg => "fairnessMemAvg",
            RecommendationReasonCodeEnum::JointAffin => "jointAffin",
            RecommendationReasonCodeEnum::AntiAffin => "antiAffin",
            RecommendationReasonCodeEnum::HostMaint => "hostMaint",
            RecommendationReasonCodeEnum::EnterStandby => "enterStandby",
            RecommendationReasonCodeEnum::ReservationCpu => "reservationCpu",
            RecommendationReasonCodeEnum::ReservationMem => "reservationMem",
            RecommendationReasonCodeEnum::PowerOnVm => "powerOnVm",
            RecommendationReasonCodeEnum::PowerSaving => "powerSaving",
            RecommendationReasonCodeEnum::IncreaseCapacity => "increaseCapacity",
            RecommendationReasonCodeEnum::CheckResource => "checkResource",
            RecommendationReasonCodeEnum::UnreservedCapacity => "unreservedCapacity",
            RecommendationReasonCodeEnum::VmHostHardAffinity => "vmHostHardAffinity",
            RecommendationReasonCodeEnum::VmHostSoftAffinity => "vmHostSoftAffinity",
            RecommendationReasonCodeEnum::BalanceDatastoreSpaceUsage => "balanceDatastoreSpaceUsage",
            RecommendationReasonCodeEnum::BalanceDatastoreIoLoad => "balanceDatastoreIOLoad",
            RecommendationReasonCodeEnum::BalanceDatastoreIopsReservation => "balanceDatastoreIOPSReservation",
            RecommendationReasonCodeEnum::DatastoreMaint => "datastoreMaint",
            RecommendationReasonCodeEnum::VirtualDiskJointAffin => "virtualDiskJointAffin",
            RecommendationReasonCodeEnum::VirtualDiskAntiAffin => "virtualDiskAntiAffin",
            RecommendationReasonCodeEnum::DatastoreSpaceOutage => "datastoreSpaceOutage",
            RecommendationReasonCodeEnum::StoragePlacement => "storagePlacement",
            RecommendationReasonCodeEnum::IolbDisabledInternal => "iolbDisabledInternal",
            RecommendationReasonCodeEnum::XvmotionPlacement => "xvmotionPlacement",
            RecommendationReasonCodeEnum::NetworkBandwidthReservation => "networkBandwidthReservation",
            RecommendationReasonCodeEnum::HostInDegradation => "hostInDegradation",
            RecommendationReasonCodeEnum::HostExitDegradation => "hostExitDegradation",
            RecommendationReasonCodeEnum::MaxVmsConstraint => "maxVmsConstraint",
            RecommendationReasonCodeEnum::FtConstraints => "ftConstraints",
            RecommendationReasonCodeEnum::VmHostAffinityPolicy => "vmHostAffinityPolicy",
            RecommendationReasonCodeEnum::VmHostAntiAffinityPolicy => "vmHostAntiAffinityPolicy",
            RecommendationReasonCodeEnum::VmAntiAffinityPolicy => "vmAntiAffinityPolicy",
            RecommendationReasonCodeEnum::BalanceVsanUsage => "balanceVsanUsage",
            RecommendationReasonCodeEnum::AhPlacementOptimization => "ahPlacementOptimization",
            RecommendationReasonCodeEnum::VmxUpgrade => "vmxUpgrade",
            RecommendationReasonCodeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        RECOMMENDATION_REASON_CODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| RecommendationReasonCodeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for RecommendationReasonCodeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for RecommendationReasonCodeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<RecommendationReasonCodeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(RecommendationReasonCodeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for RecommendationReasonCodeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for RecommendationReasonCodeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a RecommendationReasonCodeEnum> for &'a str {
    fn from(value: &'a RecommendationReasonCodeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for RecommendationReasonCodeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static RECOMMENDATION_TYPE_ENUM_MAP: phf::Map<&'static str, RecommendationTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("V1", RecommendationTypeEnum::V1),
    ],
};

impl RecommendationTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            RecommendationTypeEnum::V1 => "V1",
            RecommendationTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        RECOMMENDATION_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| RecommendationTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for RecommendationTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for RecommendationTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<RecommendationTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(RecommendationTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for RecommendationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for RecommendationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a RecommendationTypeEnum> for &'a str {
    fn from(value: &'a RecommendationTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for RecommendationTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_STORAGE_COMPLIANCE_STATUS_ENUM_MAP: phf::Map<&'static str, VsanStorageComplianceStatusEnum> = ::phf::Map {
    key: 8694567506910003252,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("notApplicable", VsanStorageComplianceStatusEnum::NotApplicable),
        ("unknown", VsanStorageComplianceStatusEnum::Unknown),
        ("nonCompliant", VsanStorageComplianceStatusEnum::NonCompliant),
        ("compliant", VsanStorageComplianceStatusEnum::Compliant),
    ],
};

impl VsanStorageComplianceStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanStorageComplianceStatusEnum::Compliant => "compliant",
            VsanStorageComplianceStatusEnum::NonCompliant => "nonCompliant",
            VsanStorageComplianceStatusEnum::Unknown => "unknown",
            VsanStorageComplianceStatusEnum::NotApplicable => "notApplicable",
            VsanStorageComplianceStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_STORAGE_COMPLIANCE_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanStorageComplianceStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanStorageComplianceStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanStorageComplianceStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanStorageComplianceStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanStorageComplianceStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanStorageComplianceStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanStorageComplianceStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanStorageComplianceStatusEnum> for &'a str {
    fn from(value: &'a VsanStorageComplianceStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanStorageComplianceStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CLUSTER_SYSTEM_V_MS_CONFIG_INFO_DEPLOYMENT_MODE_ENUM_MAP: phf::Map<&'static str, ClusterSystemVMsConfigInfoDeploymentModeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("SYSTEM_MANAGED", ClusterSystemVMsConfigInfoDeploymentModeEnum::SystemManaged),
        ("ABSENT", ClusterSystemVMsConfigInfoDeploymentModeEnum::Absent),
    ],
};

impl ClusterSystemVMsConfigInfoDeploymentModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ClusterSystemVMsConfigInfoDeploymentModeEnum::SystemManaged => "SYSTEM_MANAGED",
            ClusterSystemVMsConfigInfoDeploymentModeEnum::Absent => "ABSENT",
            ClusterSystemVMsConfigInfoDeploymentModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CLUSTER_SYSTEM_V_MS_CONFIG_INFO_DEPLOYMENT_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ClusterSystemVMsConfigInfoDeploymentModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ClusterSystemVMsConfigInfoDeploymentModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ClusterSystemVMsConfigInfoDeploymentModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ClusterSystemVMsConfigInfoDeploymentModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ClusterSystemVMsConfigInfoDeploymentModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ClusterSystemVMsConfigInfoDeploymentModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ClusterSystemVMsConfigInfoDeploymentModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ClusterSystemVMsConfigInfoDeploymentModeEnum> for &'a str {
    fn from(value: &'a ClusterSystemVMsConfigInfoDeploymentModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ClusterSystemVMsConfigInfoDeploymentModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIM_CLUSTER_VSAN_STRETCHED_CLUSTER_CONFIG_ISSUE_ENUM_ENUM_MAP: phf::Map<&'static str, VimClusterVsanStretchedClusterConfigIssueEnumEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (8, 2),
        (3, 2),
        (7, 0),
    ],
    entries: &[
        ("WitnessInsideVcCluster", VimClusterVsanStretchedClusterConfigIssueEnumEnum::WitnessInsideVcCluster),
        ("WitnessWithNoDiskMapping", VimClusterVsanStretchedClusterConfigIssueEnumEnum::WitnessWithNoDiskMapping),
        ("HostWithNoStretchedClusterSupport", VimClusterVsanStretchedClusterConfigIssueEnumEnum::HostWithNoStretchedClusterSupport),
        ("SharedWitnessComponentLimitScaledDown", VimClusterVsanStretchedClusterConfigIssueEnumEnum::SharedWitnessComponentLimitScaledDown),
        ("ClusterWithMultipleUnicastAgents", VimClusterVsanStretchedClusterConfigIssueEnumEnum::ClusterWithMultipleUnicastAgents),
        ("ClusterWithoutTwoDataFaultDomains", VimClusterVsanStretchedClusterConfigIssueEnumEnum::ClusterWithoutTwoDataFaultDomains),
        ("WitnessFaultDomainInvalid", VimClusterVsanStretchedClusterConfigIssueEnumEnum::WitnessFaultDomainInvalid),
        ("WitnessPreferredFaultDomainInvalid", VimClusterVsanStretchedClusterConfigIssueEnumEnum::WitnessPreferredFaultDomainInvalid),
        ("WitnessPreferredFaultDomainNotExist", VimClusterVsanStretchedClusterConfigIssueEnumEnum::WitnessPreferredFaultDomainNotExist),
        ("HostUnicastAgentUnset", VimClusterVsanStretchedClusterConfigIssueEnumEnum::HostUnicastAgentUnset),
        ("ClusterWithoutOneWitnessHost", VimClusterVsanStretchedClusterConfigIssueEnumEnum::ClusterWithoutOneWitnessHost),
        ("VSANStretchedClusterConfigIssueEnum_Unknown", VimClusterVsanStretchedClusterConfigIssueEnumEnum::VsanStretchedClusterConfigIssueEnumUnknown),
        ("SharedWitnessClusterDataHostNumExceed", VimClusterVsanStretchedClusterConfigIssueEnumEnum::SharedWitnessClusterDataHostNumExceed),
        ("HostWithInvalidUnicastAgent", VimClusterVsanStretchedClusterConfigIssueEnumEnum::HostWithInvalidUnicastAgent),
    ],
};

impl VimClusterVsanStretchedClusterConfigIssueEnumEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VimClusterVsanStretchedClusterConfigIssueEnumEnum::ClusterWithoutOneWitnessHost => "ClusterWithoutOneWitnessHost",
            VimClusterVsanStretchedClusterConfigIssueEnumEnum::ClusterWithoutTwoDataFaultDomains => "ClusterWithoutTwoDataFaultDomains",
            VimClusterVsanStretchedClusterConfigIssueEnumEnum::ClusterWithMultipleUnicastAgents => "ClusterWithMultipleUnicastAgents",
            VimClusterVsanStretchedClusterConfigIssueEnumEnum::WitnessPreferredFaultDomainInvalid => "WitnessPreferredFaultDomainInvalid",
            VimClusterVsanStretchedClusterConfigIssueEnumEnum::WitnessPreferredFaultDomainNotExist => "WitnessPreferredFaultDomainNotExist",
            VimClusterVsanStretchedClusterConfigIssueEnumEnum::WitnessInsideVcCluster => "WitnessInsideVcCluster",
            VimClusterVsanStretchedClusterConfigIssueEnumEnum::WitnessFaultDomainInvalid => "WitnessFaultDomainInvalid",
            VimClusterVsanStretchedClusterConfigIssueEnumEnum::HostUnicastAgentUnset => "HostUnicastAgentUnset",
            VimClusterVsanStretchedClusterConfigIssueEnumEnum::WitnessWithNoDiskMapping => "WitnessWithNoDiskMapping",
            VimClusterVsanStretchedClusterConfigIssueEnumEnum::HostWithNoStretchedClusterSupport => "HostWithNoStretchedClusterSupport",
            VimClusterVsanStretchedClusterConfigIssueEnumEnum::HostWithInvalidUnicastAgent => "HostWithInvalidUnicastAgent",
            VimClusterVsanStretchedClusterConfigIssueEnumEnum::SharedWitnessClusterDataHostNumExceed => "SharedWitnessClusterDataHostNumExceed",
            VimClusterVsanStretchedClusterConfigIssueEnumEnum::SharedWitnessComponentLimitScaledDown => "SharedWitnessComponentLimitScaledDown",
            VimClusterVsanStretchedClusterConfigIssueEnumEnum::VsanStretchedClusterConfigIssueEnumUnknown => "VSANStretchedClusterConfigIssueEnum_Unknown",
            VimClusterVsanStretchedClusterConfigIssueEnumEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIM_CLUSTER_VSAN_STRETCHED_CLUSTER_CONFIG_ISSUE_ENUM_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VimClusterVsanStretchedClusterConfigIssueEnumEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VimClusterVsanStretchedClusterConfigIssueEnumEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VimClusterVsanStretchedClusterConfigIssueEnumEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VimClusterVsanStretchedClusterConfigIssueEnumEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VimClusterVsanStretchedClusterConfigIssueEnumEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VimClusterVsanStretchedClusterConfigIssueEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VimClusterVsanStretchedClusterConfigIssueEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VimClusterVsanStretchedClusterConfigIssueEnumEnum> for &'a str {
    fn from(value: &'a VimClusterVsanStretchedClusterConfigIssueEnumEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VimClusterVsanStretchedClusterConfigIssueEnumEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CLUSTER_VM_COMPONENT_PROTECTION_SETTINGS_STORAGE_VM_REACTION_ENUM_MAP: phf::Map<&'static str, ClusterVmComponentProtectionSettingsStorageVmReactionEnum> = ::phf::Map {
    key: 2126027241312876569,
    disps: &[
        (4, 0),
    ],
    entries: &[
        ("restartAggressive", ClusterVmComponentProtectionSettingsStorageVmReactionEnum::RestartAggressive),
        ("warning", ClusterVmComponentProtectionSettingsStorageVmReactionEnum::Warning),
        ("clusterDefault", ClusterVmComponentProtectionSettingsStorageVmReactionEnum::ClusterDefault),
        ("disabled", ClusterVmComponentProtectionSettingsStorageVmReactionEnum::Disabled),
        ("restartConservative", ClusterVmComponentProtectionSettingsStorageVmReactionEnum::RestartConservative),
    ],
};

impl ClusterVmComponentProtectionSettingsStorageVmReactionEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ClusterVmComponentProtectionSettingsStorageVmReactionEnum::Disabled => "disabled",
            ClusterVmComponentProtectionSettingsStorageVmReactionEnum::Warning => "warning",
            ClusterVmComponentProtectionSettingsStorageVmReactionEnum::RestartConservative => "restartConservative",
            ClusterVmComponentProtectionSettingsStorageVmReactionEnum::RestartAggressive => "restartAggressive",
            ClusterVmComponentProtectionSettingsStorageVmReactionEnum::ClusterDefault => "clusterDefault",
            ClusterVmComponentProtectionSettingsStorageVmReactionEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CLUSTER_VM_COMPONENT_PROTECTION_SETTINGS_STORAGE_VM_REACTION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ClusterVmComponentProtectionSettingsStorageVmReactionEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ClusterVmComponentProtectionSettingsStorageVmReactionEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ClusterVmComponentProtectionSettingsStorageVmReactionEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ClusterVmComponentProtectionSettingsStorageVmReactionEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ClusterVmComponentProtectionSettingsStorageVmReactionEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ClusterVmComponentProtectionSettingsStorageVmReactionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ClusterVmComponentProtectionSettingsStorageVmReactionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ClusterVmComponentProtectionSettingsStorageVmReactionEnum> for &'a str {
    fn from(value: &'a ClusterVmComponentProtectionSettingsStorageVmReactionEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ClusterVmComponentProtectionSettingsStorageVmReactionEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CLUSTER_VM_COMPONENT_PROTECTION_SETTINGS_VM_REACTION_ON_APD_CLEARED_ENUM_MAP: phf::Map<&'static str, ClusterVmComponentProtectionSettingsVmReactionOnApdClearedEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("reset", ClusterVmComponentProtectionSettingsVmReactionOnApdClearedEnum::Reset),
        ("none", ClusterVmComponentProtectionSettingsVmReactionOnApdClearedEnum::None),
        ("useClusterDefault", ClusterVmComponentProtectionSettingsVmReactionOnApdClearedEnum::UseClusterDefault),
    ],
};

impl ClusterVmComponentProtectionSettingsVmReactionOnApdClearedEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ClusterVmComponentProtectionSettingsVmReactionOnApdClearedEnum::None => "none",
            ClusterVmComponentProtectionSettingsVmReactionOnApdClearedEnum::Reset => "reset",
            ClusterVmComponentProtectionSettingsVmReactionOnApdClearedEnum::UseClusterDefault => "useClusterDefault",
            ClusterVmComponentProtectionSettingsVmReactionOnApdClearedEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CLUSTER_VM_COMPONENT_PROTECTION_SETTINGS_VM_REACTION_ON_APD_CLEARED_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ClusterVmComponentProtectionSettingsVmReactionOnApdClearedEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ClusterVmComponentProtectionSettingsVmReactionOnApdClearedEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ClusterVmComponentProtectionSettingsVmReactionOnApdClearedEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ClusterVmComponentProtectionSettingsVmReactionOnApdClearedEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ClusterVmComponentProtectionSettingsVmReactionOnApdClearedEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ClusterVmComponentProtectionSettingsVmReactionOnApdClearedEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ClusterVmComponentProtectionSettingsVmReactionOnApdClearedEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ClusterVmComponentProtectionSettingsVmReactionOnApdClearedEnum> for &'a str {
    fn from(value: &'a ClusterVmComponentProtectionSettingsVmReactionOnApdClearedEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ClusterVmComponentProtectionSettingsVmReactionOnApdClearedEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CLUSTER_VM_READINESS_READY_CONDITION_ENUM_MAP: phf::Map<&'static str, ClusterVmReadinessReadyConditionEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("guestHbStatusGreen", ClusterVmReadinessReadyConditionEnum::GuestHbStatusGreen),
        ("none", ClusterVmReadinessReadyConditionEnum::None),
        ("useClusterDefault", ClusterVmReadinessReadyConditionEnum::UseClusterDefault),
        ("appHbStatusGreen", ClusterVmReadinessReadyConditionEnum::AppHbStatusGreen),
        ("poweredOn", ClusterVmReadinessReadyConditionEnum::PoweredOn),
    ],
};

impl ClusterVmReadinessReadyConditionEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ClusterVmReadinessReadyConditionEnum::None => "none",
            ClusterVmReadinessReadyConditionEnum::PoweredOn => "poweredOn",
            ClusterVmReadinessReadyConditionEnum::GuestHbStatusGreen => "guestHbStatusGreen",
            ClusterVmReadinessReadyConditionEnum::AppHbStatusGreen => "appHbStatusGreen",
            ClusterVmReadinessReadyConditionEnum::UseClusterDefault => "useClusterDefault",
            ClusterVmReadinessReadyConditionEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CLUSTER_VM_READINESS_READY_CONDITION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ClusterVmReadinessReadyConditionEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ClusterVmReadinessReadyConditionEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ClusterVmReadinessReadyConditionEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ClusterVmReadinessReadyConditionEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ClusterVmReadinessReadyConditionEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ClusterVmReadinessReadyConditionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ClusterVmReadinessReadyConditionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ClusterVmReadinessReadyConditionEnum> for &'a str {
    fn from(value: &'a ClusterVmReadinessReadyConditionEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ClusterVmReadinessReadyConditionEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_BASELINE_PREFERENCE_TYPE_ENUM_MAP: phf::Map<&'static str, VsanBaselinePreferenceTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (3, 0),
    ],
    entries: &[
        ("noRecommendation", VsanBaselinePreferenceTypeEnum::NoRecommendation),
        ("VsanBaselinePreferenceType_Unknown", VsanBaselinePreferenceTypeEnum::VsanBaselinePreferenceTypeUnknown),
        ("latestRelease", VsanBaselinePreferenceTypeEnum::LatestRelease),
        ("latestPatch", VsanBaselinePreferenceTypeEnum::LatestPatch),
    ],
};

impl VsanBaselinePreferenceTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanBaselinePreferenceTypeEnum::LatestRelease => "latestRelease",
            VsanBaselinePreferenceTypeEnum::LatestPatch => "latestPatch",
            VsanBaselinePreferenceTypeEnum::NoRecommendation => "noRecommendation",
            VsanBaselinePreferenceTypeEnum::VsanBaselinePreferenceTypeUnknown => "VsanBaselinePreferenceType_Unknown",
            VsanBaselinePreferenceTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_BASELINE_PREFERENCE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanBaselinePreferenceTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanBaselinePreferenceTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanBaselinePreferenceTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanBaselinePreferenceTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanBaselinePreferenceTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanBaselinePreferenceTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanBaselinePreferenceTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanBaselinePreferenceTypeEnum> for &'a str {
    fn from(value: &'a VsanBaselinePreferenceTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanBaselinePreferenceTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_CAPABILITY_STATUS_ENUM_MAP: phf::Map<&'static str, VsanCapabilityStatusEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("oldversion", VsanCapabilityStatusEnum::Oldversion),
        ("disconnected", VsanCapabilityStatusEnum::Disconnected),
        ("unknown", VsanCapabilityStatusEnum::Unknown),
        ("calculated", VsanCapabilityStatusEnum::Calculated),
    ],
};

impl VsanCapabilityStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanCapabilityStatusEnum::Unknown => "unknown",
            VsanCapabilityStatusEnum::Oldversion => "oldversion",
            VsanCapabilityStatusEnum::Disconnected => "disconnected",
            VsanCapabilityStatusEnum::Calculated => "calculated",
            VsanCapabilityStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_CAPABILITY_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanCapabilityStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanCapabilityStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanCapabilityStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanCapabilityStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanCapabilityStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanCapabilityStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanCapabilityStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanCapabilityStatusEnum> for &'a str {
    fn from(value: &'a VsanCapabilityStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanCapabilityStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_CAPABILITY_TYPE_ENUM_MAP: phf::Map<&'static str, VsanCapabilityTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 11),
        (0, 17),
        (4, 112),
        (3, 0),
        (0, 32),
        (0, 0),
        (0, 83),
        (1, 35),
        (0, 17),
        (7, 89),
        (2, 93),
        (0, 5),
        (0, 70),
        (0, 28),
        (0, 0),
        (0, 37),
        (1, 111),
        (14, 42),
        (1, 2),
        (0, 34),
        (133, 58),
        (1, 14),
        (0, 34),
        (16, 126),
        (0, 131),
        (2, 4),
        (0, 21),
        (0, 140),
        (17, 40),
    ],
    entries: &[
        ("validateconfigspec", VsanCapabilityTypeEnum::Validateconfigspec),
        ("vsan2deeprekey", VsanCapabilityTypeEnum::Vsan2Deeprekey),
        ("vsanmanagedpmem", VsanCapabilityTypeEnum::Vsanmanagedpmem),
        ("pspairgap", VsanCapabilityTypeEnum::Pspairgap),
        ("diagnosticsfeedback", VsanCapabilityTypeEnum::Diagnosticsfeedback),
        ("perfsvctwoyaxisgraph", VsanCapabilityTypeEnum::Perfsvctwoyaxisgraph),
        ("fileservicesmb", VsanCapabilityTypeEnum::Fileservicesmb),
        ("verbosemodeconfiguration", VsanCapabilityTypeEnum::Verbosemodeconfiguration),
        ("vsandirectdiskdecom", VsanCapabilityTypeEnum::Vsandirectdiskdecom),
        ("cnsvolumes", VsanCapabilityTypeEnum::Cnsvolumes),
        ("iscsitargets", VsanCapabilityTypeEnum::Iscsitargets),
        ("netperftest", VsanCapabilityTypeEnum::Netperftest),
        ("dfcobjectsmanagement", VsanCapabilityTypeEnum::Dfcobjectsmanagement),
        ("complianceprecheck", VsanCapabilityTypeEnum::Complianceprecheck),
        ("pr1741414fixed", VsanCapabilityTypeEnum::Pr1741414Fixed),
        ("vsanesasingletier", VsanCapabilityTypeEnum::Vsanesasingletier),
        ("readlocalitytodrs", VsanCapabilityTypeEnum::Readlocalitytodrs),
        ("vsandefaultgatewaysupported", VsanCapabilityTypeEnum::Vsandefaultgatewaysupported),
        ("pmanintegration", VsanCapabilityTypeEnum::Pmanintegration),
        ("fcd", VsanCapabilityTypeEnum::Fcd),
        ("capacityreservation", VsanCapabilityTypeEnum::Capacityreservation),
        ("enhancedresyncapi", VsanCapabilityTypeEnum::Enhancedresyncapi),
        ("vsandiagnostics", VsanCapabilityTypeEnum::Vsandiagnostics),
        ("nestedfd", VsanCapabilityTypeEnum::Nestedfd),
        ("resourceprecheck", VsanCapabilityTypeEnum::Resourceprecheck),
        ("stretchedcluster", VsanCapabilityTypeEnum::Stretchedcluster),
        ("policyassociation", VsanCapabilityTypeEnum::Policyassociation),
        ("diskmgmtredesign", VsanCapabilityTypeEnum::Diskmgmtredesign),
        ("supportinsight", VsanCapabilityTypeEnum::Supportinsight),
        ("vsanrebuildtrim", VsanCapabilityTypeEnum::Vsanrebuildtrim),
        ("healthremediation", VsanCapabilityTypeEnum::Healthremediation),
        ("capacityevaluationonvc", VsanCapabilityTypeEnum::Capacityevaluationonvc),
        ("dataefficiency", VsanCapabilityTypeEnum::Dataefficiency),
        ("vsanxvchcimesh", VsanCapabilityTypeEnum::Vsanxvchcimesh),
        ("encryption", VsanCapabilityTypeEnum::Encryption),
        ("vsanencrkmx", VsanCapabilityTypeEnum::Vsanencrkmx),
        ("slackspacecapacity", VsanCapabilityTypeEnum::Slackspacecapacity),
        ("nativelargeclustersupport", VsanCapabilityTypeEnum::Nativelargeclustersupport),
        ("dataintransitencryption", VsanCapabilityTypeEnum::Dataintransitencryption),
        ("witnessmanagement", VsanCapabilityTypeEnum::Witnessmanagement),
        ("historicalhealth", VsanCapabilityTypeEnum::Historicalhealth),
        ("healthcheck2018q2", VsanCapabilityTypeEnum::Healthcheck2018Q2),
        ("unicastmode", VsanCapabilityTypeEnum::Unicastmode),
        ("throttleresync", VsanCapabilityTypeEnum::Throttleresync),
        ("decomwhatif", VsanCapabilityTypeEnum::Decomwhatif),
        ("vsanperfsvc80u2", VsanCapabilityTypeEnum::Vsanperfsvc80U2),
        ("VsanCapabilityType_Unknown", VsanCapabilityTypeEnum::VsanCapabilityTypeUnknown),
        ("purgeinaccessiblevmswapobjects", VsanCapabilityTypeEnum::Purgeinaccessiblevmswapobjects),
        ("wcpappplatform", VsanCapabilityTypeEnum::Wcpappplatform),
        ("supportApiVersion", VsanCapabilityTypeEnum::SupportApiVersion),
        ("vitonlineresize", VsanCapabilityTypeEnum::Vitonlineresize),
        ("datapersistresourcecheck", VsanCapabilityTypeEnum::Datapersistresourcecheck),
        ("clusterpoweraction", VsanCapabilityTypeEnum::Clusterpoweraction),
        ("fileservices", VsanCapabilityTypeEnum::Fileservices),
        ("capacitycustomizablethresholds", VsanCapabilityTypeEnum::Capacitycustomizablethresholds),
        ("vumbaselinerecommendation", VsanCapabilityTypeEnum::Vumbaselinerecommendation),
        ("fileserviceowe", VsanCapabilityTypeEnum::Fileserviceowe),
        ("topcontributors", VsanCapabilityTypeEnum::Topcontributors),
        ("whatifcapacity", VsanCapabilityTypeEnum::Whatifcapacity),
        ("dit4sw", VsanCapabilityTypeEnum::Dit4Sw),
        ("policyhostapi", VsanCapabilityTypeEnum::Policyhostapi),
        ("elasticpolicy", VsanCapabilityTypeEnum::Elasticpolicy),
        ("vmlevelcapacity", VsanCapabilityTypeEnum::Vmlevelcapacity),
        ("fileservice80", VsanCapabilityTypeEnum::Fileservice80),
        ("iodiagnostics", VsanCapabilityTypeEnum::Iodiagnostics),
        ("compressiononly", VsanCapabilityTypeEnum::Compressiononly),
        ("archivaldataprotection", VsanCapabilityTypeEnum::Archivaldataprotection),
        ("updatevumreleasecatalogoffline", VsanCapabilityTypeEnum::Updatevumreleasecatalogoffline),
        ("recreatediskgroup", VsanCapabilityTypeEnum::Recreatediskgroup),
        ("cnsreconfigpolicy", VsanCapabilityTypeEnum::Cnsreconfigpolicy),
        ("filevolumes", VsanCapabilityTypeEnum::Filevolumes),
        ("fileservicesnapshot", VsanCapabilityTypeEnum::Fileservicesnapshot),
        ("snapservice", VsanCapabilityTypeEnum::Snapservice),
        ("vsankeyexpiration", VsanCapabilityTypeEnum::Vsankeyexpiration),
        ("hostreservedcapacity", VsanCapabilityTypeEnum::Hostreservedcapacity),
        ("device4ksupport", VsanCapabilityTypeEnum::Device4Ksupport),
        ("minrebalancethreshold", VsanCapabilityTypeEnum::Minrebalancethreshold),
        ("clusteradvancedoptions", VsanCapabilityTypeEnum::Clusteradvancedoptions),
        ("vsanxvchcimeshv3", VsanCapabilityTypeEnum::Vsanxvchcimeshv3),
        ("automaticrebalance", VsanCapabilityTypeEnum::Automaticrebalance),
        ("perfanalysis", VsanCapabilityTypeEnum::Perfanalysis),
        ("perfsvcverbosemode", VsanCapabilityTypeEnum::Perfsvcverbosemode),
        ("vsanEsaConfigure", VsanCapabilityTypeEnum::VsanEsaConfigure),
        ("vsan2encr", VsanCapabilityTypeEnum::Vsan2Encr),
        ("vitstretchedcluster", VsanCapabilityTypeEnum::Vitstretchedcluster),
        ("dhci", VsanCapabilityTypeEnum::Dhci),
        ("umap", VsanCapabilityTypeEnum::Umap),
        ("sha256thumbprint", VsanCapabilityTypeEnum::Sha256Thumbprint),
        ("healthcorrelation", VsanCapabilityTypeEnum::Healthcorrelation),
        ("vsan2hcimesh", VsanCapabilityTypeEnum::Vsan2Hcimesh),
        ("fileservicescale", VsanCapabilityTypeEnum::Fileservicescale),
        ("vsanhostdomlatencysort", VsanCapabilityTypeEnum::Vsanhostdomlatencysort),
        ("hdcsintegration", VsanCapabilityTypeEnum::Hdcsintegration),
        ("fileservicesc", VsanCapabilityTypeEnum::Fileservicesc),
        ("fileservicenfsv3", VsanCapabilityTypeEnum::Fileservicenfsv3),
        ("firmwareupdate", VsanCapabilityTypeEnum::Firmwareupdate),
        ("vumintegration", VsanCapabilityTypeEnum::Vumintegration),
        ("improvedcapacityscreen", VsanCapabilityTypeEnum::Improvedcapacityscreen),
        ("vsanmetadatanode", VsanCapabilityTypeEnum::Vsanmetadatanode),
        ("repairtimerinresyncstats", VsanCapabilityTypeEnum::Repairtimerinresyncstats),
        ("masspropertycollector", VsanCapabilityTypeEnum::Masspropertycollector),
        ("vsandsdefaultpolicy", VsanCapabilityTypeEnum::Vsandsdefaultpolicy),
        ("allflash", VsanCapabilityTypeEnum::Allflash),
        ("iodiagmultiplevms", VsanCapabilityTypeEnum::Iodiagmultiplevms),
        ("fileservicekerberos", VsanCapabilityTypeEnum::Fileservicekerberos),
        ("hcimeshpolicy", VsanCapabilityTypeEnum::Hcimeshpolicy),
        ("securewipe", VsanCapabilityTypeEnum::Securewipe),
        ("perfsvcautoconfig", VsanCapabilityTypeEnum::Perfsvcautoconfig),
        ("objectidentities", VsanCapabilityTypeEnum::Objectidentities),
        ("remotedatastore", VsanCapabilityTypeEnum::Remotedatastore),
        ("vsanmanagedvmfs", VsanCapabilityTypeEnum::Vsanmanagedvmfs),
        ("fullStackFw", VsanCapabilityTypeEnum::FullStackFw),
        ("diagnosticmode", VsanCapabilityTypeEnum::Diagnosticmode),
        ("resyncetaimprovement", VsanCapabilityTypeEnum::Resyncetaimprovement),
        ("sharedwitness", VsanCapabilityTypeEnum::Sharedwitness),
        ("volumerelocation", VsanCapabilityTypeEnum::Volumerelocation),
        ("hostaffinity", VsanCapabilityTypeEnum::Hostaffinity),
        ("hcimeshstretchedcluster", VsanCapabilityTypeEnum::Hcimeshstretchedcluster),
        ("nondatamovementdfc", VsanCapabilityTypeEnum::Nondatamovementdfc),
        ("apidevversionenabled", VsanCapabilityTypeEnum::Apidevversionenabled),
        ("vsanclient", VsanCapabilityTypeEnum::Vsanclient),
        ("historicalcapacity", VsanCapabilityTypeEnum::Historicalcapacity),
        ("vsan2disableencryption", VsanCapabilityTypeEnum::Vsan2Disableencryption),
        ("capability", VsanCapabilityTypeEnum::Capability),
        ("duplicatepciidfix", VsanCapabilityTypeEnum::Duplicatepciidfix),
        ("ioinsight", VsanCapabilityTypeEnum::Ioinsight),
        ("capacityoversubscription", VsanCapabilityTypeEnum::Capacityoversubscription),
        ("metricsconfig", VsanCapabilityTypeEnum::Metricsconfig),
        ("genericnestedfd", VsanCapabilityTypeEnum::Genericnestedfd),
        ("clusterpowerselfcontain", VsanCapabilityTypeEnum::Clusterpowerselfcontain),
        ("clusterconfig", VsanCapabilityTypeEnum::Clusterconfig),
        ("vsanxvchcimeshv2", VsanCapabilityTypeEnum::Vsanxvchcimeshv2),
        ("gethcllastupdateonvc", VsanCapabilityTypeEnum::Gethcllastupdateonvc),
        ("vsananalyticsevents", VsanCapabilityTypeEnum::Vsananalyticsevents),
        ("cloudhealth", VsanCapabilityTypeEnum::Cloudhealth),
        ("unicasttest", VsanCapabilityTypeEnum::Unicasttest),
        ("upgrade", VsanCapabilityTypeEnum::Upgrade),
        ("performanceforsupport", VsanCapabilityTypeEnum::Performanceforsupport),
        ("vsanperfhighresolution", VsanCapabilityTypeEnum::Vsanperfhighresolution),
        ("upgraderesourceprecheck", VsanCapabilityTypeEnum::Upgraderesourceprecheck),
        ("diskresourceprecheck", VsanCapabilityTypeEnum::Diskresourceprecheck),
        ("configassist", VsanCapabilityTypeEnum::Configassist),
        ("largecapacitydrive", VsanCapabilityTypeEnum::Largecapacitydrive),
        ("vsanrdma", VsanCapabilityTypeEnum::Vsanrdma),
        ("localdataprotection", VsanCapabilityTypeEnum::Localdataprotection),
    ],
};

impl VsanCapabilityTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanCapabilityTypeEnum::Capability => "capability",
            VsanCapabilityTypeEnum::Allflash => "allflash",
            VsanCapabilityTypeEnum::Stretchedcluster => "stretchedcluster",
            VsanCapabilityTypeEnum::Dataefficiency => "dataefficiency",
            VsanCapabilityTypeEnum::Clusterconfig => "clusterconfig",
            VsanCapabilityTypeEnum::Upgrade => "upgrade",
            VsanCapabilityTypeEnum::Objectidentities => "objectidentities",
            VsanCapabilityTypeEnum::Iscsitargets => "iscsitargets",
            VsanCapabilityTypeEnum::Witnessmanagement => "witnessmanagement",
            VsanCapabilityTypeEnum::Perfsvcverbosemode => "perfsvcverbosemode",
            VsanCapabilityTypeEnum::Encryption => "encryption",
            VsanCapabilityTypeEnum::Decomwhatif => "decomwhatif",
            VsanCapabilityTypeEnum::Throttleresync => "throttleresync",
            VsanCapabilityTypeEnum::Unicastmode => "unicastmode",
            VsanCapabilityTypeEnum::Device4Ksupport => "device4ksupport",
            VsanCapabilityTypeEnum::Nestedfd => "nestedfd",
            VsanCapabilityTypeEnum::Complianceprecheck => "complianceprecheck",
            VsanCapabilityTypeEnum::Vumintegration => "vumintegration",
            VsanCapabilityTypeEnum::Firmwareupdate => "firmwareupdate",
            VsanCapabilityTypeEnum::FullStackFw => "fullStackFw",
            VsanCapabilityTypeEnum::Configassist => "configassist",
            VsanCapabilityTypeEnum::Umap => "umap",
            VsanCapabilityTypeEnum::Localdataprotection => "localdataprotection",
            VsanCapabilityTypeEnum::Archivaldataprotection => "archivaldataprotection",
            VsanCapabilityTypeEnum::Pr1741414Fixed => "pr1741414fixed",
            VsanCapabilityTypeEnum::Cloudhealth => "cloudhealth",
            VsanCapabilityTypeEnum::Perfanalysis => "perfanalysis",
            VsanCapabilityTypeEnum::Fcd => "fcd",
            VsanCapabilityTypeEnum::Healthcheck2018Q2 => "healthcheck2018q2",
            VsanCapabilityTypeEnum::Enhancedresyncapi => "enhancedresyncapi",
            VsanCapabilityTypeEnum::Genericnestedfd => "genericnestedfd",
            VsanCapabilityTypeEnum::Hostaffinity => "hostaffinity",
            VsanCapabilityTypeEnum::Perfsvcautoconfig => "perfsvcautoconfig",
            VsanCapabilityTypeEnum::Unicasttest => "unicasttest",
            VsanCapabilityTypeEnum::Vsanrdma => "vsanrdma",
            VsanCapabilityTypeEnum::Vumbaselinerecommendation => "vumbaselinerecommendation",
            VsanCapabilityTypeEnum::Supportinsight => "supportinsight",
            VsanCapabilityTypeEnum::Netperftest => "netperftest",
            VsanCapabilityTypeEnum::Masspropertycollector => "masspropertycollector",
            VsanCapabilityTypeEnum::Whatifcapacity => "whatifcapacity",
            VsanCapabilityTypeEnum::Historicalcapacity => "historicalcapacity",
            VsanCapabilityTypeEnum::Policyassociation => "policyassociation",
            VsanCapabilityTypeEnum::Policyhostapi => "policyhostapi",
            VsanCapabilityTypeEnum::Diagnosticmode => "diagnosticmode",
            VsanCapabilityTypeEnum::Purgeinaccessiblevmswapobjects => "purgeinaccessiblevmswapobjects",
            VsanCapabilityTypeEnum::Recreatediskgroup => "recreatediskgroup",
            VsanCapabilityTypeEnum::Repairtimerinresyncstats => "repairtimerinresyncstats",
            VsanCapabilityTypeEnum::Clusteradvancedoptions => "clusteradvancedoptions",
            VsanCapabilityTypeEnum::Updatevumreleasecatalogoffline => "updatevumreleasecatalogoffline",
            VsanCapabilityTypeEnum::Performanceforsupport => "performanceforsupport",
            VsanCapabilityTypeEnum::Gethcllastupdateonvc => "gethcllastupdateonvc",
            VsanCapabilityTypeEnum::Automaticrebalance => "automaticrebalance",
            VsanCapabilityTypeEnum::Verbosemodeconfiguration => "verbosemodeconfiguration",
            VsanCapabilityTypeEnum::Resyncetaimprovement => "resyncetaimprovement",
            VsanCapabilityTypeEnum::Fileservices => "fileservices",
            VsanCapabilityTypeEnum::Fileservicekerberos => "fileservicekerberos",
            VsanCapabilityTypeEnum::Fileservicesmb => "fileservicesmb",
            VsanCapabilityTypeEnum::Fileservicenfsv3 => "fileservicenfsv3",
            VsanCapabilityTypeEnum::Fileservicesc => "fileservicesc",
            VsanCapabilityTypeEnum::Fileservicesnapshot => "fileservicesnapshot",
            VsanCapabilityTypeEnum::Fileserviceowe => "fileserviceowe",
            VsanCapabilityTypeEnum::Fileservice80 => "fileservice80",
            VsanCapabilityTypeEnum::Fileservicescale => "fileservicescale",
            VsanCapabilityTypeEnum::Resourceprecheck => "resourceprecheck",
            VsanCapabilityTypeEnum::Upgraderesourceprecheck => "upgraderesourceprecheck",
            VsanCapabilityTypeEnum::Vitonlineresize => "vitonlineresize",
            VsanCapabilityTypeEnum::Vitstretchedcluster => "vitstretchedcluster",
            VsanCapabilityTypeEnum::Largecapacitydrive => "largecapacitydrive",
            VsanCapabilityTypeEnum::Nondatamovementdfc => "nondatamovementdfc",
            VsanCapabilityTypeEnum::Cnsvolumes => "cnsvolumes",
            VsanCapabilityTypeEnum::Filevolumes => "filevolumes",
            VsanCapabilityTypeEnum::Diagnosticsfeedback => "diagnosticsfeedback",
            VsanCapabilityTypeEnum::Hostreservedcapacity => "hostreservedcapacity",
            VsanCapabilityTypeEnum::Vmlevelcapacity => "vmlevelcapacity",
            VsanCapabilityTypeEnum::Improvedcapacityscreen => "improvedcapacityscreen",
            VsanCapabilityTypeEnum::Slackspacecapacity => "slackspacecapacity",
            VsanCapabilityTypeEnum::Sharedwitness => "sharedwitness",
            VsanCapabilityTypeEnum::VsanCapabilityTypeUnknown => "VsanCapabilityType_Unknown",
            VsanCapabilityTypeEnum::SupportApiVersion => "supportApiVersion",
            VsanCapabilityTypeEnum::Vsanmetadatanode => "vsanmetadatanode",
            VsanCapabilityTypeEnum::Pmanintegration => "pmanintegration",
            VsanCapabilityTypeEnum::Wcpappplatform => "wcpappplatform",
            VsanCapabilityTypeEnum::Diskresourceprecheck => "diskresourceprecheck",
            VsanCapabilityTypeEnum::Metricsconfig => "metricsconfig",
            VsanCapabilityTypeEnum::Ioinsight => "ioinsight",
            VsanCapabilityTypeEnum::Apidevversionenabled => "apidevversionenabled",
            VsanCapabilityTypeEnum::Nativelargeclustersupport => "nativelargeclustersupport",
            VsanCapabilityTypeEnum::Historicalhealth => "historicalhealth",
            VsanCapabilityTypeEnum::Dataintransitencryption => "dataintransitencryption",
            VsanCapabilityTypeEnum::Perfsvctwoyaxisgraph => "perfsvctwoyaxisgraph",
            VsanCapabilityTypeEnum::Compressiononly => "compressiononly",
            VsanCapabilityTypeEnum::Remotedatastore => "remotedatastore",
            VsanCapabilityTypeEnum::Vsanmanagedvmfs => "vsanmanagedvmfs",
            VsanCapabilityTypeEnum::Capacityreservation => "capacityreservation",
            VsanCapabilityTypeEnum::Securewipe => "securewipe",
            VsanCapabilityTypeEnum::Validateconfigspec => "validateconfigspec",
            VsanCapabilityTypeEnum::Vsananalyticsevents => "vsananalyticsevents",
            VsanCapabilityTypeEnum::Vsandefaultgatewaysupported => "vsandefaultgatewaysupported",
            VsanCapabilityTypeEnum::Pspairgap => "pspairgap",
            VsanCapabilityTypeEnum::Vsanmanagedpmem => "vsanmanagedpmem",
            VsanCapabilityTypeEnum::Capacityevaluationonvc => "capacityevaluationonvc",
            VsanCapabilityTypeEnum::Readlocalitytodrs => "readlocalitytodrs",
            VsanCapabilityTypeEnum::Vsanencrkmx => "vsanencrkmx",
            VsanCapabilityTypeEnum::Vsan2Encr => "vsan2encr",
            VsanCapabilityTypeEnum::Dit4Sw => "dit4sw",
            VsanCapabilityTypeEnum::Vsanclient => "vsanclient",
            VsanCapabilityTypeEnum::Capacityoversubscription => "capacityoversubscription",
            VsanCapabilityTypeEnum::Vsandiagnostics => "vsandiagnostics",
            VsanCapabilityTypeEnum::Capacitycustomizablethresholds => "capacitycustomizablethresholds",
            VsanCapabilityTypeEnum::Hcimeshpolicy => "hcimeshpolicy",
            VsanCapabilityTypeEnum::Topcontributors => "topcontributors",
            VsanCapabilityTypeEnum::Vsandirectdiskdecom => "vsandirectdiskdecom",
            VsanCapabilityTypeEnum::Diskmgmtredesign => "diskmgmtredesign",
            VsanCapabilityTypeEnum::Datapersistresourcecheck => "datapersistresourcecheck",
            VsanCapabilityTypeEnum::Clusterpoweraction => "clusterpoweraction",
            VsanCapabilityTypeEnum::Clusterpowerselfcontain => "clusterpowerselfcontain",
            VsanCapabilityTypeEnum::Duplicatepciidfix => "duplicatepciidfix",
            VsanCapabilityTypeEnum::Healthcorrelation => "healthcorrelation",
            VsanCapabilityTypeEnum::Volumerelocation => "volumerelocation",
            VsanCapabilityTypeEnum::Iodiagnostics => "iodiagnostics",
            VsanCapabilityTypeEnum::Vsanrebuildtrim => "vsanrebuildtrim",
            VsanCapabilityTypeEnum::Elasticpolicy => "elasticpolicy",
            VsanCapabilityTypeEnum::VsanEsaConfigure => "vsanEsaConfigure",
            VsanCapabilityTypeEnum::Hdcsintegration => "hdcsintegration",
            VsanCapabilityTypeEnum::Vsanesasingletier => "vsanesasingletier",
            VsanCapabilityTypeEnum::Vsanperfhighresolution => "vsanperfhighresolution",
            VsanCapabilityTypeEnum::Cnsreconfigpolicy => "cnsreconfigpolicy",
            VsanCapabilityTypeEnum::Vsanhostdomlatencysort => "vsanhostdomlatencysort",
            VsanCapabilityTypeEnum::Sha256Thumbprint => "sha256thumbprint",
            VsanCapabilityTypeEnum::Minrebalancethreshold => "minrebalancethreshold",
            VsanCapabilityTypeEnum::Vsan2Hcimesh => "vsan2hcimesh",
            VsanCapabilityTypeEnum::Dfcobjectsmanagement => "dfcobjectsmanagement",
            VsanCapabilityTypeEnum::Healthremediation => "healthremediation",
            VsanCapabilityTypeEnum::Hcimeshstretchedcluster => "hcimeshstretchedcluster",
            VsanCapabilityTypeEnum::Vsanxvchcimesh => "vsanxvchcimesh",
            VsanCapabilityTypeEnum::Vsan2Deeprekey => "vsan2deeprekey",
            VsanCapabilityTypeEnum::Vsandsdefaultpolicy => "vsandsdefaultpolicy",
            VsanCapabilityTypeEnum::Vsanperfsvc80U2 => "vsanperfsvc80u2",
            VsanCapabilityTypeEnum::Vsankeyexpiration => "vsankeyexpiration",
            VsanCapabilityTypeEnum::Vsanxvchcimeshv2 => "vsanxvchcimeshv2",
            VsanCapabilityTypeEnum::Dhci => "dhci",
            VsanCapabilityTypeEnum::Snapservice => "snapservice",
            VsanCapabilityTypeEnum::Vsan2Disableencryption => "vsan2disableencryption",
            VsanCapabilityTypeEnum::Iodiagmultiplevms => "iodiagmultiplevms",
            VsanCapabilityTypeEnum::Vsanxvchcimeshv3 => "vsanxvchcimeshv3",
            VsanCapabilityTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_CAPABILITY_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanCapabilityTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanCapabilityTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanCapabilityTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanCapabilityTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanCapabilityTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanCapabilityTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanCapabilityTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanCapabilityTypeEnum> for &'a str {
    fn from(value: &'a VsanCapabilityTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanCapabilityTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_CAPABILITY_TYPE_90_ENUM_MAP: phf::Map<&'static str, VsanCapabilityType90Enum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (1, 0),
        (0, 2),
    ],
    entries: &[
        ("vsaniscsivip", VsanCapabilityType90Enum::Vsaniscsivip),
        ("globaldedup", VsanCapabilityType90Enum::Globaldedup),
        ("vsanstretchedclient", VsanCapabilityType90Enum::Vsanstretchedclient),
        ("vsanreplication", VsanCapabilityType90Enum::Vsanreplication),
        ("vsansitemaintenance", VsanCapabilityType90Enum::Vsansitemaintenance),
        ("vsandedicatedvmknic", VsanCapabilityType90Enum::Vsandedicatedvmknic),
    ],
};

impl VsanCapabilityType90Enum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanCapabilityType90Enum::Vsanreplication => "vsanreplication",
            VsanCapabilityType90Enum::Vsandedicatedvmknic => "vsandedicatedvmknic",
            VsanCapabilityType90Enum::Globaldedup => "globaldedup",
            VsanCapabilityType90Enum::Vsanstretchedclient => "vsanstretchedclient",
            VsanCapabilityType90Enum::Vsaniscsivip => "vsaniscsivip",
            VsanCapabilityType90Enum::Vsansitemaintenance => "vsansitemaintenance",
            VsanCapabilityType90Enum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_CAPABILITY_TYPE_90_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanCapabilityType90Enum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanCapabilityType90Enum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanCapabilityType90Enum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanCapabilityType90Enum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanCapabilityType90Enum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanCapabilityType90Enum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanCapabilityType90Enum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanCapabilityType90Enum> for &'a str {
    fn from(value: &'a VsanCapabilityType90Enum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanCapabilityType90Enum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_CLUSTER_HEALTH_ACTION_ID_ENUM_ENUM_MAP: phf::Map<&'static str, VsanClusterHealthActionIdEnumEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (0, 14),
        (1, 6),
        (6, 0),
        (3, 7),
        (6, 5),
        (8, 4),
        (0, 2),
    ],
    entries: &[
        ("PurgeInaccessSwapObjs", VsanClusterHealthActionIdEnumEnum::PurgeInaccessSwapObjs),
        ("SelectNvme", VsanClusterHealthActionIdEnumEnum::SelectNvme),
        ("ConfigureAutomaticRebalance", VsanClusterHealthActionIdEnumEnum::ConfigureAutomaticRebalance),
        ("RemediateIscsiLunsRuntimeStatus", VsanClusterHealthActionIdEnumEnum::RemediateIscsiLunsRuntimeStatus),
        ("LoginVumIsoDepot", VsanClusterHealthActionIdEnumEnum::LoginVumIsoDepot),
        ("ConfigureHA", VsanClusterHealthActionIdEnumEnum::ConfigureHa),
        ("UpgradeVsanDiskFormat", VsanClusterHealthActionIdEnumEnum::UpgradeVsanDiskFormat),
        ("EnableCeip", VsanClusterHealthActionIdEnumEnum::EnableCeip),
        ("RelayoutVsanObjects", VsanClusterHealthActionIdEnumEnum::RelayoutVsanObjects),
        ("EnablePerformanceServiceAction", VsanClusterHealthActionIdEnumEnum::EnablePerformanceServiceAction),
        ("ClusterUpgrade", VsanClusterHealthActionIdEnumEnum::ClusterUpgrade),
        ("RepairClusterObjectsAction", VsanClusterHealthActionIdEnumEnum::RepairClusterObjectsAction),
        ("CreateFileServiceDomain", VsanClusterHealthActionIdEnumEnum::CreateFileServiceDomain),
        ("ShallowRekey", VsanClusterHealthActionIdEnumEnum::ShallowRekey),
        ("UploadHclDb", VsanClusterHealthActionIdEnumEnum::UploadHclDb),
        ("ClaimVSANDisks", VsanClusterHealthActionIdEnumEnum::ClaimVsanDisks),
        ("RunBurnInTest", VsanClusterHealthActionIdEnumEnum::RunBurnInTest),
        ("EnableHealthService", VsanClusterHealthActionIdEnumEnum::EnableHealthService),
        ("CreateDVS", VsanClusterHealthActionIdEnumEnum::CreateDvs),
        ("RemediateClusterConfig", VsanClusterHealthActionIdEnumEnum::RemediateClusterConfig),
        ("CreateVMKnicWithVMotion", VsanClusterHealthActionIdEnumEnum::CreateVmKnicWithVMotion),
        ("VsanClusterHealthActionIdEnum_Unknown", VsanClusterHealthActionIdEnumEnum::VsanClusterHealthActionIdEnumUnknown),
        ("RemediateFileServiceImbalance", VsanClusterHealthActionIdEnumEnum::RemediateFileServiceImbalance),
        ("CreateVMKnic", VsanClusterHealthActionIdEnumEnum::CreateVmKnic),
        ("RemediateFileService", VsanClusterHealthActionIdEnumEnum::RemediateFileService),
        ("ConfigureVSAN", VsanClusterHealthActionIdEnumEnum::ConfigureVsan),
        ("RemediateDedup", VsanClusterHealthActionIdEnumEnum::RemediateDedup),
        ("StopDiskBalance", VsanClusterHealthActionIdEnumEnum::StopDiskBalance),
        ("DiskBalance", VsanClusterHealthActionIdEnumEnum::DiskBalance),
        ("UpdateHclDbFromInternet", VsanClusterHealthActionIdEnumEnum::UpdateHclDbFromInternet),
        ("ConfigureDRS", VsanClusterHealthActionIdEnumEnum::ConfigureDrs),
        ("EnableIscsiTargetService", VsanClusterHealthActionIdEnumEnum::EnableIscsiTargetService),
        ("UploadReleaseCatalog", VsanClusterHealthActionIdEnumEnum::UploadReleaseCatalog),
    ],
};

impl VsanClusterHealthActionIdEnumEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanClusterHealthActionIdEnumEnum::RepairClusterObjectsAction => "RepairClusterObjectsAction",
            VsanClusterHealthActionIdEnumEnum::UploadHclDb => "UploadHclDb",
            VsanClusterHealthActionIdEnumEnum::UpdateHclDbFromInternet => "UpdateHclDbFromInternet",
            VsanClusterHealthActionIdEnumEnum::EnableHealthService => "EnableHealthService",
            VsanClusterHealthActionIdEnumEnum::DiskBalance => "DiskBalance",
            VsanClusterHealthActionIdEnumEnum::StopDiskBalance => "StopDiskBalance",
            VsanClusterHealthActionIdEnumEnum::RemediateDedup => "RemediateDedup",
            VsanClusterHealthActionIdEnumEnum::UpgradeVsanDiskFormat => "UpgradeVsanDiskFormat",
            VsanClusterHealthActionIdEnumEnum::CreateDvs => "CreateDVS",
            VsanClusterHealthActionIdEnumEnum::ConfigureHa => "ConfigureHA",
            VsanClusterHealthActionIdEnumEnum::ConfigureDrs => "ConfigureDRS",
            VsanClusterHealthActionIdEnumEnum::ConfigureVsan => "ConfigureVSAN",
            VsanClusterHealthActionIdEnumEnum::ClaimVsanDisks => "ClaimVSANDisks",
            VsanClusterHealthActionIdEnumEnum::ClusterUpgrade => "ClusterUpgrade",
            VsanClusterHealthActionIdEnumEnum::CreateVmKnic => "CreateVMKnic",
            VsanClusterHealthActionIdEnumEnum::CreateVmKnicWithVMotion => "CreateVMKnicWithVMotion",
            VsanClusterHealthActionIdEnumEnum::RunBurnInTest => "RunBurnInTest",
            VsanClusterHealthActionIdEnumEnum::EnableIscsiTargetService => "EnableIscsiTargetService",
            VsanClusterHealthActionIdEnumEnum::EnablePerformanceServiceAction => "EnablePerformanceServiceAction",
            VsanClusterHealthActionIdEnumEnum::RemediateClusterConfig => "RemediateClusterConfig",
            VsanClusterHealthActionIdEnumEnum::EnableCeip => "EnableCeip",
            VsanClusterHealthActionIdEnumEnum::LoginVumIsoDepot => "LoginVumIsoDepot",
            VsanClusterHealthActionIdEnumEnum::PurgeInaccessSwapObjs => "PurgeInaccessSwapObjs",
            VsanClusterHealthActionIdEnumEnum::UploadReleaseCatalog => "UploadReleaseCatalog",
            VsanClusterHealthActionIdEnumEnum::ConfigureAutomaticRebalance => "ConfigureAutomaticRebalance",
            VsanClusterHealthActionIdEnumEnum::RemediateFileService => "RemediateFileService",
            VsanClusterHealthActionIdEnumEnum::RelayoutVsanObjects => "RelayoutVsanObjects",
            VsanClusterHealthActionIdEnumEnum::RemediateFileServiceImbalance => "RemediateFileServiceImbalance",
            VsanClusterHealthActionIdEnumEnum::SelectNvme => "SelectNvme",
            VsanClusterHealthActionIdEnumEnum::CreateFileServiceDomain => "CreateFileServiceDomain",
            VsanClusterHealthActionIdEnumEnum::RemediateIscsiLunsRuntimeStatus => "RemediateIscsiLunsRuntimeStatus",
            VsanClusterHealthActionIdEnumEnum::ShallowRekey => "ShallowRekey",
            VsanClusterHealthActionIdEnumEnum::VsanClusterHealthActionIdEnumUnknown => "VsanClusterHealthActionIdEnum_Unknown",
            VsanClusterHealthActionIdEnumEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_CLUSTER_HEALTH_ACTION_ID_ENUM_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanClusterHealthActionIdEnumEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanClusterHealthActionIdEnumEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanClusterHealthActionIdEnumEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanClusterHealthActionIdEnumEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanClusterHealthActionIdEnumEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanClusterHealthActionIdEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanClusterHealthActionIdEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanClusterHealthActionIdEnumEnum> for &'a str {
    fn from(value: &'a VsanClusterHealthActionIdEnumEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanClusterHealthActionIdEnumEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_CLUSTER_HEALTH_CATEGORY_ENUM_ENUM_MAP: phf::Map<&'static str, VsanClusterHealthCategoryEnumEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
        (1, 2),
    ],
    entries: &[
        ("CapacityUtilization", VsanClusterHealthCategoryEnumEnum::CapacityUtilization),
        ("Compliance", VsanClusterHealthCategoryEnumEnum::Compliance),
        ("InfraPerformance", VsanClusterHealthCategoryEnumEnum::InfraPerformance),
        ("InfraAvailability", VsanClusterHealthCategoryEnumEnum::InfraAvailability),
        ("DataAvailability", VsanClusterHealthCategoryEnumEnum::DataAvailability),
        ("SoftResourceUtilization", VsanClusterHealthCategoryEnumEnum::SoftResourceUtilization),
        ("DataPerformance", VsanClusterHealthCategoryEnumEnum::DataPerformance),
        ("VsanClusterHealthCategoryEnum_Unknown", VsanClusterHealthCategoryEnumEnum::VsanClusterHealthCategoryEnumUnknown),
    ],
};

impl VsanClusterHealthCategoryEnumEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanClusterHealthCategoryEnumEnum::DataAvailability => "DataAvailability",
            VsanClusterHealthCategoryEnumEnum::InfraAvailability => "InfraAvailability",
            VsanClusterHealthCategoryEnumEnum::DataPerformance => "DataPerformance",
            VsanClusterHealthCategoryEnumEnum::InfraPerformance => "InfraPerformance",
            VsanClusterHealthCategoryEnumEnum::CapacityUtilization => "CapacityUtilization",
            VsanClusterHealthCategoryEnumEnum::SoftResourceUtilization => "SoftResourceUtilization",
            VsanClusterHealthCategoryEnumEnum::Compliance => "Compliance",
            VsanClusterHealthCategoryEnumEnum::VsanClusterHealthCategoryEnumUnknown => "VsanClusterHealthCategoryEnum_Unknown",
            VsanClusterHealthCategoryEnumEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_CLUSTER_HEALTH_CATEGORY_ENUM_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanClusterHealthCategoryEnumEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanClusterHealthCategoryEnumEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanClusterHealthCategoryEnumEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanClusterHealthCategoryEnumEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanClusterHealthCategoryEnumEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanClusterHealthCategoryEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanClusterHealthCategoryEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanClusterHealthCategoryEnumEnum> for &'a str {
    fn from(value: &'a VsanClusterHealthCategoryEnumEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanClusterHealthCategoryEnumEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_DATASTORE_TYPE_ENUM_MAP: phf::Map<&'static str, VsanDatastoreTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("vsandirect", VsanDatastoreTypeEnum::Vsandirect),
        ("vsan", VsanDatastoreTypeEnum::Vsan),
        ("pmem", VsanDatastoreTypeEnum::Pmem),
        ("VsanDatastoreType_Unknown", VsanDatastoreTypeEnum::VsanDatastoreTypeUnknown),
    ],
};

impl VsanDatastoreTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanDatastoreTypeEnum::Vsan => "vsan",
            VsanDatastoreTypeEnum::Vsandirect => "vsandirect",
            VsanDatastoreTypeEnum::Pmem => "pmem",
            VsanDatastoreTypeEnum::VsanDatastoreTypeUnknown => "VsanDatastoreType_Unknown",
            VsanDatastoreTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_DATASTORE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanDatastoreTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanDatastoreTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanDatastoreTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanDatastoreTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanDatastoreTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanDatastoreTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanDatastoreTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanDatastoreTypeEnum> for &'a str {
    fn from(value: &'a VsanDatastoreTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanDatastoreTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIM_CLUSTER_VSAN_DISK_GROUP_CREATION_TYPE_ENUM_MAP: phf::Map<&'static str, VimClusterVsanDiskGroupCreationTypeEnum> = ::phf::Map {
    key: 106375038446233661,
    disps: &[
        (4, 0),
    ],
    entries: &[
        ("allflash", VimClusterVsanDiskGroupCreationTypeEnum::Allflash),
        ("hybrid", VimClusterVsanDiskGroupCreationTypeEnum::Hybrid),
        ("vsandirect", VimClusterVsanDiskGroupCreationTypeEnum::Vsandirect),
        ("VsanDiskGroupCreationType_Unknown", VimClusterVsanDiskGroupCreationTypeEnum::VsanDiskGroupCreationTypeUnknown),
        ("pmem", VimClusterVsanDiskGroupCreationTypeEnum::Pmem),
    ],
};

impl VimClusterVsanDiskGroupCreationTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VimClusterVsanDiskGroupCreationTypeEnum::Allflash => "allflash",
            VimClusterVsanDiskGroupCreationTypeEnum::Hybrid => "hybrid",
            VimClusterVsanDiskGroupCreationTypeEnum::Vsandirect => "vsandirect",
            VimClusterVsanDiskGroupCreationTypeEnum::Pmem => "pmem",
            VimClusterVsanDiskGroupCreationTypeEnum::VsanDiskGroupCreationTypeUnknown => "VsanDiskGroupCreationType_Unknown",
            VimClusterVsanDiskGroupCreationTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIM_CLUSTER_VSAN_DISK_GROUP_CREATION_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VimClusterVsanDiskGroupCreationTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VimClusterVsanDiskGroupCreationTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VimClusterVsanDiskGroupCreationTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VimClusterVsanDiskGroupCreationTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VimClusterVsanDiskGroupCreationTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VimClusterVsanDiskGroupCreationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VimClusterVsanDiskGroupCreationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VimClusterVsanDiskGroupCreationTypeEnum> for &'a str {
    fn from(value: &'a VimClusterVsanDiskGroupCreationTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VimClusterVsanDiskGroupCreationTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_IO_INSIGHT_INSTANCE_STATE_ENUM_MAP: phf::Map<&'static str, VsanIoInsightInstanceStateEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("VsanIoInsightInstanceState_unknown", VsanIoInsightInstanceStateEnum::VsanIoInsightInstanceStateUnknown),
        ("crashed", VsanIoInsightInstanceStateEnum::Crashed),
        ("running", VsanIoInsightInstanceStateEnum::Running),
        ("completed", VsanIoInsightInstanceStateEnum::Completed),
    ],
};

impl VsanIoInsightInstanceStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanIoInsightInstanceStateEnum::Running => "running",
            VsanIoInsightInstanceStateEnum::Completed => "completed",
            VsanIoInsightInstanceStateEnum::Crashed => "crashed",
            VsanIoInsightInstanceStateEnum::VsanIoInsightInstanceStateUnknown => "VsanIoInsightInstanceState_unknown",
            VsanIoInsightInstanceStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_IO_INSIGHT_INSTANCE_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanIoInsightInstanceStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanIoInsightInstanceStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanIoInsightInstanceStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanIoInsightInstanceStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanIoInsightInstanceStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanIoInsightInstanceStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanIoInsightInstanceStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanIoInsightInstanceStateEnum> for &'a str {
    fn from(value: &'a VsanIoInsightInstanceStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanIoInsightInstanceStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_ISCSI_LUN_STATUS_ENUM_MAP: phf::Map<&'static str, VsanIscsiLunStatusEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("Offline", VsanIscsiLunStatusEnum::Offline),
        ("Online", VsanIscsiLunStatusEnum::Online),
        ("VsanIscsiLUNStatus_Unknown", VsanIscsiLunStatusEnum::VsanIscsiLunStatusUnknown),
    ],
};

impl VsanIscsiLunStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanIscsiLunStatusEnum::Online => "Online",
            VsanIscsiLunStatusEnum::Offline => "Offline",
            VsanIscsiLunStatusEnum::VsanIscsiLunStatusUnknown => "VsanIscsiLUNStatus_Unknown",
            VsanIscsiLunStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_ISCSI_LUN_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanIscsiLunStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanIscsiLunStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanIscsiLunStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanIscsiLunStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanIscsiLunStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanIscsiLunStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanIscsiLunStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanIscsiLunStatusEnum> for &'a str {
    fn from(value: &'a VsanIscsiLunStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanIscsiLunStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_ISCSI_LUN_RUNTIME_STATUS_TYPE_ENUM_MAP: phf::Map<&'static str, VsanIscsiLunRuntimeStatusTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("Offline", VsanIscsiLunRuntimeStatusTypeEnum::Offline),
        ("Online", VsanIscsiLunRuntimeStatusTypeEnum::Online),
        ("VsanIscsiLUNRuntimeStatusType_Unknown", VsanIscsiLunRuntimeStatusTypeEnum::VsanIscsiLunRuntimeStatusTypeUnknown),
    ],
};

impl VsanIscsiLunRuntimeStatusTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanIscsiLunRuntimeStatusTypeEnum::Online => "Online",
            VsanIscsiLunRuntimeStatusTypeEnum::Offline => "Offline",
            VsanIscsiLunRuntimeStatusTypeEnum::VsanIscsiLunRuntimeStatusTypeUnknown => "VsanIscsiLUNRuntimeStatusType_Unknown",
            VsanIscsiLunRuntimeStatusTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_ISCSI_LUN_RUNTIME_STATUS_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanIscsiLunRuntimeStatusTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanIscsiLunRuntimeStatusTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanIscsiLunRuntimeStatusTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanIscsiLunRuntimeStatusTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanIscsiLunRuntimeStatusTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanIscsiLunRuntimeStatusTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanIscsiLunRuntimeStatusTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanIscsiLunRuntimeStatusTypeEnum> for &'a str {
    fn from(value: &'a VsanIscsiLunRuntimeStatusTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanIscsiLunRuntimeStatusTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_ISCSI_TARGET_AUTH_TYPE_ENUM_MAP: phf::Map<&'static str, VsanIscsiTargetAuthTypeEnum> = ::phf::Map {
    key: 8694567506910003252,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("CHAP_Mutual", VsanIscsiTargetAuthTypeEnum::ChapMutual),
        ("CHAP", VsanIscsiTargetAuthTypeEnum::Chap),
        ("NoAuth", VsanIscsiTargetAuthTypeEnum::NoAuth),
        ("VsanIscsiTargetAuthType_Unknown", VsanIscsiTargetAuthTypeEnum::VsanIscsiTargetAuthTypeUnknown),
    ],
};

impl VsanIscsiTargetAuthTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanIscsiTargetAuthTypeEnum::NoAuth => "NoAuth",
            VsanIscsiTargetAuthTypeEnum::Chap => "CHAP",
            VsanIscsiTargetAuthTypeEnum::ChapMutual => "CHAP_Mutual",
            VsanIscsiTargetAuthTypeEnum::VsanIscsiTargetAuthTypeUnknown => "VsanIscsiTargetAuthType_Unknown",
            VsanIscsiTargetAuthTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_ISCSI_TARGET_AUTH_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanIscsiTargetAuthTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanIscsiTargetAuthTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanIscsiTargetAuthTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanIscsiTargetAuthTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanIscsiTargetAuthTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanIscsiTargetAuthTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanIscsiTargetAuthTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanIscsiTargetAuthTypeEnum> for &'a str {
    fn from(value: &'a VsanIscsiTargetAuthTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanIscsiTargetAuthTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_ISCSI_TARGET_SERVICE_PROCESS_STATUS_ENUM_MAP: phf::Map<&'static str, VsanIscsiTargetServiceProcessStatusEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("VsanIscsiTargetServiceProcessStatus_Unknown", VsanIscsiTargetServiceProcessStatusEnum::VsanIscsiTargetServiceProcessStatusUnknown),
        ("Running", VsanIscsiTargetServiceProcessStatusEnum::Running),
        ("Stopped", VsanIscsiTargetServiceProcessStatusEnum::Stopped),
    ],
};

impl VsanIscsiTargetServiceProcessStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanIscsiTargetServiceProcessStatusEnum::Running => "Running",
            VsanIscsiTargetServiceProcessStatusEnum::Stopped => "Stopped",
            VsanIscsiTargetServiceProcessStatusEnum::VsanIscsiTargetServiceProcessStatusUnknown => "VsanIscsiTargetServiceProcessStatus_Unknown",
            VsanIscsiTargetServiceProcessStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_ISCSI_TARGET_SERVICE_PROCESS_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanIscsiTargetServiceProcessStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanIscsiTargetServiceProcessStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanIscsiTargetServiceProcessStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanIscsiTargetServiceProcessStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanIscsiTargetServiceProcessStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanIscsiTargetServiceProcessStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanIscsiTargetServiceProcessStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanIscsiTargetServiceProcessStatusEnum> for &'a str {
    fn from(value: &'a VsanIscsiTargetServiceProcessStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanIscsiTargetServiceProcessStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_OBJECT_TYPE_ENUM_ENUM_MAP: phf::Map<&'static str, VsanObjectTypeEnumEnum> = ::phf::Map {
    key: 8694567506910003252,
    disps: &[
        (15, 1),
        (6, 11),
        (0, 0),
        (1, 0),
        (5, 13),
        (0, 1),
        (25, 18),
    ],
    entries: &[
        ("hbrPersist", VsanObjectTypeEnumEnum::HbrPersist),
        ("hbrCfg", VsanObjectTypeEnumEnum::HbrCfg),
        ("iscsiLun", VsanObjectTypeEnumEnum::IscsiLun),
        ("detachedCnsVolFile", VsanObjectTypeEnumEnum::DetachedCnsVolFile),
        ("VsanObjectTypeEnum_Unknown", VsanObjectTypeEnumEnum::VsanObjectTypeEnumUnknown),
        ("attachedCnsVolBlock", VsanObjectTypeEnumEnum::AttachedCnsVolBlock),
        ("statsdb", VsanObjectTypeEnumEnum::Statsdb),
        ("slackSpaceCapRequiredForHost", VsanObjectTypeEnumEnum::SlackSpaceCapRequiredForHost),
        ("improvedVirtualDisk", VsanObjectTypeEnumEnum::ImprovedVirtualDisk),
        ("extension", VsanObjectTypeEnumEnum::Extension),
        ("transientSpace", VsanObjectTypeEnumEnum::TransientSpace),
        ("dedupOverhead", VsanObjectTypeEnumEnum::DedupOverhead),
        ("iscsiTarget", VsanObjectTypeEnumEnum::IscsiTarget),
        ("physicalTransientSpace", VsanObjectTypeEnumEnum::PhysicalTransientSpace),
        ("vmswap", VsanObjectTypeEnumEnum::Vmswap),
        ("attachedCnsVolFile", VsanObjectTypeEnumEnum::AttachedCnsVolFile),
        ("other", VsanObjectTypeEnumEnum::Other),
        ("haMetadataObject", VsanObjectTypeEnumEnum::HaMetadataObject),
        ("hostRebuildCapacity", VsanObjectTypeEnumEnum::HostRebuildCapacity),
        ("namespace", VsanObjectTypeEnumEnum::Namespace),
        ("vdisk", VsanObjectTypeEnumEnum::Vdisk),
        ("spaceUnderDedupConsideration", VsanObjectTypeEnumEnum::SpaceUnderDedupConsideration),
        ("vmem", VsanObjectTypeEnumEnum::Vmem),
        ("cnsVolFile", VsanObjectTypeEnumEnum::CnsVolFile),
        ("checksumOverhead", VsanObjectTypeEnumEnum::ChecksumOverhead),
        ("fileServiceRoot", VsanObjectTypeEnumEnum::FileServiceRoot),
        ("esaObjectOverhead", VsanObjectTypeEnumEnum::EsaObjectOverhead),
        ("traceobject", VsanObjectTypeEnumEnum::Traceobject),
        ("minSpaceRequiredForVsanOp", VsanObjectTypeEnumEnum::MinSpaceRequiredForVsanOp),
        ("hbrDisk", VsanObjectTypeEnumEnum::HbrDisk),
        ("detachedCnsVolBlock", VsanObjectTypeEnumEnum::DetachedCnsVolBlock),
        ("fileShare", VsanObjectTypeEnumEnum::FileShare),
        ("resynPauseThresholdForHost", VsanObjectTypeEnumEnum::ResynPauseThresholdForHost),
        ("fileSystemOverhead", VsanObjectTypeEnumEnum::FileSystemOverhead),
    ],
};

impl VsanObjectTypeEnumEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanObjectTypeEnumEnum::Vmswap => "vmswap",
            VsanObjectTypeEnumEnum::Vdisk => "vdisk",
            VsanObjectTypeEnumEnum::Namespace => "namespace",
            VsanObjectTypeEnumEnum::Vmem => "vmem",
            VsanObjectTypeEnumEnum::Statsdb => "statsdb",
            VsanObjectTypeEnumEnum::IscsiTarget => "iscsiTarget",
            VsanObjectTypeEnumEnum::IscsiLun => "iscsiLun",
            VsanObjectTypeEnumEnum::Other => "other",
            VsanObjectTypeEnumEnum::FileSystemOverhead => "fileSystemOverhead",
            VsanObjectTypeEnumEnum::DedupOverhead => "dedupOverhead",
            VsanObjectTypeEnumEnum::SpaceUnderDedupConsideration => "spaceUnderDedupConsideration",
            VsanObjectTypeEnumEnum::ChecksumOverhead => "checksumOverhead",
            VsanObjectTypeEnumEnum::ImprovedVirtualDisk => "improvedVirtualDisk",
            VsanObjectTypeEnumEnum::TransientSpace => "transientSpace",
            VsanObjectTypeEnumEnum::SlackSpaceCapRequiredForHost => "slackSpaceCapRequiredForHost",
            VsanObjectTypeEnumEnum::ResynPauseThresholdForHost => "resynPauseThresholdForHost",
            VsanObjectTypeEnumEnum::MinSpaceRequiredForVsanOp => "minSpaceRequiredForVsanOp",
            VsanObjectTypeEnumEnum::HostRebuildCapacity => "hostRebuildCapacity",
            VsanObjectTypeEnumEnum::PhysicalTransientSpace => "physicalTransientSpace",
            VsanObjectTypeEnumEnum::HaMetadataObject => "haMetadataObject",
            VsanObjectTypeEnumEnum::FileServiceRoot => "fileServiceRoot",
            VsanObjectTypeEnumEnum::AttachedCnsVolBlock => "attachedCnsVolBlock",
            VsanObjectTypeEnumEnum::DetachedCnsVolBlock => "detachedCnsVolBlock",
            VsanObjectTypeEnumEnum::AttachedCnsVolFile => "attachedCnsVolFile",
            VsanObjectTypeEnumEnum::DetachedCnsVolFile => "detachedCnsVolFile",
            VsanObjectTypeEnumEnum::CnsVolFile => "cnsVolFile",
            VsanObjectTypeEnumEnum::FileShare => "fileShare",
            VsanObjectTypeEnumEnum::Extension => "extension",
            VsanObjectTypeEnumEnum::HbrDisk => "hbrDisk",
            VsanObjectTypeEnumEnum::HbrCfg => "hbrCfg",
            VsanObjectTypeEnumEnum::HbrPersist => "hbrPersist",
            VsanObjectTypeEnumEnum::Traceobject => "traceobject",
            VsanObjectTypeEnumEnum::EsaObjectOverhead => "esaObjectOverhead",
            VsanObjectTypeEnumEnum::VsanObjectTypeEnumUnknown => "VsanObjectTypeEnum_Unknown",
            VsanObjectTypeEnumEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_OBJECT_TYPE_ENUM_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanObjectTypeEnumEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanObjectTypeEnumEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanObjectTypeEnumEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanObjectTypeEnumEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanObjectTypeEnumEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanObjectTypeEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanObjectTypeEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanObjectTypeEnumEnum> for &'a str {
    fn from(value: &'a VsanObjectTypeEnumEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanObjectTypeEnumEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_OBJECT_TYPE_ENUM_90_ENUM_MAP: phf::Map<&'static str, VsanObjectTypeEnum90Enum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("dedupSharedUserData", VsanObjectTypeEnum90Enum::DedupSharedUserData),
    ],
};

impl VsanObjectTypeEnum90Enum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanObjectTypeEnum90Enum::DedupSharedUserData => "dedupSharedUserData",
            VsanObjectTypeEnum90Enum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_OBJECT_TYPE_ENUM_90_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanObjectTypeEnum90Enum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanObjectTypeEnum90Enum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanObjectTypeEnum90Enum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanObjectTypeEnum90Enum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanObjectTypeEnum90Enum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanObjectTypeEnum90Enum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanObjectTypeEnum90Enum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanObjectTypeEnum90Enum> for &'a str {
    fn from(value: &'a VsanObjectTypeEnum90Enum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanObjectTypeEnum90Enum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_PERF_DIAGNOSTIC_QUERY_TYPE_ENUM_MAP: phf::Map<&'static str, VsanPerfDiagnosticQueryTypeEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("lat", VsanPerfDiagnosticQueryTypeEnum::Lat),
        ("VsanPerfDiagnosticQueryType_Unknown", VsanPerfDiagnosticQueryTypeEnum::VsanPerfDiagnosticQueryTypeUnknown),
        ("eval", VsanPerfDiagnosticQueryTypeEnum::Eval),
        ("iops", VsanPerfDiagnosticQueryTypeEnum::Iops),
        ("tput", VsanPerfDiagnosticQueryTypeEnum::Tput),
    ],
};

impl VsanPerfDiagnosticQueryTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanPerfDiagnosticQueryTypeEnum::Tput => "tput",
            VsanPerfDiagnosticQueryTypeEnum::Iops => "iops",
            VsanPerfDiagnosticQueryTypeEnum::Lat => "lat",
            VsanPerfDiagnosticQueryTypeEnum::Eval => "eval",
            VsanPerfDiagnosticQueryTypeEnum::VsanPerfDiagnosticQueryTypeUnknown => "VsanPerfDiagnosticQueryType_Unknown",
            VsanPerfDiagnosticQueryTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_PERF_DIAGNOSTIC_QUERY_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanPerfDiagnosticQueryTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanPerfDiagnosticQueryTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanPerfDiagnosticQueryTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanPerfDiagnosticQueryTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanPerfDiagnosticQueryTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanPerfDiagnosticQueryTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanPerfDiagnosticQueryTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanPerfDiagnosticQueryTypeEnum> for &'a str {
    fn from(value: &'a VsanPerfDiagnosticQueryTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanPerfDiagnosticQueryTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_PERF_STATS_UNIT_TYPE_ENUM_MAP: phf::Map<&'static str, VsanPerfStatsUnitTypeEnum> = ::phf::Map {
    key: 8694567506910003252,
    disps: &[
        (1, 0),
        (4, 8),
    ],
    entries: &[
        ("time_ns", VsanPerfStatsUnitTypeEnum::TimeNs),
        ("time_us", VsanPerfStatsUnitTypeEnum::TimeUs),
        ("VsanPerfStatsUnitType_Unknown", VsanPerfStatsUnitTypeEnum::VsanPerfStatsUnitTypeUnknown),
        ("percentage", VsanPerfStatsUnitTypeEnum::Percentage),
        ("permille", VsanPerfStatsUnitTypeEnum::Permille),
        ("time_ms", VsanPerfStatsUnitTypeEnum::TimeMs),
        ("rate_bytes", VsanPerfStatsUnitTypeEnum::RateBytes),
        ("size_bytes", VsanPerfStatsUnitTypeEnum::SizeBytes),
        ("number", VsanPerfStatsUnitTypeEnum::Number),
        ("time_s", VsanPerfStatsUnitTypeEnum::TimeS),
    ],
};

impl VsanPerfStatsUnitTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanPerfStatsUnitTypeEnum::Number => "number",
            VsanPerfStatsUnitTypeEnum::TimeMs => "time_ms",
            VsanPerfStatsUnitTypeEnum::Percentage => "percentage",
            VsanPerfStatsUnitTypeEnum::SizeBytes => "size_bytes",
            VsanPerfStatsUnitTypeEnum::RateBytes => "rate_bytes",
            VsanPerfStatsUnitTypeEnum::Permille => "permille",
            VsanPerfStatsUnitTypeEnum::TimeS => "time_s",
            VsanPerfStatsUnitTypeEnum::TimeUs => "time_us",
            VsanPerfStatsUnitTypeEnum::TimeNs => "time_ns",
            VsanPerfStatsUnitTypeEnum::VsanPerfStatsUnitTypeUnknown => "VsanPerfStatsUnitType_Unknown",
            VsanPerfStatsUnitTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_PERF_STATS_UNIT_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanPerfStatsUnitTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanPerfStatsUnitTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanPerfStatsUnitTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanPerfStatsUnitTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanPerfStatsUnitTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanPerfStatsUnitTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanPerfStatsUnitTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanPerfStatsUnitTypeEnum> for &'a str {
    fn from(value: &'a VsanPerfStatsUnitTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanPerfStatsUnitTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_PERF_STATS_TYPE_ENUM_MAP: phf::Map<&'static str, VsanPerfStatsTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("delta", VsanPerfStatsTypeEnum::Delta),
        ("VsanPerfStatsType_Unknown", VsanPerfStatsTypeEnum::VsanPerfStatsTypeUnknown),
        ("absolute", VsanPerfStatsTypeEnum::Absolute),
        ("rate", VsanPerfStatsTypeEnum::Rate),
    ],
};

impl VsanPerfStatsTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanPerfStatsTypeEnum::Absolute => "absolute",
            VsanPerfStatsTypeEnum::Delta => "delta",
            VsanPerfStatsTypeEnum::Rate => "rate",
            VsanPerfStatsTypeEnum::VsanPerfStatsTypeUnknown => "VsanPerfStatsType_Unknown",
            VsanPerfStatsTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_PERF_STATS_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanPerfStatsTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanPerfStatsTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanPerfStatsTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanPerfStatsTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanPerfStatsTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanPerfStatsTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanPerfStatsTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanPerfStatsTypeEnum> for &'a str {
    fn from(value: &'a VsanPerfStatsTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanPerfStatsTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_PERF_SUMMARY_TYPE_ENUM_MAP: phf::Map<&'static str, VsanPerfSummaryTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
        (3, 3),
    ],
    entries: &[
        ("VsanPerfSummaryType_Unknown", VsanPerfSummaryTypeEnum::VsanPerfSummaryTypeUnknown),
        ("none", VsanPerfSummaryTypeEnum::None),
        ("summation", VsanPerfSummaryTypeEnum::Summation),
        ("latest", VsanPerfSummaryTypeEnum::Latest),
        ("average", VsanPerfSummaryTypeEnum::Average),
        ("minimum", VsanPerfSummaryTypeEnum::Minimum),
        ("maximum", VsanPerfSummaryTypeEnum::Maximum),
    ],
};

impl VsanPerfSummaryTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanPerfSummaryTypeEnum::Average => "average",
            VsanPerfSummaryTypeEnum::Maximum => "maximum",
            VsanPerfSummaryTypeEnum::Minimum => "minimum",
            VsanPerfSummaryTypeEnum::Latest => "latest",
            VsanPerfSummaryTypeEnum::Summation => "summation",
            VsanPerfSummaryTypeEnum::None => "none",
            VsanPerfSummaryTypeEnum::VsanPerfSummaryTypeUnknown => "VsanPerfSummaryType_Unknown",
            VsanPerfSummaryTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_PERF_SUMMARY_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanPerfSummaryTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanPerfSummaryTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanPerfSummaryTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanPerfSummaryTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanPerfSummaryTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanPerfSummaryTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanPerfSummaryTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanPerfSummaryTypeEnum> for &'a str {
    fn from(value: &'a VsanPerfSummaryTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanPerfSummaryTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_PERF_THRESHOLD_DIRECTION_TYPE_ENUM_MAP: phf::Map<&'static str, VsanPerfThresholdDirectionTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("lower", VsanPerfThresholdDirectionTypeEnum::Lower),
        ("upper", VsanPerfThresholdDirectionTypeEnum::Upper),
        ("VsanPerfThresholdDirectionType_Unknown", VsanPerfThresholdDirectionTypeEnum::VsanPerfThresholdDirectionTypeUnknown),
    ],
};

impl VsanPerfThresholdDirectionTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanPerfThresholdDirectionTypeEnum::Upper => "upper",
            VsanPerfThresholdDirectionTypeEnum::Lower => "lower",
            VsanPerfThresholdDirectionTypeEnum::VsanPerfThresholdDirectionTypeUnknown => "VsanPerfThresholdDirectionType_Unknown",
            VsanPerfThresholdDirectionTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_PERF_THRESHOLD_DIRECTION_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanPerfThresholdDirectionTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanPerfThresholdDirectionTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanPerfThresholdDirectionTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanPerfThresholdDirectionTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanPerfThresholdDirectionTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanPerfThresholdDirectionTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanPerfThresholdDirectionTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanPerfThresholdDirectionTypeEnum> for &'a str {
    fn from(value: &'a VsanPerfThresholdDirectionTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanPerfThresholdDirectionTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_RELAYOUT_OBJECTS_ERROR_CODE_ENUM_MAP: phf::Map<&'static str, VsanRelayoutObjectsErrorCodeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("generic", VsanRelayoutObjectsErrorCodeEnum::Generic),
        ("VsanRelayoutObjectsErrorCode_Unknown", VsanRelayoutObjectsErrorCodeEnum::VsanRelayoutObjectsErrorCodeUnknown),
        ("outOfResources", VsanRelayoutObjectsErrorCodeEnum::OutOfResources),
    ],
};

impl VsanRelayoutObjectsErrorCodeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanRelayoutObjectsErrorCodeEnum::OutOfResources => "outOfResources",
            VsanRelayoutObjectsErrorCodeEnum::Generic => "generic",
            VsanRelayoutObjectsErrorCodeEnum::VsanRelayoutObjectsErrorCodeUnknown => "VsanRelayoutObjectsErrorCode_Unknown",
            VsanRelayoutObjectsErrorCodeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_RELAYOUT_OBJECTS_ERROR_CODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanRelayoutObjectsErrorCodeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanRelayoutObjectsErrorCodeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanRelayoutObjectsErrorCodeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanRelayoutObjectsErrorCodeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanRelayoutObjectsErrorCodeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanRelayoutObjectsErrorCodeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanRelayoutObjectsErrorCodeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanRelayoutObjectsErrorCodeEnum> for &'a str {
    fn from(value: &'a VsanRelayoutObjectsErrorCodeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanRelayoutObjectsErrorCodeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_SPACE_REPORTING_ENTITY_TYPE_ENUM_MAP: phf::Map<&'static str, VsanSpaceReportingEntityTypeEnum> = ::phf::Map {
    key: 2126027241312876569,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("VsanSpaceReportingEntityType_Unknown", VsanSpaceReportingEntityTypeEnum::VsanSpaceReportingEntityTypeUnknown),
        ("VM", VsanSpaceReportingEntityTypeEnum::Vm),
        ("FileShare", VsanSpaceReportingEntityTypeEnum::FileShare),
        ("FaultDomain", VsanSpaceReportingEntityTypeEnum::FaultDomain),
        ("Host", VsanSpaceReportingEntityTypeEnum::Host),
    ],
};

impl VsanSpaceReportingEntityTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanSpaceReportingEntityTypeEnum::Vm => "VM",
            VsanSpaceReportingEntityTypeEnum::FileShare => "FileShare",
            VsanSpaceReportingEntityTypeEnum::Host => "Host",
            VsanSpaceReportingEntityTypeEnum::FaultDomain => "FaultDomain",
            VsanSpaceReportingEntityTypeEnum::VsanSpaceReportingEntityTypeUnknown => "VsanSpaceReportingEntityType_Unknown",
            VsanSpaceReportingEntityTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_SPACE_REPORTING_ENTITY_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanSpaceReportingEntityTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanSpaceReportingEntityTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanSpaceReportingEntityTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanSpaceReportingEntityTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanSpaceReportingEntityTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanSpaceReportingEntityTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanSpaceReportingEntityTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanSpaceReportingEntityTypeEnum> for &'a str {
    fn from(value: &'a VsanSpaceReportingEntityTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanSpaceReportingEntityTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_HEALTH_LOG_LEVEL_ENUM_ENUM_MAP: phf::Map<&'static str, VsanHealthLogLevelEnumEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
        (1, 0),
    ],
    entries: &[
        ("WARNING", VsanHealthLogLevelEnumEnum::Warning),
        ("DEBUG", VsanHealthLogLevelEnumEnum::Debug),
        ("CRITICAL", VsanHealthLogLevelEnumEnum::Critical),
        ("INFO", VsanHealthLogLevelEnumEnum::Info),
        ("VsanHealthLogLevelEnum_Unknown", VsanHealthLogLevelEnumEnum::VsanHealthLogLevelEnumUnknown),
        ("ERROR", VsanHealthLogLevelEnumEnum::Error),
    ],
};

impl VsanHealthLogLevelEnumEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanHealthLogLevelEnumEnum::Info => "INFO",
            VsanHealthLogLevelEnumEnum::Warning => "WARNING",
            VsanHealthLogLevelEnumEnum::Error => "ERROR",
            VsanHealthLogLevelEnumEnum::Debug => "DEBUG",
            VsanHealthLogLevelEnumEnum::Critical => "CRITICAL",
            VsanHealthLogLevelEnumEnum::VsanHealthLogLevelEnumUnknown => "VsanHealthLogLevelEnum_Unknown",
            VsanHealthLogLevelEnumEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_HEALTH_LOG_LEVEL_ENUM_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanHealthLogLevelEnumEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanHealthLogLevelEnumEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanHealthLogLevelEnumEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanHealthLogLevelEnumEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanHealthLogLevelEnumEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanHealthLogLevelEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanHealthLogLevelEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanHealthLogLevelEnumEnum> for &'a str {
    fn from(value: &'a VsanHealthLogLevelEnumEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanHealthLogLevelEnumEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CNS_CLUSTER_FLAVOR_ENUM_MAP: phf::Map<&'static str, CnsClusterFlavorEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("VANILLA", CnsClusterFlavorEnum::Vanilla),
        ("ClusterFlavor_Unknown", CnsClusterFlavorEnum::ClusterFlavorUnknown),
        ("GUEST_CLUSTER", CnsClusterFlavorEnum::GuestCluster),
        ("WORKLOAD", CnsClusterFlavorEnum::Workload),
    ],
};

impl CnsClusterFlavorEnum {
    pub fn as_str(&self) -> &str {
        match self {
            CnsClusterFlavorEnum::Vanilla => "VANILLA",
            CnsClusterFlavorEnum::Workload => "WORKLOAD",
            CnsClusterFlavorEnum::GuestCluster => "GUEST_CLUSTER",
            CnsClusterFlavorEnum::ClusterFlavorUnknown => "ClusterFlavor_Unknown",
            CnsClusterFlavorEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CNS_CLUSTER_FLAVOR_ENUM_MAP.get(s).cloned().unwrap_or_else(|| CnsClusterFlavorEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for CnsClusterFlavorEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for CnsClusterFlavorEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<CnsClusterFlavorEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(CnsClusterFlavorEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for CnsClusterFlavorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for CnsClusterFlavorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a CnsClusterFlavorEnum> for &'a str {
    fn from(value: &'a CnsClusterFlavorEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for CnsClusterFlavorEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CNS_CLUSTER_TYPE_ENUM_MAP: phf::Map<&'static str, CnsClusterTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("KUBERNETES", CnsClusterTypeEnum::Kubernetes),
        ("ClusterType_Unknown", CnsClusterTypeEnum::ClusterTypeUnknown),
    ],
};

impl CnsClusterTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            CnsClusterTypeEnum::Kubernetes => "KUBERNETES",
            CnsClusterTypeEnum::ClusterTypeUnknown => "ClusterType_Unknown",
            CnsClusterTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CNS_CLUSTER_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| CnsClusterTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for CnsClusterTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for CnsClusterTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<CnsClusterTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(CnsClusterTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for CnsClusterTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for CnsClusterTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a CnsClusterTypeEnum> for &'a str {
    fn from(value: &'a CnsClusterTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for CnsClusterTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CNS_KUBERNETES_ENTITY_TYPE_ENUM_MAP: phf::Map<&'static str, CnsKubernetesEntityTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("PERSISTENT_VOLUME", CnsKubernetesEntityTypeEnum::PersistentVolume),
        ("POD", CnsKubernetesEntityTypeEnum::Pod),
        ("PERSISTENT_VOLUME_CLAIM", CnsKubernetesEntityTypeEnum::PersistentVolumeClaim),
        ("KubernetesEntityType_Unknown", CnsKubernetesEntityTypeEnum::KubernetesEntityTypeUnknown),
    ],
};

impl CnsKubernetesEntityTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            CnsKubernetesEntityTypeEnum::PersistentVolume => "PERSISTENT_VOLUME",
            CnsKubernetesEntityTypeEnum::PersistentVolumeClaim => "PERSISTENT_VOLUME_CLAIM",
            CnsKubernetesEntityTypeEnum::Pod => "POD",
            CnsKubernetesEntityTypeEnum::KubernetesEntityTypeUnknown => "KubernetesEntityType_Unknown",
            CnsKubernetesEntityTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CNS_KUBERNETES_ENTITY_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| CnsKubernetesEntityTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for CnsKubernetesEntityTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for CnsKubernetesEntityTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<CnsKubernetesEntityTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(CnsKubernetesEntityTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for CnsKubernetesEntityTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for CnsKubernetesEntityTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a CnsKubernetesEntityTypeEnum> for &'a str {
    fn from(value: &'a CnsKubernetesEntityTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for CnsKubernetesEntityTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static METRIC_FORMAT_ENUM_MAP: phf::Map<&'static str, MetricFormatEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("MetricFormat_Unknown", MetricFormatEnum::MetricFormatUnknown),
        ("WAVEFRONT", MetricFormatEnum::Wavefront),
        ("PROMETHEUS", MetricFormatEnum::Prometheus),
    ],
};

impl MetricFormatEnum {
    pub fn as_str(&self) -> &str {
        match self {
            MetricFormatEnum::Prometheus => "PROMETHEUS",
            MetricFormatEnum::Wavefront => "WAVEFRONT",
            MetricFormatEnum::MetricFormatUnknown => "MetricFormat_Unknown",
            MetricFormatEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        METRIC_FORMAT_ENUM_MAP.get(s).cloned().unwrap_or_else(|| MetricFormatEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for MetricFormatEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for MetricFormatEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<MetricFormatEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(MetricFormatEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for MetricFormatEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for MetricFormatEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a MetricFormatEnum> for &'a str {
    fn from(value: &'a MetricFormatEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for MetricFormatEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static METRIC_TYPE_ENUM_MAP: phf::Map<&'static str, MetricTypeEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (7, 0),
        (1, 5),
    ],
    entries: &[
        ("SAAS_METRICS", MetricTypeEnum::SaasMetrics),
        ("MetricType_Unknown", MetricTypeEnum::MetricTypeUnknown),
        ("STORAGE_POLICY", MetricTypeEnum::StoragePolicy),
        ("CLUSTER", MetricTypeEnum::Cluster),
        ("VOLUME", MetricTypeEnum::Volume),
        ("DISTRIBUTION", MetricTypeEnum::Distribution),
        ("OP_STATS", MetricTypeEnum::OpStats),
        ("DATASTORE", MetricTypeEnum::Datastore),
    ],
};

impl MetricTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            MetricTypeEnum::Volume => "VOLUME",
            MetricTypeEnum::Datastore => "DATASTORE",
            MetricTypeEnum::Cluster => "CLUSTER",
            MetricTypeEnum::Distribution => "DISTRIBUTION",
            MetricTypeEnum::StoragePolicy => "STORAGE_POLICY",
            MetricTypeEnum::OpStats => "OP_STATS",
            MetricTypeEnum::SaasMetrics => "SAAS_METRICS",
            MetricTypeEnum::MetricTypeUnknown => "MetricType_Unknown",
            MetricTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        METRIC_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| MetricTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for MetricTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for MetricTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<MetricTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(MetricTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for MetricTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for MetricTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a MetricTypeEnum> for &'a str {
    fn from(value: &'a MetricTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for MetricTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static QUERY_SELECTION_NAME_TYPE_ENUM_MAP: phf::Map<&'static str, QuerySelectionNameTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
        (3, 3),
    ],
    entries: &[
        ("VOLUME_NAME", QuerySelectionNameTypeEnum::VolumeName),
        ("VOLUME_METADATA", QuerySelectionNameTypeEnum::VolumeMetadata),
        ("POLICY_ID", QuerySelectionNameTypeEnum::PolicyId),
        ("COMPLIANCE_STATUS", QuerySelectionNameTypeEnum::ComplianceStatus),
        ("DATASTORE_URL", QuerySelectionNameTypeEnum::DatastoreUrl),
        ("DATASTORE_ACCESSIBILITY_STATUS", QuerySelectionNameTypeEnum::DatastoreAccessibilityStatus),
        ("VOLUME_TYPE", QuerySelectionNameTypeEnum::VolumeType),
        ("HEALTH_STATUS", QuerySelectionNameTypeEnum::HealthStatus),
        ("QuerySelectionNameType_Unknown", QuerySelectionNameTypeEnum::QuerySelectionNameTypeUnknown),
        ("BACKING_OBJECT_DETAILS", QuerySelectionNameTypeEnum::BackingObjectDetails),
    ],
};

impl QuerySelectionNameTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            QuerySelectionNameTypeEnum::VolumeMetadata => "VOLUME_METADATA",
            QuerySelectionNameTypeEnum::DatastoreUrl => "DATASTORE_URL",
            QuerySelectionNameTypeEnum::PolicyId => "POLICY_ID",
            QuerySelectionNameTypeEnum::VolumeType => "VOLUME_TYPE",
            QuerySelectionNameTypeEnum::VolumeName => "VOLUME_NAME",
            QuerySelectionNameTypeEnum::BackingObjectDetails => "BACKING_OBJECT_DETAILS",
            QuerySelectionNameTypeEnum::ComplianceStatus => "COMPLIANCE_STATUS",
            QuerySelectionNameTypeEnum::DatastoreAccessibilityStatus => "DATASTORE_ACCESSIBILITY_STATUS",
            QuerySelectionNameTypeEnum::HealthStatus => "HEALTH_STATUS",
            QuerySelectionNameTypeEnum::QuerySelectionNameTypeUnknown => "QuerySelectionNameType_Unknown",
            QuerySelectionNameTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        QUERY_SELECTION_NAME_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| QuerySelectionNameTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for QuerySelectionNameTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for QuerySelectionNameTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<QuerySelectionNameTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(QuerySelectionNameTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for QuerySelectionNameTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for QuerySelectionNameTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a QuerySelectionNameTypeEnum> for &'a str {
    fn from(value: &'a QuerySelectionNameTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for QuerySelectionNameTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CNS_VOLUME_TYPE_ENUM_MAP: phf::Map<&'static str, CnsVolumeTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("VolumeType_Unknown", CnsVolumeTypeEnum::VolumeTypeUnknown),
        ("BLOCK", CnsVolumeTypeEnum::Block),
        ("FILE", CnsVolumeTypeEnum::File),
    ],
};

impl CnsVolumeTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            CnsVolumeTypeEnum::Block => "BLOCK",
            CnsVolumeTypeEnum::File => "FILE",
            CnsVolumeTypeEnum::VolumeTypeUnknown => "VolumeType_Unknown",
            CnsVolumeTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CNS_VOLUME_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| CnsVolumeTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for CnsVolumeTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for CnsVolumeTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<CnsVolumeTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(CnsVolumeTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for CnsVolumeTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for CnsVolumeTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a CnsVolumeTypeEnum> for &'a str {
    fn from(value: &'a CnsVolumeTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for CnsVolumeTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DVS_FILTER_ON_FAILURE_ENUM_MAP: phf::Map<&'static str, DvsFilterOnFailureEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("failOpen", DvsFilterOnFailureEnum::FailOpen),
        ("failClosed", DvsFilterOnFailureEnum::FailClosed),
    ],
};

impl DvsFilterOnFailureEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DvsFilterOnFailureEnum::FailOpen => "failOpen",
            DvsFilterOnFailureEnum::FailClosed => "failClosed",
            DvsFilterOnFailureEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DVS_FILTER_ON_FAILURE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DvsFilterOnFailureEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DvsFilterOnFailureEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DvsFilterOnFailureEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DvsFilterOnFailureEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DvsFilterOnFailureEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DvsFilterOnFailureEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DvsFilterOnFailureEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DvsFilterOnFailureEnum> for &'a str {
    fn from(value: &'a DvsFilterOnFailureEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DvsFilterOnFailureEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DV_PORT_STATUS_VM_DIRECT_PATH_GEN_2_INACTIVE_REASON_NETWORK_ENUM_MAP: phf::Map<&'static str, DvPortStatusVmDirectPathGen2InactiveReasonNetworkEnum> = ::phf::Map {
    key: 2126027241312876569,
    disps: &[
        (3, 0),
    ],
    entries: &[
        ("portNptNoCompatibleNics", DvPortStatusVmDirectPathGen2InactiveReasonNetworkEnum::PortNptNoCompatibleNics),
        ("portNptIncompatibleDvs", DvPortStatusVmDirectPathGen2InactiveReasonNetworkEnum::PortNptIncompatibleDvs),
        ("portNptDisabledForPort", DvPortStatusVmDirectPathGen2InactiveReasonNetworkEnum::PortNptDisabledForPort),
        ("portNptNoVirtualFunctionsAvailable", DvPortStatusVmDirectPathGen2InactiveReasonNetworkEnum::PortNptNoVirtualFunctionsAvailable),
    ],
};

impl DvPortStatusVmDirectPathGen2InactiveReasonNetworkEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DvPortStatusVmDirectPathGen2InactiveReasonNetworkEnum::PortNptIncompatibleDvs => "portNptIncompatibleDvs",
            DvPortStatusVmDirectPathGen2InactiveReasonNetworkEnum::PortNptNoCompatibleNics => "portNptNoCompatibleNics",
            DvPortStatusVmDirectPathGen2InactiveReasonNetworkEnum::PortNptNoVirtualFunctionsAvailable => "portNptNoVirtualFunctionsAvailable",
            DvPortStatusVmDirectPathGen2InactiveReasonNetworkEnum::PortNptDisabledForPort => "portNptDisabledForPort",
            DvPortStatusVmDirectPathGen2InactiveReasonNetworkEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DV_PORT_STATUS_VM_DIRECT_PATH_GEN_2_INACTIVE_REASON_NETWORK_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DvPortStatusVmDirectPathGen2InactiveReasonNetworkEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DvPortStatusVmDirectPathGen2InactiveReasonNetworkEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DvPortStatusVmDirectPathGen2InactiveReasonNetworkEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DvPortStatusVmDirectPathGen2InactiveReasonNetworkEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DvPortStatusVmDirectPathGen2InactiveReasonNetworkEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DvPortStatusVmDirectPathGen2InactiveReasonNetworkEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DvPortStatusVmDirectPathGen2InactiveReasonNetworkEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DvPortStatusVmDirectPathGen2InactiveReasonNetworkEnum> for &'a str {
    fn from(value: &'a DvPortStatusVmDirectPathGen2InactiveReasonNetworkEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DvPortStatusVmDirectPathGen2InactiveReasonNetworkEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DV_PORT_STATUS_VM_DIRECT_PATH_GEN_2_INACTIVE_REASON_OTHER_ENUM_MAP: phf::Map<&'static str, DvPortStatusVmDirectPathGen2InactiveReasonOtherEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("portNptIncompatibleHost", DvPortStatusVmDirectPathGen2InactiveReasonOtherEnum::PortNptIncompatibleHost),
        ("portNptIncompatibleConnectee", DvPortStatusVmDirectPathGen2InactiveReasonOtherEnum::PortNptIncompatibleConnectee),
    ],
};

impl DvPortStatusVmDirectPathGen2InactiveReasonOtherEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DvPortStatusVmDirectPathGen2InactiveReasonOtherEnum::PortNptIncompatibleHost => "portNptIncompatibleHost",
            DvPortStatusVmDirectPathGen2InactiveReasonOtherEnum::PortNptIncompatibleConnectee => "portNptIncompatibleConnectee",
            DvPortStatusVmDirectPathGen2InactiveReasonOtherEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DV_PORT_STATUS_VM_DIRECT_PATH_GEN_2_INACTIVE_REASON_OTHER_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DvPortStatusVmDirectPathGen2InactiveReasonOtherEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DvPortStatusVmDirectPathGen2InactiveReasonOtherEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DvPortStatusVmDirectPathGen2InactiveReasonOtherEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DvPortStatusVmDirectPathGen2InactiveReasonOtherEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DvPortStatusVmDirectPathGen2InactiveReasonOtherEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DvPortStatusVmDirectPathGen2InactiveReasonOtherEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DvPortStatusVmDirectPathGen2InactiveReasonOtherEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DvPortStatusVmDirectPathGen2InactiveReasonOtherEnum> for &'a str {
    fn from(value: &'a DvPortStatusVmDirectPathGen2InactiveReasonOtherEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DvPortStatusVmDirectPathGen2InactiveReasonOtherEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DISTRIBUTED_VIRTUAL_PORTGROUP_BACKING_TYPE_ENUM_MAP: phf::Map<&'static str, DistributedVirtualPortgroupBackingTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("nsx", DistributedVirtualPortgroupBackingTypeEnum::Nsx),
        ("standard", DistributedVirtualPortgroupBackingTypeEnum::Standard),
    ],
};

impl DistributedVirtualPortgroupBackingTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DistributedVirtualPortgroupBackingTypeEnum::Standard => "standard",
            DistributedVirtualPortgroupBackingTypeEnum::Nsx => "nsx",
            DistributedVirtualPortgroupBackingTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DISTRIBUTED_VIRTUAL_PORTGROUP_BACKING_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DistributedVirtualPortgroupBackingTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DistributedVirtualPortgroupBackingTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DistributedVirtualPortgroupBackingTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DistributedVirtualPortgroupBackingTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DistributedVirtualPortgroupBackingTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DistributedVirtualPortgroupBackingTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DistributedVirtualPortgroupBackingTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DistributedVirtualPortgroupBackingTypeEnum> for &'a str {
    fn from(value: &'a DistributedVirtualPortgroupBackingTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DistributedVirtualPortgroupBackingTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DISTRIBUTED_VIRTUAL_PORTGROUP_META_TAG_NAME_ENUM_MAP: phf::Map<&'static str, DistributedVirtualPortgroupMetaTagNameEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("dvsName", DistributedVirtualPortgroupMetaTagNameEnum::DvsName),
        ("portIndex", DistributedVirtualPortgroupMetaTagNameEnum::PortIndex),
        ("portgroupName", DistributedVirtualPortgroupMetaTagNameEnum::PortgroupName),
    ],
};

impl DistributedVirtualPortgroupMetaTagNameEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DistributedVirtualPortgroupMetaTagNameEnum::DvsName => "dvsName",
            DistributedVirtualPortgroupMetaTagNameEnum::PortgroupName => "portgroupName",
            DistributedVirtualPortgroupMetaTagNameEnum::PortIndex => "portIndex",
            DistributedVirtualPortgroupMetaTagNameEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DISTRIBUTED_VIRTUAL_PORTGROUP_META_TAG_NAME_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DistributedVirtualPortgroupMetaTagNameEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DistributedVirtualPortgroupMetaTagNameEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DistributedVirtualPortgroupMetaTagNameEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DistributedVirtualPortgroupMetaTagNameEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DistributedVirtualPortgroupMetaTagNameEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DistributedVirtualPortgroupMetaTagNameEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DistributedVirtualPortgroupMetaTagNameEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DistributedVirtualPortgroupMetaTagNameEnum> for &'a str {
    fn from(value: &'a DistributedVirtualPortgroupMetaTagNameEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DistributedVirtualPortgroupMetaTagNameEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DISTRIBUTED_VIRTUAL_PORTGROUP_PORTGROUP_TYPE_ENUM_MAP: phf::Map<&'static str, DistributedVirtualPortgroupPortgroupTypeEnum> = ::phf::Map {
    key: 8694567506910003252,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("ephemeral", DistributedVirtualPortgroupPortgroupTypeEnum::Ephemeral),
        ("earlyBinding", DistributedVirtualPortgroupPortgroupTypeEnum::EarlyBinding),
        ("lateBinding", DistributedVirtualPortgroupPortgroupTypeEnum::LateBinding),
    ],
};

impl DistributedVirtualPortgroupPortgroupTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DistributedVirtualPortgroupPortgroupTypeEnum::EarlyBinding => "earlyBinding",
            DistributedVirtualPortgroupPortgroupTypeEnum::LateBinding => "lateBinding",
            DistributedVirtualPortgroupPortgroupTypeEnum::Ephemeral => "ephemeral",
            DistributedVirtualPortgroupPortgroupTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DISTRIBUTED_VIRTUAL_PORTGROUP_PORTGROUP_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DistributedVirtualPortgroupPortgroupTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DistributedVirtualPortgroupPortgroupTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DistributedVirtualPortgroupPortgroupTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DistributedVirtualPortgroupPortgroupTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DistributedVirtualPortgroupPortgroupTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DistributedVirtualPortgroupPortgroupTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DistributedVirtualPortgroupPortgroupTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DistributedVirtualPortgroupPortgroupTypeEnum> for &'a str {
    fn from(value: &'a DistributedVirtualPortgroupPortgroupTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DistributedVirtualPortgroupPortgroupTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static ENTITY_TYPE_ENUM_MAP: phf::Map<&'static str, EntityTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("distributedVirtualSwitch", EntityTypeEnum::DistributedVirtualSwitch),
        ("distributedVirtualPortgroup", EntityTypeEnum::DistributedVirtualPortgroup),
    ],
};

impl EntityTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            EntityTypeEnum::DistributedVirtualSwitch => "distributedVirtualSwitch",
            EntityTypeEnum::DistributedVirtualPortgroup => "distributedVirtualPortgroup",
            EntityTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        ENTITY_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| EntityTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for EntityTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for EntityTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<EntityTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(EntityTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for EntityTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for EntityTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a EntityTypeEnum> for &'a str {
    fn from(value: &'a EntityTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for EntityTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static ENTITY_IMPORT_TYPE_ENUM_MAP: phf::Map<&'static str, EntityImportTypeEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("createEntityWithOriginalIdentifier", EntityImportTypeEnum::CreateEntityWithOriginalIdentifier),
        ("applyToEntitySpecified", EntityImportTypeEnum::ApplyToEntitySpecified),
        ("createEntityWithNewIdentifier", EntityImportTypeEnum::CreateEntityWithNewIdentifier),
    ],
};

impl EntityImportTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            EntityImportTypeEnum::CreateEntityWithNewIdentifier => "createEntityWithNewIdentifier",
            EntityImportTypeEnum::CreateEntityWithOriginalIdentifier => "createEntityWithOriginalIdentifier",
            EntityImportTypeEnum::ApplyToEntitySpecified => "applyToEntitySpecified",
            EntityImportTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        ENTITY_IMPORT_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| EntityImportTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for EntityImportTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for EntityImportTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<EntityImportTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(EntityImportTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for EntityImportTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for EntityImportTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a EntityImportTypeEnum> for &'a str {
    fn from(value: &'a EntityImportTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for EntityImportTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DVS_FILTER_SPEC_LINK_CONFIG_ENUM_MAP: phf::Map<&'static str, DvsFilterSpecLinkConfigEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("unblocked", DvsFilterSpecLinkConfigEnum::Unblocked),
        ("blocked", DvsFilterSpecLinkConfigEnum::Blocked),
    ],
};

impl DvsFilterSpecLinkConfigEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DvsFilterSpecLinkConfigEnum::Blocked => "blocked",
            DvsFilterSpecLinkConfigEnum::Unblocked => "unblocked",
            DvsFilterSpecLinkConfigEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DVS_FILTER_SPEC_LINK_CONFIG_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DvsFilterSpecLinkConfigEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DvsFilterSpecLinkConfigEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DvsFilterSpecLinkConfigEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DvsFilterSpecLinkConfigEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DvsFilterSpecLinkConfigEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DvsFilterSpecLinkConfigEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DvsFilterSpecLinkConfigEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DvsFilterSpecLinkConfigEnum> for &'a str {
    fn from(value: &'a DvsFilterSpecLinkConfigEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DvsFilterSpecLinkConfigEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DVS_FILTER_SPEC_LINK_STATE_ENUM_MAP: phf::Map<&'static str, DvsFilterSpecLinkStateEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("up", DvsFilterSpecLinkStateEnum::Up),
        ("down", DvsFilterSpecLinkStateEnum::Down),
    ],
};

impl DvsFilterSpecLinkStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DvsFilterSpecLinkStateEnum::Down => "down",
            DvsFilterSpecLinkStateEnum::Up => "up",
            DvsFilterSpecLinkStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DVS_FILTER_SPEC_LINK_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DvsFilterSpecLinkStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DvsFilterSpecLinkStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DvsFilterSpecLinkStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DvsFilterSpecLinkStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DvsFilterSpecLinkStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DvsFilterSpecLinkStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DvsFilterSpecLinkStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DvsFilterSpecLinkStateEnum> for &'a str {
    fn from(value: &'a DvsFilterSpecLinkStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DvsFilterSpecLinkStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_DVS_CONFIG_SPEC_SWITCH_MODE_ENUM_MAP: phf::Map<&'static str, HostDvsConfigSpecSwitchModeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("normal", HostDvsConfigSpecSwitchModeEnum::Normal),
        ("mux", HostDvsConfigSpecSwitchModeEnum::Mux),
    ],
};

impl HostDvsConfigSpecSwitchModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostDvsConfigSpecSwitchModeEnum::Normal => "normal",
            HostDvsConfigSpecSwitchModeEnum::Mux => "mux",
            HostDvsConfigSpecSwitchModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_DVS_CONFIG_SPEC_SWITCH_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostDvsConfigSpecSwitchModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostDvsConfigSpecSwitchModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostDvsConfigSpecSwitchModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostDvsConfigSpecSwitchModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostDvsConfigSpecSwitchModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostDvsConfigSpecSwitchModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostDvsConfigSpecSwitchModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostDvsConfigSpecSwitchModeEnum> for &'a str {
    fn from(value: &'a HostDvsConfigSpecSwitchModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostDvsConfigSpecSwitchModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_DISTRIBUTED_VIRTUAL_SWITCH_MANAGER_FAILOVER_REASON_ENUM_MAP: phf::Map<&'static str, HostDistributedVirtualSwitchManagerFailoverReasonEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("userInitiated", HostDistributedVirtualSwitchManagerFailoverReasonEnum::UserInitiated),
        ("crash", HostDistributedVirtualSwitchManagerFailoverReasonEnum::Crash),
        ("linkDown", HostDistributedVirtualSwitchManagerFailoverReasonEnum::LinkDown),
    ],
};

impl HostDistributedVirtualSwitchManagerFailoverReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostDistributedVirtualSwitchManagerFailoverReasonEnum::Crash => "crash",
            HostDistributedVirtualSwitchManagerFailoverReasonEnum::LinkDown => "linkDown",
            HostDistributedVirtualSwitchManagerFailoverReasonEnum::UserInitiated => "userInitiated",
            HostDistributedVirtualSwitchManagerFailoverReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_DISTRIBUTED_VIRTUAL_SWITCH_MANAGER_FAILOVER_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostDistributedVirtualSwitchManagerFailoverReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostDistributedVirtualSwitchManagerFailoverReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostDistributedVirtualSwitchManagerFailoverReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostDistributedVirtualSwitchManagerFailoverReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostDistributedVirtualSwitchManagerFailoverReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostDistributedVirtualSwitchManagerFailoverReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostDistributedVirtualSwitchManagerFailoverReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostDistributedVirtualSwitchManagerFailoverReasonEnum> for &'a str {
    fn from(value: &'a HostDistributedVirtualSwitchManagerFailoverReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostDistributedVirtualSwitchManagerFailoverReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_DISTRIBUTED_VIRTUAL_SWITCH_MANAGER_FAILOVER_STAGE_ENUM_MAP: phf::Map<&'static str, HostDistributedVirtualSwitchManagerFailoverStageEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("STAGE_1", HostDistributedVirtualSwitchManagerFailoverStageEnum::Stage1),
    ],
};

impl HostDistributedVirtualSwitchManagerFailoverStageEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostDistributedVirtualSwitchManagerFailoverStageEnum::Stage1 => "STAGE_1",
            HostDistributedVirtualSwitchManagerFailoverStageEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_DISTRIBUTED_VIRTUAL_SWITCH_MANAGER_FAILOVER_STAGE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostDistributedVirtualSwitchManagerFailoverStageEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostDistributedVirtualSwitchManagerFailoverStageEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostDistributedVirtualSwitchManagerFailoverStageEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostDistributedVirtualSwitchManagerFailoverStageEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostDistributedVirtualSwitchManagerFailoverStageEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostDistributedVirtualSwitchManagerFailoverStageEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostDistributedVirtualSwitchManagerFailoverStageEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostDistributedVirtualSwitchManagerFailoverStageEnum> for &'a str {
    fn from(value: &'a HostDistributedVirtualSwitchManagerFailoverStageEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostDistributedVirtualSwitchManagerFailoverStageEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DISTRIBUTED_VIRTUAL_SWITCH_HOST_MEMBER_HOST_COMPONENT_STATE_ENUM_MAP: phf::Map<&'static str, DistributedVirtualSwitchHostMemberHostComponentStateEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
        (2, 0),
    ],
    entries: &[
        ("pending", DistributedVirtualSwitchHostMemberHostComponentStateEnum::Pending),
        ("up", DistributedVirtualSwitchHostMemberHostComponentStateEnum::Up),
        ("warning", DistributedVirtualSwitchHostMemberHostComponentStateEnum::Warning),
        ("down", DistributedVirtualSwitchHostMemberHostComponentStateEnum::Down),
        ("outOfSync", DistributedVirtualSwitchHostMemberHostComponentStateEnum::OutOfSync),
        ("disconnected", DistributedVirtualSwitchHostMemberHostComponentStateEnum::Disconnected),
    ],
};

impl DistributedVirtualSwitchHostMemberHostComponentStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DistributedVirtualSwitchHostMemberHostComponentStateEnum::Up => "up",
            DistributedVirtualSwitchHostMemberHostComponentStateEnum::Pending => "pending",
            DistributedVirtualSwitchHostMemberHostComponentStateEnum::OutOfSync => "outOfSync",
            DistributedVirtualSwitchHostMemberHostComponentStateEnum::Warning => "warning",
            DistributedVirtualSwitchHostMemberHostComponentStateEnum::Disconnected => "disconnected",
            DistributedVirtualSwitchHostMemberHostComponentStateEnum::Down => "down",
            DistributedVirtualSwitchHostMemberHostComponentStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DISTRIBUTED_VIRTUAL_SWITCH_HOST_MEMBER_HOST_COMPONENT_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DistributedVirtualSwitchHostMemberHostComponentStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DistributedVirtualSwitchHostMemberHostComponentStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DistributedVirtualSwitchHostMemberHostComponentStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DistributedVirtualSwitchHostMemberHostComponentStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DistributedVirtualSwitchHostMemberHostComponentStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DistributedVirtualSwitchHostMemberHostComponentStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DistributedVirtualSwitchHostMemberHostComponentStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DistributedVirtualSwitchHostMemberHostComponentStateEnum> for &'a str {
    fn from(value: &'a DistributedVirtualSwitchHostMemberHostComponentStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DistributedVirtualSwitchHostMemberHostComponentStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DISTRIBUTED_VIRTUAL_SWITCH_HOST_MEMBER_HOST_UPLINK_STATE_STATE_ENUM_MAP: phf::Map<&'static str, DistributedVirtualSwitchHostMemberHostUplinkStateStateEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("standby", DistributedVirtualSwitchHostMemberHostUplinkStateStateEnum::Standby),
        ("active", DistributedVirtualSwitchHostMemberHostUplinkStateStateEnum::Active),
    ],
};

impl DistributedVirtualSwitchHostMemberHostUplinkStateStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DistributedVirtualSwitchHostMemberHostUplinkStateStateEnum::Active => "active",
            DistributedVirtualSwitchHostMemberHostUplinkStateStateEnum::Standby => "standby",
            DistributedVirtualSwitchHostMemberHostUplinkStateStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DISTRIBUTED_VIRTUAL_SWITCH_HOST_MEMBER_HOST_UPLINK_STATE_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DistributedVirtualSwitchHostMemberHostUplinkStateStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DistributedVirtualSwitchHostMemberHostUplinkStateStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DistributedVirtualSwitchHostMemberHostUplinkStateStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DistributedVirtualSwitchHostMemberHostUplinkStateStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DistributedVirtualSwitchHostMemberHostUplinkStateStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DistributedVirtualSwitchHostMemberHostUplinkStateStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DistributedVirtualSwitchHostMemberHostUplinkStateStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DistributedVirtualSwitchHostMemberHostUplinkStateStateEnum> for &'a str {
    fn from(value: &'a DistributedVirtualSwitchHostMemberHostUplinkStateStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DistributedVirtualSwitchHostMemberHostUplinkStateStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DISTRIBUTED_VIRTUAL_SWITCH_HOST_MEMBER_TRANSPORT_ZONE_TYPE_ENUM_MAP: phf::Map<&'static str, DistributedVirtualSwitchHostMemberTransportZoneTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("vlan", DistributedVirtualSwitchHostMemberTransportZoneTypeEnum::Vlan),
        ("overlay", DistributedVirtualSwitchHostMemberTransportZoneTypeEnum::Overlay),
    ],
};

impl DistributedVirtualSwitchHostMemberTransportZoneTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DistributedVirtualSwitchHostMemberTransportZoneTypeEnum::Vlan => "vlan",
            DistributedVirtualSwitchHostMemberTransportZoneTypeEnum::Overlay => "overlay",
            DistributedVirtualSwitchHostMemberTransportZoneTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DISTRIBUTED_VIRTUAL_SWITCH_HOST_MEMBER_TRANSPORT_ZONE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DistributedVirtualSwitchHostMemberTransportZoneTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DistributedVirtualSwitchHostMemberTransportZoneTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DistributedVirtualSwitchHostMemberTransportZoneTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DistributedVirtualSwitchHostMemberTransportZoneTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DistributedVirtualSwitchHostMemberTransportZoneTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DistributedVirtualSwitchHostMemberTransportZoneTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DistributedVirtualSwitchHostMemberTransportZoneTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DistributedVirtualSwitchHostMemberTransportZoneTypeEnum> for &'a str {
    fn from(value: &'a DistributedVirtualSwitchHostMemberTransportZoneTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DistributedVirtualSwitchHostMemberTransportZoneTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DISTRIBUTED_VIRTUAL_SWITCH_PORT_CONNECTEE_CONNECTEE_TYPE_ENUM_MAP: phf::Map<&'static str, DistributedVirtualSwitchPortConnecteeConnecteeTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("pnic", DistributedVirtualSwitchPortConnecteeConnecteeTypeEnum::Pnic),
        ("systemCrxVnic", DistributedVirtualSwitchPortConnecteeConnecteeTypeEnum::SystemCrxVnic),
        ("vmVnic", DistributedVirtualSwitchPortConnecteeConnecteeTypeEnum::VmVnic),
        ("hostVmkVnic", DistributedVirtualSwitchPortConnecteeConnecteeTypeEnum::HostVmkVnic),
        ("hostConsoleVnic", DistributedVirtualSwitchPortConnecteeConnecteeTypeEnum::HostConsoleVnic),
    ],
};

impl DistributedVirtualSwitchPortConnecteeConnecteeTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DistributedVirtualSwitchPortConnecteeConnecteeTypeEnum::Pnic => "pnic",
            DistributedVirtualSwitchPortConnecteeConnecteeTypeEnum::VmVnic => "vmVnic",
            DistributedVirtualSwitchPortConnecteeConnecteeTypeEnum::HostConsoleVnic => "hostConsoleVnic",
            DistributedVirtualSwitchPortConnecteeConnecteeTypeEnum::HostVmkVnic => "hostVmkVnic",
            DistributedVirtualSwitchPortConnecteeConnecteeTypeEnum::SystemCrxVnic => "systemCrxVnic",
            DistributedVirtualSwitchPortConnecteeConnecteeTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DISTRIBUTED_VIRTUAL_SWITCH_PORT_CONNECTEE_CONNECTEE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DistributedVirtualSwitchPortConnecteeConnecteeTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DistributedVirtualSwitchPortConnecteeConnecteeTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DistributedVirtualSwitchPortConnecteeConnecteeTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DistributedVirtualSwitchPortConnecteeConnecteeTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DistributedVirtualSwitchPortConnecteeConnecteeTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DistributedVirtualSwitchPortConnecteeConnecteeTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DistributedVirtualSwitchPortConnecteeConnecteeTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DistributedVirtualSwitchPortConnecteeConnecteeTypeEnum> for &'a str {
    fn from(value: &'a DistributedVirtualSwitchPortConnecteeConnecteeTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DistributedVirtualSwitchPortConnecteeConnecteeTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DVS_NETWORK_RULE_DIRECTION_TYPE_ENUM_MAP: phf::Map<&'static str, DvsNetworkRuleDirectionTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("outgoingPackets", DvsNetworkRuleDirectionTypeEnum::OutgoingPackets),
        ("both", DvsNetworkRuleDirectionTypeEnum::Both),
        ("incomingPackets", DvsNetworkRuleDirectionTypeEnum::IncomingPackets),
    ],
};

impl DvsNetworkRuleDirectionTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DvsNetworkRuleDirectionTypeEnum::IncomingPackets => "incomingPackets",
            DvsNetworkRuleDirectionTypeEnum::OutgoingPackets => "outgoingPackets",
            DvsNetworkRuleDirectionTypeEnum::Both => "both",
            DvsNetworkRuleDirectionTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DVS_NETWORK_RULE_DIRECTION_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DvsNetworkRuleDirectionTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DvsNetworkRuleDirectionTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DvsNetworkRuleDirectionTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DvsNetworkRuleDirectionTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DvsNetworkRuleDirectionTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DvsNetworkRuleDirectionTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DvsNetworkRuleDirectionTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DvsNetworkRuleDirectionTypeEnum> for &'a str {
    fn from(value: &'a DvsNetworkRuleDirectionTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DvsNetworkRuleDirectionTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static V_MWARE_DVS_LACP_API_VERSION_ENUM_MAP: phf::Map<&'static str, VMwareDvsLacpApiVersionEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("multipleLag", VMwareDvsLacpApiVersionEnum::MultipleLag),
        ("singleLag", VMwareDvsLacpApiVersionEnum::SingleLag),
    ],
};

impl VMwareDvsLacpApiVersionEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VMwareDvsLacpApiVersionEnum::SingleLag => "singleLag",
            VMwareDvsLacpApiVersionEnum::MultipleLag => "multipleLag",
            VMwareDvsLacpApiVersionEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        V_MWARE_DVS_LACP_API_VERSION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VMwareDvsLacpApiVersionEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VMwareDvsLacpApiVersionEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VMwareDvsLacpApiVersionEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VMwareDvsLacpApiVersionEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VMwareDvsLacpApiVersionEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VMwareDvsLacpApiVersionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VMwareDvsLacpApiVersionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VMwareDvsLacpApiVersionEnum> for &'a str {
    fn from(value: &'a VMwareDvsLacpApiVersionEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VMwareDvsLacpApiVersionEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static V_MWARE_DVS_LACP_LOAD_BALANCE_ALGORITHM_ENUM_MAP: phf::Map<&'static str, VMwareDvsLacpLoadBalanceAlgorithmEnum> = ::phf::Map {
    key: 106375038446233661,
    disps: &[
        (0, 8),
        (5, 2),
        (2, 0),
        (0, 11),
    ],
    entries: &[
        ("destIpVlan", VMwareDvsLacpLoadBalanceAlgorithmEnum::DestIpVlan),
        ("destTcpUdpPort", VMwareDvsLacpLoadBalanceAlgorithmEnum::DestTcpUdpPort),
        ("srcIpVlan", VMwareDvsLacpLoadBalanceAlgorithmEnum::SrcIpVlan),
        ("srcDestIpTcpUdpPortVlan", VMwareDvsLacpLoadBalanceAlgorithmEnum::SrcDestIpTcpUdpPortVlan),
        ("srcPortId", VMwareDvsLacpLoadBalanceAlgorithmEnum::SrcPortId),
        ("srcIpTcpUdpPort", VMwareDvsLacpLoadBalanceAlgorithmEnum::SrcIpTcpUdpPort),
        ("srcDestIpTcpUdpPort", VMwareDvsLacpLoadBalanceAlgorithmEnum::SrcDestIpTcpUdpPort),
        ("vlan", VMwareDvsLacpLoadBalanceAlgorithmEnum::Vlan),
        ("srcMac", VMwareDvsLacpLoadBalanceAlgorithmEnum::SrcMac),
        ("srcDestMac", VMwareDvsLacpLoadBalanceAlgorithmEnum::SrcDestMac),
        ("srcIp", VMwareDvsLacpLoadBalanceAlgorithmEnum::SrcIp),
        ("destIp", VMwareDvsLacpLoadBalanceAlgorithmEnum::DestIp),
        ("srcTcpUdpPort", VMwareDvsLacpLoadBalanceAlgorithmEnum::SrcTcpUdpPort),
        ("srcDestIp", VMwareDvsLacpLoadBalanceAlgorithmEnum::SrcDestIp),
        ("destIpTcpUdpPort", VMwareDvsLacpLoadBalanceAlgorithmEnum::DestIpTcpUdpPort),
        ("srcDestTcpUdpPort", VMwareDvsLacpLoadBalanceAlgorithmEnum::SrcDestTcpUdpPort),
        ("destIpTcpUdpPortVlan", VMwareDvsLacpLoadBalanceAlgorithmEnum::DestIpTcpUdpPortVlan),
        ("srcIpTcpUdpPortVlan", VMwareDvsLacpLoadBalanceAlgorithmEnum::SrcIpTcpUdpPortVlan),
        ("destMac", VMwareDvsLacpLoadBalanceAlgorithmEnum::DestMac),
        ("srcDestIpVlan", VMwareDvsLacpLoadBalanceAlgorithmEnum::SrcDestIpVlan),
    ],
};

impl VMwareDvsLacpLoadBalanceAlgorithmEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VMwareDvsLacpLoadBalanceAlgorithmEnum::SrcMac => "srcMac",
            VMwareDvsLacpLoadBalanceAlgorithmEnum::DestMac => "destMac",
            VMwareDvsLacpLoadBalanceAlgorithmEnum::SrcDestMac => "srcDestMac",
            VMwareDvsLacpLoadBalanceAlgorithmEnum::DestIpVlan => "destIpVlan",
            VMwareDvsLacpLoadBalanceAlgorithmEnum::SrcIpVlan => "srcIpVlan",
            VMwareDvsLacpLoadBalanceAlgorithmEnum::SrcDestIpVlan => "srcDestIpVlan",
            VMwareDvsLacpLoadBalanceAlgorithmEnum::DestTcpUdpPort => "destTcpUdpPort",
            VMwareDvsLacpLoadBalanceAlgorithmEnum::SrcTcpUdpPort => "srcTcpUdpPort",
            VMwareDvsLacpLoadBalanceAlgorithmEnum::SrcDestTcpUdpPort => "srcDestTcpUdpPort",
            VMwareDvsLacpLoadBalanceAlgorithmEnum::DestIpTcpUdpPort => "destIpTcpUdpPort",
            VMwareDvsLacpLoadBalanceAlgorithmEnum::SrcIpTcpUdpPort => "srcIpTcpUdpPort",
            VMwareDvsLacpLoadBalanceAlgorithmEnum::SrcDestIpTcpUdpPort => "srcDestIpTcpUdpPort",
            VMwareDvsLacpLoadBalanceAlgorithmEnum::DestIpTcpUdpPortVlan => "destIpTcpUdpPortVlan",
            VMwareDvsLacpLoadBalanceAlgorithmEnum::SrcIpTcpUdpPortVlan => "srcIpTcpUdpPortVlan",
            VMwareDvsLacpLoadBalanceAlgorithmEnum::SrcDestIpTcpUdpPortVlan => "srcDestIpTcpUdpPortVlan",
            VMwareDvsLacpLoadBalanceAlgorithmEnum::DestIp => "destIp",
            VMwareDvsLacpLoadBalanceAlgorithmEnum::SrcIp => "srcIp",
            VMwareDvsLacpLoadBalanceAlgorithmEnum::SrcDestIp => "srcDestIp",
            VMwareDvsLacpLoadBalanceAlgorithmEnum::Vlan => "vlan",
            VMwareDvsLacpLoadBalanceAlgorithmEnum::SrcPortId => "srcPortId",
            VMwareDvsLacpLoadBalanceAlgorithmEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        V_MWARE_DVS_LACP_LOAD_BALANCE_ALGORITHM_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VMwareDvsLacpLoadBalanceAlgorithmEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VMwareDvsLacpLoadBalanceAlgorithmEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VMwareDvsLacpLoadBalanceAlgorithmEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VMwareDvsLacpLoadBalanceAlgorithmEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VMwareDvsLacpLoadBalanceAlgorithmEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VMwareDvsLacpLoadBalanceAlgorithmEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VMwareDvsLacpLoadBalanceAlgorithmEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VMwareDvsLacpLoadBalanceAlgorithmEnum> for &'a str {
    fn from(value: &'a VMwareDvsLacpLoadBalanceAlgorithmEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VMwareDvsLacpLoadBalanceAlgorithmEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DVS_MAC_LIMIT_POLICY_TYPE_ENUM_MAP: phf::Map<&'static str, DvsMacLimitPolicyTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("allow", DvsMacLimitPolicyTypeEnum::Allow),
        ("drop", DvsMacLimitPolicyTypeEnum::Drop),
    ],
};

impl DvsMacLimitPolicyTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DvsMacLimitPolicyTypeEnum::Allow => "allow",
            DvsMacLimitPolicyTypeEnum::Drop => "drop",
            DvsMacLimitPolicyTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DVS_MAC_LIMIT_POLICY_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DvsMacLimitPolicyTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DvsMacLimitPolicyTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DvsMacLimitPolicyTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DvsMacLimitPolicyTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DvsMacLimitPolicyTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DvsMacLimitPolicyTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DvsMacLimitPolicyTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DvsMacLimitPolicyTypeEnum> for &'a str {
    fn from(value: &'a DvsMacLimitPolicyTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DvsMacLimitPolicyTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static V_MWARE_DVS_MULTICAST_FILTERING_MODE_ENUM_MAP: phf::Map<&'static str, VMwareDvsMulticastFilteringModeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("legacyFiltering", VMwareDvsMulticastFilteringModeEnum::LegacyFiltering),
        ("snooping", VMwareDvsMulticastFilteringModeEnum::Snooping),
    ],
};

impl VMwareDvsMulticastFilteringModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VMwareDvsMulticastFilteringModeEnum::LegacyFiltering => "legacyFiltering",
            VMwareDvsMulticastFilteringModeEnum::Snooping => "snooping",
            VMwareDvsMulticastFilteringModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        V_MWARE_DVS_MULTICAST_FILTERING_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VMwareDvsMulticastFilteringModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VMwareDvsMulticastFilteringModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VMwareDvsMulticastFilteringModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VMwareDvsMulticastFilteringModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VMwareDvsMulticastFilteringModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VMwareDvsMulticastFilteringModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VMwareDvsMulticastFilteringModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VMwareDvsMulticastFilteringModeEnum> for &'a str {
    fn from(value: &'a VMwareDvsMulticastFilteringModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VMwareDvsMulticastFilteringModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VMWARE_DISTRIBUTED_VIRTUAL_SWITCH_PVLAN_PORT_TYPE_ENUM_MAP: phf::Map<&'static str, VmwareDistributedVirtualSwitchPvlanPortTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("promiscuous", VmwareDistributedVirtualSwitchPvlanPortTypeEnum::Promiscuous),
        ("community", VmwareDistributedVirtualSwitchPvlanPortTypeEnum::Community),
        ("isolated", VmwareDistributedVirtualSwitchPvlanPortTypeEnum::Isolated),
    ],
};

impl VmwareDistributedVirtualSwitchPvlanPortTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VmwareDistributedVirtualSwitchPvlanPortTypeEnum::Promiscuous => "promiscuous",
            VmwareDistributedVirtualSwitchPvlanPortTypeEnum::Isolated => "isolated",
            VmwareDistributedVirtualSwitchPvlanPortTypeEnum::Community => "community",
            VmwareDistributedVirtualSwitchPvlanPortTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VMWARE_DISTRIBUTED_VIRTUAL_SWITCH_PVLAN_PORT_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VmwareDistributedVirtualSwitchPvlanPortTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VmwareDistributedVirtualSwitchPvlanPortTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VmwareDistributedVirtualSwitchPvlanPortTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VmwareDistributedVirtualSwitchPvlanPortTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VmwareDistributedVirtualSwitchPvlanPortTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VmwareDistributedVirtualSwitchPvlanPortTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VmwareDistributedVirtualSwitchPvlanPortTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VmwareDistributedVirtualSwitchPvlanPortTypeEnum> for &'a str {
    fn from(value: &'a VmwareDistributedVirtualSwitchPvlanPortTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VmwareDistributedVirtualSwitchPvlanPortTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static V_MWARE_DVS_TEAMING_MATCH_STATUS_ENUM_MAP: phf::Map<&'static str, VMwareDvsTeamingMatchStatusEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("iphashMatch", VMwareDvsTeamingMatchStatusEnum::IphashMatch),
        ("nonIphashMatch", VMwareDvsTeamingMatchStatusEnum::NonIphashMatch),
        ("nonIphashMismatch", VMwareDvsTeamingMatchStatusEnum::NonIphashMismatch),
        ("iphashMismatch", VMwareDvsTeamingMatchStatusEnum::IphashMismatch),
    ],
};

impl VMwareDvsTeamingMatchStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VMwareDvsTeamingMatchStatusEnum::IphashMatch => "iphashMatch",
            VMwareDvsTeamingMatchStatusEnum::NonIphashMatch => "nonIphashMatch",
            VMwareDvsTeamingMatchStatusEnum::IphashMismatch => "iphashMismatch",
            VMwareDvsTeamingMatchStatusEnum::NonIphashMismatch => "nonIphashMismatch",
            VMwareDvsTeamingMatchStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        V_MWARE_DVS_TEAMING_MATCH_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VMwareDvsTeamingMatchStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VMwareDvsTeamingMatchStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VMwareDvsTeamingMatchStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VMwareDvsTeamingMatchStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VMwareDvsTeamingMatchStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VMwareDvsTeamingMatchStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VMwareDvsTeamingMatchStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VMwareDvsTeamingMatchStatusEnum> for &'a str {
    fn from(value: &'a VMwareDvsTeamingMatchStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VMwareDvsTeamingMatchStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static V_MWARE_UPLINK_LACP_MODE_ENUM_MAP: phf::Map<&'static str, VMwareUplinkLacpModeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("passive", VMwareUplinkLacpModeEnum::Passive),
        ("active", VMwareUplinkLacpModeEnum::Active),
    ],
};

impl VMwareUplinkLacpModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VMwareUplinkLacpModeEnum::Active => "active",
            VMwareUplinkLacpModeEnum::Passive => "passive",
            VMwareUplinkLacpModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        V_MWARE_UPLINK_LACP_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VMwareUplinkLacpModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VMwareUplinkLacpModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VMwareUplinkLacpModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VMwareUplinkLacpModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VMwareUplinkLacpModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VMwareUplinkLacpModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VMwareUplinkLacpModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VMwareUplinkLacpModeEnum> for &'a str {
    fn from(value: &'a VMwareUplinkLacpModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VMwareUplinkLacpModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static V_MWARE_UPLINK_LACP_TIMEOUT_MODE_ENUM_MAP: phf::Map<&'static str, VMwareUplinkLacpTimeoutModeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("fast", VMwareUplinkLacpTimeoutModeEnum::Fast),
        ("slow", VMwareUplinkLacpTimeoutModeEnum::Slow),
    ],
};

impl VMwareUplinkLacpTimeoutModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VMwareUplinkLacpTimeoutModeEnum::Fast => "fast",
            VMwareUplinkLacpTimeoutModeEnum::Slow => "slow",
            VMwareUplinkLacpTimeoutModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        V_MWARE_UPLINK_LACP_TIMEOUT_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VMwareUplinkLacpTimeoutModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VMwareUplinkLacpTimeoutModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VMwareUplinkLacpTimeoutModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VMwareUplinkLacpTimeoutModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VMwareUplinkLacpTimeoutModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VMwareUplinkLacpTimeoutModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VMwareUplinkLacpTimeoutModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VMwareUplinkLacpTimeoutModeEnum> for &'a str {
    fn from(value: &'a VMwareUplinkLacpTimeoutModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VMwareUplinkLacpTimeoutModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static V_MWARE_DVS_VSPAN_SESSION_ENCAP_TYPE_ENUM_MAP: phf::Map<&'static str, VMwareDvsVspanSessionEncapTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("erspan3", VMwareDvsVspanSessionEncapTypeEnum::Erspan3),
        ("erspan2", VMwareDvsVspanSessionEncapTypeEnum::Erspan2),
        ("gre", VMwareDvsVspanSessionEncapTypeEnum::Gre),
    ],
};

impl VMwareDvsVspanSessionEncapTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VMwareDvsVspanSessionEncapTypeEnum::Gre => "gre",
            VMwareDvsVspanSessionEncapTypeEnum::Erspan2 => "erspan2",
            VMwareDvsVspanSessionEncapTypeEnum::Erspan3 => "erspan3",
            VMwareDvsVspanSessionEncapTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        V_MWARE_DVS_VSPAN_SESSION_ENCAP_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VMwareDvsVspanSessionEncapTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VMwareDvsVspanSessionEncapTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VMwareDvsVspanSessionEncapTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VMwareDvsVspanSessionEncapTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VMwareDvsVspanSessionEncapTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VMwareDvsVspanSessionEncapTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VMwareDvsVspanSessionEncapTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VMwareDvsVspanSessionEncapTypeEnum> for &'a str {
    fn from(value: &'a VMwareDvsVspanSessionEncapTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VMwareDvsVspanSessionEncapTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static V_MWARE_DVS_VSPAN_SESSION_TYPE_ENUM_MAP: phf::Map<&'static str, VMwareDvsVspanSessionTypeEnum> = ::phf::Map {
    key: 4594751852016600049,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("remoteMirrorDest", VMwareDvsVspanSessionTypeEnum::RemoteMirrorDest),
        ("encapsulatedRemoteMirrorSource", VMwareDvsVspanSessionTypeEnum::EncapsulatedRemoteMirrorSource),
        ("dvPortMirror", VMwareDvsVspanSessionTypeEnum::DvPortMirror),
        ("mixedDestMirror", VMwareDvsVspanSessionTypeEnum::MixedDestMirror),
        ("remoteMirrorSource", VMwareDvsVspanSessionTypeEnum::RemoteMirrorSource),
    ],
};

impl VMwareDvsVspanSessionTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VMwareDvsVspanSessionTypeEnum::MixedDestMirror => "mixedDestMirror",
            VMwareDvsVspanSessionTypeEnum::DvPortMirror => "dvPortMirror",
            VMwareDvsVspanSessionTypeEnum::RemoteMirrorSource => "remoteMirrorSource",
            VMwareDvsVspanSessionTypeEnum::RemoteMirrorDest => "remoteMirrorDest",
            VMwareDvsVspanSessionTypeEnum::EncapsulatedRemoteMirrorSource => "encapsulatedRemoteMirrorSource",
            VMwareDvsVspanSessionTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        V_MWARE_DVS_VSPAN_SESSION_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VMwareDvsVspanSessionTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VMwareDvsVspanSessionTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VMwareDvsVspanSessionTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VMwareDvsVspanSessionTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VMwareDvsVspanSessionTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VMwareDvsVspanSessionTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VMwareDvsVspanSessionTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VMwareDvsVspanSessionTypeEnum> for &'a str {
    fn from(value: &'a VMwareDvsVspanSessionTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VMwareDvsVspanSessionTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CRYPTO_MANAGER_HOST_KEY_MANAGEMENT_TYPE_ENUM_MAP: phf::Map<&'static str, CryptoManagerHostKeyManagementTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("external", CryptoManagerHostKeyManagementTypeEnum::External),
        ("unknown", CryptoManagerHostKeyManagementTypeEnum::Unknown),
        ("internal", CryptoManagerHostKeyManagementTypeEnum::Internal),
    ],
};

impl CryptoManagerHostKeyManagementTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            CryptoManagerHostKeyManagementTypeEnum::Unknown => "unknown",
            CryptoManagerHostKeyManagementTypeEnum::Internal => "internal",
            CryptoManagerHostKeyManagementTypeEnum::External => "external",
            CryptoManagerHostKeyManagementTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CRYPTO_MANAGER_HOST_KEY_MANAGEMENT_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| CryptoManagerHostKeyManagementTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for CryptoManagerHostKeyManagementTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for CryptoManagerHostKeyManagementTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<CryptoManagerHostKeyManagementTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(CryptoManagerHostKeyManagementTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for CryptoManagerHostKeyManagementTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for CryptoManagerHostKeyManagementTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a CryptoManagerHostKeyManagementTypeEnum> for &'a str {
    fn from(value: &'a CryptoManagerHostKeyManagementTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for CryptoManagerHostKeyManagementTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CRYPTO_MANAGER_KMIP_CRYPTO_KEY_STATUS_KEY_UNAVAILABLE_REASON_ENUM_MAP: phf::Map<&'static str, CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (8, 2),
        (5, 0),
    ],
    entries: &[
        ("KeyStateManagedByNKP", CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum::KeyStateManagedByNkp),
        ("KeyStateClusterUnreachable", CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum::KeyStateClusterUnreachable),
        ("WrappingKeyMissingInKMS", CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum::WrappingKeyMissingInKms),
        ("KeyStateMissingInCache", CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum::KeyStateMissingInCache),
        ("KeyStateClusterInvalid", CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum::KeyStateClusterInvalid),
        ("KeyStateMissingInKMS", CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum::KeyStateMissingInKms),
        ("KeyStateNotActiveOrEnabled", CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum::KeyStateNotActiveOrEnabled),
        ("WrappingKeyNotActiveOrEnabled", CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum::WrappingKeyNotActiveOrEnabled),
        ("KeyStateManagedByTrustAuthority", CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum::KeyStateManagedByTrustAuthority),
        ("NoPermissionToAccessKeyProvider", CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum::NoPermissionToAccessKeyProvider),
    ],
};

impl CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum::KeyStateMissingInCache => "KeyStateMissingInCache",
            CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum::KeyStateClusterInvalid => "KeyStateClusterInvalid",
            CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum::KeyStateClusterUnreachable => "KeyStateClusterUnreachable",
            CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum::KeyStateMissingInKms => "KeyStateMissingInKMS",
            CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum::KeyStateNotActiveOrEnabled => "KeyStateNotActiveOrEnabled",
            CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum::KeyStateManagedByTrustAuthority => "KeyStateManagedByTrustAuthority",
            CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum::KeyStateManagedByNkp => "KeyStateManagedByNKP",
            CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum::NoPermissionToAccessKeyProvider => "NoPermissionToAccessKeyProvider",
            CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum::WrappingKeyMissingInKms => "WrappingKeyMissingInKMS",
            CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum::WrappingKeyNotActiveOrEnabled => "WrappingKeyNotActiveOrEnabled",
            CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CRYPTO_MANAGER_KMIP_CRYPTO_KEY_STATUS_KEY_UNAVAILABLE_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum> for &'a str {
    fn from(value: &'a CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static KMIP_CLUSTER_INFO_KEY_TYPE_ENUM_MAP: phf::Map<&'static str, KmipClusterInfoKeyTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("rawKey", KmipClusterInfoKeyTypeEnum::RawKey),
        ("wrappedKey", KmipClusterInfoKeyTypeEnum::WrappedKey),
    ],
};

impl KmipClusterInfoKeyTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            KmipClusterInfoKeyTypeEnum::RawKey => "rawKey",
            KmipClusterInfoKeyTypeEnum::WrappedKey => "wrappedKey",
            KmipClusterInfoKeyTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        KMIP_CLUSTER_INFO_KEY_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| KmipClusterInfoKeyTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for KmipClusterInfoKeyTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for KmipClusterInfoKeyTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<KmipClusterInfoKeyTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(KmipClusterInfoKeyTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for KmipClusterInfoKeyTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for KmipClusterInfoKeyTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a KmipClusterInfoKeyTypeEnum> for &'a str {
    fn from(value: &'a KmipClusterInfoKeyTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for KmipClusterInfoKeyTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static KMIP_CLUSTER_INFO_KMS_MANAGEMENT_TYPE_ENUM_MAP: phf::Map<&'static str, KmipClusterInfoKmsManagementTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("trustAuthority", KmipClusterInfoKmsManagementTypeEnum::TrustAuthority),
        ("nativeProvider", KmipClusterInfoKmsManagementTypeEnum::NativeProvider),
        ("unknown", KmipClusterInfoKmsManagementTypeEnum::Unknown),
        ("vCenter", KmipClusterInfoKmsManagementTypeEnum::VCenter),
    ],
};

impl KmipClusterInfoKmsManagementTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            KmipClusterInfoKmsManagementTypeEnum::Unknown => "unknown",
            KmipClusterInfoKmsManagementTypeEnum::VCenter => "vCenter",
            KmipClusterInfoKmsManagementTypeEnum::TrustAuthority => "trustAuthority",
            KmipClusterInfoKmsManagementTypeEnum::NativeProvider => "nativeProvider",
            KmipClusterInfoKmsManagementTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        KMIP_CLUSTER_INFO_KMS_MANAGEMENT_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| KmipClusterInfoKmsManagementTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for KmipClusterInfoKmsManagementTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for KmipClusterInfoKmsManagementTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<KmipClusterInfoKmsManagementTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(KmipClusterInfoKmsManagementTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for KmipClusterInfoKmsManagementTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for KmipClusterInfoKmsManagementTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a KmipClusterInfoKmsManagementTypeEnum> for &'a str {
    fn from(value: &'a KmipClusterInfoKmsManagementTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for KmipClusterInfoKmsManagementTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CUSTOMIZATION_FAILED_REASON_CODE_ENUM_MAP: phf::Map<&'static str, CustomizationFailedReasonCodeEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("rawDataIsNotSupported", CustomizationFailedReasonCodeEnum::RawDataIsNotSupported),
        ("userDefinedScriptDisabled", CustomizationFailedReasonCodeEnum::UserDefinedScriptDisabled),
        ("wrongMetadataFormat", CustomizationFailedReasonCodeEnum::WrongMetadataFormat),
        ("customizationDisabled", CustomizationFailedReasonCodeEnum::CustomizationDisabled),
    ],
};

impl CustomizationFailedReasonCodeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            CustomizationFailedReasonCodeEnum::UserDefinedScriptDisabled => "userDefinedScriptDisabled",
            CustomizationFailedReasonCodeEnum::CustomizationDisabled => "customizationDisabled",
            CustomizationFailedReasonCodeEnum::RawDataIsNotSupported => "rawDataIsNotSupported",
            CustomizationFailedReasonCodeEnum::WrongMetadataFormat => "wrongMetadataFormat",
            CustomizationFailedReasonCodeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CUSTOMIZATION_FAILED_REASON_CODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| CustomizationFailedReasonCodeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for CustomizationFailedReasonCodeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for CustomizationFailedReasonCodeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<CustomizationFailedReasonCodeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(CustomizationFailedReasonCodeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for CustomizationFailedReasonCodeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for CustomizationFailedReasonCodeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a CustomizationFailedReasonCodeEnum> for &'a str {
    fn from(value: &'a CustomizationFailedReasonCodeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for CustomizationFailedReasonCodeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DVS_EVENT_PORT_BLOCK_STATE_ENUM_MAP: phf::Map<&'static str, DvsEventPortBlockStateEnum> = ::phf::Map {
    key: 351906021642186605,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("unknown", DvsEventPortBlockStateEnum::Unknown),
        ("blocked", DvsEventPortBlockStateEnum::Blocked),
        ("unset", DvsEventPortBlockStateEnum::Unset),
        ("unblocked", DvsEventPortBlockStateEnum::Unblocked),
    ],
};

impl DvsEventPortBlockStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DvsEventPortBlockStateEnum::Unset => "unset",
            DvsEventPortBlockStateEnum::Blocked => "blocked",
            DvsEventPortBlockStateEnum::Unblocked => "unblocked",
            DvsEventPortBlockStateEnum::Unknown => "unknown",
            DvsEventPortBlockStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DVS_EVENT_PORT_BLOCK_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DvsEventPortBlockStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DvsEventPortBlockStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DvsEventPortBlockStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DvsEventPortBlockStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DvsEventPortBlockStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DvsEventPortBlockStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DvsEventPortBlockStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DvsEventPortBlockStateEnum> for &'a str {
    fn from(value: &'a DvsEventPortBlockStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DvsEventPortBlockStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static EVENT_EVENT_SEVERITY_ENUM_MAP: phf::Map<&'static str, EventEventSeverityEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("error", EventEventSeverityEnum::Error),
        ("info", EventEventSeverityEnum::Info),
        ("warning", EventEventSeverityEnum::Warning),
        ("user", EventEventSeverityEnum::User),
    ],
};

impl EventEventSeverityEnum {
    pub fn as_str(&self) -> &str {
        match self {
            EventEventSeverityEnum::Error => "error",
            EventEventSeverityEnum::Warning => "warning",
            EventEventSeverityEnum::Info => "info",
            EventEventSeverityEnum::User => "user",
            EventEventSeverityEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        EVENT_EVENT_SEVERITY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| EventEventSeverityEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for EventEventSeverityEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for EventEventSeverityEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<EventEventSeverityEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(EventEventSeverityEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for EventEventSeverityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for EventEventSeverityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a EventEventSeverityEnum> for &'a str {
    fn from(value: &'a EventEventSeverityEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for EventEventSeverityEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static EVENT_CATEGORY_ENUM_MAP: phf::Map<&'static str, EventCategoryEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("error", EventCategoryEnum::Error),
        ("info", EventCategoryEnum::Info),
        ("warning", EventCategoryEnum::Warning),
        ("user", EventCategoryEnum::User),
    ],
};

impl EventCategoryEnum {
    pub fn as_str(&self) -> &str {
        match self {
            EventCategoryEnum::Info => "info",
            EventCategoryEnum::Warning => "warning",
            EventCategoryEnum::Error => "error",
            EventCategoryEnum::User => "user",
            EventCategoryEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        EVENT_CATEGORY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| EventCategoryEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for EventCategoryEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for EventCategoryEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<EventCategoryEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(EventCategoryEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for EventCategoryEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for EventCategoryEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a EventCategoryEnum> for &'a str {
    fn from(value: &'a EventCategoryEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for EventCategoryEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static EVENT_FILTER_SPEC_RECURSION_OPTION_ENUM_MAP: phf::Map<&'static str, EventFilterSpecRecursionOptionEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("self", EventFilterSpecRecursionOptionEnum::Self_),
        ("children", EventFilterSpecRecursionOptionEnum::Children),
        ("all", EventFilterSpecRecursionOptionEnum::All),
    ],
};

impl EventFilterSpecRecursionOptionEnum {
    pub fn as_str(&self) -> &str {
        match self {
            EventFilterSpecRecursionOptionEnum::Self_ => "self",
            EventFilterSpecRecursionOptionEnum::Children => "children",
            EventFilterSpecRecursionOptionEnum::All => "all",
            EventFilterSpecRecursionOptionEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        EVENT_FILTER_SPEC_RECURSION_OPTION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| EventFilterSpecRecursionOptionEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for EventFilterSpecRecursionOptionEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for EventFilterSpecRecursionOptionEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<EventFilterSpecRecursionOptionEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(EventFilterSpecRecursionOptionEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for EventFilterSpecRecursionOptionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for EventFilterSpecRecursionOptionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a EventFilterSpecRecursionOptionEnum> for &'a str {
    fn from(value: &'a EventFilterSpecRecursionOptionEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for EventFilterSpecRecursionOptionEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_DAS_ERROR_EVENT_HOST_DAS_ERROR_REASON_ENUM_MAP: phf::Map<&'static str, HostDasErrorEventHostDasErrorReasonEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (6, 0),
        (0, 0),
    ],
    entries: &[
        ("communicationInitFailed", HostDasErrorEventHostDasErrorReasonEnum::CommunicationInitFailed),
        ("timeout", HostDasErrorEventHostDasErrorReasonEnum::Timeout),
        ("agentShutdown", HostDasErrorEventHostDasErrorReasonEnum::AgentShutdown),
        ("configFailed", HostDasErrorEventHostDasErrorReasonEnum::ConfigFailed),
        ("other", HostDasErrorEventHostDasErrorReasonEnum::Other),
        ("isolationAddressUnpingable", HostDasErrorEventHostDasErrorReasonEnum::IsolationAddressUnpingable),
        ("healthCheckScriptFailed", HostDasErrorEventHostDasErrorReasonEnum::HealthCheckScriptFailed),
        ("agentFailed", HostDasErrorEventHostDasErrorReasonEnum::AgentFailed),
    ],
};

impl HostDasErrorEventHostDasErrorReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostDasErrorEventHostDasErrorReasonEnum::ConfigFailed => "configFailed",
            HostDasErrorEventHostDasErrorReasonEnum::Timeout => "timeout",
            HostDasErrorEventHostDasErrorReasonEnum::CommunicationInitFailed => "communicationInitFailed",
            HostDasErrorEventHostDasErrorReasonEnum::HealthCheckScriptFailed => "healthCheckScriptFailed",
            HostDasErrorEventHostDasErrorReasonEnum::AgentFailed => "agentFailed",
            HostDasErrorEventHostDasErrorReasonEnum::AgentShutdown => "agentShutdown",
            HostDasErrorEventHostDasErrorReasonEnum::IsolationAddressUnpingable => "isolationAddressUnpingable",
            HostDasErrorEventHostDasErrorReasonEnum::Other => "other",
            HostDasErrorEventHostDasErrorReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_DAS_ERROR_EVENT_HOST_DAS_ERROR_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostDasErrorEventHostDasErrorReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostDasErrorEventHostDasErrorReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostDasErrorEventHostDasErrorReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostDasErrorEventHostDasErrorReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostDasErrorEventHostDasErrorReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostDasErrorEventHostDasErrorReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostDasErrorEventHostDasErrorReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostDasErrorEventHostDasErrorReasonEnum> for &'a str {
    fn from(value: &'a HostDasErrorEventHostDasErrorReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostDasErrorEventHostDasErrorReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_DISCONNECTED_EVENT_REASON_CODE_ENUM_MAP: phf::Map<&'static str, HostDisconnectedEventReasonCodeEnum> = ::phf::Map {
    key: 8694567506910003252,
    disps: &[
        (0, 0),
        (0, 0),
    ],
    entries: &[
        ("agentOutOfDate", HostDisconnectedEventReasonCodeEnum::AgentOutOfDate),
        ("passwordDecryptFailure", HostDisconnectedEventReasonCodeEnum::PasswordDecryptFailure),
        ("agentUpgrade", HostDisconnectedEventReasonCodeEnum::AgentUpgrade),
        ("vcVRAMCapacityExceeded", HostDisconnectedEventReasonCodeEnum::VcVramCapacityExceeded),
        ("insufficientLicenses", HostDisconnectedEventReasonCodeEnum::InsufficientLicenses),
        ("unknown", HostDisconnectedEventReasonCodeEnum::Unknown),
        ("sslThumbprintVerifyFailed", HostDisconnectedEventReasonCodeEnum::SslThumbprintVerifyFailed),
        ("licenseExpired", HostDisconnectedEventReasonCodeEnum::LicenseExpired),
        ("userRequest", HostDisconnectedEventReasonCodeEnum::UserRequest),
    ],
};

impl HostDisconnectedEventReasonCodeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostDisconnectedEventReasonCodeEnum::SslThumbprintVerifyFailed => "sslThumbprintVerifyFailed",
            HostDisconnectedEventReasonCodeEnum::LicenseExpired => "licenseExpired",
            HostDisconnectedEventReasonCodeEnum::AgentUpgrade => "agentUpgrade",
            HostDisconnectedEventReasonCodeEnum::UserRequest => "userRequest",
            HostDisconnectedEventReasonCodeEnum::InsufficientLicenses => "insufficientLicenses",
            HostDisconnectedEventReasonCodeEnum::AgentOutOfDate => "agentOutOfDate",
            HostDisconnectedEventReasonCodeEnum::PasswordDecryptFailure => "passwordDecryptFailure",
            HostDisconnectedEventReasonCodeEnum::Unknown => "unknown",
            HostDisconnectedEventReasonCodeEnum::VcVramCapacityExceeded => "vcVRAMCapacityExceeded",
            HostDisconnectedEventReasonCodeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_DISCONNECTED_EVENT_REASON_CODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostDisconnectedEventReasonCodeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostDisconnectedEventReasonCodeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostDisconnectedEventReasonCodeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostDisconnectedEventReasonCodeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostDisconnectedEventReasonCodeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostDisconnectedEventReasonCodeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostDisconnectedEventReasonCodeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostDisconnectedEventReasonCodeEnum> for &'a str {
    fn from(value: &'a HostDisconnectedEventReasonCodeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostDisconnectedEventReasonCodeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VM_DAS_BEING_RESET_EVENT_REASON_CODE_ENUM_MAP: phf::Map<&'static str, VmDasBeingResetEventReasonCodeEnum> = ::phf::Map {
    key: 8694567506910003252,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("vmcpResetApdCleared", VmDasBeingResetEventReasonCodeEnum::VmcpResetApdCleared),
        ("appImmediateResetRequest", VmDasBeingResetEventReasonCodeEnum::AppImmediateResetRequest),
        ("appHeartbeatFailure", VmDasBeingResetEventReasonCodeEnum::AppHeartbeatFailure),
        ("vmtoolsHeartbeatFailure", VmDasBeingResetEventReasonCodeEnum::VmtoolsHeartbeatFailure),
    ],
};

impl VmDasBeingResetEventReasonCodeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VmDasBeingResetEventReasonCodeEnum::VmtoolsHeartbeatFailure => "vmtoolsHeartbeatFailure",
            VmDasBeingResetEventReasonCodeEnum::AppHeartbeatFailure => "appHeartbeatFailure",
            VmDasBeingResetEventReasonCodeEnum::AppImmediateResetRequest => "appImmediateResetRequest",
            VmDasBeingResetEventReasonCodeEnum::VmcpResetApdCleared => "vmcpResetApdCleared",
            VmDasBeingResetEventReasonCodeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VM_DAS_BEING_RESET_EVENT_REASON_CODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VmDasBeingResetEventReasonCodeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VmDasBeingResetEventReasonCodeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VmDasBeingResetEventReasonCodeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VmDasBeingResetEventReasonCodeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VmDasBeingResetEventReasonCodeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VmDasBeingResetEventReasonCodeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VmDasBeingResetEventReasonCodeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VmDasBeingResetEventReasonCodeEnum> for &'a str {
    fn from(value: &'a VmDasBeingResetEventReasonCodeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VmDasBeingResetEventReasonCodeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VM_FAILED_STARTING_SECONDARY_EVENT_FAILURE_REASON_ENUM_MAP: phf::Map<&'static str, VmFailedStartingSecondaryEventFailureReasonEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("loginFailed", VmFailedStartingSecondaryEventFailureReasonEnum::LoginFailed),
        ("registerVmFailed", VmFailedStartingSecondaryEventFailureReasonEnum::RegisterVmFailed),
        ("migrateFailed", VmFailedStartingSecondaryEventFailureReasonEnum::MigrateFailed),
        ("incompatibleHost", VmFailedStartingSecondaryEventFailureReasonEnum::IncompatibleHost),
    ],
};

impl VmFailedStartingSecondaryEventFailureReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VmFailedStartingSecondaryEventFailureReasonEnum::IncompatibleHost => "incompatibleHost",
            VmFailedStartingSecondaryEventFailureReasonEnum::LoginFailed => "loginFailed",
            VmFailedStartingSecondaryEventFailureReasonEnum::RegisterVmFailed => "registerVmFailed",
            VmFailedStartingSecondaryEventFailureReasonEnum::MigrateFailed => "migrateFailed",
            VmFailedStartingSecondaryEventFailureReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VM_FAILED_STARTING_SECONDARY_EVENT_FAILURE_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VmFailedStartingSecondaryEventFailureReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VmFailedStartingSecondaryEventFailureReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VmFailedStartingSecondaryEventFailureReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VmFailedStartingSecondaryEventFailureReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VmFailedStartingSecondaryEventFailureReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VmFailedStartingSecondaryEventFailureReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VmFailedStartingSecondaryEventFailureReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VmFailedStartingSecondaryEventFailureReasonEnum> for &'a str {
    fn from(value: &'a VmFailedStartingSecondaryEventFailureReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VmFailedStartingSecondaryEventFailureReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VM_SHUTDOWN_ON_ISOLATION_EVENT_OPERATION_ENUM_MAP: phf::Map<&'static str, VmShutdownOnIsolationEventOperationEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("poweredOff", VmShutdownOnIsolationEventOperationEnum::PoweredOff),
        ("shutdown", VmShutdownOnIsolationEventOperationEnum::Shutdown),
    ],
};

impl VmShutdownOnIsolationEventOperationEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VmShutdownOnIsolationEventOperationEnum::Shutdown => "shutdown",
            VmShutdownOnIsolationEventOperationEnum::PoweredOff => "poweredOff",
            VmShutdownOnIsolationEventOperationEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VM_SHUTDOWN_ON_ISOLATION_EVENT_OPERATION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VmShutdownOnIsolationEventOperationEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VmShutdownOnIsolationEventOperationEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VmShutdownOnIsolationEventOperationEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VmShutdownOnIsolationEventOperationEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VmShutdownOnIsolationEventOperationEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VmShutdownOnIsolationEventOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VmShutdownOnIsolationEventOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VmShutdownOnIsolationEventOperationEnum> for &'a str {
    fn from(value: &'a VmShutdownOnIsolationEventOperationEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VmShutdownOnIsolationEventOperationEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static AFFINITY_TYPE_ENUM_MAP: phf::Map<&'static str, AffinityTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("memory", AffinityTypeEnum::Memory),
        ("cpu", AffinityTypeEnum::Cpu),
    ],
};

impl AffinityTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            AffinityTypeEnum::Memory => "memory",
            AffinityTypeEnum::Cpu => "cpu",
            AffinityTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        AFFINITY_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| AffinityTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for AffinityTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for AffinityTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<AffinityTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(AffinityTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for AffinityTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for AffinityTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a AffinityTypeEnum> for &'a str {
    fn from(value: &'a AffinityTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for AffinityTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static AGENT_INSTALL_FAILED_REASON_ENUM_MAP: phf::Map<&'static str, AgentInstallFailedReasonEnum> = ::phf::Map {
    key: 14108922650502679131,
    disps: &[
        (2, 3),
        (0, 0),
    ],
    entries: &[
        ("InstallTimedout", AgentInstallFailedReasonEnum::InstallTimedout),
        ("AgentUploadFailed", AgentInstallFailedReasonEnum::AgentUploadFailed),
        ("AgentUploadTimedout", AgentInstallFailedReasonEnum::AgentUploadTimedout),
        ("SignatureVerificationFailed", AgentInstallFailedReasonEnum::SignatureVerificationFailed),
        ("PrepareToUpgradeFailed", AgentInstallFailedReasonEnum::PrepareToUpgradeFailed),
        ("AgentNotReachable", AgentInstallFailedReasonEnum::AgentNotReachable),
        ("NotEnoughSpaceOnDevice", AgentInstallFailedReasonEnum::NotEnoughSpaceOnDevice),
        ("AgentNotRunning", AgentInstallFailedReasonEnum::AgentNotRunning),
        ("UnknownInstallerError", AgentInstallFailedReasonEnum::UnknownInstallerError),
    ],
};

impl AgentInstallFailedReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            AgentInstallFailedReasonEnum::NotEnoughSpaceOnDevice => "NotEnoughSpaceOnDevice",
            AgentInstallFailedReasonEnum::PrepareToUpgradeFailed => "PrepareToUpgradeFailed",
            AgentInstallFailedReasonEnum::AgentNotRunning => "AgentNotRunning",
            AgentInstallFailedReasonEnum::AgentNotReachable => "AgentNotReachable",
            AgentInstallFailedReasonEnum::InstallTimedout => "InstallTimedout",
            AgentInstallFailedReasonEnum::SignatureVerificationFailed => "SignatureVerificationFailed",
            AgentInstallFailedReasonEnum::AgentUploadFailed => "AgentUploadFailed",
            AgentInstallFailedReasonEnum::AgentUploadTimedout => "AgentUploadTimedout",
            AgentInstallFailedReasonEnum::UnknownInstallerError => "UnknownInstallerError",
            AgentInstallFailedReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        AGENT_INSTALL_FAILED_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| AgentInstallFailedReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for AgentInstallFailedReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for AgentInstallFailedReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<AgentInstallFailedReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(AgentInstallFailedReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for AgentInstallFailedReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for AgentInstallFailedReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a AgentInstallFailedReasonEnum> for &'a str {
    fn from(value: &'a AgentInstallFailedReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for AgentInstallFailedReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CANNOT_ENABLE_VMCP_FOR_CLUSTER_REASON_ENUM_MAP: phf::Map<&'static str, CannotEnableVmcpForClusterReasonEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("APDTimeoutDisabled", CannotEnableVmcpForClusterReasonEnum::ApdTimeoutDisabled),
    ],
};

impl CannotEnableVmcpForClusterReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            CannotEnableVmcpForClusterReasonEnum::ApdTimeoutDisabled => "APDTimeoutDisabled",
            CannotEnableVmcpForClusterReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CANNOT_ENABLE_VMCP_FOR_CLUSTER_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| CannotEnableVmcpForClusterReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for CannotEnableVmcpForClusterReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for CannotEnableVmcpForClusterReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<CannotEnableVmcpForClusterReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(CannotEnableVmcpForClusterReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for CannotEnableVmcpForClusterReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for CannotEnableVmcpForClusterReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a CannotEnableVmcpForClusterReasonEnum> for &'a str {
    fn from(value: &'a CannotEnableVmcpForClusterReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for CannotEnableVmcpForClusterReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CANNOT_MOVE_FAULT_TOLERANCE_VM_MOVE_TYPE_ENUM_MAP: phf::Map<&'static str, CannotMoveFaultToleranceVmMoveTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("cluster", CannotMoveFaultToleranceVmMoveTypeEnum::Cluster),
        ("resourcePool", CannotMoveFaultToleranceVmMoveTypeEnum::ResourcePool),
    ],
};

impl CannotMoveFaultToleranceVmMoveTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            CannotMoveFaultToleranceVmMoveTypeEnum::ResourcePool => "resourcePool",
            CannotMoveFaultToleranceVmMoveTypeEnum::Cluster => "cluster",
            CannotMoveFaultToleranceVmMoveTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CANNOT_MOVE_FAULT_TOLERANCE_VM_MOVE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| CannotMoveFaultToleranceVmMoveTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for CannotMoveFaultToleranceVmMoveTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for CannotMoveFaultToleranceVmMoveTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<CannotMoveFaultToleranceVmMoveTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(CannotMoveFaultToleranceVmMoveTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for CannotMoveFaultToleranceVmMoveTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for CannotMoveFaultToleranceVmMoveTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a CannotMoveFaultToleranceVmMoveTypeEnum> for &'a str {
    fn from(value: &'a CannotMoveFaultToleranceVmMoveTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for CannotMoveFaultToleranceVmMoveTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CANNOT_POWER_OFF_VM_IN_CLUSTER_OPERATION_ENUM_MAP: phf::Map<&'static str, CannotPowerOffVmInClusterOperationEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("guestSuspend", CannotPowerOffVmInClusterOperationEnum::GuestSuspend),
        ("guestShutdown", CannotPowerOffVmInClusterOperationEnum::GuestShutdown),
        ("suspend", CannotPowerOffVmInClusterOperationEnum::Suspend),
        ("powerOff", CannotPowerOffVmInClusterOperationEnum::PowerOff),
    ],
};

impl CannotPowerOffVmInClusterOperationEnum {
    pub fn as_str(&self) -> &str {
        match self {
            CannotPowerOffVmInClusterOperationEnum::Suspend => "suspend",
            CannotPowerOffVmInClusterOperationEnum::PowerOff => "powerOff",
            CannotPowerOffVmInClusterOperationEnum::GuestShutdown => "guestShutdown",
            CannotPowerOffVmInClusterOperationEnum::GuestSuspend => "guestSuspend",
            CannotPowerOffVmInClusterOperationEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CANNOT_POWER_OFF_VM_IN_CLUSTER_OPERATION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| CannotPowerOffVmInClusterOperationEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for CannotPowerOffVmInClusterOperationEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for CannotPowerOffVmInClusterOperationEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<CannotPowerOffVmInClusterOperationEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(CannotPowerOffVmInClusterOperationEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for CannotPowerOffVmInClusterOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for CannotPowerOffVmInClusterOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a CannotPowerOffVmInClusterOperationEnum> for &'a str {
    fn from(value: &'a CannotPowerOffVmInClusterOperationEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for CannotPowerOffVmInClusterOperationEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CANNOT_USE_NETWORK_REASON_ENUM_MAP: phf::Map<&'static str, CannotUseNetworkReasonEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (5, 0),
        (6, 2),
    ],
    entries: &[
        ("MismatchedEnsMode", CannotUseNetworkReasonEnum::MismatchedEnsMode),
        ("NetworkUnderMaintenance", CannotUseNetworkReasonEnum::NetworkUnderMaintenance),
        ("NetworkReservationNotSupported", CannotUseNetworkReasonEnum::NetworkReservationNotSupported),
        ("MismatchedNetworkPolicies", CannotUseNetworkReasonEnum::MismatchedNetworkPolicies),
        ("MismatchedDvsVersionOrVendor", CannotUseNetworkReasonEnum::MismatchedDvsVersionOrVendor),
        ("VMotionToUnsupportedNetworkType", CannotUseNetworkReasonEnum::VMotionToUnsupportedNetworkType),
        ("MismatchedRealTimeDvs", CannotUseNetworkReasonEnum::MismatchedRealTimeDvs),
    ],
};

impl CannotUseNetworkReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            CannotUseNetworkReasonEnum::NetworkReservationNotSupported => "NetworkReservationNotSupported",
            CannotUseNetworkReasonEnum::MismatchedNetworkPolicies => "MismatchedNetworkPolicies",
            CannotUseNetworkReasonEnum::MismatchedDvsVersionOrVendor => "MismatchedDvsVersionOrVendor",
            CannotUseNetworkReasonEnum::VMotionToUnsupportedNetworkType => "VMotionToUnsupportedNetworkType",
            CannotUseNetworkReasonEnum::NetworkUnderMaintenance => "NetworkUnderMaintenance",
            CannotUseNetworkReasonEnum::MismatchedEnsMode => "MismatchedEnsMode",
            CannotUseNetworkReasonEnum::MismatchedRealTimeDvs => "MismatchedRealTimeDvs",
            CannotUseNetworkReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CANNOT_USE_NETWORK_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| CannotUseNetworkReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for CannotUseNetworkReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for CannotUseNetworkReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<CannotUseNetworkReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(CannotUseNetworkReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for CannotUseNetworkReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for CannotUseNetworkReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a CannotUseNetworkReasonEnum> for &'a str {
    fn from(value: &'a CannotUseNetworkReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for CannotUseNetworkReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DAS_CONFIG_FAULT_DAS_CONFIG_FAULT_REASON_ENUM_MAP: phf::Map<&'static str, DasConfigFaultDasConfigFaultReasonEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 5),
        (9, 4),
        (0, 0),
    ],
    entries: &[
        ("HostNetworkMisconfiguration", DasConfigFaultDasConfigFaultReasonEnum::HostNetworkMisconfiguration),
        ("CreateConfigVvolFailed", DasConfigFaultDasConfigFaultReasonEnum::CreateConfigVvolFailed),
        ("Other", DasConfigFaultDasConfigFaultReasonEnum::Other),
        ("NoPrimaryAgentAvailable", DasConfigFaultDasConfigFaultReasonEnum::NoPrimaryAgentAvailable),
        ("InsufficientPrivileges", DasConfigFaultDasConfigFaultReasonEnum::InsufficientPrivileges),
        ("VSanNotSupportedOnHost", DasConfigFaultDasConfigFaultReasonEnum::VSanNotSupportedOnHost),
        ("SetDesiredImageSpecFailed", DasConfigFaultDasConfigFaultReasonEnum::SetDesiredImageSpecFailed),
        ("NoDatastoresConfigured", DasConfigFaultDasConfigFaultReasonEnum::NoDatastoresConfigured),
        ("HostMisconfiguration", DasConfigFaultDasConfigFaultReasonEnum::HostMisconfiguration),
        ("DasNetworkMisconfiguration", DasConfigFaultDasConfigFaultReasonEnum::DasNetworkMisconfiguration),
        ("ApplyHAVibsOnClusterFailed", DasConfigFaultDasConfigFaultReasonEnum::ApplyHaVibsOnClusterFailed),
    ],
};

impl DasConfigFaultDasConfigFaultReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DasConfigFaultDasConfigFaultReasonEnum::HostNetworkMisconfiguration => "HostNetworkMisconfiguration",
            DasConfigFaultDasConfigFaultReasonEnum::HostMisconfiguration => "HostMisconfiguration",
            DasConfigFaultDasConfigFaultReasonEnum::InsufficientPrivileges => "InsufficientPrivileges",
            DasConfigFaultDasConfigFaultReasonEnum::NoPrimaryAgentAvailable => "NoPrimaryAgentAvailable",
            DasConfigFaultDasConfigFaultReasonEnum::Other => "Other",
            DasConfigFaultDasConfigFaultReasonEnum::NoDatastoresConfigured => "NoDatastoresConfigured",
            DasConfigFaultDasConfigFaultReasonEnum::CreateConfigVvolFailed => "CreateConfigVvolFailed",
            DasConfigFaultDasConfigFaultReasonEnum::VSanNotSupportedOnHost => "VSanNotSupportedOnHost",
            DasConfigFaultDasConfigFaultReasonEnum::DasNetworkMisconfiguration => "DasNetworkMisconfiguration",
            DasConfigFaultDasConfigFaultReasonEnum::SetDesiredImageSpecFailed => "SetDesiredImageSpecFailed",
            DasConfigFaultDasConfigFaultReasonEnum::ApplyHaVibsOnClusterFailed => "ApplyHAVibsOnClusterFailed",
            DasConfigFaultDasConfigFaultReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DAS_CONFIG_FAULT_DAS_CONFIG_FAULT_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DasConfigFaultDasConfigFaultReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DasConfigFaultDasConfigFaultReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DasConfigFaultDasConfigFaultReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DasConfigFaultDasConfigFaultReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DasConfigFaultDasConfigFaultReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DasConfigFaultDasConfigFaultReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DasConfigFaultDasConfigFaultReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DasConfigFaultDasConfigFaultReasonEnum> for &'a str {
    fn from(value: &'a DasConfigFaultDasConfigFaultReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DasConfigFaultDasConfigFaultReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DEVICE_NOT_SUPPORTED_REASON_ENUM_MAP: phf::Map<&'static str, DeviceNotSupportedReasonEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("ft", DeviceNotSupportedReasonEnum::Ft),
        ("host", DeviceNotSupportedReasonEnum::Host),
        ("guest", DeviceNotSupportedReasonEnum::Guest),
    ],
};

impl DeviceNotSupportedReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DeviceNotSupportedReasonEnum::Host => "host",
            DeviceNotSupportedReasonEnum::Guest => "guest",
            DeviceNotSupportedReasonEnum::Ft => "ft",
            DeviceNotSupportedReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DEVICE_NOT_SUPPORTED_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DeviceNotSupportedReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DeviceNotSupportedReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DeviceNotSupportedReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DeviceNotSupportedReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DeviceNotSupportedReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DeviceNotSupportedReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DeviceNotSupportedReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DeviceNotSupportedReasonEnum> for &'a str {
    fn from(value: &'a DeviceNotSupportedReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DeviceNotSupportedReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DISALLOWED_CHANGE_BY_SERVICE_DISALLOWED_CHANGE_ENUM_MAP: phf::Map<&'static str, DisallowedChangeByServiceDisallowedChangeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("hotExtendDisk", DisallowedChangeByServiceDisallowedChangeEnum::HotExtendDisk),
    ],
};

impl DisallowedChangeByServiceDisallowedChangeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DisallowedChangeByServiceDisallowedChangeEnum::HotExtendDisk => "hotExtendDisk",
            DisallowedChangeByServiceDisallowedChangeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DISALLOWED_CHANGE_BY_SERVICE_DISALLOWED_CHANGE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DisallowedChangeByServiceDisallowedChangeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DisallowedChangeByServiceDisallowedChangeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DisallowedChangeByServiceDisallowedChangeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DisallowedChangeByServiceDisallowedChangeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DisallowedChangeByServiceDisallowedChangeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DisallowedChangeByServiceDisallowedChangeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DisallowedChangeByServiceDisallowedChangeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DisallowedChangeByServiceDisallowedChangeEnum> for &'a str {
    fn from(value: &'a DisallowedChangeByServiceDisallowedChangeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DisallowedChangeByServiceDisallowedChangeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static FT_ISSUES_ON_HOST_HOST_SELECTION_TYPE_ENUM_MAP: phf::Map<&'static str, FtIssuesOnHostHostSelectionTypeEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("user", FtIssuesOnHostHostSelectionTypeEnum::User),
        ("vc", FtIssuesOnHostHostSelectionTypeEnum::Vc),
        ("drs", FtIssuesOnHostHostSelectionTypeEnum::Drs),
    ],
};

impl FtIssuesOnHostHostSelectionTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            FtIssuesOnHostHostSelectionTypeEnum::User => "user",
            FtIssuesOnHostHostSelectionTypeEnum::Vc => "vc",
            FtIssuesOnHostHostSelectionTypeEnum::Drs => "drs",
            FtIssuesOnHostHostSelectionTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        FT_ISSUES_ON_HOST_HOST_SELECTION_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| FtIssuesOnHostHostSelectionTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for FtIssuesOnHostHostSelectionTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for FtIssuesOnHostHostSelectionTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<FtIssuesOnHostHostSelectionTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(FtIssuesOnHostHostSelectionTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for FtIssuesOnHostHostSelectionTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for FtIssuesOnHostHostSelectionTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a FtIssuesOnHostHostSelectionTypeEnum> for &'a str {
    fn from(value: &'a FtIssuesOnHostHostSelectionTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for FtIssuesOnHostHostSelectionTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_HAS_COMPONENT_FAILURE_HOST_COMPONENT_TYPE_ENUM_MAP: phf::Map<&'static str, HostHasComponentFailureHostComponentTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("Datastore", HostHasComponentFailureHostComponentTypeEnum::Datastore),
    ],
};

impl HostHasComponentFailureHostComponentTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostHasComponentFailureHostComponentTypeEnum::Datastore => "Datastore",
            HostHasComponentFailureHostComponentTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_HAS_COMPONENT_FAILURE_HOST_COMPONENT_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostHasComponentFailureHostComponentTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostHasComponentFailureHostComponentTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostHasComponentFailureHostComponentTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostHasComponentFailureHostComponentTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostHasComponentFailureHostComponentTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostHasComponentFailureHostComponentTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostHasComponentFailureHostComponentTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostHasComponentFailureHostComponentTypeEnum> for &'a str {
    fn from(value: &'a HostHasComponentFailureHostComponentTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostHasComponentFailureHostComponentTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_INCOMPATIBLE_FOR_FAULT_TOLERANCE_REASON_ENUM_MAP: phf::Map<&'static str, HostIncompatibleForFaultToleranceReasonEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("processor", HostIncompatibleForFaultToleranceReasonEnum::Processor),
        ("product", HostIncompatibleForFaultToleranceReasonEnum::Product),
    ],
};

impl HostIncompatibleForFaultToleranceReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostIncompatibleForFaultToleranceReasonEnum::Product => "product",
            HostIncompatibleForFaultToleranceReasonEnum::Processor => "processor",
            HostIncompatibleForFaultToleranceReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_INCOMPATIBLE_FOR_FAULT_TOLERANCE_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostIncompatibleForFaultToleranceReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostIncompatibleForFaultToleranceReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostIncompatibleForFaultToleranceReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostIncompatibleForFaultToleranceReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostIncompatibleForFaultToleranceReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostIncompatibleForFaultToleranceReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostIncompatibleForFaultToleranceReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostIncompatibleForFaultToleranceReasonEnum> for &'a str {
    fn from(value: &'a HostIncompatibleForFaultToleranceReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostIncompatibleForFaultToleranceReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_INCOMPATIBLE_FOR_RECORD_REPLAY_REASON_ENUM_MAP: phf::Map<&'static str, HostIncompatibleForRecordReplayReasonEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("processor", HostIncompatibleForRecordReplayReasonEnum::Processor),
        ("product", HostIncompatibleForRecordReplayReasonEnum::Product),
    ],
};

impl HostIncompatibleForRecordReplayReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostIncompatibleForRecordReplayReasonEnum::Product => "product",
            HostIncompatibleForRecordReplayReasonEnum::Processor => "processor",
            HostIncompatibleForRecordReplayReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_INCOMPATIBLE_FOR_RECORD_REPLAY_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostIncompatibleForRecordReplayReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostIncompatibleForRecordReplayReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostIncompatibleForRecordReplayReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostIncompatibleForRecordReplayReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostIncompatibleForRecordReplayReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostIncompatibleForRecordReplayReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostIncompatibleForRecordReplayReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostIncompatibleForRecordReplayReasonEnum> for &'a str {
    fn from(value: &'a HostIncompatibleForRecordReplayReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostIncompatibleForRecordReplayReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static INCOMPATIBLE_HOST_FOR_VM_REPLICATION_INCOMPATIBLE_REASON_ENUM_MAP: phf::Map<&'static str, IncompatibleHostForVmReplicationIncompatibleReasonEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("netCompression", IncompatibleHostForVmReplicationIncompatibleReasonEnum::NetCompression),
        ("rpo", IncompatibleHostForVmReplicationIncompatibleReasonEnum::Rpo),
    ],
};

impl IncompatibleHostForVmReplicationIncompatibleReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            IncompatibleHostForVmReplicationIncompatibleReasonEnum::Rpo => "rpo",
            IncompatibleHostForVmReplicationIncompatibleReasonEnum::NetCompression => "netCompression",
            IncompatibleHostForVmReplicationIncompatibleReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        INCOMPATIBLE_HOST_FOR_VM_REPLICATION_INCOMPATIBLE_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| IncompatibleHostForVmReplicationIncompatibleReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for IncompatibleHostForVmReplicationIncompatibleReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for IncompatibleHostForVmReplicationIncompatibleReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<IncompatibleHostForVmReplicationIncompatibleReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(IncompatibleHostForVmReplicationIncompatibleReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for IncompatibleHostForVmReplicationIncompatibleReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for IncompatibleHostForVmReplicationIncompatibleReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a IncompatibleHostForVmReplicationIncompatibleReasonEnum> for &'a str {
    fn from(value: &'a IncompatibleHostForVmReplicationIncompatibleReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for IncompatibleHostForVmReplicationIncompatibleReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static INVALID_DAS_CONFIG_ARGUMENT_ENTRY_FOR_INVALID_ARGUMENT_ENUM_MAP: phf::Map<&'static str, InvalidDasConfigArgumentEntryForInvalidArgumentEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("userHeartbeatDs", InvalidDasConfigArgumentEntryForInvalidArgumentEnum::UserHeartbeatDs),
        ("admissionControl", InvalidDasConfigArgumentEntryForInvalidArgumentEnum::AdmissionControl),
        ("vmConfig", InvalidDasConfigArgumentEntryForInvalidArgumentEnum::VmConfig),
    ],
};

impl InvalidDasConfigArgumentEntryForInvalidArgumentEnum {
    pub fn as_str(&self) -> &str {
        match self {
            InvalidDasConfigArgumentEntryForInvalidArgumentEnum::AdmissionControl => "admissionControl",
            InvalidDasConfigArgumentEntryForInvalidArgumentEnum::UserHeartbeatDs => "userHeartbeatDs",
            InvalidDasConfigArgumentEntryForInvalidArgumentEnum::VmConfig => "vmConfig",
            InvalidDasConfigArgumentEntryForInvalidArgumentEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        INVALID_DAS_CONFIG_ARGUMENT_ENTRY_FOR_INVALID_ARGUMENT_ENUM_MAP.get(s).cloned().unwrap_or_else(|| InvalidDasConfigArgumentEntryForInvalidArgumentEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for InvalidDasConfigArgumentEntryForInvalidArgumentEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for InvalidDasConfigArgumentEntryForInvalidArgumentEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<InvalidDasConfigArgumentEntryForInvalidArgumentEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(InvalidDasConfigArgumentEntryForInvalidArgumentEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for InvalidDasConfigArgumentEntryForInvalidArgumentEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for InvalidDasConfigArgumentEntryForInvalidArgumentEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a InvalidDasConfigArgumentEntryForInvalidArgumentEnum> for &'a str {
    fn from(value: &'a InvalidDasConfigArgumentEntryForInvalidArgumentEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for InvalidDasConfigArgumentEntryForInvalidArgumentEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static INVALID_PROFILE_REFERENCE_HOST_REASON_ENUM_MAP: phf::Map<&'static str, InvalidProfileReferenceHostReasonEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("incompatibleVersion", InvalidProfileReferenceHostReasonEnum::IncompatibleVersion),
        ("missingReferenceHost", InvalidProfileReferenceHostReasonEnum::MissingReferenceHost),
    ],
};

impl InvalidProfileReferenceHostReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            InvalidProfileReferenceHostReasonEnum::IncompatibleVersion => "incompatibleVersion",
            InvalidProfileReferenceHostReasonEnum::MissingReferenceHost => "missingReferenceHost",
            InvalidProfileReferenceHostReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        INVALID_PROFILE_REFERENCE_HOST_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| InvalidProfileReferenceHostReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for InvalidProfileReferenceHostReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for InvalidProfileReferenceHostReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<InvalidProfileReferenceHostReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(InvalidProfileReferenceHostReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for InvalidProfileReferenceHostReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for InvalidProfileReferenceHostReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a InvalidProfileReferenceHostReasonEnum> for &'a str {
    fn from(value: &'a InvalidProfileReferenceHostReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for InvalidProfileReferenceHostReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static LICENSE_ASSIGNMENT_FAILED_REASON_ENUM_MAP: phf::Map<&'static str, LicenseAssignmentFailedReasonEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("inventoryNotManageableByVirtualCenter", LicenseAssignmentFailedReasonEnum::InventoryNotManageableByVirtualCenter),
        ("keyEntityMismatch", LicenseAssignmentFailedReasonEnum::KeyEntityMismatch),
        ("downgradeDisallowed", LicenseAssignmentFailedReasonEnum::DowngradeDisallowed),
        ("hostsUnmanageableByVirtualCenterWithoutLicenseServer", LicenseAssignmentFailedReasonEnum::HostsUnmanageableByVirtualCenterWithoutLicenseServer),
    ],
};

impl LicenseAssignmentFailedReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            LicenseAssignmentFailedReasonEnum::KeyEntityMismatch => "keyEntityMismatch",
            LicenseAssignmentFailedReasonEnum::DowngradeDisallowed => "downgradeDisallowed",
            LicenseAssignmentFailedReasonEnum::InventoryNotManageableByVirtualCenter => "inventoryNotManageableByVirtualCenter",
            LicenseAssignmentFailedReasonEnum::HostsUnmanageableByVirtualCenterWithoutLicenseServer => "hostsUnmanageableByVirtualCenterWithoutLicenseServer",
            LicenseAssignmentFailedReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        LICENSE_ASSIGNMENT_FAILED_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| LicenseAssignmentFailedReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for LicenseAssignmentFailedReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for LicenseAssignmentFailedReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<LicenseAssignmentFailedReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(LicenseAssignmentFailedReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for LicenseAssignmentFailedReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for LicenseAssignmentFailedReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a LicenseAssignmentFailedReasonEnum> for &'a str {
    fn from(value: &'a LicenseAssignmentFailedReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for LicenseAssignmentFailedReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static NOT_SUPPORTED_DEVICE_FOR_FT_DEVICE_TYPE_ENUM_MAP: phf::Map<&'static str, NotSupportedDeviceForFtDeviceTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("virtualVmxnet3", NotSupportedDeviceForFtDeviceTypeEnum::VirtualVmxnet3),
        ("paraVirtualSCSIController", NotSupportedDeviceForFtDeviceTypeEnum::ParaVirtualScsiController),
    ],
};

impl NotSupportedDeviceForFtDeviceTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            NotSupportedDeviceForFtDeviceTypeEnum::VirtualVmxnet3 => "virtualVmxnet3",
            NotSupportedDeviceForFtDeviceTypeEnum::ParaVirtualScsiController => "paraVirtualSCSIController",
            NotSupportedDeviceForFtDeviceTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        NOT_SUPPORTED_DEVICE_FOR_FT_DEVICE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| NotSupportedDeviceForFtDeviceTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for NotSupportedDeviceForFtDeviceTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for NotSupportedDeviceForFtDeviceTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<NotSupportedDeviceForFtDeviceTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(NotSupportedDeviceForFtDeviceTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for NotSupportedDeviceForFtDeviceTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for NotSupportedDeviceForFtDeviceTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a NotSupportedDeviceForFtDeviceTypeEnum> for &'a str {
    fn from(value: &'a NotSupportedDeviceForFtDeviceTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for NotSupportedDeviceForFtDeviceTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static NUM_VIRTUAL_CPUS_INCOMPATIBLE_REASON_ENUM_MAP: phf::Map<&'static str, NumVirtualCpusIncompatibleReasonEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("recordReplay", NumVirtualCpusIncompatibleReasonEnum::RecordReplay),
        ("faultTolerance", NumVirtualCpusIncompatibleReasonEnum::FaultTolerance),
    ],
};

impl NumVirtualCpusIncompatibleReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            NumVirtualCpusIncompatibleReasonEnum::RecordReplay => "recordReplay",
            NumVirtualCpusIncompatibleReasonEnum::FaultTolerance => "faultTolerance",
            NumVirtualCpusIncompatibleReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        NUM_VIRTUAL_CPUS_INCOMPATIBLE_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| NumVirtualCpusIncompatibleReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for NumVirtualCpusIncompatibleReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for NumVirtualCpusIncompatibleReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<NumVirtualCpusIncompatibleReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(NumVirtualCpusIncompatibleReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for NumVirtualCpusIncompatibleReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for NumVirtualCpusIncompatibleReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a NumVirtualCpusIncompatibleReasonEnum> for &'a str {
    fn from(value: &'a NumVirtualCpusIncompatibleReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for NumVirtualCpusIncompatibleReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static QUARANTINE_MODE_FAULT_FAULT_TYPE_ENUM_MAP: phf::Map<&'static str, QuarantineModeFaultFaultTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("CorrectionDisallowed", QuarantineModeFaultFaultTypeEnum::CorrectionDisallowed),
        ("CorrectionImpact", QuarantineModeFaultFaultTypeEnum::CorrectionImpact),
        ("NoCompatibleNonQuarantinedHost", QuarantineModeFaultFaultTypeEnum::NoCompatibleNonQuarantinedHost),
    ],
};

impl QuarantineModeFaultFaultTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            QuarantineModeFaultFaultTypeEnum::NoCompatibleNonQuarantinedHost => "NoCompatibleNonQuarantinedHost",
            QuarantineModeFaultFaultTypeEnum::CorrectionDisallowed => "CorrectionDisallowed",
            QuarantineModeFaultFaultTypeEnum::CorrectionImpact => "CorrectionImpact",
            QuarantineModeFaultFaultTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        QUARANTINE_MODE_FAULT_FAULT_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| QuarantineModeFaultFaultTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for QuarantineModeFaultFaultTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for QuarantineModeFaultFaultTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<QuarantineModeFaultFaultTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(QuarantineModeFaultFaultTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for QuarantineModeFaultFaultTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for QuarantineModeFaultFaultTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a QuarantineModeFaultFaultTypeEnum> for &'a str {
    fn from(value: &'a QuarantineModeFaultFaultTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for QuarantineModeFaultFaultTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static REPLICATION_DISK_CONFIG_FAULT_REASON_FOR_FAULT_ENUM_MAP: phf::Map<&'static str, ReplicationDiskConfigFaultReasonForFaultEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (2, 3),
        (1, 0),
    ],
    entries: &[
        ("invalidDiskKey", ReplicationDiskConfigFaultReasonForFaultEnum::InvalidDiskKey),
        ("reconfigureDiskReplicationIdNotAllowed", ReplicationDiskConfigFaultReasonForFaultEnum::ReconfigureDiskReplicationIdNotAllowed),
        ("diskTypeNotSupported", ReplicationDiskConfigFaultReasonForFaultEnum::DiskTypeNotSupported),
        ("invalidPersistentFilePath", ReplicationDiskConfigFaultReasonForFaultEnum::InvalidPersistentFilePath),
        ("duplicateDiskReplicationId", ReplicationDiskConfigFaultReasonForFaultEnum::DuplicateDiskReplicationId),
        ("diskNotFound", ReplicationDiskConfigFaultReasonForFaultEnum::DiskNotFound),
        ("invalidDiskReplicationId", ReplicationDiskConfigFaultReasonForFaultEnum::InvalidDiskReplicationId),
    ],
};

impl ReplicationDiskConfigFaultReasonForFaultEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ReplicationDiskConfigFaultReasonForFaultEnum::DiskNotFound => "diskNotFound",
            ReplicationDiskConfigFaultReasonForFaultEnum::DiskTypeNotSupported => "diskTypeNotSupported",
            ReplicationDiskConfigFaultReasonForFaultEnum::InvalidDiskKey => "invalidDiskKey",
            ReplicationDiskConfigFaultReasonForFaultEnum::InvalidDiskReplicationId => "invalidDiskReplicationId",
            ReplicationDiskConfigFaultReasonForFaultEnum::DuplicateDiskReplicationId => "duplicateDiskReplicationId",
            ReplicationDiskConfigFaultReasonForFaultEnum::InvalidPersistentFilePath => "invalidPersistentFilePath",
            ReplicationDiskConfigFaultReasonForFaultEnum::ReconfigureDiskReplicationIdNotAllowed => "reconfigureDiskReplicationIdNotAllowed",
            ReplicationDiskConfigFaultReasonForFaultEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        REPLICATION_DISK_CONFIG_FAULT_REASON_FOR_FAULT_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ReplicationDiskConfigFaultReasonForFaultEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ReplicationDiskConfigFaultReasonForFaultEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ReplicationDiskConfigFaultReasonForFaultEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ReplicationDiskConfigFaultReasonForFaultEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ReplicationDiskConfigFaultReasonForFaultEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ReplicationDiskConfigFaultReasonForFaultEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ReplicationDiskConfigFaultReasonForFaultEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ReplicationDiskConfigFaultReasonForFaultEnum> for &'a str {
    fn from(value: &'a ReplicationDiskConfigFaultReasonForFaultEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ReplicationDiskConfigFaultReasonForFaultEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static REPLICATION_VM_CONFIG_FAULT_REASON_FOR_FAULT_ENUM_MAP: phf::Map<&'static str, ReplicationVmConfigFaultReasonForFaultEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 1),
        (11, 8),
        (16, 7),
        (12, 0),
    ],
    entries: &[
        ("invalidPriorConfiguration", ReplicationVmConfigFaultReasonForFaultEnum::InvalidPriorConfiguration),
        ("invalidGenerationNumber", ReplicationVmConfigFaultReasonForFaultEnum::InvalidGenerationNumber),
        ("reconfigureVmReplicationIdNotAllowed", ReplicationVmConfigFaultReasonForFaultEnum::ReconfigureVmReplicationIdNotAllowed),
        ("cannotRetrieveVmReplicationConfiguration", ReplicationVmConfigFaultReasonForFaultEnum::CannotRetrieveVmReplicationConfiguration),
        ("staleGenerationNumber", ReplicationVmConfigFaultReasonForFaultEnum::StaleGenerationNumber),
        ("replicationNotEnabled", ReplicationVmConfigFaultReasonForFaultEnum::ReplicationNotEnabled),
        ("invalidVmReplicationId", ReplicationVmConfigFaultReasonForFaultEnum::InvalidVmReplicationId),
        ("encryptedVm", ReplicationVmConfigFaultReasonForFaultEnum::EncryptedVm),
        ("replicationConfigurationFailed", ReplicationVmConfigFaultReasonForFaultEnum::ReplicationConfigurationFailed),
        ("invalidThumbprint", ReplicationVmConfigFaultReasonForFaultEnum::InvalidThumbprint),
        ("incompatibleHwVersion", ReplicationVmConfigFaultReasonForFaultEnum::IncompatibleHwVersion),
        ("incompatibleDevice", ReplicationVmConfigFaultReasonForFaultEnum::IncompatibleDevice),
        ("invalidExtraVmOptions", ReplicationVmConfigFaultReasonForFaultEnum::InvalidExtraVmOptions),
        ("outOfBoundsRpoValue", ReplicationVmConfigFaultReasonForFaultEnum::OutOfBoundsRpoValue),
        ("replicationAlreadyEnabled", ReplicationVmConfigFaultReasonForFaultEnum::ReplicationAlreadyEnabled),
        ("invalidDestinationPort", ReplicationVmConfigFaultReasonForFaultEnum::InvalidDestinationPort),
        ("invalidDestinationIpAddress", ReplicationVmConfigFaultReasonForFaultEnum::InvalidDestinationIpAddress),
    ],
};

impl ReplicationVmConfigFaultReasonForFaultEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ReplicationVmConfigFaultReasonForFaultEnum::IncompatibleHwVersion => "incompatibleHwVersion",
            ReplicationVmConfigFaultReasonForFaultEnum::InvalidVmReplicationId => "invalidVmReplicationId",
            ReplicationVmConfigFaultReasonForFaultEnum::InvalidGenerationNumber => "invalidGenerationNumber",
            ReplicationVmConfigFaultReasonForFaultEnum::OutOfBoundsRpoValue => "outOfBoundsRpoValue",
            ReplicationVmConfigFaultReasonForFaultEnum::InvalidDestinationIpAddress => "invalidDestinationIpAddress",
            ReplicationVmConfigFaultReasonForFaultEnum::InvalidDestinationPort => "invalidDestinationPort",
            ReplicationVmConfigFaultReasonForFaultEnum::InvalidExtraVmOptions => "invalidExtraVmOptions",
            ReplicationVmConfigFaultReasonForFaultEnum::StaleGenerationNumber => "staleGenerationNumber",
            ReplicationVmConfigFaultReasonForFaultEnum::ReconfigureVmReplicationIdNotAllowed => "reconfigureVmReplicationIdNotAllowed",
            ReplicationVmConfigFaultReasonForFaultEnum::CannotRetrieveVmReplicationConfiguration => "cannotRetrieveVmReplicationConfiguration",
            ReplicationVmConfigFaultReasonForFaultEnum::ReplicationAlreadyEnabled => "replicationAlreadyEnabled",
            ReplicationVmConfigFaultReasonForFaultEnum::InvalidPriorConfiguration => "invalidPriorConfiguration",
            ReplicationVmConfigFaultReasonForFaultEnum::ReplicationNotEnabled => "replicationNotEnabled",
            ReplicationVmConfigFaultReasonForFaultEnum::ReplicationConfigurationFailed => "replicationConfigurationFailed",
            ReplicationVmConfigFaultReasonForFaultEnum::EncryptedVm => "encryptedVm",
            ReplicationVmConfigFaultReasonForFaultEnum::InvalidThumbprint => "invalidThumbprint",
            ReplicationVmConfigFaultReasonForFaultEnum::IncompatibleDevice => "incompatibleDevice",
            ReplicationVmConfigFaultReasonForFaultEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        REPLICATION_VM_CONFIG_FAULT_REASON_FOR_FAULT_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ReplicationVmConfigFaultReasonForFaultEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ReplicationVmConfigFaultReasonForFaultEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ReplicationVmConfigFaultReasonForFaultEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ReplicationVmConfigFaultReasonForFaultEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ReplicationVmConfigFaultReasonForFaultEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ReplicationVmConfigFaultReasonForFaultEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ReplicationVmConfigFaultReasonForFaultEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ReplicationVmConfigFaultReasonForFaultEnum> for &'a str {
    fn from(value: &'a ReplicationVmConfigFaultReasonForFaultEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ReplicationVmConfigFaultReasonForFaultEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static REPLICATION_VM_FAULT_REASON_FOR_FAULT_ENUM_MAP: phf::Map<&'static str, ReplicationVmFaultReasonForFaultEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
        (0, 2),
    ],
    entries: &[
        ("groupExist", ReplicationVmFaultReasonForFaultEnum::GroupExist),
        ("closeDiskError", ReplicationVmFaultReasonForFaultEnum::CloseDiskError),
        ("poweredOff", ReplicationVmFaultReasonForFaultEnum::PoweredOff),
        ("suspended", ReplicationVmFaultReasonForFaultEnum::Suspended),
        ("offlineReplicating", ReplicationVmFaultReasonForFaultEnum::OfflineReplicating),
        ("notConfigured", ReplicationVmFaultReasonForFaultEnum::NotConfigured),
        ("invalidState", ReplicationVmFaultReasonForFaultEnum::InvalidState),
        ("poweredOn", ReplicationVmFaultReasonForFaultEnum::PoweredOn),
        ("invalidInstanceId", ReplicationVmFaultReasonForFaultEnum::InvalidInstanceId),
    ],
};

impl ReplicationVmFaultReasonForFaultEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ReplicationVmFaultReasonForFaultEnum::NotConfigured => "notConfigured",
            ReplicationVmFaultReasonForFaultEnum::PoweredOff => "poweredOff",
            ReplicationVmFaultReasonForFaultEnum::Suspended => "suspended",
            ReplicationVmFaultReasonForFaultEnum::PoweredOn => "poweredOn",
            ReplicationVmFaultReasonForFaultEnum::OfflineReplicating => "offlineReplicating",
            ReplicationVmFaultReasonForFaultEnum::InvalidState => "invalidState",
            ReplicationVmFaultReasonForFaultEnum::InvalidInstanceId => "invalidInstanceId",
            ReplicationVmFaultReasonForFaultEnum::CloseDiskError => "closeDiskError",
            ReplicationVmFaultReasonForFaultEnum::GroupExist => "groupExist",
            ReplicationVmFaultReasonForFaultEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        REPLICATION_VM_FAULT_REASON_FOR_FAULT_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ReplicationVmFaultReasonForFaultEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ReplicationVmFaultReasonForFaultEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ReplicationVmFaultReasonForFaultEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ReplicationVmFaultReasonForFaultEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ReplicationVmFaultReasonForFaultEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ReplicationVmFaultReasonForFaultEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ReplicationVmFaultReasonForFaultEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ReplicationVmFaultReasonForFaultEnum> for &'a str {
    fn from(value: &'a ReplicationVmFaultReasonForFaultEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ReplicationVmFaultReasonForFaultEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static REPLICATION_VM_IN_PROGRESS_FAULT_ACTIVITY_ENUM_MAP: phf::Map<&'static str, ReplicationVmInProgressFaultActivityEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("delta", ReplicationVmInProgressFaultActivityEnum::Delta),
        ("fullSync", ReplicationVmInProgressFaultActivityEnum::FullSync),
    ],
};

impl ReplicationVmInProgressFaultActivityEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ReplicationVmInProgressFaultActivityEnum::FullSync => "fullSync",
            ReplicationVmInProgressFaultActivityEnum::Delta => "delta",
            ReplicationVmInProgressFaultActivityEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        REPLICATION_VM_IN_PROGRESS_FAULT_ACTIVITY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ReplicationVmInProgressFaultActivityEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ReplicationVmInProgressFaultActivityEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ReplicationVmInProgressFaultActivityEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ReplicationVmInProgressFaultActivityEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ReplicationVmInProgressFaultActivityEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ReplicationVmInProgressFaultActivityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ReplicationVmInProgressFaultActivityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ReplicationVmInProgressFaultActivityEnum> for &'a str {
    fn from(value: &'a ReplicationVmInProgressFaultActivityEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ReplicationVmInProgressFaultActivityEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static THIRD_PARTY_LICENSE_ASSIGNMENT_FAILED_REASON_ENUM_MAP: phf::Map<&'static str, ThirdPartyLicenseAssignmentFailedReasonEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("licenseAssignmentFailed", ThirdPartyLicenseAssignmentFailedReasonEnum::LicenseAssignmentFailed),
        ("moduleNotInstalled", ThirdPartyLicenseAssignmentFailedReasonEnum::ModuleNotInstalled),
    ],
};

impl ThirdPartyLicenseAssignmentFailedReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ThirdPartyLicenseAssignmentFailedReasonEnum::LicenseAssignmentFailed => "licenseAssignmentFailed",
            ThirdPartyLicenseAssignmentFailedReasonEnum::ModuleNotInstalled => "moduleNotInstalled",
            ThirdPartyLicenseAssignmentFailedReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        THIRD_PARTY_LICENSE_ASSIGNMENT_FAILED_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ThirdPartyLicenseAssignmentFailedReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ThirdPartyLicenseAssignmentFailedReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ThirdPartyLicenseAssignmentFailedReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ThirdPartyLicenseAssignmentFailedReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ThirdPartyLicenseAssignmentFailedReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ThirdPartyLicenseAssignmentFailedReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ThirdPartyLicenseAssignmentFailedReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ThirdPartyLicenseAssignmentFailedReasonEnum> for &'a str {
    fn from(value: &'a ThirdPartyLicenseAssignmentFailedReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ThirdPartyLicenseAssignmentFailedReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static V_FLASH_MODULE_NOT_SUPPORTED_REASON_ENUM_MAP: phf::Map<&'static str, VFlashModuleNotSupportedReasonEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("CacheConsistencyTypeNotSupported", VFlashModuleNotSupportedReasonEnum::CacheConsistencyTypeNotSupported),
        ("CacheBlockSizeNotSupported", VFlashModuleNotSupportedReasonEnum::CacheBlockSizeNotSupported),
        ("DiskSizeNotSupported", VFlashModuleNotSupportedReasonEnum::DiskSizeNotSupported),
        ("CacheModeNotSupported", VFlashModuleNotSupportedReasonEnum::CacheModeNotSupported),
        ("CacheReservationNotSupported", VFlashModuleNotSupportedReasonEnum::CacheReservationNotSupported),
    ],
};

impl VFlashModuleNotSupportedReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VFlashModuleNotSupportedReasonEnum::CacheModeNotSupported => "CacheModeNotSupported",
            VFlashModuleNotSupportedReasonEnum::CacheConsistencyTypeNotSupported => "CacheConsistencyTypeNotSupported",
            VFlashModuleNotSupportedReasonEnum::CacheBlockSizeNotSupported => "CacheBlockSizeNotSupported",
            VFlashModuleNotSupportedReasonEnum::CacheReservationNotSupported => "CacheReservationNotSupported",
            VFlashModuleNotSupportedReasonEnum::DiskSizeNotSupported => "DiskSizeNotSupported",
            VFlashModuleNotSupportedReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        V_FLASH_MODULE_NOT_SUPPORTED_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VFlashModuleNotSupportedReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VFlashModuleNotSupportedReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VFlashModuleNotSupportedReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VFlashModuleNotSupportedReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VFlashModuleNotSupportedReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VFlashModuleNotSupportedReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VFlashModuleNotSupportedReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VFlashModuleNotSupportedReasonEnum> for &'a str {
    fn from(value: &'a VFlashModuleNotSupportedReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VFlashModuleNotSupportedReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VM_FAULT_TOLERANCE_CONFIG_ISSUE_REASON_FOR_ISSUE_ENUM_MAP: phf::Map<&'static str, VmFaultToleranceConfigIssueReasonForIssueEnum> = ::phf::Map {
    key: 12213676231523076107,
    disps: &[
        (0, 0),
        (1, 0),
        (0, 20),
        (2, 31),
        (3, 30),
        (2, 10),
        (9, 19),
        (3, 30),
    ],
    entries: &[
        ("tooMuchMemory", VmFaultToleranceConfigIssueReasonForIssueEnum::TooMuchMemory),
        ("hasNestedHVConfiguration", VmFaultToleranceConfigIssueReasonForIssueEnum::HasNestedHvConfiguration),
        ("tooManyVCPUs", VmFaultToleranceConfigIssueReasonForIssueEnum::TooManyVcpUs),
        ("thinDisk", VmFaultToleranceConfigIssueReasonForIssueEnum::ThinDisk),
        ("cpuHvDisabled", VmFaultToleranceConfigIssueReasonForIssueEnum::CpuHvDisabled),
        ("recordReplayNotSupported", VmFaultToleranceConfigIssueReasonForIssueEnum::RecordReplayNotSupported),
        ("hasLinkedCloneDisk", VmFaultToleranceConfigIssueReasonForIssueEnum::HasLinkedCloneDisk),
        ("noHostGroupConfigured", VmFaultToleranceConfigIssueReasonForIssueEnum::NoHostGroupConfigured),
        ("moreThanOneSecondary", VmFaultToleranceConfigIssueReasonForIssueEnum::MoreThanOneSecondary),
        ("haAgentIssue", VmFaultToleranceConfigIssueReasonForIssueEnum::HaAgentIssue),
        ("missingVMotionNic", VmFaultToleranceConfigIssueReasonForIssueEnum::MissingVMotionNic),
        ("hostInactive", VmFaultToleranceConfigIssueReasonForIssueEnum::HostInactive),
        ("video3dEnabled", VmFaultToleranceConfigIssueReasonForIssueEnum::Video3DEnabled),
        ("vMotionNotLicensed", VmFaultToleranceConfigIssueReasonForIssueEnum::VMotionNotLicensed),
        ("templateVm", VmFaultToleranceConfigIssueReasonForIssueEnum::TemplateVm),
        ("unsupportedSPBM", VmFaultToleranceConfigIssueReasonForIssueEnum::UnsupportedSpbm),
        ("unsupportedProduct", VmFaultToleranceConfigIssueReasonForIssueEnum::UnsupportedProduct),
        ("hasEFIFirmware", VmFaultToleranceConfigIssueReasonForIssueEnum::HasEfiFirmware),
        ("ftSecondaryVm", VmFaultToleranceConfigIssueReasonForIssueEnum::FtSecondaryVm),
        ("hasUnsupportedDisk", VmFaultToleranceConfigIssueReasonForIssueEnum::HasUnsupportedDisk),
        ("missingFTLoggingNic", VmFaultToleranceConfigIssueReasonForIssueEnum::MissingFtLoggingNic),
        ("unsupportedPMemHAFailOver", VmFaultToleranceConfigIssueReasonForIssueEnum::UnsupportedPMemHaFailOver),
        ("hasLocalDisk", VmFaultToleranceConfigIssueReasonForIssueEnum::HasLocalDisk),
        ("haNotEnabled", VmFaultToleranceConfigIssueReasonForIssueEnum::HaNotEnabled),
        ("ftUnsupportedProduct", VmFaultToleranceConfigIssueReasonForIssueEnum::FtUnsupportedProduct),
        ("ftUnsupportedHardware", VmFaultToleranceConfigIssueReasonForIssueEnum::FtUnsupportedHardware),
        ("verifySSLCertificateFlagNotSet", VmFaultToleranceConfigIssueReasonForIssueEnum::VerifySslCertificateFlagNotSet),
        ("esxAgentVm", VmFaultToleranceConfigIssueReasonForIssueEnum::EsxAgentVm),
        ("ftNotLicensed", VmFaultToleranceConfigIssueReasonForIssueEnum::FtNotLicensed),
        ("cpuHvUnsupported", VmFaultToleranceConfigIssueReasonForIssueEnum::CpuHvUnsupported),
        ("ftMetroClusterNotEditable", VmFaultToleranceConfigIssueReasonForIssueEnum::FtMetroClusterNotEditable),
        ("insufficientBandwidth", VmFaultToleranceConfigIssueReasonForIssueEnum::InsufficientBandwidth),
        ("hasVFlashConfiguration", VmFaultToleranceConfigIssueReasonForIssueEnum::HasVFlashConfiguration),
        ("hasSnapshots", VmFaultToleranceConfigIssueReasonForIssueEnum::HasSnapshots),
        ("noConfig", VmFaultToleranceConfigIssueReasonForIssueEnum::NoConfig),
        ("replayNotSupported", VmFaultToleranceConfigIssueReasonForIssueEnum::ReplayNotSupported),
        ("unsupportedEncryptedDisk", VmFaultToleranceConfigIssueReasonForIssueEnum::UnsupportedEncryptedDisk),
        ("multipleVCPU", VmFaultToleranceConfigIssueReasonForIssueEnum::MultipleVcpu),
        ("cpuHwmmuUnsupported", VmFaultToleranceConfigIssueReasonForIssueEnum::CpuHwmmuUnsupported),
    ],
};

impl VmFaultToleranceConfigIssueReasonForIssueEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VmFaultToleranceConfigIssueReasonForIssueEnum::HaNotEnabled => "haNotEnabled",
            VmFaultToleranceConfigIssueReasonForIssueEnum::MoreThanOneSecondary => "moreThanOneSecondary",
            VmFaultToleranceConfigIssueReasonForIssueEnum::RecordReplayNotSupported => "recordReplayNotSupported",
            VmFaultToleranceConfigIssueReasonForIssueEnum::ReplayNotSupported => "replayNotSupported",
            VmFaultToleranceConfigIssueReasonForIssueEnum::TemplateVm => "templateVm",
            VmFaultToleranceConfigIssueReasonForIssueEnum::MultipleVcpu => "multipleVCPU",
            VmFaultToleranceConfigIssueReasonForIssueEnum::HostInactive => "hostInactive",
            VmFaultToleranceConfigIssueReasonForIssueEnum::FtUnsupportedHardware => "ftUnsupportedHardware",
            VmFaultToleranceConfigIssueReasonForIssueEnum::FtUnsupportedProduct => "ftUnsupportedProduct",
            VmFaultToleranceConfigIssueReasonForIssueEnum::MissingVMotionNic => "missingVMotionNic",
            VmFaultToleranceConfigIssueReasonForIssueEnum::MissingFtLoggingNic => "missingFTLoggingNic",
            VmFaultToleranceConfigIssueReasonForIssueEnum::ThinDisk => "thinDisk",
            VmFaultToleranceConfigIssueReasonForIssueEnum::VerifySslCertificateFlagNotSet => "verifySSLCertificateFlagNotSet",
            VmFaultToleranceConfigIssueReasonForIssueEnum::HasSnapshots => "hasSnapshots",
            VmFaultToleranceConfigIssueReasonForIssueEnum::NoConfig => "noConfig",
            VmFaultToleranceConfigIssueReasonForIssueEnum::FtSecondaryVm => "ftSecondaryVm",
            VmFaultToleranceConfigIssueReasonForIssueEnum::HasLocalDisk => "hasLocalDisk",
            VmFaultToleranceConfigIssueReasonForIssueEnum::EsxAgentVm => "esxAgentVm",
            VmFaultToleranceConfigIssueReasonForIssueEnum::Video3DEnabled => "video3dEnabled",
            VmFaultToleranceConfigIssueReasonForIssueEnum::HasUnsupportedDisk => "hasUnsupportedDisk",
            VmFaultToleranceConfigIssueReasonForIssueEnum::InsufficientBandwidth => "insufficientBandwidth",
            VmFaultToleranceConfigIssueReasonForIssueEnum::HasNestedHvConfiguration => "hasNestedHVConfiguration",
            VmFaultToleranceConfigIssueReasonForIssueEnum::HasVFlashConfiguration => "hasVFlashConfiguration",
            VmFaultToleranceConfigIssueReasonForIssueEnum::UnsupportedProduct => "unsupportedProduct",
            VmFaultToleranceConfigIssueReasonForIssueEnum::CpuHvUnsupported => "cpuHvUnsupported",
            VmFaultToleranceConfigIssueReasonForIssueEnum::CpuHwmmuUnsupported => "cpuHwmmuUnsupported",
            VmFaultToleranceConfigIssueReasonForIssueEnum::CpuHvDisabled => "cpuHvDisabled",
            VmFaultToleranceConfigIssueReasonForIssueEnum::HasEfiFirmware => "hasEFIFirmware",
            VmFaultToleranceConfigIssueReasonForIssueEnum::TooManyVcpUs => "tooManyVCPUs",
            VmFaultToleranceConfigIssueReasonForIssueEnum::TooMuchMemory => "tooMuchMemory",
            VmFaultToleranceConfigIssueReasonForIssueEnum::VMotionNotLicensed => "vMotionNotLicensed",
            VmFaultToleranceConfigIssueReasonForIssueEnum::FtNotLicensed => "ftNotLicensed",
            VmFaultToleranceConfigIssueReasonForIssueEnum::HaAgentIssue => "haAgentIssue",
            VmFaultToleranceConfigIssueReasonForIssueEnum::UnsupportedSpbm => "unsupportedSPBM",
            VmFaultToleranceConfigIssueReasonForIssueEnum::HasLinkedCloneDisk => "hasLinkedCloneDisk",
            VmFaultToleranceConfigIssueReasonForIssueEnum::UnsupportedPMemHaFailOver => "unsupportedPMemHAFailOver",
            VmFaultToleranceConfigIssueReasonForIssueEnum::UnsupportedEncryptedDisk => "unsupportedEncryptedDisk",
            VmFaultToleranceConfigIssueReasonForIssueEnum::FtMetroClusterNotEditable => "ftMetroClusterNotEditable",
            VmFaultToleranceConfigIssueReasonForIssueEnum::NoHostGroupConfigured => "noHostGroupConfigured",
            VmFaultToleranceConfigIssueReasonForIssueEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VM_FAULT_TOLERANCE_CONFIG_ISSUE_REASON_FOR_ISSUE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VmFaultToleranceConfigIssueReasonForIssueEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VmFaultToleranceConfigIssueReasonForIssueEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VmFaultToleranceConfigIssueReasonForIssueEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VmFaultToleranceConfigIssueReasonForIssueEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VmFaultToleranceConfigIssueReasonForIssueEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VmFaultToleranceConfigIssueReasonForIssueEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VmFaultToleranceConfigIssueReasonForIssueEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VmFaultToleranceConfigIssueReasonForIssueEnum> for &'a str {
    fn from(value: &'a VmFaultToleranceConfigIssueReasonForIssueEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VmFaultToleranceConfigIssueReasonForIssueEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VM_FAULT_TOLERANCE_INVALID_FILE_BACKING_DEVICE_TYPE_ENUM_MAP: phf::Map<&'static str, VmFaultToleranceInvalidFileBackingDeviceTypeEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (3, 0),
    ],
    entries: &[
        ("virtualSerialPort", VmFaultToleranceInvalidFileBackingDeviceTypeEnum::VirtualSerialPort),
        ("virtualParallelPort", VmFaultToleranceInvalidFileBackingDeviceTypeEnum::VirtualParallelPort),
        ("virtualCdrom", VmFaultToleranceInvalidFileBackingDeviceTypeEnum::VirtualCdrom),
        ("virtualFloppy", VmFaultToleranceInvalidFileBackingDeviceTypeEnum::VirtualFloppy),
        ("virtualDisk", VmFaultToleranceInvalidFileBackingDeviceTypeEnum::VirtualDisk),
    ],
};

impl VmFaultToleranceInvalidFileBackingDeviceTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VmFaultToleranceInvalidFileBackingDeviceTypeEnum::VirtualFloppy => "virtualFloppy",
            VmFaultToleranceInvalidFileBackingDeviceTypeEnum::VirtualCdrom => "virtualCdrom",
            VmFaultToleranceInvalidFileBackingDeviceTypeEnum::VirtualSerialPort => "virtualSerialPort",
            VmFaultToleranceInvalidFileBackingDeviceTypeEnum::VirtualParallelPort => "virtualParallelPort",
            VmFaultToleranceInvalidFileBackingDeviceTypeEnum::VirtualDisk => "virtualDisk",
            VmFaultToleranceInvalidFileBackingDeviceTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VM_FAULT_TOLERANCE_INVALID_FILE_BACKING_DEVICE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VmFaultToleranceInvalidFileBackingDeviceTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VmFaultToleranceInvalidFileBackingDeviceTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VmFaultToleranceInvalidFileBackingDeviceTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VmFaultToleranceInvalidFileBackingDeviceTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VmFaultToleranceInvalidFileBackingDeviceTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VmFaultToleranceInvalidFileBackingDeviceTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VmFaultToleranceInvalidFileBackingDeviceTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VmFaultToleranceInvalidFileBackingDeviceTypeEnum> for &'a str {
    fn from(value: &'a VmFaultToleranceInvalidFileBackingDeviceTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VmFaultToleranceInvalidFileBackingDeviceTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static WILL_LOSE_HA_PROTECTION_RESOLUTION_ENUM_MAP: phf::Map<&'static str, WillLoseHaProtectionResolutionEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("relocate", WillLoseHaProtectionResolutionEnum::Relocate),
        ("svmotion", WillLoseHaProtectionResolutionEnum::Svmotion),
    ],
};

impl WillLoseHaProtectionResolutionEnum {
    pub fn as_str(&self) -> &str {
        match self {
            WillLoseHaProtectionResolutionEnum::Svmotion => "svmotion",
            WillLoseHaProtectionResolutionEnum::Relocate => "relocate",
            WillLoseHaProtectionResolutionEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        WILL_LOSE_HA_PROTECTION_RESOLUTION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| WillLoseHaProtectionResolutionEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for WillLoseHaProtectionResolutionEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for WillLoseHaProtectionResolutionEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<WillLoseHaProtectionResolutionEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(WillLoseHaProtectionResolutionEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for WillLoseHaProtectionResolutionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for WillLoseHaProtectionResolutionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a WillLoseHaProtectionResolutionEnum> for &'a str {
    fn from(value: &'a WillLoseHaProtectionResolutionEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for WillLoseHaProtectionResolutionEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_ACTIVE_DIRECTORY_AUTHENTICATION_CERTIFICATE_DIGEST_ENUM_MAP: phf::Map<&'static str, HostActiveDirectoryAuthenticationCertificateDigestEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("SHA1", HostActiveDirectoryAuthenticationCertificateDigestEnum::Sha1),
    ],
};

impl HostActiveDirectoryAuthenticationCertificateDigestEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostActiveDirectoryAuthenticationCertificateDigestEnum::Sha1 => "SHA1",
            HostActiveDirectoryAuthenticationCertificateDigestEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_ACTIVE_DIRECTORY_AUTHENTICATION_CERTIFICATE_DIGEST_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostActiveDirectoryAuthenticationCertificateDigestEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostActiveDirectoryAuthenticationCertificateDigestEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostActiveDirectoryAuthenticationCertificateDigestEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostActiveDirectoryAuthenticationCertificateDigestEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostActiveDirectoryAuthenticationCertificateDigestEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostActiveDirectoryAuthenticationCertificateDigestEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostActiveDirectoryAuthenticationCertificateDigestEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostActiveDirectoryAuthenticationCertificateDigestEnum> for &'a str {
    fn from(value: &'a HostActiveDirectoryAuthenticationCertificateDigestEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostActiveDirectoryAuthenticationCertificateDigestEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_ACTIVE_DIRECTORY_INFO_DOMAIN_MEMBERSHIP_STATUS_ENUM_MAP: phf::Map<&'static str, HostActiveDirectoryInfoDomainMembershipStatusEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (4, 0),
        (0, 4),
    ],
    entries: &[
        ("otherProblem", HostActiveDirectoryInfoDomainMembershipStatusEnum::OtherProblem),
        ("inconsistentTrust", HostActiveDirectoryInfoDomainMembershipStatusEnum::InconsistentTrust),
        ("ok", HostActiveDirectoryInfoDomainMembershipStatusEnum::Ok),
        ("noServers", HostActiveDirectoryInfoDomainMembershipStatusEnum::NoServers),
        ("unknown", HostActiveDirectoryInfoDomainMembershipStatusEnum::Unknown),
        ("clientTrustBroken", HostActiveDirectoryInfoDomainMembershipStatusEnum::ClientTrustBroken),
        ("serverTrustBroken", HostActiveDirectoryInfoDomainMembershipStatusEnum::ServerTrustBroken),
    ],
};

impl HostActiveDirectoryInfoDomainMembershipStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostActiveDirectoryInfoDomainMembershipStatusEnum::Unknown => "unknown",
            HostActiveDirectoryInfoDomainMembershipStatusEnum::Ok => "ok",
            HostActiveDirectoryInfoDomainMembershipStatusEnum::NoServers => "noServers",
            HostActiveDirectoryInfoDomainMembershipStatusEnum::ClientTrustBroken => "clientTrustBroken",
            HostActiveDirectoryInfoDomainMembershipStatusEnum::ServerTrustBroken => "serverTrustBroken",
            HostActiveDirectoryInfoDomainMembershipStatusEnum::InconsistentTrust => "inconsistentTrust",
            HostActiveDirectoryInfoDomainMembershipStatusEnum::OtherProblem => "otherProblem",
            HostActiveDirectoryInfoDomainMembershipStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_ACTIVE_DIRECTORY_INFO_DOMAIN_MEMBERSHIP_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostActiveDirectoryInfoDomainMembershipStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostActiveDirectoryInfoDomainMembershipStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostActiveDirectoryInfoDomainMembershipStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostActiveDirectoryInfoDomainMembershipStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostActiveDirectoryInfoDomainMembershipStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostActiveDirectoryInfoDomainMembershipStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostActiveDirectoryInfoDomainMembershipStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostActiveDirectoryInfoDomainMembershipStatusEnum> for &'a str {
    fn from(value: &'a HostActiveDirectoryInfoDomainMembershipStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostActiveDirectoryInfoDomainMembershipStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static AUTO_START_ACTION_ENUM_MAP: phf::Map<&'static str, AutoStartActionEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (4, 0),
        (0, 5),
    ],
    entries: &[
        ("suspend", AutoStartActionEnum::Suspend),
        ("none", AutoStartActionEnum::None),
        ("systemDefault", AutoStartActionEnum::SystemDefault),
        ("guestShutdown", AutoStartActionEnum::GuestShutdown),
        ("powerOn", AutoStartActionEnum::PowerOn),
        ("powerOff", AutoStartActionEnum::PowerOff),
    ],
};

impl AutoStartActionEnum {
    pub fn as_str(&self) -> &str {
        match self {
            AutoStartActionEnum::None => "none",
            AutoStartActionEnum::SystemDefault => "systemDefault",
            AutoStartActionEnum::PowerOn => "powerOn",
            AutoStartActionEnum::PowerOff => "powerOff",
            AutoStartActionEnum::GuestShutdown => "guestShutdown",
            AutoStartActionEnum::Suspend => "suspend",
            AutoStartActionEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        AUTO_START_ACTION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| AutoStartActionEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for AutoStartActionEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for AutoStartActionEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<AutoStartActionEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(AutoStartActionEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for AutoStartActionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for AutoStartActionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a AutoStartActionEnum> for &'a str {
    fn from(value: &'a AutoStartActionEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for AutoStartActionEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static AUTO_START_WAIT_HEARTBEAT_SETTING_ENUM_MAP: phf::Map<&'static str, AutoStartWaitHeartbeatSettingEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("no", AutoStartWaitHeartbeatSettingEnum::No),
        ("yes", AutoStartWaitHeartbeatSettingEnum::Yes),
        ("systemDefault", AutoStartWaitHeartbeatSettingEnum::SystemDefault),
    ],
};

impl AutoStartWaitHeartbeatSettingEnum {
    pub fn as_str(&self) -> &str {
        match self {
            AutoStartWaitHeartbeatSettingEnum::Yes => "yes",
            AutoStartWaitHeartbeatSettingEnum::No => "no",
            AutoStartWaitHeartbeatSettingEnum::SystemDefault => "systemDefault",
            AutoStartWaitHeartbeatSettingEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        AUTO_START_WAIT_HEARTBEAT_SETTING_ENUM_MAP.get(s).cloned().unwrap_or_else(|| AutoStartWaitHeartbeatSettingEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for AutoStartWaitHeartbeatSettingEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for AutoStartWaitHeartbeatSettingEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<AutoStartWaitHeartbeatSettingEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(AutoStartWaitHeartbeatSettingEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for AutoStartWaitHeartbeatSettingEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for AutoStartWaitHeartbeatSettingEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a AutoStartWaitHeartbeatSettingEnum> for &'a str {
    fn from(value: &'a AutoStartWaitHeartbeatSettingEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for AutoStartWaitHeartbeatSettingEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_BIOS_INFO_FIRMWARE_TYPE_ENUM_MAP: phf::Map<&'static str, HostBiosInfoFirmwareTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("BIOS", HostBiosInfoFirmwareTypeEnum::Bios),
        ("UEFI", HostBiosInfoFirmwareTypeEnum::Uefi),
    ],
};

impl HostBiosInfoFirmwareTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostBiosInfoFirmwareTypeEnum::Bios => "BIOS",
            HostBiosInfoFirmwareTypeEnum::Uefi => "UEFI",
            HostBiosInfoFirmwareTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_BIOS_INFO_FIRMWARE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostBiosInfoFirmwareTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostBiosInfoFirmwareTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostBiosInfoFirmwareTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostBiosInfoFirmwareTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostBiosInfoFirmwareTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostBiosInfoFirmwareTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostBiosInfoFirmwareTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostBiosInfoFirmwareTypeEnum> for &'a str {
    fn from(value: &'a HostBiosInfoFirmwareTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostBiosInfoFirmwareTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_CAPABILITY_FT_UNSUPPORTED_REASON_ENUM_MAP: phf::Map<&'static str, HostCapabilityFtUnsupportedReasonEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (3, 7),
        (6, 0),
    ],
    entries: &[
        ("ftNotLicensed", HostCapabilityFtUnsupportedReasonEnum::FtNotLicensed),
        ("haAgentIssue", HostCapabilityFtUnsupportedReasonEnum::HaAgentIssue),
        ("unsupportedProduct", HostCapabilityFtUnsupportedReasonEnum::UnsupportedProduct),
        ("missingVMotionNic", HostCapabilityFtUnsupportedReasonEnum::MissingVMotionNic),
        ("cpuHwmmuUnsupported", HostCapabilityFtUnsupportedReasonEnum::CpuHwmmuUnsupported),
        ("vMotionNotLicensed", HostCapabilityFtUnsupportedReasonEnum::VMotionNotLicensed),
        ("cpuHvUnsupported", HostCapabilityFtUnsupportedReasonEnum::CpuHvUnsupported),
        ("missingFTLoggingNic", HostCapabilityFtUnsupportedReasonEnum::MissingFtLoggingNic),
        ("cpuHvDisabled", HostCapabilityFtUnsupportedReasonEnum::CpuHvDisabled),
    ],
};

impl HostCapabilityFtUnsupportedReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostCapabilityFtUnsupportedReasonEnum::VMotionNotLicensed => "vMotionNotLicensed",
            HostCapabilityFtUnsupportedReasonEnum::MissingVMotionNic => "missingVMotionNic",
            HostCapabilityFtUnsupportedReasonEnum::MissingFtLoggingNic => "missingFTLoggingNic",
            HostCapabilityFtUnsupportedReasonEnum::FtNotLicensed => "ftNotLicensed",
            HostCapabilityFtUnsupportedReasonEnum::HaAgentIssue => "haAgentIssue",
            HostCapabilityFtUnsupportedReasonEnum::UnsupportedProduct => "unsupportedProduct",
            HostCapabilityFtUnsupportedReasonEnum::CpuHvUnsupported => "cpuHvUnsupported",
            HostCapabilityFtUnsupportedReasonEnum::CpuHwmmuUnsupported => "cpuHwmmuUnsupported",
            HostCapabilityFtUnsupportedReasonEnum::CpuHvDisabled => "cpuHvDisabled",
            HostCapabilityFtUnsupportedReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_CAPABILITY_FT_UNSUPPORTED_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostCapabilityFtUnsupportedReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostCapabilityFtUnsupportedReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostCapabilityFtUnsupportedReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostCapabilityFtUnsupportedReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostCapabilityFtUnsupportedReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostCapabilityFtUnsupportedReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostCapabilityFtUnsupportedReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostCapabilityFtUnsupportedReasonEnum> for &'a str {
    fn from(value: &'a HostCapabilityFtUnsupportedReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostCapabilityFtUnsupportedReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_REPLAY_UNSUPPORTED_REASON_ENUM_MAP: phf::Map<&'static str, HostReplayUnsupportedReasonEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (2, 0),
        (0, 0),
    ],
    entries: &[
        ("unknown", HostReplayUnsupportedReasonEnum::Unknown),
        ("incompatibleProduct", HostReplayUnsupportedReasonEnum::IncompatibleProduct),
        ("oldBIOS", HostReplayUnsupportedReasonEnum::OldBios),
        ("incompatibleCpu", HostReplayUnsupportedReasonEnum::IncompatibleCpu),
        ("cpuidLimitSet", HostReplayUnsupportedReasonEnum::CpuidLimitSet),
        ("hvDisabled", HostReplayUnsupportedReasonEnum::HvDisabled),
    ],
};

impl HostReplayUnsupportedReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostReplayUnsupportedReasonEnum::IncompatibleProduct => "incompatibleProduct",
            HostReplayUnsupportedReasonEnum::IncompatibleCpu => "incompatibleCpu",
            HostReplayUnsupportedReasonEnum::HvDisabled => "hvDisabled",
            HostReplayUnsupportedReasonEnum::CpuidLimitSet => "cpuidLimitSet",
            HostReplayUnsupportedReasonEnum::OldBios => "oldBIOS",
            HostReplayUnsupportedReasonEnum::Unknown => "unknown",
            HostReplayUnsupportedReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_REPLAY_UNSUPPORTED_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostReplayUnsupportedReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostReplayUnsupportedReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostReplayUnsupportedReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostReplayUnsupportedReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostReplayUnsupportedReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostReplayUnsupportedReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostReplayUnsupportedReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostReplayUnsupportedReasonEnum> for &'a str {
    fn from(value: &'a HostReplayUnsupportedReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostReplayUnsupportedReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_CAPABILITY_UNMAP_METHOD_SUPPORTED_ENUM_MAP: phf::Map<&'static str, HostCapabilityUnmapMethodSupportedEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("priority", HostCapabilityUnmapMethodSupportedEnum::Priority),
        ("dynamic", HostCapabilityUnmapMethodSupportedEnum::Dynamic),
        ("fixed", HostCapabilityUnmapMethodSupportedEnum::Fixed),
    ],
};

impl HostCapabilityUnmapMethodSupportedEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostCapabilityUnmapMethodSupportedEnum::Priority => "priority",
            HostCapabilityUnmapMethodSupportedEnum::Fixed => "fixed",
            HostCapabilityUnmapMethodSupportedEnum::Dynamic => "dynamic",
            HostCapabilityUnmapMethodSupportedEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_CAPABILITY_UNMAP_METHOD_SUPPORTED_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostCapabilityUnmapMethodSupportedEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostCapabilityUnmapMethodSupportedEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostCapabilityUnmapMethodSupportedEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostCapabilityUnmapMethodSupportedEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostCapabilityUnmapMethodSupportedEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostCapabilityUnmapMethodSupportedEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostCapabilityUnmapMethodSupportedEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostCapabilityUnmapMethodSupportedEnum> for &'a str {
    fn from(value: &'a HostCapabilityUnmapMethodSupportedEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostCapabilityUnmapMethodSupportedEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_CAPABILITY_VM_DIRECT_PATH_GEN_2_UNSUPPORTED_REASON_ENUM_MAP: phf::Map<&'static str, HostCapabilityVmDirectPathGen2UnsupportedReasonEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("hostNptDisabled", HostCapabilityVmDirectPathGen2UnsupportedReasonEnum::HostNptDisabled),
        ("hostNptIncompatibleProduct", HostCapabilityVmDirectPathGen2UnsupportedReasonEnum::HostNptIncompatibleProduct),
        ("hostNptIncompatibleHardware", HostCapabilityVmDirectPathGen2UnsupportedReasonEnum::HostNptIncompatibleHardware),
    ],
};

impl HostCapabilityVmDirectPathGen2UnsupportedReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostCapabilityVmDirectPathGen2UnsupportedReasonEnum::HostNptIncompatibleProduct => "hostNptIncompatibleProduct",
            HostCapabilityVmDirectPathGen2UnsupportedReasonEnum::HostNptIncompatibleHardware => "hostNptIncompatibleHardware",
            HostCapabilityVmDirectPathGen2UnsupportedReasonEnum::HostNptDisabled => "hostNptDisabled",
            HostCapabilityVmDirectPathGen2UnsupportedReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_CAPABILITY_VM_DIRECT_PATH_GEN_2_UNSUPPORTED_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostCapabilityVmDirectPathGen2UnsupportedReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostCapabilityVmDirectPathGen2UnsupportedReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostCapabilityVmDirectPathGen2UnsupportedReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostCapabilityVmDirectPathGen2UnsupportedReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostCapabilityVmDirectPathGen2UnsupportedReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostCapabilityVmDirectPathGen2UnsupportedReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostCapabilityVmDirectPathGen2UnsupportedReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostCapabilityVmDirectPathGen2UnsupportedReasonEnum> for &'a str {
    fn from(value: &'a HostCapabilityVmDirectPathGen2UnsupportedReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostCapabilityVmDirectPathGen2UnsupportedReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_CERTIFICATE_MANAGER_CERTIFICATE_INFO_CERTIFICATE_STATUS_ENUM_MAP: phf::Map<&'static str, HostCertificateManagerCertificateInfoCertificateStatusEnum> = ::phf::Map {
    key: 14108922650502679131,
    disps: &[
        (2, 0),
        (0, 0),
    ],
    entries: &[
        ("expiringShortly", HostCertificateManagerCertificateInfoCertificateStatusEnum::ExpiringShortly),
        ("unknown", HostCertificateManagerCertificateInfoCertificateStatusEnum::Unknown),
        ("expiring", HostCertificateManagerCertificateInfoCertificateStatusEnum::Expiring),
        ("good", HostCertificateManagerCertificateInfoCertificateStatusEnum::Good),
        ("expired", HostCertificateManagerCertificateInfoCertificateStatusEnum::Expired),
        ("expirationImminent", HostCertificateManagerCertificateInfoCertificateStatusEnum::ExpirationImminent),
    ],
};

impl HostCertificateManagerCertificateInfoCertificateStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostCertificateManagerCertificateInfoCertificateStatusEnum::Unknown => "unknown",
            HostCertificateManagerCertificateInfoCertificateStatusEnum::Expired => "expired",
            HostCertificateManagerCertificateInfoCertificateStatusEnum::Expiring => "expiring",
            HostCertificateManagerCertificateInfoCertificateStatusEnum::ExpiringShortly => "expiringShortly",
            HostCertificateManagerCertificateInfoCertificateStatusEnum::ExpirationImminent => "expirationImminent",
            HostCertificateManagerCertificateInfoCertificateStatusEnum::Good => "good",
            HostCertificateManagerCertificateInfoCertificateStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_CERTIFICATE_MANAGER_CERTIFICATE_INFO_CERTIFICATE_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostCertificateManagerCertificateInfoCertificateStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostCertificateManagerCertificateInfoCertificateStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostCertificateManagerCertificateInfoCertificateStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostCertificateManagerCertificateInfoCertificateStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostCertificateManagerCertificateInfoCertificateStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostCertificateManagerCertificateInfoCertificateStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostCertificateManagerCertificateInfoCertificateStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostCertificateManagerCertificateInfoCertificateStatusEnum> for &'a str {
    fn from(value: &'a HostCertificateManagerCertificateInfoCertificateStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostCertificateManagerCertificateInfoCertificateStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_CERTIFICATE_MANAGER_CERTIFICATE_KIND_ENUM_MAP: phf::Map<&'static str, HostCertificateManagerCertificateKindEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("VASAClient", HostCertificateManagerCertificateKindEnum::VasaClient),
        ("Machine", HostCertificateManagerCertificateKindEnum::Machine),
    ],
};

impl HostCertificateManagerCertificateKindEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostCertificateManagerCertificateKindEnum::Machine => "Machine",
            HostCertificateManagerCertificateKindEnum::VasaClient => "VASAClient",
            HostCertificateManagerCertificateKindEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_CERTIFICATE_MANAGER_CERTIFICATE_KIND_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostCertificateManagerCertificateKindEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostCertificateManagerCertificateKindEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostCertificateManagerCertificateKindEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostCertificateManagerCertificateKindEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostCertificateManagerCertificateKindEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostCertificateManagerCertificateKindEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostCertificateManagerCertificateKindEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostCertificateManagerCertificateKindEnum> for &'a str {
    fn from(value: &'a HostCertificateManagerCertificateKindEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostCertificateManagerCertificateKindEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_CONFIG_CHANGE_MODE_ENUM_MAP: phf::Map<&'static str, HostConfigChangeModeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("modify", HostConfigChangeModeEnum::Modify),
        ("replace", HostConfigChangeModeEnum::Replace),
    ],
};

impl HostConfigChangeModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostConfigChangeModeEnum::Modify => "modify",
            HostConfigChangeModeEnum::Replace => "replace",
            HostConfigChangeModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_CONFIG_CHANGE_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostConfigChangeModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostConfigChangeModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostConfigChangeModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostConfigChangeModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostConfigChangeModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostConfigChangeModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostConfigChangeModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostConfigChangeModeEnum> for &'a str {
    fn from(value: &'a HostConfigChangeModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostConfigChangeModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_CONFIG_CHANGE_OPERATION_ENUM_MAP: phf::Map<&'static str, HostConfigChangeOperationEnum> = ::phf::Map {
    key: 8694567506910003252,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("remove", HostConfigChangeOperationEnum::Remove),
        ("edit", HostConfigChangeOperationEnum::Edit),
        ("add", HostConfigChangeOperationEnum::Add),
        ("ignore", HostConfigChangeOperationEnum::Ignore),
    ],
};

impl HostConfigChangeOperationEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostConfigChangeOperationEnum::Add => "add",
            HostConfigChangeOperationEnum::Remove => "remove",
            HostConfigChangeOperationEnum::Edit => "edit",
            HostConfigChangeOperationEnum::Ignore => "ignore",
            HostConfigChangeOperationEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_CONFIG_CHANGE_OPERATION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostConfigChangeOperationEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostConfigChangeOperationEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostConfigChangeOperationEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostConfigChangeOperationEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostConfigChangeOperationEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostConfigChangeOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostConfigChangeOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostConfigChangeOperationEnum> for &'a str {
    fn from(value: &'a HostConfigChangeOperationEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostConfigChangeOperationEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_CONFIG_CHANGE_OWNER_ENUM_MAP: phf::Map<&'static str, HostConfigChangeOwnerEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("VSAN", HostConfigChangeOwnerEnum::Vsan),
        ("NSX", HostConfigChangeOwnerEnum::Nsx),
    ],
};

impl HostConfigChangeOwnerEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostConfigChangeOwnerEnum::Nsx => "NSX",
            HostConfigChangeOwnerEnum::Vsan => "VSAN",
            HostConfigChangeOwnerEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_CONFIG_CHANGE_OWNER_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostConfigChangeOwnerEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostConfigChangeOwnerEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostConfigChangeOwnerEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostConfigChangeOwnerEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostConfigChangeOwnerEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostConfigChangeOwnerEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostConfigChangeOwnerEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostConfigChangeOwnerEnum> for &'a str {
    fn from(value: &'a HostConfigChangeOwnerEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostConfigChangeOwnerEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_CPU_PACKAGE_VENDOR_ENUM_MAP: phf::Map<&'static str, HostCpuPackageVendorEnum> = ::phf::Map {
    key: 8694567506910003252,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("unknown", HostCpuPackageVendorEnum::Unknown),
        ("hygon", HostCpuPackageVendorEnum::Hygon),
        ("amd", HostCpuPackageVendorEnum::Amd),
        ("intel", HostCpuPackageVendorEnum::Intel),
    ],
};

impl HostCpuPackageVendorEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostCpuPackageVendorEnum::Unknown => "unknown",
            HostCpuPackageVendorEnum::Intel => "intel",
            HostCpuPackageVendorEnum::Amd => "amd",
            HostCpuPackageVendorEnum::Hygon => "hygon",
            HostCpuPackageVendorEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_CPU_PACKAGE_VENDOR_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostCpuPackageVendorEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostCpuPackageVendorEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostCpuPackageVendorEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostCpuPackageVendorEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostCpuPackageVendorEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostCpuPackageVendorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostCpuPackageVendorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostCpuPackageVendorEnum> for &'a str {
    fn from(value: &'a HostCpuPackageVendorEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostCpuPackageVendorEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_CPU_POWER_MANAGEMENT_INFO_POLICY_TYPE_ENUM_MAP: phf::Map<&'static str, HostCpuPowerManagementInfoPolicyTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("staticPolicy", HostCpuPowerManagementInfoPolicyTypeEnum::StaticPolicy),
        ("off", HostCpuPowerManagementInfoPolicyTypeEnum::Off),
        ("dynamicPolicy", HostCpuPowerManagementInfoPolicyTypeEnum::DynamicPolicy),
    ],
};

impl HostCpuPowerManagementInfoPolicyTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostCpuPowerManagementInfoPolicyTypeEnum::Off => "off",
            HostCpuPowerManagementInfoPolicyTypeEnum::StaticPolicy => "staticPolicy",
            HostCpuPowerManagementInfoPolicyTypeEnum::DynamicPolicy => "dynamicPolicy",
            HostCpuPowerManagementInfoPolicyTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_CPU_POWER_MANAGEMENT_INFO_POLICY_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostCpuPowerManagementInfoPolicyTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostCpuPowerManagementInfoPolicyTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostCpuPowerManagementInfoPolicyTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostCpuPowerManagementInfoPolicyTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostCpuPowerManagementInfoPolicyTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostCpuPowerManagementInfoPolicyTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostCpuPowerManagementInfoPolicyTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostCpuPowerManagementInfoPolicyTypeEnum> for &'a str {
    fn from(value: &'a HostCpuPowerManagementInfoPolicyTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostCpuPowerManagementInfoPolicyTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_CPU_SCHEDULER_INFO_CPU_SCHEDULER_POLICY_INFO_ENUM_MAP: phf::Map<&'static str, HostCpuSchedulerInfoCpuSchedulerPolicyInfoEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("scav2", HostCpuSchedulerInfoCpuSchedulerPolicyInfoEnum::Scav2),
        ("scav1", HostCpuSchedulerInfoCpuSchedulerPolicyInfoEnum::Scav1),
        ("systemDefault", HostCpuSchedulerInfoCpuSchedulerPolicyInfoEnum::SystemDefault),
    ],
};

impl HostCpuSchedulerInfoCpuSchedulerPolicyInfoEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostCpuSchedulerInfoCpuSchedulerPolicyInfoEnum::SystemDefault => "systemDefault",
            HostCpuSchedulerInfoCpuSchedulerPolicyInfoEnum::Scav1 => "scav1",
            HostCpuSchedulerInfoCpuSchedulerPolicyInfoEnum::Scav2 => "scav2",
            HostCpuSchedulerInfoCpuSchedulerPolicyInfoEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_CPU_SCHEDULER_INFO_CPU_SCHEDULER_POLICY_INFO_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostCpuSchedulerInfoCpuSchedulerPolicyInfoEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostCpuSchedulerInfoCpuSchedulerPolicyInfoEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostCpuSchedulerInfoCpuSchedulerPolicyInfoEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostCpuSchedulerInfoCpuSchedulerPolicyInfoEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostCpuSchedulerInfoCpuSchedulerPolicyInfoEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostCpuSchedulerInfoCpuSchedulerPolicyInfoEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostCpuSchedulerInfoCpuSchedulerPolicyInfoEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostCpuSchedulerInfoCpuSchedulerPolicyInfoEnum> for &'a str {
    fn from(value: &'a HostCpuSchedulerInfoCpuSchedulerPolicyInfoEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostCpuSchedulerInfoCpuSchedulerPolicyInfoEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_DATE_TIME_INFO_PROTOCOL_ENUM_MAP: phf::Map<&'static str, HostDateTimeInfoProtocolEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("ntp", HostDateTimeInfoProtocolEnum::Ntp),
        ("ptp", HostDateTimeInfoProtocolEnum::Ptp),
    ],
};

impl HostDateTimeInfoProtocolEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostDateTimeInfoProtocolEnum::Ntp => "ntp",
            HostDateTimeInfoProtocolEnum::Ptp => "ptp",
            HostDateTimeInfoProtocolEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_DATE_TIME_INFO_PROTOCOL_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostDateTimeInfoProtocolEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostDateTimeInfoProtocolEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostDateTimeInfoProtocolEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostDateTimeInfoProtocolEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostDateTimeInfoProtocolEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostDateTimeInfoProtocolEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostDateTimeInfoProtocolEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostDateTimeInfoProtocolEnum> for &'a str {
    fn from(value: &'a HostDateTimeInfoProtocolEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostDateTimeInfoProtocolEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DIAGNOSTIC_PARTITION_TYPE_ENUM_MAP: phf::Map<&'static str, DiagnosticPartitionTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("singleHost", DiagnosticPartitionTypeEnum::SingleHost),
        ("multiHost", DiagnosticPartitionTypeEnum::MultiHost),
    ],
};

impl DiagnosticPartitionTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DiagnosticPartitionTypeEnum::SingleHost => "singleHost",
            DiagnosticPartitionTypeEnum::MultiHost => "multiHost",
            DiagnosticPartitionTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DIAGNOSTIC_PARTITION_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DiagnosticPartitionTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DiagnosticPartitionTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DiagnosticPartitionTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DiagnosticPartitionTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DiagnosticPartitionTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DiagnosticPartitionTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DiagnosticPartitionTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DiagnosticPartitionTypeEnum> for &'a str {
    fn from(value: &'a DiagnosticPartitionTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DiagnosticPartitionTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DIAGNOSTIC_PARTITION_STORAGE_TYPE_ENUM_MAP: phf::Map<&'static str, DiagnosticPartitionStorageTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("networkAttached", DiagnosticPartitionStorageTypeEnum::NetworkAttached),
        ("directAttached", DiagnosticPartitionStorageTypeEnum::DirectAttached),
    ],
};

impl DiagnosticPartitionStorageTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DiagnosticPartitionStorageTypeEnum::DirectAttached => "directAttached",
            DiagnosticPartitionStorageTypeEnum::NetworkAttached => "networkAttached",
            DiagnosticPartitionStorageTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DIAGNOSTIC_PARTITION_STORAGE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DiagnosticPartitionStorageTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DiagnosticPartitionStorageTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DiagnosticPartitionStorageTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DiagnosticPartitionStorageTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DiagnosticPartitionStorageTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DiagnosticPartitionStorageTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DiagnosticPartitionStorageTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DiagnosticPartitionStorageTypeEnum> for &'a str {
    fn from(value: &'a DiagnosticPartitionStorageTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DiagnosticPartitionStorageTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_DIGEST_INFO_DIGEST_METHOD_TYPE_ENUM_MAP: phf::Map<&'static str, HostDigestInfoDigestMethodTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
        (2, 1),
    ],
    entries: &[
        ("SM3_256", HostDigestInfoDigestMethodTypeEnum::Sm3256),
        ("SHA512", HostDigestInfoDigestMethodTypeEnum::Sha512),
        ("MD5", HostDigestInfoDigestMethodTypeEnum::Md5),
        ("SHA384", HostDigestInfoDigestMethodTypeEnum::Sha384),
        ("SHA256", HostDigestInfoDigestMethodTypeEnum::Sha256),
        ("SHA1", HostDigestInfoDigestMethodTypeEnum::Sha1),
    ],
};

impl HostDigestInfoDigestMethodTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostDigestInfoDigestMethodTypeEnum::Sha1 => "SHA1",
            HostDigestInfoDigestMethodTypeEnum::Md5 => "MD5",
            HostDigestInfoDigestMethodTypeEnum::Sha256 => "SHA256",
            HostDigestInfoDigestMethodTypeEnum::Sha384 => "SHA384",
            HostDigestInfoDigestMethodTypeEnum::Sha512 => "SHA512",
            HostDigestInfoDigestMethodTypeEnum::Sm3256 => "SM3_256",
            HostDigestInfoDigestMethodTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_DIGEST_INFO_DIGEST_METHOD_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostDigestInfoDigestMethodTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostDigestInfoDigestMethodTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostDigestInfoDigestMethodTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostDigestInfoDigestMethodTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostDigestInfoDigestMethodTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostDigestInfoDigestMethodTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostDigestInfoDigestMethodTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostDigestInfoDigestMethodTypeEnum> for &'a str {
    fn from(value: &'a HostDigestInfoDigestMethodTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostDigestInfoDigestMethodTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_DIGEST_VERIFICATION_SETTING_ENUM_MAP: phf::Map<&'static str, HostDigestVerificationSettingEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("headerOnly", HostDigestVerificationSettingEnum::HeaderOnly),
        ("headerAndData", HostDigestVerificationSettingEnum::HeaderAndData),
        ("dataOnly", HostDigestVerificationSettingEnum::DataOnly),
        ("digestDisabled", HostDigestVerificationSettingEnum::DigestDisabled),
    ],
};

impl HostDigestVerificationSettingEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostDigestVerificationSettingEnum::DigestDisabled => "digestDisabled",
            HostDigestVerificationSettingEnum::HeaderOnly => "headerOnly",
            HostDigestVerificationSettingEnum::DataOnly => "dataOnly",
            HostDigestVerificationSettingEnum::HeaderAndData => "headerAndData",
            HostDigestVerificationSettingEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_DIGEST_VERIFICATION_SETTING_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostDigestVerificationSettingEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostDigestVerificationSettingEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostDigestVerificationSettingEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostDigestVerificationSettingEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostDigestVerificationSettingEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostDigestVerificationSettingEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostDigestVerificationSettingEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostDigestVerificationSettingEnum> for &'a str {
    fn from(value: &'a HostDigestVerificationSettingEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostDigestVerificationSettingEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_DISK_PARTITION_INFO_PARTITION_FORMAT_ENUM_MAP: phf::Map<&'static str, HostDiskPartitionInfoPartitionFormatEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("gpt", HostDiskPartitionInfoPartitionFormatEnum::Gpt),
        ("mbr", HostDiskPartitionInfoPartitionFormatEnum::Mbr),
        ("unknown", HostDiskPartitionInfoPartitionFormatEnum::Unknown),
    ],
};

impl HostDiskPartitionInfoPartitionFormatEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostDiskPartitionInfoPartitionFormatEnum::Gpt => "gpt",
            HostDiskPartitionInfoPartitionFormatEnum::Mbr => "mbr",
            HostDiskPartitionInfoPartitionFormatEnum::Unknown => "unknown",
            HostDiskPartitionInfoPartitionFormatEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_DISK_PARTITION_INFO_PARTITION_FORMAT_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostDiskPartitionInfoPartitionFormatEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostDiskPartitionInfoPartitionFormatEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostDiskPartitionInfoPartitionFormatEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostDiskPartitionInfoPartitionFormatEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostDiskPartitionInfoPartitionFormatEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostDiskPartitionInfoPartitionFormatEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostDiskPartitionInfoPartitionFormatEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostDiskPartitionInfoPartitionFormatEnum> for &'a str {
    fn from(value: &'a HostDiskPartitionInfoPartitionFormatEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostDiskPartitionInfoPartitionFormatEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_DISK_PARTITION_INFO_TYPE_ENUM_MAP: phf::Map<&'static str, HostDiskPartitionInfoTypeEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (1, 6),
        (0, 0),
    ],
    entries: &[
        ("vmkDiagnostic", HostDiskPartitionInfoTypeEnum::VmkDiagnostic),
        ("ntfs", HostDiskPartitionInfoTypeEnum::Ntfs),
        ("extended", HostDiskPartitionInfoTypeEnum::Extended),
        ("vmfs", HostDiskPartitionInfoTypeEnum::Vmfs),
        ("linuxSwap", HostDiskPartitionInfoTypeEnum::LinuxSwap),
        ("vffs", HostDiskPartitionInfoTypeEnum::Vffs),
        ("linuxNative", HostDiskPartitionInfoTypeEnum::LinuxNative),
        ("none", HostDiskPartitionInfoTypeEnum::None),
    ],
};

impl HostDiskPartitionInfoTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostDiskPartitionInfoTypeEnum::None => "none",
            HostDiskPartitionInfoTypeEnum::Vmfs => "vmfs",
            HostDiskPartitionInfoTypeEnum::LinuxNative => "linuxNative",
            HostDiskPartitionInfoTypeEnum::LinuxSwap => "linuxSwap",
            HostDiskPartitionInfoTypeEnum::Extended => "extended",
            HostDiskPartitionInfoTypeEnum::Ntfs => "ntfs",
            HostDiskPartitionInfoTypeEnum::VmkDiagnostic => "vmkDiagnostic",
            HostDiskPartitionInfoTypeEnum::Vffs => "vffs",
            HostDiskPartitionInfoTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_DISK_PARTITION_INFO_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostDiskPartitionInfoTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostDiskPartitionInfoTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostDiskPartitionInfoTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostDiskPartitionInfoTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostDiskPartitionInfoTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostDiskPartitionInfoTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostDiskPartitionInfoTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostDiskPartitionInfoTypeEnum> for &'a str {
    fn from(value: &'a HostDiskPartitionInfoTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostDiskPartitionInfoTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_FEATURE_VERSION_KEY_ENUM_MAP: phf::Map<&'static str, HostFeatureVersionKeyEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("faultTolerance", HostFeatureVersionKeyEnum::FaultTolerance),
    ],
};

impl HostFeatureVersionKeyEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostFeatureVersionKeyEnum::FaultTolerance => "faultTolerance",
            HostFeatureVersionKeyEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_FEATURE_VERSION_KEY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostFeatureVersionKeyEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostFeatureVersionKeyEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostFeatureVersionKeyEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostFeatureVersionKeyEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostFeatureVersionKeyEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostFeatureVersionKeyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostFeatureVersionKeyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostFeatureVersionKeyEnum> for &'a str {
    fn from(value: &'a HostFeatureVersionKeyEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostFeatureVersionKeyEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static FIBRE_CHANNEL_PORT_TYPE_ENUM_MAP: phf::Map<&'static str, FibreChannelPortTypeEnum> = ::phf::Map {
    key: 14108922650502679131,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("loop", FibreChannelPortTypeEnum::Loop),
        ("fabric", FibreChannelPortTypeEnum::Fabric),
        ("pointToPoint", FibreChannelPortTypeEnum::PointToPoint),
        ("unknown", FibreChannelPortTypeEnum::Unknown),
    ],
};

impl FibreChannelPortTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            FibreChannelPortTypeEnum::Fabric => "fabric",
            FibreChannelPortTypeEnum::Loop => "loop",
            FibreChannelPortTypeEnum::PointToPoint => "pointToPoint",
            FibreChannelPortTypeEnum::Unknown => "unknown",
            FibreChannelPortTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        FIBRE_CHANNEL_PORT_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| FibreChannelPortTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for FibreChannelPortTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for FibreChannelPortTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<FibreChannelPortTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(FibreChannelPortTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for FibreChannelPortTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for FibreChannelPortTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a FibreChannelPortTypeEnum> for &'a str {
    fn from(value: &'a FibreChannelPortTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for FibreChannelPortTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static FILE_SYSTEM_MOUNT_INFO_V_STORAGE_SUPPORT_STATUS_ENUM_MAP: phf::Map<&'static str, FileSystemMountInfoVStorageSupportStatusEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("vStorageUnsupported", FileSystemMountInfoVStorageSupportStatusEnum::VStorageUnsupported),
        ("vStorageSupported", FileSystemMountInfoVStorageSupportStatusEnum::VStorageSupported),
        ("vStorageUnknown", FileSystemMountInfoVStorageSupportStatusEnum::VStorageUnknown),
    ],
};

impl FileSystemMountInfoVStorageSupportStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            FileSystemMountInfoVStorageSupportStatusEnum::VStorageSupported => "vStorageSupported",
            FileSystemMountInfoVStorageSupportStatusEnum::VStorageUnsupported => "vStorageUnsupported",
            FileSystemMountInfoVStorageSupportStatusEnum::VStorageUnknown => "vStorageUnknown",
            FileSystemMountInfoVStorageSupportStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        FILE_SYSTEM_MOUNT_INFO_V_STORAGE_SUPPORT_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| FileSystemMountInfoVStorageSupportStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for FileSystemMountInfoVStorageSupportStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for FileSystemMountInfoVStorageSupportStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<FileSystemMountInfoVStorageSupportStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(FileSystemMountInfoVStorageSupportStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for FileSystemMountInfoVStorageSupportStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for FileSystemMountInfoVStorageSupportStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a FileSystemMountInfoVStorageSupportStatusEnum> for &'a str {
    fn from(value: &'a FileSystemMountInfoVStorageSupportStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for FileSystemMountInfoVStorageSupportStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_FILE_SYSTEM_VOLUME_FILE_SYSTEM_TYPE_ENUM_MAP: phf::Map<&'static str, HostFileSystemVolumeFileSystemTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
        (5, 7),
    ],
    entries: &[
        ("VFFS", HostFileSystemVolumeFileSystemTypeEnum::Vffs),
        ("PMEM", HostFileSystemVolumeFileSystemTypeEnum::Pmem),
        ("CIFS", HostFileSystemVolumeFileSystemTypeEnum::Cifs),
        ("OTHER", HostFileSystemVolumeFileSystemTypeEnum::Other),
        ("VMFS", HostFileSystemVolumeFileSystemTypeEnum::Vmfs),
        ("vsanD", HostFileSystemVolumeFileSystemTypeEnum::VsanD),
        ("NFS41", HostFileSystemVolumeFileSystemTypeEnum::Nfs41),
        ("vsan", HostFileSystemVolumeFileSystemTypeEnum::Vsan),
        ("NFS", HostFileSystemVolumeFileSystemTypeEnum::Nfs),
        ("VVOL", HostFileSystemVolumeFileSystemTypeEnum::Vvol),
    ],
};

impl HostFileSystemVolumeFileSystemTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostFileSystemVolumeFileSystemTypeEnum::Vmfs => "VMFS",
            HostFileSystemVolumeFileSystemTypeEnum::Nfs => "NFS",
            HostFileSystemVolumeFileSystemTypeEnum::Nfs41 => "NFS41",
            HostFileSystemVolumeFileSystemTypeEnum::Cifs => "CIFS",
            HostFileSystemVolumeFileSystemTypeEnum::Vsan => "vsan",
            HostFileSystemVolumeFileSystemTypeEnum::Vffs => "VFFS",
            HostFileSystemVolumeFileSystemTypeEnum::Vvol => "VVOL",
            HostFileSystemVolumeFileSystemTypeEnum::Pmem => "PMEM",
            HostFileSystemVolumeFileSystemTypeEnum::VsanD => "vsanD",
            HostFileSystemVolumeFileSystemTypeEnum::Other => "OTHER",
            HostFileSystemVolumeFileSystemTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_FILE_SYSTEM_VOLUME_FILE_SYSTEM_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostFileSystemVolumeFileSystemTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostFileSystemVolumeFileSystemTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostFileSystemVolumeFileSystemTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostFileSystemVolumeFileSystemTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostFileSystemVolumeFileSystemTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostFileSystemVolumeFileSystemTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostFileSystemVolumeFileSystemTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostFileSystemVolumeFileSystemTypeEnum> for &'a str {
    fn from(value: &'a HostFileSystemVolumeFileSystemTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostFileSystemVolumeFileSystemTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_FIREWALL_SYSTEM_RULE_SET_ID_ENUM_MAP: phf::Map<&'static str, HostFirewallSystemRuleSetIdEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("faultTolerance", HostFirewallSystemRuleSetIdEnum::FaultTolerance),
        ("fdm", HostFirewallSystemRuleSetIdEnum::Fdm),
        ("updateManager", HostFirewallSystemRuleSetIdEnum::UpdateManager),
        ("vpxHeartbeats", HostFirewallSystemRuleSetIdEnum::VpxHeartbeats),
    ],
};

impl HostFirewallSystemRuleSetIdEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostFirewallSystemRuleSetIdEnum::FaultTolerance => "faultTolerance",
            HostFirewallSystemRuleSetIdEnum::Fdm => "fdm",
            HostFirewallSystemRuleSetIdEnum::UpdateManager => "updateManager",
            HostFirewallSystemRuleSetIdEnum::VpxHeartbeats => "vpxHeartbeats",
            HostFirewallSystemRuleSetIdEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_FIREWALL_SYSTEM_RULE_SET_ID_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostFirewallSystemRuleSetIdEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostFirewallSystemRuleSetIdEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostFirewallSystemRuleSetIdEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostFirewallSystemRuleSetIdEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostFirewallSystemRuleSetIdEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostFirewallSystemRuleSetIdEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostFirewallSystemRuleSetIdEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostFirewallSystemRuleSetIdEnum> for &'a str {
    fn from(value: &'a HostFirewallSystemRuleSetIdEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostFirewallSystemRuleSetIdEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_FIREWALL_SYSTEM_SERVICE_NAME_ENUM_MAP: phf::Map<&'static str, HostFirewallSystemServiceNameEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("vpxa", HostFirewallSystemServiceNameEnum::Vpxa),
    ],
};

impl HostFirewallSystemServiceNameEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostFirewallSystemServiceNameEnum::Vpxa => "vpxa",
            HostFirewallSystemServiceNameEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_FIREWALL_SYSTEM_SERVICE_NAME_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostFirewallSystemServiceNameEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostFirewallSystemServiceNameEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostFirewallSystemServiceNameEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostFirewallSystemServiceNameEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostFirewallSystemServiceNameEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostFirewallSystemServiceNameEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostFirewallSystemServiceNameEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostFirewallSystemServiceNameEnum> for &'a str {
    fn from(value: &'a HostFirewallSystemServiceNameEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostFirewallSystemServiceNameEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_FRU_FRU_TYPE_ENUM_MAP: phf::Map<&'static str, HostFruFruTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("product", HostFruFruTypeEnum::Product),
        ("board", HostFruFruTypeEnum::Board),
        ("undefined", HostFruFruTypeEnum::Undefined),
    ],
};

impl HostFruFruTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostFruFruTypeEnum::Undefined => "undefined",
            HostFruFruTypeEnum::Board => "board",
            HostFruFruTypeEnum::Product => "product",
            HostFruFruTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_FRU_FRU_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostFruFruTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostFruFruTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostFruFruTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostFruFruTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostFruFruTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostFruFruTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostFruFruTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostFruFruTypeEnum> for &'a str {
    fn from(value: &'a HostFruFruTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostFruFruTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_GRAPHICS_CONFIG_GRAPHICS_TYPE_ENUM_MAP: phf::Map<&'static str, HostGraphicsConfigGraphicsTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("shared", HostGraphicsConfigGraphicsTypeEnum::Shared),
        ("sharedDirect", HostGraphicsConfigGraphicsTypeEnum::SharedDirect),
    ],
};

impl HostGraphicsConfigGraphicsTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostGraphicsConfigGraphicsTypeEnum::Shared => "shared",
            HostGraphicsConfigGraphicsTypeEnum::SharedDirect => "sharedDirect",
            HostGraphicsConfigGraphicsTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_GRAPHICS_CONFIG_GRAPHICS_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostGraphicsConfigGraphicsTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostGraphicsConfigGraphicsTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostGraphicsConfigGraphicsTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostGraphicsConfigGraphicsTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostGraphicsConfigGraphicsTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostGraphicsConfigGraphicsTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostGraphicsConfigGraphicsTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostGraphicsConfigGraphicsTypeEnum> for &'a str {
    fn from(value: &'a HostGraphicsConfigGraphicsTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostGraphicsConfigGraphicsTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_GRAPHICS_CONFIG_SHARED_PASSTHRU_ASSIGNMENT_POLICY_ENUM_MAP: phf::Map<&'static str, HostGraphicsConfigSharedPassthruAssignmentPolicyEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("consolidation", HostGraphicsConfigSharedPassthruAssignmentPolicyEnum::Consolidation),
        ("performance", HostGraphicsConfigSharedPassthruAssignmentPolicyEnum::Performance),
    ],
};

impl HostGraphicsConfigSharedPassthruAssignmentPolicyEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostGraphicsConfigSharedPassthruAssignmentPolicyEnum::Performance => "performance",
            HostGraphicsConfigSharedPassthruAssignmentPolicyEnum::Consolidation => "consolidation",
            HostGraphicsConfigSharedPassthruAssignmentPolicyEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_GRAPHICS_CONFIG_SHARED_PASSTHRU_ASSIGNMENT_POLICY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostGraphicsConfigSharedPassthruAssignmentPolicyEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostGraphicsConfigSharedPassthruAssignmentPolicyEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostGraphicsConfigSharedPassthruAssignmentPolicyEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostGraphicsConfigSharedPassthruAssignmentPolicyEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostGraphicsConfigSharedPassthruAssignmentPolicyEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostGraphicsConfigSharedPassthruAssignmentPolicyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostGraphicsConfigSharedPassthruAssignmentPolicyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostGraphicsConfigSharedPassthruAssignmentPolicyEnum> for &'a str {
    fn from(value: &'a HostGraphicsConfigSharedPassthruAssignmentPolicyEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostGraphicsConfigSharedPassthruAssignmentPolicyEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_GRAPHICS_CONFIG_VGPU_MODE_ENUM_MAP: phf::Map<&'static str, HostGraphicsConfigVgpuModeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("sameSize", HostGraphicsConfigVgpuModeEnum::SameSize),
        ("mixedSize", HostGraphicsConfigVgpuModeEnum::MixedSize),
    ],
};

impl HostGraphicsConfigVgpuModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostGraphicsConfigVgpuModeEnum::SameSize => "sameSize",
            HostGraphicsConfigVgpuModeEnum::MixedSize => "mixedSize",
            HostGraphicsConfigVgpuModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_GRAPHICS_CONFIG_VGPU_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostGraphicsConfigVgpuModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostGraphicsConfigVgpuModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostGraphicsConfigVgpuModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostGraphicsConfigVgpuModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostGraphicsConfigVgpuModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostGraphicsConfigVgpuModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostGraphicsConfigVgpuModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostGraphicsConfigVgpuModeEnum> for &'a str {
    fn from(value: &'a HostGraphicsConfigVgpuModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostGraphicsConfigVgpuModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_GRAPHICS_INFO_GRAPHICS_TYPE_ENUM_MAP: phf::Map<&'static str, HostGraphicsInfoGraphicsTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("basic", HostGraphicsInfoGraphicsTypeEnum::Basic),
        ("sharedDirect", HostGraphicsInfoGraphicsTypeEnum::SharedDirect),
        ("direct", HostGraphicsInfoGraphicsTypeEnum::Direct),
        ("shared", HostGraphicsInfoGraphicsTypeEnum::Shared),
    ],
};

impl HostGraphicsInfoGraphicsTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostGraphicsInfoGraphicsTypeEnum::Basic => "basic",
            HostGraphicsInfoGraphicsTypeEnum::Shared => "shared",
            HostGraphicsInfoGraphicsTypeEnum::Direct => "direct",
            HostGraphicsInfoGraphicsTypeEnum::SharedDirect => "sharedDirect",
            HostGraphicsInfoGraphicsTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_GRAPHICS_INFO_GRAPHICS_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostGraphicsInfoGraphicsTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostGraphicsInfoGraphicsTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostGraphicsInfoGraphicsTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostGraphicsInfoGraphicsTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostGraphicsInfoGraphicsTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostGraphicsInfoGraphicsTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostGraphicsInfoGraphicsTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostGraphicsInfoGraphicsTypeEnum> for &'a str {
    fn from(value: &'a HostGraphicsInfoGraphicsTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostGraphicsInfoGraphicsTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_GRAPHICS_INFO_VGPU_MODE_ENUM_MAP: phf::Map<&'static str, HostGraphicsInfoVgpuModeEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("mixedSize", HostGraphicsInfoVgpuModeEnum::MixedSize),
        ("multiInstanceGpu", HostGraphicsInfoVgpuModeEnum::MultiInstanceGpu),
        ("sameSize", HostGraphicsInfoVgpuModeEnum::SameSize),
        ("none", HostGraphicsInfoVgpuModeEnum::None),
    ],
};

impl HostGraphicsInfoVgpuModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostGraphicsInfoVgpuModeEnum::None => "none",
            HostGraphicsInfoVgpuModeEnum::SameSize => "sameSize",
            HostGraphicsInfoVgpuModeEnum::MixedSize => "mixedSize",
            HostGraphicsInfoVgpuModeEnum::MultiInstanceGpu => "multiInstanceGpu",
            HostGraphicsInfoVgpuModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_GRAPHICS_INFO_VGPU_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostGraphicsInfoVgpuModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostGraphicsInfoVgpuModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostGraphicsInfoVgpuModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostGraphicsInfoVgpuModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostGraphicsInfoVgpuModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostGraphicsInfoVgpuModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostGraphicsInfoVgpuModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostGraphicsInfoVgpuModeEnum> for &'a str {
    fn from(value: &'a HostGraphicsInfoVgpuModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostGraphicsInfoVgpuModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_HARDWARE_ELEMENT_STATUS_ENUM_MAP: phf::Map<&'static str, HostHardwareElementStatusEnum> = ::phf::Map {
    key: 399332969041170284,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("Unknown", HostHardwareElementStatusEnum::Unknown),
        ("Yellow", HostHardwareElementStatusEnum::Yellow),
        ("Green", HostHardwareElementStatusEnum::Green),
        ("Red", HostHardwareElementStatusEnum::Red),
    ],
};

impl HostHardwareElementStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostHardwareElementStatusEnum::Unknown => "Unknown",
            HostHardwareElementStatusEnum::Green => "Green",
            HostHardwareElementStatusEnum::Yellow => "Yellow",
            HostHardwareElementStatusEnum::Red => "Red",
            HostHardwareElementStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_HARDWARE_ELEMENT_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostHardwareElementStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostHardwareElementStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostHardwareElementStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostHardwareElementStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostHardwareElementStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostHardwareElementStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostHardwareElementStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostHardwareElementStatusEnum> for &'a str {
    fn from(value: &'a HostHardwareElementStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostHardwareElementStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_ACCESS_MODE_ENUM_MAP: phf::Map<&'static str, HostAccessModeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("accessOther", HostAccessModeEnum::AccessOther),
        ("accessNone", HostAccessModeEnum::AccessNone),
        ("accessReadOnly", HostAccessModeEnum::AccessReadOnly),
        ("accessNoAccess", HostAccessModeEnum::AccessNoAccess),
        ("accessAdmin", HostAccessModeEnum::AccessAdmin),
    ],
};

impl HostAccessModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostAccessModeEnum::AccessNone => "accessNone",
            HostAccessModeEnum::AccessAdmin => "accessAdmin",
            HostAccessModeEnum::AccessNoAccess => "accessNoAccess",
            HostAccessModeEnum::AccessReadOnly => "accessReadOnly",
            HostAccessModeEnum::AccessOther => "accessOther",
            HostAccessModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_ACCESS_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostAccessModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostAccessModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostAccessModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostAccessModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostAccessModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostAccessModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostAccessModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostAccessModeEnum> for &'a str {
    fn from(value: &'a HostAccessModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostAccessModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_LOCKDOWN_MODE_ENUM_MAP: phf::Map<&'static str, HostLockdownModeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("lockdownStrict", HostLockdownModeEnum::LockdownStrict),
        ("lockdownNormal", HostLockdownModeEnum::LockdownNormal),
        ("lockdownDisabled", HostLockdownModeEnum::LockdownDisabled),
    ],
};

impl HostLockdownModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostLockdownModeEnum::LockdownDisabled => "lockdownDisabled",
            HostLockdownModeEnum::LockdownNormal => "lockdownNormal",
            HostLockdownModeEnum::LockdownStrict => "lockdownStrict",
            HostLockdownModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_LOCKDOWN_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostLockdownModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostLockdownModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostLockdownModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostLockdownModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostLockdownModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostLockdownModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostLockdownModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostLockdownModeEnum> for &'a str {
    fn from(value: &'a HostLockdownModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostLockdownModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_IMAGE_ACCEPTANCE_LEVEL_ENUM_MAP: phf::Map<&'static str, HostImageAcceptanceLevelEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("partner", HostImageAcceptanceLevelEnum::Partner),
        ("community", HostImageAcceptanceLevelEnum::Community),
        ("vmware_certified", HostImageAcceptanceLevelEnum::VmwareCertified),
        ("vmware_accepted", HostImageAcceptanceLevelEnum::VmwareAccepted),
    ],
};

impl HostImageAcceptanceLevelEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostImageAcceptanceLevelEnum::VmwareCertified => "vmware_certified",
            HostImageAcceptanceLevelEnum::VmwareAccepted => "vmware_accepted",
            HostImageAcceptanceLevelEnum::Partner => "partner",
            HostImageAcceptanceLevelEnum::Community => "community",
            HostImageAcceptanceLevelEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_IMAGE_ACCEPTANCE_LEVEL_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostImageAcceptanceLevelEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostImageAcceptanceLevelEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostImageAcceptanceLevelEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostImageAcceptanceLevelEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostImageAcceptanceLevelEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostImageAcceptanceLevelEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostImageAcceptanceLevelEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostImageAcceptanceLevelEnum> for &'a str {
    fn from(value: &'a HostImageAcceptanceLevelEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostImageAcceptanceLevelEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_INTERNET_SCSI_HBA_CHAP_AUTHENTICATION_TYPE_ENUM_MAP: phf::Map<&'static str, HostInternetScsiHbaChapAuthenticationTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("chapPreferred", HostInternetScsiHbaChapAuthenticationTypeEnum::ChapPreferred),
        ("chapDiscouraged", HostInternetScsiHbaChapAuthenticationTypeEnum::ChapDiscouraged),
        ("chapRequired", HostInternetScsiHbaChapAuthenticationTypeEnum::ChapRequired),
        ("chapProhibited", HostInternetScsiHbaChapAuthenticationTypeEnum::ChapProhibited),
    ],
};

impl HostInternetScsiHbaChapAuthenticationTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostInternetScsiHbaChapAuthenticationTypeEnum::ChapProhibited => "chapProhibited",
            HostInternetScsiHbaChapAuthenticationTypeEnum::ChapDiscouraged => "chapDiscouraged",
            HostInternetScsiHbaChapAuthenticationTypeEnum::ChapPreferred => "chapPreferred",
            HostInternetScsiHbaChapAuthenticationTypeEnum::ChapRequired => "chapRequired",
            HostInternetScsiHbaChapAuthenticationTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_INTERNET_SCSI_HBA_CHAP_AUTHENTICATION_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostInternetScsiHbaChapAuthenticationTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostInternetScsiHbaChapAuthenticationTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostInternetScsiHbaChapAuthenticationTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostInternetScsiHbaChapAuthenticationTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostInternetScsiHbaChapAuthenticationTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostInternetScsiHbaChapAuthenticationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostInternetScsiHbaChapAuthenticationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostInternetScsiHbaChapAuthenticationTypeEnum> for &'a str {
    fn from(value: &'a HostInternetScsiHbaChapAuthenticationTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostInternetScsiHbaChapAuthenticationTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_INTERNET_SCSI_HBA_DIGEST_TYPE_ENUM_MAP: phf::Map<&'static str, HostInternetScsiHbaDigestTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("digestDiscouraged", HostInternetScsiHbaDigestTypeEnum::DigestDiscouraged),
        ("digestRequired", HostInternetScsiHbaDigestTypeEnum::DigestRequired),
        ("digestPreferred", HostInternetScsiHbaDigestTypeEnum::DigestPreferred),
        ("digestProhibited", HostInternetScsiHbaDigestTypeEnum::DigestProhibited),
    ],
};

impl HostInternetScsiHbaDigestTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostInternetScsiHbaDigestTypeEnum::DigestProhibited => "digestProhibited",
            HostInternetScsiHbaDigestTypeEnum::DigestDiscouraged => "digestDiscouraged",
            HostInternetScsiHbaDigestTypeEnum::DigestPreferred => "digestPreferred",
            HostInternetScsiHbaDigestTypeEnum::DigestRequired => "digestRequired",
            HostInternetScsiHbaDigestTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_INTERNET_SCSI_HBA_DIGEST_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostInternetScsiHbaDigestTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostInternetScsiHbaDigestTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostInternetScsiHbaDigestTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostInternetScsiHbaDigestTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostInternetScsiHbaDigestTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostInternetScsiHbaDigestTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostInternetScsiHbaDigestTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostInternetScsiHbaDigestTypeEnum> for &'a str {
    fn from(value: &'a HostInternetScsiHbaDigestTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostInternetScsiHbaDigestTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static INTERNET_SCSI_SNS_DISCOVERY_METHOD_ENUM_MAP: phf::Map<&'static str, InternetScsiSnsDiscoveryMethodEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("isnsDhcp", InternetScsiSnsDiscoveryMethodEnum::IsnsDhcp),
        ("isnsSlp", InternetScsiSnsDiscoveryMethodEnum::IsnsSlp),
        ("isnsStatic", InternetScsiSnsDiscoveryMethodEnum::IsnsStatic),
    ],
};

impl InternetScsiSnsDiscoveryMethodEnum {
    pub fn as_str(&self) -> &str {
        match self {
            InternetScsiSnsDiscoveryMethodEnum::IsnsStatic => "isnsStatic",
            InternetScsiSnsDiscoveryMethodEnum::IsnsDhcp => "isnsDhcp",
            InternetScsiSnsDiscoveryMethodEnum::IsnsSlp => "isnsSlp",
            InternetScsiSnsDiscoveryMethodEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        INTERNET_SCSI_SNS_DISCOVERY_METHOD_ENUM_MAP.get(s).cloned().unwrap_or_else(|| InternetScsiSnsDiscoveryMethodEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for InternetScsiSnsDiscoveryMethodEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for InternetScsiSnsDiscoveryMethodEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<InternetScsiSnsDiscoveryMethodEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(InternetScsiSnsDiscoveryMethodEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for InternetScsiSnsDiscoveryMethodEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for InternetScsiSnsDiscoveryMethodEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a InternetScsiSnsDiscoveryMethodEnum> for &'a str {
    fn from(value: &'a InternetScsiSnsDiscoveryMethodEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for InternetScsiSnsDiscoveryMethodEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static SLP_DISCOVERY_METHOD_ENUM_MAP: phf::Map<&'static str, SlpDiscoveryMethodEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (3, 0),
    ],
    entries: &[
        ("slpAutoMulticast", SlpDiscoveryMethodEnum::SlpAutoMulticast),
        ("slpManual", SlpDiscoveryMethodEnum::SlpManual),
        ("slpDhcp", SlpDiscoveryMethodEnum::SlpDhcp),
        ("slpAutoUnicast", SlpDiscoveryMethodEnum::SlpAutoUnicast),
    ],
};

impl SlpDiscoveryMethodEnum {
    pub fn as_str(&self) -> &str {
        match self {
            SlpDiscoveryMethodEnum::SlpDhcp => "slpDhcp",
            SlpDiscoveryMethodEnum::SlpAutoUnicast => "slpAutoUnicast",
            SlpDiscoveryMethodEnum::SlpAutoMulticast => "slpAutoMulticast",
            SlpDiscoveryMethodEnum::SlpManual => "slpManual",
            SlpDiscoveryMethodEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        SLP_DISCOVERY_METHOD_ENUM_MAP.get(s).cloned().unwrap_or_else(|| SlpDiscoveryMethodEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for SlpDiscoveryMethodEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for SlpDiscoveryMethodEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<SlpDiscoveryMethodEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(SlpDiscoveryMethodEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for SlpDiscoveryMethodEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for SlpDiscoveryMethodEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a SlpDiscoveryMethodEnum> for &'a str {
    fn from(value: &'a SlpDiscoveryMethodEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for SlpDiscoveryMethodEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_INTERNET_SCSI_HBA_ISCSI_IPV_6_ADDRESS_ADDRESS_CONFIGURATION_TYPE_ENUM_MAP: phf::Map<&'static str, HostInternetScsiHbaIscsiIpv6AddressAddressConfigurationTypeEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (3, 0),
    ],
    entries: &[
        ("AutoConfigured", HostInternetScsiHbaIscsiIpv6AddressAddressConfigurationTypeEnum::AutoConfigured),
        ("Other", HostInternetScsiHbaIscsiIpv6AddressAddressConfigurationTypeEnum::Other),
        ("Static", HostInternetScsiHbaIscsiIpv6AddressAddressConfigurationTypeEnum::Static),
        ("DHCP", HostInternetScsiHbaIscsiIpv6AddressAddressConfigurationTypeEnum::Dhcp),
    ],
};

impl HostInternetScsiHbaIscsiIpv6AddressAddressConfigurationTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostInternetScsiHbaIscsiIpv6AddressAddressConfigurationTypeEnum::Dhcp => "DHCP",
            HostInternetScsiHbaIscsiIpv6AddressAddressConfigurationTypeEnum::AutoConfigured => "AutoConfigured",
            HostInternetScsiHbaIscsiIpv6AddressAddressConfigurationTypeEnum::Static => "Static",
            HostInternetScsiHbaIscsiIpv6AddressAddressConfigurationTypeEnum::Other => "Other",
            HostInternetScsiHbaIscsiIpv6AddressAddressConfigurationTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_INTERNET_SCSI_HBA_ISCSI_IPV_6_ADDRESS_ADDRESS_CONFIGURATION_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostInternetScsiHbaIscsiIpv6AddressAddressConfigurationTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostInternetScsiHbaIscsiIpv6AddressAddressConfigurationTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostInternetScsiHbaIscsiIpv6AddressAddressConfigurationTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostInternetScsiHbaIscsiIpv6AddressAddressConfigurationTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostInternetScsiHbaIscsiIpv6AddressAddressConfigurationTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostInternetScsiHbaIscsiIpv6AddressAddressConfigurationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostInternetScsiHbaIscsiIpv6AddressAddressConfigurationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostInternetScsiHbaIscsiIpv6AddressAddressConfigurationTypeEnum> for &'a str {
    fn from(value: &'a HostInternetScsiHbaIscsiIpv6AddressAddressConfigurationTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostInternetScsiHbaIscsiIpv6AddressAddressConfigurationTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_INTERNET_SCSI_HBA_ISCSI_IPV_6_ADDRESS_I_PV_6_ADDRESS_OPERATION_ENUM_MAP: phf::Map<&'static str, HostInternetScsiHbaIscsiIpv6AddressIPv6AddressOperationEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("add", HostInternetScsiHbaIscsiIpv6AddressIPv6AddressOperationEnum::Add),
        ("remove", HostInternetScsiHbaIscsiIpv6AddressIPv6AddressOperationEnum::Remove),
    ],
};

impl HostInternetScsiHbaIscsiIpv6AddressIPv6AddressOperationEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostInternetScsiHbaIscsiIpv6AddressIPv6AddressOperationEnum::Add => "add",
            HostInternetScsiHbaIscsiIpv6AddressIPv6AddressOperationEnum::Remove => "remove",
            HostInternetScsiHbaIscsiIpv6AddressIPv6AddressOperationEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_INTERNET_SCSI_HBA_ISCSI_IPV_6_ADDRESS_I_PV_6_ADDRESS_OPERATION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostInternetScsiHbaIscsiIpv6AddressIPv6AddressOperationEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostInternetScsiHbaIscsiIpv6AddressIPv6AddressOperationEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostInternetScsiHbaIscsiIpv6AddressIPv6AddressOperationEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostInternetScsiHbaIscsiIpv6AddressIPv6AddressOperationEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostInternetScsiHbaIscsiIpv6AddressIPv6AddressOperationEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostInternetScsiHbaIscsiIpv6AddressIPv6AddressOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostInternetScsiHbaIscsiIpv6AddressIPv6AddressOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostInternetScsiHbaIscsiIpv6AddressIPv6AddressOperationEnum> for &'a str {
    fn from(value: &'a HostInternetScsiHbaIscsiIpv6AddressIPv6AddressOperationEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostInternetScsiHbaIscsiIpv6AddressIPv6AddressOperationEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_INTERNET_SCSI_HBA_NETWORK_BINDING_SUPPORT_TYPE_ENUM_MAP: phf::Map<&'static str, HostInternetScsiHbaNetworkBindingSupportTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("required", HostInternetScsiHbaNetworkBindingSupportTypeEnum::Required),
        ("optional", HostInternetScsiHbaNetworkBindingSupportTypeEnum::Optional),
        ("notsupported", HostInternetScsiHbaNetworkBindingSupportTypeEnum::Notsupported),
    ],
};

impl HostInternetScsiHbaNetworkBindingSupportTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostInternetScsiHbaNetworkBindingSupportTypeEnum::Notsupported => "notsupported",
            HostInternetScsiHbaNetworkBindingSupportTypeEnum::Optional => "optional",
            HostInternetScsiHbaNetworkBindingSupportTypeEnum::Required => "required",
            HostInternetScsiHbaNetworkBindingSupportTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_INTERNET_SCSI_HBA_NETWORK_BINDING_SUPPORT_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostInternetScsiHbaNetworkBindingSupportTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostInternetScsiHbaNetworkBindingSupportTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostInternetScsiHbaNetworkBindingSupportTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostInternetScsiHbaNetworkBindingSupportTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostInternetScsiHbaNetworkBindingSupportTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostInternetScsiHbaNetworkBindingSupportTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostInternetScsiHbaNetworkBindingSupportTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostInternetScsiHbaNetworkBindingSupportTypeEnum> for &'a str {
    fn from(value: &'a HostInternetScsiHbaNetworkBindingSupportTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostInternetScsiHbaNetworkBindingSupportTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_INTERNET_SCSI_HBA_STATIC_TARGET_TARGET_DISCOVERY_METHOD_ENUM_MAP: phf::Map<&'static str, HostInternetScsiHbaStaticTargetTargetDiscoveryMethodEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (4, 0),
    ],
    entries: &[
        ("unknownMethod", HostInternetScsiHbaStaticTargetTargetDiscoveryMethodEnum::UnknownMethod),
        ("slpMethod", HostInternetScsiHbaStaticTargetTargetDiscoveryMethodEnum::SlpMethod),
        ("sendTargetMethod", HostInternetScsiHbaStaticTargetTargetDiscoveryMethodEnum::SendTargetMethod),
        ("isnsMethod", HostInternetScsiHbaStaticTargetTargetDiscoveryMethodEnum::IsnsMethod),
        ("staticMethod", HostInternetScsiHbaStaticTargetTargetDiscoveryMethodEnum::StaticMethod),
    ],
};

impl HostInternetScsiHbaStaticTargetTargetDiscoveryMethodEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostInternetScsiHbaStaticTargetTargetDiscoveryMethodEnum::StaticMethod => "staticMethod",
            HostInternetScsiHbaStaticTargetTargetDiscoveryMethodEnum::SendTargetMethod => "sendTargetMethod",
            HostInternetScsiHbaStaticTargetTargetDiscoveryMethodEnum::SlpMethod => "slpMethod",
            HostInternetScsiHbaStaticTargetTargetDiscoveryMethodEnum::IsnsMethod => "isnsMethod",
            HostInternetScsiHbaStaticTargetTargetDiscoveryMethodEnum::UnknownMethod => "unknownMethod",
            HostInternetScsiHbaStaticTargetTargetDiscoveryMethodEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_INTERNET_SCSI_HBA_STATIC_TARGET_TARGET_DISCOVERY_METHOD_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostInternetScsiHbaStaticTargetTargetDiscoveryMethodEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostInternetScsiHbaStaticTargetTargetDiscoveryMethodEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostInternetScsiHbaStaticTargetTargetDiscoveryMethodEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostInternetScsiHbaStaticTargetTargetDiscoveryMethodEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostInternetScsiHbaStaticTargetTargetDiscoveryMethodEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostInternetScsiHbaStaticTargetTargetDiscoveryMethodEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostInternetScsiHbaStaticTargetTargetDiscoveryMethodEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostInternetScsiHbaStaticTargetTargetDiscoveryMethodEnum> for &'a str {
    fn from(value: &'a HostInternetScsiHbaStaticTargetTargetDiscoveryMethodEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostInternetScsiHbaStaticTargetTargetDiscoveryMethodEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_IP_CONFIG_IP_V_6_ADDRESS_CONFIG_TYPE_ENUM_MAP: phf::Map<&'static str, HostIpConfigIpV6AddressConfigTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (3, 0),
    ],
    entries: &[
        ("linklayer", HostIpConfigIpV6AddressConfigTypeEnum::Linklayer),
        ("dhcp", HostIpConfigIpV6AddressConfigTypeEnum::Dhcp),
        ("manual", HostIpConfigIpV6AddressConfigTypeEnum::Manual),
        ("random", HostIpConfigIpV6AddressConfigTypeEnum::Random),
        ("other", HostIpConfigIpV6AddressConfigTypeEnum::Other),
    ],
};

impl HostIpConfigIpV6AddressConfigTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostIpConfigIpV6AddressConfigTypeEnum::Other => "other",
            HostIpConfigIpV6AddressConfigTypeEnum::Manual => "manual",
            HostIpConfigIpV6AddressConfigTypeEnum::Dhcp => "dhcp",
            HostIpConfigIpV6AddressConfigTypeEnum::Linklayer => "linklayer",
            HostIpConfigIpV6AddressConfigTypeEnum::Random => "random",
            HostIpConfigIpV6AddressConfigTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_IP_CONFIG_IP_V_6_ADDRESS_CONFIG_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostIpConfigIpV6AddressConfigTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostIpConfigIpV6AddressConfigTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostIpConfigIpV6AddressConfigTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostIpConfigIpV6AddressConfigTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostIpConfigIpV6AddressConfigTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostIpConfigIpV6AddressConfigTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostIpConfigIpV6AddressConfigTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostIpConfigIpV6AddressConfigTypeEnum> for &'a str {
    fn from(value: &'a HostIpConfigIpV6AddressConfigTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostIpConfigIpV6AddressConfigTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_IP_CONFIG_IP_V_6_ADDRESS_STATUS_ENUM_MAP: phf::Map<&'static str, HostIpConfigIpV6AddressStatusEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (4, 6),
        (1, 0),
    ],
    entries: &[
        ("tentative", HostIpConfigIpV6AddressStatusEnum::Tentative),
        ("invalid", HostIpConfigIpV6AddressStatusEnum::Invalid),
        ("unknown", HostIpConfigIpV6AddressStatusEnum::Unknown),
        ("duplicate", HostIpConfigIpV6AddressStatusEnum::Duplicate),
        ("preferred", HostIpConfigIpV6AddressStatusEnum::Preferred),
        ("deprecated", HostIpConfigIpV6AddressStatusEnum::Deprecated),
        ("inaccessible", HostIpConfigIpV6AddressStatusEnum::Inaccessible),
    ],
};

impl HostIpConfigIpV6AddressStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostIpConfigIpV6AddressStatusEnum::Preferred => "preferred",
            HostIpConfigIpV6AddressStatusEnum::Deprecated => "deprecated",
            HostIpConfigIpV6AddressStatusEnum::Invalid => "invalid",
            HostIpConfigIpV6AddressStatusEnum::Inaccessible => "inaccessible",
            HostIpConfigIpV6AddressStatusEnum::Unknown => "unknown",
            HostIpConfigIpV6AddressStatusEnum::Tentative => "tentative",
            HostIpConfigIpV6AddressStatusEnum::Duplicate => "duplicate",
            HostIpConfigIpV6AddressStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_IP_CONFIG_IP_V_6_ADDRESS_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostIpConfigIpV6AddressStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostIpConfigIpV6AddressStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostIpConfigIpV6AddressStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostIpConfigIpV6AddressStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostIpConfigIpV6AddressStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostIpConfigIpV6AddressStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostIpConfigIpV6AddressStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostIpConfigIpV6AddressStatusEnum> for &'a str {
    fn from(value: &'a HostIpConfigIpV6AddressStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostIpConfigIpV6AddressStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static ISCSI_PORT_INFO_PATH_STATUS_ENUM_MAP: phf::Map<&'static str, IscsiPortInfoPathStatusEnum> = ::phf::Map {
    key: 2980949210194914378,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("standBy", IscsiPortInfoPathStatusEnum::StandBy),
        ("notUsed", IscsiPortInfoPathStatusEnum::NotUsed),
        ("lastActive", IscsiPortInfoPathStatusEnum::LastActive),
        ("active", IscsiPortInfoPathStatusEnum::Active),
    ],
};

impl IscsiPortInfoPathStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            IscsiPortInfoPathStatusEnum::NotUsed => "notUsed",
            IscsiPortInfoPathStatusEnum::Active => "active",
            IscsiPortInfoPathStatusEnum::StandBy => "standBy",
            IscsiPortInfoPathStatusEnum::LastActive => "lastActive",
            IscsiPortInfoPathStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        ISCSI_PORT_INFO_PATH_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| IscsiPortInfoPathStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for IscsiPortInfoPathStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for IscsiPortInfoPathStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<IscsiPortInfoPathStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(IscsiPortInfoPathStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for IscsiPortInfoPathStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for IscsiPortInfoPathStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a IscsiPortInfoPathStatusEnum> for &'a str {
    fn from(value: &'a IscsiPortInfoPathStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for IscsiPortInfoPathStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static LINK_DISCOVERY_PROTOCOL_CONFIG_OPERATION_TYPE_ENUM_MAP: phf::Map<&'static str, LinkDiscoveryProtocolConfigOperationTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("both", LinkDiscoveryProtocolConfigOperationTypeEnum::Both),
        ("advertise", LinkDiscoveryProtocolConfigOperationTypeEnum::Advertise),
        ("none", LinkDiscoveryProtocolConfigOperationTypeEnum::None),
        ("listen", LinkDiscoveryProtocolConfigOperationTypeEnum::Listen),
    ],
};

impl LinkDiscoveryProtocolConfigOperationTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            LinkDiscoveryProtocolConfigOperationTypeEnum::None => "none",
            LinkDiscoveryProtocolConfigOperationTypeEnum::Listen => "listen",
            LinkDiscoveryProtocolConfigOperationTypeEnum::Advertise => "advertise",
            LinkDiscoveryProtocolConfigOperationTypeEnum::Both => "both",
            LinkDiscoveryProtocolConfigOperationTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        LINK_DISCOVERY_PROTOCOL_CONFIG_OPERATION_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| LinkDiscoveryProtocolConfigOperationTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for LinkDiscoveryProtocolConfigOperationTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for LinkDiscoveryProtocolConfigOperationTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<LinkDiscoveryProtocolConfigOperationTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(LinkDiscoveryProtocolConfigOperationTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for LinkDiscoveryProtocolConfigOperationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for LinkDiscoveryProtocolConfigOperationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a LinkDiscoveryProtocolConfigOperationTypeEnum> for &'a str {
    fn from(value: &'a LinkDiscoveryProtocolConfigOperationTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for LinkDiscoveryProtocolConfigOperationTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static LINK_DISCOVERY_PROTOCOL_CONFIG_PROTOCOL_TYPE_ENUM_MAP: phf::Map<&'static str, LinkDiscoveryProtocolConfigProtocolTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("lldp", LinkDiscoveryProtocolConfigProtocolTypeEnum::Lldp),
        ("cdp", LinkDiscoveryProtocolConfigProtocolTypeEnum::Cdp),
    ],
};

impl LinkDiscoveryProtocolConfigProtocolTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            LinkDiscoveryProtocolConfigProtocolTypeEnum::Cdp => "cdp",
            LinkDiscoveryProtocolConfigProtocolTypeEnum::Lldp => "lldp",
            LinkDiscoveryProtocolConfigProtocolTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        LINK_DISCOVERY_PROTOCOL_CONFIG_PROTOCOL_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| LinkDiscoveryProtocolConfigProtocolTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for LinkDiscoveryProtocolConfigProtocolTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for LinkDiscoveryProtocolConfigProtocolTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<LinkDiscoveryProtocolConfigProtocolTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(LinkDiscoveryProtocolConfigProtocolTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for LinkDiscoveryProtocolConfigProtocolTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for LinkDiscoveryProtocolConfigProtocolTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a LinkDiscoveryProtocolConfigProtocolTypeEnum> for &'a str {
    fn from(value: &'a LinkDiscoveryProtocolConfigProtocolTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for LinkDiscoveryProtocolConfigProtocolTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_LOW_LEVEL_PROVISIONING_MANAGER_FILE_TYPE_ENUM_MAP: phf::Map<&'static str, HostLowLevelProvisioningManagerFileTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("Directory", HostLowLevelProvisioningManagerFileTypeEnum::Directory),
        ("File", HostLowLevelProvisioningManagerFileTypeEnum::File),
        ("VirtualDisk", HostLowLevelProvisioningManagerFileTypeEnum::VirtualDisk),
    ],
};

impl HostLowLevelProvisioningManagerFileTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostLowLevelProvisioningManagerFileTypeEnum::File => "File",
            HostLowLevelProvisioningManagerFileTypeEnum::VirtualDisk => "VirtualDisk",
            HostLowLevelProvisioningManagerFileTypeEnum::Directory => "Directory",
            HostLowLevelProvisioningManagerFileTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_LOW_LEVEL_PROVISIONING_MANAGER_FILE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostLowLevelProvisioningManagerFileTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostLowLevelProvisioningManagerFileTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostLowLevelProvisioningManagerFileTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostLowLevelProvisioningManagerFileTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostLowLevelProvisioningManagerFileTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostLowLevelProvisioningManagerFileTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostLowLevelProvisioningManagerFileTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostLowLevelProvisioningManagerFileTypeEnum> for &'a str {
    fn from(value: &'a HostLowLevelProvisioningManagerFileTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostLowLevelProvisioningManagerFileTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_LOW_LEVEL_PROVISIONING_MANAGER_RELOAD_TARGET_ENUM_MAP: phf::Map<&'static str, HostLowLevelProvisioningManagerReloadTargetEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("snapshotConfig", HostLowLevelProvisioningManagerReloadTargetEnum::SnapshotConfig),
        ("currentConfig", HostLowLevelProvisioningManagerReloadTargetEnum::CurrentConfig),
    ],
};

impl HostLowLevelProvisioningManagerReloadTargetEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostLowLevelProvisioningManagerReloadTargetEnum::CurrentConfig => "currentConfig",
            HostLowLevelProvisioningManagerReloadTargetEnum::SnapshotConfig => "snapshotConfig",
            HostLowLevelProvisioningManagerReloadTargetEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_LOW_LEVEL_PROVISIONING_MANAGER_RELOAD_TARGET_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostLowLevelProvisioningManagerReloadTargetEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostLowLevelProvisioningManagerReloadTargetEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostLowLevelProvisioningManagerReloadTargetEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostLowLevelProvisioningManagerReloadTargetEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostLowLevelProvisioningManagerReloadTargetEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostLowLevelProvisioningManagerReloadTargetEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostLowLevelProvisioningManagerReloadTargetEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostLowLevelProvisioningManagerReloadTargetEnum> for &'a str {
    fn from(value: &'a HostLowLevelProvisioningManagerReloadTargetEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostLowLevelProvisioningManagerReloadTargetEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_MAINTENANCE_SPEC_PURPOSE_ENUM_MAP: phf::Map<&'static str, HostMaintenanceSpecPurposeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("hostUpgrade", HostMaintenanceSpecPurposeEnum::HostUpgrade),
    ],
};

impl HostMaintenanceSpecPurposeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostMaintenanceSpecPurposeEnum::HostUpgrade => "hostUpgrade",
            HostMaintenanceSpecPurposeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_MAINTENANCE_SPEC_PURPOSE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostMaintenanceSpecPurposeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostMaintenanceSpecPurposeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostMaintenanceSpecPurposeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostMaintenanceSpecPurposeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostMaintenanceSpecPurposeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostMaintenanceSpecPurposeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostMaintenanceSpecPurposeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostMaintenanceSpecPurposeEnum> for &'a str {
    fn from(value: &'a HostMaintenanceSpecPurposeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostMaintenanceSpecPurposeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_MEMORY_ALLOCATION_POLICY_ENUM_MAP: phf::Map<&'static str, VirtualMachineMemoryAllocationPolicyEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("swapSome", VirtualMachineMemoryAllocationPolicyEnum::SwapSome),
        ("swapMost", VirtualMachineMemoryAllocationPolicyEnum::SwapMost),
        ("swapNone", VirtualMachineMemoryAllocationPolicyEnum::SwapNone),
    ],
};

impl VirtualMachineMemoryAllocationPolicyEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineMemoryAllocationPolicyEnum::SwapNone => "swapNone",
            VirtualMachineMemoryAllocationPolicyEnum::SwapSome => "swapSome",
            VirtualMachineMemoryAllocationPolicyEnum::SwapMost => "swapMost",
            VirtualMachineMemoryAllocationPolicyEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_MEMORY_ALLOCATION_POLICY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineMemoryAllocationPolicyEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineMemoryAllocationPolicyEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineMemoryAllocationPolicyEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineMemoryAllocationPolicyEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineMemoryAllocationPolicyEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineMemoryAllocationPolicyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineMemoryAllocationPolicyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineMemoryAllocationPolicyEnum> for &'a str {
    fn from(value: &'a VirtualMachineMemoryAllocationPolicyEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineMemoryAllocationPolicyEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_MEMORY_TIER_FLAGS_ENUM_MAP: phf::Map<&'static str, HostMemoryTierFlagsEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("cachingTier", HostMemoryTierFlagsEnum::CachingTier),
        ("memoryTier", HostMemoryTierFlagsEnum::MemoryTier),
        ("unmappableTier", HostMemoryTierFlagsEnum::UnmappableTier),
        ("persistentTier", HostMemoryTierFlagsEnum::PersistentTier),
    ],
};

impl HostMemoryTierFlagsEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostMemoryTierFlagsEnum::MemoryTier => "memoryTier",
            HostMemoryTierFlagsEnum::PersistentTier => "persistentTier",
            HostMemoryTierFlagsEnum::CachingTier => "cachingTier",
            HostMemoryTierFlagsEnum::UnmappableTier => "unmappableTier",
            HostMemoryTierFlagsEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_MEMORY_TIER_FLAGS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostMemoryTierFlagsEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostMemoryTierFlagsEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostMemoryTierFlagsEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostMemoryTierFlagsEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostMemoryTierFlagsEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostMemoryTierFlagsEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostMemoryTierFlagsEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostMemoryTierFlagsEnum> for &'a str {
    fn from(value: &'a HostMemoryTierFlagsEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostMemoryTierFlagsEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_MEMORY_TIER_TYPE_ENUM_MAP: phf::Map<&'static str, HostMemoryTierTypeEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("PMem", HostMemoryTierTypeEnum::PMem),
        ("DRAM", HostMemoryTierTypeEnum::Dram),
        ("NVMe", HostMemoryTierTypeEnum::NvMe),
    ],
};

impl HostMemoryTierTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostMemoryTierTypeEnum::Dram => "DRAM",
            HostMemoryTierTypeEnum::PMem => "PMem",
            HostMemoryTierTypeEnum::NvMe => "NVMe",
            HostMemoryTierTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_MEMORY_TIER_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostMemoryTierTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostMemoryTierTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostMemoryTierTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostMemoryTierTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostMemoryTierTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostMemoryTierTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostMemoryTierTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostMemoryTierTypeEnum> for &'a str {
    fn from(value: &'a HostMemoryTierTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostMemoryTierTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_MEMORY_TIERING_TYPE_ENUM_MAP: phf::Map<&'static str, HostMemoryTieringTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("softwareTiering", HostMemoryTieringTypeEnum::SoftwareTiering),
        ("noTiering", HostMemoryTieringTypeEnum::NoTiering),
        ("hardwareTiering", HostMemoryTieringTypeEnum::HardwareTiering),
    ],
};

impl HostMemoryTieringTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostMemoryTieringTypeEnum::NoTiering => "noTiering",
            HostMemoryTieringTypeEnum::HardwareTiering => "hardwareTiering",
            HostMemoryTieringTypeEnum::SoftwareTiering => "softwareTiering",
            HostMemoryTieringTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_MEMORY_TIERING_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostMemoryTieringTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostMemoryTieringTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostMemoryTieringTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostMemoryTieringTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostMemoryTieringTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostMemoryTieringTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostMemoryTieringTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostMemoryTieringTypeEnum> for &'a str {
    fn from(value: &'a HostMemoryTieringTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostMemoryTieringTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_MOUNT_MODE_ENUM_MAP: phf::Map<&'static str, HostMountModeEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("readOnly", HostMountModeEnum::ReadOnly),
        ("readWrite", HostMountModeEnum::ReadWrite),
    ],
};

impl HostMountModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostMountModeEnum::ReadWrite => "readWrite",
            HostMountModeEnum::ReadOnly => "readOnly",
            HostMountModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_MOUNT_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostMountModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostMountModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostMountModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostMountModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostMountModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostMountModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostMountModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostMountModeEnum> for &'a str {
    fn from(value: &'a HostMountModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostMountModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_MOUNT_INFO_INACCESSIBLE_REASON_ENUM_MAP: phf::Map<&'static str, HostMountInfoInaccessibleReasonEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("AllPathsDown_Timeout", HostMountInfoInaccessibleReasonEnum::AllPathsDownTimeout),
        ("AllPathsDown_Start", HostMountInfoInaccessibleReasonEnum::AllPathsDownStart),
        ("PermanentDeviceLoss", HostMountInfoInaccessibleReasonEnum::PermanentDeviceLoss),
    ],
};

impl HostMountInfoInaccessibleReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostMountInfoInaccessibleReasonEnum::AllPathsDownStart => "AllPathsDown_Start",
            HostMountInfoInaccessibleReasonEnum::AllPathsDownTimeout => "AllPathsDown_Timeout",
            HostMountInfoInaccessibleReasonEnum::PermanentDeviceLoss => "PermanentDeviceLoss",
            HostMountInfoInaccessibleReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_MOUNT_INFO_INACCESSIBLE_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostMountInfoInaccessibleReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostMountInfoInaccessibleReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostMountInfoInaccessibleReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostMountInfoInaccessibleReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostMountInfoInaccessibleReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostMountInfoInaccessibleReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostMountInfoInaccessibleReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostMountInfoInaccessibleReasonEnum> for &'a str {
    fn from(value: &'a HostMountInfoInaccessibleReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostMountInfoInaccessibleReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_MOUNT_INFO_MOUNT_FAILED_REASON_ENUM_MAP: phf::Map<&'static str, HostMountInfoMountFailedReasonEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (5, 0),
        (1, 2),
    ],
    entries: &[
        ("MOUNT_EXISTS", HostMountInfoMountFailedReasonEnum::MountExists),
        ("CONNECT_FAILURE", HostMountInfoMountFailedReasonEnum::ConnectFailure),
        ("MOUNT_NOT_SUPPORTED", HostMountInfoMountFailedReasonEnum::MountNotSupported),
        ("CONN_LIMIT_EXCEEDED", HostMountInfoMountFailedReasonEnum::ConnLimitExceeded),
        ("NFS_NOT_SUPPORTED", HostMountInfoMountFailedReasonEnum::NfsNotSupported),
        ("MOUNT_NOT_DIR", HostMountInfoMountFailedReasonEnum::MountNotDir),
        ("OTHERS", HostMountInfoMountFailedReasonEnum::Others),
        ("MOUNT_DENIED", HostMountInfoMountFailedReasonEnum::MountDenied),
        ("VOLUME_LIMIT_EXCEEDED", HostMountInfoMountFailedReasonEnum::VolumeLimitExceeded),
    ],
};

impl HostMountInfoMountFailedReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostMountInfoMountFailedReasonEnum::ConnectFailure => "CONNECT_FAILURE",
            HostMountInfoMountFailedReasonEnum::MountNotSupported => "MOUNT_NOT_SUPPORTED",
            HostMountInfoMountFailedReasonEnum::NfsNotSupported => "NFS_NOT_SUPPORTED",
            HostMountInfoMountFailedReasonEnum::MountDenied => "MOUNT_DENIED",
            HostMountInfoMountFailedReasonEnum::MountNotDir => "MOUNT_NOT_DIR",
            HostMountInfoMountFailedReasonEnum::VolumeLimitExceeded => "VOLUME_LIMIT_EXCEEDED",
            HostMountInfoMountFailedReasonEnum::ConnLimitExceeded => "CONN_LIMIT_EXCEEDED",
            HostMountInfoMountFailedReasonEnum::MountExists => "MOUNT_EXISTS",
            HostMountInfoMountFailedReasonEnum::Others => "OTHERS",
            HostMountInfoMountFailedReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_MOUNT_INFO_MOUNT_FAILED_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostMountInfoMountFailedReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostMountInfoMountFailedReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostMountInfoMountFailedReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostMountInfoMountFailedReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostMountInfoMountFailedReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostMountInfoMountFailedReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostMountInfoMountFailedReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostMountInfoMountFailedReasonEnum> for &'a str {
    fn from(value: &'a HostMountInfoMountFailedReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostMountInfoMountFailedReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static MULTIPATH_STATE_ENUM_MAP: phf::Map<&'static str, MultipathStateEnum> = ::phf::Map {
    key: 2980949210194914378,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("unknown", MultipathStateEnum::Unknown),
        ("active", MultipathStateEnum::Active),
        ("dead", MultipathStateEnum::Dead),
        ("standby", MultipathStateEnum::Standby),
        ("disabled", MultipathStateEnum::Disabled),
    ],
};

impl MultipathStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            MultipathStateEnum::Standby => "standby",
            MultipathStateEnum::Active => "active",
            MultipathStateEnum::Disabled => "disabled",
            MultipathStateEnum::Dead => "dead",
            MultipathStateEnum::Unknown => "unknown",
            MultipathStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        MULTIPATH_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| MultipathStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for MultipathStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for MultipathStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<MultipathStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(MultipathStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for MultipathStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for MultipathStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a MultipathStateEnum> for &'a str {
    fn from(value: &'a MultipathStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for MultipathStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_NAS_VOLUME_SECURITY_TYPE_ENUM_MAP: phf::Map<&'static str, HostNasVolumeSecurityTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("SEC_KRB5P", HostNasVolumeSecurityTypeEnum::SecKrb5P),
        ("SEC_KRB5", HostNasVolumeSecurityTypeEnum::SecKrb5),
        ("AUTH_SYS", HostNasVolumeSecurityTypeEnum::AuthSys),
        ("SEC_KRB5I", HostNasVolumeSecurityTypeEnum::SecKrb5I),
    ],
};

impl HostNasVolumeSecurityTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostNasVolumeSecurityTypeEnum::AuthSys => "AUTH_SYS",
            HostNasVolumeSecurityTypeEnum::SecKrb5 => "SEC_KRB5",
            HostNasVolumeSecurityTypeEnum::SecKrb5I => "SEC_KRB5I",
            HostNasVolumeSecurityTypeEnum::SecKrb5P => "SEC_KRB5P",
            HostNasVolumeSecurityTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_NAS_VOLUME_SECURITY_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostNasVolumeSecurityTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostNasVolumeSecurityTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostNasVolumeSecurityTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostNasVolumeSecurityTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostNasVolumeSecurityTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostNasVolumeSecurityTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostNasVolumeSecurityTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostNasVolumeSecurityTypeEnum> for &'a str {
    fn from(value: &'a HostNasVolumeSecurityTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostNasVolumeSecurityTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_NET_STACK_INSTANCE_CONGESTION_CONTROL_ALGORITHM_TYPE_ENUM_MAP: phf::Map<&'static str, HostNetStackInstanceCongestionControlAlgorithmTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("cubic", HostNetStackInstanceCongestionControlAlgorithmTypeEnum::Cubic),
        ("newreno", HostNetStackInstanceCongestionControlAlgorithmTypeEnum::Newreno),
    ],
};

impl HostNetStackInstanceCongestionControlAlgorithmTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostNetStackInstanceCongestionControlAlgorithmTypeEnum::Newreno => "newreno",
            HostNetStackInstanceCongestionControlAlgorithmTypeEnum::Cubic => "cubic",
            HostNetStackInstanceCongestionControlAlgorithmTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_NET_STACK_INSTANCE_CONGESTION_CONTROL_ALGORITHM_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostNetStackInstanceCongestionControlAlgorithmTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostNetStackInstanceCongestionControlAlgorithmTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostNetStackInstanceCongestionControlAlgorithmTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostNetStackInstanceCongestionControlAlgorithmTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostNetStackInstanceCongestionControlAlgorithmTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostNetStackInstanceCongestionControlAlgorithmTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostNetStackInstanceCongestionControlAlgorithmTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostNetStackInstanceCongestionControlAlgorithmTypeEnum> for &'a str {
    fn from(value: &'a HostNetStackInstanceCongestionControlAlgorithmTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostNetStackInstanceCongestionControlAlgorithmTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_NET_STACK_INSTANCE_SYSTEM_STACK_KEY_ENUM_MAP: phf::Map<&'static str, HostNetStackInstanceSystemStackKeyEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("mirror", HostNetStackInstanceSystemStackKeyEnum::Mirror),
        ("ops", HostNetStackInstanceSystemStackKeyEnum::Ops),
        ("vmotion", HostNetStackInstanceSystemStackKeyEnum::Vmotion),
        ("vSphereProvisioning", HostNetStackInstanceSystemStackKeyEnum::VSphereProvisioning),
        ("defaultTcpipStack", HostNetStackInstanceSystemStackKeyEnum::DefaultTcpipStack),
    ],
};

impl HostNetStackInstanceSystemStackKeyEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostNetStackInstanceSystemStackKeyEnum::DefaultTcpipStack => "defaultTcpipStack",
            HostNetStackInstanceSystemStackKeyEnum::Vmotion => "vmotion",
            HostNetStackInstanceSystemStackKeyEnum::VSphereProvisioning => "vSphereProvisioning",
            HostNetStackInstanceSystemStackKeyEnum::Mirror => "mirror",
            HostNetStackInstanceSystemStackKeyEnum::Ops => "ops",
            HostNetStackInstanceSystemStackKeyEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_NET_STACK_INSTANCE_SYSTEM_STACK_KEY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostNetStackInstanceSystemStackKeyEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostNetStackInstanceSystemStackKeyEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostNetStackInstanceSystemStackKeyEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostNetStackInstanceSystemStackKeyEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostNetStackInstanceSystemStackKeyEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostNetStackInstanceSystemStackKeyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostNetStackInstanceSystemStackKeyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostNetStackInstanceSystemStackKeyEnum> for &'a str {
    fn from(value: &'a HostNetStackInstanceSystemStackKeyEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostNetStackInstanceSystemStackKeyEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_NUMERIC_SENSOR_HEALTH_STATE_ENUM_MAP: phf::Map<&'static str, HostNumericSensorHealthStateEnum> = ::phf::Map {
    key: 351906021642186605,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("red", HostNumericSensorHealthStateEnum::Red),
        ("yellow", HostNumericSensorHealthStateEnum::Yellow),
        ("unknown", HostNumericSensorHealthStateEnum::Unknown),
        ("green", HostNumericSensorHealthStateEnum::Green),
    ],
};

impl HostNumericSensorHealthStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostNumericSensorHealthStateEnum::Unknown => "unknown",
            HostNumericSensorHealthStateEnum::Green => "green",
            HostNumericSensorHealthStateEnum::Yellow => "yellow",
            HostNumericSensorHealthStateEnum::Red => "red",
            HostNumericSensorHealthStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_NUMERIC_SENSOR_HEALTH_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostNumericSensorHealthStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostNumericSensorHealthStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostNumericSensorHealthStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostNumericSensorHealthStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostNumericSensorHealthStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostNumericSensorHealthStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostNumericSensorHealthStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostNumericSensorHealthStateEnum> for &'a str {
    fn from(value: &'a HostNumericSensorHealthStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostNumericSensorHealthStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_NUMERIC_SENSOR_TYPE_ENUM_MAP: phf::Map<&'static str, HostNumericSensorTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (4, 6),
        (5, 6),
        (8, 0),
    ],
    entries: &[
        ("watchdog", HostNumericSensorTypeEnum::Watchdog),
        ("bios", HostNumericSensorTypeEnum::Bios),
        ("voltage", HostNumericSensorTypeEnum::Voltage),
        ("power", HostNumericSensorTypeEnum::Power),
        ("systemBoard", HostNumericSensorTypeEnum::SystemBoard),
        ("battery", HostNumericSensorTypeEnum::Battery),
        ("temperature", HostNumericSensorTypeEnum::Temperature),
        ("cable", HostNumericSensorTypeEnum::Cable),
        ("fan", HostNumericSensorTypeEnum::Fan),
        ("memory", HostNumericSensorTypeEnum::Memory),
        ("storage", HostNumericSensorTypeEnum::Storage),
        ("processor", HostNumericSensorTypeEnum::Processor),
        ("other", HostNumericSensorTypeEnum::Other),
    ],
};

impl HostNumericSensorTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostNumericSensorTypeEnum::Fan => "fan",
            HostNumericSensorTypeEnum::Power => "power",
            HostNumericSensorTypeEnum::Temperature => "temperature",
            HostNumericSensorTypeEnum::Voltage => "voltage",
            HostNumericSensorTypeEnum::Other => "other",
            HostNumericSensorTypeEnum::Processor => "processor",
            HostNumericSensorTypeEnum::Memory => "memory",
            HostNumericSensorTypeEnum::Storage => "storage",
            HostNumericSensorTypeEnum::SystemBoard => "systemBoard",
            HostNumericSensorTypeEnum::Battery => "battery",
            HostNumericSensorTypeEnum::Bios => "bios",
            HostNumericSensorTypeEnum::Cable => "cable",
            HostNumericSensorTypeEnum::Watchdog => "watchdog",
            HostNumericSensorTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_NUMERIC_SENSOR_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostNumericSensorTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostNumericSensorTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostNumericSensorTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostNumericSensorTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostNumericSensorTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostNumericSensorTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostNumericSensorTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostNumericSensorTypeEnum> for &'a str {
    fn from(value: &'a HostNumericSensorTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostNumericSensorTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static NVDIMM_NVDIMM_HEALTH_INFO_STATE_ENUM_MAP: phf::Map<&'static str, NvdimmNvdimmHealthInfoStateEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("normal", NvdimmNvdimmHealthInfoStateEnum::Normal),
        ("error", NvdimmNvdimmHealthInfoStateEnum::Error),
    ],
};

impl NvdimmNvdimmHealthInfoStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            NvdimmNvdimmHealthInfoStateEnum::Normal => "normal",
            NvdimmNvdimmHealthInfoStateEnum::Error => "error",
            NvdimmNvdimmHealthInfoStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        NVDIMM_NVDIMM_HEALTH_INFO_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| NvdimmNvdimmHealthInfoStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for NvdimmNvdimmHealthInfoStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for NvdimmNvdimmHealthInfoStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<NvdimmNvdimmHealthInfoStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(NvdimmNvdimmHealthInfoStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for NvdimmNvdimmHealthInfoStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for NvdimmNvdimmHealthInfoStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a NvdimmNvdimmHealthInfoStateEnum> for &'a str {
    fn from(value: &'a NvdimmNvdimmHealthInfoStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for NvdimmNvdimmHealthInfoStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static NVDIMM_INTERLEAVE_SET_STATE_ENUM_MAP: phf::Map<&'static str, NvdimmInterleaveSetStateEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("invalid", NvdimmInterleaveSetStateEnum::Invalid),
        ("active", NvdimmInterleaveSetStateEnum::Active),
    ],
};

impl NvdimmInterleaveSetStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            NvdimmInterleaveSetStateEnum::Invalid => "invalid",
            NvdimmInterleaveSetStateEnum::Active => "active",
            NvdimmInterleaveSetStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        NVDIMM_INTERLEAVE_SET_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| NvdimmInterleaveSetStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for NvdimmInterleaveSetStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for NvdimmInterleaveSetStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<NvdimmInterleaveSetStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(NvdimmInterleaveSetStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for NvdimmInterleaveSetStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for NvdimmInterleaveSetStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a NvdimmInterleaveSetStateEnum> for &'a str {
    fn from(value: &'a NvdimmInterleaveSetStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for NvdimmInterleaveSetStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static NVDIMM_NAMESPACE_DETAILS_HEALTH_STATUS_ENUM_MAP: phf::Map<&'static str, NvdimmNamespaceDetailsHealthStatusEnum> = ::phf::Map {
    key: 8694567506910003252,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("labelMissing", NvdimmNamespaceDetailsHealthStatusEnum::LabelMissing),
        ("normal", NvdimmNamespaceDetailsHealthStatusEnum::Normal),
        ("interleaveBroken", NvdimmNamespaceDetailsHealthStatusEnum::InterleaveBroken),
        ("missing", NvdimmNamespaceDetailsHealthStatusEnum::Missing),
        ("labelInconsistent", NvdimmNamespaceDetailsHealthStatusEnum::LabelInconsistent),
    ],
};

impl NvdimmNamespaceDetailsHealthStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            NvdimmNamespaceDetailsHealthStatusEnum::Normal => "normal",
            NvdimmNamespaceDetailsHealthStatusEnum::Missing => "missing",
            NvdimmNamespaceDetailsHealthStatusEnum::LabelMissing => "labelMissing",
            NvdimmNamespaceDetailsHealthStatusEnum::InterleaveBroken => "interleaveBroken",
            NvdimmNamespaceDetailsHealthStatusEnum::LabelInconsistent => "labelInconsistent",
            NvdimmNamespaceDetailsHealthStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        NVDIMM_NAMESPACE_DETAILS_HEALTH_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| NvdimmNamespaceDetailsHealthStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for NvdimmNamespaceDetailsHealthStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for NvdimmNamespaceDetailsHealthStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<NvdimmNamespaceDetailsHealthStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(NvdimmNamespaceDetailsHealthStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for NvdimmNamespaceDetailsHealthStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for NvdimmNamespaceDetailsHealthStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a NvdimmNamespaceDetailsHealthStatusEnum> for &'a str {
    fn from(value: &'a NvdimmNamespaceDetailsHealthStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for NvdimmNamespaceDetailsHealthStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static NVDIMM_NAMESPACE_DETAILS_STATE_ENUM_MAP: phf::Map<&'static str, NvdimmNamespaceDetailsStateEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("invalid", NvdimmNamespaceDetailsStateEnum::Invalid),
        ("inUse", NvdimmNamespaceDetailsStateEnum::InUse),
        ("notInUse", NvdimmNamespaceDetailsStateEnum::NotInUse),
    ],
};

impl NvdimmNamespaceDetailsStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            NvdimmNamespaceDetailsStateEnum::Invalid => "invalid",
            NvdimmNamespaceDetailsStateEnum::NotInUse => "notInUse",
            NvdimmNamespaceDetailsStateEnum::InUse => "inUse",
            NvdimmNamespaceDetailsStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        NVDIMM_NAMESPACE_DETAILS_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| NvdimmNamespaceDetailsStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for NvdimmNamespaceDetailsStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for NvdimmNamespaceDetailsStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<NvdimmNamespaceDetailsStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(NvdimmNamespaceDetailsStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for NvdimmNamespaceDetailsStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for NvdimmNamespaceDetailsStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a NvdimmNamespaceDetailsStateEnum> for &'a str {
    fn from(value: &'a NvdimmNamespaceDetailsStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for NvdimmNamespaceDetailsStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static NVDIMM_NAMESPACE_HEALTH_STATUS_ENUM_MAP: phf::Map<&'static str, NvdimmNamespaceHealthStatusEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (3, 2),
        (2, 0),
    ],
    entries: &[
        ("interleaveBroken", NvdimmNamespaceHealthStatusEnum::InterleaveBroken),
        ("bttCorrupt", NvdimmNamespaceHealthStatusEnum::BttCorrupt),
        ("normal", NvdimmNamespaceHealthStatusEnum::Normal),
        ("labelMissing", NvdimmNamespaceHealthStatusEnum::LabelMissing),
        ("badBlockSize", NvdimmNamespaceHealthStatusEnum::BadBlockSize),
        ("missing", NvdimmNamespaceHealthStatusEnum::Missing),
        ("labelInconsistent", NvdimmNamespaceHealthStatusEnum::LabelInconsistent),
    ],
};

impl NvdimmNamespaceHealthStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            NvdimmNamespaceHealthStatusEnum::Normal => "normal",
            NvdimmNamespaceHealthStatusEnum::Missing => "missing",
            NvdimmNamespaceHealthStatusEnum::LabelMissing => "labelMissing",
            NvdimmNamespaceHealthStatusEnum::InterleaveBroken => "interleaveBroken",
            NvdimmNamespaceHealthStatusEnum::LabelInconsistent => "labelInconsistent",
            NvdimmNamespaceHealthStatusEnum::BttCorrupt => "bttCorrupt",
            NvdimmNamespaceHealthStatusEnum::BadBlockSize => "badBlockSize",
            NvdimmNamespaceHealthStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        NVDIMM_NAMESPACE_HEALTH_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| NvdimmNamespaceHealthStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for NvdimmNamespaceHealthStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for NvdimmNamespaceHealthStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<NvdimmNamespaceHealthStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(NvdimmNamespaceHealthStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for NvdimmNamespaceHealthStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for NvdimmNamespaceHealthStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a NvdimmNamespaceHealthStatusEnum> for &'a str {
    fn from(value: &'a NvdimmNamespaceHealthStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for NvdimmNamespaceHealthStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static NVDIMM_NAMESPACE_STATE_ENUM_MAP: phf::Map<&'static str, NvdimmNamespaceStateEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("invalid", NvdimmNamespaceStateEnum::Invalid),
        ("inUse", NvdimmNamespaceStateEnum::InUse),
        ("notInUse", NvdimmNamespaceStateEnum::NotInUse),
    ],
};

impl NvdimmNamespaceStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            NvdimmNamespaceStateEnum::Invalid => "invalid",
            NvdimmNamespaceStateEnum::NotInUse => "notInUse",
            NvdimmNamespaceStateEnum::InUse => "inUse",
            NvdimmNamespaceStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        NVDIMM_NAMESPACE_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| NvdimmNamespaceStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for NvdimmNamespaceStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for NvdimmNamespaceStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<NvdimmNamespaceStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(NvdimmNamespaceStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for NvdimmNamespaceStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for NvdimmNamespaceStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a NvdimmNamespaceStateEnum> for &'a str {
    fn from(value: &'a NvdimmNamespaceStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for NvdimmNamespaceStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static NVDIMM_NAMESPACE_TYPE_ENUM_MAP: phf::Map<&'static str, NvdimmNamespaceTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("blockNamespace", NvdimmNamespaceTypeEnum::BlockNamespace),
        ("persistentNamespace", NvdimmNamespaceTypeEnum::PersistentNamespace),
    ],
};

impl NvdimmNamespaceTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            NvdimmNamespaceTypeEnum::BlockNamespace => "blockNamespace",
            NvdimmNamespaceTypeEnum::PersistentNamespace => "persistentNamespace",
            NvdimmNamespaceTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        NVDIMM_NAMESPACE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| NvdimmNamespaceTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for NvdimmNamespaceTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for NvdimmNamespaceTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<NvdimmNamespaceTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(NvdimmNamespaceTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for NvdimmNamespaceTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for NvdimmNamespaceTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a NvdimmNamespaceTypeEnum> for &'a str {
    fn from(value: &'a NvdimmNamespaceTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for NvdimmNamespaceTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static NVDIMM_RANGE_TYPE_ENUM_MAP: phf::Map<&'static str, NvdimmRangeTypeEnum> = ::phf::Map {
    key: 2980949210194914378,
    disps: &[
        (1, 0),
        (4, 7),
    ],
    entries: &[
        ("blockRange", NvdimmRangeTypeEnum::BlockRange),
        ("persistentVirtualCDRange", NvdimmRangeTypeEnum::PersistentVirtualCdRange),
        ("controlRange", NvdimmRangeTypeEnum::ControlRange),
        ("volatileRange", NvdimmRangeTypeEnum::VolatileRange),
        ("volatileVirtualDiskRange", NvdimmRangeTypeEnum::VolatileVirtualDiskRange),
        ("persistentRange", NvdimmRangeTypeEnum::PersistentRange),
        ("volatileVirtualCDRange", NvdimmRangeTypeEnum::VolatileVirtualCdRange),
        ("persistentVirtualDiskRange", NvdimmRangeTypeEnum::PersistentVirtualDiskRange),
    ],
};

impl NvdimmRangeTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            NvdimmRangeTypeEnum::VolatileRange => "volatileRange",
            NvdimmRangeTypeEnum::PersistentRange => "persistentRange",
            NvdimmRangeTypeEnum::ControlRange => "controlRange",
            NvdimmRangeTypeEnum::BlockRange => "blockRange",
            NvdimmRangeTypeEnum::VolatileVirtualDiskRange => "volatileVirtualDiskRange",
            NvdimmRangeTypeEnum::VolatileVirtualCdRange => "volatileVirtualCDRange",
            NvdimmRangeTypeEnum::PersistentVirtualDiskRange => "persistentVirtualDiskRange",
            NvdimmRangeTypeEnum::PersistentVirtualCdRange => "persistentVirtualCDRange",
            NvdimmRangeTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        NVDIMM_RANGE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| NvdimmRangeTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for NvdimmRangeTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for NvdimmRangeTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<NvdimmRangeTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(NvdimmRangeTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for NvdimmRangeTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for NvdimmRangeTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a NvdimmRangeTypeEnum> for &'a str {
    fn from(value: &'a NvdimmRangeTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for NvdimmRangeTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_NVME_DISCOVERY_LOG_SUBSYSTEM_TYPE_ENUM_MAP: phf::Map<&'static str, HostNvmeDiscoveryLogSubsystemTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("nvm", HostNvmeDiscoveryLogSubsystemTypeEnum::Nvm),
        ("discovery", HostNvmeDiscoveryLogSubsystemTypeEnum::Discovery),
    ],
};

impl HostNvmeDiscoveryLogSubsystemTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostNvmeDiscoveryLogSubsystemTypeEnum::Discovery => "discovery",
            HostNvmeDiscoveryLogSubsystemTypeEnum::Nvm => "nvm",
            HostNvmeDiscoveryLogSubsystemTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_NVME_DISCOVERY_LOG_SUBSYSTEM_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostNvmeDiscoveryLogSubsystemTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostNvmeDiscoveryLogSubsystemTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostNvmeDiscoveryLogSubsystemTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostNvmeDiscoveryLogSubsystemTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostNvmeDiscoveryLogSubsystemTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostNvmeDiscoveryLogSubsystemTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostNvmeDiscoveryLogSubsystemTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostNvmeDiscoveryLogSubsystemTypeEnum> for &'a str {
    fn from(value: &'a HostNvmeDiscoveryLogSubsystemTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostNvmeDiscoveryLogSubsystemTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_NVME_DISCOVERY_LOG_TRANSPORT_REQUIREMENTS_ENUM_MAP: phf::Map<&'static str, HostNvmeDiscoveryLogTransportRequirementsEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("requirementsNotSpecified", HostNvmeDiscoveryLogTransportRequirementsEnum::RequirementsNotSpecified),
        ("secureChannelRequired", HostNvmeDiscoveryLogTransportRequirementsEnum::SecureChannelRequired),
        ("secureChannelNotRequired", HostNvmeDiscoveryLogTransportRequirementsEnum::SecureChannelNotRequired),
    ],
};

impl HostNvmeDiscoveryLogTransportRequirementsEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostNvmeDiscoveryLogTransportRequirementsEnum::SecureChannelRequired => "secureChannelRequired",
            HostNvmeDiscoveryLogTransportRequirementsEnum::SecureChannelNotRequired => "secureChannelNotRequired",
            HostNvmeDiscoveryLogTransportRequirementsEnum::RequirementsNotSpecified => "requirementsNotSpecified",
            HostNvmeDiscoveryLogTransportRequirementsEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_NVME_DISCOVERY_LOG_TRANSPORT_REQUIREMENTS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostNvmeDiscoveryLogTransportRequirementsEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostNvmeDiscoveryLogTransportRequirementsEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostNvmeDiscoveryLogTransportRequirementsEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostNvmeDiscoveryLogTransportRequirementsEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostNvmeDiscoveryLogTransportRequirementsEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostNvmeDiscoveryLogTransportRequirementsEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostNvmeDiscoveryLogTransportRequirementsEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostNvmeDiscoveryLogTransportRequirementsEnum> for &'a str {
    fn from(value: &'a HostNvmeDiscoveryLogTransportRequirementsEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostNvmeDiscoveryLogTransportRequirementsEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_NVME_TRANSPORT_PARAMETERS_NVME_ADDRESS_FAMILY_ENUM_MAP: phf::Map<&'static str, HostNvmeTransportParametersNvmeAddressFamilyEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
        (0, 0),
    ],
    entries: &[
        ("fc", HostNvmeTransportParametersNvmeAddressFamilyEnum::Fc),
        ("ipv6", HostNvmeTransportParametersNvmeAddressFamilyEnum::Ipv6),
        ("loopback", HostNvmeTransportParametersNvmeAddressFamilyEnum::Loopback),
        ("infiniBand", HostNvmeTransportParametersNvmeAddressFamilyEnum::InfiniBand),
        ("unknown", HostNvmeTransportParametersNvmeAddressFamilyEnum::Unknown),
        ("ipv4", HostNvmeTransportParametersNvmeAddressFamilyEnum::Ipv4),
    ],
};

impl HostNvmeTransportParametersNvmeAddressFamilyEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostNvmeTransportParametersNvmeAddressFamilyEnum::Ipv4 => "ipv4",
            HostNvmeTransportParametersNvmeAddressFamilyEnum::Ipv6 => "ipv6",
            HostNvmeTransportParametersNvmeAddressFamilyEnum::InfiniBand => "infiniBand",
            HostNvmeTransportParametersNvmeAddressFamilyEnum::Fc => "fc",
            HostNvmeTransportParametersNvmeAddressFamilyEnum::Loopback => "loopback",
            HostNvmeTransportParametersNvmeAddressFamilyEnum::Unknown => "unknown",
            HostNvmeTransportParametersNvmeAddressFamilyEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_NVME_TRANSPORT_PARAMETERS_NVME_ADDRESS_FAMILY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostNvmeTransportParametersNvmeAddressFamilyEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostNvmeTransportParametersNvmeAddressFamilyEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostNvmeTransportParametersNvmeAddressFamilyEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostNvmeTransportParametersNvmeAddressFamilyEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostNvmeTransportParametersNvmeAddressFamilyEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostNvmeTransportParametersNvmeAddressFamilyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostNvmeTransportParametersNvmeAddressFamilyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostNvmeTransportParametersNvmeAddressFamilyEnum> for &'a str {
    fn from(value: &'a HostNvmeTransportParametersNvmeAddressFamilyEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostNvmeTransportParametersNvmeAddressFamilyEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_NVME_TRANSPORT_TYPE_ENUM_MAP: phf::Map<&'static str, HostNvmeTransportTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
        (0, 1),
    ],
    entries: &[
        ("rdma", HostNvmeTransportTypeEnum::Rdma),
        ("unsupported", HostNvmeTransportTypeEnum::Unsupported),
        ("loopback", HostNvmeTransportTypeEnum::Loopback),
        ("fibreChannel", HostNvmeTransportTypeEnum::FibreChannel),
        ("pcie", HostNvmeTransportTypeEnum::Pcie),
        ("tcp", HostNvmeTransportTypeEnum::Tcp),
    ],
};

impl HostNvmeTransportTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostNvmeTransportTypeEnum::Pcie => "pcie",
            HostNvmeTransportTypeEnum::FibreChannel => "fibreChannel",
            HostNvmeTransportTypeEnum::Rdma => "rdma",
            HostNvmeTransportTypeEnum::Tcp => "tcp",
            HostNvmeTransportTypeEnum::Loopback => "loopback",
            HostNvmeTransportTypeEnum::Unsupported => "unsupported",
            HostNvmeTransportTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_NVME_TRANSPORT_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostNvmeTransportTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostNvmeTransportTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostNvmeTransportTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostNvmeTransportTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostNvmeTransportTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostNvmeTransportTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostNvmeTransportTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostNvmeTransportTypeEnum> for &'a str {
    fn from(value: &'a HostNvmeTransportTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostNvmeTransportTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_OPAQUE_SWITCH_OPAQUE_SWITCH_STATE_ENUM_MAP: phf::Map<&'static str, HostOpaqueSwitchOpaqueSwitchStateEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("maintenance", HostOpaqueSwitchOpaqueSwitchStateEnum::Maintenance),
        ("down", HostOpaqueSwitchOpaqueSwitchStateEnum::Down),
        ("warning", HostOpaqueSwitchOpaqueSwitchStateEnum::Warning),
        ("up", HostOpaqueSwitchOpaqueSwitchStateEnum::Up),
    ],
};

impl HostOpaqueSwitchOpaqueSwitchStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostOpaqueSwitchOpaqueSwitchStateEnum::Up => "up",
            HostOpaqueSwitchOpaqueSwitchStateEnum::Warning => "warning",
            HostOpaqueSwitchOpaqueSwitchStateEnum::Down => "down",
            HostOpaqueSwitchOpaqueSwitchStateEnum::Maintenance => "maintenance",
            HostOpaqueSwitchOpaqueSwitchStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_OPAQUE_SWITCH_OPAQUE_SWITCH_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostOpaqueSwitchOpaqueSwitchStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostOpaqueSwitchOpaqueSwitchStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostOpaqueSwitchOpaqueSwitchStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostOpaqueSwitchOpaqueSwitchStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostOpaqueSwitchOpaqueSwitchStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostOpaqueSwitchOpaqueSwitchStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostOpaqueSwitchOpaqueSwitchStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostOpaqueSwitchOpaqueSwitchStateEnum> for &'a str {
    fn from(value: &'a HostOpaqueSwitchOpaqueSwitchStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostOpaqueSwitchOpaqueSwitchStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_PARTIAL_MAINTENANCE_MODE_ID_ENUM_MAP: phf::Map<&'static str, HostPartialMaintenanceModeIdEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("quickPatchPartialMM", HostPartialMaintenanceModeIdEnum::QuickPatchPartialMm),
    ],
};

impl HostPartialMaintenanceModeIdEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostPartialMaintenanceModeIdEnum::QuickPatchPartialMm => "quickPatchPartialMM",
            HostPartialMaintenanceModeIdEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_PARTIAL_MAINTENANCE_MODE_ID_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostPartialMaintenanceModeIdEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostPartialMaintenanceModeIdEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostPartialMaintenanceModeIdEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostPartialMaintenanceModeIdEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostPartialMaintenanceModeIdEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostPartialMaintenanceModeIdEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostPartialMaintenanceModeIdEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostPartialMaintenanceModeIdEnum> for &'a str {
    fn from(value: &'a HostPartialMaintenanceModeIdEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostPartialMaintenanceModeIdEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_PARTIAL_MAINTENANCE_MODE_STATUS_ENUM_MAP: phf::Map<&'static str, HostPartialMaintenanceModeStatusEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("enteringPartialMM", HostPartialMaintenanceModeStatusEnum::EnteringPartialMm),
        ("inPartialMM", HostPartialMaintenanceModeStatusEnum::InPartialMm),
        ("notInPartialMM", HostPartialMaintenanceModeStatusEnum::NotInPartialMm),
        ("exitingPartialMM", HostPartialMaintenanceModeStatusEnum::ExitingPartialMm),
    ],
};

impl HostPartialMaintenanceModeStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostPartialMaintenanceModeStatusEnum::NotInPartialMm => "notInPartialMM",
            HostPartialMaintenanceModeStatusEnum::EnteringPartialMm => "enteringPartialMM",
            HostPartialMaintenanceModeStatusEnum::ExitingPartialMm => "exitingPartialMM",
            HostPartialMaintenanceModeStatusEnum::InPartialMm => "inPartialMM",
            HostPartialMaintenanceModeStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_PARTIAL_MAINTENANCE_MODE_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostPartialMaintenanceModeStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostPartialMaintenanceModeStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostPartialMaintenanceModeStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostPartialMaintenanceModeStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostPartialMaintenanceModeStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostPartialMaintenanceModeStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostPartialMaintenanceModeStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostPartialMaintenanceModeStatusEnum> for &'a str {
    fn from(value: &'a HostPartialMaintenanceModeStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostPartialMaintenanceModeStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_PATCH_MANAGER_INSTALL_STATE_ENUM_MAP: phf::Map<&'static str, HostPatchManagerInstallStateEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("hostRestarted", HostPatchManagerInstallStateEnum::HostRestarted),
        ("imageActive", HostPatchManagerInstallStateEnum::ImageActive),
    ],
};

impl HostPatchManagerInstallStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostPatchManagerInstallStateEnum::HostRestarted => "hostRestarted",
            HostPatchManagerInstallStateEnum::ImageActive => "imageActive",
            HostPatchManagerInstallStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_PATCH_MANAGER_INSTALL_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostPatchManagerInstallStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostPatchManagerInstallStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostPatchManagerInstallStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostPatchManagerInstallStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostPatchManagerInstallStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostPatchManagerInstallStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostPatchManagerInstallStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostPatchManagerInstallStateEnum> for &'a str {
    fn from(value: &'a HostPatchManagerInstallStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostPatchManagerInstallStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_PATCH_MANAGER_INTEGRITY_STATUS_ENUM_MAP: phf::Map<&'static str, HostPatchManagerIntegrityStatusEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (1, 0),
        (1, 5),
    ],
    entries: &[
        ("validationError", HostPatchManagerIntegrityStatusEnum::ValidationError),
        ("notEnoughSignatures", HostPatchManagerIntegrityStatusEnum::NotEnoughSignatures),
        ("validated", HostPatchManagerIntegrityStatusEnum::Validated),
        ("keyExpired", HostPatchManagerIntegrityStatusEnum::KeyExpired),
        ("keyNotFound", HostPatchManagerIntegrityStatusEnum::KeyNotFound),
        ("digestMismatch", HostPatchManagerIntegrityStatusEnum::DigestMismatch),
        ("keyRevoked", HostPatchManagerIntegrityStatusEnum::KeyRevoked),
    ],
};

impl HostPatchManagerIntegrityStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostPatchManagerIntegrityStatusEnum::Validated => "validated",
            HostPatchManagerIntegrityStatusEnum::KeyNotFound => "keyNotFound",
            HostPatchManagerIntegrityStatusEnum::KeyRevoked => "keyRevoked",
            HostPatchManagerIntegrityStatusEnum::KeyExpired => "keyExpired",
            HostPatchManagerIntegrityStatusEnum::DigestMismatch => "digestMismatch",
            HostPatchManagerIntegrityStatusEnum::NotEnoughSignatures => "notEnoughSignatures",
            HostPatchManagerIntegrityStatusEnum::ValidationError => "validationError",
            HostPatchManagerIntegrityStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_PATCH_MANAGER_INTEGRITY_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostPatchManagerIntegrityStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostPatchManagerIntegrityStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostPatchManagerIntegrityStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostPatchManagerIntegrityStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostPatchManagerIntegrityStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostPatchManagerIntegrityStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostPatchManagerIntegrityStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostPatchManagerIntegrityStatusEnum> for &'a str {
    fn from(value: &'a HostPatchManagerIntegrityStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostPatchManagerIntegrityStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_PATCH_MANAGER_REASON_ENUM_MAP: phf::Map<&'static str, HostPatchManagerReasonEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 4),
        (0, 0),
    ],
    entries: &[
        ("obsoleted", HostPatchManagerReasonEnum::Obsoleted),
        ("conflictLib", HostPatchManagerReasonEnum::ConflictLib),
        ("conflictPatch", HostPatchManagerReasonEnum::ConflictPatch),
        ("hasDependentPatch", HostPatchManagerReasonEnum::HasDependentPatch),
        ("missingLib", HostPatchManagerReasonEnum::MissingLib),
        ("missingPatch", HostPatchManagerReasonEnum::MissingPatch),
    ],
};

impl HostPatchManagerReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostPatchManagerReasonEnum::Obsoleted => "obsoleted",
            HostPatchManagerReasonEnum::MissingPatch => "missingPatch",
            HostPatchManagerReasonEnum::MissingLib => "missingLib",
            HostPatchManagerReasonEnum::HasDependentPatch => "hasDependentPatch",
            HostPatchManagerReasonEnum::ConflictPatch => "conflictPatch",
            HostPatchManagerReasonEnum::ConflictLib => "conflictLib",
            HostPatchManagerReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_PATCH_MANAGER_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostPatchManagerReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostPatchManagerReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostPatchManagerReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostPatchManagerReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostPatchManagerReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostPatchManagerReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostPatchManagerReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostPatchManagerReasonEnum> for &'a str {
    fn from(value: &'a HostPatchManagerReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostPatchManagerReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PHYSICAL_NIC_RESOURCE_POOL_SCHEDULER_DISALLOWED_REASON_ENUM_MAP: phf::Map<&'static str, PhysicalNicResourcePoolSchedulerDisallowedReasonEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("hardwareUnsupported", PhysicalNicResourcePoolSchedulerDisallowedReasonEnum::HardwareUnsupported),
        ("userOptOut", PhysicalNicResourcePoolSchedulerDisallowedReasonEnum::UserOptOut),
    ],
};

impl PhysicalNicResourcePoolSchedulerDisallowedReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PhysicalNicResourcePoolSchedulerDisallowedReasonEnum::UserOptOut => "userOptOut",
            PhysicalNicResourcePoolSchedulerDisallowedReasonEnum::HardwareUnsupported => "hardwareUnsupported",
            PhysicalNicResourcePoolSchedulerDisallowedReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PHYSICAL_NIC_RESOURCE_POOL_SCHEDULER_DISALLOWED_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PhysicalNicResourcePoolSchedulerDisallowedReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PhysicalNicResourcePoolSchedulerDisallowedReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PhysicalNicResourcePoolSchedulerDisallowedReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PhysicalNicResourcePoolSchedulerDisallowedReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PhysicalNicResourcePoolSchedulerDisallowedReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PhysicalNicResourcePoolSchedulerDisallowedReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PhysicalNicResourcePoolSchedulerDisallowedReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PhysicalNicResourcePoolSchedulerDisallowedReasonEnum> for &'a str {
    fn from(value: &'a PhysicalNicResourcePoolSchedulerDisallowedReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PhysicalNicResourcePoolSchedulerDisallowedReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PHYSICAL_NIC_VM_DIRECT_PATH_GEN_2_SUPPORTED_MODE_ENUM_MAP: phf::Map<&'static str, PhysicalNicVmDirectPathGen2SupportedModeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("upt", PhysicalNicVmDirectPathGen2SupportedModeEnum::Upt),
    ],
};

impl PhysicalNicVmDirectPathGen2SupportedModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PhysicalNicVmDirectPathGen2SupportedModeEnum::Upt => "upt",
            PhysicalNicVmDirectPathGen2SupportedModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PHYSICAL_NIC_VM_DIRECT_PATH_GEN_2_SUPPORTED_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PhysicalNicVmDirectPathGen2SupportedModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PhysicalNicVmDirectPathGen2SupportedModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PhysicalNicVmDirectPathGen2SupportedModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PhysicalNicVmDirectPathGen2SupportedModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PhysicalNicVmDirectPathGen2SupportedModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PhysicalNicVmDirectPathGen2SupportedModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PhysicalNicVmDirectPathGen2SupportedModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PhysicalNicVmDirectPathGen2SupportedModeEnum> for &'a str {
    fn from(value: &'a PhysicalNicVmDirectPathGen2SupportedModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PhysicalNicVmDirectPathGen2SupportedModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PORT_GROUP_CONNECTEE_TYPE_ENUM_MAP: phf::Map<&'static str, PortGroupConnecteeTypeEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (3, 0),
    ],
    entries: &[
        ("systemManagement", PortGroupConnecteeTypeEnum::SystemManagement),
        ("unknown", PortGroupConnecteeTypeEnum::Unknown),
        ("virtualMachine", PortGroupConnecteeTypeEnum::VirtualMachine),
        ("host", PortGroupConnecteeTypeEnum::Host),
    ],
};

impl PortGroupConnecteeTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PortGroupConnecteeTypeEnum::VirtualMachine => "virtualMachine",
            PortGroupConnecteeTypeEnum::SystemManagement => "systemManagement",
            PortGroupConnecteeTypeEnum::Host => "host",
            PortGroupConnecteeTypeEnum::Unknown => "unknown",
            PortGroupConnecteeTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PORT_GROUP_CONNECTEE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PortGroupConnecteeTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PortGroupConnecteeTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PortGroupConnecteeTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PortGroupConnecteeTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PortGroupConnecteeTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PortGroupConnecteeTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PortGroupConnecteeTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PortGroupConnecteeTypeEnum> for &'a str {
    fn from(value: &'a PortGroupConnecteeTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PortGroupConnecteeTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_PROTOCOL_ENDPOINT_PE_TYPE_ENUM_MAP: phf::Map<&'static str, HostProtocolEndpointPeTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("nas", HostProtocolEndpointPeTypeEnum::Nas),
        ("block", HostProtocolEndpointPeTypeEnum::Block),
    ],
};

impl HostProtocolEndpointPeTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostProtocolEndpointPeTypeEnum::Block => "block",
            HostProtocolEndpointPeTypeEnum::Nas => "nas",
            HostProtocolEndpointPeTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_PROTOCOL_ENDPOINT_PE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostProtocolEndpointPeTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostProtocolEndpointPeTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostProtocolEndpointPeTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostProtocolEndpointPeTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostProtocolEndpointPeTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostProtocolEndpointPeTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostProtocolEndpointPeTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostProtocolEndpointPeTypeEnum> for &'a str {
    fn from(value: &'a HostProtocolEndpointPeTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostProtocolEndpointPeTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_PROTOCOL_ENDPOINT_PROTOCOL_ENDPOINT_TYPE_ENUM_MAP: phf::Map<&'static str, HostProtocolEndpointProtocolEndpointTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("nfs", HostProtocolEndpointProtocolEndpointTypeEnum::Nfs),
        ("scsi", HostProtocolEndpointProtocolEndpointTypeEnum::Scsi),
        ("nfs4x", HostProtocolEndpointProtocolEndpointTypeEnum::Nfs4X),
    ],
};

impl HostProtocolEndpointProtocolEndpointTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostProtocolEndpointProtocolEndpointTypeEnum::Scsi => "scsi",
            HostProtocolEndpointProtocolEndpointTypeEnum::Nfs => "nfs",
            HostProtocolEndpointProtocolEndpointTypeEnum::Nfs4X => "nfs4x",
            HostProtocolEndpointProtocolEndpointTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_PROTOCOL_ENDPOINT_PROTOCOL_ENDPOINT_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostProtocolEndpointProtocolEndpointTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostProtocolEndpointProtocolEndpointTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostProtocolEndpointProtocolEndpointTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostProtocolEndpointProtocolEndpointTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostProtocolEndpointProtocolEndpointTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostProtocolEndpointProtocolEndpointTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostProtocolEndpointProtocolEndpointTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostProtocolEndpointProtocolEndpointTypeEnum> for &'a str {
    fn from(value: &'a HostProtocolEndpointProtocolEndpointTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostProtocolEndpointProtocolEndpointTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_PTP_CONFIG_DEVICE_TYPE_ENUM_MAP: phf::Map<&'static str, HostPtpConfigDeviceTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("none", HostPtpConfigDeviceTypeEnum::None),
        ("virtualNic", HostPtpConfigDeviceTypeEnum::VirtualNic),
        ("pciPassthruNic", HostPtpConfigDeviceTypeEnum::PciPassthruNic),
    ],
};

impl HostPtpConfigDeviceTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostPtpConfigDeviceTypeEnum::None => "none",
            HostPtpConfigDeviceTypeEnum::VirtualNic => "virtualNic",
            HostPtpConfigDeviceTypeEnum::PciPassthruNic => "pciPassthruNic",
            HostPtpConfigDeviceTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_PTP_CONFIG_DEVICE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostPtpConfigDeviceTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostPtpConfigDeviceTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostPtpConfigDeviceTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostPtpConfigDeviceTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostPtpConfigDeviceTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostPtpConfigDeviceTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostPtpConfigDeviceTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostPtpConfigDeviceTypeEnum> for &'a str {
    fn from(value: &'a HostPtpConfigDeviceTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostPtpConfigDeviceTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_QUALIFIED_NAME_TYPE_ENUM_MAP: phf::Map<&'static str, HostQualifiedNameTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("nvmeQualifiedName", HostQualifiedNameTypeEnum::NvmeQualifiedName),
        ("vvolNvmeQualifiedName", HostQualifiedNameTypeEnum::VvolNvmeQualifiedName),
    ],
};

impl HostQualifiedNameTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostQualifiedNameTypeEnum::NvmeQualifiedName => "nvmeQualifiedName",
            HostQualifiedNameTypeEnum::VvolNvmeQualifiedName => "vvolNvmeQualifiedName",
            HostQualifiedNameTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_QUALIFIED_NAME_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostQualifiedNameTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostQualifiedNameTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostQualifiedNameTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostQualifiedNameTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostQualifiedNameTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostQualifiedNameTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostQualifiedNameTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostQualifiedNameTypeEnum> for &'a str {
    fn from(value: &'a HostQualifiedNameTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostQualifiedNameTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_RDMA_DEVICE_CONNECTION_STATE_ENUM_MAP: phf::Map<&'static str, HostRdmaDeviceConnectionStateEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (2, 2),
        (0, 0),
    ],
    entries: &[
        ("active", HostRdmaDeviceConnectionStateEnum::Active),
        ("armed", HostRdmaDeviceConnectionStateEnum::Armed),
        ("init", HostRdmaDeviceConnectionStateEnum::Init),
        ("down", HostRdmaDeviceConnectionStateEnum::Down),
        ("unknown", HostRdmaDeviceConnectionStateEnum::Unknown),
        ("activeDefer", HostRdmaDeviceConnectionStateEnum::ActiveDefer),
    ],
};

impl HostRdmaDeviceConnectionStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostRdmaDeviceConnectionStateEnum::Unknown => "unknown",
            HostRdmaDeviceConnectionStateEnum::Down => "down",
            HostRdmaDeviceConnectionStateEnum::Init => "init",
            HostRdmaDeviceConnectionStateEnum::Armed => "armed",
            HostRdmaDeviceConnectionStateEnum::Active => "active",
            HostRdmaDeviceConnectionStateEnum::ActiveDefer => "activeDefer",
            HostRdmaDeviceConnectionStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_RDMA_DEVICE_CONNECTION_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostRdmaDeviceConnectionStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostRdmaDeviceConnectionStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostRdmaDeviceConnectionStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostRdmaDeviceConnectionStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostRdmaDeviceConnectionStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostRdmaDeviceConnectionStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostRdmaDeviceConnectionStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostRdmaDeviceConnectionStateEnum> for &'a str {
    fn from(value: &'a HostRdmaDeviceConnectionStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostRdmaDeviceConnectionStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static RDMA_PROTOCOL_ENUM_MAP: phf::Map<&'static str, RdmaProtocolEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("RoCEv2", RdmaProtocolEnum::RoCEv2),
    ],
};

impl RdmaProtocolEnum {
    pub fn as_str(&self) -> &str {
        match self {
            RdmaProtocolEnum::RoCEv2 => "RoCEv2",
            RdmaProtocolEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        RDMA_PROTOCOL_ENUM_MAP.get(s).cloned().unwrap_or_else(|| RdmaProtocolEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for RdmaProtocolEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for RdmaProtocolEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<RdmaProtocolEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(RdmaProtocolEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for RdmaProtocolEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for RdmaProtocolEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a RdmaProtocolEnum> for &'a str {
    fn from(value: &'a RdmaProtocolEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for RdmaProtocolEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_FIREWALL_RULE_DIRECTION_ENUM_MAP: phf::Map<&'static str, HostFirewallRuleDirectionEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("inbound", HostFirewallRuleDirectionEnum::Inbound),
        ("outbound", HostFirewallRuleDirectionEnum::Outbound),
    ],
};

impl HostFirewallRuleDirectionEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostFirewallRuleDirectionEnum::Inbound => "inbound",
            HostFirewallRuleDirectionEnum::Outbound => "outbound",
            HostFirewallRuleDirectionEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_FIREWALL_RULE_DIRECTION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostFirewallRuleDirectionEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostFirewallRuleDirectionEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostFirewallRuleDirectionEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostFirewallRuleDirectionEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostFirewallRuleDirectionEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostFirewallRuleDirectionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostFirewallRuleDirectionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostFirewallRuleDirectionEnum> for &'a str {
    fn from(value: &'a HostFirewallRuleDirectionEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostFirewallRuleDirectionEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_FIREWALL_RULE_PORT_TYPE_ENUM_MAP: phf::Map<&'static str, HostFirewallRulePortTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("dst", HostFirewallRulePortTypeEnum::Dst),
        ("src", HostFirewallRulePortTypeEnum::Src),
    ],
};

impl HostFirewallRulePortTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostFirewallRulePortTypeEnum::Src => "src",
            HostFirewallRulePortTypeEnum::Dst => "dst",
            HostFirewallRulePortTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_FIREWALL_RULE_PORT_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostFirewallRulePortTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostFirewallRulePortTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostFirewallRulePortTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostFirewallRulePortTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostFirewallRulePortTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostFirewallRulePortTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostFirewallRulePortTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostFirewallRulePortTypeEnum> for &'a str {
    fn from(value: &'a HostFirewallRulePortTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostFirewallRulePortTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_FIREWALL_RULE_PROTOCOL_ENUM_MAP: phf::Map<&'static str, HostFirewallRuleProtocolEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("tcp", HostFirewallRuleProtocolEnum::Tcp),
        ("udp", HostFirewallRuleProtocolEnum::Udp),
    ],
};

impl HostFirewallRuleProtocolEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostFirewallRuleProtocolEnum::Tcp => "tcp",
            HostFirewallRuleProtocolEnum::Udp => "udp",
            HostFirewallRuleProtocolEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_FIREWALL_RULE_PROTOCOL_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostFirewallRuleProtocolEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostFirewallRuleProtocolEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostFirewallRuleProtocolEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostFirewallRuleProtocolEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostFirewallRuleProtocolEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostFirewallRuleProtocolEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostFirewallRuleProtocolEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostFirewallRuleProtocolEnum> for &'a str {
    fn from(value: &'a HostFirewallRuleProtocolEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostFirewallRuleProtocolEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_RUNTIME_INFO_NET_STACK_INSTANCE_RUNTIME_INFO_STATE_ENUM_MAP: phf::Map<&'static str, HostRuntimeInfoNetStackInstanceRuntimeInfoStateEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("inactive", HostRuntimeInfoNetStackInstanceRuntimeInfoStateEnum::Inactive),
        ("active", HostRuntimeInfoNetStackInstanceRuntimeInfoStateEnum::Active),
        ("deactivating", HostRuntimeInfoNetStackInstanceRuntimeInfoStateEnum::Deactivating),
        ("activating", HostRuntimeInfoNetStackInstanceRuntimeInfoStateEnum::Activating),
    ],
};

impl HostRuntimeInfoNetStackInstanceRuntimeInfoStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostRuntimeInfoNetStackInstanceRuntimeInfoStateEnum::Inactive => "inactive",
            HostRuntimeInfoNetStackInstanceRuntimeInfoStateEnum::Active => "active",
            HostRuntimeInfoNetStackInstanceRuntimeInfoStateEnum::Deactivating => "deactivating",
            HostRuntimeInfoNetStackInstanceRuntimeInfoStateEnum::Activating => "activating",
            HostRuntimeInfoNetStackInstanceRuntimeInfoStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_RUNTIME_INFO_NET_STACK_INSTANCE_RUNTIME_INFO_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostRuntimeInfoNetStackInstanceRuntimeInfoStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostRuntimeInfoNetStackInstanceRuntimeInfoStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostRuntimeInfoNetStackInstanceRuntimeInfoStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostRuntimeInfoNetStackInstanceRuntimeInfoStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostRuntimeInfoNetStackInstanceRuntimeInfoStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostRuntimeInfoNetStackInstanceRuntimeInfoStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostRuntimeInfoNetStackInstanceRuntimeInfoStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostRuntimeInfoNetStackInstanceRuntimeInfoStateEnum> for &'a str {
    fn from(value: &'a HostRuntimeInfoNetStackInstanceRuntimeInfoStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostRuntimeInfoNetStackInstanceRuntimeInfoStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_RUNTIME_INFO_STATE_ENCRYPTION_INFO_PROTECTION_MODE_ENUM_MAP: phf::Map<&'static str, HostRuntimeInfoStateEncryptionInfoProtectionModeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("none", HostRuntimeInfoStateEncryptionInfoProtectionModeEnum::None),
        ("tpm", HostRuntimeInfoStateEncryptionInfoProtectionModeEnum::Tpm),
    ],
};

impl HostRuntimeInfoStateEncryptionInfoProtectionModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostRuntimeInfoStateEncryptionInfoProtectionModeEnum::None => "none",
            HostRuntimeInfoStateEncryptionInfoProtectionModeEnum::Tpm => "tpm",
            HostRuntimeInfoStateEncryptionInfoProtectionModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_RUNTIME_INFO_STATE_ENCRYPTION_INFO_PROTECTION_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostRuntimeInfoStateEncryptionInfoProtectionModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostRuntimeInfoStateEncryptionInfoProtectionModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostRuntimeInfoStateEncryptionInfoProtectionModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostRuntimeInfoStateEncryptionInfoProtectionModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostRuntimeInfoStateEncryptionInfoProtectionModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostRuntimeInfoStateEncryptionInfoProtectionModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostRuntimeInfoStateEncryptionInfoProtectionModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostRuntimeInfoStateEncryptionInfoProtectionModeEnum> for &'a str {
    fn from(value: &'a HostRuntimeInfoStateEncryptionInfoProtectionModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostRuntimeInfoStateEncryptionInfoProtectionModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_RUNTIME_INFO_STATELESS_NVDS_MIGRATION_STATE_ENUM_MAP: phf::Map<&'static str, HostRuntimeInfoStatelessNvdsMigrationStateEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("ready", HostRuntimeInfoStatelessNvdsMigrationStateEnum::Ready),
        ("notNeeded", HostRuntimeInfoStatelessNvdsMigrationStateEnum::NotNeeded),
        ("unknown", HostRuntimeInfoStatelessNvdsMigrationStateEnum::Unknown),
    ],
};

impl HostRuntimeInfoStatelessNvdsMigrationStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostRuntimeInfoStatelessNvdsMigrationStateEnum::Ready => "ready",
            HostRuntimeInfoStatelessNvdsMigrationStateEnum::NotNeeded => "notNeeded",
            HostRuntimeInfoStatelessNvdsMigrationStateEnum::Unknown => "unknown",
            HostRuntimeInfoStatelessNvdsMigrationStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_RUNTIME_INFO_STATELESS_NVDS_MIGRATION_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostRuntimeInfoStatelessNvdsMigrationStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostRuntimeInfoStatelessNvdsMigrationStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostRuntimeInfoStatelessNvdsMigrationStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostRuntimeInfoStatelessNvdsMigrationStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostRuntimeInfoStatelessNvdsMigrationStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostRuntimeInfoStatelessNvdsMigrationStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostRuntimeInfoStatelessNvdsMigrationStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostRuntimeInfoStatelessNvdsMigrationStateEnum> for &'a str {
    fn from(value: &'a HostRuntimeInfoStatelessNvdsMigrationStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostRuntimeInfoStatelessNvdsMigrationStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static SCSI_DISK_TYPE_ENUM_MAP: phf::Map<&'static str, ScsiDiskTypeEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (3, 0),
    ],
    entries: &[
        ("SoftwareEmulated4k", ScsiDiskTypeEnum::SoftwareEmulated4K),
        ("native4k", ScsiDiskTypeEnum::Native4K),
        ("native512", ScsiDiskTypeEnum::Native512),
        ("unknown", ScsiDiskTypeEnum::Unknown),
        ("emulated512", ScsiDiskTypeEnum::Emulated512),
    ],
};

impl ScsiDiskTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ScsiDiskTypeEnum::Native512 => "native512",
            ScsiDiskTypeEnum::Emulated512 => "emulated512",
            ScsiDiskTypeEnum::Native4K => "native4k",
            ScsiDiskTypeEnum::SoftwareEmulated4K => "SoftwareEmulated4k",
            ScsiDiskTypeEnum::Unknown => "unknown",
            ScsiDiskTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        SCSI_DISK_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ScsiDiskTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ScsiDiskTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ScsiDiskTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ScsiDiskTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ScsiDiskTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ScsiDiskTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ScsiDiskTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ScsiDiskTypeEnum> for &'a str {
    fn from(value: &'a ScsiDiskTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ScsiDiskTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static SCSI_LUN_DESCRIPTOR_QUALITY_ENUM_MAP: phf::Map<&'static str, ScsiLunDescriptorQualityEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("lowQuality", ScsiLunDescriptorQualityEnum::LowQuality),
        ("unknownQuality", ScsiLunDescriptorQualityEnum::UnknownQuality),
        ("mediumQuality", ScsiLunDescriptorQualityEnum::MediumQuality),
        ("highQuality", ScsiLunDescriptorQualityEnum::HighQuality),
    ],
};

impl ScsiLunDescriptorQualityEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ScsiLunDescriptorQualityEnum::HighQuality => "highQuality",
            ScsiLunDescriptorQualityEnum::MediumQuality => "mediumQuality",
            ScsiLunDescriptorQualityEnum::LowQuality => "lowQuality",
            ScsiLunDescriptorQualityEnum::UnknownQuality => "unknownQuality",
            ScsiLunDescriptorQualityEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        SCSI_LUN_DESCRIPTOR_QUALITY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ScsiLunDescriptorQualityEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ScsiLunDescriptorQualityEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ScsiLunDescriptorQualityEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ScsiLunDescriptorQualityEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ScsiLunDescriptorQualityEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ScsiLunDescriptorQualityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ScsiLunDescriptorQualityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ScsiLunDescriptorQualityEnum> for &'a str {
    fn from(value: &'a ScsiLunDescriptorQualityEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ScsiLunDescriptorQualityEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DEVICE_PROTOCOL_ENUM_MAP: phf::Map<&'static str, DeviceProtocolEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("SCSI", DeviceProtocolEnum::Scsi),
        ("NVMe", DeviceProtocolEnum::NvMe),
    ],
};

impl DeviceProtocolEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DeviceProtocolEnum::NvMe => "NVMe",
            DeviceProtocolEnum::Scsi => "SCSI",
            DeviceProtocolEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DEVICE_PROTOCOL_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DeviceProtocolEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DeviceProtocolEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DeviceProtocolEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DeviceProtocolEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DeviceProtocolEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DeviceProtocolEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DeviceProtocolEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DeviceProtocolEnum> for &'a str {
    fn from(value: &'a DeviceProtocolEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DeviceProtocolEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static SCSI_LUN_LUN_RESERVATION_STATUS_ENUM_MAP: phf::Map<&'static str, ScsiLunLunReservationStatusEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("LUN_RESERVED_NO", ScsiLunLunReservationStatusEnum::LunReservedNo),
        ("LUN_RESERVED_UNKNOWN", ScsiLunLunReservationStatusEnum::LunReservedUnknown),
        ("LUN_RESERVED_YES", ScsiLunLunReservationStatusEnum::LunReservedYes),
        ("LUN_RESERVED_NOT_SUPPORTED", ScsiLunLunReservationStatusEnum::LunReservedNotSupported),
    ],
};

impl ScsiLunLunReservationStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ScsiLunLunReservationStatusEnum::LunReservedUnknown => "LUN_RESERVED_UNKNOWN",
            ScsiLunLunReservationStatusEnum::LunReservedYes => "LUN_RESERVED_YES",
            ScsiLunLunReservationStatusEnum::LunReservedNo => "LUN_RESERVED_NO",
            ScsiLunLunReservationStatusEnum::LunReservedNotSupported => "LUN_RESERVED_NOT_SUPPORTED",
            ScsiLunLunReservationStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        SCSI_LUN_LUN_RESERVATION_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ScsiLunLunReservationStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ScsiLunLunReservationStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ScsiLunLunReservationStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ScsiLunLunReservationStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ScsiLunLunReservationStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ScsiLunLunReservationStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ScsiLunLunReservationStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ScsiLunLunReservationStatusEnum> for &'a str {
    fn from(value: &'a ScsiLunLunReservationStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ScsiLunLunReservationStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static SCSI_LUN_TYPE_ENUM_MAP: phf::Map<&'static str, ScsiLunTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 4),
        (1, 12),
        (12, 0),
    ],
    entries: &[
        ("communications", ScsiLunTypeEnum::Communications),
        ("mediaChanger", ScsiLunTypeEnum::MediaChanger),
        ("unknown", ScsiLunTypeEnum::Unknown),
        ("cdrom", ScsiLunTypeEnum::Cdrom),
        ("enclosure", ScsiLunTypeEnum::Enclosure),
        ("disk", ScsiLunTypeEnum::Disk),
        ("printer", ScsiLunTypeEnum::Printer),
        ("storageArrayController", ScsiLunTypeEnum::StorageArrayController),
        ("scanner", ScsiLunTypeEnum::Scanner),
        ("tape", ScsiLunTypeEnum::Tape),
        ("opticalDevice", ScsiLunTypeEnum::OpticalDevice),
        ("processor", ScsiLunTypeEnum::Processor),
        ("worm", ScsiLunTypeEnum::Worm),
    ],
};

impl ScsiLunTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ScsiLunTypeEnum::Disk => "disk",
            ScsiLunTypeEnum::Tape => "tape",
            ScsiLunTypeEnum::Printer => "printer",
            ScsiLunTypeEnum::Processor => "processor",
            ScsiLunTypeEnum::Worm => "worm",
            ScsiLunTypeEnum::Cdrom => "cdrom",
            ScsiLunTypeEnum::Scanner => "scanner",
            ScsiLunTypeEnum::OpticalDevice => "opticalDevice",
            ScsiLunTypeEnum::MediaChanger => "mediaChanger",
            ScsiLunTypeEnum::Communications => "communications",
            ScsiLunTypeEnum::StorageArrayController => "storageArrayController",
            ScsiLunTypeEnum::Enclosure => "enclosure",
            ScsiLunTypeEnum::Unknown => "unknown",
            ScsiLunTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        SCSI_LUN_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ScsiLunTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ScsiLunTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ScsiLunTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ScsiLunTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ScsiLunTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ScsiLunTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ScsiLunTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ScsiLunTypeEnum> for &'a str {
    fn from(value: &'a ScsiLunTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ScsiLunTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static SCSI_LUN_STATE_ENUM_MAP: phf::Map<&'static str, ScsiLunStateEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (1, 7),
        (1, 0),
    ],
    entries: &[
        ("timeout", ScsiLunStateEnum::Timeout),
        ("lostCommunication", ScsiLunStateEnum::LostCommunication),
        ("degraded", ScsiLunStateEnum::Degraded),
        ("unknownState", ScsiLunStateEnum::UnknownState),
        ("ok", ScsiLunStateEnum::Ok),
        ("off", ScsiLunStateEnum::Off),
        ("quiesced", ScsiLunStateEnum::Quiesced),
        ("error", ScsiLunStateEnum::Error),
    ],
};

impl ScsiLunStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ScsiLunStateEnum::UnknownState => "unknownState",
            ScsiLunStateEnum::Ok => "ok",
            ScsiLunStateEnum::Error => "error",
            ScsiLunStateEnum::Off => "off",
            ScsiLunStateEnum::Quiesced => "quiesced",
            ScsiLunStateEnum::Degraded => "degraded",
            ScsiLunStateEnum::LostCommunication => "lostCommunication",
            ScsiLunStateEnum::Timeout => "timeout",
            ScsiLunStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        SCSI_LUN_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ScsiLunStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ScsiLunStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ScsiLunStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ScsiLunStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ScsiLunStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ScsiLunStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ScsiLunStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ScsiLunStateEnum> for &'a str {
    fn from(value: &'a ScsiLunStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ScsiLunStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static SCSI_LUN_V_STORAGE_SUPPORT_STATUS_ENUM_MAP: phf::Map<&'static str, ScsiLunVStorageSupportStatusEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("vStorageUnsupported", ScsiLunVStorageSupportStatusEnum::VStorageUnsupported),
        ("vStorageSupported", ScsiLunVStorageSupportStatusEnum::VStorageSupported),
        ("vStorageUnknown", ScsiLunVStorageSupportStatusEnum::VStorageUnknown),
    ],
};

impl ScsiLunVStorageSupportStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ScsiLunVStorageSupportStatusEnum::VStorageSupported => "vStorageSupported",
            ScsiLunVStorageSupportStatusEnum::VStorageUnsupported => "vStorageUnsupported",
            ScsiLunVStorageSupportStatusEnum::VStorageUnknown => "vStorageUnknown",
            ScsiLunVStorageSupportStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        SCSI_LUN_V_STORAGE_SUPPORT_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ScsiLunVStorageSupportStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ScsiLunVStorageSupportStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ScsiLunVStorageSupportStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ScsiLunVStorageSupportStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ScsiLunVStorageSupportStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ScsiLunVStorageSupportStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ScsiLunVStorageSupportStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ScsiLunVStorageSupportStatusEnum> for &'a str {
    fn from(value: &'a ScsiLunVStorageSupportStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ScsiLunVStorageSupportStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_SERVICE_POLICY_ENUM_MAP: phf::Map<&'static str, HostServicePolicyEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("automatic", HostServicePolicyEnum::Automatic),
        ("off", HostServicePolicyEnum::Off),
        ("on", HostServicePolicyEnum::On),
    ],
};

impl HostServicePolicyEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostServicePolicyEnum::On => "on",
            HostServicePolicyEnum::Automatic => "automatic",
            HostServicePolicyEnum::Off => "off",
            HostServicePolicyEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_SERVICE_POLICY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostServicePolicyEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostServicePolicyEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostServicePolicyEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostServicePolicyEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostServicePolicyEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostServicePolicyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostServicePolicyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostServicePolicyEnum> for &'a str {
    fn from(value: &'a HostServicePolicyEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostServicePolicyEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_SEV_INFO_SEV_STATE_ENUM_MAP: phf::Map<&'static str, HostSevInfoSevStateEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("working", HostSevInfoSevStateEnum::Working),
        ("initialized", HostSevInfoSevStateEnum::Initialized),
        ("uninitialized", HostSevInfoSevStateEnum::Uninitialized),
    ],
};

impl HostSevInfoSevStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostSevInfoSevStateEnum::Uninitialized => "uninitialized",
            HostSevInfoSevStateEnum::Initialized => "initialized",
            HostSevInfoSevStateEnum::Working => "working",
            HostSevInfoSevStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_SEV_INFO_SEV_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostSevInfoSevStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostSevInfoSevStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostSevInfoSevStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostSevInfoSevStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostSevInfoSevStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostSevInfoSevStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostSevInfoSevStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostSevInfoSevStateEnum> for &'a str {
    fn from(value: &'a HostSevInfoSevStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostSevInfoSevStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_SGX_INFO_FLC_MODES_ENUM_MAP: phf::Map<&'static str, HostSgxInfoFlcModesEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("locked", HostSgxInfoFlcModesEnum::Locked),
        ("off", HostSgxInfoFlcModesEnum::Off),
        ("unlocked", HostSgxInfoFlcModesEnum::Unlocked),
    ],
};

impl HostSgxInfoFlcModesEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostSgxInfoFlcModesEnum::Off => "off",
            HostSgxInfoFlcModesEnum::Locked => "locked",
            HostSgxInfoFlcModesEnum::Unlocked => "unlocked",
            HostSgxInfoFlcModesEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_SGX_INFO_FLC_MODES_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostSgxInfoFlcModesEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostSgxInfoFlcModesEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostSgxInfoFlcModesEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostSgxInfoFlcModesEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostSgxInfoFlcModesEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostSgxInfoFlcModesEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostSgxInfoFlcModesEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostSgxInfoFlcModesEnum> for &'a str {
    fn from(value: &'a HostSgxInfoFlcModesEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostSgxInfoFlcModesEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_SGX_INFO_SGX_STATES_ENUM_MAP: phf::Map<&'static str, HostSgxInfoSgxStatesEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 1),
        (4, 0),
    ],
    entries: &[
        ("disabledCPUMismatch", HostSgxInfoSgxStatesEnum::DisabledCpuMismatch),
        ("disabledMaxEPCRegs", HostSgxInfoSgxStatesEnum::DisabledMaxEpcRegs),
        ("disabledNUMAUnsup", HostSgxInfoSgxStatesEnum::DisabledNumaUnsup),
        ("disabledNoFLC", HostSgxInfoSgxStatesEnum::DisabledNoFlc),
        ("disabledCFW101", HostSgxInfoSgxStatesEnum::DisabledCfw101),
        ("notPresent", HostSgxInfoSgxStatesEnum::NotPresent),
        ("disabledBIOS", HostSgxInfoSgxStatesEnum::DisabledBios),
        ("enabled", HostSgxInfoSgxStatesEnum::Enabled),
    ],
};

impl HostSgxInfoSgxStatesEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostSgxInfoSgxStatesEnum::NotPresent => "notPresent",
            HostSgxInfoSgxStatesEnum::DisabledBios => "disabledBIOS",
            HostSgxInfoSgxStatesEnum::DisabledCfw101 => "disabledCFW101",
            HostSgxInfoSgxStatesEnum::DisabledCpuMismatch => "disabledCPUMismatch",
            HostSgxInfoSgxStatesEnum::DisabledNoFlc => "disabledNoFLC",
            HostSgxInfoSgxStatesEnum::DisabledNumaUnsup => "disabledNUMAUnsup",
            HostSgxInfoSgxStatesEnum::DisabledMaxEpcRegs => "disabledMaxEPCRegs",
            HostSgxInfoSgxStatesEnum::Enabled => "enabled",
            HostSgxInfoSgxStatesEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_SGX_INFO_SGX_STATES_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostSgxInfoSgxStatesEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostSgxInfoSgxStatesEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostSgxInfoSgxStatesEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostSgxInfoSgxStatesEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostSgxInfoSgxStatesEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostSgxInfoSgxStatesEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostSgxInfoSgxStatesEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostSgxInfoSgxStatesEnum> for &'a str {
    fn from(value: &'a HostSgxInfoSgxStatesEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostSgxInfoSgxStatesEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_SGX_REGISTRATION_INFO_REGISTRATION_STATUS_ENUM_MAP: phf::Map<&'static str, HostSgxRegistrationInfoRegistrationStatusEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("notApplicable", HostSgxRegistrationInfoRegistrationStatusEnum::NotApplicable),
        ("complete", HostSgxRegistrationInfoRegistrationStatusEnum::Complete),
        ("incomplete", HostSgxRegistrationInfoRegistrationStatusEnum::Incomplete),
    ],
};

impl HostSgxRegistrationInfoRegistrationStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostSgxRegistrationInfoRegistrationStatusEnum::NotApplicable => "notApplicable",
            HostSgxRegistrationInfoRegistrationStatusEnum::Incomplete => "incomplete",
            HostSgxRegistrationInfoRegistrationStatusEnum::Complete => "complete",
            HostSgxRegistrationInfoRegistrationStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_SGX_REGISTRATION_INFO_REGISTRATION_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostSgxRegistrationInfoRegistrationStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostSgxRegistrationInfoRegistrationStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostSgxRegistrationInfoRegistrationStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostSgxRegistrationInfoRegistrationStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostSgxRegistrationInfoRegistrationStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostSgxRegistrationInfoRegistrationStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostSgxRegistrationInfoRegistrationStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostSgxRegistrationInfoRegistrationStatusEnum> for &'a str {
    fn from(value: &'a HostSgxRegistrationInfoRegistrationStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostSgxRegistrationInfoRegistrationStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_SGX_REGISTRATION_INFO_REGISTRATION_TYPE_ENUM_MAP: phf::Map<&'static str, HostSgxRegistrationInfoRegistrationTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("manifest", HostSgxRegistrationInfoRegistrationTypeEnum::Manifest),
        ("addPackage", HostSgxRegistrationInfoRegistrationTypeEnum::AddPackage),
    ],
};

impl HostSgxRegistrationInfoRegistrationTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostSgxRegistrationInfoRegistrationTypeEnum::Manifest => "manifest",
            HostSgxRegistrationInfoRegistrationTypeEnum::AddPackage => "addPackage",
            HostSgxRegistrationInfoRegistrationTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_SGX_REGISTRATION_INFO_REGISTRATION_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostSgxRegistrationInfoRegistrationTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostSgxRegistrationInfoRegistrationTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostSgxRegistrationInfoRegistrationTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostSgxRegistrationInfoRegistrationTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostSgxRegistrationInfoRegistrationTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostSgxRegistrationInfoRegistrationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostSgxRegistrationInfoRegistrationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostSgxRegistrationInfoRegistrationTypeEnum> for &'a str {
    fn from(value: &'a HostSgxRegistrationInfoRegistrationTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostSgxRegistrationInfoRegistrationTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_SNMP_AGENT_CAPABILITY_ENUM_MAP: phf::Map<&'static str, HostSnmpAgentCapabilityEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("CONFIGURATION", HostSnmpAgentCapabilityEnum::Configuration),
        ("DIAGNOSTICS", HostSnmpAgentCapabilityEnum::Diagnostics),
        ("COMPLETE", HostSnmpAgentCapabilityEnum::Complete),
    ],
};

impl HostSnmpAgentCapabilityEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostSnmpAgentCapabilityEnum::Complete => "COMPLETE",
            HostSnmpAgentCapabilityEnum::Diagnostics => "DIAGNOSTICS",
            HostSnmpAgentCapabilityEnum::Configuration => "CONFIGURATION",
            HostSnmpAgentCapabilityEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_SNMP_AGENT_CAPABILITY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostSnmpAgentCapabilityEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostSnmpAgentCapabilityEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostSnmpAgentCapabilityEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostSnmpAgentCapabilityEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostSnmpAgentCapabilityEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostSnmpAgentCapabilityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostSnmpAgentCapabilityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostSnmpAgentCapabilityEnum> for &'a str {
    fn from(value: &'a HostSnmpAgentCapabilityEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostSnmpAgentCapabilityEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static SOFTWARE_PACKAGE_CONSTRAINT_ENUM_MAP: phf::Map<&'static str, SoftwarePackageConstraintEnum> = ::phf::Map {
    key: 2980949210194914378,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("lessThanEqual", SoftwarePackageConstraintEnum::LessThanEqual),
        ("greaterThan", SoftwarePackageConstraintEnum::GreaterThan),
        ("greaterThanEqual", SoftwarePackageConstraintEnum::GreaterThanEqual),
        ("equals", SoftwarePackageConstraintEnum::Equals),
        ("lessThan", SoftwarePackageConstraintEnum::LessThan),
    ],
};

impl SoftwarePackageConstraintEnum {
    pub fn as_str(&self) -> &str {
        match self {
            SoftwarePackageConstraintEnum::Equals => "equals",
            SoftwarePackageConstraintEnum::LessThan => "lessThan",
            SoftwarePackageConstraintEnum::LessThanEqual => "lessThanEqual",
            SoftwarePackageConstraintEnum::GreaterThanEqual => "greaterThanEqual",
            SoftwarePackageConstraintEnum::GreaterThan => "greaterThan",
            SoftwarePackageConstraintEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        SOFTWARE_PACKAGE_CONSTRAINT_ENUM_MAP.get(s).cloned().unwrap_or_else(|| SoftwarePackageConstraintEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for SoftwarePackageConstraintEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for SoftwarePackageConstraintEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<SoftwarePackageConstraintEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(SoftwarePackageConstraintEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for SoftwarePackageConstraintEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for SoftwarePackageConstraintEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a SoftwarePackageConstraintEnum> for &'a str {
    fn from(value: &'a SoftwarePackageConstraintEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for SoftwarePackageConstraintEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static SOFTWARE_PACKAGE_VIB_TYPE_ENUM_MAP: phf::Map<&'static str, SoftwarePackageVibTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("tools", SoftwarePackageVibTypeEnum::Tools),
        ("meta", SoftwarePackageVibTypeEnum::Meta),
        ("bootbank", SoftwarePackageVibTypeEnum::Bootbank),
    ],
};

impl SoftwarePackageVibTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            SoftwarePackageVibTypeEnum::Bootbank => "bootbank",
            SoftwarePackageVibTypeEnum::Tools => "tools",
            SoftwarePackageVibTypeEnum::Meta => "meta",
            SoftwarePackageVibTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        SOFTWARE_PACKAGE_VIB_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| SoftwarePackageVibTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for SoftwarePackageVibTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for SoftwarePackageVibTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<SoftwarePackageVibTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(SoftwarePackageVibTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for SoftwarePackageVibTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for SoftwarePackageVibTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a SoftwarePackageVibTypeEnum> for &'a str {
    fn from(value: &'a SoftwarePackageVibTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for SoftwarePackageVibTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_STORAGE_PROTOCOL_ENUM_MAP: phf::Map<&'static str, HostStorageProtocolEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("nvme", HostStorageProtocolEnum::Nvme),
        ("scsi", HostStorageProtocolEnum::Scsi),
    ],
};

impl HostStorageProtocolEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostStorageProtocolEnum::Scsi => "scsi",
            HostStorageProtocolEnum::Nvme => "nvme",
            HostStorageProtocolEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_STORAGE_PROTOCOL_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostStorageProtocolEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostStorageProtocolEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostStorageProtocolEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostStorageProtocolEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostStorageProtocolEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostStorageProtocolEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostStorageProtocolEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostStorageProtocolEnum> for &'a str {
    fn from(value: &'a HostStorageProtocolEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostStorageProtocolEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_SYSTEM_IDENTIFICATION_INFO_IDENTIFIER_ENUM_MAP: phf::Map<&'static str, HostSystemIdentificationInfoIdentifierEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("ServiceTag", HostSystemIdentificationInfoIdentifierEnum::ServiceTag),
        ("SerialNumberTag", HostSystemIdentificationInfoIdentifierEnum::SerialNumberTag),
        ("OemSpecificString", HostSystemIdentificationInfoIdentifierEnum::OemSpecificString),
        ("AssetTag", HostSystemIdentificationInfoIdentifierEnum::AssetTag),
        ("EnclosureSerialNumberTag", HostSystemIdentificationInfoIdentifierEnum::EnclosureSerialNumberTag),
    ],
};

impl HostSystemIdentificationInfoIdentifierEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostSystemIdentificationInfoIdentifierEnum::AssetTag => "AssetTag",
            HostSystemIdentificationInfoIdentifierEnum::ServiceTag => "ServiceTag",
            HostSystemIdentificationInfoIdentifierEnum::OemSpecificString => "OemSpecificString",
            HostSystemIdentificationInfoIdentifierEnum::EnclosureSerialNumberTag => "EnclosureSerialNumberTag",
            HostSystemIdentificationInfoIdentifierEnum::SerialNumberTag => "SerialNumberTag",
            HostSystemIdentificationInfoIdentifierEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_SYSTEM_IDENTIFICATION_INFO_IDENTIFIER_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostSystemIdentificationInfoIdentifierEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostSystemIdentificationInfoIdentifierEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostSystemIdentificationInfoIdentifierEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostSystemIdentificationInfoIdentifierEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostSystemIdentificationInfoIdentifierEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostSystemIdentificationInfoIdentifierEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostSystemIdentificationInfoIdentifierEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostSystemIdentificationInfoIdentifierEnum> for &'a str {
    fn from(value: &'a HostSystemIdentificationInfoIdentifierEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostSystemIdentificationInfoIdentifierEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_TDX_INFO_TDX_STATE_ENUM_MAP: phf::Map<&'static str, HostTdxInfoTdxStateEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (3, 0),
    ],
    entries: &[
        ("configured", HostTdxInfoTdxStateEnum::Configured),
        ("ready", HostTdxInfoTdxStateEnum::Ready),
        ("initialized", HostTdxInfoTdxStateEnum::Initialized),
        ("initializing", HostTdxInfoTdxStateEnum::Initializing),
    ],
};

impl HostTdxInfoTdxStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostTdxInfoTdxStateEnum::Initializing => "initializing",
            HostTdxInfoTdxStateEnum::Initialized => "initialized",
            HostTdxInfoTdxStateEnum::Configured => "configured",
            HostTdxInfoTdxStateEnum::Ready => "ready",
            HostTdxInfoTdxStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_TDX_INFO_TDX_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostTdxInfoTdxStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostTdxInfoTdxStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostTdxInfoTdxStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostTdxInfoTdxStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostTdxInfoTdxStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostTdxInfoTdxStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostTdxInfoTdxStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostTdxInfoTdxStateEnum> for &'a str {
    fn from(value: &'a HostTdxInfoTdxStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostTdxInfoTdxStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_TPM_ATTESTATION_INFO_ACCEPTANCE_STATUS_ENUM_MAP: phf::Map<&'static str, HostTpmAttestationInfoAcceptanceStatusEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("notAccepted", HostTpmAttestationInfoAcceptanceStatusEnum::NotAccepted),
        ("accepted", HostTpmAttestationInfoAcceptanceStatusEnum::Accepted),
    ],
};

impl HostTpmAttestationInfoAcceptanceStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostTpmAttestationInfoAcceptanceStatusEnum::NotAccepted => "notAccepted",
            HostTpmAttestationInfoAcceptanceStatusEnum::Accepted => "accepted",
            HostTpmAttestationInfoAcceptanceStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_TPM_ATTESTATION_INFO_ACCEPTANCE_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostTpmAttestationInfoAcceptanceStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostTpmAttestationInfoAcceptanceStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostTpmAttestationInfoAcceptanceStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostTpmAttestationInfoAcceptanceStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostTpmAttestationInfoAcceptanceStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostTpmAttestationInfoAcceptanceStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostTpmAttestationInfoAcceptanceStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostTpmAttestationInfoAcceptanceStatusEnum> for &'a str {
    fn from(value: &'a HostTpmAttestationInfoAcceptanceStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostTpmAttestationInfoAcceptanceStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_TRUST_AUTHORITY_ATTESTATION_INFO_ATTESTATION_STATUS_ENUM_MAP: phf::Map<&'static str, HostTrustAuthorityAttestationInfoAttestationStatusEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("notAttested", HostTrustAuthorityAttestationInfoAttestationStatusEnum::NotAttested),
        ("unknown", HostTrustAuthorityAttestationInfoAttestationStatusEnum::Unknown),
        ("attested", HostTrustAuthorityAttestationInfoAttestationStatusEnum::Attested),
    ],
};

impl HostTrustAuthorityAttestationInfoAttestationStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostTrustAuthorityAttestationInfoAttestationStatusEnum::Attested => "attested",
            HostTrustAuthorityAttestationInfoAttestationStatusEnum::NotAttested => "notAttested",
            HostTrustAuthorityAttestationInfoAttestationStatusEnum::Unknown => "unknown",
            HostTrustAuthorityAttestationInfoAttestationStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_TRUST_AUTHORITY_ATTESTATION_INFO_ATTESTATION_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostTrustAuthorityAttestationInfoAttestationStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostTrustAuthorityAttestationInfoAttestationStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostTrustAuthorityAttestationInfoAttestationStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostTrustAuthorityAttestationInfoAttestationStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostTrustAuthorityAttestationInfoAttestationStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostTrustAuthorityAttestationInfoAttestationStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostTrustAuthorityAttestationInfoAttestationStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostTrustAuthorityAttestationInfoAttestationStatusEnum> for &'a str {
    fn from(value: &'a HostTrustAuthorityAttestationInfoAttestationStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostTrustAuthorityAttestationInfoAttestationStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_UNRESOLVED_VMFS_EXTENT_UNRESOLVED_REASON_ENUM_MAP: phf::Map<&'static str, HostUnresolvedVmfsExtentUnresolvedReasonEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("diskIdMismatch", HostUnresolvedVmfsExtentUnresolvedReasonEnum::DiskIdMismatch),
        ("uuidConflict", HostUnresolvedVmfsExtentUnresolvedReasonEnum::UuidConflict),
    ],
};

impl HostUnresolvedVmfsExtentUnresolvedReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostUnresolvedVmfsExtentUnresolvedReasonEnum::DiskIdMismatch => "diskIdMismatch",
            HostUnresolvedVmfsExtentUnresolvedReasonEnum::UuidConflict => "uuidConflict",
            HostUnresolvedVmfsExtentUnresolvedReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_UNRESOLVED_VMFS_EXTENT_UNRESOLVED_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostUnresolvedVmfsExtentUnresolvedReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostUnresolvedVmfsExtentUnresolvedReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostUnresolvedVmfsExtentUnresolvedReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostUnresolvedVmfsExtentUnresolvedReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostUnresolvedVmfsExtentUnresolvedReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostUnresolvedVmfsExtentUnresolvedReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostUnresolvedVmfsExtentUnresolvedReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostUnresolvedVmfsExtentUnresolvedReasonEnum> for &'a str {
    fn from(value: &'a HostUnresolvedVmfsExtentUnresolvedReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostUnresolvedVmfsExtentUnresolvedReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_UNRESOLVED_VMFS_RESOLUTION_SPEC_VMFS_UUID_RESOLUTION_ENUM_MAP: phf::Map<&'static str, HostUnresolvedVmfsResolutionSpecVmfsUuidResolutionEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("resignature", HostUnresolvedVmfsResolutionSpecVmfsUuidResolutionEnum::Resignature),
        ("forceMount", HostUnresolvedVmfsResolutionSpecVmfsUuidResolutionEnum::ForceMount),
    ],
};

impl HostUnresolvedVmfsResolutionSpecVmfsUuidResolutionEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostUnresolvedVmfsResolutionSpecVmfsUuidResolutionEnum::Resignature => "resignature",
            HostUnresolvedVmfsResolutionSpecVmfsUuidResolutionEnum::ForceMount => "forceMount",
            HostUnresolvedVmfsResolutionSpecVmfsUuidResolutionEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_UNRESOLVED_VMFS_RESOLUTION_SPEC_VMFS_UUID_RESOLUTION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostUnresolvedVmfsResolutionSpecVmfsUuidResolutionEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostUnresolvedVmfsResolutionSpecVmfsUuidResolutionEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostUnresolvedVmfsResolutionSpecVmfsUuidResolutionEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostUnresolvedVmfsResolutionSpecVmfsUuidResolutionEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostUnresolvedVmfsResolutionSpecVmfsUuidResolutionEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostUnresolvedVmfsResolutionSpecVmfsUuidResolutionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostUnresolvedVmfsResolutionSpecVmfsUuidResolutionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostUnresolvedVmfsResolutionSpecVmfsUuidResolutionEnum> for &'a str {
    fn from(value: &'a HostUnresolvedVmfsResolutionSpecVmfsUuidResolutionEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostUnresolvedVmfsResolutionSpecVmfsUuidResolutionEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_VIRTUAL_NIC_MANAGER_NIC_TYPE_ENUM_MAP: phf::Map<&'static str, HostVirtualNicManagerNicTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
        (0, 1),
        (9, 4),
    ],
    entries: &[
        ("vSphereProvisioning", HostVirtualNicManagerNicTypeEnum::VSphereProvisioning),
        ("vsan", HostVirtualNicManagerNicTypeEnum::Vsan),
        ("vSphereReplication", HostVirtualNicManagerNicTypeEnum::VSphereReplication),
        ("faultToleranceLogging", HostVirtualNicManagerNicTypeEnum::FaultToleranceLogging),
        ("vmotion", HostVirtualNicManagerNicTypeEnum::Vmotion),
        ("management", HostVirtualNicManagerNicTypeEnum::Management),
        ("nvmeTcp", HostVirtualNicManagerNicTypeEnum::NvmeTcp),
        ("vSphereReplicationNFC", HostVirtualNicManagerNicTypeEnum::VSphereReplicationNfc),
        ("nvmeRdma", HostVirtualNicManagerNicTypeEnum::NvmeRdma),
        ("vsanExternal", HostVirtualNicManagerNicTypeEnum::VsanExternal),
        ("ptp", HostVirtualNicManagerNicTypeEnum::Ptp),
        ("vSphereBackupNFC", HostVirtualNicManagerNicTypeEnum::VSphereBackupNfc),
        ("vsanWitness", HostVirtualNicManagerNicTypeEnum::VsanWitness),
    ],
};

impl HostVirtualNicManagerNicTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostVirtualNicManagerNicTypeEnum::Vmotion => "vmotion",
            HostVirtualNicManagerNicTypeEnum::FaultToleranceLogging => "faultToleranceLogging",
            HostVirtualNicManagerNicTypeEnum::VSphereReplication => "vSphereReplication",
            HostVirtualNicManagerNicTypeEnum::VSphereReplicationNfc => "vSphereReplicationNFC",
            HostVirtualNicManagerNicTypeEnum::Management => "management",
            HostVirtualNicManagerNicTypeEnum::Vsan => "vsan",
            HostVirtualNicManagerNicTypeEnum::VSphereProvisioning => "vSphereProvisioning",
            HostVirtualNicManagerNicTypeEnum::VsanWitness => "vsanWitness",
            HostVirtualNicManagerNicTypeEnum::VSphereBackupNfc => "vSphereBackupNFC",
            HostVirtualNicManagerNicTypeEnum::Ptp => "ptp",
            HostVirtualNicManagerNicTypeEnum::NvmeTcp => "nvmeTcp",
            HostVirtualNicManagerNicTypeEnum::NvmeRdma => "nvmeRdma",
            HostVirtualNicManagerNicTypeEnum::VsanExternal => "vsanExternal",
            HostVirtualNicManagerNicTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_VIRTUAL_NIC_MANAGER_NIC_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostVirtualNicManagerNicTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostVirtualNicManagerNicTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostVirtualNicManagerNicTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostVirtualNicManagerNicTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostVirtualNicManagerNicTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostVirtualNicManagerNicTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostVirtualNicManagerNicTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostVirtualNicManagerNicTypeEnum> for &'a str {
    fn from(value: &'a HostVirtualNicManagerNicTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostVirtualNicManagerNicTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_VMCI_ACCESS_MANAGER_MODE_ENUM_MAP: phf::Map<&'static str, HostVmciAccessManagerModeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("revoke", HostVmciAccessManagerModeEnum::Revoke),
        ("grant", HostVmciAccessManagerModeEnum::Grant),
        ("replace", HostVmciAccessManagerModeEnum::Replace),
    ],
};

impl HostVmciAccessManagerModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostVmciAccessManagerModeEnum::Grant => "grant",
            HostVmciAccessManagerModeEnum::Replace => "replace",
            HostVmciAccessManagerModeEnum::Revoke => "revoke",
            HostVmciAccessManagerModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_VMCI_ACCESS_MANAGER_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostVmciAccessManagerModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostVmciAccessManagerModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostVmciAccessManagerModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostVmciAccessManagerModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostVmciAccessManagerModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostVmciAccessManagerModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostVmciAccessManagerModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostVmciAccessManagerModeEnum> for &'a str {
    fn from(value: &'a HostVmciAccessManagerModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostVmciAccessManagerModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_VMFS_VOLUME_UNMAP_BANDWIDTH_POLICY_ENUM_MAP: phf::Map<&'static str, HostVmfsVolumeUnmapBandwidthPolicyEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("fixed", HostVmfsVolumeUnmapBandwidthPolicyEnum::Fixed),
        ("dynamic", HostVmfsVolumeUnmapBandwidthPolicyEnum::Dynamic),
    ],
};

impl HostVmfsVolumeUnmapBandwidthPolicyEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostVmfsVolumeUnmapBandwidthPolicyEnum::Fixed => "fixed",
            HostVmfsVolumeUnmapBandwidthPolicyEnum::Dynamic => "dynamic",
            HostVmfsVolumeUnmapBandwidthPolicyEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_VMFS_VOLUME_UNMAP_BANDWIDTH_POLICY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostVmfsVolumeUnmapBandwidthPolicyEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostVmfsVolumeUnmapBandwidthPolicyEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostVmfsVolumeUnmapBandwidthPolicyEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostVmfsVolumeUnmapBandwidthPolicyEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostVmfsVolumeUnmapBandwidthPolicyEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostVmfsVolumeUnmapBandwidthPolicyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostVmfsVolumeUnmapBandwidthPolicyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostVmfsVolumeUnmapBandwidthPolicyEnum> for &'a str {
    fn from(value: &'a HostVmfsVolumeUnmapBandwidthPolicyEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostVmfsVolumeUnmapBandwidthPolicyEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_VMFS_VOLUME_UNMAP_PRIORITY_ENUM_MAP: phf::Map<&'static str, HostVmfsVolumeUnmapPriorityEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("none", HostVmfsVolumeUnmapPriorityEnum::None),
        ("low", HostVmfsVolumeUnmapPriorityEnum::Low),
    ],
};

impl HostVmfsVolumeUnmapPriorityEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostVmfsVolumeUnmapPriorityEnum::None => "none",
            HostVmfsVolumeUnmapPriorityEnum::Low => "low",
            HostVmfsVolumeUnmapPriorityEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_VMFS_VOLUME_UNMAP_PRIORITY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostVmfsVolumeUnmapPriorityEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostVmfsVolumeUnmapPriorityEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostVmfsVolumeUnmapPriorityEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostVmfsVolumeUnmapPriorityEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostVmfsVolumeUnmapPriorityEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostVmfsVolumeUnmapPriorityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostVmfsVolumeUnmapPriorityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostVmfsVolumeUnmapPriorityEnum> for &'a str {
    fn from(value: &'a HostVmfsVolumeUnmapPriorityEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostVmfsVolumeUnmapPriorityEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_CONTROLLER_TYPE_ENUM_MAP: phf::Map<&'static str, VsanControllerTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("NVMe", VsanControllerTypeEnum::NvMe),
        ("SCSI", VsanControllerTypeEnum::Scsi),
        ("VsanControllerType_Unknown", VsanControllerTypeEnum::VsanControllerTypeUnknown),
    ],
};

impl VsanControllerTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanControllerTypeEnum::NvMe => "NVMe",
            VsanControllerTypeEnum::Scsi => "SCSI",
            VsanControllerTypeEnum::VsanControllerTypeUnknown => "VsanControllerType_Unknown",
            VsanControllerTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_CONTROLLER_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanControllerTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanControllerTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanControllerTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanControllerTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanControllerTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanControllerTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanControllerTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanControllerTypeEnum> for &'a str {
    fn from(value: &'a VsanControllerTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanControllerTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_DISK_BALANCE_STATE_ENUM_MAP: phf::Map<&'static str, VsanDiskBalanceStateEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
        (0, 0),
        (5, 8),
    ],
    entries: &[
        ("proactiverebalanceinprogress", VsanDiskBalanceStateEnum::Proactiverebalanceinprogress),
        ("imbalancewithintolerance", VsanDiskBalanceStateEnum::Imbalancewithintolerance),
        ("proactivenotmustdo", VsanDiskBalanceStateEnum::Proactivenotmustdo),
        ("rebalanceentitydecom", VsanDiskBalanceStateEnum::Rebalanceentitydecom),
        ("rebalanceoff", VsanDiskBalanceStateEnum::Rebalanceoff),
        ("rebalancediskunhealthy", VsanDiskBalanceStateEnum::Rebalancediskunhealthy),
        ("proactiverebalancefailed", VsanDiskBalanceStateEnum::Proactiverebalancefailed),
        ("reactiverebalanceinprogress", VsanDiskBalanceStateEnum::Reactiverebalanceinprogress),
        ("proactiveneededbutdisabled", VsanDiskBalanceStateEnum::Proactiveneededbutdisabled),
        ("reactiverebalancefailed", VsanDiskBalanceStateEnum::Reactiverebalancefailed),
        ("VsanDiskBalanceState_Unknown", VsanDiskBalanceStateEnum::VsanDiskBalanceStateUnknown),
    ],
};

impl VsanDiskBalanceStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanDiskBalanceStateEnum::Rebalanceoff => "rebalanceoff",
            VsanDiskBalanceStateEnum::Rebalanceentitydecom => "rebalanceentitydecom",
            VsanDiskBalanceStateEnum::Rebalancediskunhealthy => "rebalancediskunhealthy",
            VsanDiskBalanceStateEnum::Imbalancewithintolerance => "imbalancewithintolerance",
            VsanDiskBalanceStateEnum::Reactiverebalanceinprogress => "reactiverebalanceinprogress",
            VsanDiskBalanceStateEnum::Reactiverebalancefailed => "reactiverebalancefailed",
            VsanDiskBalanceStateEnum::Proactiveneededbutdisabled => "proactiveneededbutdisabled",
            VsanDiskBalanceStateEnum::Proactiverebalanceinprogress => "proactiverebalanceinprogress",
            VsanDiskBalanceStateEnum::Proactiverebalancefailed => "proactiverebalancefailed",
            VsanDiskBalanceStateEnum::Proactivenotmustdo => "proactivenotmustdo",
            VsanDiskBalanceStateEnum::VsanDiskBalanceStateUnknown => "VsanDiskBalanceState_Unknown",
            VsanDiskBalanceStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_DISK_BALANCE_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanDiskBalanceStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanDiskBalanceStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanDiskBalanceStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanDiskBalanceStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanDiskBalanceStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanDiskBalanceStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanDiskBalanceStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanDiskBalanceStateEnum> for &'a str {
    fn from(value: &'a VsanDiskBalanceStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanDiskBalanceStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_ENCRYPTION_ISSUE_ENUM_MAP: phf::Map<&'static str, VsanEncryptionIssueEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (2, 0),
        (3, 20),
        (18, 17),
        (8, 11),
        (1, 21),
        (9, 13),
    ],
    entries: &[
        ("dataencryptionkeyinconsistent", VsanEncryptionIssueEnum::Dataencryptionkeyinconsistent),
        ("objectencryptioninconsistent", VsanEncryptionIssueEnum::Objectencryptioninconsistent),
        ("enabledwhenclusterdisabled", VsanEncryptionIssueEnum::Enabledwhenclusterdisabled),
        ("VsanEncryptionIssue_Unknown", VsanEncryptionIssueEnum::VsanEncryptionIssueUnknown),
        ("dataencryptionkeyverifierinconsistent", VsanEncryptionIssueEnum::Dataencryptionkeyverifierinconsistent),
        ("disabledwhenclusterenabled", VsanEncryptionIssueEnum::Disabledwhenclusterenabled),
        ("erasedisksbeforeuseinconsistent", VsanEncryptionIssueEnum::Erasedisksbeforeuseinconsistent),
        ("hosthaswrongolddekid", VsanEncryptionIssueEnum::Hosthaswrongolddekid),
        ("clientkeyinconsistent", VsanEncryptionIssueEnum::Clientkeyinconsistent),
        ("keyencryptionkeyverifierinconsistent", VsanEncryptionIssueEnum::Keyencryptionkeyverifierinconsistent),
        ("diskhaswrongdekid", VsanEncryptionIssueEnum::Diskhaswrongdekid),
        ("keknotavailable", VsanEncryptionIssueEnum::Keknotavailable),
        ("hosthaspendingdeeprekey", VsanEncryptionIssueEnum::Hosthaspendingdeeprekey),
        ("diskhaspendingdeeprekey", VsanEncryptionIssueEnum::Diskhaspendingdeeprekey),
        ("changingstatenotfinished", VsanEncryptionIssueEnum::Changingstatenotfinished),
        ("hostkeyinconsistent", VsanEncryptionIssueEnum::Hostkeyinconsistent),
        ("cmknotinenabledstate", VsanEncryptionIssueEnum::Cmknotinenabledstate),
        ("hostencryptiondekidinconsistent", VsanEncryptionIssueEnum::Hostencryptiondekidinconsistent),
        ("olddataencryptionkeyinconsistent", VsanEncryptionIssueEnum::Olddataencryptionkeyinconsistent),
        ("cmkcannotretrieve", VsanEncryptionIssueEnum::Cmkcannotretrieve),
        ("keyencryptionkeyinconsistent", VsanEncryptionIssueEnum::Keyencryptionkeyinconsistent),
        ("hostkeynotavailable", VsanEncryptionIssueEnum::Hostkeynotavailable),
        ("clientcertificateinconsistent", VsanEncryptionIssueEnum::Clientcertificateinconsistent),
        ("diskhaswrongpendingdekid", VsanEncryptionIssueEnum::Diskhaswrongpendingdekid),
        ("hosthaswrongdekid", VsanEncryptionIssueEnum::Hosthaswrongdekid),
        ("kmsinfoinconsistent", VsanEncryptionIssueEnum::Kmsinfoinconsistent),
        ("changingstateinconsistent", VsanEncryptionIssueEnum::Changingstateinconsistent),
        ("dataencryptionkeyverifierofdiskmetainconsistent", VsanEncryptionIssueEnum::Dataencryptionkeyverifierofdiskmetainconsistent),
        ("servercertificatesinconsistent", VsanEncryptionIssueEnum::Servercertificatesinconsistent),
    ],
};

impl VsanEncryptionIssueEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanEncryptionIssueEnum::Enabledwhenclusterdisabled => "enabledwhenclusterdisabled",
            VsanEncryptionIssueEnum::Disabledwhenclusterenabled => "disabledwhenclusterenabled",
            VsanEncryptionIssueEnum::Keyencryptionkeyinconsistent => "keyencryptionkeyinconsistent",
            VsanEncryptionIssueEnum::Dataencryptionkeyinconsistent => "dataencryptionkeyinconsistent",
            VsanEncryptionIssueEnum::Kmsinfoinconsistent => "kmsinfoinconsistent",
            VsanEncryptionIssueEnum::Servercertificatesinconsistent => "servercertificatesinconsistent",
            VsanEncryptionIssueEnum::Clientcertificateinconsistent => "clientcertificateinconsistent",
            VsanEncryptionIssueEnum::Clientkeyinconsistent => "clientkeyinconsistent",
            VsanEncryptionIssueEnum::Hostkeyinconsistent => "hostkeyinconsistent",
            VsanEncryptionIssueEnum::Erasedisksbeforeuseinconsistent => "erasedisksbeforeuseinconsistent",
            VsanEncryptionIssueEnum::Cmknotinenabledstate => "cmknotinenabledstate",
            VsanEncryptionIssueEnum::Cmkcannotretrieve => "cmkcannotretrieve",
            VsanEncryptionIssueEnum::Hostkeynotavailable => "hostkeynotavailable",
            VsanEncryptionIssueEnum::Keknotavailable => "keknotavailable",
            VsanEncryptionIssueEnum::Hostencryptiondekidinconsistent => "hostencryptiondekidinconsistent",
            VsanEncryptionIssueEnum::Objectencryptioninconsistent => "objectencryptioninconsistent",
            VsanEncryptionIssueEnum::Keyencryptionkeyverifierinconsistent => "keyencryptionkeyverifierinconsistent",
            VsanEncryptionIssueEnum::Dataencryptionkeyverifierinconsistent => "dataencryptionkeyverifierinconsistent",
            VsanEncryptionIssueEnum::Olddataencryptionkeyinconsistent => "olddataencryptionkeyinconsistent",
            VsanEncryptionIssueEnum::Hosthaswrongdekid => "hosthaswrongdekid",
            VsanEncryptionIssueEnum::Hosthaswrongolddekid => "hosthaswrongolddekid",
            VsanEncryptionIssueEnum::Hosthaspendingdeeprekey => "hosthaspendingdeeprekey",
            VsanEncryptionIssueEnum::Diskhaswrongdekid => "diskhaswrongdekid",
            VsanEncryptionIssueEnum::Diskhaswrongpendingdekid => "diskhaswrongpendingdekid",
            VsanEncryptionIssueEnum::Diskhaspendingdeeprekey => "diskhaspendingdeeprekey",
            VsanEncryptionIssueEnum::Dataencryptionkeyverifierofdiskmetainconsistent => "dataencryptionkeyverifierofdiskmetainconsistent",
            VsanEncryptionIssueEnum::Changingstateinconsistent => "changingstateinconsistent",
            VsanEncryptionIssueEnum::Changingstatenotfinished => "changingstatenotfinished",
            VsanEncryptionIssueEnum::VsanEncryptionIssueUnknown => "VsanEncryptionIssue_Unknown",
            VsanEncryptionIssueEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_ENCRYPTION_ISSUE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanEncryptionIssueEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanEncryptionIssueEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanEncryptionIssueEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanEncryptionIssueEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanEncryptionIssueEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanEncryptionIssueEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanEncryptionIssueEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanEncryptionIssueEnum> for &'a str {
    fn from(value: &'a VsanEncryptionIssueEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanEncryptionIssueEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_HOST_QUERY_CHECK_LIMITS_OPTION_TYPE_ENUM_MAP: phf::Map<&'static str, VsanHostQueryCheckLimitsOptionTypeEnum> = ::phf::Map {
    key: 8694567506910003252,
    disps: &[
        (1, 4),
        (3, 0),
    ],
    entries: &[
        ("dgTransientCapacityUsed", VsanHostQueryCheckLimitsOptionTypeEnum::DgTransientCapacityUsed),
        ("logicalCapacityUsed", VsanHostQueryCheckLimitsOptionTypeEnum::LogicalCapacityUsed),
        ("logicalCapacity", VsanHostQueryCheckLimitsOptionTypeEnum::LogicalCapacity),
        ("VsanHostQueryCheckLimitsOptionType_Unknown", VsanHostQueryCheckLimitsOptionTypeEnum::VsanHostQueryCheckLimitsOptionTypeUnknown),
        ("diskTransientCapacityUsed", VsanHostQueryCheckLimitsOptionTypeEnum::DiskTransientCapacityUsed),
        ("dedupMetadata", VsanHostQueryCheckLimitsOptionTypeEnum::DedupMetadata),
    ],
};

impl VsanHostQueryCheckLimitsOptionTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanHostQueryCheckLimitsOptionTypeEnum::LogicalCapacity => "logicalCapacity",
            VsanHostQueryCheckLimitsOptionTypeEnum::LogicalCapacityUsed => "logicalCapacityUsed",
            VsanHostQueryCheckLimitsOptionTypeEnum::DiskTransientCapacityUsed => "diskTransientCapacityUsed",
            VsanHostQueryCheckLimitsOptionTypeEnum::DgTransientCapacityUsed => "dgTransientCapacityUsed",
            VsanHostQueryCheckLimitsOptionTypeEnum::DedupMetadata => "dedupMetadata",
            VsanHostQueryCheckLimitsOptionTypeEnum::VsanHostQueryCheckLimitsOptionTypeUnknown => "VsanHostQueryCheckLimitsOptionType_Unknown",
            VsanHostQueryCheckLimitsOptionTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_HOST_QUERY_CHECK_LIMITS_OPTION_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanHostQueryCheckLimitsOptionTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanHostQueryCheckLimitsOptionTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanHostQueryCheckLimitsOptionTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanHostQueryCheckLimitsOptionTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanHostQueryCheckLimitsOptionTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanHostQueryCheckLimitsOptionTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanHostQueryCheckLimitsOptionTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanHostQueryCheckLimitsOptionTypeEnum> for &'a str {
    fn from(value: &'a VsanHostQueryCheckLimitsOptionTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanHostQueryCheckLimitsOptionTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_IO_INSIGHT_STATE_ENUM_MAP: phf::Map<&'static str, VsanIoInsightStateEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (3, 0),
    ],
    entries: &[
        ("VsanIoInsightState_unknown", VsanIoInsightStateEnum::VsanIoInsightStateUnknown),
        ("stopped", VsanIoInsightStateEnum::Stopped),
        ("running", VsanIoInsightStateEnum::Running),
        ("notFound", VsanIoInsightStateEnum::NotFound),
    ],
};

impl VsanIoInsightStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanIoInsightStateEnum::Running => "running",
            VsanIoInsightStateEnum::Stopped => "stopped",
            VsanIoInsightStateEnum::NotFound => "notFound",
            VsanIoInsightStateEnum::VsanIoInsightStateUnknown => "VsanIoInsightState_unknown",
            VsanIoInsightStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_IO_INSIGHT_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanIoInsightStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanIoInsightStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanIoInsightStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanIoInsightStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanIoInsightStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanIoInsightStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanIoInsightStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanIoInsightStateEnum> for &'a str {
    fn from(value: &'a VsanIoInsightStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanIoInsightStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_OBJECT_HEALTH_STATE_ENUM_MAP: phf::Map<&'static str, VsanObjectHealthStateEnum> = ::phf::Map {
    key: 2980949210194914378,
    disps: &[
        (0, 0),
        (1, 12),
        (1, 2),
        (1, 15),
    ],
    entries: &[
        ("VsanObjectHealthState_Unknown", VsanObjectHealthStateEnum::VsanObjectHealthStateUnknown),
        ("nonavailabilityrelatedincompliancewithpolicypending", VsanObjectHealthStateEnum::Nonavailabilityrelatedincompliancewithpolicypending),
        ("remoteAccessible", VsanObjectHealthStateEnum::RemoteAccessible),
        ("inaccessible", VsanObjectHealthStateEnum::Inaccessible),
        ("nonavailabilityrelatedincompliance", VsanObjectHealthStateEnum::Nonavailabilityrelatedincompliance),
        ("reducedavailabilitywithnorebuild", VsanObjectHealthStateEnum::Reducedavailabilitywithnorebuild),
        ("datamove", VsanObjectHealthStateEnum::Datamove),
        ("reducedavailabilitywithnorebuilddelaytimer", VsanObjectHealthStateEnum::Reducedavailabilitywithnorebuilddelaytimer),
        ("reducedavailabilitywithactiverebuild", VsanObjectHealthStateEnum::Reducedavailabilitywithactiverebuild),
        ("healthy", VsanObjectHealthStateEnum::Healthy),
        ("reducedavailabilitywithpolicypending", VsanObjectHealthStateEnum::Reducedavailabilitywithpolicypending),
        ("nonavailabilityrelatedincompliancewithpolicypendingfailed", VsanObjectHealthStateEnum::Nonavailabilityrelatedincompliancewithpolicypendingfailed),
        ("nonavailabilityrelatedincompliancewithpausedrebuild", VsanObjectHealthStateEnum::Nonavailabilityrelatedincompliancewithpausedrebuild),
        ("reducedavailabilitywithpolicypendingfailed", VsanObjectHealthStateEnum::Reducedavailabilitywithpolicypendingfailed),
        ("reducedavailabilitywithpausedrebuild", VsanObjectHealthStateEnum::Reducedavailabilitywithpausedrebuild),
        ("nonavailabilityrelatedreconfig", VsanObjectHealthStateEnum::Nonavailabilityrelatedreconfig),
    ],
};

impl VsanObjectHealthStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanObjectHealthStateEnum::Inaccessible => "inaccessible",
            VsanObjectHealthStateEnum::Reducedavailabilitywithnorebuild => "reducedavailabilitywithnorebuild",
            VsanObjectHealthStateEnum::Reducedavailabilitywithnorebuilddelaytimer => "reducedavailabilitywithnorebuilddelaytimer",
            VsanObjectHealthStateEnum::Reducedavailabilitywithactiverebuild => "reducedavailabilitywithactiverebuild",
            VsanObjectHealthStateEnum::Datamove => "datamove",
            VsanObjectHealthStateEnum::Nonavailabilityrelatedreconfig => "nonavailabilityrelatedreconfig",
            VsanObjectHealthStateEnum::Nonavailabilityrelatedincompliance => "nonavailabilityrelatedincompliance",
            VsanObjectHealthStateEnum::Healthy => "healthy",
            VsanObjectHealthStateEnum::Reducedavailabilitywithpolicypending => "reducedavailabilitywithpolicypending",
            VsanObjectHealthStateEnum::Reducedavailabilitywithpolicypendingfailed => "reducedavailabilitywithpolicypendingfailed",
            VsanObjectHealthStateEnum::Reducedavailabilitywithpausedrebuild => "reducedavailabilitywithpausedrebuild",
            VsanObjectHealthStateEnum::Nonavailabilityrelatedincompliancewithpolicypending => "nonavailabilityrelatedincompliancewithpolicypending",
            VsanObjectHealthStateEnum::Nonavailabilityrelatedincompliancewithpolicypendingfailed => "nonavailabilityrelatedincompliancewithpolicypendingfailed",
            VsanObjectHealthStateEnum::Nonavailabilityrelatedincompliancewithpausedrebuild => "nonavailabilityrelatedincompliancewithpausedrebuild",
            VsanObjectHealthStateEnum::RemoteAccessible => "remoteAccessible",
            VsanObjectHealthStateEnum::VsanObjectHealthStateUnknown => "VsanObjectHealthState_Unknown",
            VsanObjectHealthStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_OBJECT_HEALTH_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanObjectHealthStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanObjectHealthStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanObjectHealthStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanObjectHealthStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanObjectHealthStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanObjectHealthStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanObjectHealthStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanObjectHealthStateEnum> for &'a str {
    fn from(value: &'a VsanObjectHealthStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanObjectHealthStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_PEER_HOST_CONNECTIVITY_HEALTH_STATE_ENUM_MAP: phf::Map<&'static str, VsanPeerHostConnectivityHealthStateEnum> = ::phf::Map {
    key: 2980949210194914378,
    disps: &[
        (6, 0),
        (9, 8),
    ],
    entries: &[
        ("STATE_SOCKET_TIMEOUT", VsanPeerHostConnectivityHealthStateEnum::StateSocketTimeout),
        ("STATE_SSL_ERROR", VsanPeerHostConnectivityHealthStateEnum::StateSslError),
        ("STATE_OS_ERROR", VsanPeerHostConnectivityHealthStateEnum::StateOsError),
        ("STATE_GENERAL_EXCEPTION", VsanPeerHostConnectivityHealthStateEnum::StateGeneralException),
        ("STATE_SYSTEM_ERROR", VsanPeerHostConnectivityHealthStateEnum::StateSystemError),
        ("STATE_GOOD", VsanPeerHostConnectivityHealthStateEnum::StateGood),
        ("STATE_HTTP_EXCEPTION", VsanPeerHostConnectivityHealthStateEnum::StateHttpException),
        ("STATE_CONNECTION_REFUSED_ERROR", VsanPeerHostConnectivityHealthStateEnum::StateConnectionRefusedError),
        ("STATE_MEMORY_ERROR", VsanPeerHostConnectivityHealthStateEnum::StateMemoryError),
        ("STATE_UNKNOWN", VsanPeerHostConnectivityHealthStateEnum::StateUnknown),
    ],
};

impl VsanPeerHostConnectivityHealthStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanPeerHostConnectivityHealthStateEnum::StateGood => "STATE_GOOD",
            VsanPeerHostConnectivityHealthStateEnum::StateSslError => "STATE_SSL_ERROR",
            VsanPeerHostConnectivityHealthStateEnum::StateConnectionRefusedError => "STATE_CONNECTION_REFUSED_ERROR",
            VsanPeerHostConnectivityHealthStateEnum::StateSocketTimeout => "STATE_SOCKET_TIMEOUT",
            VsanPeerHostConnectivityHealthStateEnum::StateHttpException => "STATE_HTTP_EXCEPTION",
            VsanPeerHostConnectivityHealthStateEnum::StateMemoryError => "STATE_MEMORY_ERROR",
            VsanPeerHostConnectivityHealthStateEnum::StateSystemError => "STATE_SYSTEM_ERROR",
            VsanPeerHostConnectivityHealthStateEnum::StateOsError => "STATE_OS_ERROR",
            VsanPeerHostConnectivityHealthStateEnum::StateGeneralException => "STATE_GENERAL_EXCEPTION",
            VsanPeerHostConnectivityHealthStateEnum::StateUnknown => "STATE_UNKNOWN",
            VsanPeerHostConnectivityHealthStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_PEER_HOST_CONNECTIVITY_HEALTH_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanPeerHostConnectivityHealthStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanPeerHostConnectivityHealthStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanPeerHostConnectivityHealthStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanPeerHostConnectivityHealthStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanPeerHostConnectivityHealthStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanPeerHostConnectivityHealthStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanPeerHostConnectivityHealthStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanPeerHostConnectivityHealthStateEnum> for &'a str {
    fn from(value: &'a VsanPeerHostConnectivityHealthStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanPeerHostConnectivityHealthStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_SMART_PARAMETER_TYPE_ENUM_MAP: phf::Map<&'static str, VsanSmartParameterTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
        (10, 0),
        (11, 2),
    ],
    entries: &[
        ("smartdriveratedmaxtemperature", VsanSmartParameterTypeEnum::Smartdriveratedmaxtemperature),
        ("VsanSmartParameterType_Unknown", VsanSmartParameterTypeEnum::VsanSmartParameterTypeUnknown),
        ("smartreaderrorcount", VsanSmartParameterTypeEnum::Smartreaderrorcount),
        ("smartreadsectorstotct", VsanSmartParameterTypeEnum::Smartreadsectorstotct),
        ("smartwriteerrorcount", VsanSmartParameterTypeEnum::Smartwriteerrorcount),
        ("smartpowercyclecount", VsanSmartParameterTypeEnum::Smartpowercyclecount),
        ("smartwritesectorstotct", VsanSmartParameterTypeEnum::Smartwritesectorstotct),
        ("smartmediawearoutindicator", VsanSmartParameterTypeEnum::Smartmediawearoutindicator),
        ("smarthealthstatus", VsanSmartParameterTypeEnum::Smarthealthstatus),
        ("smartreallocatedsectorct", VsanSmartParameterTypeEnum::Smartreallocatedsectorct),
        ("smartdrivetemperature", VsanSmartParameterTypeEnum::Smartdrivetemperature),
        ("smartpoweronhours", VsanSmartParameterTypeEnum::Smartpoweronhours),
        ("smartrawreaderrorrate", VsanSmartParameterTypeEnum::Smartrawreaderrorrate),
        ("smartinitialbadblockcount", VsanSmartParameterTypeEnum::Smartinitialbadblockcount),
    ],
};

impl VsanSmartParameterTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanSmartParameterTypeEnum::Smarthealthstatus => "smarthealthstatus",
            VsanSmartParameterTypeEnum::Smartmediawearoutindicator => "smartmediawearoutindicator",
            VsanSmartParameterTypeEnum::Smartwriteerrorcount => "smartwriteerrorcount",
            VsanSmartParameterTypeEnum::Smartreaderrorcount => "smartreaderrorcount",
            VsanSmartParameterTypeEnum::Smartpoweronhours => "smartpoweronhours",
            VsanSmartParameterTypeEnum::Smartpowercyclecount => "smartpowercyclecount",
            VsanSmartParameterTypeEnum::Smartreallocatedsectorct => "smartreallocatedsectorct",
            VsanSmartParameterTypeEnum::Smartrawreaderrorrate => "smartrawreaderrorrate",
            VsanSmartParameterTypeEnum::Smartdrivetemperature => "smartdrivetemperature",
            VsanSmartParameterTypeEnum::Smartdriveratedmaxtemperature => "smartdriveratedmaxtemperature",
            VsanSmartParameterTypeEnum::Smartwritesectorstotct => "smartwritesectorstotct",
            VsanSmartParameterTypeEnum::Smartreadsectorstotct => "smartreadsectorstotct",
            VsanSmartParameterTypeEnum::Smartinitialbadblockcount => "smartinitialbadblockcount",
            VsanSmartParameterTypeEnum::VsanSmartParameterTypeUnknown => "VsanSmartParameterType_Unknown",
            VsanSmartParameterTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_SMART_PARAMETER_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanSmartParameterTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanSmartParameterTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanSmartParameterTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanSmartParameterTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanSmartParameterTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanSmartParameterTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanSmartParameterTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanSmartParameterTypeEnum> for &'a str {
    fn from(value: &'a VsanSmartParameterTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanSmartParameterTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static NET_IP_CONFIG_INFO_IP_ADDRESS_ORIGIN_ENUM_MAP: phf::Map<&'static str, NetIpConfigInfoIpAddressOriginEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (3, 0),
    ],
    entries: &[
        ("linklayer", NetIpConfigInfoIpAddressOriginEnum::Linklayer),
        ("dhcp", NetIpConfigInfoIpAddressOriginEnum::Dhcp),
        ("manual", NetIpConfigInfoIpAddressOriginEnum::Manual),
        ("random", NetIpConfigInfoIpAddressOriginEnum::Random),
        ("other", NetIpConfigInfoIpAddressOriginEnum::Other),
    ],
};

impl NetIpConfigInfoIpAddressOriginEnum {
    pub fn as_str(&self) -> &str {
        match self {
            NetIpConfigInfoIpAddressOriginEnum::Other => "other",
            NetIpConfigInfoIpAddressOriginEnum::Manual => "manual",
            NetIpConfigInfoIpAddressOriginEnum::Dhcp => "dhcp",
            NetIpConfigInfoIpAddressOriginEnum::Linklayer => "linklayer",
            NetIpConfigInfoIpAddressOriginEnum::Random => "random",
            NetIpConfigInfoIpAddressOriginEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        NET_IP_CONFIG_INFO_IP_ADDRESS_ORIGIN_ENUM_MAP.get(s).cloned().unwrap_or_else(|| NetIpConfigInfoIpAddressOriginEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for NetIpConfigInfoIpAddressOriginEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for NetIpConfigInfoIpAddressOriginEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<NetIpConfigInfoIpAddressOriginEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(NetIpConfigInfoIpAddressOriginEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for NetIpConfigInfoIpAddressOriginEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for NetIpConfigInfoIpAddressOriginEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a NetIpConfigInfoIpAddressOriginEnum> for &'a str {
    fn from(value: &'a NetIpConfigInfoIpAddressOriginEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for NetIpConfigInfoIpAddressOriginEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static NET_IP_CONFIG_INFO_IP_ADDRESS_STATUS_ENUM_MAP: phf::Map<&'static str, NetIpConfigInfoIpAddressStatusEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (4, 6),
        (1, 0),
    ],
    entries: &[
        ("tentative", NetIpConfigInfoIpAddressStatusEnum::Tentative),
        ("invalid", NetIpConfigInfoIpAddressStatusEnum::Invalid),
        ("unknown", NetIpConfigInfoIpAddressStatusEnum::Unknown),
        ("duplicate", NetIpConfigInfoIpAddressStatusEnum::Duplicate),
        ("preferred", NetIpConfigInfoIpAddressStatusEnum::Preferred),
        ("deprecated", NetIpConfigInfoIpAddressStatusEnum::Deprecated),
        ("inaccessible", NetIpConfigInfoIpAddressStatusEnum::Inaccessible),
    ],
};

impl NetIpConfigInfoIpAddressStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            NetIpConfigInfoIpAddressStatusEnum::Preferred => "preferred",
            NetIpConfigInfoIpAddressStatusEnum::Deprecated => "deprecated",
            NetIpConfigInfoIpAddressStatusEnum::Invalid => "invalid",
            NetIpConfigInfoIpAddressStatusEnum::Inaccessible => "inaccessible",
            NetIpConfigInfoIpAddressStatusEnum::Unknown => "unknown",
            NetIpConfigInfoIpAddressStatusEnum::Tentative => "tentative",
            NetIpConfigInfoIpAddressStatusEnum::Duplicate => "duplicate",
            NetIpConfigInfoIpAddressStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        NET_IP_CONFIG_INFO_IP_ADDRESS_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| NetIpConfigInfoIpAddressStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for NetIpConfigInfoIpAddressStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for NetIpConfigInfoIpAddressStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<NetIpConfigInfoIpAddressStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(NetIpConfigInfoIpAddressStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for NetIpConfigInfoIpAddressStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for NetIpConfigInfoIpAddressStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a NetIpConfigInfoIpAddressStatusEnum> for &'a str {
    fn from(value: &'a NetIpConfigInfoIpAddressStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for NetIpConfigInfoIpAddressStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static NET_IP_STACK_INFO_ENTRY_TYPE_ENUM_MAP: phf::Map<&'static str, NetIpStackInfoEntryTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("dynamic", NetIpStackInfoEntryTypeEnum::Dynamic),
        ("other", NetIpStackInfoEntryTypeEnum::Other),
        ("manual", NetIpStackInfoEntryTypeEnum::Manual),
        ("invalid", NetIpStackInfoEntryTypeEnum::Invalid),
    ],
};

impl NetIpStackInfoEntryTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            NetIpStackInfoEntryTypeEnum::Other => "other",
            NetIpStackInfoEntryTypeEnum::Invalid => "invalid",
            NetIpStackInfoEntryTypeEnum::Dynamic => "dynamic",
            NetIpStackInfoEntryTypeEnum::Manual => "manual",
            NetIpStackInfoEntryTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        NET_IP_STACK_INFO_ENTRY_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| NetIpStackInfoEntryTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for NetIpStackInfoEntryTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for NetIpStackInfoEntryTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<NetIpStackInfoEntryTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(NetIpStackInfoEntryTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for NetIpStackInfoEntryTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for NetIpStackInfoEntryTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a NetIpStackInfoEntryTypeEnum> for &'a str {
    fn from(value: &'a NetIpStackInfoEntryTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for NetIpStackInfoEntryTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static NET_IP_STACK_INFO_PREFERENCE_ENUM_MAP: phf::Map<&'static str, NetIpStackInfoPreferenceEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("reserved", NetIpStackInfoPreferenceEnum::Reserved),
        ("low", NetIpStackInfoPreferenceEnum::Low),
        ("medium", NetIpStackInfoPreferenceEnum::Medium),
        ("high", NetIpStackInfoPreferenceEnum::High),
    ],
};

impl NetIpStackInfoPreferenceEnum {
    pub fn as_str(&self) -> &str {
        match self {
            NetIpStackInfoPreferenceEnum::Reserved => "reserved",
            NetIpStackInfoPreferenceEnum::Low => "low",
            NetIpStackInfoPreferenceEnum::Medium => "medium",
            NetIpStackInfoPreferenceEnum::High => "high",
            NetIpStackInfoPreferenceEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        NET_IP_STACK_INFO_PREFERENCE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| NetIpStackInfoPreferenceEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for NetIpStackInfoPreferenceEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for NetIpStackInfoPreferenceEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<NetIpStackInfoPreferenceEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(NetIpStackInfoPreferenceEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for NetIpStackInfoPreferenceEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for NetIpStackInfoPreferenceEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a NetIpStackInfoPreferenceEnum> for &'a str {
    fn from(value: &'a NetIpStackInfoPreferenceEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for NetIpStackInfoPreferenceEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static NET_BIOS_CONFIG_INFO_MODE_ENUM_MAP: phf::Map<&'static str, NetBiosConfigInfoModeEnum> = ::phf::Map {
    key: 12213676231523076107,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("enabled", NetBiosConfigInfoModeEnum::Enabled),
        ("unknown", NetBiosConfigInfoModeEnum::Unknown),
        ("enabledViaDHCP", NetBiosConfigInfoModeEnum::EnabledViaDhcp),
        ("disabled", NetBiosConfigInfoModeEnum::Disabled),
    ],
};

impl NetBiosConfigInfoModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            NetBiosConfigInfoModeEnum::Unknown => "unknown",
            NetBiosConfigInfoModeEnum::Enabled => "enabled",
            NetBiosConfigInfoModeEnum::Disabled => "disabled",
            NetBiosConfigInfoModeEnum::EnabledViaDhcp => "enabledViaDHCP",
            NetBiosConfigInfoModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        NET_BIOS_CONFIG_INFO_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| NetBiosConfigInfoModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for NetBiosConfigInfoModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for NetBiosConfigInfoModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<NetBiosConfigInfoModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(NetBiosConfigInfoModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for NetBiosConfigInfoModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for NetBiosConfigInfoModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a NetBiosConfigInfoModeEnum> for &'a str {
    fn from(value: &'a NetBiosConfigInfoModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for NetBiosConfigInfoModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static ARRAY_UPDATE_OPERATION_ENUM_MAP: phf::Map<&'static str, ArrayUpdateOperationEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("add", ArrayUpdateOperationEnum::Add),
        ("edit", ArrayUpdateOperationEnum::Edit),
        ("remove", ArrayUpdateOperationEnum::Remove),
    ],
};

impl ArrayUpdateOperationEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ArrayUpdateOperationEnum::Add => "add",
            ArrayUpdateOperationEnum::Remove => "remove",
            ArrayUpdateOperationEnum::Edit => "edit",
            ArrayUpdateOperationEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        ARRAY_UPDATE_OPERATION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ArrayUpdateOperationEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ArrayUpdateOperationEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ArrayUpdateOperationEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ArrayUpdateOperationEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ArrayUpdateOperationEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ArrayUpdateOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ArrayUpdateOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ArrayUpdateOperationEnum> for &'a str {
    fn from(value: &'a ArrayUpdateOperationEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ArrayUpdateOperationEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static COMPLIANCE_RESULT_STATUS_ENUM_MAP: phf::Map<&'static str, ComplianceResultStatusEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("compliant", ComplianceResultStatusEnum::Compliant),
        ("unknown", ComplianceResultStatusEnum::Unknown),
        ("nonCompliant", ComplianceResultStatusEnum::NonCompliant),
        ("running", ComplianceResultStatusEnum::Running),
    ],
};

impl ComplianceResultStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ComplianceResultStatusEnum::Compliant => "compliant",
            ComplianceResultStatusEnum::NonCompliant => "nonCompliant",
            ComplianceResultStatusEnum::Unknown => "unknown",
            ComplianceResultStatusEnum::Running => "running",
            ComplianceResultStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        COMPLIANCE_RESULT_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ComplianceResultStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ComplianceResultStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ComplianceResultStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ComplianceResultStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ComplianceResultStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ComplianceResultStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ComplianceResultStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ComplianceResultStatusEnum> for &'a str {
    fn from(value: &'a ComplianceResultStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ComplianceResultStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PROFILE_NUMERIC_COMPARATOR_ENUM_MAP: phf::Map<&'static str, ProfileNumericComparatorEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
        (0, 1),
    ],
    entries: &[
        ("lessThanEqual", ProfileNumericComparatorEnum::LessThanEqual),
        ("notEqual", ProfileNumericComparatorEnum::NotEqual),
        ("greaterThan", ProfileNumericComparatorEnum::GreaterThan),
        ("lessThan", ProfileNumericComparatorEnum::LessThan),
        ("equal", ProfileNumericComparatorEnum::Equal),
        ("greaterThanEqual", ProfileNumericComparatorEnum::GreaterThanEqual),
    ],
};

impl ProfileNumericComparatorEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ProfileNumericComparatorEnum::LessThan => "lessThan",
            ProfileNumericComparatorEnum::LessThanEqual => "lessThanEqual",
            ProfileNumericComparatorEnum::Equal => "equal",
            ProfileNumericComparatorEnum::NotEqual => "notEqual",
            ProfileNumericComparatorEnum::GreaterThanEqual => "greaterThanEqual",
            ProfileNumericComparatorEnum::GreaterThan => "greaterThan",
            ProfileNumericComparatorEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PROFILE_NUMERIC_COMPARATOR_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ProfileNumericComparatorEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ProfileNumericComparatorEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ProfileNumericComparatorEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ProfileNumericComparatorEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ProfileNumericComparatorEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ProfileNumericComparatorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ProfileNumericComparatorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ProfileNumericComparatorEnum> for &'a str {
    fn from(value: &'a ProfileNumericComparatorEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ProfileNumericComparatorEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PROFILE_PARAMETER_METADATA_RELATION_TYPE_ENUM_MAP: phf::Map<&'static str, ProfileParameterMetadataRelationTypeEnum> = ::phf::Map {
    key: 345707026197253659,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("dynamic_relation", ProfileParameterMetadataRelationTypeEnum::DynamicRelation),
        ("static_relation", ProfileParameterMetadataRelationTypeEnum::StaticRelation),
        ("extensible_relation", ProfileParameterMetadataRelationTypeEnum::ExtensibleRelation),
        ("localizable_relation", ProfileParameterMetadataRelationTypeEnum::LocalizableRelation),
        ("validation_relation", ProfileParameterMetadataRelationTypeEnum::ValidationRelation),
    ],
};

impl ProfileParameterMetadataRelationTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ProfileParameterMetadataRelationTypeEnum::DynamicRelation => "dynamic_relation",
            ProfileParameterMetadataRelationTypeEnum::ExtensibleRelation => "extensible_relation",
            ProfileParameterMetadataRelationTypeEnum::LocalizableRelation => "localizable_relation",
            ProfileParameterMetadataRelationTypeEnum::StaticRelation => "static_relation",
            ProfileParameterMetadataRelationTypeEnum::ValidationRelation => "validation_relation",
            ProfileParameterMetadataRelationTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PROFILE_PARAMETER_METADATA_RELATION_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ProfileParameterMetadataRelationTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ProfileParameterMetadataRelationTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ProfileParameterMetadataRelationTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ProfileParameterMetadataRelationTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ProfileParameterMetadataRelationTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ProfileParameterMetadataRelationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ProfileParameterMetadataRelationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ProfileParameterMetadataRelationTypeEnum> for &'a str {
    fn from(value: &'a ProfileParameterMetadataRelationTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ProfileParameterMetadataRelationTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CLUSTER_PROFILE_SERVICE_TYPE_ENUM_MAP: phf::Map<&'static str, ClusterProfileServiceTypeEnum> = ::phf::Map {
    key: 14108922650502679131,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("DPM", ClusterProfileServiceTypeEnum::Dpm),
        ("DRS", ClusterProfileServiceTypeEnum::Drs),
        ("HA", ClusterProfileServiceTypeEnum::Ha),
        ("FT", ClusterProfileServiceTypeEnum::Ft),
    ],
};

impl ClusterProfileServiceTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ClusterProfileServiceTypeEnum::Drs => "DRS",
            ClusterProfileServiceTypeEnum::Ha => "HA",
            ClusterProfileServiceTypeEnum::Dpm => "DPM",
            ClusterProfileServiceTypeEnum::Ft => "FT",
            ClusterProfileServiceTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CLUSTER_PROFILE_SERVICE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ClusterProfileServiceTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ClusterProfileServiceTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ClusterProfileServiceTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ClusterProfileServiceTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ClusterProfileServiceTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ClusterProfileServiceTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ClusterProfileServiceTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ClusterProfileServiceTypeEnum> for &'a str {
    fn from(value: &'a ClusterProfileServiceTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ClusterProfileServiceTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PROFILE_EXECUTE_RESULT_STATUS_ENUM_MAP: phf::Map<&'static str, ProfileExecuteResultStatusEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("needInput", ProfileExecuteResultStatusEnum::NeedInput),
        ("success", ProfileExecuteResultStatusEnum::Success),
        ("error", ProfileExecuteResultStatusEnum::Error),
    ],
};

impl ProfileExecuteResultStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ProfileExecuteResultStatusEnum::Success => "success",
            ProfileExecuteResultStatusEnum::NeedInput => "needInput",
            ProfileExecuteResultStatusEnum::Error => "error",
            ProfileExecuteResultStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PROFILE_EXECUTE_RESULT_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ProfileExecuteResultStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ProfileExecuteResultStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ProfileExecuteResultStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ProfileExecuteResultStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ProfileExecuteResultStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ProfileExecuteResultStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ProfileExecuteResultStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ProfileExecuteResultStatusEnum> for &'a str {
    fn from(value: &'a ProfileExecuteResultStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ProfileExecuteResultStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_PROFILE_VALIDATION_FAILURE_INFO_UPDATE_TYPE_ENUM_MAP: phf::Map<&'static str, HostProfileValidationFailureInfoUpdateTypeEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("Edit", HostProfileValidationFailureInfoUpdateTypeEnum::Edit),
        ("Compose", HostProfileValidationFailureInfoUpdateTypeEnum::Compose),
        ("Import", HostProfileValidationFailureInfoUpdateTypeEnum::Import),
        ("HostBased", HostProfileValidationFailureInfoUpdateTypeEnum::HostBased),
    ],
};

impl HostProfileValidationFailureInfoUpdateTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostProfileValidationFailureInfoUpdateTypeEnum::HostBased => "HostBased",
            HostProfileValidationFailureInfoUpdateTypeEnum::Import => "Import",
            HostProfileValidationFailureInfoUpdateTypeEnum::Edit => "Edit",
            HostProfileValidationFailureInfoUpdateTypeEnum::Compose => "Compose",
            HostProfileValidationFailureInfoUpdateTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_PROFILE_VALIDATION_FAILURE_INFO_UPDATE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostProfileValidationFailureInfoUpdateTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostProfileValidationFailureInfoUpdateTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostProfileValidationFailureInfoUpdateTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostProfileValidationFailureInfoUpdateTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostProfileValidationFailureInfoUpdateTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostProfileValidationFailureInfoUpdateTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostProfileValidationFailureInfoUpdateTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostProfileValidationFailureInfoUpdateTypeEnum> for &'a str {
    fn from(value: &'a HostProfileValidationFailureInfoUpdateTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostProfileValidationFailureInfoUpdateTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_PROFILE_VALIDATION_STATE_ENUM_MAP: phf::Map<&'static str, HostProfileValidationStateEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("Failed", HostProfileValidationStateEnum::Failed),
        ("Running", HostProfileValidationStateEnum::Running),
        ("Ready", HostProfileValidationStateEnum::Ready),
    ],
};

impl HostProfileValidationStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostProfileValidationStateEnum::Ready => "Ready",
            HostProfileValidationStateEnum::Running => "Running",
            HostProfileValidationStateEnum::Failed => "Failed",
            HostProfileValidationStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_PROFILE_VALIDATION_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostProfileValidationStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostProfileValidationStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostProfileValidationStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostProfileValidationStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostProfileValidationStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostProfileValidationStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostProfileValidationStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostProfileValidationStateEnum> for &'a str {
    fn from(value: &'a HostProfileValidationStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostProfileValidationStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_PROFILE_MANAGER_ANSWER_FILE_STATUS_ENUM_MAP: phf::Map<&'static str, HostProfileManagerAnswerFileStatusEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("invalid", HostProfileManagerAnswerFileStatusEnum::Invalid),
        ("unknown", HostProfileManagerAnswerFileStatusEnum::Unknown),
        ("valid", HostProfileManagerAnswerFileStatusEnum::Valid),
    ],
};

impl HostProfileManagerAnswerFileStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostProfileManagerAnswerFileStatusEnum::Valid => "valid",
            HostProfileManagerAnswerFileStatusEnum::Invalid => "invalid",
            HostProfileManagerAnswerFileStatusEnum::Unknown => "unknown",
            HostProfileManagerAnswerFileStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_PROFILE_MANAGER_ANSWER_FILE_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostProfileManagerAnswerFileStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostProfileManagerAnswerFileStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostProfileManagerAnswerFileStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostProfileManagerAnswerFileStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostProfileManagerAnswerFileStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostProfileManagerAnswerFileStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostProfileManagerAnswerFileStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostProfileManagerAnswerFileStatusEnum> for &'a str {
    fn from(value: &'a HostProfileManagerAnswerFileStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostProfileManagerAnswerFileStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static APPLY_HOST_PROFILE_CONFIGURATION_RESULT_STATUS_ENUM_MAP: phf::Map<&'static str, ApplyHostProfileConfigurationResultStatusEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (2, 0),
        (2, 5),
    ],
    entries: &[
        ("failed", ApplyHostProfileConfigurationResultStatusEnum::Failed),
        ("state_not_satisfied", ApplyHostProfileConfigurationResultStatusEnum::StateNotSatisfied),
        ("canceled", ApplyHostProfileConfigurationResultStatusEnum::Canceled),
        ("success", ApplyHostProfileConfigurationResultStatusEnum::Success),
        ("exit_maintenancemode_failed", ApplyHostProfileConfigurationResultStatusEnum::ExitMaintenancemodeFailed),
        ("check_compliance_failed", ApplyHostProfileConfigurationResultStatusEnum::CheckComplianceFailed),
        ("stateless_reboot_failed", ApplyHostProfileConfigurationResultStatusEnum::StatelessRebootFailed),
        ("reboot_failed", ApplyHostProfileConfigurationResultStatusEnum::RebootFailed),
    ],
};

impl ApplyHostProfileConfigurationResultStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ApplyHostProfileConfigurationResultStatusEnum::Success => "success",
            ApplyHostProfileConfigurationResultStatusEnum::Failed => "failed",
            ApplyHostProfileConfigurationResultStatusEnum::RebootFailed => "reboot_failed",
            ApplyHostProfileConfigurationResultStatusEnum::StatelessRebootFailed => "stateless_reboot_failed",
            ApplyHostProfileConfigurationResultStatusEnum::CheckComplianceFailed => "check_compliance_failed",
            ApplyHostProfileConfigurationResultStatusEnum::StateNotSatisfied => "state_not_satisfied",
            ApplyHostProfileConfigurationResultStatusEnum::ExitMaintenancemodeFailed => "exit_maintenancemode_failed",
            ApplyHostProfileConfigurationResultStatusEnum::Canceled => "canceled",
            ApplyHostProfileConfigurationResultStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        APPLY_HOST_PROFILE_CONFIGURATION_RESULT_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ApplyHostProfileConfigurationResultStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ApplyHostProfileConfigurationResultStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ApplyHostProfileConfigurationResultStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ApplyHostProfileConfigurationResultStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ApplyHostProfileConfigurationResultStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ApplyHostProfileConfigurationResultStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ApplyHostProfileConfigurationResultStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ApplyHostProfileConfigurationResultStatusEnum> for &'a str {
    fn from(value: &'a ApplyHostProfileConfigurationResultStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ApplyHostProfileConfigurationResultStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_PROFILE_MANAGER_COMPOSITION_RESULT_RESULT_ELEMENT_STATUS_ENUM_MAP: phf::Map<&'static str, HostProfileManagerCompositionResultResultElementStatusEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("success", HostProfileManagerCompositionResultResultElementStatusEnum::Success),
        ("error", HostProfileManagerCompositionResultResultElementStatusEnum::Error),
    ],
};

impl HostProfileManagerCompositionResultResultElementStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostProfileManagerCompositionResultResultElementStatusEnum::Success => "success",
            HostProfileManagerCompositionResultResultElementStatusEnum::Error => "error",
            HostProfileManagerCompositionResultResultElementStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_PROFILE_MANAGER_COMPOSITION_RESULT_RESULT_ELEMENT_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostProfileManagerCompositionResultResultElementStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostProfileManagerCompositionResultResultElementStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostProfileManagerCompositionResultResultElementStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostProfileManagerCompositionResultResultElementStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostProfileManagerCompositionResultResultElementStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostProfileManagerCompositionResultResultElementStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostProfileManagerCompositionResultResultElementStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostProfileManagerCompositionResultResultElementStatusEnum> for &'a str {
    fn from(value: &'a HostProfileManagerCompositionResultResultElementStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostProfileManagerCompositionResultResultElementStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_PROFILE_MANAGER_COMPOSITION_VALIDATION_RESULT_RESULT_ELEMENT_STATUS_ENUM_MAP: phf::Map<&'static str, HostProfileManagerCompositionValidationResultResultElementStatusEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("success", HostProfileManagerCompositionValidationResultResultElementStatusEnum::Success),
        ("error", HostProfileManagerCompositionValidationResultResultElementStatusEnum::Error),
    ],
};

impl HostProfileManagerCompositionValidationResultResultElementStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostProfileManagerCompositionValidationResultResultElementStatusEnum::Success => "success",
            HostProfileManagerCompositionValidationResultResultElementStatusEnum::Error => "error",
            HostProfileManagerCompositionValidationResultResultElementStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_PROFILE_MANAGER_COMPOSITION_VALIDATION_RESULT_RESULT_ELEMENT_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostProfileManagerCompositionValidationResultResultElementStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostProfileManagerCompositionValidationResultResultElementStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostProfileManagerCompositionValidationResultResultElementStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostProfileManagerCompositionValidationResultResultElementStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostProfileManagerCompositionValidationResultResultElementStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostProfileManagerCompositionValidationResultResultElementStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostProfileManagerCompositionValidationResultResultElementStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostProfileManagerCompositionValidationResultResultElementStatusEnum> for &'a str {
    fn from(value: &'a HostProfileManagerCompositionValidationResultResultElementStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostProfileManagerCompositionValidationResultResultElementStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HOST_PROFILE_MANAGER_TASK_LIST_REQUIREMENT_ENUM_MAP: phf::Map<&'static str, HostProfileManagerTaskListRequirementEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("rebootRequired", HostProfileManagerTaskListRequirementEnum::RebootRequired),
        ("maintenanceModeRequired", HostProfileManagerTaskListRequirementEnum::MaintenanceModeRequired),
    ],
};

impl HostProfileManagerTaskListRequirementEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HostProfileManagerTaskListRequirementEnum::MaintenanceModeRequired => "maintenanceModeRequired",
            HostProfileManagerTaskListRequirementEnum::RebootRequired => "rebootRequired",
            HostProfileManagerTaskListRequirementEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HOST_PROFILE_MANAGER_TASK_LIST_REQUIREMENT_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HostProfileManagerTaskListRequirementEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HostProfileManagerTaskListRequirementEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HostProfileManagerTaskListRequirementEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HostProfileManagerTaskListRequirementEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HostProfileManagerTaskListRequirementEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HostProfileManagerTaskListRequirementEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HostProfileManagerTaskListRequirementEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HostProfileManagerTaskListRequirementEnum> for &'a str {
    fn from(value: &'a HostProfileManagerTaskListRequirementEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HostProfileManagerTaskListRequirementEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static ANSWER_FILE_VALIDATION_INFO_STATUS_ENUM_MAP: phf::Map<&'static str, AnswerFileValidationInfoStatusEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("failed_defaults", AnswerFileValidationInfoStatusEnum::FailedDefaults),
        ("success", AnswerFileValidationInfoStatusEnum::Success),
        ("failed", AnswerFileValidationInfoStatusEnum::Failed),
    ],
};

impl AnswerFileValidationInfoStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            AnswerFileValidationInfoStatusEnum::Success => "success",
            AnswerFileValidationInfoStatusEnum::Failed => "failed",
            AnswerFileValidationInfoStatusEnum::FailedDefaults => "failed_defaults",
            AnswerFileValidationInfoStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        ANSWER_FILE_VALIDATION_INFO_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| AnswerFileValidationInfoStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for AnswerFileValidationInfoStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for AnswerFileValidationInfoStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<AnswerFileValidationInfoStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(AnswerFileValidationInfoStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for AnswerFileValidationInfoStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for AnswerFileValidationInfoStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a AnswerFileValidationInfoStatusEnum> for &'a str {
    fn from(value: &'a AnswerFileValidationInfoStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for AnswerFileValidationInfoStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static DAY_OF_WEEK_ENUM_MAP: phf::Map<&'static str, DayOfWeekEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (3, 6),
        (6, 0),
    ],
    entries: &[
        ("tuesday", DayOfWeekEnum::Tuesday),
        ("wednesday", DayOfWeekEnum::Wednesday),
        ("friday", DayOfWeekEnum::Friday),
        ("sunday", DayOfWeekEnum::Sunday),
        ("saturday", DayOfWeekEnum::Saturday),
        ("thursday", DayOfWeekEnum::Thursday),
        ("monday", DayOfWeekEnum::Monday),
    ],
};

impl DayOfWeekEnum {
    pub fn as_str(&self) -> &str {
        match self {
            DayOfWeekEnum::Sunday => "sunday",
            DayOfWeekEnum::Monday => "monday",
            DayOfWeekEnum::Tuesday => "tuesday",
            DayOfWeekEnum::Wednesday => "wednesday",
            DayOfWeekEnum::Thursday => "thursday",
            DayOfWeekEnum::Friday => "friday",
            DayOfWeekEnum::Saturday => "saturday",
            DayOfWeekEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        DAY_OF_WEEK_ENUM_MAP.get(s).cloned().unwrap_or_else(|| DayOfWeekEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for DayOfWeekEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for DayOfWeekEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<DayOfWeekEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(DayOfWeekEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for DayOfWeekEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for DayOfWeekEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a DayOfWeekEnum> for &'a str {
    fn from(value: &'a DayOfWeekEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for DayOfWeekEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static WEEK_OF_MONTH_ENUM_MAP: phf::Map<&'static str, WeekOfMonthEnum> = ::phf::Map {
    key: 351906021642186605,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("fourth", WeekOfMonthEnum::Fourth),
        ("second", WeekOfMonthEnum::Second),
        ("third", WeekOfMonthEnum::Third),
        ("first", WeekOfMonthEnum::First),
        ("last", WeekOfMonthEnum::Last),
    ],
};

impl WeekOfMonthEnum {
    pub fn as_str(&self) -> &str {
        match self {
            WeekOfMonthEnum::First => "first",
            WeekOfMonthEnum::Second => "second",
            WeekOfMonthEnum::Third => "third",
            WeekOfMonthEnum::Fourth => "fourth",
            WeekOfMonthEnum::Last => "last",
            WeekOfMonthEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        WEEK_OF_MONTH_ENUM_MAP.get(s).cloned().unwrap_or_else(|| WeekOfMonthEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for WeekOfMonthEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for WeekOfMonthEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<WeekOfMonthEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(WeekOfMonthEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for WeekOfMonthEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for WeekOfMonthEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a WeekOfMonthEnum> for &'a str {
    fn from(value: &'a WeekOfMonthEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for WeekOfMonthEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PLACEMENT_AFFINITY_RULE_RULE_SCOPE_ENUM_MAP: phf::Map<&'static str, PlacementAffinityRuleRuleScopeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("datastore", PlacementAffinityRuleRuleScopeEnum::Datastore),
        ("storagePod", PlacementAffinityRuleRuleScopeEnum::StoragePod),
        ("host", PlacementAffinityRuleRuleScopeEnum::Host),
        ("cluster", PlacementAffinityRuleRuleScopeEnum::Cluster),
    ],
};

impl PlacementAffinityRuleRuleScopeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PlacementAffinityRuleRuleScopeEnum::Cluster => "cluster",
            PlacementAffinityRuleRuleScopeEnum::Host => "host",
            PlacementAffinityRuleRuleScopeEnum::StoragePod => "storagePod",
            PlacementAffinityRuleRuleScopeEnum::Datastore => "datastore",
            PlacementAffinityRuleRuleScopeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PLACEMENT_AFFINITY_RULE_RULE_SCOPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PlacementAffinityRuleRuleScopeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PlacementAffinityRuleRuleScopeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PlacementAffinityRuleRuleScopeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PlacementAffinityRuleRuleScopeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PlacementAffinityRuleRuleScopeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PlacementAffinityRuleRuleScopeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PlacementAffinityRuleRuleScopeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PlacementAffinityRuleRuleScopeEnum> for &'a str {
    fn from(value: &'a PlacementAffinityRuleRuleScopeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PlacementAffinityRuleRuleScopeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PLACEMENT_AFFINITY_RULE_RULE_TYPE_ENUM_MAP: phf::Map<&'static str, PlacementAffinityRuleRuleTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("softAntiAffinity", PlacementAffinityRuleRuleTypeEnum::SoftAntiAffinity),
        ("softAffinity", PlacementAffinityRuleRuleTypeEnum::SoftAffinity),
        ("antiAffinity", PlacementAffinityRuleRuleTypeEnum::AntiAffinity),
        ("affinity", PlacementAffinityRuleRuleTypeEnum::Affinity),
    ],
};

impl PlacementAffinityRuleRuleTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PlacementAffinityRuleRuleTypeEnum::Affinity => "affinity",
            PlacementAffinityRuleRuleTypeEnum::AntiAffinity => "antiAffinity",
            PlacementAffinityRuleRuleTypeEnum::SoftAffinity => "softAffinity",
            PlacementAffinityRuleRuleTypeEnum::SoftAntiAffinity => "softAntiAffinity",
            PlacementAffinityRuleRuleTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PLACEMENT_AFFINITY_RULE_RULE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PlacementAffinityRuleRuleTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PlacementAffinityRuleRuleTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PlacementAffinityRuleRuleTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PlacementAffinityRuleRuleTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PlacementAffinityRuleRuleTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PlacementAffinityRuleRuleTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PlacementAffinityRuleRuleTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PlacementAffinityRuleRuleTypeEnum> for &'a str {
    fn from(value: &'a PlacementAffinityRuleRuleTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PlacementAffinityRuleRuleTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static STORAGE_DRS_POD_CONFIG_INFO_BEHAVIOR_ENUM_MAP: phf::Map<&'static str, StorageDrsPodConfigInfoBehaviorEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("manual", StorageDrsPodConfigInfoBehaviorEnum::Manual),
        ("automated", StorageDrsPodConfigInfoBehaviorEnum::Automated),
    ],
};

impl StorageDrsPodConfigInfoBehaviorEnum {
    pub fn as_str(&self) -> &str {
        match self {
            StorageDrsPodConfigInfoBehaviorEnum::Manual => "manual",
            StorageDrsPodConfigInfoBehaviorEnum::Automated => "automated",
            StorageDrsPodConfigInfoBehaviorEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        STORAGE_DRS_POD_CONFIG_INFO_BEHAVIOR_ENUM_MAP.get(s).cloned().unwrap_or_else(|| StorageDrsPodConfigInfoBehaviorEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for StorageDrsPodConfigInfoBehaviorEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for StorageDrsPodConfigInfoBehaviorEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<StorageDrsPodConfigInfoBehaviorEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(StorageDrsPodConfigInfoBehaviorEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for StorageDrsPodConfigInfoBehaviorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for StorageDrsPodConfigInfoBehaviorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a StorageDrsPodConfigInfoBehaviorEnum> for &'a str {
    fn from(value: &'a StorageDrsPodConfigInfoBehaviorEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for StorageDrsPodConfigInfoBehaviorEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static STORAGE_DRS_SPACE_LOAD_BALANCE_CONFIG_SPACE_THRESHOLD_MODE_ENUM_MAP: phf::Map<&'static str, StorageDrsSpaceLoadBalanceConfigSpaceThresholdModeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("freeSpace", StorageDrsSpaceLoadBalanceConfigSpaceThresholdModeEnum::FreeSpace),
        ("utilization", StorageDrsSpaceLoadBalanceConfigSpaceThresholdModeEnum::Utilization),
    ],
};

impl StorageDrsSpaceLoadBalanceConfigSpaceThresholdModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            StorageDrsSpaceLoadBalanceConfigSpaceThresholdModeEnum::Utilization => "utilization",
            StorageDrsSpaceLoadBalanceConfigSpaceThresholdModeEnum::FreeSpace => "freeSpace",
            StorageDrsSpaceLoadBalanceConfigSpaceThresholdModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        STORAGE_DRS_SPACE_LOAD_BALANCE_CONFIG_SPACE_THRESHOLD_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| StorageDrsSpaceLoadBalanceConfigSpaceThresholdModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for StorageDrsSpaceLoadBalanceConfigSpaceThresholdModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for StorageDrsSpaceLoadBalanceConfigSpaceThresholdModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<StorageDrsSpaceLoadBalanceConfigSpaceThresholdModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(StorageDrsSpaceLoadBalanceConfigSpaceThresholdModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for StorageDrsSpaceLoadBalanceConfigSpaceThresholdModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for StorageDrsSpaceLoadBalanceConfigSpaceThresholdModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a StorageDrsSpaceLoadBalanceConfigSpaceThresholdModeEnum> for &'a str {
    fn from(value: &'a StorageDrsSpaceLoadBalanceConfigSpaceThresholdModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for StorageDrsSpaceLoadBalanceConfigSpaceThresholdModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static STORAGE_PLACEMENT_SPEC_PLACEMENT_TYPE_ENUM_MAP: phf::Map<&'static str, StoragePlacementSpecPlacementTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("clone", StoragePlacementSpecPlacementTypeEnum::Clone),
        ("reconfigure", StoragePlacementSpecPlacementTypeEnum::Reconfigure),
        ("relocate", StoragePlacementSpecPlacementTypeEnum::Relocate),
        ("create", StoragePlacementSpecPlacementTypeEnum::Create),
    ],
};

impl StoragePlacementSpecPlacementTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            StoragePlacementSpecPlacementTypeEnum::Create => "create",
            StoragePlacementSpecPlacementTypeEnum::Reconfigure => "reconfigure",
            StoragePlacementSpecPlacementTypeEnum::Relocate => "relocate",
            StoragePlacementSpecPlacementTypeEnum::Clone => "clone",
            StoragePlacementSpecPlacementTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        STORAGE_PLACEMENT_SPEC_PLACEMENT_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| StoragePlacementSpecPlacementTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for StoragePlacementSpecPlacementTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for StoragePlacementSpecPlacementTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<StoragePlacementSpecPlacementTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(StoragePlacementSpecPlacementTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for StoragePlacementSpecPlacementTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for StoragePlacementSpecPlacementTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a StoragePlacementSpecPlacementTypeEnum> for &'a str {
    fn from(value: &'a StoragePlacementSpecPlacementTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for StoragePlacementSpecPlacementTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_DISK_RULE_SPEC_RULE_TYPE_ENUM_MAP: phf::Map<&'static str, VirtualDiskRuleSpecRuleTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("affinity", VirtualDiskRuleSpecRuleTypeEnum::Affinity),
        ("disabled", VirtualDiskRuleSpecRuleTypeEnum::Disabled),
        ("antiAffinity", VirtualDiskRuleSpecRuleTypeEnum::AntiAffinity),
    ],
};

impl VirtualDiskRuleSpecRuleTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualDiskRuleSpecRuleTypeEnum::Affinity => "affinity",
            VirtualDiskRuleSpecRuleTypeEnum::AntiAffinity => "antiAffinity",
            VirtualDiskRuleSpecRuleTypeEnum::Disabled => "disabled",
            VirtualDiskRuleSpecRuleTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_DISK_RULE_SPEC_RULE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualDiskRuleSpecRuleTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualDiskRuleSpecRuleTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualDiskRuleSpecRuleTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualDiskRuleSpecRuleTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualDiskRuleSpecRuleTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualDiskRuleSpecRuleTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualDiskRuleSpecRuleTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualDiskRuleSpecRuleTypeEnum> for &'a str {
    fn from(value: &'a VirtualDiskRuleSpecRuleTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualDiskRuleSpecRuleTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static V_APP_CLONE_SPEC_PROVISIONING_TYPE_ENUM_MAP: phf::Map<&'static str, VAppCloneSpecProvisioningTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("thin", VAppCloneSpecProvisioningTypeEnum::Thin),
        ("thick", VAppCloneSpecProvisioningTypeEnum::Thick),
        ("sameAsSource", VAppCloneSpecProvisioningTypeEnum::SameAsSource),
    ],
};

impl VAppCloneSpecProvisioningTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VAppCloneSpecProvisioningTypeEnum::SameAsSource => "sameAsSource",
            VAppCloneSpecProvisioningTypeEnum::Thin => "thin",
            VAppCloneSpecProvisioningTypeEnum::Thick => "thick",
            VAppCloneSpecProvisioningTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        V_APP_CLONE_SPEC_PROVISIONING_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VAppCloneSpecProvisioningTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VAppCloneSpecProvisioningTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VAppCloneSpecProvisioningTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VAppCloneSpecProvisioningTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VAppCloneSpecProvisioningTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VAppCloneSpecProvisioningTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VAppCloneSpecProvisioningTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VAppCloneSpecProvisioningTypeEnum> for &'a str {
    fn from(value: &'a VAppCloneSpecProvisioningTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VAppCloneSpecProvisioningTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static V_APP_AUTO_START_ACTION_ENUM_MAP: phf::Map<&'static str, VAppAutoStartActionEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (3, 0),
    ],
    entries: &[
        ("none", VAppAutoStartActionEnum::None),
        ("guestShutdown", VAppAutoStartActionEnum::GuestShutdown),
        ("suspend", VAppAutoStartActionEnum::Suspend),
        ("powerOn", VAppAutoStartActionEnum::PowerOn),
        ("powerOff", VAppAutoStartActionEnum::PowerOff),
    ],
};

impl VAppAutoStartActionEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VAppAutoStartActionEnum::None => "none",
            VAppAutoStartActionEnum::PowerOn => "powerOn",
            VAppAutoStartActionEnum::PowerOff => "powerOff",
            VAppAutoStartActionEnum::GuestShutdown => "guestShutdown",
            VAppAutoStartActionEnum::Suspend => "suspend",
            VAppAutoStartActionEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        V_APP_AUTO_START_ACTION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VAppAutoStartActionEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VAppAutoStartActionEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VAppAutoStartActionEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VAppAutoStartActionEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VAppAutoStartActionEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VAppAutoStartActionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VAppAutoStartActionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VAppAutoStartActionEnum> for &'a str {
    fn from(value: &'a VAppAutoStartActionEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VAppAutoStartActionEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static V_APP_IP_ASSIGNMENT_INFO_ALLOCATION_SCHEMES_ENUM_MAP: phf::Map<&'static str, VAppIpAssignmentInfoAllocationSchemesEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("dhcp", VAppIpAssignmentInfoAllocationSchemesEnum::Dhcp),
        ("ovfenv", VAppIpAssignmentInfoAllocationSchemesEnum::Ovfenv),
    ],
};

impl VAppIpAssignmentInfoAllocationSchemesEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VAppIpAssignmentInfoAllocationSchemesEnum::Dhcp => "dhcp",
            VAppIpAssignmentInfoAllocationSchemesEnum::Ovfenv => "ovfenv",
            VAppIpAssignmentInfoAllocationSchemesEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        V_APP_IP_ASSIGNMENT_INFO_ALLOCATION_SCHEMES_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VAppIpAssignmentInfoAllocationSchemesEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VAppIpAssignmentInfoAllocationSchemesEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VAppIpAssignmentInfoAllocationSchemesEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VAppIpAssignmentInfoAllocationSchemesEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VAppIpAssignmentInfoAllocationSchemesEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VAppIpAssignmentInfoAllocationSchemesEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VAppIpAssignmentInfoAllocationSchemesEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VAppIpAssignmentInfoAllocationSchemesEnum> for &'a str {
    fn from(value: &'a VAppIpAssignmentInfoAllocationSchemesEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VAppIpAssignmentInfoAllocationSchemesEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static V_APP_IP_ASSIGNMENT_INFO_IP_ALLOCATION_POLICY_ENUM_MAP: phf::Map<&'static str, VAppIpAssignmentInfoIpAllocationPolicyEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("fixedPolicy", VAppIpAssignmentInfoIpAllocationPolicyEnum::FixedPolicy),
        ("transientPolicy", VAppIpAssignmentInfoIpAllocationPolicyEnum::TransientPolicy),
        ("dhcpPolicy", VAppIpAssignmentInfoIpAllocationPolicyEnum::DhcpPolicy),
        ("fixedAllocatedPolicy", VAppIpAssignmentInfoIpAllocationPolicyEnum::FixedAllocatedPolicy),
    ],
};

impl VAppIpAssignmentInfoIpAllocationPolicyEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VAppIpAssignmentInfoIpAllocationPolicyEnum::DhcpPolicy => "dhcpPolicy",
            VAppIpAssignmentInfoIpAllocationPolicyEnum::TransientPolicy => "transientPolicy",
            VAppIpAssignmentInfoIpAllocationPolicyEnum::FixedPolicy => "fixedPolicy",
            VAppIpAssignmentInfoIpAllocationPolicyEnum::FixedAllocatedPolicy => "fixedAllocatedPolicy",
            VAppIpAssignmentInfoIpAllocationPolicyEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        V_APP_IP_ASSIGNMENT_INFO_IP_ALLOCATION_POLICY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VAppIpAssignmentInfoIpAllocationPolicyEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VAppIpAssignmentInfoIpAllocationPolicyEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VAppIpAssignmentInfoIpAllocationPolicyEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VAppIpAssignmentInfoIpAllocationPolicyEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VAppIpAssignmentInfoIpAllocationPolicyEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VAppIpAssignmentInfoIpAllocationPolicyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VAppIpAssignmentInfoIpAllocationPolicyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VAppIpAssignmentInfoIpAllocationPolicyEnum> for &'a str {
    fn from(value: &'a VAppIpAssignmentInfoIpAllocationPolicyEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VAppIpAssignmentInfoIpAllocationPolicyEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static V_APP_IP_ASSIGNMENT_INFO_PROTOCOLS_ENUM_MAP: phf::Map<&'static str, VAppIpAssignmentInfoProtocolsEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("IPv6", VAppIpAssignmentInfoProtocolsEnum::IPv6),
        ("IPv4", VAppIpAssignmentInfoProtocolsEnum::IPv4),
    ],
};

impl VAppIpAssignmentInfoProtocolsEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VAppIpAssignmentInfoProtocolsEnum::IPv4 => "IPv4",
            VAppIpAssignmentInfoProtocolsEnum::IPv6 => "IPv6",
            VAppIpAssignmentInfoProtocolsEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        V_APP_IP_ASSIGNMENT_INFO_PROTOCOLS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VAppIpAssignmentInfoProtocolsEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VAppIpAssignmentInfoProtocolsEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VAppIpAssignmentInfoProtocolsEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VAppIpAssignmentInfoProtocolsEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VAppIpAssignmentInfoProtocolsEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VAppIpAssignmentInfoProtocolsEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VAppIpAssignmentInfoProtocolsEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VAppIpAssignmentInfoProtocolsEnum> for &'a str {
    fn from(value: &'a VAppIpAssignmentInfoProtocolsEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VAppIpAssignmentInfoProtocolsEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VCHA_STATE_ENUM_MAP: phf::Map<&'static str, VchaStateEnum> = ::phf::Map {
    key: 2126027241312876569,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("notConfigured", VchaStateEnum::NotConfigured),
        ("prepared", VchaStateEnum::Prepared),
        ("configured", VchaStateEnum::Configured),
        ("invalid", VchaStateEnum::Invalid),
    ],
};

impl VchaStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VchaStateEnum::Configured => "configured",
            VchaStateEnum::NotConfigured => "notConfigured",
            VchaStateEnum::Invalid => "invalid",
            VchaStateEnum::Prepared => "prepared",
            VchaStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VCHA_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VchaStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VchaStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VchaStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VchaStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VchaStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VchaStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VchaStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VchaStateEnum> for &'a str {
    fn from(value: &'a VchaStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VchaStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VCHA_CLUSTER_MODE_ENUM_MAP: phf::Map<&'static str, VchaClusterModeEnum> = ::phf::Map {
    key: 8694567506910003252,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("maintenance", VchaClusterModeEnum::Maintenance),
        ("disabled", VchaClusterModeEnum::Disabled),
        ("enabled", VchaClusterModeEnum::Enabled),
    ],
};

impl VchaClusterModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VchaClusterModeEnum::Enabled => "enabled",
            VchaClusterModeEnum::Disabled => "disabled",
            VchaClusterModeEnum::Maintenance => "maintenance",
            VchaClusterModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VCHA_CLUSTER_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VchaClusterModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VchaClusterModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VchaClusterModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VchaClusterModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VchaClusterModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VchaClusterModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VchaClusterModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VchaClusterModeEnum> for &'a str {
    fn from(value: &'a VchaClusterModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VchaClusterModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VCHA_CLUSTER_STATE_ENUM_MAP: phf::Map<&'static str, VchaClusterStateEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("healthy", VchaClusterStateEnum::Healthy),
        ("degraded", VchaClusterStateEnum::Degraded),
        ("isolated", VchaClusterStateEnum::Isolated),
    ],
};

impl VchaClusterStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VchaClusterStateEnum::Healthy => "healthy",
            VchaClusterStateEnum::Degraded => "degraded",
            VchaClusterStateEnum::Isolated => "isolated",
            VchaClusterStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VCHA_CLUSTER_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VchaClusterStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VchaClusterStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VchaClusterStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VchaClusterStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VchaClusterStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VchaClusterStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VchaClusterStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VchaClusterStateEnum> for &'a str {
    fn from(value: &'a VchaClusterStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VchaClusterStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VCHA_NODE_ROLE_ENUM_MAP: phf::Map<&'static str, VchaNodeRoleEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("active", VchaNodeRoleEnum::Active),
        ("passive", VchaNodeRoleEnum::Passive),
        ("witness", VchaNodeRoleEnum::Witness),
    ],
};

impl VchaNodeRoleEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VchaNodeRoleEnum::Active => "active",
            VchaNodeRoleEnum::Passive => "passive",
            VchaNodeRoleEnum::Witness => "witness",
            VchaNodeRoleEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VCHA_NODE_ROLE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VchaNodeRoleEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VchaNodeRoleEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VchaNodeRoleEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VchaNodeRoleEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VchaNodeRoleEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VchaNodeRoleEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VchaNodeRoleEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VchaNodeRoleEnum> for &'a str {
    fn from(value: &'a VchaNodeRoleEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VchaNodeRoleEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VCHA_NODE_STATE_ENUM_MAP: phf::Map<&'static str, VchaNodeStateEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("up", VchaNodeStateEnum::Up),
        ("down", VchaNodeStateEnum::Down),
    ],
};

impl VchaNodeStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VchaNodeStateEnum::Up => "up",
            VchaNodeStateEnum::Down => "down",
            VchaNodeStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VCHA_NODE_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VchaNodeStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VchaNodeStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VchaNodeStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VchaNodeStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VchaNodeStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VchaNodeStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VchaNodeStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VchaNodeStateEnum> for &'a str {
    fn from(value: &'a VchaNodeStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VchaNodeStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_BOOT_OPTIONS_NETWORK_BOOT_PROTOCOL_TYPE_ENUM_MAP: phf::Map<&'static str, VirtualMachineBootOptionsNetworkBootProtocolTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("ipv4", VirtualMachineBootOptionsNetworkBootProtocolTypeEnum::Ipv4),
        ("ipv6", VirtualMachineBootOptionsNetworkBootProtocolTypeEnum::Ipv6),
    ],
};

impl VirtualMachineBootOptionsNetworkBootProtocolTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineBootOptionsNetworkBootProtocolTypeEnum::Ipv4 => "ipv4",
            VirtualMachineBootOptionsNetworkBootProtocolTypeEnum::Ipv6 => "ipv6",
            VirtualMachineBootOptionsNetworkBootProtocolTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_BOOT_OPTIONS_NETWORK_BOOT_PROTOCOL_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineBootOptionsNetworkBootProtocolTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineBootOptionsNetworkBootProtocolTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineBootOptionsNetworkBootProtocolTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineBootOptionsNetworkBootProtocolTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineBootOptionsNetworkBootProtocolTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineBootOptionsNetworkBootProtocolTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineBootOptionsNetworkBootProtocolTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineBootOptionsNetworkBootProtocolTypeEnum> for &'a str {
    fn from(value: &'a VirtualMachineBootOptionsNetworkBootProtocolTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineBootOptionsNetworkBootProtocolTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_CERT_THUMBPRINT_HASH_ALGORITHM_ENUM_MAP: phf::Map<&'static str, VirtualMachineCertThumbprintHashAlgorithmEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("sha256", VirtualMachineCertThumbprintHashAlgorithmEnum::Sha256),
    ],
};

impl VirtualMachineCertThumbprintHashAlgorithmEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineCertThumbprintHashAlgorithmEnum::Sha256 => "sha256",
            VirtualMachineCertThumbprintHashAlgorithmEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_CERT_THUMBPRINT_HASH_ALGORITHM_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineCertThumbprintHashAlgorithmEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineCertThumbprintHashAlgorithmEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineCertThumbprintHashAlgorithmEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineCertThumbprintHashAlgorithmEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineCertThumbprintHashAlgorithmEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineCertThumbprintHashAlgorithmEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineCertThumbprintHashAlgorithmEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineCertThumbprintHashAlgorithmEnum> for &'a str {
    fn from(value: &'a VirtualMachineCertThumbprintHashAlgorithmEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineCertThumbprintHashAlgorithmEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_CLONE_SPEC_TPM_PROVISION_POLICY_ENUM_MAP: phf::Map<&'static str, VirtualMachineCloneSpecTpmProvisionPolicyEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("copy", VirtualMachineCloneSpecTpmProvisionPolicyEnum::Copy),
        ("replace", VirtualMachineCloneSpecTpmProvisionPolicyEnum::Replace),
    ],
};

impl VirtualMachineCloneSpecTpmProvisionPolicyEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineCloneSpecTpmProvisionPolicyEnum::Copy => "copy",
            VirtualMachineCloneSpecTpmProvisionPolicyEnum::Replace => "replace",
            VirtualMachineCloneSpecTpmProvisionPolicyEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_CLONE_SPEC_TPM_PROVISION_POLICY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineCloneSpecTpmProvisionPolicyEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineCloneSpecTpmProvisionPolicyEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineCloneSpecTpmProvisionPolicyEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineCloneSpecTpmProvisionPolicyEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineCloneSpecTpmProvisionPolicyEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineCloneSpecTpmProvisionPolicyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineCloneSpecTpmProvisionPolicyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineCloneSpecTpmProvisionPolicyEnum> for &'a str {
    fn from(value: &'a VirtualMachineCloneSpecTpmProvisionPolicyEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineCloneSpecTpmProvisionPolicyEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_CONFIG_INFO_NPIV_WWN_TYPE_ENUM_MAP: phf::Map<&'static str, VirtualMachineConfigInfoNpivWwnTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("external", VirtualMachineConfigInfoNpivWwnTypeEnum::External),
        ("host", VirtualMachineConfigInfoNpivWwnTypeEnum::Host),
        ("vc", VirtualMachineConfigInfoNpivWwnTypeEnum::Vc),
    ],
};

impl VirtualMachineConfigInfoNpivWwnTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineConfigInfoNpivWwnTypeEnum::Vc => "vc",
            VirtualMachineConfigInfoNpivWwnTypeEnum::Host => "host",
            VirtualMachineConfigInfoNpivWwnTypeEnum::External => "external",
            VirtualMachineConfigInfoNpivWwnTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_CONFIG_INFO_NPIV_WWN_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineConfigInfoNpivWwnTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineConfigInfoNpivWwnTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineConfigInfoNpivWwnTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineConfigInfoNpivWwnTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineConfigInfoNpivWwnTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineConfigInfoNpivWwnTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineConfigInfoNpivWwnTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineConfigInfoNpivWwnTypeEnum> for &'a str {
    fn from(value: &'a VirtualMachineConfigInfoNpivWwnTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineConfigInfoNpivWwnTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_CONFIG_INFO_SWAP_PLACEMENT_TYPE_ENUM_MAP: phf::Map<&'static str, VirtualMachineConfigInfoSwapPlacementTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("inherit", VirtualMachineConfigInfoSwapPlacementTypeEnum::Inherit),
        ("vmDirectory", VirtualMachineConfigInfoSwapPlacementTypeEnum::VmDirectory),
        ("hostLocal", VirtualMachineConfigInfoSwapPlacementTypeEnum::HostLocal),
    ],
};

impl VirtualMachineConfigInfoSwapPlacementTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineConfigInfoSwapPlacementTypeEnum::Inherit => "inherit",
            VirtualMachineConfigInfoSwapPlacementTypeEnum::VmDirectory => "vmDirectory",
            VirtualMachineConfigInfoSwapPlacementTypeEnum::HostLocal => "hostLocal",
            VirtualMachineConfigInfoSwapPlacementTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_CONFIG_INFO_SWAP_PLACEMENT_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineConfigInfoSwapPlacementTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineConfigInfoSwapPlacementTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineConfigInfoSwapPlacementTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineConfigInfoSwapPlacementTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineConfigInfoSwapPlacementTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineConfigInfoSwapPlacementTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineConfigInfoSwapPlacementTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineConfigInfoSwapPlacementTypeEnum> for &'a str {
    fn from(value: &'a VirtualMachineConfigInfoSwapPlacementTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineConfigInfoSwapPlacementTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_CONFIG_SPEC_ENCRYPTED_FT_MODES_ENUM_MAP: phf::Map<&'static str, VirtualMachineConfigSpecEncryptedFtModesEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("ftEncryptionDisabled", VirtualMachineConfigSpecEncryptedFtModesEnum::FtEncryptionDisabled),
        ("ftEncryptionRequired", VirtualMachineConfigSpecEncryptedFtModesEnum::FtEncryptionRequired),
        ("ftEncryptionOpportunistic", VirtualMachineConfigSpecEncryptedFtModesEnum::FtEncryptionOpportunistic),
    ],
};

impl VirtualMachineConfigSpecEncryptedFtModesEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineConfigSpecEncryptedFtModesEnum::FtEncryptionDisabled => "ftEncryptionDisabled",
            VirtualMachineConfigSpecEncryptedFtModesEnum::FtEncryptionOpportunistic => "ftEncryptionOpportunistic",
            VirtualMachineConfigSpecEncryptedFtModesEnum::FtEncryptionRequired => "ftEncryptionRequired",
            VirtualMachineConfigSpecEncryptedFtModesEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_CONFIG_SPEC_ENCRYPTED_FT_MODES_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineConfigSpecEncryptedFtModesEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineConfigSpecEncryptedFtModesEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineConfigSpecEncryptedFtModesEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineConfigSpecEncryptedFtModesEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineConfigSpecEncryptedFtModesEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineConfigSpecEncryptedFtModesEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineConfigSpecEncryptedFtModesEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineConfigSpecEncryptedFtModesEnum> for &'a str {
    fn from(value: &'a VirtualMachineConfigSpecEncryptedFtModesEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineConfigSpecEncryptedFtModesEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_CONFIG_SPEC_ENCRYPTED_V_MOTION_MODES_ENUM_MAP: phf::Map<&'static str, VirtualMachineConfigSpecEncryptedVMotionModesEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("disabled", VirtualMachineConfigSpecEncryptedVMotionModesEnum::Disabled),
        ("opportunistic", VirtualMachineConfigSpecEncryptedVMotionModesEnum::Opportunistic),
        ("required", VirtualMachineConfigSpecEncryptedVMotionModesEnum::Required),
    ],
};

impl VirtualMachineConfigSpecEncryptedVMotionModesEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineConfigSpecEncryptedVMotionModesEnum::Disabled => "disabled",
            VirtualMachineConfigSpecEncryptedVMotionModesEnum::Opportunistic => "opportunistic",
            VirtualMachineConfigSpecEncryptedVMotionModesEnum::Required => "required",
            VirtualMachineConfigSpecEncryptedVMotionModesEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_CONFIG_SPEC_ENCRYPTED_V_MOTION_MODES_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineConfigSpecEncryptedVMotionModesEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineConfigSpecEncryptedVMotionModesEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineConfigSpecEncryptedVMotionModesEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineConfigSpecEncryptedVMotionModesEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineConfigSpecEncryptedVMotionModesEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineConfigSpecEncryptedVMotionModesEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineConfigSpecEncryptedVMotionModesEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineConfigSpecEncryptedVMotionModesEnum> for &'a str {
    fn from(value: &'a VirtualMachineConfigSpecEncryptedVMotionModesEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineConfigSpecEncryptedVMotionModesEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_CONFIG_SPEC_NPIV_WWN_OP_ENUM_MAP: phf::Map<&'static str, VirtualMachineConfigSpecNpivWwnOpEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (3, 0),
    ],
    entries: &[
        ("set", VirtualMachineConfigSpecNpivWwnOpEnum::Set),
        ("remove", VirtualMachineConfigSpecNpivWwnOpEnum::Remove),
        ("generate", VirtualMachineConfigSpecNpivWwnOpEnum::Generate),
        ("extend", VirtualMachineConfigSpecNpivWwnOpEnum::Extend),
    ],
};

impl VirtualMachineConfigSpecNpivWwnOpEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineConfigSpecNpivWwnOpEnum::Generate => "generate",
            VirtualMachineConfigSpecNpivWwnOpEnum::Set => "set",
            VirtualMachineConfigSpecNpivWwnOpEnum::Remove => "remove",
            VirtualMachineConfigSpecNpivWwnOpEnum::Extend => "extend",
            VirtualMachineConfigSpecNpivWwnOpEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_CONFIG_SPEC_NPIV_WWN_OP_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineConfigSpecNpivWwnOpEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineConfigSpecNpivWwnOpEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineConfigSpecNpivWwnOpEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineConfigSpecNpivWwnOpEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineConfigSpecNpivWwnOpEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineConfigSpecNpivWwnOpEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineConfigSpecNpivWwnOpEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineConfigSpecNpivWwnOpEnum> for &'a str {
    fn from(value: &'a VirtualMachineConfigSpecNpivWwnOpEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineConfigSpecNpivWwnOpEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_POWER_OP_TYPE_ENUM_MAP: phf::Map<&'static str, VirtualMachinePowerOpTypeEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("hard", VirtualMachinePowerOpTypeEnum::Hard),
        ("soft", VirtualMachinePowerOpTypeEnum::Soft),
        ("preset", VirtualMachinePowerOpTypeEnum::Preset),
    ],
};

impl VirtualMachinePowerOpTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachinePowerOpTypeEnum::Soft => "soft",
            VirtualMachinePowerOpTypeEnum::Hard => "hard",
            VirtualMachinePowerOpTypeEnum::Preset => "preset",
            VirtualMachinePowerOpTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_POWER_OP_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachinePowerOpTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachinePowerOpTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachinePowerOpTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachinePowerOpTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachinePowerOpTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachinePowerOpTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachinePowerOpTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachinePowerOpTypeEnum> for &'a str {
    fn from(value: &'a VirtualMachinePowerOpTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachinePowerOpTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_STANDBY_ACTION_TYPE_ENUM_MAP: phf::Map<&'static str, VirtualMachineStandbyActionTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("checkpoint", VirtualMachineStandbyActionTypeEnum::Checkpoint),
        ("powerOnSuspend", VirtualMachineStandbyActionTypeEnum::PowerOnSuspend),
    ],
};

impl VirtualMachineStandbyActionTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineStandbyActionTypeEnum::Checkpoint => "checkpoint",
            VirtualMachineStandbyActionTypeEnum::PowerOnSuspend => "powerOnSuspend",
            VirtualMachineStandbyActionTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_STANDBY_ACTION_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineStandbyActionTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineStandbyActionTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineStandbyActionTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineStandbyActionTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineStandbyActionTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineStandbyActionTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineStandbyActionTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineStandbyActionTypeEnum> for &'a str {
    fn from(value: &'a VirtualMachineStandbyActionTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineStandbyActionTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_DEVICE_RUNTIME_INFO_VIRTUAL_ETHERNET_CARD_RUNTIME_STATE_VM_DIRECT_PATH_GEN_2_INACTIVE_REASON_OTHER_ENUM_MAP: phf::Map<&'static str, VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOtherEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("vmNptIncompatibleHost", VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOtherEnum::VmNptIncompatibleHost),
        ("vmNptIncompatibleNetwork", VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOtherEnum::VmNptIncompatibleNetwork),
    ],
};

impl VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOtherEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOtherEnum::VmNptIncompatibleHost => "vmNptIncompatibleHost",
            VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOtherEnum::VmNptIncompatibleNetwork => "vmNptIncompatibleNetwork",
            VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOtherEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_DEVICE_RUNTIME_INFO_VIRTUAL_ETHERNET_CARD_RUNTIME_STATE_VM_DIRECT_PATH_GEN_2_INACTIVE_REASON_OTHER_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOtherEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOtherEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOtherEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOtherEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOtherEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOtherEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOtherEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOtherEnum> for &'a str {
    fn from(value: &'a VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOtherEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOtherEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_DEVICE_RUNTIME_INFO_VIRTUAL_ETHERNET_CARD_RUNTIME_STATE_VM_DIRECT_PATH_GEN_2_INACTIVE_REASON_VM_ENUM_MAP: phf::Map<&'static str, VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 13),
        (6, 10),
        (2, 0),
    ],
    entries: &[
        ("vmNptInsufficientMemoryReservation", VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::VmNptInsufficientMemoryReservation),
        ("vmNptIncompatibleBackingType", VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::VmNptIncompatibleBackingType),
        ("vmNptOutOfIntrVector", VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::VmNptOutOfIntrVector),
        ("vmNptConflictingOperationInProgress", VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::VmNptConflictingOperationInProgress),
        ("vmNptIncompatibleAdapterType", VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::VmNptIncompatibleAdapterType),
        ("vmNptMonitorBlocks", VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::VmNptMonitorBlocks),
        ("vmNptFaultToleranceOrRecordReplayConfigured", VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::VmNptFaultToleranceOrRecordReplayConfigured),
        ("vmNptIncompatibleAdapterFeatures", VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::VmNptIncompatibleAdapterFeatures),
        ("vmNptDisabledOrDisconnectedAdapter", VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::VmNptDisabledOrDisconnectedAdapter),
        ("vmNptIncompatibleGuestDriver", VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::VmNptIncompatibleGuestDriver),
        ("vmNptIncompatibleGuest", VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::VmNptIncompatibleGuest),
        ("vmNptConflictingIOChainConfigured", VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::VmNptConflictingIoChainConfigured),
        ("vmNptVMCIActive", VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::VmNptVmciActive),
        ("vmNptRuntimeError", VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::VmNptRuntimeError),
    ],
};

impl VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::VmNptIncompatibleGuest => "vmNptIncompatibleGuest",
            VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::VmNptIncompatibleGuestDriver => "vmNptIncompatibleGuestDriver",
            VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::VmNptIncompatibleAdapterType => "vmNptIncompatibleAdapterType",
            VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::VmNptDisabledOrDisconnectedAdapter => "vmNptDisabledOrDisconnectedAdapter",
            VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::VmNptIncompatibleAdapterFeatures => "vmNptIncompatibleAdapterFeatures",
            VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::VmNptIncompatibleBackingType => "vmNptIncompatibleBackingType",
            VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::VmNptInsufficientMemoryReservation => "vmNptInsufficientMemoryReservation",
            VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::VmNptFaultToleranceOrRecordReplayConfigured => "vmNptFaultToleranceOrRecordReplayConfigured",
            VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::VmNptConflictingIoChainConfigured => "vmNptConflictingIOChainConfigured",
            VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::VmNptMonitorBlocks => "vmNptMonitorBlocks",
            VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::VmNptConflictingOperationInProgress => "vmNptConflictingOperationInProgress",
            VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::VmNptRuntimeError => "vmNptRuntimeError",
            VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::VmNptOutOfIntrVector => "vmNptOutOfIntrVector",
            VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::VmNptVmciActive => "vmNptVMCIActive",
            VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_DEVICE_RUNTIME_INFO_VIRTUAL_ETHERNET_CARD_RUNTIME_STATE_VM_DIRECT_PATH_GEN_2_INACTIVE_REASON_VM_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum> for &'a str {
    fn from(value: &'a VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_FILE_LAYOUT_EX_FILE_TYPE_ENUM_MAP: phf::Map<&'static str, VirtualMachineFileLayoutExFileTypeEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (0, 0),
        (5, 17),
        (11, 5),
        (1, 19),
        (6, 10),
    ],
    entries: &[
        ("dataSetsDiskModeStore", VirtualMachineFileLayoutExFileTypeEnum::DataSetsDiskModeStore),
        ("diskExtent", VirtualMachineFileLayoutExFileTypeEnum::DiskExtent),
        ("uwswap", VirtualMachineFileLayoutExFileTypeEnum::Uwswap),
        ("diskReplicationState", VirtualMachineFileLayoutExFileTypeEnum::DiskReplicationState),
        ("swap", VirtualMachineFileLayoutExFileTypeEnum::Swap),
        ("snapshotManifestList", VirtualMachineFileLayoutExFileTypeEnum::SnapshotManifestList),
        ("snapshotData", VirtualMachineFileLayoutExFileTypeEnum::SnapshotData),
        ("snapshotMemory", VirtualMachineFileLayoutExFileTypeEnum::SnapshotMemory),
        ("extendedConfig", VirtualMachineFileLayoutExFileTypeEnum::ExtendedConfig),
        ("log", VirtualMachineFileLayoutExFileTypeEnum::Log),
        ("nvram", VirtualMachineFileLayoutExFileTypeEnum::Nvram),
        ("diskDescriptor", VirtualMachineFileLayoutExFileTypeEnum::DiskDescriptor),
        ("namespaceData", VirtualMachineFileLayoutExFileTypeEnum::NamespaceData),
        ("digestDescriptor", VirtualMachineFileLayoutExFileTypeEnum::DigestDescriptor),
        ("screenshot", VirtualMachineFileLayoutExFileTypeEnum::Screenshot),
        ("digestExtent", VirtualMachineFileLayoutExFileTypeEnum::DigestExtent),
        ("core", VirtualMachineFileLayoutExFileTypeEnum::Core),
        ("config", VirtualMachineFileLayoutExFileTypeEnum::Config),
        ("dataSetsVmModeStore", VirtualMachineFileLayoutExFileTypeEnum::DataSetsVmModeStore),
        ("suspendMemory", VirtualMachineFileLayoutExFileTypeEnum::SuspendMemory),
        ("stat", VirtualMachineFileLayoutExFileTypeEnum::Stat),
        ("ftMetadata", VirtualMachineFileLayoutExFileTypeEnum::FtMetadata),
        ("snapshotList", VirtualMachineFileLayoutExFileTypeEnum::SnapshotList),
        ("suspend", VirtualMachineFileLayoutExFileTypeEnum::Suspend),
        ("guestCustomization", VirtualMachineFileLayoutExFileTypeEnum::GuestCustomization),
    ],
};

impl VirtualMachineFileLayoutExFileTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineFileLayoutExFileTypeEnum::Config => "config",
            VirtualMachineFileLayoutExFileTypeEnum::ExtendedConfig => "extendedConfig",
            VirtualMachineFileLayoutExFileTypeEnum::DiskDescriptor => "diskDescriptor",
            VirtualMachineFileLayoutExFileTypeEnum::DiskExtent => "diskExtent",
            VirtualMachineFileLayoutExFileTypeEnum::DigestDescriptor => "digestDescriptor",
            VirtualMachineFileLayoutExFileTypeEnum::DigestExtent => "digestExtent",
            VirtualMachineFileLayoutExFileTypeEnum::DiskReplicationState => "diskReplicationState",
            VirtualMachineFileLayoutExFileTypeEnum::Log => "log",
            VirtualMachineFileLayoutExFileTypeEnum::Stat => "stat",
            VirtualMachineFileLayoutExFileTypeEnum::NamespaceData => "namespaceData",
            VirtualMachineFileLayoutExFileTypeEnum::DataSetsDiskModeStore => "dataSetsDiskModeStore",
            VirtualMachineFileLayoutExFileTypeEnum::DataSetsVmModeStore => "dataSetsVmModeStore",
            VirtualMachineFileLayoutExFileTypeEnum::Nvram => "nvram",
            VirtualMachineFileLayoutExFileTypeEnum::SnapshotData => "snapshotData",
            VirtualMachineFileLayoutExFileTypeEnum::SnapshotMemory => "snapshotMemory",
            VirtualMachineFileLayoutExFileTypeEnum::SnapshotList => "snapshotList",
            VirtualMachineFileLayoutExFileTypeEnum::SnapshotManifestList => "snapshotManifestList",
            VirtualMachineFileLayoutExFileTypeEnum::Suspend => "suspend",
            VirtualMachineFileLayoutExFileTypeEnum::SuspendMemory => "suspendMemory",
            VirtualMachineFileLayoutExFileTypeEnum::Swap => "swap",
            VirtualMachineFileLayoutExFileTypeEnum::Uwswap => "uwswap",
            VirtualMachineFileLayoutExFileTypeEnum::Core => "core",
            VirtualMachineFileLayoutExFileTypeEnum::Screenshot => "screenshot",
            VirtualMachineFileLayoutExFileTypeEnum::FtMetadata => "ftMetadata",
            VirtualMachineFileLayoutExFileTypeEnum::GuestCustomization => "guestCustomization",
            VirtualMachineFileLayoutExFileTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_FILE_LAYOUT_EX_FILE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineFileLayoutExFileTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineFileLayoutExFileTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineFileLayoutExFileTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineFileLayoutExFileTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineFileLayoutExFileTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineFileLayoutExFileTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineFileLayoutExFileTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineFileLayoutExFileTypeEnum> for &'a str {
    fn from(value: &'a VirtualMachineFileLayoutExFileTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineFileLayoutExFileTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_HT_SHARING_ENUM_MAP: phf::Map<&'static str, VirtualMachineHtSharingEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("internal", VirtualMachineHtSharingEnum::Internal),
        ("none", VirtualMachineHtSharingEnum::None),
        ("any", VirtualMachineHtSharingEnum::Any),
    ],
};

impl VirtualMachineHtSharingEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineHtSharingEnum::Any => "any",
            VirtualMachineHtSharingEnum::None => "none",
            VirtualMachineHtSharingEnum::Internal => "internal",
            VirtualMachineHtSharingEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_HT_SHARING_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineHtSharingEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineHtSharingEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineHtSharingEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineHtSharingEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineHtSharingEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineHtSharingEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineHtSharingEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineHtSharingEnum> for &'a str {
    fn from(value: &'a VirtualMachineHtSharingEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineHtSharingEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_FLAG_INFO_MONITOR_TYPE_ENUM_MAP: phf::Map<&'static str, VirtualMachineFlagInfoMonitorTypeEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("debug", VirtualMachineFlagInfoMonitorTypeEnum::Debug),
        ("stats", VirtualMachineFlagInfoMonitorTypeEnum::Stats),
        ("release", VirtualMachineFlagInfoMonitorTypeEnum::Release),
    ],
};

impl VirtualMachineFlagInfoMonitorTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineFlagInfoMonitorTypeEnum::Release => "release",
            VirtualMachineFlagInfoMonitorTypeEnum::Debug => "debug",
            VirtualMachineFlagInfoMonitorTypeEnum::Stats => "stats",
            VirtualMachineFlagInfoMonitorTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_FLAG_INFO_MONITOR_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineFlagInfoMonitorTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineFlagInfoMonitorTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineFlagInfoMonitorTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineFlagInfoMonitorTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineFlagInfoMonitorTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineFlagInfoMonitorTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineFlagInfoMonitorTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineFlagInfoMonitorTypeEnum> for &'a str {
    fn from(value: &'a VirtualMachineFlagInfoMonitorTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineFlagInfoMonitorTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_POWER_OFF_BEHAVIOR_ENUM_MAP: phf::Map<&'static str, VirtualMachinePowerOffBehaviorEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (3, 0),
    ],
    entries: &[
        ("prompt", VirtualMachinePowerOffBehaviorEnum::Prompt),
        ("take", VirtualMachinePowerOffBehaviorEnum::Take),
        ("powerOff", VirtualMachinePowerOffBehaviorEnum::PowerOff),
        ("revert", VirtualMachinePowerOffBehaviorEnum::Revert),
    ],
};

impl VirtualMachinePowerOffBehaviorEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachinePowerOffBehaviorEnum::PowerOff => "powerOff",
            VirtualMachinePowerOffBehaviorEnum::Revert => "revert",
            VirtualMachinePowerOffBehaviorEnum::Prompt => "prompt",
            VirtualMachinePowerOffBehaviorEnum::Take => "take",
            VirtualMachinePowerOffBehaviorEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_POWER_OFF_BEHAVIOR_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachinePowerOffBehaviorEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachinePowerOffBehaviorEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachinePowerOffBehaviorEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachinePowerOffBehaviorEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachinePowerOffBehaviorEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachinePowerOffBehaviorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachinePowerOffBehaviorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachinePowerOffBehaviorEnum> for &'a str {
    fn from(value: &'a VirtualMachinePowerOffBehaviorEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachinePowerOffBehaviorEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_FLAG_INFO_VIRTUAL_EXEC_USAGE_ENUM_MAP: phf::Map<&'static str, VirtualMachineFlagInfoVirtualExecUsageEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("hvOff", VirtualMachineFlagInfoVirtualExecUsageEnum::HvOff),
        ("hvAuto", VirtualMachineFlagInfoVirtualExecUsageEnum::HvAuto),
        ("hvOn", VirtualMachineFlagInfoVirtualExecUsageEnum::HvOn),
    ],
};

impl VirtualMachineFlagInfoVirtualExecUsageEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineFlagInfoVirtualExecUsageEnum::HvAuto => "hvAuto",
            VirtualMachineFlagInfoVirtualExecUsageEnum::HvOn => "hvOn",
            VirtualMachineFlagInfoVirtualExecUsageEnum::HvOff => "hvOff",
            VirtualMachineFlagInfoVirtualExecUsageEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_FLAG_INFO_VIRTUAL_EXEC_USAGE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineFlagInfoVirtualExecUsageEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineFlagInfoVirtualExecUsageEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineFlagInfoVirtualExecUsageEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineFlagInfoVirtualExecUsageEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineFlagInfoVirtualExecUsageEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineFlagInfoVirtualExecUsageEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineFlagInfoVirtualExecUsageEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineFlagInfoVirtualExecUsageEnum> for &'a str {
    fn from(value: &'a VirtualMachineFlagInfoVirtualExecUsageEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineFlagInfoVirtualExecUsageEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_FLAG_INFO_VIRTUAL_MMU_USAGE_ENUM_MAP: phf::Map<&'static str, VirtualMachineFlagInfoVirtualMmuUsageEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("automatic", VirtualMachineFlagInfoVirtualMmuUsageEnum::Automatic),
        ("off", VirtualMachineFlagInfoVirtualMmuUsageEnum::Off),
        ("on", VirtualMachineFlagInfoVirtualMmuUsageEnum::On),
    ],
};

impl VirtualMachineFlagInfoVirtualMmuUsageEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineFlagInfoVirtualMmuUsageEnum::Automatic => "automatic",
            VirtualMachineFlagInfoVirtualMmuUsageEnum::On => "on",
            VirtualMachineFlagInfoVirtualMmuUsageEnum::Off => "off",
            VirtualMachineFlagInfoVirtualMmuUsageEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_FLAG_INFO_VIRTUAL_MMU_USAGE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineFlagInfoVirtualMmuUsageEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineFlagInfoVirtualMmuUsageEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineFlagInfoVirtualMmuUsageEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineFlagInfoVirtualMmuUsageEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineFlagInfoVirtualMmuUsageEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineFlagInfoVirtualMmuUsageEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineFlagInfoVirtualMmuUsageEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineFlagInfoVirtualMmuUsageEnum> for &'a str {
    fn from(value: &'a VirtualMachineFlagInfoVirtualMmuUsageEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineFlagInfoVirtualMmuUsageEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_FORK_CONFIG_INFO_CHILD_TYPE_ENUM_MAP: phf::Map<&'static str, VirtualMachineForkConfigInfoChildTypeEnum> = ::phf::Map {
    key: 14108922650502679131,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("none", VirtualMachineForkConfigInfoChildTypeEnum::None),
        ("persistent", VirtualMachineForkConfigInfoChildTypeEnum::Persistent),
        ("nonpersistent", VirtualMachineForkConfigInfoChildTypeEnum::Nonpersistent),
    ],
};

impl VirtualMachineForkConfigInfoChildTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineForkConfigInfoChildTypeEnum::None => "none",
            VirtualMachineForkConfigInfoChildTypeEnum::Persistent => "persistent",
            VirtualMachineForkConfigInfoChildTypeEnum::Nonpersistent => "nonpersistent",
            VirtualMachineForkConfigInfoChildTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_FORK_CONFIG_INFO_CHILD_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineForkConfigInfoChildTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineForkConfigInfoChildTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineForkConfigInfoChildTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineForkConfigInfoChildTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineForkConfigInfoChildTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineForkConfigInfoChildTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineForkConfigInfoChildTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineForkConfigInfoChildTypeEnum> for &'a str {
    fn from(value: &'a VirtualMachineForkConfigInfoChildTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineForkConfigInfoChildTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static GUEST_INFO_APP_STATE_TYPE_ENUM_MAP: phf::Map<&'static str, GuestInfoAppStateTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("appStateOk", GuestInfoAppStateTypeEnum::AppStateOk),
        ("appStateNeedReset", GuestInfoAppStateTypeEnum::AppStateNeedReset),
        ("none", GuestInfoAppStateTypeEnum::None),
    ],
};

impl GuestInfoAppStateTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            GuestInfoAppStateTypeEnum::None => "none",
            GuestInfoAppStateTypeEnum::AppStateOk => "appStateOk",
            GuestInfoAppStateTypeEnum::AppStateNeedReset => "appStateNeedReset",
            GuestInfoAppStateTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        GUEST_INFO_APP_STATE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| GuestInfoAppStateTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for GuestInfoAppStateTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for GuestInfoAppStateTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<GuestInfoAppStateTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(GuestInfoAppStateTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for GuestInfoAppStateTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for GuestInfoAppStateTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a GuestInfoAppStateTypeEnum> for &'a str {
    fn from(value: &'a GuestInfoAppStateTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for GuestInfoAppStateTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static GUEST_INFO_CUSTOMIZATION_STATUS_ENUM_MAP: phf::Map<&'static str, GuestInfoCustomizationStatusEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("TOOLSDEPLOYPKG_RUNNING", GuestInfoCustomizationStatusEnum::ToolsdeploypkgRunning),
        ("TOOLSDEPLOYPKG_PENDING", GuestInfoCustomizationStatusEnum::ToolsdeploypkgPending),
        ("TOOLSDEPLOYPKG_IDLE", GuestInfoCustomizationStatusEnum::ToolsdeploypkgIdle),
        ("TOOLSDEPLOYPKG_FAILED", GuestInfoCustomizationStatusEnum::ToolsdeploypkgFailed),
        ("TOOLSDEPLOYPKG_SUCCEEDED", GuestInfoCustomizationStatusEnum::ToolsdeploypkgSucceeded),
    ],
};

impl GuestInfoCustomizationStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            GuestInfoCustomizationStatusEnum::ToolsdeploypkgIdle => "TOOLSDEPLOYPKG_IDLE",
            GuestInfoCustomizationStatusEnum::ToolsdeploypkgPending => "TOOLSDEPLOYPKG_PENDING",
            GuestInfoCustomizationStatusEnum::ToolsdeploypkgRunning => "TOOLSDEPLOYPKG_RUNNING",
            GuestInfoCustomizationStatusEnum::ToolsdeploypkgSucceeded => "TOOLSDEPLOYPKG_SUCCEEDED",
            GuestInfoCustomizationStatusEnum::ToolsdeploypkgFailed => "TOOLSDEPLOYPKG_FAILED",
            GuestInfoCustomizationStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        GUEST_INFO_CUSTOMIZATION_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| GuestInfoCustomizationStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for GuestInfoCustomizationStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for GuestInfoCustomizationStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<GuestInfoCustomizationStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(GuestInfoCustomizationStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for GuestInfoCustomizationStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for GuestInfoCustomizationStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a GuestInfoCustomizationStatusEnum> for &'a str {
    fn from(value: &'a GuestInfoCustomizationStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for GuestInfoCustomizationStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_GUEST_STATE_ENUM_MAP: phf::Map<&'static str, VirtualMachineGuestStateEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
        (0, 2),
    ],
    entries: &[
        ("standby", VirtualMachineGuestStateEnum::Standby),
        ("notRunning", VirtualMachineGuestStateEnum::NotRunning),
        ("resetting", VirtualMachineGuestStateEnum::Resetting),
        ("unknown", VirtualMachineGuestStateEnum::Unknown),
        ("shuttingDown", VirtualMachineGuestStateEnum::ShuttingDown),
        ("running", VirtualMachineGuestStateEnum::Running),
    ],
};

impl VirtualMachineGuestStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineGuestStateEnum::Running => "running",
            VirtualMachineGuestStateEnum::ShuttingDown => "shuttingDown",
            VirtualMachineGuestStateEnum::Resetting => "resetting",
            VirtualMachineGuestStateEnum::Standby => "standby",
            VirtualMachineGuestStateEnum::NotRunning => "notRunning",
            VirtualMachineGuestStateEnum::Unknown => "unknown",
            VirtualMachineGuestStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_GUEST_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineGuestStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineGuestStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineGuestStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineGuestStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineGuestStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineGuestStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineGuestStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineGuestStateEnum> for &'a str {
    fn from(value: &'a VirtualMachineGuestStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineGuestStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_TOOLS_INSTALL_TYPE_ENUM_MAP: phf::Map<&'static str, VirtualMachineToolsInstallTypeEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (4, 0),
    ],
    entries: &[
        ("guestToolsTypeTar", VirtualMachineToolsInstallTypeEnum::GuestToolsTypeTar),
        ("guestToolsTypeOSP", VirtualMachineToolsInstallTypeEnum::GuestToolsTypeOsp),
        ("guestToolsTypeMSI", VirtualMachineToolsInstallTypeEnum::GuestToolsTypeMsi),
        ("guestToolsTypeOpenVMTools", VirtualMachineToolsInstallTypeEnum::GuestToolsTypeOpenVmTools),
        ("guestToolsTypeUnknown", VirtualMachineToolsInstallTypeEnum::GuestToolsTypeUnknown),
    ],
};

impl VirtualMachineToolsInstallTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineToolsInstallTypeEnum::GuestToolsTypeUnknown => "guestToolsTypeUnknown",
            VirtualMachineToolsInstallTypeEnum::GuestToolsTypeMsi => "guestToolsTypeMSI",
            VirtualMachineToolsInstallTypeEnum::GuestToolsTypeTar => "guestToolsTypeTar",
            VirtualMachineToolsInstallTypeEnum::GuestToolsTypeOsp => "guestToolsTypeOSP",
            VirtualMachineToolsInstallTypeEnum::GuestToolsTypeOpenVmTools => "guestToolsTypeOpenVMTools",
            VirtualMachineToolsInstallTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_TOOLS_INSTALL_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineToolsInstallTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineToolsInstallTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineToolsInstallTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineToolsInstallTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineToolsInstallTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineToolsInstallTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineToolsInstallTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineToolsInstallTypeEnum> for &'a str {
    fn from(value: &'a VirtualMachineToolsInstallTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineToolsInstallTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_TOOLS_RUNNING_STATUS_ENUM_MAP: phf::Map<&'static str, VirtualMachineToolsRunningStatusEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("guestToolsExecutingScripts", VirtualMachineToolsRunningStatusEnum::GuestToolsExecutingScripts),
        ("guestToolsRunning", VirtualMachineToolsRunningStatusEnum::GuestToolsRunning),
        ("guestToolsNotRunning", VirtualMachineToolsRunningStatusEnum::GuestToolsNotRunning),
    ],
};

impl VirtualMachineToolsRunningStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineToolsRunningStatusEnum::GuestToolsNotRunning => "guestToolsNotRunning",
            VirtualMachineToolsRunningStatusEnum::GuestToolsRunning => "guestToolsRunning",
            VirtualMachineToolsRunningStatusEnum::GuestToolsExecutingScripts => "guestToolsExecutingScripts",
            VirtualMachineToolsRunningStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_TOOLS_RUNNING_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineToolsRunningStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineToolsRunningStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineToolsRunningStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineToolsRunningStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineToolsRunningStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineToolsRunningStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineToolsRunningStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineToolsRunningStatusEnum> for &'a str {
    fn from(value: &'a VirtualMachineToolsRunningStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineToolsRunningStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_TOOLS_STATUS_ENUM_MAP: phf::Map<&'static str, VirtualMachineToolsStatusEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("toolsOld", VirtualMachineToolsStatusEnum::ToolsOld),
        ("toolsNotInstalled", VirtualMachineToolsStatusEnum::ToolsNotInstalled),
        ("toolsOk", VirtualMachineToolsStatusEnum::ToolsOk),
        ("toolsNotRunning", VirtualMachineToolsStatusEnum::ToolsNotRunning),
    ],
};

impl VirtualMachineToolsStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineToolsStatusEnum::ToolsNotInstalled => "toolsNotInstalled",
            VirtualMachineToolsStatusEnum::ToolsNotRunning => "toolsNotRunning",
            VirtualMachineToolsStatusEnum::ToolsOld => "toolsOld",
            VirtualMachineToolsStatusEnum::ToolsOk => "toolsOk",
            VirtualMachineToolsStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_TOOLS_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineToolsStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineToolsStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineToolsStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineToolsStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineToolsStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineToolsStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineToolsStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineToolsStatusEnum> for &'a str {
    fn from(value: &'a VirtualMachineToolsStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineToolsStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_TOOLS_VERSION_STATUS_ENUM_MAP: phf::Map<&'static str, VirtualMachineToolsVersionStatusEnum> = ::phf::Map {
    key: 3599879742736855518,
    disps: &[
        (0, 0),
        (2, 5),
    ],
    entries: &[
        ("guestToolsCurrent", VirtualMachineToolsVersionStatusEnum::GuestToolsCurrent),
        ("guestToolsNeedUpgrade", VirtualMachineToolsVersionStatusEnum::GuestToolsNeedUpgrade),
        ("guestToolsBlacklisted", VirtualMachineToolsVersionStatusEnum::GuestToolsBlacklisted),
        ("guestToolsNotInstalled", VirtualMachineToolsVersionStatusEnum::GuestToolsNotInstalled),
        ("guestToolsSupportedNew", VirtualMachineToolsVersionStatusEnum::GuestToolsSupportedNew),
        ("guestToolsTooOld", VirtualMachineToolsVersionStatusEnum::GuestToolsTooOld),
        ("guestToolsTooNew", VirtualMachineToolsVersionStatusEnum::GuestToolsTooNew),
        ("guestToolsSupportedOld", VirtualMachineToolsVersionStatusEnum::GuestToolsSupportedOld),
        ("guestToolsUnmanaged", VirtualMachineToolsVersionStatusEnum::GuestToolsUnmanaged),
    ],
};

impl VirtualMachineToolsVersionStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineToolsVersionStatusEnum::GuestToolsNotInstalled => "guestToolsNotInstalled",
            VirtualMachineToolsVersionStatusEnum::GuestToolsNeedUpgrade => "guestToolsNeedUpgrade",
            VirtualMachineToolsVersionStatusEnum::GuestToolsCurrent => "guestToolsCurrent",
            VirtualMachineToolsVersionStatusEnum::GuestToolsUnmanaged => "guestToolsUnmanaged",
            VirtualMachineToolsVersionStatusEnum::GuestToolsTooOld => "guestToolsTooOld",
            VirtualMachineToolsVersionStatusEnum::GuestToolsSupportedOld => "guestToolsSupportedOld",
            VirtualMachineToolsVersionStatusEnum::GuestToolsSupportedNew => "guestToolsSupportedNew",
            VirtualMachineToolsVersionStatusEnum::GuestToolsTooNew => "guestToolsTooNew",
            VirtualMachineToolsVersionStatusEnum::GuestToolsBlacklisted => "guestToolsBlacklisted",
            VirtualMachineToolsVersionStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_TOOLS_VERSION_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineToolsVersionStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineToolsVersionStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineToolsVersionStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineToolsVersionStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineToolsVersionStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineToolsVersionStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineToolsVersionStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineToolsVersionStatusEnum> for &'a str {
    fn from(value: &'a VirtualMachineToolsVersionStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineToolsVersionStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static GUEST_OS_DESCRIPTOR_FIRMWARE_TYPE_ENUM_MAP: phf::Map<&'static str, GuestOsDescriptorFirmwareTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("bios", GuestOsDescriptorFirmwareTypeEnum::Bios),
        ("efi", GuestOsDescriptorFirmwareTypeEnum::Efi),
    ],
};

impl GuestOsDescriptorFirmwareTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            GuestOsDescriptorFirmwareTypeEnum::Bios => "bios",
            GuestOsDescriptorFirmwareTypeEnum::Efi => "efi",
            GuestOsDescriptorFirmwareTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        GUEST_OS_DESCRIPTOR_FIRMWARE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| GuestOsDescriptorFirmwareTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for GuestOsDescriptorFirmwareTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for GuestOsDescriptorFirmwareTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<GuestOsDescriptorFirmwareTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(GuestOsDescriptorFirmwareTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for GuestOsDescriptorFirmwareTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for GuestOsDescriptorFirmwareTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a GuestOsDescriptorFirmwareTypeEnum> for &'a str {
    fn from(value: &'a GuestOsDescriptorFirmwareTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for GuestOsDescriptorFirmwareTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_GUEST_OS_FAMILY_ENUM_MAP: phf::Map<&'static str, VirtualMachineGuestOsFamilyEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
        (1, 1),
    ],
    entries: &[
        ("netwareGuest", VirtualMachineGuestOsFamilyEnum::NetwareGuest),
        ("solarisGuest", VirtualMachineGuestOsFamilyEnum::SolarisGuest),
        ("linuxGuest", VirtualMachineGuestOsFamilyEnum::LinuxGuest),
        ("windowsGuest", VirtualMachineGuestOsFamilyEnum::WindowsGuest),
        ("darwinGuestFamily", VirtualMachineGuestOsFamilyEnum::DarwinGuestFamily),
        ("otherGuestFamily", VirtualMachineGuestOsFamilyEnum::OtherGuestFamily),
    ],
};

impl VirtualMachineGuestOsFamilyEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineGuestOsFamilyEnum::WindowsGuest => "windowsGuest",
            VirtualMachineGuestOsFamilyEnum::LinuxGuest => "linuxGuest",
            VirtualMachineGuestOsFamilyEnum::NetwareGuest => "netwareGuest",
            VirtualMachineGuestOsFamilyEnum::SolarisGuest => "solarisGuest",
            VirtualMachineGuestOsFamilyEnum::DarwinGuestFamily => "darwinGuestFamily",
            VirtualMachineGuestOsFamilyEnum::OtherGuestFamily => "otherGuestFamily",
            VirtualMachineGuestOsFamilyEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_GUEST_OS_FAMILY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineGuestOsFamilyEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineGuestOsFamilyEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineGuestOsFamilyEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineGuestOsFamilyEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineGuestOsFamilyEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineGuestOsFamilyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineGuestOsFamilyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineGuestOsFamilyEnum> for &'a str {
    fn from(value: &'a VirtualMachineGuestOsFamilyEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineGuestOsFamilyEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_GUEST_OS_IDENTIFIER_ENUM_MAP: phf::Map<&'static str, VirtualMachineGuestOsIdentifierEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
        (0, 138),
        (1, 46),
        (0, 13),
        (0, 8),
        (0, 21),
        (1, 1),
        (0, 1),
        (3, 115),
        (0, 10),
        (4, 7),
        (0, 165),
        (4, 3),
        (0, 0),
        (0, 184),
        (0, 0),
        (1, 0),
        (0, 86),
        (1, 0),
        (0, 0),
        (0, 3),
        (0, 7),
        (2, 173),
        (0, 94),
        (0, 24),
        (1, 168),
        (0, 17),
        (0, 6),
        (0, 30),
        (2, 34),
        (0, 187),
        (1, 185),
        (0, 151),
        (0, 8),
        (1, 25),
        (6, 17),
        (1, 56),
        (0, 54),
        (4, 205),
        (50, 120),
        (43, 90),
        (0, 3),
    ],
    entries: &[
        ("debian6Guest", VirtualMachineGuestOsIdentifierEnum::Debian6Guest),
        ("sjdsGuest", VirtualMachineGuestOsIdentifierEnum::SjdsGuest),
        ("centos7Guest", VirtualMachineGuestOsIdentifierEnum::Centos7Guest),
        ("oracleLinux64Guest", VirtualMachineGuestOsIdentifierEnum::OracleLinux64Guest),
        ("other26xLinux64Guest", VirtualMachineGuestOsIdentifierEnum::Other26XLinux64Guest),
        ("darwin18_64Guest", VirtualMachineGuestOsIdentifierEnum::Darwin1864Guest),
        ("windows7Server64Guest", VirtualMachineGuestOsIdentifierEnum::Windows7Server64Guest),
        ("darwin11Guest", VirtualMachineGuestOsIdentifierEnum::Darwin11Guest),
        ("windows9Server64Guest", VirtualMachineGuestOsIdentifierEnum::Windows9Server64Guest),
        ("centos64Guest", VirtualMachineGuestOsIdentifierEnum::Centos64Guest),
        ("oesGuest", VirtualMachineGuestOsIdentifierEnum::OesGuest),
        ("winNTGuest", VirtualMachineGuestOsIdentifierEnum::WinNtGuest),
        ("windows8Server64Guest", VirtualMachineGuestOsIdentifierEnum::Windows8Server64Guest),
        ("coreos64Guest", VirtualMachineGuestOsIdentifierEnum::Coreos64Guest),
        ("winVista64Guest", VirtualMachineGuestOsIdentifierEnum::WinVista64Guest),
        ("oracleLinux9_64Guest", VirtualMachineGuestOsIdentifierEnum::OracleLinux964Guest),
        ("debian13_64Guest", VirtualMachineGuestOsIdentifierEnum::Debian1364Guest),
        ("otherLinuxGuest", VirtualMachineGuestOsIdentifierEnum::OtherLinuxGuest),
        ("otherGuest", VirtualMachineGuestOsIdentifierEnum::OtherGuest),
        ("other7xLinuxGuest", VirtualMachineGuestOsIdentifierEnum::Other7XLinuxGuest),
        ("vmkernel8Guest", VirtualMachineGuestOsIdentifierEnum::Vmkernel8Guest),
        ("freebsd12_64Guest", VirtualMachineGuestOsIdentifierEnum::Freebsd1264Guest),
        ("other24xLinuxGuest", VirtualMachineGuestOsIdentifierEnum::Other24XLinuxGuest),
        ("rhel3Guest", VirtualMachineGuestOsIdentifierEnum::Rhel3Guest),
        ("sles10_64Guest", VirtualMachineGuestOsIdentifierEnum::Sles1064Guest),
        ("winNetEnterpriseGuest", VirtualMachineGuestOsIdentifierEnum::WinNetEnterpriseGuest),
        ("solaris8Guest", VirtualMachineGuestOsIdentifierEnum::Solaris8Guest),
        ("darwin10_64Guest", VirtualMachineGuestOsIdentifierEnum::Darwin1064Guest),
        ("asianux8_64Guest", VirtualMachineGuestOsIdentifierEnum::Asianux864Guest),
        ("darwin14_64Guest", VirtualMachineGuestOsIdentifierEnum::Darwin1464Guest),
        ("solaris10_64Guest", VirtualMachineGuestOsIdentifierEnum::Solaris1064Guest),
        ("asianux4_64Guest", VirtualMachineGuestOsIdentifierEnum::Asianux464Guest),
        ("winNetBusinessGuest", VirtualMachineGuestOsIdentifierEnum::WinNetBusinessGuest),
        ("pardus_64Guest", VirtualMachineGuestOsIdentifierEnum::Pardus64Guest),
        ("debian7Guest", VirtualMachineGuestOsIdentifierEnum::Debian7Guest),
        ("turboLinux64Guest", VirtualMachineGuestOsIdentifierEnum::TurboLinux64Guest),
        ("centos7_64Guest", VirtualMachineGuestOsIdentifierEnum::Centos764Guest),
        ("winXPProGuest", VirtualMachineGuestOsIdentifierEnum::WinXpProGuest),
        ("redhatGuest", VirtualMachineGuestOsIdentifierEnum::RedhatGuest),
        ("rhel6_64Guest", VirtualMachineGuestOsIdentifierEnum::Rhel664Guest),
        ("windows2019srv_64Guest", VirtualMachineGuestOsIdentifierEnum::Windows2019Srv64Guest),
        ("debian11_64Guest", VirtualMachineGuestOsIdentifierEnum::Debian1164Guest),
        ("rhel9_64Guest", VirtualMachineGuestOsIdentifierEnum::Rhel964Guest),
        ("genericLinuxGuest", VirtualMachineGuestOsIdentifierEnum::GenericLinuxGuest),
        ("debian8Guest", VirtualMachineGuestOsIdentifierEnum::Debian8Guest),
        ("kylinlinux_64Guest", VirtualMachineGuestOsIdentifierEnum::Kylinlinux64Guest),
        ("vmkernel7Guest", VirtualMachineGuestOsIdentifierEnum::Vmkernel7Guest),
        ("rhel2Guest", VirtualMachineGuestOsIdentifierEnum::Rhel2Guest),
        ("win2000ProGuest", VirtualMachineGuestOsIdentifierEnum::Win2000ProGuest),
        ("debian10_64Guest", VirtualMachineGuestOsIdentifierEnum::Debian1064Guest),
        ("freebsd14_64Guest", VirtualMachineGuestOsIdentifierEnum::Freebsd1464Guest),
        ("otherLinux64Guest", VirtualMachineGuestOsIdentifierEnum::OtherLinux64Guest),
        ("asianux9_64Guest", VirtualMachineGuestOsIdentifierEnum::Asianux964Guest),
        ("darwin19_64Guest", VirtualMachineGuestOsIdentifierEnum::Darwin1964Guest),
        ("sles16_64Guest", VirtualMachineGuestOsIdentifierEnum::Sles1664Guest),
        ("rhel7_64Guest", VirtualMachineGuestOsIdentifierEnum::Rhel764Guest),
        ("debian12Guest", VirtualMachineGuestOsIdentifierEnum::Debian12Guest),
        ("sles15_64Guest", VirtualMachineGuestOsIdentifierEnum::Sles1564Guest),
        ("rhel6Guest", VirtualMachineGuestOsIdentifierEnum::Rhel6Guest),
        ("darwin23_64Guest", VirtualMachineGuestOsIdentifierEnum::Darwin2364Guest),
        ("other6xLinux64Guest", VirtualMachineGuestOsIdentifierEnum::Other6XLinux64Guest),
        ("debian5Guest", VirtualMachineGuestOsIdentifierEnum::Debian5Guest),
        ("windows2022srvNext_64Guest", VirtualMachineGuestOsIdentifierEnum::Windows2022SrvNext64Guest),
        ("crxSys1Guest", VirtualMachineGuestOsIdentifierEnum::CrxSys1Guest),
        ("otherGuest64", VirtualMachineGuestOsIdentifierEnum::OtherGuest64),
        ("sles11Guest", VirtualMachineGuestOsIdentifierEnum::Sles11Guest),
        ("centos9_64Guest", VirtualMachineGuestOsIdentifierEnum::Centos964Guest),
        ("darwinGuest", VirtualMachineGuestOsIdentifierEnum::DarwinGuest),
        ("freebsd15_64Guest", VirtualMachineGuestOsIdentifierEnum::Freebsd1564Guest),
        ("prolinux_64Guest", VirtualMachineGuestOsIdentifierEnum::Prolinux64Guest),
        ("mandrivaGuest", VirtualMachineGuestOsIdentifierEnum::MandrivaGuest),
        ("other6xLinuxGuest", VirtualMachineGuestOsIdentifierEnum::Other6XLinuxGuest),
        ("centos6_64Guest", VirtualMachineGuestOsIdentifierEnum::Centos664Guest),
        ("other5xLinux64Guest", VirtualMachineGuestOsIdentifierEnum::Other5XLinux64Guest),
        ("asianux3_64Guest", VirtualMachineGuestOsIdentifierEnum::Asianux364Guest),
        ("oracleLinux7_64Guest", VirtualMachineGuestOsIdentifierEnum::OracleLinux764Guest),
        ("freebsdGuest", VirtualMachineGuestOsIdentifierEnum::FreebsdGuest),
        ("winLonghorn64Guest", VirtualMachineGuestOsIdentifierEnum::WinLonghorn64Guest),
        ("fusionos_64Guest", VirtualMachineGuestOsIdentifierEnum::Fusionos64Guest),
        ("debian13Guest", VirtualMachineGuestOsIdentifierEnum::Debian13Guest),
        ("asianux5_64Guest", VirtualMachineGuestOsIdentifierEnum::Asianux564Guest),
        ("amazonlinux3_64Guest", VirtualMachineGuestOsIdentifierEnum::Amazonlinux364Guest),
        ("freebsd64Guest", VirtualMachineGuestOsIdentifierEnum::Freebsd64Guest),
        ("ubuntuGuest", VirtualMachineGuestOsIdentifierEnum::UbuntuGuest),
        ("other5xLinuxGuest", VirtualMachineGuestOsIdentifierEnum::Other5XLinuxGuest),
        ("darwin13_64Guest", VirtualMachineGuestOsIdentifierEnum::Darwin1364Guest),
        ("vmkernel5Guest", VirtualMachineGuestOsIdentifierEnum::Vmkernel5Guest),
        ("other26xLinuxGuest", VirtualMachineGuestOsIdentifierEnum::Other26XLinuxGuest),
        ("netware4Guest", VirtualMachineGuestOsIdentifierEnum::Netware4Guest),
        ("freebsd13Guest", VirtualMachineGuestOsIdentifierEnum::Freebsd13Guest),
        ("centos6Guest", VirtualMachineGuestOsIdentifierEnum::Centos6Guest),
        ("oracleLinuxGuest", VirtualMachineGuestOsIdentifierEnum::OracleLinuxGuest),
        ("freebsd14Guest", VirtualMachineGuestOsIdentifierEnum::Freebsd14Guest),
        ("miraclelinux_64Guest", VirtualMachineGuestOsIdentifierEnum::Miraclelinux64Guest),
        ("debian11Guest", VirtualMachineGuestOsIdentifierEnum::Debian11Guest),
        ("sles11_64Guest", VirtualMachineGuestOsIdentifierEnum::Sles1164Guest),
        ("rhel5_64Guest", VirtualMachineGuestOsIdentifierEnum::Rhel564Guest),
        ("winXPPro64Guest", VirtualMachineGuestOsIdentifierEnum::WinXpPro64Guest),
        ("dosGuest", VirtualMachineGuestOsIdentifierEnum::DosGuest),
        ("freebsd15Guest", VirtualMachineGuestOsIdentifierEnum::Freebsd15Guest),
        ("windows7Guest", VirtualMachineGuestOsIdentifierEnum::Windows7Guest),
        ("unixWare7Guest", VirtualMachineGuestOsIdentifierEnum::UnixWare7Guest),
        ("oracleLinux10_64Guest", VirtualMachineGuestOsIdentifierEnum::OracleLinux1064Guest),
        ("freebsd12Guest", VirtualMachineGuestOsIdentifierEnum::Freebsd12Guest),
        ("windowsHyperVGuest", VirtualMachineGuestOsIdentifierEnum::WindowsHyperVGuest),
        ("openServer5Guest", VirtualMachineGuestOsIdentifierEnum::OpenServer5Guest),
        ("fedoraGuest", VirtualMachineGuestOsIdentifierEnum::FedoraGuest),
        ("asianux4Guest", VirtualMachineGuestOsIdentifierEnum::Asianux4Guest),
        ("other4xLinuxGuest", VirtualMachineGuestOsIdentifierEnum::Other4XLinuxGuest),
        ("vmkernel6Guest", VirtualMachineGuestOsIdentifierEnum::Vmkernel6Guest),
        ("freebsd11_64Guest", VirtualMachineGuestOsIdentifierEnum::Freebsd1164Guest),
        ("other24xLinux64Guest", VirtualMachineGuestOsIdentifierEnum::Other24XLinux64Guest),
        ("debian9_64Guest", VirtualMachineGuestOsIdentifierEnum::Debian964Guest),
        ("winNetWebGuest", VirtualMachineGuestOsIdentifierEnum::WinNetWebGuest),
        ("debian4_64Guest", VirtualMachineGuestOsIdentifierEnum::Debian464Guest),
        ("win2000ServGuest", VirtualMachineGuestOsIdentifierEnum::Win2000ServGuest),
        ("win98Guest", VirtualMachineGuestOsIdentifierEnum::Win98Guest),
        ("winMeGuest", VirtualMachineGuestOsIdentifierEnum::WinMeGuest),
        ("slesGuest", VirtualMachineGuestOsIdentifierEnum::SlesGuest),
        ("windows11_64Guest", VirtualMachineGuestOsIdentifierEnum::Windows1164Guest),
        ("windows9Guest", VirtualMachineGuestOsIdentifierEnum::Windows9Guest),
        ("darwin16_64Guest", VirtualMachineGuestOsIdentifierEnum::Darwin1664Guest),
        ("windows9_64Guest", VirtualMachineGuestOsIdentifierEnum::Windows964Guest),
        ("debian10Guest", VirtualMachineGuestOsIdentifierEnum::Debian10Guest),
        ("centosGuest", VirtualMachineGuestOsIdentifierEnum::CentosGuest),
        ("mandriva64Guest", VirtualMachineGuestOsIdentifierEnum::Mandriva64Guest),
        ("winNetStandardGuest", VirtualMachineGuestOsIdentifierEnum::WinNetStandardGuest),
        ("suse64Guest", VirtualMachineGuestOsIdentifierEnum::Suse64Guest),
        ("oracleLinux6_64Guest", VirtualMachineGuestOsIdentifierEnum::OracleLinux664Guest),
        ("winNetEnterprise64Guest", VirtualMachineGuestOsIdentifierEnum::WinNetEnterprise64Guest),
        ("windows2019srvNext_64Guest", VirtualMachineGuestOsIdentifierEnum::Windows2019SrvNext64Guest),
        ("mandrakeGuest", VirtualMachineGuestOsIdentifierEnum::MandrakeGuest),
        ("netware6Guest", VirtualMachineGuestOsIdentifierEnum::Netware6Guest),
        ("winLonghornGuest", VirtualMachineGuestOsIdentifierEnum::WinLonghornGuest),
        ("debian4Guest", VirtualMachineGuestOsIdentifierEnum::Debian4Guest),
        ("vmkernel65Guest", VirtualMachineGuestOsIdentifierEnum::Vmkernel65Guest),
        ("debian9Guest", VirtualMachineGuestOsIdentifierEnum::Debian9Guest),
        ("darwin10Guest", VirtualMachineGuestOsIdentifierEnum::Darwin10Guest),
        ("darwin17_64Guest", VirtualMachineGuestOsIdentifierEnum::Darwin1764Guest),
        ("turboLinuxGuest", VirtualMachineGuestOsIdentifierEnum::TurboLinuxGuest),
        ("ubuntu64Guest", VirtualMachineGuestOsIdentifierEnum::Ubuntu64Guest),
        ("darwin64Guest", VirtualMachineGuestOsIdentifierEnum::Darwin64Guest),
        ("os2Guest", VirtualMachineGuestOsIdentifierEnum::Os2Guest),
        ("rhel8_64Guest", VirtualMachineGuestOsIdentifierEnum::Rhel864Guest),
        ("rhel3_64Guest", VirtualMachineGuestOsIdentifierEnum::Rhel364Guest),
        ("netware5Guest", VirtualMachineGuestOsIdentifierEnum::Netware5Guest),
        ("rhel5Guest", VirtualMachineGuestOsIdentifierEnum::Rhel5Guest),
        ("opensuseGuest", VirtualMachineGuestOsIdentifierEnum::OpensuseGuest),
        ("debian8_64Guest", VirtualMachineGuestOsIdentifierEnum::Debian864Guest),
        ("win31Guest", VirtualMachineGuestOsIdentifierEnum::Win31Guest),
        ("oracleLinux7Guest", VirtualMachineGuestOsIdentifierEnum::OracleLinux7Guest),
        ("sles10Guest", VirtualMachineGuestOsIdentifierEnum::Sles10Guest),
        ("debian5_64Guest", VirtualMachineGuestOsIdentifierEnum::Debian564Guest),
        ("darwin12_64Guest", VirtualMachineGuestOsIdentifierEnum::Darwin1264Guest),
        ("debian7_64Guest", VirtualMachineGuestOsIdentifierEnum::Debian764Guest),
        ("sles12Guest", VirtualMachineGuestOsIdentifierEnum::Sles12Guest),
        ("darwin21_64Guest", VirtualMachineGuestOsIdentifierEnum::Darwin2164Guest),
        ("windows7_64Guest", VirtualMachineGuestOsIdentifierEnum::Windows764Guest),
        ("rhel4_64Guest", VirtualMachineGuestOsIdentifierEnum::Rhel464Guest),
        ("winNetStandard64Guest", VirtualMachineGuestOsIdentifierEnum::WinNetStandard64Guest),
        ("oracleLinux8_64Guest", VirtualMachineGuestOsIdentifierEnum::OracleLinux864Guest),
        ("other3xLinux64Guest", VirtualMachineGuestOsIdentifierEnum::Other3XLinux64Guest),
        ("asianux7_64Guest", VirtualMachineGuestOsIdentifierEnum::Asianux764Guest),
        ("other3xLinuxGuest", VirtualMachineGuestOsIdentifierEnum::Other3XLinuxGuest),
        ("vmkernelGuest", VirtualMachineGuestOsIdentifierEnum::VmkernelGuest),
        ("eComStation2Guest", VirtualMachineGuestOsIdentifierEnum::EComStation2Guest),
        ("windows12_64Guest", VirtualMachineGuestOsIdentifierEnum::Windows1264Guest),
        ("vmwarePhoton64Guest", VirtualMachineGuestOsIdentifierEnum::VmwarePhoton64Guest),
        ("openServer6Guest", VirtualMachineGuestOsIdentifierEnum::OpenServer6Guest),
        ("nld9Guest", VirtualMachineGuestOsIdentifierEnum::Nld9Guest),
        ("solaris7Guest", VirtualMachineGuestOsIdentifierEnum::Solaris7Guest),
        ("vmkernel9Guest", VirtualMachineGuestOsIdentifierEnum::Vmkernel9Guest),
        ("sles12_64Guest", VirtualMachineGuestOsIdentifierEnum::Sles1264Guest),
        ("win2000AdvServGuest", VirtualMachineGuestOsIdentifierEnum::Win2000AdvServGuest),
        ("freebsd11Guest", VirtualMachineGuestOsIdentifierEnum::Freebsd11Guest),
        ("rhel4Guest", VirtualMachineGuestOsIdentifierEnum::Rhel4Guest),
        ("darwin11_64Guest", VirtualMachineGuestOsIdentifierEnum::Darwin1164Guest),
        ("suseGuest", VirtualMachineGuestOsIdentifierEnum::SuseGuest),
        ("solaris10Guest", VirtualMachineGuestOsIdentifierEnum::Solaris10Guest),
        ("crxPod1Guest", VirtualMachineGuestOsIdentifierEnum::CrxPod1Guest),
        ("opensuse64Guest", VirtualMachineGuestOsIdentifierEnum::Opensuse64Guest),
        ("asianux3Guest", VirtualMachineGuestOsIdentifierEnum::Asianux3Guest),
        ("centos8_64Guest", VirtualMachineGuestOsIdentifierEnum::Centos864Guest),
        ("debian6_64Guest", VirtualMachineGuestOsIdentifierEnum::Debian664Guest),
        ("oracleLinux6Guest", VirtualMachineGuestOsIdentifierEnum::OracleLinux6Guest),
        ("win95Guest", VirtualMachineGuestOsIdentifierEnum::Win95Guest),
        ("winNetDatacenter64Guest", VirtualMachineGuestOsIdentifierEnum::WinNetDatacenter64Guest),
        ("darwin20_64Guest", VirtualMachineGuestOsIdentifierEnum::Darwin2064Guest),
        ("windows8Guest", VirtualMachineGuestOsIdentifierEnum::Windows8Guest),
        ("freebsd13_64Guest", VirtualMachineGuestOsIdentifierEnum::Freebsd1364Guest),
        ("rhel10_64Guest", VirtualMachineGuestOsIdentifierEnum::Rhel1064Guest),
        ("winVistaGuest", VirtualMachineGuestOsIdentifierEnum::WinVistaGuest),
        ("fedora64Guest", VirtualMachineGuestOsIdentifierEnum::Fedora64Guest),
        ("almalinux_64Guest", VirtualMachineGuestOsIdentifierEnum::Almalinux64Guest),
        ("windows8_64Guest", VirtualMachineGuestOsIdentifierEnum::Windows864Guest),
        ("eComStationGuest", VirtualMachineGuestOsIdentifierEnum::EComStationGuest),
        ("sles64Guest", VirtualMachineGuestOsIdentifierEnum::Sles64Guest),
        ("other4xLinux64Guest", VirtualMachineGuestOsIdentifierEnum::Other4XLinux64Guest),
        ("darwin22_64Guest", VirtualMachineGuestOsIdentifierEnum::Darwin2264Guest),
        ("solaris9Guest", VirtualMachineGuestOsIdentifierEnum::Solaris9Guest),
        ("solaris11_64Guest", VirtualMachineGuestOsIdentifierEnum::Solaris1164Guest),
        ("darwin15_64Guest", VirtualMachineGuestOsIdentifierEnum::Darwin1564Guest),
        ("winNetDatacenterGuest", VirtualMachineGuestOsIdentifierEnum::WinNetDatacenterGuest),
        ("debian12_64Guest", VirtualMachineGuestOsIdentifierEnum::Debian1264Guest),
        ("solaris6Guest", VirtualMachineGuestOsIdentifierEnum::Solaris6Guest),
        ("winXPHomeGuest", VirtualMachineGuestOsIdentifierEnum::WinXpHomeGuest),
        ("amazonlinux2_64Guest", VirtualMachineGuestOsIdentifierEnum::Amazonlinux264Guest),
        ("other7xLinux64Guest", VirtualMachineGuestOsIdentifierEnum::Other7XLinux64Guest),
        ("rhel7Guest", VirtualMachineGuestOsIdentifierEnum::Rhel7Guest),
        ("rockylinux_64Guest", VirtualMachineGuestOsIdentifierEnum::Rockylinux64Guest),
    ],
};

impl VirtualMachineGuestOsIdentifierEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineGuestOsIdentifierEnum::DosGuest => "dosGuest",
            VirtualMachineGuestOsIdentifierEnum::Win31Guest => "win31Guest",
            VirtualMachineGuestOsIdentifierEnum::Win95Guest => "win95Guest",
            VirtualMachineGuestOsIdentifierEnum::Win98Guest => "win98Guest",
            VirtualMachineGuestOsIdentifierEnum::WinMeGuest => "winMeGuest",
            VirtualMachineGuestOsIdentifierEnum::WinNtGuest => "winNTGuest",
            VirtualMachineGuestOsIdentifierEnum::Win2000ProGuest => "win2000ProGuest",
            VirtualMachineGuestOsIdentifierEnum::Win2000ServGuest => "win2000ServGuest",
            VirtualMachineGuestOsIdentifierEnum::Win2000AdvServGuest => "win2000AdvServGuest",
            VirtualMachineGuestOsIdentifierEnum::WinXpHomeGuest => "winXPHomeGuest",
            VirtualMachineGuestOsIdentifierEnum::WinXpProGuest => "winXPProGuest",
            VirtualMachineGuestOsIdentifierEnum::WinXpPro64Guest => "winXPPro64Guest",
            VirtualMachineGuestOsIdentifierEnum::WinNetWebGuest => "winNetWebGuest",
            VirtualMachineGuestOsIdentifierEnum::WinNetStandardGuest => "winNetStandardGuest",
            VirtualMachineGuestOsIdentifierEnum::WinNetEnterpriseGuest => "winNetEnterpriseGuest",
            VirtualMachineGuestOsIdentifierEnum::WinNetDatacenterGuest => "winNetDatacenterGuest",
            VirtualMachineGuestOsIdentifierEnum::WinNetBusinessGuest => "winNetBusinessGuest",
            VirtualMachineGuestOsIdentifierEnum::WinNetStandard64Guest => "winNetStandard64Guest",
            VirtualMachineGuestOsIdentifierEnum::WinNetEnterprise64Guest => "winNetEnterprise64Guest",
            VirtualMachineGuestOsIdentifierEnum::WinLonghornGuest => "winLonghornGuest",
            VirtualMachineGuestOsIdentifierEnum::WinLonghorn64Guest => "winLonghorn64Guest",
            VirtualMachineGuestOsIdentifierEnum::WinNetDatacenter64Guest => "winNetDatacenter64Guest",
            VirtualMachineGuestOsIdentifierEnum::WinVistaGuest => "winVistaGuest",
            VirtualMachineGuestOsIdentifierEnum::WinVista64Guest => "winVista64Guest",
            VirtualMachineGuestOsIdentifierEnum::Windows7Guest => "windows7Guest",
            VirtualMachineGuestOsIdentifierEnum::Windows764Guest => "windows7_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Windows7Server64Guest => "windows7Server64Guest",
            VirtualMachineGuestOsIdentifierEnum::Windows8Guest => "windows8Guest",
            VirtualMachineGuestOsIdentifierEnum::Windows864Guest => "windows8_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Windows8Server64Guest => "windows8Server64Guest",
            VirtualMachineGuestOsIdentifierEnum::Windows9Guest => "windows9Guest",
            VirtualMachineGuestOsIdentifierEnum::Windows964Guest => "windows9_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Windows9Server64Guest => "windows9Server64Guest",
            VirtualMachineGuestOsIdentifierEnum::Windows1164Guest => "windows11_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Windows1264Guest => "windows12_64Guest",
            VirtualMachineGuestOsIdentifierEnum::WindowsHyperVGuest => "windowsHyperVGuest",
            VirtualMachineGuestOsIdentifierEnum::Windows2019Srv64Guest => "windows2019srv_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Windows2019SrvNext64Guest => "windows2019srvNext_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Windows2022SrvNext64Guest => "windows2022srvNext_64Guest",
            VirtualMachineGuestOsIdentifierEnum::FreebsdGuest => "freebsdGuest",
            VirtualMachineGuestOsIdentifierEnum::Freebsd64Guest => "freebsd64Guest",
            VirtualMachineGuestOsIdentifierEnum::Freebsd11Guest => "freebsd11Guest",
            VirtualMachineGuestOsIdentifierEnum::Freebsd1164Guest => "freebsd11_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Freebsd12Guest => "freebsd12Guest",
            VirtualMachineGuestOsIdentifierEnum::Freebsd1264Guest => "freebsd12_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Freebsd13Guest => "freebsd13Guest",
            VirtualMachineGuestOsIdentifierEnum::Freebsd1364Guest => "freebsd13_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Freebsd14Guest => "freebsd14Guest",
            VirtualMachineGuestOsIdentifierEnum::Freebsd1464Guest => "freebsd14_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Freebsd15Guest => "freebsd15Guest",
            VirtualMachineGuestOsIdentifierEnum::Freebsd1564Guest => "freebsd15_64Guest",
            VirtualMachineGuestOsIdentifierEnum::RedhatGuest => "redhatGuest",
            VirtualMachineGuestOsIdentifierEnum::Rhel2Guest => "rhel2Guest",
            VirtualMachineGuestOsIdentifierEnum::Rhel3Guest => "rhel3Guest",
            VirtualMachineGuestOsIdentifierEnum::Rhel364Guest => "rhel3_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Rhel4Guest => "rhel4Guest",
            VirtualMachineGuestOsIdentifierEnum::Rhel464Guest => "rhel4_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Rhel5Guest => "rhel5Guest",
            VirtualMachineGuestOsIdentifierEnum::Rhel564Guest => "rhel5_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Rhel6Guest => "rhel6Guest",
            VirtualMachineGuestOsIdentifierEnum::Rhel664Guest => "rhel6_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Rhel7Guest => "rhel7Guest",
            VirtualMachineGuestOsIdentifierEnum::Rhel764Guest => "rhel7_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Rhel864Guest => "rhel8_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Rhel964Guest => "rhel9_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Rhel1064Guest => "rhel10_64Guest",
            VirtualMachineGuestOsIdentifierEnum::CentosGuest => "centosGuest",
            VirtualMachineGuestOsIdentifierEnum::Centos64Guest => "centos64Guest",
            VirtualMachineGuestOsIdentifierEnum::Centos6Guest => "centos6Guest",
            VirtualMachineGuestOsIdentifierEnum::Centos664Guest => "centos6_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Centos7Guest => "centos7Guest",
            VirtualMachineGuestOsIdentifierEnum::Centos764Guest => "centos7_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Centos864Guest => "centos8_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Centos964Guest => "centos9_64Guest",
            VirtualMachineGuestOsIdentifierEnum::OracleLinuxGuest => "oracleLinuxGuest",
            VirtualMachineGuestOsIdentifierEnum::OracleLinux64Guest => "oracleLinux64Guest",
            VirtualMachineGuestOsIdentifierEnum::OracleLinux6Guest => "oracleLinux6Guest",
            VirtualMachineGuestOsIdentifierEnum::OracleLinux664Guest => "oracleLinux6_64Guest",
            VirtualMachineGuestOsIdentifierEnum::OracleLinux7Guest => "oracleLinux7Guest",
            VirtualMachineGuestOsIdentifierEnum::OracleLinux764Guest => "oracleLinux7_64Guest",
            VirtualMachineGuestOsIdentifierEnum::OracleLinux864Guest => "oracleLinux8_64Guest",
            VirtualMachineGuestOsIdentifierEnum::OracleLinux964Guest => "oracleLinux9_64Guest",
            VirtualMachineGuestOsIdentifierEnum::OracleLinux1064Guest => "oracleLinux10_64Guest",
            VirtualMachineGuestOsIdentifierEnum::SuseGuest => "suseGuest",
            VirtualMachineGuestOsIdentifierEnum::Suse64Guest => "suse64Guest",
            VirtualMachineGuestOsIdentifierEnum::SlesGuest => "slesGuest",
            VirtualMachineGuestOsIdentifierEnum::Sles64Guest => "sles64Guest",
            VirtualMachineGuestOsIdentifierEnum::Sles10Guest => "sles10Guest",
            VirtualMachineGuestOsIdentifierEnum::Sles1064Guest => "sles10_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Sles11Guest => "sles11Guest",
            VirtualMachineGuestOsIdentifierEnum::Sles1164Guest => "sles11_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Sles12Guest => "sles12Guest",
            VirtualMachineGuestOsIdentifierEnum::Sles1264Guest => "sles12_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Sles1564Guest => "sles15_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Sles1664Guest => "sles16_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Nld9Guest => "nld9Guest",
            VirtualMachineGuestOsIdentifierEnum::OesGuest => "oesGuest",
            VirtualMachineGuestOsIdentifierEnum::SjdsGuest => "sjdsGuest",
            VirtualMachineGuestOsIdentifierEnum::MandrakeGuest => "mandrakeGuest",
            VirtualMachineGuestOsIdentifierEnum::MandrivaGuest => "mandrivaGuest",
            VirtualMachineGuestOsIdentifierEnum::Mandriva64Guest => "mandriva64Guest",
            VirtualMachineGuestOsIdentifierEnum::TurboLinuxGuest => "turboLinuxGuest",
            VirtualMachineGuestOsIdentifierEnum::TurboLinux64Guest => "turboLinux64Guest",
            VirtualMachineGuestOsIdentifierEnum::UbuntuGuest => "ubuntuGuest",
            VirtualMachineGuestOsIdentifierEnum::Ubuntu64Guest => "ubuntu64Guest",
            VirtualMachineGuestOsIdentifierEnum::Debian4Guest => "debian4Guest",
            VirtualMachineGuestOsIdentifierEnum::Debian464Guest => "debian4_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Debian5Guest => "debian5Guest",
            VirtualMachineGuestOsIdentifierEnum::Debian564Guest => "debian5_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Debian6Guest => "debian6Guest",
            VirtualMachineGuestOsIdentifierEnum::Debian664Guest => "debian6_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Debian7Guest => "debian7Guest",
            VirtualMachineGuestOsIdentifierEnum::Debian764Guest => "debian7_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Debian8Guest => "debian8Guest",
            VirtualMachineGuestOsIdentifierEnum::Debian864Guest => "debian8_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Debian9Guest => "debian9Guest",
            VirtualMachineGuestOsIdentifierEnum::Debian964Guest => "debian9_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Debian10Guest => "debian10Guest",
            VirtualMachineGuestOsIdentifierEnum::Debian1064Guest => "debian10_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Debian11Guest => "debian11Guest",
            VirtualMachineGuestOsIdentifierEnum::Debian1164Guest => "debian11_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Debian12Guest => "debian12Guest",
            VirtualMachineGuestOsIdentifierEnum::Debian1264Guest => "debian12_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Debian13Guest => "debian13Guest",
            VirtualMachineGuestOsIdentifierEnum::Debian1364Guest => "debian13_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Asianux3Guest => "asianux3Guest",
            VirtualMachineGuestOsIdentifierEnum::Asianux364Guest => "asianux3_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Asianux4Guest => "asianux4Guest",
            VirtualMachineGuestOsIdentifierEnum::Asianux464Guest => "asianux4_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Asianux564Guest => "asianux5_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Asianux764Guest => "asianux7_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Asianux864Guest => "asianux8_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Asianux964Guest => "asianux9_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Miraclelinux64Guest => "miraclelinux_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Pardus64Guest => "pardus_64Guest",
            VirtualMachineGuestOsIdentifierEnum::OpensuseGuest => "opensuseGuest",
            VirtualMachineGuestOsIdentifierEnum::Opensuse64Guest => "opensuse64Guest",
            VirtualMachineGuestOsIdentifierEnum::FedoraGuest => "fedoraGuest",
            VirtualMachineGuestOsIdentifierEnum::Fedora64Guest => "fedora64Guest",
            VirtualMachineGuestOsIdentifierEnum::Coreos64Guest => "coreos64Guest",
            VirtualMachineGuestOsIdentifierEnum::VmwarePhoton64Guest => "vmwarePhoton64Guest",
            VirtualMachineGuestOsIdentifierEnum::Other24XLinuxGuest => "other24xLinuxGuest",
            VirtualMachineGuestOsIdentifierEnum::Other26XLinuxGuest => "other26xLinuxGuest",
            VirtualMachineGuestOsIdentifierEnum::OtherLinuxGuest => "otherLinuxGuest",
            VirtualMachineGuestOsIdentifierEnum::Other3XLinuxGuest => "other3xLinuxGuest",
            VirtualMachineGuestOsIdentifierEnum::Other4XLinuxGuest => "other4xLinuxGuest",
            VirtualMachineGuestOsIdentifierEnum::Other5XLinuxGuest => "other5xLinuxGuest",
            VirtualMachineGuestOsIdentifierEnum::Other6XLinuxGuest => "other6xLinuxGuest",
            VirtualMachineGuestOsIdentifierEnum::Other7XLinuxGuest => "other7xLinuxGuest",
            VirtualMachineGuestOsIdentifierEnum::GenericLinuxGuest => "genericLinuxGuest",
            VirtualMachineGuestOsIdentifierEnum::Other24XLinux64Guest => "other24xLinux64Guest",
            VirtualMachineGuestOsIdentifierEnum::Other26XLinux64Guest => "other26xLinux64Guest",
            VirtualMachineGuestOsIdentifierEnum::Other3XLinux64Guest => "other3xLinux64Guest",
            VirtualMachineGuestOsIdentifierEnum::Other4XLinux64Guest => "other4xLinux64Guest",
            VirtualMachineGuestOsIdentifierEnum::Other5XLinux64Guest => "other5xLinux64Guest",
            VirtualMachineGuestOsIdentifierEnum::Other6XLinux64Guest => "other6xLinux64Guest",
            VirtualMachineGuestOsIdentifierEnum::Other7XLinux64Guest => "other7xLinux64Guest",
            VirtualMachineGuestOsIdentifierEnum::OtherLinux64Guest => "otherLinux64Guest",
            VirtualMachineGuestOsIdentifierEnum::Solaris6Guest => "solaris6Guest",
            VirtualMachineGuestOsIdentifierEnum::Solaris7Guest => "solaris7Guest",
            VirtualMachineGuestOsIdentifierEnum::Solaris8Guest => "solaris8Guest",
            VirtualMachineGuestOsIdentifierEnum::Solaris9Guest => "solaris9Guest",
            VirtualMachineGuestOsIdentifierEnum::Solaris10Guest => "solaris10Guest",
            VirtualMachineGuestOsIdentifierEnum::Solaris1064Guest => "solaris10_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Solaris1164Guest => "solaris11_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Fusionos64Guest => "fusionos_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Prolinux64Guest => "prolinux_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Kylinlinux64Guest => "kylinlinux_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Os2Guest => "os2Guest",
            VirtualMachineGuestOsIdentifierEnum::EComStationGuest => "eComStationGuest",
            VirtualMachineGuestOsIdentifierEnum::EComStation2Guest => "eComStation2Guest",
            VirtualMachineGuestOsIdentifierEnum::Netware4Guest => "netware4Guest",
            VirtualMachineGuestOsIdentifierEnum::Netware5Guest => "netware5Guest",
            VirtualMachineGuestOsIdentifierEnum::Netware6Guest => "netware6Guest",
            VirtualMachineGuestOsIdentifierEnum::OpenServer5Guest => "openServer5Guest",
            VirtualMachineGuestOsIdentifierEnum::OpenServer6Guest => "openServer6Guest",
            VirtualMachineGuestOsIdentifierEnum::UnixWare7Guest => "unixWare7Guest",
            VirtualMachineGuestOsIdentifierEnum::DarwinGuest => "darwinGuest",
            VirtualMachineGuestOsIdentifierEnum::Darwin64Guest => "darwin64Guest",
            VirtualMachineGuestOsIdentifierEnum::Darwin10Guest => "darwin10Guest",
            VirtualMachineGuestOsIdentifierEnum::Darwin1064Guest => "darwin10_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Darwin11Guest => "darwin11Guest",
            VirtualMachineGuestOsIdentifierEnum::Darwin1164Guest => "darwin11_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Darwin1264Guest => "darwin12_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Darwin1364Guest => "darwin13_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Darwin1464Guest => "darwin14_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Darwin1564Guest => "darwin15_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Darwin1664Guest => "darwin16_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Darwin1764Guest => "darwin17_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Darwin1864Guest => "darwin18_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Darwin1964Guest => "darwin19_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Darwin2064Guest => "darwin20_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Darwin2164Guest => "darwin21_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Darwin2264Guest => "darwin22_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Darwin2364Guest => "darwin23_64Guest",
            VirtualMachineGuestOsIdentifierEnum::VmkernelGuest => "vmkernelGuest",
            VirtualMachineGuestOsIdentifierEnum::Vmkernel5Guest => "vmkernel5Guest",
            VirtualMachineGuestOsIdentifierEnum::Vmkernel6Guest => "vmkernel6Guest",
            VirtualMachineGuestOsIdentifierEnum::Vmkernel65Guest => "vmkernel65Guest",
            VirtualMachineGuestOsIdentifierEnum::Vmkernel7Guest => "vmkernel7Guest",
            VirtualMachineGuestOsIdentifierEnum::Vmkernel8Guest => "vmkernel8Guest",
            VirtualMachineGuestOsIdentifierEnum::Vmkernel9Guest => "vmkernel9Guest",
            VirtualMachineGuestOsIdentifierEnum::Amazonlinux264Guest => "amazonlinux2_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Amazonlinux364Guest => "amazonlinux3_64Guest",
            VirtualMachineGuestOsIdentifierEnum::CrxPod1Guest => "crxPod1Guest",
            VirtualMachineGuestOsIdentifierEnum::CrxSys1Guest => "crxSys1Guest",
            VirtualMachineGuestOsIdentifierEnum::Rockylinux64Guest => "rockylinux_64Guest",
            VirtualMachineGuestOsIdentifierEnum::Almalinux64Guest => "almalinux_64Guest",
            VirtualMachineGuestOsIdentifierEnum::OtherGuest => "otherGuest",
            VirtualMachineGuestOsIdentifierEnum::OtherGuest64 => "otherGuest64",
            VirtualMachineGuestOsIdentifierEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_GUEST_OS_IDENTIFIER_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineGuestOsIdentifierEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineGuestOsIdentifierEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineGuestOsIdentifierEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineGuestOsIdentifierEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineGuestOsIdentifierEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineGuestOsIdentifierEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineGuestOsIdentifierEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineGuestOsIdentifierEnum> for &'a str {
    fn from(value: &'a VirtualMachineGuestOsIdentifierEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineGuestOsIdentifierEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static GUEST_OS_DESCRIPTOR_SUPPORT_LEVEL_ENUM_MAP: phf::Map<&'static str, GuestOsDescriptorSupportLevelEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (5, 0),
        (4, 5),
    ],
    entries: &[
        ("experimental", GuestOsDescriptorSupportLevelEnum::Experimental),
        ("legacy", GuestOsDescriptorSupportLevelEnum::Legacy),
        ("supported", GuestOsDescriptorSupportLevelEnum::Supported),
        ("terminated", GuestOsDescriptorSupportLevelEnum::Terminated),
        ("techPreview", GuestOsDescriptorSupportLevelEnum::TechPreview),
        ("unsupported", GuestOsDescriptorSupportLevelEnum::Unsupported),
        ("deprecated", GuestOsDescriptorSupportLevelEnum::Deprecated),
    ],
};

impl GuestOsDescriptorSupportLevelEnum {
    pub fn as_str(&self) -> &str {
        match self {
            GuestOsDescriptorSupportLevelEnum::Experimental => "experimental",
            GuestOsDescriptorSupportLevelEnum::Legacy => "legacy",
            GuestOsDescriptorSupportLevelEnum::Terminated => "terminated",
            GuestOsDescriptorSupportLevelEnum::Supported => "supported",
            GuestOsDescriptorSupportLevelEnum::Unsupported => "unsupported",
            GuestOsDescriptorSupportLevelEnum::Deprecated => "deprecated",
            GuestOsDescriptorSupportLevelEnum::TechPreview => "techPreview",
            GuestOsDescriptorSupportLevelEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        GUEST_OS_DESCRIPTOR_SUPPORT_LEVEL_ENUM_MAP.get(s).cloned().unwrap_or_else(|| GuestOsDescriptorSupportLevelEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for GuestOsDescriptorSupportLevelEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for GuestOsDescriptorSupportLevelEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<GuestOsDescriptorSupportLevelEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(GuestOsDescriptorSupportLevelEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for GuestOsDescriptorSupportLevelEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for GuestOsDescriptorSupportLevelEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a GuestOsDescriptorSupportLevelEnum> for &'a str {
    fn from(value: &'a GuestOsDescriptorSupportLevelEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for GuestOsDescriptorSupportLevelEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static GUEST_QUIESCE_END_GUEST_QUIESCE_ERROR_ENUM_MAP: phf::Map<&'static str, GuestQuiesceEndGuestQuiesceErrorEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("failure", GuestQuiesceEndGuestQuiesceErrorEnum::Failure),
    ],
};

impl GuestQuiesceEndGuestQuiesceErrorEnum {
    pub fn as_str(&self) -> &str {
        match self {
            GuestQuiesceEndGuestQuiesceErrorEnum::Failure => "failure",
            GuestQuiesceEndGuestQuiesceErrorEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        GUEST_QUIESCE_END_GUEST_QUIESCE_ERROR_ENUM_MAP.get(s).cloned().unwrap_or_else(|| GuestQuiesceEndGuestQuiesceErrorEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for GuestQuiesceEndGuestQuiesceErrorEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for GuestQuiesceEndGuestQuiesceErrorEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<GuestQuiesceEndGuestQuiesceErrorEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(GuestQuiesceEndGuestQuiesceErrorEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for GuestQuiesceEndGuestQuiesceErrorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for GuestQuiesceEndGuestQuiesceErrorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a GuestQuiesceEndGuestQuiesceErrorEnum> for &'a str {
    fn from(value: &'a GuestQuiesceEndGuestQuiesceErrorEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for GuestQuiesceEndGuestQuiesceErrorEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_METADATA_MANAGER_VM_METADATA_OP_ENUM_MAP: phf::Map<&'static str, VirtualMachineMetadataManagerVmMetadataOpEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("Update", VirtualMachineMetadataManagerVmMetadataOpEnum::Update),
        ("Remove", VirtualMachineMetadataManagerVmMetadataOpEnum::Remove),
    ],
};

impl VirtualMachineMetadataManagerVmMetadataOpEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineMetadataManagerVmMetadataOpEnum::Update => "Update",
            VirtualMachineMetadataManagerVmMetadataOpEnum::Remove => "Remove",
            VirtualMachineMetadataManagerVmMetadataOpEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_METADATA_MANAGER_VM_METADATA_OP_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineMetadataManagerVmMetadataOpEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineMetadataManagerVmMetadataOpEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineMetadataManagerVmMetadataOpEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineMetadataManagerVmMetadataOpEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineMetadataManagerVmMetadataOpEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineMetadataManagerVmMetadataOpEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineMetadataManagerVmMetadataOpEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineMetadataManagerVmMetadataOpEnum> for &'a str {
    fn from(value: &'a VirtualMachineMetadataManagerVmMetadataOpEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineMetadataManagerVmMetadataOpEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_METADATA_MANAGER_VM_METADATA_OWNER_OWNER_ENUM_MAP: phf::Map<&'static str, VirtualMachineMetadataManagerVmMetadataOwnerOwnerEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("ComVmwareVsphereHA", VirtualMachineMetadataManagerVmMetadataOwnerOwnerEnum::ComVmwareVsphereHa),
    ],
};

impl VirtualMachineMetadataManagerVmMetadataOwnerOwnerEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineMetadataManagerVmMetadataOwnerOwnerEnum::ComVmwareVsphereHa => "ComVmwareVsphereHA",
            VirtualMachineMetadataManagerVmMetadataOwnerOwnerEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_METADATA_MANAGER_VM_METADATA_OWNER_OWNER_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineMetadataManagerVmMetadataOwnerOwnerEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineMetadataManagerVmMetadataOwnerOwnerEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineMetadataManagerVmMetadataOwnerOwnerEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineMetadataManagerVmMetadataOwnerOwnerEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineMetadataManagerVmMetadataOwnerOwnerEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineMetadataManagerVmMetadataOwnerOwnerEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineMetadataManagerVmMetadataOwnerOwnerEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineMetadataManagerVmMetadataOwnerOwnerEnum> for &'a str {
    fn from(value: &'a VirtualMachineMetadataManagerVmMetadataOwnerOwnerEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineMetadataManagerVmMetadataOwnerOwnerEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_RELOCATE_DISK_MOVE_OPTIONS_ENUM_MAP: phf::Map<&'static str, VirtualMachineRelocateDiskMoveOptionsEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("moveAllDiskBackingsAndDisallowSharing", VirtualMachineRelocateDiskMoveOptionsEnum::MoveAllDiskBackingsAndDisallowSharing),
        ("moveChildMostDiskBacking", VirtualMachineRelocateDiskMoveOptionsEnum::MoveChildMostDiskBacking),
        ("moveAllDiskBackingsAndAllowSharing", VirtualMachineRelocateDiskMoveOptionsEnum::MoveAllDiskBackingsAndAllowSharing),
        ("moveAllDiskBackingsAndConsolidate", VirtualMachineRelocateDiskMoveOptionsEnum::MoveAllDiskBackingsAndConsolidate),
        ("createNewChildDiskBacking", VirtualMachineRelocateDiskMoveOptionsEnum::CreateNewChildDiskBacking),
    ],
};

impl VirtualMachineRelocateDiskMoveOptionsEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineRelocateDiskMoveOptionsEnum::MoveAllDiskBackingsAndAllowSharing => "moveAllDiskBackingsAndAllowSharing",
            VirtualMachineRelocateDiskMoveOptionsEnum::MoveAllDiskBackingsAndDisallowSharing => "moveAllDiskBackingsAndDisallowSharing",
            VirtualMachineRelocateDiskMoveOptionsEnum::MoveChildMostDiskBacking => "moveChildMostDiskBacking",
            VirtualMachineRelocateDiskMoveOptionsEnum::CreateNewChildDiskBacking => "createNewChildDiskBacking",
            VirtualMachineRelocateDiskMoveOptionsEnum::MoveAllDiskBackingsAndConsolidate => "moveAllDiskBackingsAndConsolidate",
            VirtualMachineRelocateDiskMoveOptionsEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_RELOCATE_DISK_MOVE_OPTIONS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineRelocateDiskMoveOptionsEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineRelocateDiskMoveOptionsEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineRelocateDiskMoveOptionsEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineRelocateDiskMoveOptionsEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineRelocateDiskMoveOptionsEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineRelocateDiskMoveOptionsEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineRelocateDiskMoveOptionsEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineRelocateDiskMoveOptionsEnum> for &'a str {
    fn from(value: &'a VirtualMachineRelocateDiskMoveOptionsEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineRelocateDiskMoveOptionsEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_RELOCATE_TRANSFORMATION_ENUM_MAP: phf::Map<&'static str, VirtualMachineRelocateTransformationEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("sparse", VirtualMachineRelocateTransformationEnum::Sparse),
        ("flat", VirtualMachineRelocateTransformationEnum::Flat),
    ],
};

impl VirtualMachineRelocateTransformationEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineRelocateTransformationEnum::Flat => "flat",
            VirtualMachineRelocateTransformationEnum::Sparse => "sparse",
            VirtualMachineRelocateTransformationEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_RELOCATE_TRANSFORMATION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineRelocateTransformationEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineRelocateTransformationEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineRelocateTransformationEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineRelocateTransformationEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineRelocateTransformationEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineRelocateTransformationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineRelocateTransformationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineRelocateTransformationEnum> for &'a str {
    fn from(value: &'a VirtualMachineRelocateTransformationEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineRelocateTransformationEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static SCHEDULED_HARDWARE_UPGRADE_INFO_HARDWARE_UPGRADE_POLICY_ENUM_MAP: phf::Map<&'static str, ScheduledHardwareUpgradeInfoHardwareUpgradePolicyEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("never", ScheduledHardwareUpgradeInfoHardwareUpgradePolicyEnum::Never),
        ("always", ScheduledHardwareUpgradeInfoHardwareUpgradePolicyEnum::Always),
        ("onSoftPowerOff", ScheduledHardwareUpgradeInfoHardwareUpgradePolicyEnum::OnSoftPowerOff),
    ],
};

impl ScheduledHardwareUpgradeInfoHardwareUpgradePolicyEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ScheduledHardwareUpgradeInfoHardwareUpgradePolicyEnum::Never => "never",
            ScheduledHardwareUpgradeInfoHardwareUpgradePolicyEnum::OnSoftPowerOff => "onSoftPowerOff",
            ScheduledHardwareUpgradeInfoHardwareUpgradePolicyEnum::Always => "always",
            ScheduledHardwareUpgradeInfoHardwareUpgradePolicyEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        SCHEDULED_HARDWARE_UPGRADE_INFO_HARDWARE_UPGRADE_POLICY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ScheduledHardwareUpgradeInfoHardwareUpgradePolicyEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ScheduledHardwareUpgradeInfoHardwareUpgradePolicyEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ScheduledHardwareUpgradeInfoHardwareUpgradePolicyEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ScheduledHardwareUpgradeInfoHardwareUpgradePolicyEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ScheduledHardwareUpgradeInfoHardwareUpgradePolicyEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ScheduledHardwareUpgradeInfoHardwareUpgradePolicyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ScheduledHardwareUpgradeInfoHardwareUpgradePolicyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ScheduledHardwareUpgradeInfoHardwareUpgradePolicyEnum> for &'a str {
    fn from(value: &'a ScheduledHardwareUpgradeInfoHardwareUpgradePolicyEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ScheduledHardwareUpgradeInfoHardwareUpgradePolicyEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static SCHEDULED_HARDWARE_UPGRADE_INFO_HARDWARE_UPGRADE_STATUS_ENUM_MAP: phf::Map<&'static str, ScheduledHardwareUpgradeInfoHardwareUpgradeStatusEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("none", ScheduledHardwareUpgradeInfoHardwareUpgradeStatusEnum::None),
        ("failed", ScheduledHardwareUpgradeInfoHardwareUpgradeStatusEnum::Failed),
        ("success", ScheduledHardwareUpgradeInfoHardwareUpgradeStatusEnum::Success),
        ("pending", ScheduledHardwareUpgradeInfoHardwareUpgradeStatusEnum::Pending),
    ],
};

impl ScheduledHardwareUpgradeInfoHardwareUpgradeStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ScheduledHardwareUpgradeInfoHardwareUpgradeStatusEnum::None => "none",
            ScheduledHardwareUpgradeInfoHardwareUpgradeStatusEnum::Pending => "pending",
            ScheduledHardwareUpgradeInfoHardwareUpgradeStatusEnum::Success => "success",
            ScheduledHardwareUpgradeInfoHardwareUpgradeStatusEnum::Failed => "failed",
            ScheduledHardwareUpgradeInfoHardwareUpgradeStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        SCHEDULED_HARDWARE_UPGRADE_INFO_HARDWARE_UPGRADE_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ScheduledHardwareUpgradeInfoHardwareUpgradeStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ScheduledHardwareUpgradeInfoHardwareUpgradeStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ScheduledHardwareUpgradeInfoHardwareUpgradeStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ScheduledHardwareUpgradeInfoHardwareUpgradeStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ScheduledHardwareUpgradeInfoHardwareUpgradeStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ScheduledHardwareUpgradeInfoHardwareUpgradeStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ScheduledHardwareUpgradeInfoHardwareUpgradeStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ScheduledHardwareUpgradeInfoHardwareUpgradeStatusEnum> for &'a str {
    fn from(value: &'a ScheduledHardwareUpgradeInfoHardwareUpgradeStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ScheduledHardwareUpgradeInfoHardwareUpgradeStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_SCSI_PASSTHROUGH_TYPE_ENUM_MAP: phf::Map<&'static str, VirtualMachineScsiPassthroughTypeEnum> = ::phf::Map {
    key: 14108922650502679131,
    disps: &[
        (0, 7),
        (2, 10),
        (2, 0),
    ],
    entries: &[
        ("processor", VirtualMachineScsiPassthroughTypeEnum::Processor),
        ("printer", VirtualMachineScsiPassthroughTypeEnum::Printer),
        ("optical", VirtualMachineScsiPassthroughTypeEnum::Optical),
        ("disk", VirtualMachineScsiPassthroughTypeEnum::Disk),
        ("com", VirtualMachineScsiPassthroughTypeEnum::Com),
        ("cdrom", VirtualMachineScsiPassthroughTypeEnum::Cdrom),
        ("media", VirtualMachineScsiPassthroughTypeEnum::Media),
        ("unknown", VirtualMachineScsiPassthroughTypeEnum::Unknown),
        ("raid", VirtualMachineScsiPassthroughTypeEnum::Raid),
        ("scanner", VirtualMachineScsiPassthroughTypeEnum::Scanner),
        ("tape", VirtualMachineScsiPassthroughTypeEnum::Tape),
        ("worm", VirtualMachineScsiPassthroughTypeEnum::Worm),
    ],
};

impl VirtualMachineScsiPassthroughTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineScsiPassthroughTypeEnum::Disk => "disk",
            VirtualMachineScsiPassthroughTypeEnum::Tape => "tape",
            VirtualMachineScsiPassthroughTypeEnum::Printer => "printer",
            VirtualMachineScsiPassthroughTypeEnum::Processor => "processor",
            VirtualMachineScsiPassthroughTypeEnum::Worm => "worm",
            VirtualMachineScsiPassthroughTypeEnum::Cdrom => "cdrom",
            VirtualMachineScsiPassthroughTypeEnum::Scanner => "scanner",
            VirtualMachineScsiPassthroughTypeEnum::Optical => "optical",
            VirtualMachineScsiPassthroughTypeEnum::Media => "media",
            VirtualMachineScsiPassthroughTypeEnum::Com => "com",
            VirtualMachineScsiPassthroughTypeEnum::Raid => "raid",
            VirtualMachineScsiPassthroughTypeEnum::Unknown => "unknown",
            VirtualMachineScsiPassthroughTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_SCSI_PASSTHROUGH_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineScsiPassthroughTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineScsiPassthroughTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineScsiPassthroughTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineScsiPassthroughTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineScsiPassthroughTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineScsiPassthroughTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineScsiPassthroughTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineScsiPassthroughTypeEnum> for &'a str {
    fn from(value: &'a VirtualMachineScsiPassthroughTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineScsiPassthroughTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_SGX_INFO_FLC_MODES_ENUM_MAP: phf::Map<&'static str, VirtualMachineSgxInfoFlcModesEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("unlocked", VirtualMachineSgxInfoFlcModesEnum::Unlocked),
        ("locked", VirtualMachineSgxInfoFlcModesEnum::Locked),
    ],
};

impl VirtualMachineSgxInfoFlcModesEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineSgxInfoFlcModesEnum::Locked => "locked",
            VirtualMachineSgxInfoFlcModesEnum::Unlocked => "unlocked",
            VirtualMachineSgxInfoFlcModesEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_SGX_INFO_FLC_MODES_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineSgxInfoFlcModesEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineSgxInfoFlcModesEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineSgxInfoFlcModesEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineSgxInfoFlcModesEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineSgxInfoFlcModesEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineSgxInfoFlcModesEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineSgxInfoFlcModesEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineSgxInfoFlcModesEnum> for &'a str {
    fn from(value: &'a VirtualMachineSgxInfoFlcModesEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineSgxInfoFlcModesEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_TARGET_INFO_CONFIGURATION_TAG_ENUM_MAP: phf::Map<&'static str, VirtualMachineTargetInfoConfigurationTagEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("compliant", VirtualMachineTargetInfoConfigurationTagEnum::Compliant),
        ("clusterWide", VirtualMachineTargetInfoConfigurationTagEnum::ClusterWide),
    ],
};

impl VirtualMachineTargetInfoConfigurationTagEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineTargetInfoConfigurationTagEnum::Compliant => "compliant",
            VirtualMachineTargetInfoConfigurationTagEnum::ClusterWide => "clusterWide",
            VirtualMachineTargetInfoConfigurationTagEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_TARGET_INFO_CONFIGURATION_TAG_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineTargetInfoConfigurationTagEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineTargetInfoConfigurationTagEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineTargetInfoConfigurationTagEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineTargetInfoConfigurationTagEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineTargetInfoConfigurationTagEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineTargetInfoConfigurationTagEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineTargetInfoConfigurationTagEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineTargetInfoConfigurationTagEnum> for &'a str {
    fn from(value: &'a VirtualMachineTargetInfoConfigurationTagEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineTargetInfoConfigurationTagEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static UPGRADE_POLICY_ENUM_MAP: phf::Map<&'static str, UpgradePolicyEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("manual", UpgradePolicyEnum::Manual),
        ("upgradeAtPowerCycle", UpgradePolicyEnum::UpgradeAtPowerCycle),
    ],
};

impl UpgradePolicyEnum {
    pub fn as_str(&self) -> &str {
        match self {
            UpgradePolicyEnum::Manual => "manual",
            UpgradePolicyEnum::UpgradeAtPowerCycle => "upgradeAtPowerCycle",
            UpgradePolicyEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        UPGRADE_POLICY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| UpgradePolicyEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for UpgradePolicyEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for UpgradePolicyEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<UpgradePolicyEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(UpgradePolicyEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for UpgradePolicyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for UpgradePolicyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a UpgradePolicyEnum> for &'a str {
    fn from(value: &'a UpgradePolicyEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for UpgradePolicyEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_USB_INFO_FAMILY_ENUM_MAP: phf::Map<&'static str, VirtualMachineUsbInfoFamilyEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (1, 0),
        (0, 4),
        (1, 14),
        (1, 7),
    ],
    entries: &[
        ("smart_card", VirtualMachineUsbInfoFamilyEnum::SmartCard),
        ("video", VirtualMachineUsbInfoFamilyEnum::Video),
        ("printer", VirtualMachineUsbInfoFamilyEnum::Printer),
        ("hub", VirtualMachineUsbInfoFamilyEnum::Hub),
        ("storage", VirtualMachineUsbInfoFamilyEnum::Storage),
        ("security", VirtualMachineUsbInfoFamilyEnum::Security),
        ("physical", VirtualMachineUsbInfoFamilyEnum::Physical),
        ("vendor_specific", VirtualMachineUsbInfoFamilyEnum::VendorSpecific),
        ("pda", VirtualMachineUsbInfoFamilyEnum::Pda),
        ("hid_bootable", VirtualMachineUsbInfoFamilyEnum::HidBootable),
        ("wusb", VirtualMachineUsbInfoFamilyEnum::Wusb),
        ("hid", VirtualMachineUsbInfoFamilyEnum::Hid),
        ("imaging", VirtualMachineUsbInfoFamilyEnum::Imaging),
        ("other", VirtualMachineUsbInfoFamilyEnum::Other),
        ("bluetooth", VirtualMachineUsbInfoFamilyEnum::Bluetooth),
        ("audio", VirtualMachineUsbInfoFamilyEnum::Audio),
        ("unknownFamily", VirtualMachineUsbInfoFamilyEnum::UnknownFamily),
        ("communication", VirtualMachineUsbInfoFamilyEnum::Communication),
        ("wireless", VirtualMachineUsbInfoFamilyEnum::Wireless),
    ],
};

impl VirtualMachineUsbInfoFamilyEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineUsbInfoFamilyEnum::Audio => "audio",
            VirtualMachineUsbInfoFamilyEnum::Hid => "hid",
            VirtualMachineUsbInfoFamilyEnum::HidBootable => "hid_bootable",
            VirtualMachineUsbInfoFamilyEnum::Physical => "physical",
            VirtualMachineUsbInfoFamilyEnum::Communication => "communication",
            VirtualMachineUsbInfoFamilyEnum::Imaging => "imaging",
            VirtualMachineUsbInfoFamilyEnum::Printer => "printer",
            VirtualMachineUsbInfoFamilyEnum::Storage => "storage",
            VirtualMachineUsbInfoFamilyEnum::Hub => "hub",
            VirtualMachineUsbInfoFamilyEnum::SmartCard => "smart_card",
            VirtualMachineUsbInfoFamilyEnum::Security => "security",
            VirtualMachineUsbInfoFamilyEnum::Video => "video",
            VirtualMachineUsbInfoFamilyEnum::Wireless => "wireless",
            VirtualMachineUsbInfoFamilyEnum::Bluetooth => "bluetooth",
            VirtualMachineUsbInfoFamilyEnum::Wusb => "wusb",
            VirtualMachineUsbInfoFamilyEnum::Pda => "pda",
            VirtualMachineUsbInfoFamilyEnum::VendorSpecific => "vendor_specific",
            VirtualMachineUsbInfoFamilyEnum::Other => "other",
            VirtualMachineUsbInfoFamilyEnum::UnknownFamily => "unknownFamily",
            VirtualMachineUsbInfoFamilyEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_USB_INFO_FAMILY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineUsbInfoFamilyEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineUsbInfoFamilyEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineUsbInfoFamilyEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineUsbInfoFamilyEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineUsbInfoFamilyEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineUsbInfoFamilyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineUsbInfoFamilyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineUsbInfoFamilyEnum> for &'a str {
    fn from(value: &'a VirtualMachineUsbInfoFamilyEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineUsbInfoFamilyEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_USB_INFO_SPEED_ENUM_MAP: phf::Map<&'static str, VirtualMachineUsbInfoSpeedEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (4, 0),
        (6, 0),
    ],
    entries: &[
        ("low", VirtualMachineUsbInfoSpeedEnum::Low),
        ("high", VirtualMachineUsbInfoSpeedEnum::High),
        ("unknownSpeed", VirtualMachineUsbInfoSpeedEnum::UnknownSpeed),
        ("superSpeed", VirtualMachineUsbInfoSpeedEnum::SuperSpeed),
        ("superSpeed20Gbps", VirtualMachineUsbInfoSpeedEnum::SuperSpeed20Gbps),
        ("superSpeedPlus", VirtualMachineUsbInfoSpeedEnum::SuperSpeedPlus),
        ("full", VirtualMachineUsbInfoSpeedEnum::Full),
    ],
};

impl VirtualMachineUsbInfoSpeedEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineUsbInfoSpeedEnum::Low => "low",
            VirtualMachineUsbInfoSpeedEnum::Full => "full",
            VirtualMachineUsbInfoSpeedEnum::High => "high",
            VirtualMachineUsbInfoSpeedEnum::SuperSpeed => "superSpeed",
            VirtualMachineUsbInfoSpeedEnum::SuperSpeedPlus => "superSpeedPlus",
            VirtualMachineUsbInfoSpeedEnum::SuperSpeed20Gbps => "superSpeed20Gbps",
            VirtualMachineUsbInfoSpeedEnum::UnknownSpeed => "unknownSpeed",
            VirtualMachineUsbInfoSpeedEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_USB_INFO_SPEED_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineUsbInfoSpeedEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineUsbInfoSpeedEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineUsbInfoSpeedEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineUsbInfoSpeedEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineUsbInfoSpeedEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineUsbInfoSpeedEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineUsbInfoSpeedEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineUsbInfoSpeedEnum> for &'a str {
    fn from(value: &'a VirtualMachineUsbInfoSpeedEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineUsbInfoSpeedEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_VENDOR_DEVICE_GROUP_INFO_COMPONENT_DEVICE_INFO_COMPONENT_TYPE_ENUM_MAP: phf::Map<&'static str, VirtualMachineVendorDeviceGroupInfoComponentDeviceInfoComponentTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("dvx", VirtualMachineVendorDeviceGroupInfoComponentDeviceInfoComponentTypeEnum::Dvx),
        ("sriovNic", VirtualMachineVendorDeviceGroupInfoComponentDeviceInfoComponentTypeEnum::SriovNic),
        ("pciPassthru", VirtualMachineVendorDeviceGroupInfoComponentDeviceInfoComponentTypeEnum::PciPassthru),
        ("nvidiaVgpu", VirtualMachineVendorDeviceGroupInfoComponentDeviceInfoComponentTypeEnum::NvidiaVgpu),
    ],
};

impl VirtualMachineVendorDeviceGroupInfoComponentDeviceInfoComponentTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineVendorDeviceGroupInfoComponentDeviceInfoComponentTypeEnum::PciPassthru => "pciPassthru",
            VirtualMachineVendorDeviceGroupInfoComponentDeviceInfoComponentTypeEnum::NvidiaVgpu => "nvidiaVgpu",
            VirtualMachineVendorDeviceGroupInfoComponentDeviceInfoComponentTypeEnum::SriovNic => "sriovNic",
            VirtualMachineVendorDeviceGroupInfoComponentDeviceInfoComponentTypeEnum::Dvx => "dvx",
            VirtualMachineVendorDeviceGroupInfoComponentDeviceInfoComponentTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_VENDOR_DEVICE_GROUP_INFO_COMPONENT_DEVICE_INFO_COMPONENT_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineVendorDeviceGroupInfoComponentDeviceInfoComponentTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineVendorDeviceGroupInfoComponentDeviceInfoComponentTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineVendorDeviceGroupInfoComponentDeviceInfoComponentTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineVendorDeviceGroupInfoComponentDeviceInfoComponentTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineVendorDeviceGroupInfoComponentDeviceInfoComponentTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineVendorDeviceGroupInfoComponentDeviceInfoComponentTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineVendorDeviceGroupInfoComponentDeviceInfoComponentTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineVendorDeviceGroupInfoComponentDeviceInfoComponentTypeEnum> for &'a str {
    fn from(value: &'a VirtualMachineVendorDeviceGroupInfoComponentDeviceInfoComponentTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineVendorDeviceGroupInfoComponentDeviceInfoComponentTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_VGPU_PROFILE_INFO_PROFILE_CLASS_ENUM_MAP: phf::Map<&'static str, VirtualMachineVgpuProfileInfoProfileClassEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("quadro", VirtualMachineVgpuProfileInfoProfileClassEnum::Quadro),
        ("compute", VirtualMachineVgpuProfileInfoProfileClassEnum::Compute),
    ],
};

impl VirtualMachineVgpuProfileInfoProfileClassEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineVgpuProfileInfoProfileClassEnum::Compute => "compute",
            VirtualMachineVgpuProfileInfoProfileClassEnum::Quadro => "quadro",
            VirtualMachineVgpuProfileInfoProfileClassEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_VGPU_PROFILE_INFO_PROFILE_CLASS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineVgpuProfileInfoProfileClassEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineVgpuProfileInfoProfileClassEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineVgpuProfileInfoProfileClassEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineVgpuProfileInfoProfileClassEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineVgpuProfileInfoProfileClassEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineVgpuProfileInfoProfileClassEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineVgpuProfileInfoProfileClassEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineVgpuProfileInfoProfileClassEnum> for &'a str {
    fn from(value: &'a VirtualMachineVgpuProfileInfoProfileClassEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineVgpuProfileInfoProfileClassEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_VGPU_PROFILE_INFO_PROFILE_SHARING_ENUM_MAP: phf::Map<&'static str, VirtualMachineVgpuProfileInfoProfileSharingEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("timeSliced", VirtualMachineVgpuProfileInfoProfileSharingEnum::TimeSliced),
        ("mig", VirtualMachineVgpuProfileInfoProfileSharingEnum::Mig),
    ],
};

impl VirtualMachineVgpuProfileInfoProfileSharingEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineVgpuProfileInfoProfileSharingEnum::TimeSliced => "timeSliced",
            VirtualMachineVgpuProfileInfoProfileSharingEnum::Mig => "mig",
            VirtualMachineVgpuProfileInfoProfileSharingEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_VGPU_PROFILE_INFO_PROFILE_SHARING_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineVgpuProfileInfoProfileSharingEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineVgpuProfileInfoProfileSharingEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineVgpuProfileInfoProfileSharingEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineVgpuProfileInfoProfileSharingEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineVgpuProfileInfoProfileSharingEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineVgpuProfileInfoProfileSharingEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineVgpuProfileInfoProfileSharingEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineVgpuProfileInfoProfileSharingEnum> for &'a str {
    fn from(value: &'a VirtualMachineVgpuProfileInfoProfileSharingEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineVgpuProfileInfoProfileSharingEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_VIRTUAL_DEVICE_SWAP_DEVICE_SWAP_STATUS_ENUM_MAP: phf::Map<&'static str, VirtualMachineVirtualDeviceSwapDeviceSwapStatusEnum> = ::phf::Map {
    key: 12213676231523076107,
    disps: &[
        (3, 0),
    ],
    entries: &[
        ("none", VirtualMachineVirtualDeviceSwapDeviceSwapStatusEnum::None),
        ("completed", VirtualMachineVirtualDeviceSwapDeviceSwapStatusEnum::Completed),
        ("scheduled", VirtualMachineVirtualDeviceSwapDeviceSwapStatusEnum::Scheduled),
        ("inprogress", VirtualMachineVirtualDeviceSwapDeviceSwapStatusEnum::Inprogress),
        ("failed", VirtualMachineVirtualDeviceSwapDeviceSwapStatusEnum::Failed),
    ],
};

impl VirtualMachineVirtualDeviceSwapDeviceSwapStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineVirtualDeviceSwapDeviceSwapStatusEnum::None => "none",
            VirtualMachineVirtualDeviceSwapDeviceSwapStatusEnum::Scheduled => "scheduled",
            VirtualMachineVirtualDeviceSwapDeviceSwapStatusEnum::Inprogress => "inprogress",
            VirtualMachineVirtualDeviceSwapDeviceSwapStatusEnum::Failed => "failed",
            VirtualMachineVirtualDeviceSwapDeviceSwapStatusEnum::Completed => "completed",
            VirtualMachineVirtualDeviceSwapDeviceSwapStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_VIRTUAL_DEVICE_SWAP_DEVICE_SWAP_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineVirtualDeviceSwapDeviceSwapStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineVirtualDeviceSwapDeviceSwapStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineVirtualDeviceSwapDeviceSwapStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineVirtualDeviceSwapDeviceSwapStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineVirtualDeviceSwapDeviceSwapStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineVirtualDeviceSwapDeviceSwapStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineVirtualDeviceSwapDeviceSwapStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineVirtualDeviceSwapDeviceSwapStatusEnum> for &'a str {
    fn from(value: &'a VirtualMachineVirtualDeviceSwapDeviceSwapStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineVirtualDeviceSwapDeviceSwapStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_HARDWARE_MOTHERBOARD_LAYOUT_ENUM_MAP: phf::Map<&'static str, VirtualHardwareMotherboardLayoutEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("acpiHostBridges", VirtualHardwareMotherboardLayoutEnum::AcpiHostBridges),
        ("i440bxHostBridge", VirtualHardwareMotherboardLayoutEnum::I440BxHostBridge),
    ],
};

impl VirtualHardwareMotherboardLayoutEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualHardwareMotherboardLayoutEnum::I440BxHostBridge => "i440bxHostBridge",
            VirtualHardwareMotherboardLayoutEnum::AcpiHostBridges => "acpiHostBridges",
            VirtualHardwareMotherboardLayoutEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_HARDWARE_MOTHERBOARD_LAYOUT_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualHardwareMotherboardLayoutEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualHardwareMotherboardLayoutEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualHardwareMotherboardLayoutEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualHardwareMotherboardLayoutEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualHardwareMotherboardLayoutEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualHardwareMotherboardLayoutEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualHardwareMotherboardLayoutEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualHardwareMotherboardLayoutEnum> for &'a str {
    fn from(value: &'a VirtualHardwareMotherboardLayoutEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualHardwareMotherboardLayoutEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_VIRTUAL_P_MEM_SNAPSHOT_MODE_ENUM_MAP: phf::Map<&'static str, VirtualMachineVirtualPMemSnapshotModeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("independent_persistent", VirtualMachineVirtualPMemSnapshotModeEnum::IndependentPersistent),
        ("independent_eraseonrevert", VirtualMachineVirtualPMemSnapshotModeEnum::IndependentEraseonrevert),
    ],
};

impl VirtualMachineVirtualPMemSnapshotModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineVirtualPMemSnapshotModeEnum::IndependentPersistent => "independent_persistent",
            VirtualMachineVirtualPMemSnapshotModeEnum::IndependentEraseonrevert => "independent_eraseonrevert",
            VirtualMachineVirtualPMemSnapshotModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_VIRTUAL_P_MEM_SNAPSHOT_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineVirtualPMemSnapshotModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineVirtualPMemSnapshotModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineVirtualPMemSnapshotModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineVirtualPMemSnapshotModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineVirtualPMemSnapshotModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineVirtualPMemSnapshotModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineVirtualPMemSnapshotModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineVirtualPMemSnapshotModeEnum> for &'a str {
    fn from(value: &'a VirtualMachineVirtualPMemSnapshotModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineVirtualPMemSnapshotModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_WINDOWS_QUIESCE_SPEC_VSS_BACKUP_CONTEXT_ENUM_MAP: phf::Map<&'static str, VirtualMachineWindowsQuiesceSpecVssBackupContextEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("ctx_backup", VirtualMachineWindowsQuiesceSpecVssBackupContextEnum::CtxBackup),
        ("ctx_auto", VirtualMachineWindowsQuiesceSpecVssBackupContextEnum::CtxAuto),
        ("ctx_file_share_backup", VirtualMachineWindowsQuiesceSpecVssBackupContextEnum::CtxFileShareBackup),
    ],
};

impl VirtualMachineWindowsQuiesceSpecVssBackupContextEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineWindowsQuiesceSpecVssBackupContextEnum::CtxAuto => "ctx_auto",
            VirtualMachineWindowsQuiesceSpecVssBackupContextEnum::CtxBackup => "ctx_backup",
            VirtualMachineWindowsQuiesceSpecVssBackupContextEnum::CtxFileShareBackup => "ctx_file_share_backup",
            VirtualMachineWindowsQuiesceSpecVssBackupContextEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_WINDOWS_QUIESCE_SPEC_VSS_BACKUP_CONTEXT_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineWindowsQuiesceSpecVssBackupContextEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineWindowsQuiesceSpecVssBackupContextEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineWindowsQuiesceSpecVssBackupContextEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineWindowsQuiesceSpecVssBackupContextEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineWindowsQuiesceSpecVssBackupContextEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineWindowsQuiesceSpecVssBackupContextEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineWindowsQuiesceSpecVssBackupContextEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineWindowsQuiesceSpecVssBackupContextEnum> for &'a str {
    fn from(value: &'a VirtualMachineWindowsQuiesceSpecVssBackupContextEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineWindowsQuiesceSpecVssBackupContextEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CHECK_TEST_TYPE_ENUM_MAP: phf::Map<&'static str, CheckTestTypeEnum> = ::phf::Map {
    key: 14108922650502679131,
    disps: &[
        (3, 0),
    ],
    entries: &[
        ("networkTests", CheckTestTypeEnum::NetworkTests),
        ("datastoreTests", CheckTestTypeEnum::DatastoreTests),
        ("hostTests", CheckTestTypeEnum::HostTests),
        ("sourceTests", CheckTestTypeEnum::SourceTests),
        ("resourcePoolTests", CheckTestTypeEnum::ResourcePoolTests),
    ],
};

impl CheckTestTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            CheckTestTypeEnum::SourceTests => "sourceTests",
            CheckTestTypeEnum::HostTests => "hostTests",
            CheckTestTypeEnum::ResourcePoolTests => "resourcePoolTests",
            CheckTestTypeEnum::DatastoreTests => "datastoreTests",
            CheckTestTypeEnum::NetworkTests => "networkTests",
            CheckTestTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CHECK_TEST_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| CheckTestTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for CheckTestTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for CheckTestTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<CheckTestTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(CheckTestTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for CheckTestTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for CheckTestTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a CheckTestTypeEnum> for &'a str {
    fn from(value: &'a CheckTestTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for CheckTestTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CUSTOMIZATION_NET_BIOS_MODE_ENUM_MAP: phf::Map<&'static str, CustomizationNetBiosModeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("enableNetBIOSViaDhcp", CustomizationNetBiosModeEnum::EnableNetBiosViaDhcp),
        ("disableNetBIOS", CustomizationNetBiosModeEnum::DisableNetBios),
        ("enableNetBIOS", CustomizationNetBiosModeEnum::EnableNetBios),
    ],
};

impl CustomizationNetBiosModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            CustomizationNetBiosModeEnum::EnableNetBiosViaDhcp => "enableNetBIOSViaDhcp",
            CustomizationNetBiosModeEnum::EnableNetBios => "enableNetBIOS",
            CustomizationNetBiosModeEnum::DisableNetBios => "disableNetBIOS",
            CustomizationNetBiosModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CUSTOMIZATION_NET_BIOS_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| CustomizationNetBiosModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for CustomizationNetBiosModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for CustomizationNetBiosModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<CustomizationNetBiosModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(CustomizationNetBiosModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for CustomizationNetBiosModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for CustomizationNetBiosModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a CustomizationNetBiosModeEnum> for &'a str {
    fn from(value: &'a CustomizationNetBiosModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for CustomizationNetBiosModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CUSTOMIZATION_LICENSE_DATA_MODE_ENUM_MAP: phf::Map<&'static str, CustomizationLicenseDataModeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("perServer", CustomizationLicenseDataModeEnum::PerServer),
        ("perSeat", CustomizationLicenseDataModeEnum::PerSeat),
    ],
};

impl CustomizationLicenseDataModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            CustomizationLicenseDataModeEnum::PerServer => "perServer",
            CustomizationLicenseDataModeEnum::PerSeat => "perSeat",
            CustomizationLicenseDataModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CUSTOMIZATION_LICENSE_DATA_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| CustomizationLicenseDataModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for CustomizationLicenseDataModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for CustomizationLicenseDataModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<CustomizationLicenseDataModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(CustomizationLicenseDataModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for CustomizationLicenseDataModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for CustomizationLicenseDataModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a CustomizationLicenseDataModeEnum> for &'a str {
    fn from(value: &'a CustomizationLicenseDataModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for CustomizationLicenseDataModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CUSTOMIZATION_SYSPREP_REBOOT_OPTION_ENUM_MAP: phf::Map<&'static str, CustomizationSysprepRebootOptionEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("reboot", CustomizationSysprepRebootOptionEnum::Reboot),
        ("shutdown", CustomizationSysprepRebootOptionEnum::Shutdown),
        ("noreboot", CustomizationSysprepRebootOptionEnum::Noreboot),
    ],
};

impl CustomizationSysprepRebootOptionEnum {
    pub fn as_str(&self) -> &str {
        match self {
            CustomizationSysprepRebootOptionEnum::Reboot => "reboot",
            CustomizationSysprepRebootOptionEnum::Noreboot => "noreboot",
            CustomizationSysprepRebootOptionEnum::Shutdown => "shutdown",
            CustomizationSysprepRebootOptionEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CUSTOMIZATION_SYSPREP_REBOOT_OPTION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| CustomizationSysprepRebootOptionEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for CustomizationSysprepRebootOptionEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for CustomizationSysprepRebootOptionEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<CustomizationSysprepRebootOptionEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(CustomizationSysprepRebootOptionEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for CustomizationSysprepRebootOptionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for CustomizationSysprepRebootOptionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a CustomizationSysprepRebootOptionEnum> for &'a str {
    fn from(value: &'a CustomizationSysprepRebootOptionEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for CustomizationSysprepRebootOptionEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_DEVICE_CONNECT_INFO_MIGRATE_CONNECT_OP_ENUM_MAP: phf::Map<&'static str, VirtualDeviceConnectInfoMigrateConnectOpEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("unset", VirtualDeviceConnectInfoMigrateConnectOpEnum::Unset),
        ("disconnect", VirtualDeviceConnectInfoMigrateConnectOpEnum::Disconnect),
        ("connect", VirtualDeviceConnectInfoMigrateConnectOpEnum::Connect),
    ],
};

impl VirtualDeviceConnectInfoMigrateConnectOpEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualDeviceConnectInfoMigrateConnectOpEnum::Connect => "connect",
            VirtualDeviceConnectInfoMigrateConnectOpEnum::Disconnect => "disconnect",
            VirtualDeviceConnectInfoMigrateConnectOpEnum::Unset => "unset",
            VirtualDeviceConnectInfoMigrateConnectOpEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_DEVICE_CONNECT_INFO_MIGRATE_CONNECT_OP_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualDeviceConnectInfoMigrateConnectOpEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualDeviceConnectInfoMigrateConnectOpEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualDeviceConnectInfoMigrateConnectOpEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualDeviceConnectInfoMigrateConnectOpEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualDeviceConnectInfoMigrateConnectOpEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualDeviceConnectInfoMigrateConnectOpEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualDeviceConnectInfoMigrateConnectOpEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualDeviceConnectInfoMigrateConnectOpEnum> for &'a str {
    fn from(value: &'a VirtualDeviceConnectInfoMigrateConnectOpEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualDeviceConnectInfoMigrateConnectOpEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_DEVICE_CONNECT_INFO_STATUS_ENUM_MAP: phf::Map<&'static str, VirtualDeviceConnectInfoStatusEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("recoverableError", VirtualDeviceConnectInfoStatusEnum::RecoverableError),
        ("unrecoverableError", VirtualDeviceConnectInfoStatusEnum::UnrecoverableError),
        ("untried", VirtualDeviceConnectInfoStatusEnum::Untried),
        ("ok", VirtualDeviceConnectInfoStatusEnum::Ok),
    ],
};

impl VirtualDeviceConnectInfoStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualDeviceConnectInfoStatusEnum::Ok => "ok",
            VirtualDeviceConnectInfoStatusEnum::RecoverableError => "recoverableError",
            VirtualDeviceConnectInfoStatusEnum::UnrecoverableError => "unrecoverableError",
            VirtualDeviceConnectInfoStatusEnum::Untried => "untried",
            VirtualDeviceConnectInfoStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_DEVICE_CONNECT_INFO_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualDeviceConnectInfoStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualDeviceConnectInfoStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualDeviceConnectInfoStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualDeviceConnectInfoStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualDeviceConnectInfoStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualDeviceConnectInfoStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualDeviceConnectInfoStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualDeviceConnectInfoStatusEnum> for &'a str {
    fn from(value: &'a VirtualDeviceConnectInfoStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualDeviceConnectInfoStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_DEVICE_FILE_EXTENSION_ENUM_MAP: phf::Map<&'static str, VirtualDeviceFileExtensionEnum> = ::phf::Map {
    key: 8694567506910003252,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("rdm", VirtualDeviceFileExtensionEnum::Rdm),
        ("iso", VirtualDeviceFileExtensionEnum::Iso),
        ("flp", VirtualDeviceFileExtensionEnum::Flp),
        ("vmdk", VirtualDeviceFileExtensionEnum::Vmdk),
        ("dsk", VirtualDeviceFileExtensionEnum::Dsk),
    ],
};

impl VirtualDeviceFileExtensionEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualDeviceFileExtensionEnum::Iso => "iso",
            VirtualDeviceFileExtensionEnum::Flp => "flp",
            VirtualDeviceFileExtensionEnum::Vmdk => "vmdk",
            VirtualDeviceFileExtensionEnum::Dsk => "dsk",
            VirtualDeviceFileExtensionEnum::Rdm => "rdm",
            VirtualDeviceFileExtensionEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_DEVICE_FILE_EXTENSION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualDeviceFileExtensionEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualDeviceFileExtensionEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualDeviceFileExtensionEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualDeviceFileExtensionEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualDeviceFileExtensionEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualDeviceFileExtensionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualDeviceFileExtensionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualDeviceFileExtensionEnum> for &'a str {
    fn from(value: &'a VirtualDeviceFileExtensionEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualDeviceFileExtensionEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_DEVICE_URI_BACKING_OPTION_DIRECTION_ENUM_MAP: phf::Map<&'static str, VirtualDeviceUriBackingOptionDirectionEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("server", VirtualDeviceUriBackingOptionDirectionEnum::Server),
        ("client", VirtualDeviceUriBackingOptionDirectionEnum::Client),
    ],
};

impl VirtualDeviceUriBackingOptionDirectionEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualDeviceUriBackingOptionDirectionEnum::Server => "server",
            VirtualDeviceUriBackingOptionDirectionEnum::Client => "client",
            VirtualDeviceUriBackingOptionDirectionEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_DEVICE_URI_BACKING_OPTION_DIRECTION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualDeviceUriBackingOptionDirectionEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualDeviceUriBackingOptionDirectionEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualDeviceUriBackingOptionDirectionEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualDeviceUriBackingOptionDirectionEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualDeviceUriBackingOptionDirectionEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualDeviceUriBackingOptionDirectionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualDeviceUriBackingOptionDirectionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualDeviceUriBackingOptionDirectionEnum> for &'a str {
    fn from(value: &'a VirtualDeviceUriBackingOptionDirectionEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualDeviceUriBackingOptionDirectionEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_DEVICE_CONFIG_SPEC_CHANGE_MODE_ENUM_MAP: phf::Map<&'static str, VirtualDeviceConfigSpecChangeModeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("skip", VirtualDeviceConfigSpecChangeModeEnum::Skip),
        ("fail", VirtualDeviceConfigSpecChangeModeEnum::Fail),
    ],
};

impl VirtualDeviceConfigSpecChangeModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualDeviceConfigSpecChangeModeEnum::Fail => "fail",
            VirtualDeviceConfigSpecChangeModeEnum::Skip => "skip",
            VirtualDeviceConfigSpecChangeModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_DEVICE_CONFIG_SPEC_CHANGE_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualDeviceConfigSpecChangeModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualDeviceConfigSpecChangeModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualDeviceConfigSpecChangeModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualDeviceConfigSpecChangeModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualDeviceConfigSpecChangeModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualDeviceConfigSpecChangeModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualDeviceConfigSpecChangeModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualDeviceConfigSpecChangeModeEnum> for &'a str {
    fn from(value: &'a VirtualDeviceConfigSpecChangeModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualDeviceConfigSpecChangeModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_DEVICE_CONFIG_SPEC_FILE_OPERATION_ENUM_MAP: phf::Map<&'static str, VirtualDeviceConfigSpecFileOperationEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("replace", VirtualDeviceConfigSpecFileOperationEnum::Replace),
        ("destroy", VirtualDeviceConfigSpecFileOperationEnum::Destroy),
        ("create", VirtualDeviceConfigSpecFileOperationEnum::Create),
    ],
};

impl VirtualDeviceConfigSpecFileOperationEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualDeviceConfigSpecFileOperationEnum::Create => "create",
            VirtualDeviceConfigSpecFileOperationEnum::Destroy => "destroy",
            VirtualDeviceConfigSpecFileOperationEnum::Replace => "replace",
            VirtualDeviceConfigSpecFileOperationEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_DEVICE_CONFIG_SPEC_FILE_OPERATION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualDeviceConfigSpecFileOperationEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualDeviceConfigSpecFileOperationEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualDeviceConfigSpecFileOperationEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualDeviceConfigSpecFileOperationEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualDeviceConfigSpecFileOperationEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualDeviceConfigSpecFileOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualDeviceConfigSpecFileOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualDeviceConfigSpecFileOperationEnum> for &'a str {
    fn from(value: &'a VirtualDeviceConfigSpecFileOperationEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualDeviceConfigSpecFileOperationEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_DEVICE_CONFIG_SPEC_OPERATION_ENUM_MAP: phf::Map<&'static str, VirtualDeviceConfigSpecOperationEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("add", VirtualDeviceConfigSpecOperationEnum::Add),
        ("edit", VirtualDeviceConfigSpecOperationEnum::Edit),
        ("remove", VirtualDeviceConfigSpecOperationEnum::Remove),
    ],
};

impl VirtualDeviceConfigSpecOperationEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualDeviceConfigSpecOperationEnum::Add => "add",
            VirtualDeviceConfigSpecOperationEnum::Remove => "remove",
            VirtualDeviceConfigSpecOperationEnum::Edit => "edit",
            VirtualDeviceConfigSpecOperationEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_DEVICE_CONFIG_SPEC_OPERATION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualDeviceConfigSpecOperationEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualDeviceConfigSpecOperationEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualDeviceConfigSpecOperationEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualDeviceConfigSpecOperationEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualDeviceConfigSpecOperationEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualDeviceConfigSpecOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualDeviceConfigSpecOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualDeviceConfigSpecOperationEnum> for &'a str {
    fn from(value: &'a VirtualDeviceConfigSpecOperationEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualDeviceConfigSpecOperationEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_DISK_DELTA_DISK_FORMAT_ENUM_MAP: phf::Map<&'static str, VirtualDiskDeltaDiskFormatEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("nativeFormat", VirtualDiskDeltaDiskFormatEnum::NativeFormat),
        ("seSparseFormat", VirtualDiskDeltaDiskFormatEnum::SeSparseFormat),
        ("redoLogFormat", VirtualDiskDeltaDiskFormatEnum::RedoLogFormat),
    ],
};

impl VirtualDiskDeltaDiskFormatEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualDiskDeltaDiskFormatEnum::RedoLogFormat => "redoLogFormat",
            VirtualDiskDeltaDiskFormatEnum::NativeFormat => "nativeFormat",
            VirtualDiskDeltaDiskFormatEnum::SeSparseFormat => "seSparseFormat",
            VirtualDiskDeltaDiskFormatEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_DISK_DELTA_DISK_FORMAT_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualDiskDeltaDiskFormatEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualDiskDeltaDiskFormatEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualDiskDeltaDiskFormatEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualDiskDeltaDiskFormatEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualDiskDeltaDiskFormatEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualDiskDeltaDiskFormatEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualDiskDeltaDiskFormatEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualDiskDeltaDiskFormatEnum> for &'a str {
    fn from(value: &'a VirtualDiskDeltaDiskFormatEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualDiskDeltaDiskFormatEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_DISK_DELTA_DISK_FORMAT_VARIANT_ENUM_MAP: phf::Map<&'static str, VirtualDiskDeltaDiskFormatVariantEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("vmfsSparseVariant", VirtualDiskDeltaDiskFormatVariantEnum::VmfsSparseVariant),
        ("vsanSparseVariant", VirtualDiskDeltaDiskFormatVariantEnum::VsanSparseVariant),
    ],
};

impl VirtualDiskDeltaDiskFormatVariantEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualDiskDeltaDiskFormatVariantEnum::VmfsSparseVariant => "vmfsSparseVariant",
            VirtualDiskDeltaDiskFormatVariantEnum::VsanSparseVariant => "vsanSparseVariant",
            VirtualDiskDeltaDiskFormatVariantEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_DISK_DELTA_DISK_FORMAT_VARIANT_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualDiskDeltaDiskFormatVariantEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualDiskDeltaDiskFormatVariantEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualDiskDeltaDiskFormatVariantEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualDiskDeltaDiskFormatVariantEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualDiskDeltaDiskFormatVariantEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualDiskDeltaDiskFormatVariantEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualDiskDeltaDiskFormatVariantEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualDiskDeltaDiskFormatVariantEnum> for &'a str {
    fn from(value: &'a VirtualDiskDeltaDiskFormatVariantEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualDiskDeltaDiskFormatVariantEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_DISK_SHARING_ENUM_MAP: phf::Map<&'static str, VirtualDiskSharingEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("sharingMultiWriter", VirtualDiskSharingEnum::SharingMultiWriter),
        ("sharingNone", VirtualDiskSharingEnum::SharingNone),
    ],
};

impl VirtualDiskSharingEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualDiskSharingEnum::SharingNone => "sharingNone",
            VirtualDiskSharingEnum::SharingMultiWriter => "sharingMultiWriter",
            VirtualDiskSharingEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_DISK_SHARING_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualDiskSharingEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualDiskSharingEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualDiskSharingEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualDiskSharingEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualDiskSharingEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualDiskSharingEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualDiskSharingEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualDiskSharingEnum> for &'a str {
    fn from(value: &'a VirtualDiskSharingEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualDiskSharingEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_DISK_V_FLASH_CACHE_CONFIG_INFO_CACHE_CONSISTENCY_TYPE_ENUM_MAP: phf::Map<&'static str, VirtualDiskVFlashCacheConfigInfoCacheConsistencyTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("strong", VirtualDiskVFlashCacheConfigInfoCacheConsistencyTypeEnum::Strong),
        ("weak", VirtualDiskVFlashCacheConfigInfoCacheConsistencyTypeEnum::Weak),
    ],
};

impl VirtualDiskVFlashCacheConfigInfoCacheConsistencyTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualDiskVFlashCacheConfigInfoCacheConsistencyTypeEnum::Strong => "strong",
            VirtualDiskVFlashCacheConfigInfoCacheConsistencyTypeEnum::Weak => "weak",
            VirtualDiskVFlashCacheConfigInfoCacheConsistencyTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_DISK_V_FLASH_CACHE_CONFIG_INFO_CACHE_CONSISTENCY_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualDiskVFlashCacheConfigInfoCacheConsistencyTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualDiskVFlashCacheConfigInfoCacheConsistencyTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualDiskVFlashCacheConfigInfoCacheConsistencyTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualDiskVFlashCacheConfigInfoCacheConsistencyTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualDiskVFlashCacheConfigInfoCacheConsistencyTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualDiskVFlashCacheConfigInfoCacheConsistencyTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualDiskVFlashCacheConfigInfoCacheConsistencyTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualDiskVFlashCacheConfigInfoCacheConsistencyTypeEnum> for &'a str {
    fn from(value: &'a VirtualDiskVFlashCacheConfigInfoCacheConsistencyTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualDiskVFlashCacheConfigInfoCacheConsistencyTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_DISK_V_FLASH_CACHE_CONFIG_INFO_CACHE_MODE_ENUM_MAP: phf::Map<&'static str, VirtualDiskVFlashCacheConfigInfoCacheModeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("write_thru", VirtualDiskVFlashCacheConfigInfoCacheModeEnum::WriteThru),
        ("write_back", VirtualDiskVFlashCacheConfigInfoCacheModeEnum::WriteBack),
    ],
};

impl VirtualDiskVFlashCacheConfigInfoCacheModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualDiskVFlashCacheConfigInfoCacheModeEnum::WriteThru => "write_thru",
            VirtualDiskVFlashCacheConfigInfoCacheModeEnum::WriteBack => "write_back",
            VirtualDiskVFlashCacheConfigInfoCacheModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_DISK_V_FLASH_CACHE_CONFIG_INFO_CACHE_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualDiskVFlashCacheConfigInfoCacheModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualDiskVFlashCacheConfigInfoCacheModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualDiskVFlashCacheConfigInfoCacheModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualDiskVFlashCacheConfigInfoCacheModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualDiskVFlashCacheConfigInfoCacheModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualDiskVFlashCacheConfigInfoCacheModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualDiskVFlashCacheConfigInfoCacheModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualDiskVFlashCacheConfigInfoCacheModeEnum> for &'a str {
    fn from(value: &'a VirtualDiskVFlashCacheConfigInfoCacheModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualDiskVFlashCacheConfigInfoCacheModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_DISK_COMPATIBILITY_MODE_ENUM_MAP: phf::Map<&'static str, VirtualDiskCompatibilityModeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("virtualMode", VirtualDiskCompatibilityModeEnum::VirtualMode),
        ("physicalMode", VirtualDiskCompatibilityModeEnum::PhysicalMode),
    ],
};

impl VirtualDiskCompatibilityModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualDiskCompatibilityModeEnum::VirtualMode => "virtualMode",
            VirtualDiskCompatibilityModeEnum::PhysicalMode => "physicalMode",
            VirtualDiskCompatibilityModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_DISK_COMPATIBILITY_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualDiskCompatibilityModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualDiskCompatibilityModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualDiskCompatibilityModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualDiskCompatibilityModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualDiskCompatibilityModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualDiskCompatibilityModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualDiskCompatibilityModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualDiskCompatibilityModeEnum> for &'a str {
    fn from(value: &'a VirtualDiskCompatibilityModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualDiskCompatibilityModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_DISK_MODE_ENUM_MAP: phf::Map<&'static str, VirtualDiskModeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (3, 0),
        (0, 4),
    ],
    entries: &[
        ("append", VirtualDiskModeEnum::Append),
        ("independent_nonpersistent", VirtualDiskModeEnum::IndependentNonpersistent),
        ("independent_persistent", VirtualDiskModeEnum::IndependentPersistent),
        ("nonpersistent", VirtualDiskModeEnum::Nonpersistent),
        ("persistent", VirtualDiskModeEnum::Persistent),
        ("undoable", VirtualDiskModeEnum::Undoable),
    ],
};

impl VirtualDiskModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualDiskModeEnum::Persistent => "persistent",
            VirtualDiskModeEnum::Nonpersistent => "nonpersistent",
            VirtualDiskModeEnum::Undoable => "undoable",
            VirtualDiskModeEnum::IndependentPersistent => "independent_persistent",
            VirtualDiskModeEnum::IndependentNonpersistent => "independent_nonpersistent",
            VirtualDiskModeEnum::Append => "append",
            VirtualDiskModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_DISK_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualDiskModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualDiskModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualDiskModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualDiskModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualDiskModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualDiskModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualDiskModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualDiskModeEnum> for &'a str {
    fn from(value: &'a VirtualDiskModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualDiskModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_ETHERNET_CARD_LEGACY_NETWORK_DEVICE_NAME_ENUM_MAP: phf::Map<&'static str, VirtualEthernetCardLegacyNetworkDeviceNameEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("hostonly", VirtualEthernetCardLegacyNetworkDeviceNameEnum::Hostonly),
        ("nat", VirtualEthernetCardLegacyNetworkDeviceNameEnum::Nat),
        ("bridged", VirtualEthernetCardLegacyNetworkDeviceNameEnum::Bridged),
    ],
};

impl VirtualEthernetCardLegacyNetworkDeviceNameEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualEthernetCardLegacyNetworkDeviceNameEnum::Bridged => "bridged",
            VirtualEthernetCardLegacyNetworkDeviceNameEnum::Nat => "nat",
            VirtualEthernetCardLegacyNetworkDeviceNameEnum::Hostonly => "hostonly",
            VirtualEthernetCardLegacyNetworkDeviceNameEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_ETHERNET_CARD_LEGACY_NETWORK_DEVICE_NAME_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualEthernetCardLegacyNetworkDeviceNameEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualEthernetCardLegacyNetworkDeviceNameEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualEthernetCardLegacyNetworkDeviceNameEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualEthernetCardLegacyNetworkDeviceNameEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualEthernetCardLegacyNetworkDeviceNameEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualEthernetCardLegacyNetworkDeviceNameEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualEthernetCardLegacyNetworkDeviceNameEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualEthernetCardLegacyNetworkDeviceNameEnum> for &'a str {
    fn from(value: &'a VirtualEthernetCardLegacyNetworkDeviceNameEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualEthernetCardLegacyNetworkDeviceNameEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_ETHERNET_CARD_MAC_TYPE_ENUM_MAP: phf::Map<&'static str, VirtualEthernetCardMacTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("generated", VirtualEthernetCardMacTypeEnum::Generated),
        ("assigned", VirtualEthernetCardMacTypeEnum::Assigned),
        ("manual", VirtualEthernetCardMacTypeEnum::Manual),
    ],
};

impl VirtualEthernetCardMacTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualEthernetCardMacTypeEnum::Manual => "manual",
            VirtualEthernetCardMacTypeEnum::Generated => "generated",
            VirtualEthernetCardMacTypeEnum::Assigned => "assigned",
            VirtualEthernetCardMacTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_ETHERNET_CARD_MAC_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualEthernetCardMacTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualEthernetCardMacTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualEthernetCardMacTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualEthernetCardMacTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualEthernetCardMacTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualEthernetCardMacTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualEthernetCardMacTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualEthernetCardMacTypeEnum> for &'a str {
    fn from(value: &'a VirtualEthernetCardMacTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualEthernetCardMacTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_NVME_CONTROLLER_SHARING_ENUM_MAP: phf::Map<&'static str, VirtualNvmeControllerSharingEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("noSharing", VirtualNvmeControllerSharingEnum::NoSharing),
        ("physicalSharing", VirtualNvmeControllerSharingEnum::PhysicalSharing),
    ],
};

impl VirtualNvmeControllerSharingEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualNvmeControllerSharingEnum::NoSharing => "noSharing",
            VirtualNvmeControllerSharingEnum::PhysicalSharing => "physicalSharing",
            VirtualNvmeControllerSharingEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_NVME_CONTROLLER_SHARING_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualNvmeControllerSharingEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualNvmeControllerSharingEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualNvmeControllerSharingEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualNvmeControllerSharingEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualNvmeControllerSharingEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualNvmeControllerSharingEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualNvmeControllerSharingEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualNvmeControllerSharingEnum> for &'a str {
    fn from(value: &'a VirtualNvmeControllerSharingEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualNvmeControllerSharingEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_POINTING_DEVICE_HOST_CHOICE_ENUM_MAP: phf::Map<&'static str, VirtualPointingDeviceHostChoiceEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 4),
        (4, 0),
    ],
    entries: &[
        ("ps2", VirtualPointingDeviceHostChoiceEnum::Ps2),
        ("intellimouseExplorer", VirtualPointingDeviceHostChoiceEnum::IntellimouseExplorer),
        ("microsoft_serial", VirtualPointingDeviceHostChoiceEnum::MicrosoftSerial),
        ("logitechMouseman", VirtualPointingDeviceHostChoiceEnum::LogitechMouseman),
        ("mousemanSerial", VirtualPointingDeviceHostChoiceEnum::MousemanSerial),
        ("autodetect", VirtualPointingDeviceHostChoiceEnum::Autodetect),
        ("intellimousePs2", VirtualPointingDeviceHostChoiceEnum::IntellimousePs2),
        ("mouseSystems", VirtualPointingDeviceHostChoiceEnum::MouseSystems),
    ],
};

impl VirtualPointingDeviceHostChoiceEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualPointingDeviceHostChoiceEnum::Autodetect => "autodetect",
            VirtualPointingDeviceHostChoiceEnum::IntellimouseExplorer => "intellimouseExplorer",
            VirtualPointingDeviceHostChoiceEnum::IntellimousePs2 => "intellimousePs2",
            VirtualPointingDeviceHostChoiceEnum::LogitechMouseman => "logitechMouseman",
            VirtualPointingDeviceHostChoiceEnum::MicrosoftSerial => "microsoft_serial",
            VirtualPointingDeviceHostChoiceEnum::MouseSystems => "mouseSystems",
            VirtualPointingDeviceHostChoiceEnum::MousemanSerial => "mousemanSerial",
            VirtualPointingDeviceHostChoiceEnum::Ps2 => "ps2",
            VirtualPointingDeviceHostChoiceEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_POINTING_DEVICE_HOST_CHOICE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualPointingDeviceHostChoiceEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualPointingDeviceHostChoiceEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualPointingDeviceHostChoiceEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualPointingDeviceHostChoiceEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualPointingDeviceHostChoiceEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualPointingDeviceHostChoiceEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualPointingDeviceHostChoiceEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualPointingDeviceHostChoiceEnum> for &'a str {
    fn from(value: &'a VirtualPointingDeviceHostChoiceEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualPointingDeviceHostChoiceEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_SCSI_SHARING_ENUM_MAP: phf::Map<&'static str, VirtualScsiSharingEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("physicalSharing", VirtualScsiSharingEnum::PhysicalSharing),
        ("noSharing", VirtualScsiSharingEnum::NoSharing),
        ("virtualSharing", VirtualScsiSharingEnum::VirtualSharing),
    ],
};

impl VirtualScsiSharingEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualScsiSharingEnum::NoSharing => "noSharing",
            VirtualScsiSharingEnum::VirtualSharing => "virtualSharing",
            VirtualScsiSharingEnum::PhysicalSharing => "physicalSharing",
            VirtualScsiSharingEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_SCSI_SHARING_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualScsiSharingEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualScsiSharingEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualScsiSharingEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualScsiSharingEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualScsiSharingEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualScsiSharingEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualScsiSharingEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualScsiSharingEnum> for &'a str {
    fn from(value: &'a VirtualScsiSharingEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualScsiSharingEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_SERIAL_PORT_END_POINT_ENUM_MAP: phf::Map<&'static str, VirtualSerialPortEndPointEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("server", VirtualSerialPortEndPointEnum::Server),
        ("client", VirtualSerialPortEndPointEnum::Client),
    ],
};

impl VirtualSerialPortEndPointEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualSerialPortEndPointEnum::Client => "client",
            VirtualSerialPortEndPointEnum::Server => "server",
            VirtualSerialPortEndPointEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_SERIAL_PORT_END_POINT_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualSerialPortEndPointEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualSerialPortEndPointEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualSerialPortEndPointEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualSerialPortEndPointEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualSerialPortEndPointEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualSerialPortEndPointEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualSerialPortEndPointEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualSerialPortEndPointEnum> for &'a str {
    fn from(value: &'a VirtualSerialPortEndPointEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualSerialPortEndPointEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_VMCI_DEVICE_ACTION_ENUM_MAP: phf::Map<&'static str, VirtualMachineVmciDeviceActionEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("allow", VirtualMachineVmciDeviceActionEnum::Allow),
        ("deny", VirtualMachineVmciDeviceActionEnum::Deny),
    ],
};

impl VirtualMachineVmciDeviceActionEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineVmciDeviceActionEnum::Allow => "allow",
            VirtualMachineVmciDeviceActionEnum::Deny => "deny",
            VirtualMachineVmciDeviceActionEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_VMCI_DEVICE_ACTION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineVmciDeviceActionEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineVmciDeviceActionEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineVmciDeviceActionEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineVmciDeviceActionEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineVmciDeviceActionEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineVmciDeviceActionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineVmciDeviceActionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineVmciDeviceActionEnum> for &'a str {
    fn from(value: &'a VirtualMachineVmciDeviceActionEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineVmciDeviceActionEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_VMCI_DEVICE_DIRECTION_ENUM_MAP: phf::Map<&'static str, VirtualMachineVmciDeviceDirectionEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("anyDirection", VirtualMachineVmciDeviceDirectionEnum::AnyDirection),
        ("host", VirtualMachineVmciDeviceDirectionEnum::Host),
        ("guest", VirtualMachineVmciDeviceDirectionEnum::Guest),
    ],
};

impl VirtualMachineVmciDeviceDirectionEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineVmciDeviceDirectionEnum::Guest => "guest",
            VirtualMachineVmciDeviceDirectionEnum::Host => "host",
            VirtualMachineVmciDeviceDirectionEnum::AnyDirection => "anyDirection",
            VirtualMachineVmciDeviceDirectionEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_VMCI_DEVICE_DIRECTION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineVmciDeviceDirectionEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineVmciDeviceDirectionEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineVmciDeviceDirectionEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineVmciDeviceDirectionEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineVmciDeviceDirectionEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineVmciDeviceDirectionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineVmciDeviceDirectionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineVmciDeviceDirectionEnum> for &'a str {
    fn from(value: &'a VirtualMachineVmciDeviceDirectionEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineVmciDeviceDirectionEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_VMCI_DEVICE_PROTOCOL_ENUM_MAP: phf::Map<&'static str, VirtualMachineVmciDeviceProtocolEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (3, 0),
        (1, 0),
    ],
    entries: &[
        ("datagram", VirtualMachineVmciDeviceProtocolEnum::Datagram),
        ("stream", VirtualMachineVmciDeviceProtocolEnum::Stream),
        ("doorbell", VirtualMachineVmciDeviceProtocolEnum::Doorbell),
        ("queuepair", VirtualMachineVmciDeviceProtocolEnum::Queuepair),
        ("hypervisor", VirtualMachineVmciDeviceProtocolEnum::Hypervisor),
        ("anyProtocol", VirtualMachineVmciDeviceProtocolEnum::AnyProtocol),
    ],
};

impl VirtualMachineVmciDeviceProtocolEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineVmciDeviceProtocolEnum::Hypervisor => "hypervisor",
            VirtualMachineVmciDeviceProtocolEnum::Doorbell => "doorbell",
            VirtualMachineVmciDeviceProtocolEnum::Queuepair => "queuepair",
            VirtualMachineVmciDeviceProtocolEnum::Datagram => "datagram",
            VirtualMachineVmciDeviceProtocolEnum::Stream => "stream",
            VirtualMachineVmciDeviceProtocolEnum::AnyProtocol => "anyProtocol",
            VirtualMachineVmciDeviceProtocolEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_VMCI_DEVICE_PROTOCOL_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineVmciDeviceProtocolEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineVmciDeviceProtocolEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineVmciDeviceProtocolEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineVmciDeviceProtocolEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineVmciDeviceProtocolEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineVmciDeviceProtocolEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineVmciDeviceProtocolEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineVmciDeviceProtocolEnum> for &'a str {
    fn from(value: &'a VirtualMachineVmciDeviceProtocolEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineVmciDeviceProtocolEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_MACHINE_VIDEO_CARD_USE_3_D_RENDERER_ENUM_MAP: phf::Map<&'static str, VirtualMachineVideoCardUse3DRendererEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("software", VirtualMachineVideoCardUse3DRendererEnum::Software),
        ("hardware", VirtualMachineVideoCardUse3DRendererEnum::Hardware),
        ("automatic", VirtualMachineVideoCardUse3DRendererEnum::Automatic),
    ],
};

impl VirtualMachineVideoCardUse3DRendererEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualMachineVideoCardUse3DRendererEnum::Automatic => "automatic",
            VirtualMachineVideoCardUse3DRendererEnum::Software => "software",
            VirtualMachineVideoCardUse3DRendererEnum::Hardware => "hardware",
            VirtualMachineVideoCardUse3DRendererEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_MACHINE_VIDEO_CARD_USE_3_D_RENDERER_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualMachineVideoCardUse3DRendererEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualMachineVideoCardUse3DRendererEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualMachineVideoCardUse3DRendererEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualMachineVideoCardUse3DRendererEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualMachineVideoCardUse3DRendererEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualMachineVideoCardUse3DRendererEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualMachineVideoCardUse3DRendererEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualMachineVideoCardUse3DRendererEnum> for &'a str {
    fn from(value: &'a VirtualMachineVideoCardUse3DRendererEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualMachineVideoCardUse3DRendererEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_VMXNET_3_STRICT_LATENCY_CONFIG_DISABLE_OFFLOAD_ENUM_MAP: phf::Map<&'static str, VirtualVmxnet3StrictLatencyConfigDisableOffloadEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("TSO_LRO", VirtualVmxnet3StrictLatencyConfigDisableOffloadEnum::TsoLro),
        ("NONE", VirtualVmxnet3StrictLatencyConfigDisableOffloadEnum::None),
        ("LRO", VirtualVmxnet3StrictLatencyConfigDisableOffloadEnum::Lro),
        ("TSO", VirtualVmxnet3StrictLatencyConfigDisableOffloadEnum::Tso),
    ],
};

impl VirtualVmxnet3StrictLatencyConfigDisableOffloadEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualVmxnet3StrictLatencyConfigDisableOffloadEnum::None => "NONE",
            VirtualVmxnet3StrictLatencyConfigDisableOffloadEnum::Tso => "TSO",
            VirtualVmxnet3StrictLatencyConfigDisableOffloadEnum::Lro => "LRO",
            VirtualVmxnet3StrictLatencyConfigDisableOffloadEnum::TsoLro => "TSO_LRO",
            VirtualVmxnet3StrictLatencyConfigDisableOffloadEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_VMXNET_3_STRICT_LATENCY_CONFIG_DISABLE_OFFLOAD_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualVmxnet3StrictLatencyConfigDisableOffloadEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualVmxnet3StrictLatencyConfigDisableOffloadEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualVmxnet3StrictLatencyConfigDisableOffloadEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualVmxnet3StrictLatencyConfigDisableOffloadEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualVmxnet3StrictLatencyConfigDisableOffloadEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualVmxnet3StrictLatencyConfigDisableOffloadEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualVmxnet3StrictLatencyConfigDisableOffloadEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualVmxnet3StrictLatencyConfigDisableOffloadEnum> for &'a str {
    fn from(value: &'a VirtualVmxnet3StrictLatencyConfigDisableOffloadEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualVmxnet3StrictLatencyConfigDisableOffloadEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIRTUAL_VMXNET_3_VRDMA_OPTION_DEVICE_PROTOCOLS_ENUM_MAP: phf::Map<&'static str, VirtualVmxnet3VrdmaOptionDeviceProtocolsEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("rocev1", VirtualVmxnet3VrdmaOptionDeviceProtocolsEnum::Rocev1),
        ("rocev2", VirtualVmxnet3VrdmaOptionDeviceProtocolsEnum::Rocev2),
    ],
};

impl VirtualVmxnet3VrdmaOptionDeviceProtocolsEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VirtualVmxnet3VrdmaOptionDeviceProtocolsEnum::Rocev1 => "rocev1",
            VirtualVmxnet3VrdmaOptionDeviceProtocolsEnum::Rocev2 => "rocev2",
            VirtualVmxnet3VrdmaOptionDeviceProtocolsEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIRTUAL_VMXNET_3_VRDMA_OPTION_DEVICE_PROTOCOLS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VirtualVmxnet3VrdmaOptionDeviceProtocolsEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VirtualVmxnet3VrdmaOptionDeviceProtocolsEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VirtualVmxnet3VrdmaOptionDeviceProtocolsEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VirtualVmxnet3VrdmaOptionDeviceProtocolsEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VirtualVmxnet3VrdmaOptionDeviceProtocolsEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VirtualVmxnet3VrdmaOptionDeviceProtocolsEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VirtualVmxnet3VrdmaOptionDeviceProtocolsEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VirtualVmxnet3VrdmaOptionDeviceProtocolsEnum> for &'a str {
    fn from(value: &'a VirtualVmxnet3VrdmaOptionDeviceProtocolsEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VirtualVmxnet3VrdmaOptionDeviceProtocolsEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static GUEST_FILE_TYPE_ENUM_MAP: phf::Map<&'static str, GuestFileTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("directory", GuestFileTypeEnum::Directory),
        ("symlink", GuestFileTypeEnum::Symlink),
        ("file", GuestFileTypeEnum::File),
    ],
};

impl GuestFileTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            GuestFileTypeEnum::File => "file",
            GuestFileTypeEnum::Directory => "directory",
            GuestFileTypeEnum::Symlink => "symlink",
            GuestFileTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        GUEST_FILE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| GuestFileTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for GuestFileTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for GuestFileTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<GuestFileTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(GuestFileTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for GuestFileTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for GuestFileTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a GuestFileTypeEnum> for &'a str {
    fn from(value: &'a GuestFileTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for GuestFileTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static GUEST_REG_KEY_WOW_SPEC_ENUM_MAP: phf::Map<&'static str, GuestRegKeyWowSpecEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("WOW64", GuestRegKeyWowSpecEnum::Wow64),
        ("WOWNative", GuestRegKeyWowSpecEnum::WowNative),
        ("WOW32", GuestRegKeyWowSpecEnum::Wow32),
    ],
};

impl GuestRegKeyWowSpecEnum {
    pub fn as_str(&self) -> &str {
        match self {
            GuestRegKeyWowSpecEnum::WowNative => "WOWNative",
            GuestRegKeyWowSpecEnum::Wow32 => "WOW32",
            GuestRegKeyWowSpecEnum::Wow64 => "WOW64",
            GuestRegKeyWowSpecEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        GUEST_REG_KEY_WOW_SPEC_ENUM_MAP.get(s).cloned().unwrap_or_else(|| GuestRegKeyWowSpecEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for GuestRegKeyWowSpecEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for GuestRegKeyWowSpecEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<GuestRegKeyWowSpecEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(GuestRegKeyWowSpecEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for GuestRegKeyWowSpecEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for GuestRegKeyWowSpecEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a GuestRegKeyWowSpecEnum> for &'a str {
    fn from(value: &'a GuestRegKeyWowSpecEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for GuestRegKeyWowSpecEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_CAPACITY_RESERVATION_STATE_ENUM_MAP: phf::Map<&'static str, VsanCapacityReservationStateEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("Enforced", VsanCapacityReservationStateEnum::Enforced),
        ("State_Unknown", VsanCapacityReservationStateEnum::StateUnknown),
        ("Disabled", VsanCapacityReservationStateEnum::Disabled),
        ("Reported", VsanCapacityReservationStateEnum::Reported),
        ("Unsupported", VsanCapacityReservationStateEnum::Unsupported),
    ],
};

impl VsanCapacityReservationStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanCapacityReservationStateEnum::StateUnknown => "State_Unknown",
            VsanCapacityReservationStateEnum::Enforced => "Enforced",
            VsanCapacityReservationStateEnum::Reported => "Reported",
            VsanCapacityReservationStateEnum::Disabled => "Disabled",
            VsanCapacityReservationStateEnum::Unsupported => "Unsupported",
            VsanCapacityReservationStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_CAPACITY_RESERVATION_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanCapacityReservationStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanCapacityReservationStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanCapacityReservationStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanCapacityReservationStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanCapacityReservationStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanCapacityReservationStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanCapacityReservationStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanCapacityReservationStateEnum> for &'a str {
    fn from(value: &'a VsanCapacityReservationStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanCapacityReservationStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_FILE_SERVICE_CONFIG_OP_TYPE_ENUM_MAP: phf::Map<&'static str, VsanFileServiceConfigOpTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("CleanAffinityLocation", VsanFileServiceConfigOpTypeEnum::CleanAffinityLocation),
        ("FileServiceConfigOpType_Unknown", VsanFileServiceConfigOpTypeEnum::FileServiceConfigOpTypeUnknown),
    ],
};

impl VsanFileServiceConfigOpTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanFileServiceConfigOpTypeEnum::CleanAffinityLocation => "CleanAffinityLocation",
            VsanFileServiceConfigOpTypeEnum::FileServiceConfigOpTypeUnknown => "FileServiceConfigOpType_Unknown",
            VsanFileServiceConfigOpTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_FILE_SERVICE_CONFIG_OP_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanFileServiceConfigOpTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanFileServiceConfigOpTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanFileServiceConfigOpTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanFileServiceConfigOpTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanFileServiceConfigOpTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanFileServiceConfigOpTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanFileServiceConfigOpTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanFileServiceConfigOpTypeEnum> for &'a str {
    fn from(value: &'a VsanFileServiceConfigOpTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanFileServiceConfigOpTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_FILE_SERVICE_PREFLIGHT_CHECK_SCOPE_ENUM_MAP: phf::Map<&'static str, VsanFileServicePreflightCheckScopeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("basic", VsanFileServicePreflightCheckScopeEnum::Basic),
        ("advanced", VsanFileServicePreflightCheckScopeEnum::Advanced),
        ("FileServicePreflightCheckScope_Unknown", VsanFileServicePreflightCheckScopeEnum::FileServicePreflightCheckScopeUnknown),
    ],
};

impl VsanFileServicePreflightCheckScopeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanFileServicePreflightCheckScopeEnum::Basic => "basic",
            VsanFileServicePreflightCheckScopeEnum::Advanced => "advanced",
            VsanFileServicePreflightCheckScopeEnum::FileServicePreflightCheckScopeUnknown => "FileServicePreflightCheckScope_Unknown",
            VsanFileServicePreflightCheckScopeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_FILE_SERVICE_PREFLIGHT_CHECK_SCOPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanFileServicePreflightCheckScopeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanFileServicePreflightCheckScopeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanFileServicePreflightCheckScopeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanFileServicePreflightCheckScopeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanFileServicePreflightCheckScopeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanFileServicePreflightCheckScopeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanFileServicePreflightCheckScopeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanFileServicePreflightCheckScopeEnum> for &'a str {
    fn from(value: &'a VsanFileServicePreflightCheckScopeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanFileServicePreflightCheckScopeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_FILE_SERVICE_VM_STATUS_ENUM_MAP: phf::Map<&'static str, VsanFileServiceVmStatusEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("upgrading", VsanFileServiceVmStatusEnum::Upgrading),
        ("running", VsanFileServiceVmStatusEnum::Running),
        ("FileServiceVMStatus_Unknown", VsanFileServiceVmStatusEnum::FileServiceVmStatusUnknown),
    ],
};

impl VsanFileServiceVmStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanFileServiceVmStatusEnum::Running => "running",
            VsanFileServiceVmStatusEnum::Upgrading => "upgrading",
            VsanFileServiceVmStatusEnum::FileServiceVmStatusUnknown => "FileServiceVMStatus_Unknown",
            VsanFileServiceVmStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_FILE_SERVICE_VM_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanFileServiceVmStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanFileServiceVmStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanFileServiceVmStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanFileServiceVmStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanFileServiceVmStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanFileServiceVmStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanFileServiceVmStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanFileServiceVmStatusEnum> for &'a str {
    fn from(value: &'a VsanFileServiceVmStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanFileServiceVmStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_FILE_SHARE_ACCESS_TYPE_ENUM_MAP: phf::Map<&'static str, VsanFileShareAccessTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (3, 0),
    ],
    entries: &[
        ("NO_ACCESS", VsanFileShareAccessTypeEnum::NoAccess),
        ("FileShareAccessType_Unknown", VsanFileShareAccessTypeEnum::FileShareAccessTypeUnknown),
        ("READ_WRITE", VsanFileShareAccessTypeEnum::ReadWrite),
        ("READ_ONLY", VsanFileShareAccessTypeEnum::ReadOnly),
    ],
};

impl VsanFileShareAccessTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanFileShareAccessTypeEnum::ReadOnly => "READ_ONLY",
            VsanFileShareAccessTypeEnum::ReadWrite => "READ_WRITE",
            VsanFileShareAccessTypeEnum::NoAccess => "NO_ACCESS",
            VsanFileShareAccessTypeEnum::FileShareAccessTypeUnknown => "FileShareAccessType_Unknown",
            VsanFileShareAccessTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_FILE_SHARE_ACCESS_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanFileShareAccessTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanFileShareAccessTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanFileShareAccessTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanFileShareAccessTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanFileShareAccessTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanFileShareAccessTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanFileShareAccessTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanFileShareAccessTypeEnum> for &'a str {
    fn from(value: &'a VsanFileShareAccessTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanFileShareAccessTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_FILE_SHARE_MANAGING_ENTITY_ENUM_MAP: phf::Map<&'static str, VsanFileShareManagingEntityEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("user", VsanFileShareManagingEntityEnum::User),
        ("cns", VsanFileShareManagingEntityEnum::Cns),
        ("FileShareManagingEntity_Unknown", VsanFileShareManagingEntityEnum::FileShareManagingEntityUnknown),
    ],
};

impl VsanFileShareManagingEntityEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanFileShareManagingEntityEnum::Cns => "cns",
            VsanFileShareManagingEntityEnum::User => "user",
            VsanFileShareManagingEntityEnum::FileShareManagingEntityUnknown => "FileShareManagingEntity_Unknown",
            VsanFileShareManagingEntityEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_FILE_SHARE_MANAGING_ENTITY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanFileShareManagingEntityEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanFileShareManagingEntityEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanFileShareManagingEntityEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanFileShareManagingEntityEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanFileShareManagingEntityEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanFileShareManagingEntityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanFileShareManagingEntityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanFileShareManagingEntityEnum> for &'a str {
    fn from(value: &'a VsanFileShareManagingEntityEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanFileShareManagingEntityEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_FILE_SHARE_NFS_SEC_TYPE_ENUM_MAP: phf::Map<&'static str, VsanFileShareNfsSecTypeEnum> = ::phf::Map {
    key: 12213676231523076107,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("FileShareNfsSecType_Unknown", VsanFileShareNfsSecTypeEnum::FileShareNfsSecTypeUnknown),
        ("SYS", VsanFileShareNfsSecTypeEnum::Sys),
        ("KRB5I", VsanFileShareNfsSecTypeEnum::Krb5I),
        ("KRB5", VsanFileShareNfsSecTypeEnum::Krb5),
        ("KRB5P", VsanFileShareNfsSecTypeEnum::Krb5P),
    ],
};

impl VsanFileShareNfsSecTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanFileShareNfsSecTypeEnum::Sys => "SYS",
            VsanFileShareNfsSecTypeEnum::Krb5 => "KRB5",
            VsanFileShareNfsSecTypeEnum::Krb5I => "KRB5I",
            VsanFileShareNfsSecTypeEnum::Krb5P => "KRB5P",
            VsanFileShareNfsSecTypeEnum::FileShareNfsSecTypeUnknown => "FileShareNfsSecType_Unknown",
            VsanFileShareNfsSecTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_FILE_SHARE_NFS_SEC_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanFileShareNfsSecTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanFileShareNfsSecTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanFileShareNfsSecTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanFileShareNfsSecTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanFileShareNfsSecTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanFileShareNfsSecTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanFileShareNfsSecTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanFileShareNfsSecTypeEnum> for &'a str {
    fn from(value: &'a VsanFileShareNfsSecTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanFileShareNfsSecTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_FILE_PROTOCOL_ENUM_MAP: phf::Map<&'static str, VsanFileProtocolEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("NFSv4", VsanFileProtocolEnum::NfSv4),
        ("SMB", VsanFileProtocolEnum::Smb),
        ("NFSv3", VsanFileProtocolEnum::NfSv3),
        ("FileShareProtocol_Unknown", VsanFileProtocolEnum::FileShareProtocolUnknown),
    ],
};

impl VsanFileProtocolEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanFileProtocolEnum::NfSv3 => "NFSv3",
            VsanFileProtocolEnum::NfSv4 => "NFSv4",
            VsanFileProtocolEnum::Smb => "SMB",
            VsanFileProtocolEnum::FileShareProtocolUnknown => "FileShareProtocol_Unknown",
            VsanFileProtocolEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_FILE_PROTOCOL_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanFileProtocolEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanFileProtocolEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanFileProtocolEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanFileProtocolEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanFileProtocolEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanFileProtocolEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanFileProtocolEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanFileProtocolEnum> for &'a str {
    fn from(value: &'a VsanFileProtocolEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanFileProtocolEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_FILE_SHARE_SMB_ENCRYPTION_TYPE_ENUM_MAP: phf::Map<&'static str, VsanFileShareSmbEncryptionTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("mandatory", VsanFileShareSmbEncryptionTypeEnum::Mandatory),
        ("FileShareSmbEncryptionType_Unknown", VsanFileShareSmbEncryptionTypeEnum::FileShareSmbEncryptionTypeUnknown),
        ("disabled", VsanFileShareSmbEncryptionTypeEnum::Disabled),
    ],
};

impl VsanFileShareSmbEncryptionTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanFileShareSmbEncryptionTypeEnum::Disabled => "disabled",
            VsanFileShareSmbEncryptionTypeEnum::Mandatory => "mandatory",
            VsanFileShareSmbEncryptionTypeEnum::FileShareSmbEncryptionTypeUnknown => "FileShareSmbEncryptionType_Unknown",
            VsanFileShareSmbEncryptionTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_FILE_SHARE_SMB_ENCRYPTION_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanFileShareSmbEncryptionTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanFileShareSmbEncryptionTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanFileShareSmbEncryptionTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanFileShareSmbEncryptionTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanFileShareSmbEncryptionTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanFileShareSmbEncryptionTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanFileShareSmbEncryptionTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanFileShareSmbEncryptionTypeEnum> for &'a str {
    fn from(value: &'a VsanFileShareSmbEncryptionTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanFileShareSmbEncryptionTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static HCI_MESH_CLIENT_OPERATION_ENUM_MAP: phf::Map<&'static str, HciMeshClientOperationEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (3, 0),
        (0, 1),
    ],
    entries: &[
        ("updateDs", HciMeshClientOperationEnum::UpdateDs),
        ("dryrun", HciMeshClientOperationEnum::Dryrun),
        ("destroyDs", HciMeshClientOperationEnum::DestroyDs),
        ("HciMeshClientOperation_unknown", HciMeshClientOperationEnum::HciMeshClientOperationUnknown),
        ("update", HciMeshClientOperationEnum::Update),
        ("mount", HciMeshClientOperationEnum::Mount),
        ("dryrunDs", HciMeshClientOperationEnum::DryrunDs),
        ("unmount", HciMeshClientOperationEnum::Unmount),
    ],
};

impl HciMeshClientOperationEnum {
    pub fn as_str(&self) -> &str {
        match self {
            HciMeshClientOperationEnum::DryrunDs => "dryrunDs",
            HciMeshClientOperationEnum::UpdateDs => "updateDs",
            HciMeshClientOperationEnum::DestroyDs => "destroyDs",
            HciMeshClientOperationEnum::Dryrun => "dryrun",
            HciMeshClientOperationEnum::Mount => "mount",
            HciMeshClientOperationEnum::Update => "update",
            HciMeshClientOperationEnum::Unmount => "unmount",
            HciMeshClientOperationEnum::HciMeshClientOperationUnknown => "HciMeshClientOperation_unknown",
            HciMeshClientOperationEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        HCI_MESH_CLIENT_OPERATION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| HciMeshClientOperationEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for HciMeshClientOperationEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for HciMeshClientOperationEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<HciMeshClientOperationEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(HciMeshClientOperationEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for HciMeshClientOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for HciMeshClientOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a HciMeshClientOperationEnum> for &'a str {
    fn from(value: &'a HciMeshClientOperationEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for HciMeshClientOperationEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_IO_DIAGNOSTICS_FAILED_CHECK_TYPE_ENUM_MAP: phf::Map<&'static str, VsanIoDiagnosticsFailedCheckTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (5, 14),
        (0, 1),
        (0, 0),
        (1, 9),
    ],
    entries: &[
        ("vsandisabled", VsanIoDiagnosticsFailedCheckTypeEnum::Vsandisabled),
        ("runninginstanceontarget", VsanIoDiagnosticsFailedCheckTypeEnum::Runninginstanceontarget),
        ("computeonlycluster", VsanIoDiagnosticsFailedCheckTypeEnum::Computeonlycluster),
        ("perfsvcdisabled", VsanIoDiagnosticsFailedCheckTypeEnum::Perfsvcdisabled),
        ("nestedfaultdomain", VsanIoDiagnosticsFailedCheckTypeEnum::Nestedfaultdomain),
        ("stretchedcluster", VsanIoDiagnosticsFailedCheckTypeEnum::Stretchedcluster),
        ("vmnotpoweredon", VsanIoDiagnosticsFailedCheckTypeEnum::Vmnotpoweredon),
        ("invalidtarget", VsanIoDiagnosticsFailedCheckTypeEnum::Invalidtarget),
        ("toomanytargets", VsanIoDiagnosticsFailedCheckTypeEnum::Toomanytargets),
        ("invalidduration", VsanIoDiagnosticsFailedCheckTypeEnum::Invalidduration),
        ("invalidobjuuid", VsanIoDiagnosticsFailedCheckTypeEnum::Invalidobjuuid),
        ("toomanyobjects", VsanIoDiagnosticsFailedCheckTypeEnum::Toomanyobjects),
        ("runninginstance", VsanIoDiagnosticsFailedCheckTypeEnum::Runninginstance),
        ("vsanobjectinremotedatastore", VsanIoDiagnosticsFailedCheckTypeEnum::Vsanobjectinremotedatastore),
        ("networkpartition", VsanIoDiagnosticsFailedCheckTypeEnum::Networkpartition),
        ("VsanIODiagnosticsFailedCheckType_Unknown", VsanIoDiagnosticsFailedCheckTypeEnum::VsanIoDiagnosticsFailedCheckTypeUnknown),
    ],
};

impl VsanIoDiagnosticsFailedCheckTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanIoDiagnosticsFailedCheckTypeEnum::Perfsvcdisabled => "perfsvcdisabled",
            VsanIoDiagnosticsFailedCheckTypeEnum::Vsandisabled => "vsandisabled",
            VsanIoDiagnosticsFailedCheckTypeEnum::Runninginstance => "runninginstance",
            VsanIoDiagnosticsFailedCheckTypeEnum::Stretchedcluster => "stretchedcluster",
            VsanIoDiagnosticsFailedCheckTypeEnum::Nestedfaultdomain => "nestedfaultdomain",
            VsanIoDiagnosticsFailedCheckTypeEnum::Computeonlycluster => "computeonlycluster",
            VsanIoDiagnosticsFailedCheckTypeEnum::Networkpartition => "networkpartition",
            VsanIoDiagnosticsFailedCheckTypeEnum::Vmnotpoweredon => "vmnotpoweredon",
            VsanIoDiagnosticsFailedCheckTypeEnum::Vsanobjectinremotedatastore => "vsanobjectinremotedatastore",
            VsanIoDiagnosticsFailedCheckTypeEnum::Invalidtarget => "invalidtarget",
            VsanIoDiagnosticsFailedCheckTypeEnum::Invalidobjuuid => "invalidobjuuid",
            VsanIoDiagnosticsFailedCheckTypeEnum::Invalidduration => "invalidduration",
            VsanIoDiagnosticsFailedCheckTypeEnum::Runninginstanceontarget => "runninginstanceontarget",
            VsanIoDiagnosticsFailedCheckTypeEnum::Toomanytargets => "toomanytargets",
            VsanIoDiagnosticsFailedCheckTypeEnum::Toomanyobjects => "toomanyobjects",
            VsanIoDiagnosticsFailedCheckTypeEnum::VsanIoDiagnosticsFailedCheckTypeUnknown => "VsanIODiagnosticsFailedCheckType_Unknown",
            VsanIoDiagnosticsFailedCheckTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_IO_DIAGNOSTICS_FAILED_CHECK_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanIoDiagnosticsFailedCheckTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanIoDiagnosticsFailedCheckTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanIoDiagnosticsFailedCheckTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanIoDiagnosticsFailedCheckTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanIoDiagnosticsFailedCheckTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanIoDiagnosticsFailedCheckTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanIoDiagnosticsFailedCheckTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanIoDiagnosticsFailedCheckTypeEnum> for &'a str {
    fn from(value: &'a VsanIoDiagnosticsFailedCheckTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanIoDiagnosticsFailedCheckTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_IO_DIAGNOSTICS_INSTANCE_EVENT_TYPE_ENUM_MAP: phf::Map<&'static str, VsanIoDiagnosticsInstanceEventTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (5, 3),
        (1, 0),
    ],
    entries: &[
        ("objectOwnerTransfer", VsanIoDiagnosticsInstanceEventTypeEnum::ObjectOwnerTransfer),
        ("vsanmgmtdRestart", VsanIoDiagnosticsInstanceEventTypeEnum::VsanmgmtdRestart),
        ("objectRemoval", VsanIoDiagnosticsInstanceEventTypeEnum::ObjectRemoval),
        ("objectProxyOwnerTransfer", VsanIoDiagnosticsInstanceEventTypeEnum::ObjectProxyOwnerTransfer),
        ("VsanIODiagnosticsInstanceEventType_Unknown", VsanIoDiagnosticsInstanceEventTypeEnum::VsanIoDiagnosticsInstanceEventTypeUnknown),
        ("objectComponentsLayoutChange", VsanIoDiagnosticsInstanceEventTypeEnum::ObjectComponentsLayoutChange),
        ("primaryHostTransfer", VsanIoDiagnosticsInstanceEventTypeEnum::PrimaryHostTransfer),
    ],
};

impl VsanIoDiagnosticsInstanceEventTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanIoDiagnosticsInstanceEventTypeEnum::ObjectOwnerTransfer => "objectOwnerTransfer",
            VsanIoDiagnosticsInstanceEventTypeEnum::PrimaryHostTransfer => "primaryHostTransfer",
            VsanIoDiagnosticsInstanceEventTypeEnum::VsanmgmtdRestart => "vsanmgmtdRestart",
            VsanIoDiagnosticsInstanceEventTypeEnum::ObjectComponentsLayoutChange => "objectComponentsLayoutChange",
            VsanIoDiagnosticsInstanceEventTypeEnum::ObjectProxyOwnerTransfer => "objectProxyOwnerTransfer",
            VsanIoDiagnosticsInstanceEventTypeEnum::ObjectRemoval => "objectRemoval",
            VsanIoDiagnosticsInstanceEventTypeEnum::VsanIoDiagnosticsInstanceEventTypeUnknown => "VsanIODiagnosticsInstanceEventType_Unknown",
            VsanIoDiagnosticsInstanceEventTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_IO_DIAGNOSTICS_INSTANCE_EVENT_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanIoDiagnosticsInstanceEventTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanIoDiagnosticsInstanceEventTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanIoDiagnosticsInstanceEventTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanIoDiagnosticsInstanceEventTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanIoDiagnosticsInstanceEventTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanIoDiagnosticsInstanceEventTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanIoDiagnosticsInstanceEventTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanIoDiagnosticsInstanceEventTypeEnum> for &'a str {
    fn from(value: &'a VsanIoDiagnosticsInstanceEventTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanIoDiagnosticsInstanceEventTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_IO_DIAGNOSTICS_INSTANCE_STATE_ENUM_MAP: phf::Map<&'static str, VsanIoDiagnosticsInstanceStateEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("VsanIODiagnosticsInstanceRunning", VsanIoDiagnosticsInstanceStateEnum::VsanIoDiagnosticsInstanceRunning),
        ("VsanIODiagnosticsInstanceState_Unknown", VsanIoDiagnosticsInstanceStateEnum::VsanIoDiagnosticsInstanceStateUnknown),
        ("VsanIODiagnosticsInstanceCompleted", VsanIoDiagnosticsInstanceStateEnum::VsanIoDiagnosticsInstanceCompleted),
    ],
};

impl VsanIoDiagnosticsInstanceStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanIoDiagnosticsInstanceStateEnum::VsanIoDiagnosticsInstanceCompleted => "VsanIODiagnosticsInstanceCompleted",
            VsanIoDiagnosticsInstanceStateEnum::VsanIoDiagnosticsInstanceRunning => "VsanIODiagnosticsInstanceRunning",
            VsanIoDiagnosticsInstanceStateEnum::VsanIoDiagnosticsInstanceStateUnknown => "VsanIODiagnosticsInstanceState_Unknown",
            VsanIoDiagnosticsInstanceStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_IO_DIAGNOSTICS_INSTANCE_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanIoDiagnosticsInstanceStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanIoDiagnosticsInstanceStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanIoDiagnosticsInstanceStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanIoDiagnosticsInstanceStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanIoDiagnosticsInstanceStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanIoDiagnosticsInstanceStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanIoDiagnosticsInstanceStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanIoDiagnosticsInstanceStateEnum> for &'a str {
    fn from(value: &'a VsanIoDiagnosticsInstanceStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanIoDiagnosticsInstanceStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_IO_DIAGNOSTICS_TARGET_TYPE_ENUM_MAP: phf::Map<&'static str, VsanIoDiagnosticsTargetTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("VirtualMachine", VsanIoDiagnosticsTargetTypeEnum::VirtualMachine),
        ("VsanIODiagnosticsTargetType_Unknown", VsanIoDiagnosticsTargetTypeEnum::VsanIoDiagnosticsTargetTypeUnknown),
    ],
};

impl VsanIoDiagnosticsTargetTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanIoDiagnosticsTargetTypeEnum::VirtualMachine => "VirtualMachine",
            VsanIoDiagnosticsTargetTypeEnum::VsanIoDiagnosticsTargetTypeUnknown => "VsanIODiagnosticsTargetType_Unknown",
            VsanIoDiagnosticsTargetTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_IO_DIAGNOSTICS_TARGET_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanIoDiagnosticsTargetTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanIoDiagnosticsTargetTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanIoDiagnosticsTargetTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanIoDiagnosticsTargetTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanIoDiagnosticsTargetTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanIoDiagnosticsTargetTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanIoDiagnosticsTargetTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanIoDiagnosticsTargetTypeEnum> for &'a str {
    fn from(value: &'a VsanIoDiagnosticsTargetTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanIoDiagnosticsTargetTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_IO_LATENCY_TYPE_ENUM_MAP: phf::Map<&'static str, VsanIoLatencyTypeEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (10, 6),
        (2, 5),
        (2, 0),
    ],
    entries: &[
        ("PerfDomOwnerLatency", VsanIoLatencyTypeEnum::PerfDomOwnerLatency),
        ("DomOwnerLatency", VsanIoLatencyTypeEnum::DomOwnerLatency),
        ("VsanIOLatencyType_Unknown", VsanIoLatencyTypeEnum::VsanIoLatencyTypeUnknown),
        ("CapacityNetworkLatency", VsanIoLatencyTypeEnum::CapacityNetworkLatency),
        ("CapacityDomOwnerLatency", VsanIoLatencyTypeEnum::CapacityDomOwnerLatency),
        ("PerfLsomLatency", VsanIoLatencyTypeEnum::PerfLsomLatency),
        ("ZdomLatency", VsanIoLatencyTypeEnum::ZdomLatency),
        ("NetworkLatency", VsanIoLatencyTypeEnum::NetworkLatency),
        ("PerfNetworkLatency", VsanIoLatencyTypeEnum::PerfNetworkLatency),
        ("CapacityLsomLatency", VsanIoLatencyTypeEnum::CapacityLsomLatency),
        ("CrossSiteNetworkLatency", VsanIoLatencyTypeEnum::CrossSiteNetworkLatency),
        ("LsomLatency", VsanIoLatencyTypeEnum::LsomLatency),
    ],
};

impl VsanIoLatencyTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanIoLatencyTypeEnum::DomOwnerLatency => "DomOwnerLatency",
            VsanIoLatencyTypeEnum::NetworkLatency => "NetworkLatency",
            VsanIoLatencyTypeEnum::LsomLatency => "LsomLatency",
            VsanIoLatencyTypeEnum::VsanIoLatencyTypeUnknown => "VsanIOLatencyType_Unknown",
            VsanIoLatencyTypeEnum::ZdomLatency => "ZdomLatency",
            VsanIoLatencyTypeEnum::PerfDomOwnerLatency => "PerfDomOwnerLatency",
            VsanIoLatencyTypeEnum::CapacityDomOwnerLatency => "CapacityDomOwnerLatency",
            VsanIoLatencyTypeEnum::PerfNetworkLatency => "PerfNetworkLatency",
            VsanIoLatencyTypeEnum::CapacityNetworkLatency => "CapacityNetworkLatency",
            VsanIoLatencyTypeEnum::PerfLsomLatency => "PerfLsomLatency",
            VsanIoLatencyTypeEnum::CapacityLsomLatency => "CapacityLsomLatency",
            VsanIoLatencyTypeEnum::CrossSiteNetworkLatency => "CrossSiteNetworkLatency",
            VsanIoLatencyTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_IO_LATENCY_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanIoLatencyTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanIoLatencyTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanIoLatencyTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanIoLatencyTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanIoLatencyTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanIoLatencyTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanIoLatencyTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanIoLatencyTypeEnum> for &'a str {
    fn from(value: &'a VsanIoLatencyTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanIoLatencyTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIM_VSAN_LIFECYCLE_CHECK_OPERATION_ENUM_MAP: phf::Map<&'static str, VimVsanLifecycleCheckOperationEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("LifecycleCheckOperation_unknown", VimVsanLifecycleCheckOperationEnum::LifecycleCheckOperationUnknown),
        ("noChecks", VimVsanLifecycleCheckOperationEnum::NoChecks),
    ],
};

impl VimVsanLifecycleCheckOperationEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VimVsanLifecycleCheckOperationEnum::NoChecks => "noChecks",
            VimVsanLifecycleCheckOperationEnum::LifecycleCheckOperationUnknown => "LifecycleCheckOperation_unknown",
            VimVsanLifecycleCheckOperationEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIM_VSAN_LIFECYCLE_CHECK_OPERATION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VimVsanLifecycleCheckOperationEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VimVsanLifecycleCheckOperationEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VimVsanLifecycleCheckOperationEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VimVsanLifecycleCheckOperationEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VimVsanLifecycleCheckOperationEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VimVsanLifecycleCheckOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VimVsanLifecycleCheckOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VimVsanLifecycleCheckOperationEnum> for &'a str {
    fn from(value: &'a VimVsanLifecycleCheckOperationEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VimVsanLifecycleCheckOperationEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIM_VSAN_LIFECYCLE_CLUSTER_TYPE_ENUM_MAP: phf::Map<&'static str, VimVsanLifecycleClusterTypeEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("metadata", VimVsanLifecycleClusterTypeEnum::Metadata),
        ("single", VimVsanLifecycleClusterTypeEnum::Single),
        ("stretched", VimVsanLifecycleClusterTypeEnum::Stretched),
        ("LifecycleClusterType_unknown", VimVsanLifecycleClusterTypeEnum::LifecycleClusterTypeUnknown),
    ],
};

impl VimVsanLifecycleClusterTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VimVsanLifecycleClusterTypeEnum::Single => "single",
            VimVsanLifecycleClusterTypeEnum::Stretched => "stretched",
            VimVsanLifecycleClusterTypeEnum::Metadata => "metadata",
            VimVsanLifecycleClusterTypeEnum::LifecycleClusterTypeUnknown => "LifecycleClusterType_unknown",
            VimVsanLifecycleClusterTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIM_VSAN_LIFECYCLE_CLUSTER_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VimVsanLifecycleClusterTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VimVsanLifecycleClusterTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VimVsanLifecycleClusterTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VimVsanLifecycleClusterTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VimVsanLifecycleClusterTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VimVsanLifecycleClusterTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VimVsanLifecycleClusterTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VimVsanLifecycleClusterTypeEnum> for &'a str {
    fn from(value: &'a VimVsanLifecycleClusterTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VimVsanLifecycleClusterTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIM_VSAN_LIFECYCLE_PRE_CHECK_TYPE_ENUM_MAP: phf::Map<&'static str, VimVsanLifecyclePreCheckTypeEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("PreCheckType_unknown", VimVsanLifecyclePreCheckTypeEnum::PreCheckTypeUnknown),
        ("supportedWitnessVersion", VimVsanLifecyclePreCheckTypeEnum::SupportedWitnessVersion),
        ("virtualWitnessHost", VimVsanLifecyclePreCheckTypeEnum::VirtualWitnessHost),
        ("sharedWitnessHost", VimVsanLifecyclePreCheckTypeEnum::SharedWitnessHost),
    ],
};

impl VimVsanLifecyclePreCheckTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VimVsanLifecyclePreCheckTypeEnum::SupportedWitnessVersion => "supportedWitnessVersion",
            VimVsanLifecyclePreCheckTypeEnum::VirtualWitnessHost => "virtualWitnessHost",
            VimVsanLifecyclePreCheckTypeEnum::SharedWitnessHost => "sharedWitnessHost",
            VimVsanLifecyclePreCheckTypeEnum::PreCheckTypeUnknown => "PreCheckType_unknown",
            VimVsanLifecyclePreCheckTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIM_VSAN_LIFECYCLE_PRE_CHECK_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VimVsanLifecyclePreCheckTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VimVsanLifecyclePreCheckTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VimVsanLifecyclePreCheckTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VimVsanLifecyclePreCheckTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VimVsanLifecyclePreCheckTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VimVsanLifecyclePreCheckTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VimVsanLifecyclePreCheckTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VimVsanLifecyclePreCheckTypeEnum> for &'a str {
    fn from(value: &'a VimVsanLifecyclePreCheckTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VimVsanLifecyclePreCheckTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_MODE_ENUM_MAP: phf::Map<&'static str, VsanModeEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("Mode_Compute", VsanModeEnum::ModeCompute),
        ("Mode_Storage", VsanModeEnum::ModeStorage),
        ("Mode_Unknown", VsanModeEnum::ModeUnknown),
        ("Mode_None", VsanModeEnum::ModeNone),
    ],
};

impl VsanModeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanModeEnum::ModeNone => "Mode_None",
            VsanModeEnum::ModeCompute => "Mode_Compute",
            VsanModeEnum::ModeStorage => "Mode_Storage",
            VsanModeEnum::ModeUnknown => "Mode_Unknown",
            VsanModeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_MODE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanModeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanModeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanModeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanModeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanModeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanModeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanModeEnum> for &'a str {
    fn from(value: &'a VsanModeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanModeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIM_VSAN_MOUNT_PRECHECK_TYPE_ENUM_MAP: phf::Map<&'static str, VimVsanMountPrecheckTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 12),
        (11, 1),
        (9, 13),
        (0, 0),
        (0, 18),
    ],
    entries: &[
        ("serverVcenterLimit", VimVsanMountPrecheckTypeEnum::ServerVcenterLimit),
        ("vsanFormatVersion", VimVsanMountPrecheckTypeEnum::VsanFormatVersion),
        ("supportedConfiguration", VimVsanMountPrecheckTypeEnum::SupportedConfiguration),
        ("datastoreExists", VimVsanMountPrecheckTypeEnum::DatastoreExists),
        ("vcApiVersion", VimVsanMountPrecheckTypeEnum::VcApiVersion),
        ("precheck_unknown", VimVsanMountPrecheckTypeEnum::PrecheckUnknown),
        ("serverClusterLimit", VimVsanMountPrecheckTypeEnum::ServerClusterLimit),
        ("datastoreType", VimVsanMountPrecheckTypeEnum::DatastoreType),
        ("remoteDatastoreLimit", VimVsanMountPrecheckTypeEnum::RemoteDatastoreLimit),
        ("datastorePolicy", VimVsanMountPrecheckTypeEnum::DatastorePolicy),
        ("datacenter", VimVsanMountPrecheckTypeEnum::Datacenter),
        ("serverClusterHealth", VimVsanMountPrecheckTypeEnum::ServerClusterHealth),
        ("remoteVcConnection", VimVsanMountPrecheckTypeEnum::RemoteVcConnection),
        ("clientClusterLimit", VimVsanMountPrecheckTypeEnum::ClientClusterLimit),
        ("serverVersionForComputeMode", VimVsanMountPrecheckTypeEnum::ServerVersionForComputeMode),
        ("clientVcenterLimit", VimVsanMountPrecheckTypeEnum::ClientVcenterLimit),
        ("connectivity", VimVsanMountPrecheckTypeEnum::Connectivity),
        ("localVsanDatastore", VimVsanMountPrecheckTypeEnum::LocalVsanDatastore),
        ("license", VimVsanMountPrecheckTypeEnum::License),
        ("checkServerVcenter", VimVsanMountPrecheckTypeEnum::CheckServerVcenter),
        ("networkLatency", VimVsanMountPrecheckTypeEnum::NetworkLatency),
        ("vcenterIdValid", VimVsanMountPrecheckTypeEnum::VcenterIdValid),
    ],
};

impl VimVsanMountPrecheckTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VimVsanMountPrecheckTypeEnum::SupportedConfiguration => "supportedConfiguration",
            VimVsanMountPrecheckTypeEnum::LocalVsanDatastore => "localVsanDatastore",
            VimVsanMountPrecheckTypeEnum::DatastoreType => "datastoreType",
            VimVsanMountPrecheckTypeEnum::Datacenter => "datacenter",
            VimVsanMountPrecheckTypeEnum::VsanFormatVersion => "vsanFormatVersion",
            VimVsanMountPrecheckTypeEnum::ServerClusterHealth => "serverClusterHealth",
            VimVsanMountPrecheckTypeEnum::DatastorePolicy => "datastorePolicy",
            VimVsanMountPrecheckTypeEnum::RemoteDatastoreLimit => "remoteDatastoreLimit",
            VimVsanMountPrecheckTypeEnum::ClientClusterLimit => "clientClusterLimit",
            VimVsanMountPrecheckTypeEnum::ServerClusterLimit => "serverClusterLimit",
            VimVsanMountPrecheckTypeEnum::Connectivity => "connectivity",
            VimVsanMountPrecheckTypeEnum::NetworkLatency => "networkLatency",
            VimVsanMountPrecheckTypeEnum::License => "license",
            VimVsanMountPrecheckTypeEnum::PrecheckUnknown => "precheck_unknown",
            VimVsanMountPrecheckTypeEnum::ServerVersionForComputeMode => "serverVersionForComputeMode",
            VimVsanMountPrecheckTypeEnum::RemoteVcConnection => "remoteVcConnection",
            VimVsanMountPrecheckTypeEnum::DatastoreExists => "datastoreExists",
            VimVsanMountPrecheckTypeEnum::ServerVcenterLimit => "serverVcenterLimit",
            VimVsanMountPrecheckTypeEnum::ClientVcenterLimit => "clientVcenterLimit",
            VimVsanMountPrecheckTypeEnum::VcApiVersion => "vcApiVersion",
            VimVsanMountPrecheckTypeEnum::VcenterIdValid => "vcenterIdValid",
            VimVsanMountPrecheckTypeEnum::CheckServerVcenter => "checkServerVcenter",
            VimVsanMountPrecheckTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIM_VSAN_MOUNT_PRECHECK_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VimVsanMountPrecheckTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VimVsanMountPrecheckTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VimVsanMountPrecheckTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VimVsanMountPrecheckTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VimVsanMountPrecheckTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VimVsanMountPrecheckTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VimVsanMountPrecheckTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VimVsanMountPrecheckTypeEnum> for &'a str {
    fn from(value: &'a VimVsanMountPrecheckTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VimVsanMountPrecheckTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_PERFSVC_REMEDIATE_ACTION_ENUM_MAP: phf::Map<&'static str, VsanPerfsvcRemediateActionEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("update_profile", VsanPerfsvcRemediateActionEnum::UpdateProfile),
        ("PerfsvcRemediateAction_Unknown", VsanPerfsvcRemediateActionEnum::PerfsvcRemediateActionUnknown),
        ("enable", VsanPerfsvcRemediateActionEnum::Enable),
        ("no_action", VsanPerfsvcRemediateActionEnum::NoAction),
        ("disable", VsanPerfsvcRemediateActionEnum::Disable),
    ],
};

impl VsanPerfsvcRemediateActionEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanPerfsvcRemediateActionEnum::Enable => "enable",
            VsanPerfsvcRemediateActionEnum::Disable => "disable",
            VsanPerfsvcRemediateActionEnum::UpdateProfile => "update_profile",
            VsanPerfsvcRemediateActionEnum::NoAction => "no_action",
            VsanPerfsvcRemediateActionEnum::PerfsvcRemediateActionUnknown => "PerfsvcRemediateAction_Unknown",
            VsanPerfsvcRemediateActionEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_PERFSVC_REMEDIATE_ACTION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanPerfsvcRemediateActionEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanPerfsvcRemediateActionEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanPerfsvcRemediateActionEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanPerfsvcRemediateActionEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanPerfsvcRemediateActionEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanPerfsvcRemediateActionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanPerfsvcRemediateActionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanPerfsvcRemediateActionEnum> for &'a str {
    fn from(value: &'a VsanPerfsvcRemediateActionEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanPerfsvcRemediateActionEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PRECHECK_DATASTORE_SOURCE_OPERATION_ENUM_MAP: phf::Map<&'static str, PrecheckDatastoreSourceOperationEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("checkDestroyDs", PrecheckDatastoreSourceOperationEnum::CheckDestroyDs),
        ("checkUpdateDs", PrecheckDatastoreSourceOperationEnum::CheckUpdateDs),
        ("checkCreateDs", PrecheckDatastoreSourceOperationEnum::CheckCreateDs),
        ("PrecheckDatastoreSourceOperation_unknown", PrecheckDatastoreSourceOperationEnum::PrecheckDatastoreSourceOperationUnknown),
    ],
};

impl PrecheckDatastoreSourceOperationEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PrecheckDatastoreSourceOperationEnum::CheckCreateDs => "checkCreateDs",
            PrecheckDatastoreSourceOperationEnum::CheckUpdateDs => "checkUpdateDs",
            PrecheckDatastoreSourceOperationEnum::CheckDestroyDs => "checkDestroyDs",
            PrecheckDatastoreSourceOperationEnum::PrecheckDatastoreSourceOperationUnknown => "PrecheckDatastoreSourceOperation_unknown",
            PrecheckDatastoreSourceOperationEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PRECHECK_DATASTORE_SOURCE_OPERATION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PrecheckDatastoreSourceOperationEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PrecheckDatastoreSourceOperationEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PrecheckDatastoreSourceOperationEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PrecheckDatastoreSourceOperationEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PrecheckDatastoreSourceOperationEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PrecheckDatastoreSourceOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PrecheckDatastoreSourceOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PrecheckDatastoreSourceOperationEnum> for &'a str {
    fn from(value: &'a PrecheckDatastoreSourceOperationEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PrecheckDatastoreSourceOperationEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_REMOTE_VC_LINK_TYPE_ENUM_MAP: phf::Map<&'static str, VsanRemoteVcLinkTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("standalone", VsanRemoteVcLinkTypeEnum::Standalone),
        ("VsanRemoteVcLinkType_unknown", VsanRemoteVcLinkTypeEnum::VsanRemoteVcLinkTypeUnknown),
    ],
};

impl VsanRemoteVcLinkTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanRemoteVcLinkTypeEnum::Standalone => "standalone",
            VsanRemoteVcLinkTypeEnum::VsanRemoteVcLinkTypeUnknown => "VsanRemoteVcLinkType_unknown",
            VsanRemoteVcLinkTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_REMOTE_VC_LINK_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanRemoteVcLinkTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanRemoteVcLinkTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanRemoteVcLinkTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanRemoteVcLinkTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanRemoteVcLinkTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanRemoteVcLinkTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanRemoteVcLinkTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanRemoteVcLinkTypeEnum> for &'a str {
    fn from(value: &'a VsanRemoteVcLinkTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanRemoteVcLinkTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static REMOTE_VSAN_NETWORK_TOPOLOGY_ENUM_MAP: phf::Map<&'static str, RemoteVsanNetworkTopologyEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("Topology_Unknown", RemoteVsanNetworkTopologyEnum::TopologyUnknown),
        ("Symmetric", RemoteVsanNetworkTopologyEnum::Symmetric),
        ("Asymmetric", RemoteVsanNetworkTopologyEnum::Asymmetric),
    ],
};

impl RemoteVsanNetworkTopologyEnum {
    pub fn as_str(&self) -> &str {
        match self {
            RemoteVsanNetworkTopologyEnum::TopologyUnknown => "Topology_Unknown",
            RemoteVsanNetworkTopologyEnum::Symmetric => "Symmetric",
            RemoteVsanNetworkTopologyEnum::Asymmetric => "Asymmetric",
            RemoteVsanNetworkTopologyEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        REMOTE_VSAN_NETWORK_TOPOLOGY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| RemoteVsanNetworkTopologyEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for RemoteVsanNetworkTopologyEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for RemoteVsanNetworkTopologyEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<RemoteVsanNetworkTopologyEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(RemoteVsanNetworkTopologyEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for RemoteVsanNetworkTopologyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for RemoteVsanNetworkTopologyEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a RemoteVsanNetworkTopologyEnum> for &'a str {
    fn from(value: &'a RemoteVsanNetworkTopologyEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for RemoteVsanNetworkTopologyEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_RESOURCE_CHECK_COMPONENT_TYPE_ENUM_MAP: phf::Map<&'static str, VsanResourceCheckComponentTypeEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("vSAN", VsanResourceCheckComponentTypeEnum::VSan),
        ("DataPersistence", VsanResourceCheckComponentTypeEnum::DataPersistence),
        ("ResourceCheckComponentType_Unknown", VsanResourceCheckComponentTypeEnum::ResourceCheckComponentTypeUnknown),
    ],
};

impl VsanResourceCheckComponentTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanResourceCheckComponentTypeEnum::VSan => "vSAN",
            VsanResourceCheckComponentTypeEnum::DataPersistence => "DataPersistence",
            VsanResourceCheckComponentTypeEnum::ResourceCheckComponentTypeUnknown => "ResourceCheckComponentType_Unknown",
            VsanResourceCheckComponentTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_RESOURCE_CHECK_COMPONENT_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanResourceCheckComponentTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanResourceCheckComponentTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanResourceCheckComponentTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanResourceCheckComponentTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanResourceCheckComponentTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanResourceCheckComponentTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanResourceCheckComponentTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanResourceCheckComponentTypeEnum> for &'a str {
    fn from(value: &'a VsanResourceCheckComponentTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanResourceCheckComponentTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static RESOURCE_CHECK_DEDUP_STORE_HEALTH_STATE_ENUM_MAP: phf::Map<&'static str, ResourceCheckDedupStoreHealthStateEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("Noncompliant", ResourceCheckDedupStoreHealthStateEnum::Noncompliant),
        ("Inaccessible", ResourceCheckDedupStoreHealthStateEnum::Inaccessible),
    ],
};

impl ResourceCheckDedupStoreHealthStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ResourceCheckDedupStoreHealthStateEnum::Inaccessible => "Inaccessible",
            ResourceCheckDedupStoreHealthStateEnum::Noncompliant => "Noncompliant",
            ResourceCheckDedupStoreHealthStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        RESOURCE_CHECK_DEDUP_STORE_HEALTH_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ResourceCheckDedupStoreHealthStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ResourceCheckDedupStoreHealthStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ResourceCheckDedupStoreHealthStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ResourceCheckDedupStoreHealthStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ResourceCheckDedupStoreHealthStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ResourceCheckDedupStoreHealthStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ResourceCheckDedupStoreHealthStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ResourceCheckDedupStoreHealthStateEnum> for &'a str {
    fn from(value: &'a ResourceCheckDedupStoreHealthStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ResourceCheckDedupStoreHealthStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_RESOURCE_CHECK_STATUS_TYPE_ENUM_MAP: phf::Map<&'static str, VsanResourceCheckStatusTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
        (1, 7),
    ],
    entries: &[
        ("resourceCheckFailed", VsanResourceCheckStatusTypeEnum::ResourceCheckFailed),
        ("resourceCheckNotSupported", VsanResourceCheckStatusTypeEnum::ResourceCheckNotSupported),
        ("ResourceCheckStatusType_Unknown", VsanResourceCheckStatusTypeEnum::ResourceCheckStatusTypeUnknown),
        ("resourceCheckCompleted", VsanResourceCheckStatusTypeEnum::ResourceCheckCompleted),
        ("resourceCheckCancelled", VsanResourceCheckStatusTypeEnum::ResourceCheckCancelled),
        ("resourceCheckUninitialized", VsanResourceCheckStatusTypeEnum::ResourceCheckUninitialized),
        ("resourceCheckRunning", VsanResourceCheckStatusTypeEnum::ResourceCheckRunning),
        ("resourceCheckNoRecentValue", VsanResourceCheckStatusTypeEnum::ResourceCheckNoRecentValue),
    ],
};

impl VsanResourceCheckStatusTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanResourceCheckStatusTypeEnum::ResourceCheckUninitialized => "resourceCheckUninitialized",
            VsanResourceCheckStatusTypeEnum::ResourceCheckRunning => "resourceCheckRunning",
            VsanResourceCheckStatusTypeEnum::ResourceCheckFailed => "resourceCheckFailed",
            VsanResourceCheckStatusTypeEnum::ResourceCheckCancelled => "resourceCheckCancelled",
            VsanResourceCheckStatusTypeEnum::ResourceCheckCompleted => "resourceCheckCompleted",
            VsanResourceCheckStatusTypeEnum::ResourceCheckNoRecentValue => "resourceCheckNoRecentValue",
            VsanResourceCheckStatusTypeEnum::ResourceCheckNotSupported => "resourceCheckNotSupported",
            VsanResourceCheckStatusTypeEnum::ResourceCheckStatusTypeUnknown => "ResourceCheckStatusType_Unknown",
            VsanResourceCheckStatusTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_RESOURCE_CHECK_STATUS_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanResourceCheckStatusTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanResourceCheckStatusTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanResourceCheckStatusTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanResourceCheckStatusTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanResourceCheckStatusTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanResourceCheckStatusTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanResourceCheckStatusTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanResourceCheckStatusTypeEnum> for &'a str {
    fn from(value: &'a VsanResourceCheckStatusTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanResourceCheckStatusTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_SNAPSHOT_CREATOR_ENUM_MAP: phf::Map<&'static str, VsanSnapshotCreatorEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("SnapshotCreator_Unknown", VsanSnapshotCreatorEnum::SnapshotCreatorUnknown),
        ("SnapService", VsanSnapshotCreatorEnum::SnapService),
    ],
};

impl VsanSnapshotCreatorEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanSnapshotCreatorEnum::SnapService => "SnapService",
            VsanSnapshotCreatorEnum::SnapshotCreatorUnknown => "SnapshotCreator_Unknown",
            VsanSnapshotCreatorEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_SNAPSHOT_CREATOR_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanSnapshotCreatorEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanSnapshotCreatorEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanSnapshotCreatorEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanSnapshotCreatorEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanSnapshotCreatorEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanSnapshotCreatorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanSnapshotCreatorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanSnapshotCreatorEnum> for &'a str {
    fn from(value: &'a VsanSnapshotCreatorEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanSnapshotCreatorEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_SNAPSHOT_TYPE_ENUM_MAP: phf::Map<&'static str, VsanSnapshotTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("Managed", VsanSnapshotTypeEnum::Managed),
        ("SnapshotType_Unknown", VsanSnapshotTypeEnum::SnapshotTypeUnknown),
        ("Unmanaged", VsanSnapshotTypeEnum::Unmanaged),
    ],
};

impl VsanSnapshotTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanSnapshotTypeEnum::Managed => "Managed",
            VsanSnapshotTypeEnum::Unmanaged => "Unmanaged",
            VsanSnapshotTypeEnum::SnapshotTypeUnknown => "SnapshotType_Unknown",
            VsanSnapshotTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_SNAPSHOT_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanSnapshotTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanSnapshotTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanSnapshotTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanSnapshotTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanSnapshotTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanSnapshotTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanSnapshotTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanSnapshotTypeEnum> for &'a str {
    fn from(value: &'a VsanSnapshotTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanSnapshotTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_ANALYTICS_EVENT_LOCATION_TYPE_ENUM_MAP: phf::Map<&'static str, VsanAnalyticsEventLocationTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("DISK", VsanAnalyticsEventLocationTypeEnum::Disk),
        ("CLUSTER", VsanAnalyticsEventLocationTypeEnum::Cluster),
        ("EVENT_LOCATION_UNKNOWN", VsanAnalyticsEventLocationTypeEnum::EventLocationUnknown),
        ("HOST", VsanAnalyticsEventLocationTypeEnum::Host),
    ],
};

impl VsanAnalyticsEventLocationTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanAnalyticsEventLocationTypeEnum::Cluster => "CLUSTER",
            VsanAnalyticsEventLocationTypeEnum::Host => "HOST",
            VsanAnalyticsEventLocationTypeEnum::Disk => "DISK",
            VsanAnalyticsEventLocationTypeEnum::EventLocationUnknown => "EVENT_LOCATION_UNKNOWN",
            VsanAnalyticsEventLocationTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_ANALYTICS_EVENT_LOCATION_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanAnalyticsEventLocationTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanAnalyticsEventLocationTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanAnalyticsEventLocationTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanAnalyticsEventLocationTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanAnalyticsEventLocationTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanAnalyticsEventLocationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanAnalyticsEventLocationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanAnalyticsEventLocationTypeEnum> for &'a str {
    fn from(value: &'a VsanAnalyticsEventLocationTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanAnalyticsEventLocationTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_ANALYTICS_EVENT_SNAPSHOT_TYPE_ENUM_MAP: phf::Map<&'static str, VsanAnalyticsEventSnapshotTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("HOST_SNAPSHOT", VsanAnalyticsEventSnapshotTypeEnum::HostSnapshot),
        ("SNAPSHOT_TYPE_UNKNOWN", VsanAnalyticsEventSnapshotTypeEnum::SnapshotTypeUnknown),
        ("DISK_SNAPSHOT", VsanAnalyticsEventSnapshotTypeEnum::DiskSnapshot),
        ("OBJECT_SNAPSHOT", VsanAnalyticsEventSnapshotTypeEnum::ObjectSnapshot),
        ("POLICY_SNAPSHOT", VsanAnalyticsEventSnapshotTypeEnum::PolicySnapshot),
    ],
};

impl VsanAnalyticsEventSnapshotTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanAnalyticsEventSnapshotTypeEnum::ObjectSnapshot => "OBJECT_SNAPSHOT",
            VsanAnalyticsEventSnapshotTypeEnum::HostSnapshot => "HOST_SNAPSHOT",
            VsanAnalyticsEventSnapshotTypeEnum::DiskSnapshot => "DISK_SNAPSHOT",
            VsanAnalyticsEventSnapshotTypeEnum::PolicySnapshot => "POLICY_SNAPSHOT",
            VsanAnalyticsEventSnapshotTypeEnum::SnapshotTypeUnknown => "SNAPSHOT_TYPE_UNKNOWN",
            VsanAnalyticsEventSnapshotTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_ANALYTICS_EVENT_SNAPSHOT_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanAnalyticsEventSnapshotTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanAnalyticsEventSnapshotTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanAnalyticsEventSnapshotTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanAnalyticsEventSnapshotTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanAnalyticsEventSnapshotTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanAnalyticsEventSnapshotTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanAnalyticsEventSnapshotTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanAnalyticsEventSnapshotTypeEnum> for &'a str {
    fn from(value: &'a VsanAnalyticsEventSnapshotTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanAnalyticsEventSnapshotTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_ANALYTICS_EVENT_TYPE_ENUM_MAP: phf::Map<&'static str, VsanAnalyticsEventTypeEnum> = ::phf::Map {
    key: 8694567506910003252,
    disps: &[
        (9, 20),
        (0, 3),
        (0, 8),
        (0, 7),
        (7, 4),
        (0, 0),
        (14, 2),
    ],
    entries: &[
        ("CLUSTER_MEMBERSHIP_CHANGED", VsanAnalyticsEventTypeEnum::ClusterMembershipChanged),
        ("HOST_DECOM_START", VsanAnalyticsEventTypeEnum::HostDecomStart),
        ("STORAGE_OBJECT_UNAVAILABLE", VsanAnalyticsEventTypeEnum::StorageObjectUnavailable),
        ("STORAGE_OBJECT_LOST", VsanAnalyticsEventTypeEnum::StorageObjectLost),
        ("EVENT_TYPE_UNKNOWN", VsanAnalyticsEventTypeEnum::EventTypeUnknown),
        ("DEVICE_ERROR", VsanAnalyticsEventTypeEnum::DeviceError),
        ("HOST_DECOM_END", VsanAnalyticsEventTypeEnum::HostDecomEnd),
        ("RESYNC_END", VsanAnalyticsEventTypeEnum::ResyncEnd),
        ("STORAGE_DOM_OBJECT_CHANGE", VsanAnalyticsEventTypeEnum::StorageDomObjectChange),
        ("HOST_NORMAL", VsanAnalyticsEventTypeEnum::HostNormal),
        ("SDDC_DELETED", VsanAnalyticsEventTypeEnum::SddcDeleted),
        ("STORAGE_OBJECT_AVAILABLE", VsanAnalyticsEventTypeEnum::StorageObjectAvailable),
        ("DG_DECOM_END", VsanAnalyticsEventTypeEnum::DgDecomEnd),
        ("STORAGE_OBJECT_CREATED", VsanAnalyticsEventTypeEnum::StorageObjectCreated),
        ("CLUSTER_CREATED", VsanAnalyticsEventTypeEnum::ClusterCreated),
        ("SDDC_CREATED", VsanAnalyticsEventTypeEnum::SddcCreated),
        ("STORAGE_OBJECT_REPL_CHANGE", VsanAnalyticsEventTypeEnum::StorageObjectReplChange),
        ("REPAIR_START", VsanAnalyticsEventTypeEnum::RepairStart),
        ("REPAIR_END", VsanAnalyticsEventTypeEnum::RepairEnd),
        ("HOST_FAILURE", VsanAnalyticsEventTypeEnum::HostFailure),
        ("HOST_CREATED", VsanAnalyticsEventTypeEnum::HostCreated),
        ("DEVICE_FAILURE", VsanAnalyticsEventTypeEnum::DeviceFailure),
        ("DEVICE_OFFLINE", VsanAnalyticsEventTypeEnum::DeviceOffline),
        ("REBUILD_START", VsanAnalyticsEventTypeEnum::RebuildStart),
        ("REBUILD_END", VsanAnalyticsEventTypeEnum::RebuildEnd),
        ("HOST_DELETED", VsanAnalyticsEventTypeEnum::HostDeleted),
        ("PATCH_START", VsanAnalyticsEventTypeEnum::PatchStart),
        ("STORAGE_OBJECT_DELETED", VsanAnalyticsEventTypeEnum::StorageObjectDeleted),
        ("RESYNC_IN_PROGRESS", VsanAnalyticsEventTypeEnum::ResyncInProgress),
        ("PATCH_END", VsanAnalyticsEventTypeEnum::PatchEnd),
        ("DEVICE_NORMAL", VsanAnalyticsEventTypeEnum::DeviceNormal),
        ("HOST_DECOM_FAIL", VsanAnalyticsEventTypeEnum::HostDecomFail),
        ("DG_DECOM_START", VsanAnalyticsEventTypeEnum::DgDecomStart),
        ("CLUSTER_DELETED", VsanAnalyticsEventTypeEnum::ClusterDeleted),
    ],
};

impl VsanAnalyticsEventTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanAnalyticsEventTypeEnum::StorageObjectUnavailable => "STORAGE_OBJECT_UNAVAILABLE",
            VsanAnalyticsEventTypeEnum::StorageObjectAvailable => "STORAGE_OBJECT_AVAILABLE",
            VsanAnalyticsEventTypeEnum::StorageObjectReplChange => "STORAGE_OBJECT_REPL_CHANGE",
            VsanAnalyticsEventTypeEnum::StorageObjectLost => "STORAGE_OBJECT_LOST",
            VsanAnalyticsEventTypeEnum::StorageObjectCreated => "STORAGE_OBJECT_CREATED",
            VsanAnalyticsEventTypeEnum::StorageObjectDeleted => "STORAGE_OBJECT_DELETED",
            VsanAnalyticsEventTypeEnum::StorageDomObjectChange => "STORAGE_DOM_OBJECT_CHANGE",
            VsanAnalyticsEventTypeEnum::RepairStart => "REPAIR_START",
            VsanAnalyticsEventTypeEnum::RepairEnd => "REPAIR_END",
            VsanAnalyticsEventTypeEnum::RebuildStart => "REBUILD_START",
            VsanAnalyticsEventTypeEnum::RebuildEnd => "REBUILD_END",
            VsanAnalyticsEventTypeEnum::ResyncInProgress => "RESYNC_IN_PROGRESS",
            VsanAnalyticsEventTypeEnum::ResyncEnd => "RESYNC_END",
            VsanAnalyticsEventTypeEnum::PatchStart => "PATCH_START",
            VsanAnalyticsEventTypeEnum::PatchEnd => "PATCH_END",
            VsanAnalyticsEventTypeEnum::DgDecomStart => "DG_DECOM_START",
            VsanAnalyticsEventTypeEnum::DgDecomEnd => "DG_DECOM_END",
            VsanAnalyticsEventTypeEnum::HostDecomStart => "HOST_DECOM_START",
            VsanAnalyticsEventTypeEnum::HostDecomFail => "HOST_DECOM_FAIL",
            VsanAnalyticsEventTypeEnum::HostDecomEnd => "HOST_DECOM_END",
            VsanAnalyticsEventTypeEnum::ClusterCreated => "CLUSTER_CREATED",
            VsanAnalyticsEventTypeEnum::ClusterDeleted => "CLUSTER_DELETED",
            VsanAnalyticsEventTypeEnum::SddcCreated => "SDDC_CREATED",
            VsanAnalyticsEventTypeEnum::SddcDeleted => "SDDC_DELETED",
            VsanAnalyticsEventTypeEnum::HostCreated => "HOST_CREATED",
            VsanAnalyticsEventTypeEnum::HostDeleted => "HOST_DELETED",
            VsanAnalyticsEventTypeEnum::ClusterMembershipChanged => "CLUSTER_MEMBERSHIP_CHANGED",
            VsanAnalyticsEventTypeEnum::DeviceFailure => "DEVICE_FAILURE",
            VsanAnalyticsEventTypeEnum::DeviceNormal => "DEVICE_NORMAL",
            VsanAnalyticsEventTypeEnum::DeviceOffline => "DEVICE_OFFLINE",
            VsanAnalyticsEventTypeEnum::DeviceError => "DEVICE_ERROR",
            VsanAnalyticsEventTypeEnum::HostFailure => "HOST_FAILURE",
            VsanAnalyticsEventTypeEnum::HostNormal => "HOST_NORMAL",
            VsanAnalyticsEventTypeEnum::EventTypeUnknown => "EVENT_TYPE_UNKNOWN",
            VsanAnalyticsEventTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_ANALYTICS_EVENT_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanAnalyticsEventTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanAnalyticsEventTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanAnalyticsEventTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanAnalyticsEventTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanAnalyticsEventTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanAnalyticsEventTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanAnalyticsEventTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanAnalyticsEventTypeEnum> for &'a str {
    fn from(value: &'a VsanAnalyticsEventTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanAnalyticsEventTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_CONFIG_TYPE_ENUM_MAP: phf::Map<&'static str, VsanConfigTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("vsan", VsanConfigTypeEnum::Vsan),
        ("vsanEsa", VsanConfigTypeEnum::VsanEsa),
        ("VsanConfigType_Unknown", VsanConfigTypeEnum::VsanConfigTypeUnknown),
    ],
};

impl VsanConfigTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanConfigTypeEnum::Vsan => "vsan",
            VsanConfigTypeEnum::VsanEsa => "vsanEsa",
            VsanConfigTypeEnum::VsanConfigTypeUnknown => "VsanConfigType_Unknown",
            VsanConfigTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_CONFIG_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanConfigTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanConfigTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanConfigTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanConfigTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanConfigTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanConfigTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanConfigTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanConfigTypeEnum> for &'a str {
    fn from(value: &'a VsanConfigTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanConfigTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_DISK_COMPATIBILITY_TYPE_ENUM_MAP: phf::Map<&'static str, VsanDiskCompatibilityTypeEnum> = ::phf::Map {
    key: 8694567506910003252,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("VsanDiskCompatibilityType_Unknown", VsanDiskCompatibilityTypeEnum::VsanDiskCompatibilityTypeUnknown),
        ("singleTier", VsanDiskCompatibilityTypeEnum::SingleTier),
        ("diskGroup", VsanDiskCompatibilityTypeEnum::DiskGroup),
    ],
};

impl VsanDiskCompatibilityTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanDiskCompatibilityTypeEnum::DiskGroup => "diskGroup",
            VsanDiskCompatibilityTypeEnum::SingleTier => "singleTier",
            VsanDiskCompatibilityTypeEnum::VsanDiskCompatibilityTypeUnknown => "VsanDiskCompatibilityType_Unknown",
            VsanDiskCompatibilityTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_DISK_COMPATIBILITY_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanDiskCompatibilityTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanDiskCompatibilityTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanDiskCompatibilityTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanDiskCompatibilityTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanDiskCompatibilityTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanDiskCompatibilityTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanDiskCompatibilityTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanDiskCompatibilityTypeEnum> for &'a str {
    fn from(value: &'a VsanDiskCompatibilityTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanDiskCompatibilityTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_HEALTH_PERSPECTIVE_ENUM_MAP: phf::Map<&'static str, VsanHealthPerspectiveEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (12, 17),
        (0, 2),
        (1, 9),
        (7, 13),
        (0, 0),
    ],
    entries: &[
        ("vsanUpgradeBeforeExitMM", VsanHealthPerspectiveEnum::VsanUpgradeBeforeExitMm),
        ("VsanHealthPerspective_Unknown", VsanHealthPerspectiveEnum::VsanHealthPerspectiveUnknown),
        ("CreateExtendClusterView", VsanHealthPerspectiveEnum::CreateExtendClusterView),
        ("upgradeAfterExitMMPmanForVMC", VsanHealthPerspectiveEnum::UpgradeAfterExitMmPmanForVmc),
        ("upgradeAfterExitMMPman", VsanHealthPerspectiveEnum::UpgradeAfterExitMmPman),
        ("clusterPowerOffPrecheck", VsanHealthPerspectiveEnum::ClusterPowerOffPrecheck),
        ("defaultView", VsanHealthPerspectiveEnum::DefaultView),
        ("upgradeBeforeExitMM", VsanHealthPerspectiveEnum::UpgradeBeforeExitMm),
        ("upgradePreCheck", VsanHealthPerspectiveEnum::UpgradePreCheck),
        ("vmcUpgradePreChecks", VsanHealthPerspectiveEnum::VmcUpgradePreChecks),
        ("vsanUpgradeAfterExitMM", VsanHealthPerspectiveEnum::VsanUpgradeAfterExitMm),
        ("upgradePreCheckPman", VsanHealthPerspectiveEnum::UpgradePreCheckPman),
        ("upgradeBeforeExitMMPman", VsanHealthPerspectiveEnum::UpgradeBeforeExitMmPman),
        ("inPlaceUpgradeServiceMode", VsanHealthPerspectiveEnum::InPlaceUpgradeServiceMode),
        ("upgradePreCheckPmanForVMC", VsanHealthPerspectiveEnum::UpgradePreCheckPmanForVmc),
        ("beforeConfigureHost", VsanHealthPerspectiveEnum::BeforeConfigureHost),
        ("upgradePreCheckForVCF", VsanHealthPerspectiveEnum::UpgradePreCheckForVcf),
        ("deployAssist", VsanHealthPerspectiveEnum::DeployAssist),
        ("VsanEsaPreChecks", VsanHealthPerspectiveEnum::VsanEsaPreChecks),
        ("upgradeAfterExitMM", VsanHealthPerspectiveEnum::UpgradeAfterExitMm),
        ("upgradeBeforeExitMMPmanForVMC", VsanHealthPerspectiveEnum::UpgradeBeforeExitMmPmanForVmc),
        ("vcsaInstallerForVsanEsa", VsanHealthPerspectiveEnum::VcsaInstallerForVsanEsa),
        ("vsanUpgradePreCheck", VsanHealthPerspectiveEnum::VsanUpgradePreCheck),
    ],
};

impl VsanHealthPerspectiveEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanHealthPerspectiveEnum::DefaultView => "defaultView",
            VsanHealthPerspectiveEnum::DeployAssist => "deployAssist",
            VsanHealthPerspectiveEnum::CreateExtendClusterView => "CreateExtendClusterView",
            VsanHealthPerspectiveEnum::BeforeConfigureHost => "beforeConfigureHost",
            VsanHealthPerspectiveEnum::UpgradePreCheck => "upgradePreCheck",
            VsanHealthPerspectiveEnum::VsanUpgradePreCheck => "vsanUpgradePreCheck",
            VsanHealthPerspectiveEnum::UpgradeBeforeExitMm => "upgradeBeforeExitMM",
            VsanHealthPerspectiveEnum::UpgradeAfterExitMm => "upgradeAfterExitMM",
            VsanHealthPerspectiveEnum::VsanUpgradeBeforeExitMm => "vsanUpgradeBeforeExitMM",
            VsanHealthPerspectiveEnum::VsanUpgradeAfterExitMm => "vsanUpgradeAfterExitMM",
            VsanHealthPerspectiveEnum::VmcUpgradePreChecks => "vmcUpgradePreChecks",
            VsanHealthPerspectiveEnum::UpgradePreCheckPman => "upgradePreCheckPman",
            VsanHealthPerspectiveEnum::UpgradeBeforeExitMmPman => "upgradeBeforeExitMMPman",
            VsanHealthPerspectiveEnum::UpgradeAfterExitMmPman => "upgradeAfterExitMMPman",
            VsanHealthPerspectiveEnum::InPlaceUpgradeServiceMode => "inPlaceUpgradeServiceMode",
            VsanHealthPerspectiveEnum::UpgradePreCheckPmanForVmc => "upgradePreCheckPmanForVMC",
            VsanHealthPerspectiveEnum::UpgradeBeforeExitMmPmanForVmc => "upgradeBeforeExitMMPmanForVMC",
            VsanHealthPerspectiveEnum::UpgradeAfterExitMmPmanForVmc => "upgradeAfterExitMMPmanForVMC",
            VsanHealthPerspectiveEnum::ClusterPowerOffPrecheck => "clusterPowerOffPrecheck",
            VsanHealthPerspectiveEnum::VsanEsaPreChecks => "VsanEsaPreChecks",
            VsanHealthPerspectiveEnum::VcsaInstallerForVsanEsa => "vcsaInstallerForVsanEsa",
            VsanHealthPerspectiveEnum::UpgradePreCheckForVcf => "upgradePreCheckForVCF",
            VsanHealthPerspectiveEnum::VsanHealthPerspectiveUnknown => "VsanHealthPerspective_Unknown",
            VsanHealthPerspectiveEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_HEALTH_PERSPECTIVE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanHealthPerspectiveEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanHealthPerspectiveEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanHealthPerspectiveEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanHealthPerspectiveEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanHealthPerspectiveEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanHealthPerspectiveEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanHealthPerspectiveEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanHealthPerspectiveEnum> for &'a str {
    fn from(value: &'a VsanHealthPerspectiveEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanHealthPerspectiveEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_HEALTH_PERSPECTIVE_90_ENUM_MAP: phf::Map<&'static str, VsanHealthPerspective90Enum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("siteEnterMaintenance", VsanHealthPerspective90Enum::SiteEnterMaintenance),
    ],
};

impl VsanHealthPerspective90Enum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanHealthPerspective90Enum::SiteEnterMaintenance => "siteEnterMaintenance",
            VsanHealthPerspective90Enum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_HEALTH_PERSPECTIVE_90_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanHealthPerspective90Enum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanHealthPerspective90Enum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanHealthPerspective90Enum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanHealthPerspective90Enum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanHealthPerspective90Enum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanHealthPerspective90Enum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanHealthPerspective90Enum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanHealthPerspective90Enum> for &'a str {
    fn from(value: &'a VsanHealthPerspective90Enum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanHealthPerspective90Enum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_HEALTH_STATUS_TYPE_ENUM_MAP: phf::Map<&'static str, VsanHealthStatusTypeEnum> = ::phf::Map {
    key: 351906021642186605,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("red", VsanHealthStatusTypeEnum::Red),
        ("yellow", VsanHealthStatusTypeEnum::Yellow),
        ("unknown", VsanHealthStatusTypeEnum::Unknown),
        ("green", VsanHealthStatusTypeEnum::Green),
    ],
};

impl VsanHealthStatusTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanHealthStatusTypeEnum::Unknown => "unknown",
            VsanHealthStatusTypeEnum::Yellow => "yellow",
            VsanHealthStatusTypeEnum::Red => "red",
            VsanHealthStatusTypeEnum::Green => "green",
            VsanHealthStatusTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_HEALTH_STATUS_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanHealthStatusTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanHealthStatusTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanHealthStatusTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanHealthStatusTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanHealthStatusTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanHealthStatusTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanHealthStatusTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanHealthStatusTypeEnum> for &'a str {
    fn from(value: &'a VsanHealthStatusTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanHealthStatusTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_HEALTH_THRESHOLD_TARGET_ENUM_MAP: phf::Map<&'static str, VsanHealthThresholdTargetEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("diskspace_vsan_datastore", VsanHealthThresholdTargetEnum::DiskspaceVsanDatastore),
        ("diskspace_vsan_pmem", VsanHealthThresholdTargetEnum::DiskspaceVsanPmem),
        ("VsanHealthThresholdTarget_Unknown", VsanHealthThresholdTargetEnum::VsanHealthThresholdTargetUnknown),
        ("diskspace_vsan_direct", VsanHealthThresholdTargetEnum::DiskspaceVsanDirect),
    ],
};

impl VsanHealthThresholdTargetEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanHealthThresholdTargetEnum::DiskspaceVsanDatastore => "diskspace_vsan_datastore",
            VsanHealthThresholdTargetEnum::DiskspaceVsanDirect => "diskspace_vsan_direct",
            VsanHealthThresholdTargetEnum::DiskspaceVsanPmem => "diskspace_vsan_pmem",
            VsanHealthThresholdTargetEnum::VsanHealthThresholdTargetUnknown => "VsanHealthThresholdTarget_Unknown",
            VsanHealthThresholdTargetEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_HEALTH_THRESHOLD_TARGET_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanHealthThresholdTargetEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanHealthThresholdTargetEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanHealthThresholdTargetEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanHealthThresholdTargetEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanHealthThresholdTargetEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanHealthThresholdTargetEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanHealthThresholdTargetEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanHealthThresholdTargetEnum> for &'a str {
    fn from(value: &'a VsanHealthThresholdTargetEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanHealthThresholdTargetEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_IO_TRIP_ANALYZER_RECURRENCE_STATUS_ENUM_MAP: phf::Map<&'static str, VsanIoTripAnalyzerRecurrenceStatusEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("recurrenceEnabled", VsanIoTripAnalyzerRecurrenceStatusEnum::RecurrenceEnabled),
        ("VsanIOTripAnalyzerRecurrenceStatus_Unknown", VsanIoTripAnalyzerRecurrenceStatusEnum::VsanIoTripAnalyzerRecurrenceStatusUnknown),
        ("recurrenceDisabled", VsanIoTripAnalyzerRecurrenceStatusEnum::RecurrenceDisabled),
    ],
};

impl VsanIoTripAnalyzerRecurrenceStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanIoTripAnalyzerRecurrenceStatusEnum::RecurrenceEnabled => "recurrenceEnabled",
            VsanIoTripAnalyzerRecurrenceStatusEnum::RecurrenceDisabled => "recurrenceDisabled",
            VsanIoTripAnalyzerRecurrenceStatusEnum::VsanIoTripAnalyzerRecurrenceStatusUnknown => "VsanIOTripAnalyzerRecurrenceStatus_Unknown",
            VsanIoTripAnalyzerRecurrenceStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_IO_TRIP_ANALYZER_RECURRENCE_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanIoTripAnalyzerRecurrenceStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanIoTripAnalyzerRecurrenceStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanIoTripAnalyzerRecurrenceStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanIoTripAnalyzerRecurrenceStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanIoTripAnalyzerRecurrenceStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanIoTripAnalyzerRecurrenceStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanIoTripAnalyzerRecurrenceStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanIoTripAnalyzerRecurrenceStatusEnum> for &'a str {
    fn from(value: &'a VsanIoTripAnalyzerRecurrenceStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanIoTripAnalyzerRecurrenceStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_POLICY_REGULATION_CHECK_OP_ENUM_ENUM_MAP: phf::Map<&'static str, VsanPolicyRegulationCheckOpEnumEnum> = ::phf::Map {
    key: 12213676231523076107,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("less", VsanPolicyRegulationCheckOpEnumEnum::Less),
        ("equal", VsanPolicyRegulationCheckOpEnumEnum::Equal),
        ("greater", VsanPolicyRegulationCheckOpEnumEnum::Greater),
        ("noless", VsanPolicyRegulationCheckOpEnumEnum::Noless),
        ("nogreater", VsanPolicyRegulationCheckOpEnumEnum::Nogreater),
    ],
};

impl VsanPolicyRegulationCheckOpEnumEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanPolicyRegulationCheckOpEnumEnum::Equal => "equal",
            VsanPolicyRegulationCheckOpEnumEnum::Greater => "greater",
            VsanPolicyRegulationCheckOpEnumEnum::Nogreater => "nogreater",
            VsanPolicyRegulationCheckOpEnumEnum::Less => "less",
            VsanPolicyRegulationCheckOpEnumEnum::Noless => "noless",
            VsanPolicyRegulationCheckOpEnumEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_POLICY_REGULATION_CHECK_OP_ENUM_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanPolicyRegulationCheckOpEnumEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanPolicyRegulationCheckOpEnumEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanPolicyRegulationCheckOpEnumEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanPolicyRegulationCheckOpEnumEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanPolicyRegulationCheckOpEnumEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanPolicyRegulationCheckOpEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanPolicyRegulationCheckOpEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanPolicyRegulationCheckOpEnumEnum> for &'a str {
    fn from(value: &'a VsanPolicyRegulationCheckOpEnumEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanPolicyRegulationCheckOpEnumEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIM_VSAN_VSAN_SCAN_OBJECTS_ISSUE_TYPE_ENUM_MAP: phf::Map<&'static str, VimVsanVsanScanObjectsIssueTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("LEAKED_OBJECT", VimVsanVsanScanObjectsIssueTypeEnum::LeakedObject),
        ("UNKNOWN", VimVsanVsanScanObjectsIssueTypeEnum::Unknown),
        ("BROKEN_CHAIN", VimVsanVsanScanObjectsIssueTypeEnum::BrokenChain),
    ],
};

impl VimVsanVsanScanObjectsIssueTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VimVsanVsanScanObjectsIssueTypeEnum::BrokenChain => "BROKEN_CHAIN",
            VimVsanVsanScanObjectsIssueTypeEnum::LeakedObject => "LEAKED_OBJECT",
            VimVsanVsanScanObjectsIssueTypeEnum::Unknown => "UNKNOWN",
            VimVsanVsanScanObjectsIssueTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIM_VSAN_VSAN_SCAN_OBJECTS_ISSUE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VimVsanVsanScanObjectsIssueTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VimVsanVsanScanObjectsIssueTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VimVsanVsanScanObjectsIssueTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VimVsanVsanScanObjectsIssueTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VimVsanVsanScanObjectsIssueTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VimVsanVsanScanObjectsIssueTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VimVsanVsanScanObjectsIssueTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VimVsanVsanScanObjectsIssueTypeEnum> for &'a str {
    fn from(value: &'a VimVsanVsanScanObjectsIssueTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VimVsanVsanScanObjectsIssueTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_SERVICE_STATUS_ENUM_MAP: phf::Map<&'static str, VsanServiceStatusEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("started", VsanServiceStatusEnum::Started),
        ("VsanServiceStatus_Unknown", VsanServiceStatusEnum::VsanServiceStatusUnknown),
        ("stopped", VsanServiceStatusEnum::Stopped),
    ],
};

impl VsanServiceStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanServiceStatusEnum::Started => "started",
            VsanServiceStatusEnum::Stopped => "stopped",
            VsanServiceStatusEnum::VsanServiceStatusUnknown => "VsanServiceStatus_Unknown",
            VsanServiceStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_SERVICE_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanServiceStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanServiceStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanServiceStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanServiceStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanServiceStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanServiceStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanServiceStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanServiceStatusEnum> for &'a str {
    fn from(value: &'a VsanServiceStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanServiceStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_SITE_LOCATION_TYPE_ENUM_MAP: phf::Map<&'static str, VsanSiteLocationTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (3, 0),
    ],
    entries: &[
        ("NonPreferred", VsanSiteLocationTypeEnum::NonPreferred),
        ("Preferred", VsanSiteLocationTypeEnum::Preferred),
        ("VsanSiteLocationType_Unknown", VsanSiteLocationTypeEnum::VsanSiteLocationTypeUnknown),
        ("None", VsanSiteLocationTypeEnum::None),
    ],
};

impl VsanSiteLocationTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanSiteLocationTypeEnum::None => "None",
            VsanSiteLocationTypeEnum::Preferred => "Preferred",
            VsanSiteLocationTypeEnum::NonPreferred => "NonPreferred",
            VsanSiteLocationTypeEnum::VsanSiteLocationTypeUnknown => "VsanSiteLocationType_Unknown",
            VsanSiteLocationTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_SITE_LOCATION_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanSiteLocationTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanSiteLocationTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanSiteLocationTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanSiteLocationTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanSiteLocationTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanSiteLocationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanSiteLocationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanSiteLocationTypeEnum> for &'a str {
    fn from(value: &'a VsanSiteLocationTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanSiteLocationTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_SNAP_HEALTH_TYPE_ENUM_MAP: phf::Map<&'static str, VsanSnapHealthTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("vmSnapshotsHealth", VsanSnapHealthTypeEnum::VmSnapshotsHealth),
        ("VsanSnapHealthType_Unknown", VsanSnapHealthTypeEnum::VsanSnapHealthTypeUnknown),
        ("vmMembershipChanges", VsanSnapHealthTypeEnum::VmMembershipChanges),
        ("applianceHealth", VsanSnapHealthTypeEnum::ApplianceHealth),
        ("pgSnapshotsHealth", VsanSnapHealthTypeEnum::PgSnapshotsHealth),
    ],
};

impl VsanSnapHealthTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanSnapHealthTypeEnum::ApplianceHealth => "applianceHealth",
            VsanSnapHealthTypeEnum::PgSnapshotsHealth => "pgSnapshotsHealth",
            VsanSnapHealthTypeEnum::VmSnapshotsHealth => "vmSnapshotsHealth",
            VsanSnapHealthTypeEnum::VmMembershipChanges => "vmMembershipChanges",
            VsanSnapHealthTypeEnum::VsanSnapHealthTypeUnknown => "VsanSnapHealthType_Unknown",
            VsanSnapHealthTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_SNAP_HEALTH_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanSnapHealthTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanSnapHealthTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanSnapHealthTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanSnapHealthTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanSnapHealthTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanSnapHealthTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanSnapHealthTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanSnapHealthTypeEnum> for &'a str {
    fn from(value: &'a VsanSnapHealthTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanSnapHealthTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_SNAP_STATS_EXPIRATION_TYPE_ENUM_MAP: phf::Map<&'static str, VsanSnapStatsExpirationTypeEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("afterTtl", VsanSnapStatsExpirationTypeEnum::AfterTtl),
        ("afterSet", VsanSnapStatsExpirationTypeEnum::AfterSet),
        ("afterGet", VsanSnapStatsExpirationTypeEnum::AfterGet),
        ("never", VsanSnapStatsExpirationTypeEnum::Never),
        ("VsanSnapStatsExpirationType_Unknown", VsanSnapStatsExpirationTypeEnum::VsanSnapStatsExpirationTypeUnknown),
    ],
};

impl VsanSnapStatsExpirationTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanSnapStatsExpirationTypeEnum::AfterSet => "afterSet",
            VsanSnapStatsExpirationTypeEnum::AfterGet => "afterGet",
            VsanSnapStatsExpirationTypeEnum::AfterTtl => "afterTtl",
            VsanSnapStatsExpirationTypeEnum::Never => "never",
            VsanSnapStatsExpirationTypeEnum::VsanSnapStatsExpirationTypeUnknown => "VsanSnapStatsExpirationType_Unknown",
            VsanSnapStatsExpirationTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_SNAP_STATS_EXPIRATION_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanSnapStatsExpirationTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanSnapStatsExpirationTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanSnapStatsExpirationTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanSnapStatsExpirationTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanSnapStatsExpirationTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanSnapStatsExpirationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanSnapStatsExpirationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanSnapStatsExpirationTypeEnum> for &'a str {
    fn from(value: &'a VsanSnapStatsExpirationTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanSnapStatsExpirationTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_SNAP_VM_MEMBERSHIP_CHANGE_STATUS_ENUM_MAP: phf::Map<&'static str, VsanSnapVmMembershipChangeStatusEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("VsanSnapVmMembershipChangeStatus_Unknown", VsanSnapVmMembershipChangeStatusEnum::VsanSnapVmMembershipChangeStatusUnknown),
        ("added", VsanSnapVmMembershipChangeStatusEnum::Added),
        ("removed", VsanSnapVmMembershipChangeStatusEnum::Removed),
    ],
};

impl VsanSnapVmMembershipChangeStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanSnapVmMembershipChangeStatusEnum::Added => "added",
            VsanSnapVmMembershipChangeStatusEnum::Removed => "removed",
            VsanSnapVmMembershipChangeStatusEnum::VsanSnapVmMembershipChangeStatusUnknown => "VsanSnapVmMembershipChangeStatus_Unknown",
            VsanSnapVmMembershipChangeStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_SNAP_VM_MEMBERSHIP_CHANGE_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanSnapVmMembershipChangeStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanSnapVmMembershipChangeStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanSnapVmMembershipChangeStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanSnapVmMembershipChangeStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanSnapVmMembershipChangeStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanSnapVmMembershipChangeStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanSnapVmMembershipChangeStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanSnapVmMembershipChangeStatusEnum> for &'a str {
    fn from(value: &'a VsanSnapVmMembershipChangeStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanSnapVmMembershipChangeStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_SYNC_REASON_ENUM_MAP: phf::Map<&'static str, VsanSyncReasonEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (8, 6),
        (7, 0),
    ],
    entries: &[
        ("reconfigure", VsanSyncReasonEnum::Reconfigure),
        ("evacuate", VsanSyncReasonEnum::Evacuate),
        ("dying_evacuate", VsanSyncReasonEnum::DyingEvacuate),
        ("stale", VsanSyncReasonEnum::Stale),
        ("rebalance", VsanSyncReasonEnum::Rebalance),
        ("VsanSyncReason_Unknown", VsanSyncReasonEnum::VsanSyncReasonUnknown),
        ("object_format_change", VsanSyncReasonEnum::ObjectFormatChange),
        ("merge_concat", VsanSyncReasonEnum::MergeConcat),
        ("repair", VsanSyncReasonEnum::Repair),
    ],
};

impl VsanSyncReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanSyncReasonEnum::Repair => "repair",
            VsanSyncReasonEnum::Evacuate => "evacuate",
            VsanSyncReasonEnum::Rebalance => "rebalance",
            VsanSyncReasonEnum::Reconfigure => "reconfigure",
            VsanSyncReasonEnum::DyingEvacuate => "dying_evacuate",
            VsanSyncReasonEnum::Stale => "stale",
            VsanSyncReasonEnum::MergeConcat => "merge_concat",
            VsanSyncReasonEnum::ObjectFormatChange => "object_format_change",
            VsanSyncReasonEnum::VsanSyncReasonUnknown => "VsanSyncReason_Unknown",
            VsanSyncReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_SYNC_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanSyncReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanSyncReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanSyncReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanSyncReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanSyncReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanSyncReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanSyncReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanSyncReasonEnum> for &'a str {
    fn from(value: &'a VsanSyncReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanSyncReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_SYNC_STATUS_ENUM_MAP: phf::Map<&'static str, VsanSyncStatusEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("queued", VsanSyncStatusEnum::Queued),
        ("VsanSyncStatus_Unknown", VsanSyncStatusEnum::VsanSyncStatusUnknown),
        ("active", VsanSyncStatusEnum::Active),
        ("suspended", VsanSyncStatusEnum::Suspended),
    ],
};

impl VsanSyncStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanSyncStatusEnum::Active => "active",
            VsanSyncStatusEnum::Queued => "queued",
            VsanSyncStatusEnum::Suspended => "suspended",
            VsanSyncStatusEnum::VsanSyncStatusUnknown => "VsanSyncStatus_Unknown",
            VsanSyncStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_SYNC_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanSyncStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanSyncStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanSyncStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanSyncStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanSyncStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanSyncStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanSyncStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanSyncStatusEnum> for &'a str {
    fn from(value: &'a VsanSyncStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanSyncStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_UPDATE_ITEM_IMPACT_TYPE_ENUM_MAP: phf::Map<&'static str, VsanUpdateItemImpactTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("reboot", VsanUpdateItemImpactTypeEnum::Reboot),
        ("VsanUpdateItemImpactType_Unknown", VsanUpdateItemImpactTypeEnum::VsanUpdateItemImpactTypeUnknown),
    ],
};

impl VsanUpdateItemImpactTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanUpdateItemImpactTypeEnum::Reboot => "reboot",
            VsanUpdateItemImpactTypeEnum::VsanUpdateItemImpactTypeUnknown => "VsanUpdateItemImpactType_Unknown",
            VsanUpdateItemImpactTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_UPDATE_ITEM_IMPACT_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanUpdateItemImpactTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanUpdateItemImpactTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanUpdateItemImpactTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanUpdateItemImpactTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanUpdateItemImpactTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanUpdateItemImpactTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanUpdateItemImpactTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanUpdateItemImpactTypeEnum> for &'a str {
    fn from(value: &'a VsanUpdateItemImpactTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanUpdateItemImpactTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_UPDATE_ITEM_TYPE_ENUM_MAP: phf::Map<&'static str, VsanUpdateItemTypeEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (4, 0),
    ],
    entries: &[
        ("vmhbaFirmware", VsanUpdateItemTypeEnum::VmhbaFirmware),
        ("vib", VsanUpdateItemTypeEnum::Vib),
        ("VsanUpdateItemType_Unknown", VsanUpdateItemTypeEnum::VsanUpdateItemTypeUnknown),
        ("offlinebundle", VsanUpdateItemTypeEnum::Offlinebundle),
        ("fullStackFirmware", VsanUpdateItemTypeEnum::FullStackFirmware),
    ],
};

impl VsanUpdateItemTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanUpdateItemTypeEnum::Vib => "vib",
            VsanUpdateItemTypeEnum::Offlinebundle => "offlinebundle",
            VsanUpdateItemTypeEnum::VmhbaFirmware => "vmhbaFirmware",
            VsanUpdateItemTypeEnum::FullStackFirmware => "fullStackFirmware",
            VsanUpdateItemTypeEnum::VsanUpdateItemTypeUnknown => "VsanUpdateItemType_Unknown",
            VsanUpdateItemTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_UPDATE_ITEM_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanUpdateItemTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanUpdateItemTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanUpdateItemTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanUpdateItemTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanUpdateItemTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanUpdateItemTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanUpdateItemTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanUpdateItemTypeEnum> for &'a str {
    fn from(value: &'a VsanUpdateItemTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanUpdateItemTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIM_VSAN_VSAN_VCSA_DEPLOYMENT_PHASE_ENUM_MAP: phf::Map<&'static str, VimVsanVsanVcsaDeploymentPhaseEnum> = ::phf::Map {
    key: 14108922650502679131,
    disps: &[
        (2, 0),
        (1, 1),
    ],
    entries: &[
        ("done", VimVsanVsanVcsaDeploymentPhaseEnum::Done),
        ("failed", VimVsanVsanVcsaDeploymentPhaseEnum::Failed),
        ("vsanbootstrap", VimVsanVsanVcsaDeploymentPhaseEnum::Vsanbootstrap),
        ("ovaunpack", VimVsanVsanVcsaDeploymentPhaseEnum::Ovaunpack),
        ("vcconfig", VimVsanVsanVcsaDeploymentPhaseEnum::Vcconfig),
        ("initializing", VimVsanVsanVcsaDeploymentPhaseEnum::Initializing),
        ("validation", VimVsanVsanVcsaDeploymentPhaseEnum::Validation),
        ("VsanVcsaDeploymentPhase_Unknown", VimVsanVsanVcsaDeploymentPhaseEnum::VsanVcsaDeploymentPhaseUnknown),
        ("vcsadeploy", VimVsanVsanVcsaDeploymentPhaseEnum::Vcsadeploy),
    ],
};

impl VimVsanVsanVcsaDeploymentPhaseEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VimVsanVsanVcsaDeploymentPhaseEnum::Initializing => "initializing",
            VimVsanVsanVcsaDeploymentPhaseEnum::Validation => "validation",
            VimVsanVsanVcsaDeploymentPhaseEnum::Vsanbootstrap => "vsanbootstrap",
            VimVsanVsanVcsaDeploymentPhaseEnum::Ovaunpack => "ovaunpack",
            VimVsanVsanVcsaDeploymentPhaseEnum::Vcsadeploy => "vcsadeploy",
            VimVsanVsanVcsaDeploymentPhaseEnum::Vcconfig => "vcconfig",
            VimVsanVsanVcsaDeploymentPhaseEnum::Done => "done",
            VimVsanVsanVcsaDeploymentPhaseEnum::Failed => "failed",
            VimVsanVsanVcsaDeploymentPhaseEnum::VsanVcsaDeploymentPhaseUnknown => "VsanVcsaDeploymentPhase_Unknown",
            VimVsanVsanVcsaDeploymentPhaseEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIM_VSAN_VSAN_VCSA_DEPLOYMENT_PHASE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VimVsanVsanVcsaDeploymentPhaseEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VimVsanVsanVcsaDeploymentPhaseEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VimVsanVsanVcsaDeploymentPhaseEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VimVsanVsanVcsaDeploymentPhaseEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VimVsanVsanVcsaDeploymentPhaseEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VimVsanVsanVcsaDeploymentPhaseEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VimVsanVsanVcsaDeploymentPhaseEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VimVsanVsanVcsaDeploymentPhaseEnum> for &'a str {
    fn from(value: &'a VimVsanVsanVcsaDeploymentPhaseEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VimVsanVsanVcsaDeploymentPhaseEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_VIB_TYPE_ENUM_MAP: phf::Map<&'static str, VsanVibTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("VsanVibType_Unknown", VsanVibTypeEnum::VsanVibTypeUnknown),
        ("driver", VsanVibTypeEnum::Driver),
        ("tool", VsanVibTypeEnum::Tool),
    ],
};

impl VsanVibTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanVibTypeEnum::Tool => "tool",
            VsanVibTypeEnum::Driver => "driver",
            VsanVibTypeEnum::VsanVibTypeUnknown => "VsanVibType_Unknown",
            VsanVibTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_VIB_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanVibTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanVibTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanVibTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanVibTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanVibTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanVibTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanVibTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanVibTypeEnum> for &'a str {
    fn from(value: &'a VsanVibTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanVibTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_XVC_QUERY_CRITERIA_OPERATOR_ENUM_MAP: phf::Map<&'static str, VsanXvcQueryCriteriaOperatorEnum> = ::phf::Map {
    key: 106375038446233661,
    disps: &[
        (3, 2),
        (2, 0),
        (1, 2),
    ],
    entries: &[
        ("Like", VsanXvcQueryCriteriaOperatorEnum::Like),
        ("Unset", VsanXvcQueryCriteriaOperatorEnum::Unset),
        ("LessOrEqual", VsanXvcQueryCriteriaOperatorEnum::LessOrEqual),
        ("NotEqual", VsanXvcQueryCriteriaOperatorEnum::NotEqual),
        ("Equal", VsanXvcQueryCriteriaOperatorEnum::Equal),
        ("GreaterOrEqual", VsanXvcQueryCriteriaOperatorEnum::GreaterOrEqual),
        ("Less", VsanXvcQueryCriteriaOperatorEnum::Less),
        ("VsanXvcQueryCriteriaOperator_unknown", VsanXvcQueryCriteriaOperatorEnum::VsanXvcQueryCriteriaOperatorUnknown),
        ("NotIn", VsanXvcQueryCriteriaOperatorEnum::NotIn),
        ("In", VsanXvcQueryCriteriaOperatorEnum::In),
        ("NotLike", VsanXvcQueryCriteriaOperatorEnum::NotLike),
        ("Greater", VsanXvcQueryCriteriaOperatorEnum::Greater),
    ],
};

impl VsanXvcQueryCriteriaOperatorEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanXvcQueryCriteriaOperatorEnum::Equal => "Equal",
            VsanXvcQueryCriteriaOperatorEnum::NotEqual => "NotEqual",
            VsanXvcQueryCriteriaOperatorEnum::Greater => "Greater",
            VsanXvcQueryCriteriaOperatorEnum::GreaterOrEqual => "GreaterOrEqual",
            VsanXvcQueryCriteriaOperatorEnum::Less => "Less",
            VsanXvcQueryCriteriaOperatorEnum::LessOrEqual => "LessOrEqual",
            VsanXvcQueryCriteriaOperatorEnum::In => "In",
            VsanXvcQueryCriteriaOperatorEnum::NotIn => "NotIn",
            VsanXvcQueryCriteriaOperatorEnum::Like => "Like",
            VsanXvcQueryCriteriaOperatorEnum::NotLike => "NotLike",
            VsanXvcQueryCriteriaOperatorEnum::Unset => "Unset",
            VsanXvcQueryCriteriaOperatorEnum::VsanXvcQueryCriteriaOperatorUnknown => "VsanXvcQueryCriteriaOperator_unknown",
            VsanXvcQueryCriteriaOperatorEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_XVC_QUERY_CRITERIA_OPERATOR_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanXvcQueryCriteriaOperatorEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanXvcQueryCriteriaOperatorEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanXvcQueryCriteriaOperatorEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanXvcQueryCriteriaOperatorEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanXvcQueryCriteriaOperatorEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanXvcQueryCriteriaOperatorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanXvcQueryCriteriaOperatorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanXvcQueryCriteriaOperatorEnum> for &'a str {
    fn from(value: &'a VsanXvcQueryCriteriaOperatorEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanXvcQueryCriteriaOperatorEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_XVC_QUERY_FILTER_OPERATOR_ENUM_MAP: phf::Map<&'static str, VsanXvcQueryFilterOperatorEnum> = ::phf::Map {
    key: 8694567506910003252,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("Op_unknown", VsanXvcQueryFilterOperatorEnum::OpUnknown),
        ("And", VsanXvcQueryFilterOperatorEnum::And),
        ("Or", VsanXvcQueryFilterOperatorEnum::Or),
    ],
};

impl VsanXvcQueryFilterOperatorEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanXvcQueryFilterOperatorEnum::And => "And",
            VsanXvcQueryFilterOperatorEnum::Or => "Or",
            VsanXvcQueryFilterOperatorEnum::OpUnknown => "Op_unknown",
            VsanXvcQueryFilterOperatorEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_XVC_QUERY_FILTER_OPERATOR_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanXvcQueryFilterOperatorEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanXvcQueryFilterOperatorEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanXvcQueryFilterOperatorEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanXvcQueryFilterOperatorEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanXvcQueryFilterOperatorEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanXvcQueryFilterOperatorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanXvcQueryFilterOperatorEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanXvcQueryFilterOperatorEnum> for &'a str {
    fn from(value: &'a VsanXvcQueryFilterOperatorEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanXvcQueryFilterOperatorEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIM_VSAN_CLUSTER_COMPLIANCE_RESOURCE_CHECK_STATUS_TYPE_ENUM_MAP: phf::Map<&'static str, VimVsanClusterComplianceResourceCheckStatusTypeEnum> = ::phf::Map {
    key: 8694567506910003252,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("aborted", VimVsanClusterComplianceResourceCheckStatusTypeEnum::Aborted),
        ("ComplianceResourceCheckStatusType_Unknown", VimVsanClusterComplianceResourceCheckStatusTypeEnum::ComplianceResourceCheckStatusTypeUnknown),
        ("completed", VimVsanClusterComplianceResourceCheckStatusTypeEnum::Completed),
        ("uninitialized", VimVsanClusterComplianceResourceCheckStatusTypeEnum::Uninitialized),
        ("inProgress", VimVsanClusterComplianceResourceCheckStatusTypeEnum::InProgress),
    ],
};

impl VimVsanClusterComplianceResourceCheckStatusTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VimVsanClusterComplianceResourceCheckStatusTypeEnum::InProgress => "inProgress",
            VimVsanClusterComplianceResourceCheckStatusTypeEnum::Aborted => "aborted",
            VimVsanClusterComplianceResourceCheckStatusTypeEnum::Completed => "completed",
            VimVsanClusterComplianceResourceCheckStatusTypeEnum::Uninitialized => "uninitialized",
            VimVsanClusterComplianceResourceCheckStatusTypeEnum::ComplianceResourceCheckStatusTypeUnknown => "ComplianceResourceCheckStatusType_Unknown",
            VimVsanClusterComplianceResourceCheckStatusTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIM_VSAN_CLUSTER_COMPLIANCE_RESOURCE_CHECK_STATUS_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VimVsanClusterComplianceResourceCheckStatusTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VimVsanClusterComplianceResourceCheckStatusTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VimVsanClusterComplianceResourceCheckStatusTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VimVsanClusterComplianceResourceCheckStatusTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VimVsanClusterComplianceResourceCheckStatusTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VimVsanClusterComplianceResourceCheckStatusTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VimVsanClusterComplianceResourceCheckStatusTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VimVsanClusterComplianceResourceCheckStatusTypeEnum> for &'a str {
    fn from(value: &'a VimVsanClusterComplianceResourceCheckStatusTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VimVsanClusterComplianceResourceCheckStatusTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIM_VSAN_CLUSTER_VSAN_MANAGED_STORAGE_TYPE_ENUM_MAP: phf::Map<&'static str, VimVsanClusterVsanManagedStorageTypeEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("pmem", VimVsanClusterVsanManagedStorageTypeEnum::Pmem),
        ("VsanManagedStorageType_Unknown", VimVsanClusterVsanManagedStorageTypeEnum::VsanManagedStorageTypeUnknown),
        ("vsandirect", VimVsanClusterVsanManagedStorageTypeEnum::Vsandirect),
    ],
};

impl VimVsanClusterVsanManagedStorageTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VimVsanClusterVsanManagedStorageTypeEnum::Vsandirect => "vsandirect",
            VimVsanClusterVsanManagedStorageTypeEnum::Pmem => "pmem",
            VimVsanClusterVsanManagedStorageTypeEnum::VsanManagedStorageTypeUnknown => "VsanManagedStorageType_Unknown",
            VimVsanClusterVsanManagedStorageTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIM_VSAN_CLUSTER_VSAN_MANAGED_STORAGE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VimVsanClusterVsanManagedStorageTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VimVsanClusterVsanManagedStorageTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VimVsanClusterVsanManagedStorageTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VimVsanClusterVsanManagedStorageTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VimVsanClusterVsanManagedStorageTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VimVsanClusterVsanManagedStorageTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VimVsanClusterVsanManagedStorageTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VimVsanClusterVsanManagedStorageTypeEnum> for &'a str {
    fn from(value: &'a VimVsanClusterVsanManagedStorageTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VimVsanClusterVsanManagedStorageTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static CLUSTER_POWER_STATE_ENUM_MAP: phf::Map<&'static str, ClusterPowerStateEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("ClusterPowerState_Unknown", ClusterPowerStateEnum::ClusterPowerStateUnknown),
        ("poweringOn", ClusterPowerStateEnum::PoweringOn),
        ("poweredOn", ClusterPowerStateEnum::PoweredOn),
        ("poweringOff", ClusterPowerStateEnum::PoweringOff),
        ("poweredOff", ClusterPowerStateEnum::PoweredOff),
    ],
};

impl ClusterPowerStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ClusterPowerStateEnum::PoweredOn => "poweredOn",
            ClusterPowerStateEnum::PoweredOff => "poweredOff",
            ClusterPowerStateEnum::PoweringOn => "poweringOn",
            ClusterPowerStateEnum::PoweringOff => "poweringOff",
            ClusterPowerStateEnum::ClusterPowerStateUnknown => "ClusterPowerState_Unknown",
            ClusterPowerStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        CLUSTER_POWER_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ClusterPowerStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ClusterPowerStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ClusterPowerStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ClusterPowerStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ClusterPowerStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ClusterPowerStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ClusterPowerStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ClusterPowerStateEnum> for &'a str {
    fn from(value: &'a ClusterPowerStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ClusterPowerStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_COMPLIANCE_STATUS_ENUM_MAP: phf::Map<&'static str, VsanComplianceStatusEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (1, 0),
        (1, 0),
    ],
    entries: &[
        ("ComplianceStatus_Unknown", VsanComplianceStatusEnum::ComplianceStatusUnknown),
        ("compliant", VsanComplianceStatusEnum::Compliant),
        ("outOfDate", VsanComplianceStatusEnum::OutOfDate),
        ("nonCompliant", VsanComplianceStatusEnum::NonCompliant),
        ("unknown", VsanComplianceStatusEnum::Unknown),
        ("notApplicable", VsanComplianceStatusEnum::NotApplicable),
    ],
};

impl VsanComplianceStatusEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanComplianceStatusEnum::Compliant => "compliant",
            VsanComplianceStatusEnum::NonCompliant => "nonCompliant",
            VsanComplianceStatusEnum::Unknown => "unknown",
            VsanComplianceStatusEnum::NotApplicable => "notApplicable",
            VsanComplianceStatusEnum::OutOfDate => "outOfDate",
            VsanComplianceStatusEnum::ComplianceStatusUnknown => "ComplianceStatus_Unknown",
            VsanComplianceStatusEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_COMPLIANCE_STATUS_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanComplianceStatusEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanComplianceStatusEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanComplianceStatusEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanComplianceStatusEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanComplianceStatusEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanComplianceStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanComplianceStatusEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanComplianceStatusEnum> for &'a str {
    fn from(value: &'a VsanComplianceStatusEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanComplianceStatusEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_HOST_DECOMMISSION_MODE_OBJECT_ACTION_ENUM_MAP: phf::Map<&'static str, VsanHostDecommissionModeObjectActionEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("evacuateAllData", VsanHostDecommissionModeObjectActionEnum::EvacuateAllData),
        ("ensureObjectAccessibility", VsanHostDecommissionModeObjectActionEnum::EnsureObjectAccessibility),
        ("noAction", VsanHostDecommissionModeObjectActionEnum::NoAction),
    ],
};

impl VsanHostDecommissionModeObjectActionEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanHostDecommissionModeObjectActionEnum::NoAction => "noAction",
            VsanHostDecommissionModeObjectActionEnum::EnsureObjectAccessibility => "ensureObjectAccessibility",
            VsanHostDecommissionModeObjectActionEnum::EvacuateAllData => "evacuateAllData",
            VsanHostDecommissionModeObjectActionEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_HOST_DECOMMISSION_MODE_OBJECT_ACTION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanHostDecommissionModeObjectActionEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanHostDecommissionModeObjectActionEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanHostDecommissionModeObjectActionEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanHostDecommissionModeObjectActionEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanHostDecommissionModeObjectActionEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanHostDecommissionModeObjectActionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanHostDecommissionModeObjectActionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanHostDecommissionModeObjectActionEnum> for &'a str {
    fn from(value: &'a VsanHostDecommissionModeObjectActionEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanHostDecommissionModeObjectActionEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIM_VSAN_HOST_DISK_MAPPING_CREATION_TYPE_ENUM_MAP: phf::Map<&'static str, VimVsanHostDiskMappingCreationTypeEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("pmem", VimVsanHostDiskMappingCreationTypeEnum::Pmem),
        ("DiskMappingCreationType_Unknown", VimVsanHostDiskMappingCreationTypeEnum::DiskMappingCreationTypeUnknown),
        ("hybrid", VimVsanHostDiskMappingCreationTypeEnum::Hybrid),
        ("vsandirect", VimVsanHostDiskMappingCreationTypeEnum::Vsandirect),
        ("allFlash", VimVsanHostDiskMappingCreationTypeEnum::AllFlash),
    ],
};

impl VimVsanHostDiskMappingCreationTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VimVsanHostDiskMappingCreationTypeEnum::Hybrid => "hybrid",
            VimVsanHostDiskMappingCreationTypeEnum::AllFlash => "allFlash",
            VimVsanHostDiskMappingCreationTypeEnum::Vsandirect => "vsandirect",
            VimVsanHostDiskMappingCreationTypeEnum::Pmem => "pmem",
            VimVsanHostDiskMappingCreationTypeEnum::DiskMappingCreationTypeUnknown => "DiskMappingCreationType_Unknown",
            VimVsanHostDiskMappingCreationTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIM_VSAN_HOST_DISK_MAPPING_CREATION_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VimVsanHostDiskMappingCreationTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VimVsanHostDiskMappingCreationTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VimVsanHostDiskMappingCreationTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VimVsanHostDiskMappingCreationTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VimVsanHostDiskMappingCreationTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VimVsanHostDiskMappingCreationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VimVsanHostDiskMappingCreationTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VimVsanHostDiskMappingCreationTypeEnum> for &'a str {
    fn from(value: &'a VimVsanHostDiskMappingCreationTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VimVsanHostDiskMappingCreationTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_HOST_DISK_RESULT_STATE_ENUM_MAP: phf::Map<&'static str, VsanHostDiskResultStateEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("eligible", VsanHostDiskResultStateEnum::Eligible),
        ("ineligible", VsanHostDiskResultStateEnum::Ineligible),
        ("inUse", VsanHostDiskResultStateEnum::InUse),
    ],
};

impl VsanHostDiskResultStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanHostDiskResultStateEnum::InUse => "inUse",
            VsanHostDiskResultStateEnum::Eligible => "eligible",
            VsanHostDiskResultStateEnum::Ineligible => "ineligible",
            VsanHostDiskResultStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_HOST_DISK_RESULT_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanHostDiskResultStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanHostDiskResultStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanHostDiskResultStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanHostDiskResultStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanHostDiskResultStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanHostDiskResultStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanHostDiskResultStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanHostDiskResultStateEnum> for &'a str {
    fn from(value: &'a VsanHostDiskResultStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanHostDiskResultStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_ENCRYPTION_OPERATION_ENUM_MAP: phf::Map<&'static str, VsanEncryptionOperationEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("deepRekey", VsanEncryptionOperationEnum::DeepRekey),
        ("EncryptionOperation_Unknown", VsanEncryptionOperationEnum::EncryptionOperationUnknown),
        ("enablement", VsanEncryptionOperationEnum::Enablement),
        ("disablement", VsanEncryptionOperationEnum::Disablement),
        ("shallowRekey", VsanEncryptionOperationEnum::ShallowRekey),
    ],
};

impl VsanEncryptionOperationEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanEncryptionOperationEnum::Enablement => "enablement",
            VsanEncryptionOperationEnum::ShallowRekey => "shallowRekey",
            VsanEncryptionOperationEnum::DeepRekey => "deepRekey",
            VsanEncryptionOperationEnum::Disablement => "disablement",
            VsanEncryptionOperationEnum::EncryptionOperationUnknown => "EncryptionOperation_Unknown",
            VsanEncryptionOperationEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_ENCRYPTION_OPERATION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanEncryptionOperationEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanEncryptionOperationEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanEncryptionOperationEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanEncryptionOperationEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanEncryptionOperationEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanEncryptionOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanEncryptionOperationEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanEncryptionOperationEnum> for &'a str {
    fn from(value: &'a VsanEncryptionOperationEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanEncryptionOperationEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_ENCRYPTION_TRANSITION_STATE_ENUM_MAP: phf::Map<&'static str, VsanEncryptionTransitionStateEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("prepared", VsanEncryptionTransitionStateEnum::Prepared),
        ("EncryptionTransitionState_Unknown", VsanEncryptionTransitionStateEnum::EncryptionTransitionStateUnknown),
        ("settled", VsanEncryptionTransitionStateEnum::Settled),
        ("preparing", VsanEncryptionTransitionStateEnum::Preparing),
    ],
};

impl VsanEncryptionTransitionStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanEncryptionTransitionStateEnum::Settled => "settled",
            VsanEncryptionTransitionStateEnum::Preparing => "preparing",
            VsanEncryptionTransitionStateEnum::Prepared => "prepared",
            VsanEncryptionTransitionStateEnum::EncryptionTransitionStateUnknown => "EncryptionTransitionState_Unknown",
            VsanEncryptionTransitionStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_ENCRYPTION_TRANSITION_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanEncryptionTransitionStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanEncryptionTransitionStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanEncryptionTransitionStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanEncryptionTransitionStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanEncryptionTransitionStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanEncryptionTransitionStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanEncryptionTransitionStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanEncryptionTransitionStateEnum> for &'a str {
    fn from(value: &'a VsanEncryptionTransitionStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanEncryptionTransitionStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_HOST_HEALTH_STATE_ENUM_MAP: phf::Map<&'static str, VsanHostHealthStateEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("unknown", VsanHostHealthStateEnum::Unknown),
        ("healthy", VsanHostHealthStateEnum::Healthy),
        ("unhealthy", VsanHostHealthStateEnum::Unhealthy),
    ],
};

impl VsanHostHealthStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanHostHealthStateEnum::Unknown => "unknown",
            VsanHostHealthStateEnum::Healthy => "healthy",
            VsanHostHealthStateEnum::Unhealthy => "unhealthy",
            VsanHostHealthStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_HOST_HEALTH_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanHostHealthStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanHostHealthStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanHostHealthStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanHostHealthStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanHostHealthStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanHostHealthStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanHostHealthStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanHostHealthStateEnum> for &'a str {
    fn from(value: &'a VsanHostHealthStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanHostHealthStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_HOST_NODE_STATE_ENUM_MAP: phf::Map<&'static str, VsanHostNodeStateEnum> = ::phf::Map {
    key: 345707026197253659,
    disps: &[
        (0, 0),
        (6, 3),
    ],
    entries: &[
        ("enteringMaintenanceMode", VsanHostNodeStateEnum::EnteringMaintenanceMode),
        ("decommissioning", VsanHostNodeStateEnum::Decommissioning),
        ("agent", VsanHostNodeStateEnum::Agent),
        ("starting", VsanHostNodeStateEnum::Starting),
        ("disabled", VsanHostNodeStateEnum::Disabled),
        ("exitingMaintenanceMode", VsanHostNodeStateEnum::ExitingMaintenanceMode),
        ("stopping", VsanHostNodeStateEnum::Stopping),
        ("error", VsanHostNodeStateEnum::Error),
        ("master", VsanHostNodeStateEnum::Master),
        ("backup", VsanHostNodeStateEnum::Backup),
    ],
};

impl VsanHostNodeStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanHostNodeStateEnum::Error => "error",
            VsanHostNodeStateEnum::Disabled => "disabled",
            VsanHostNodeStateEnum::Agent => "agent",
            VsanHostNodeStateEnum::Master => "master",
            VsanHostNodeStateEnum::Backup => "backup",
            VsanHostNodeStateEnum::Starting => "starting",
            VsanHostNodeStateEnum::Stopping => "stopping",
            VsanHostNodeStateEnum::EnteringMaintenanceMode => "enteringMaintenanceMode",
            VsanHostNodeStateEnum::ExitingMaintenanceMode => "exitingMaintenanceMode",
            VsanHostNodeStateEnum::Decommissioning => "decommissioning",
            VsanHostNodeStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_HOST_NODE_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanHostNodeStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanHostNodeStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanHostNodeStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanHostNodeStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanHostNodeStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanHostNodeStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanHostNodeStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanHostNodeStateEnum> for &'a str {
    fn from(value: &'a VsanHostNodeStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanHostNodeStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIM_VSAN_HOST_TRAFFIC_TYPE_ENUM_MAP: phf::Map<&'static str, VimVsanHostTrafficTypeEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("vsan", VimVsanHostTrafficTypeEnum::Vsan),
        ("TrafficType_Unknown", VimVsanHostTrafficTypeEnum::TrafficTypeUnknown),
        ("witness", VimVsanHostTrafficTypeEnum::Witness),
    ],
};

impl VimVsanHostTrafficTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VimVsanHostTrafficTypeEnum::Vsan => "vsan",
            VimVsanHostTrafficTypeEnum::Witness => "witness",
            VimVsanHostTrafficTypeEnum::TrafficTypeUnknown => "TrafficType_Unknown",
            VimVsanHostTrafficTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIM_VSAN_HOST_TRAFFIC_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VimVsanHostTrafficTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VimVsanHostTrafficTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VimVsanHostTrafficTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VimVsanHostTrafficTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VimVsanHostTrafficTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VimVsanHostTrafficTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VimVsanHostTrafficTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VimVsanHostTrafficTypeEnum> for &'a str {
    fn from(value: &'a VimVsanHostTrafficTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VimVsanHostTrafficTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VIM_VSAN_HOST_TRAFFIC_TYPE_90_ENUM_MAP: phf::Map<&'static str, VimVsanHostTrafficType90Enum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("vsanExternal", VimVsanHostTrafficType90Enum::VsanExternal),
    ],
};

impl VimVsanHostTrafficType90Enum {
    pub fn as_str(&self) -> &str {
        match self {
            VimVsanHostTrafficType90Enum::VsanExternal => "vsanExternal",
            VimVsanHostTrafficType90Enum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VIM_VSAN_HOST_TRAFFIC_TYPE_90_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VimVsanHostTrafficType90Enum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VimVsanHostTrafficType90Enum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VimVsanHostTrafficType90Enum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VimVsanHostTrafficType90Enum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VimVsanHostTrafficType90Enum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VimVsanHostTrafficType90Enum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VimVsanHostTrafficType90Enum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VimVsanHostTrafficType90Enum> for &'a str {
    fn from(value: &'a VimVsanHostTrafficType90Enum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VimVsanHostTrafficType90Enum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static SERVER_NODE_TYPE_ENUM_MAP: phf::Map<&'static str, ServerNodeTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("REMOTE_METADATA_NODE", ServerNodeTypeEnum::RemoteMetadataNode),
        ("REMOTE_WITNESS_NODE", ServerNodeTypeEnum::RemoteWitnessNode),
        ("REMOTE_NODE", ServerNodeTypeEnum::RemoteNode),
        ("NodeType_Unknown", ServerNodeTypeEnum::NodeTypeUnknown),
    ],
};

impl ServerNodeTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ServerNodeTypeEnum::NodeTypeUnknown => "NodeType_Unknown",
            ServerNodeTypeEnum::RemoteNode => "REMOTE_NODE",
            ServerNodeTypeEnum::RemoteWitnessNode => "REMOTE_WITNESS_NODE",
            ServerNodeTypeEnum::RemoteMetadataNode => "REMOTE_METADATA_NODE",
            ServerNodeTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        SERVER_NODE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ServerNodeTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ServerNodeTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ServerNodeTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ServerNodeTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ServerNodeTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ServerNodeTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ServerNodeTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ServerNodeTypeEnum> for &'a str {
    fn from(value: &'a ServerNodeTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ServerNodeTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_HOST_STATS_TYPE_ENUM_MAP: phf::Map<&'static str, VsanHostStatsTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (6, 1),
        (0, 0),
    ],
    entries: &[
        ("maxWitnessClusters", VsanHostStatsTypeEnum::MaxWitnessClusters),
        ("repairTimerInfo", VsanHostStatsTypeEnum::RepairTimerInfo),
        ("supportedClusterSize", VsanHostStatsTypeEnum::SupportedClusterSize),
        ("resyncIopsInfo", VsanHostStatsTypeEnum::ResyncIopsInfo),
        ("componentLimitPerCluster", VsanHostStatsTypeEnum::ComponentLimitPerCluster),
        ("StatsType_Unknown", VsanHostStatsTypeEnum::StatsTypeUnknown),
        ("configGeneration", VsanHostStatsTypeEnum::ConfigGeneration),
    ],
};

impl VsanHostStatsTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanHostStatsTypeEnum::ResyncIopsInfo => "resyncIopsInfo",
            VsanHostStatsTypeEnum::ConfigGeneration => "configGeneration",
            VsanHostStatsTypeEnum::SupportedClusterSize => "supportedClusterSize",
            VsanHostStatsTypeEnum::RepairTimerInfo => "repairTimerInfo",
            VsanHostStatsTypeEnum::ComponentLimitPerCluster => "componentLimitPerCluster",
            VsanHostStatsTypeEnum::MaxWitnessClusters => "maxWitnessClusters",
            VsanHostStatsTypeEnum::StatsTypeUnknown => "StatsType_Unknown",
            VsanHostStatsTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_HOST_STATS_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanHostStatsTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanHostStatsTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanHostStatsTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanHostStatsTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanHostStatsTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanHostStatsTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanHostStatsTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanHostStatsTypeEnum> for &'a str {
    fn from(value: &'a VsanHostStatsTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanHostStatsTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static STORAGE_POOL_DISK_TYPE_ENUM_MAP: phf::Map<&'static str, StoragePoolDiskTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("StoragePoolDiskType_Unknown", StoragePoolDiskTypeEnum::StoragePoolDiskTypeUnknown),
        ("singleTier", StoragePoolDiskTypeEnum::SingleTier),
    ],
};

impl StoragePoolDiskTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            StoragePoolDiskTypeEnum::SingleTier => "singleTier",
            StoragePoolDiskTypeEnum::StoragePoolDiskTypeUnknown => "StoragePoolDiskType_Unknown",
            StoragePoolDiskTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        STORAGE_POOL_DISK_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| StoragePoolDiskTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for StoragePoolDiskTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for StoragePoolDiskTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<StoragePoolDiskTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(StoragePoolDiskTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for StoragePoolDiskTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for StoragePoolDiskTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a StoragePoolDiskTypeEnum> for &'a str {
    fn from(value: &'a StoragePoolDiskTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for StoragePoolDiskTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static TRIM_DISK_TYPE_ENUM_MAP: phf::Map<&'static str, TrimDiskTypeEnum> = ::phf::Map {
    key: 2980949210194914378,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("cacheDisk", TrimDiskTypeEnum::CacheDisk),
        ("TrimDiskType_Unknown", TrimDiskTypeEnum::TrimDiskTypeUnknown),
        ("capacityDisk", TrimDiskTypeEnum::CapacityDisk),
    ],
};

impl TrimDiskTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            TrimDiskTypeEnum::CacheDisk => "cacheDisk",
            TrimDiskTypeEnum::CapacityDisk => "capacityDisk",
            TrimDiskTypeEnum::TrimDiskTypeUnknown => "TrimDiskType_Unknown",
            TrimDiskTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        TRIM_DISK_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| TrimDiskTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for TrimDiskTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for TrimDiskTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<TrimDiskTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(TrimDiskTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for TrimDiskTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for TrimDiskTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a TrimDiskTypeEnum> for &'a str {
    fn from(value: &'a TrimDiskTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for TrimDiskTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_DISK_EVAC_REASON_ENUM_MAP: phf::Map<&'static str, VsanDiskEvacReasonEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (5, 2),
        (0, 0),
    ],
    entries: &[
        ("Ure", VsanDiskEvacReasonEnum::Ure),
        ("SmartDiskFailures", VsanDiskEvacReasonEnum::SmartDiskFailures),
        ("Latency", VsanDiskEvacReasonEnum::Latency),
        ("VsanDiskEvacReason_Unknow", VsanDiskEvacReasonEnum::VsanDiskEvacReasonUnknow),
        ("Congestion", VsanDiskEvacReasonEnum::Congestion),
        ("TransientDeviceError", VsanDiskEvacReasonEnum::TransientDeviceError),
        ("User", VsanDiskEvacReasonEnum::User),
    ],
};

impl VsanDiskEvacReasonEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanDiskEvacReasonEnum::User => "User",
            VsanDiskEvacReasonEnum::Ure => "Ure",
            VsanDiskEvacReasonEnum::SmartDiskFailures => "SmartDiskFailures",
            VsanDiskEvacReasonEnum::Latency => "Latency",
            VsanDiskEvacReasonEnum::Congestion => "Congestion",
            VsanDiskEvacReasonEnum::TransientDeviceError => "TransientDeviceError",
            VsanDiskEvacReasonEnum::VsanDiskEvacReasonUnknow => "VsanDiskEvacReason_Unknow",
            VsanDiskEvacReasonEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_DISK_EVAC_REASON_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanDiskEvacReasonEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanDiskEvacReasonEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanDiskEvacReasonEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanDiskEvacReasonEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanDiskEvacReasonEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanDiskEvacReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanDiskEvacReasonEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanDiskEvacReasonEnum> for &'a str {
    fn from(value: &'a VsanDiskEvacReasonEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanDiskEvacReasonEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_DISK_TRIM_OPTION_ENUM_MAP: phf::Map<&'static str, VsanDiskTrimOptionEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("VsanDiskTrimOption_Unknown", VsanDiskTrimOptionEnum::VsanDiskTrimOptionUnknown),
        ("metaDataOnly", VsanDiskTrimOptionEnum::MetaDataOnly),
        ("fullDisk", VsanDiskTrimOptionEnum::FullDisk),
    ],
};

impl VsanDiskTrimOptionEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanDiskTrimOptionEnum::MetaDataOnly => "metaDataOnly",
            VsanDiskTrimOptionEnum::FullDisk => "fullDisk",
            VsanDiskTrimOptionEnum::VsanDiskTrimOptionUnknown => "VsanDiskTrimOption_Unknown",
            VsanDiskTrimOptionEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_DISK_TRIM_OPTION_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanDiskTrimOptionEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanDiskTrimOptionEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanDiskTrimOptionEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanDiskTrimOptionEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanDiskTrimOptionEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanDiskTrimOptionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanDiskTrimOptionEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanDiskTrimOptionEnum> for &'a str {
    fn from(value: &'a VsanDiskTrimOptionEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanDiskTrimOptionEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_DISK_TYPE_ENUM_MAP: phf::Map<&'static str, VsanDiskTypeEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("VsanDiskType_Unknown", VsanDiskTypeEnum::VsanDiskTypeUnknown),
        ("directDisk", VsanDiskTypeEnum::DirectDisk),
        ("storagePool", VsanDiskTypeEnum::StoragePool),
        ("diskGroup", VsanDiskTypeEnum::DiskGroup),
    ],
};

impl VsanDiskTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanDiskTypeEnum::DiskGroup => "diskGroup",
            VsanDiskTypeEnum::StoragePool => "storagePool",
            VsanDiskTypeEnum::DirectDisk => "directDisk",
            VsanDiskTypeEnum::VsanDiskTypeUnknown => "VsanDiskType_Unknown",
            VsanDiskTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_DISK_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanDiskTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanDiskTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanDiskTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanDiskTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanDiskTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanDiskTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanDiskTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanDiskTypeEnum> for &'a str {
    fn from(value: &'a VsanDiskTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanDiskTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_DISKGROUP_CAPABILITY_ENUM_MAP: phf::Map<&'static str, VsanDiskgroupCapabilityEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("VsanDiskgroupCapability_Unknown", VsanDiskgroupCapabilityEnum::VsanDiskgroupCapabilityUnknown),
        ("supportLargerThan16TB", VsanDiskgroupCapabilityEnum::SupportLargerThan16Tb),
    ],
};

impl VsanDiskgroupCapabilityEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanDiskgroupCapabilityEnum::SupportLargerThan16Tb => "supportLargerThan16TB",
            VsanDiskgroupCapabilityEnum::VsanDiskgroupCapabilityUnknown => "VsanDiskgroupCapability_Unknown",
            VsanDiskgroupCapabilityEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_DISKGROUP_CAPABILITY_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanDiskgroupCapabilityEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanDiskgroupCapabilityEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanDiskgroupCapabilityEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanDiskgroupCapabilityEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanDiskgroupCapabilityEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanDiskgroupCapabilityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanDiskgroupCapabilityEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanDiskgroupCapabilityEnum> for &'a str {
    fn from(value: &'a VsanDiskgroupCapabilityEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanDiskgroupCapabilityEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_DISK_ISSUE_TYPE_ENUM_MAP: phf::Map<&'static str, VsanDiskIssueTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("unknown", VsanDiskIssueTypeEnum::Unknown),
        ("nonExist", VsanDiskIssueTypeEnum::NonExist),
        ("stampMismatch", VsanDiskIssueTypeEnum::StampMismatch),
    ],
};

impl VsanDiskIssueTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanDiskIssueTypeEnum::NonExist => "nonExist",
            VsanDiskIssueTypeEnum::StampMismatch => "stampMismatch",
            VsanDiskIssueTypeEnum::Unknown => "unknown",
            VsanDiskIssueTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_DISK_ISSUE_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanDiskIssueTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanDiskIssueTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanDiskIssueTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanDiskIssueTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanDiskIssueTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanDiskIssueTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanDiskIssueTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanDiskIssueTypeEnum> for &'a str {
    fn from(value: &'a VsanDiskIssueTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanDiskIssueTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_HOST_WIPE_DISK_ELIGIBLE_ENUM_MAP: phf::Map<&'static str, VsanHostWipeDiskEligibleEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("Yes", VsanHostWipeDiskEligibleEnum::Yes),
        ("Unknown", VsanHostWipeDiskEligibleEnum::Unknown),
        ("WipeDiskEligible_Unknown", VsanHostWipeDiskEligibleEnum::WipeDiskEligibleUnknown),
        ("No", VsanHostWipeDiskEligibleEnum::No),
    ],
};

impl VsanHostWipeDiskEligibleEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanHostWipeDiskEligibleEnum::WipeDiskEligibleUnknown => "WipeDiskEligible_Unknown",
            VsanHostWipeDiskEligibleEnum::Yes => "Yes",
            VsanHostWipeDiskEligibleEnum::No => "No",
            VsanHostWipeDiskEligibleEnum::Unknown => "Unknown",
            VsanHostWipeDiskEligibleEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_HOST_WIPE_DISK_ELIGIBLE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanHostWipeDiskEligibleEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanHostWipeDiskEligibleEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanHostWipeDiskEligibleEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanHostWipeDiskEligibleEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanHostWipeDiskEligibleEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanHostWipeDiskEligibleEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanHostWipeDiskEligibleEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanHostWipeDiskEligibleEnum> for &'a str {
    fn from(value: &'a VsanHostWipeDiskEligibleEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanHostWipeDiskEligibleEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSAN_HOST_WIPE_DISK_STATE_ENUM_MAP: phf::Map<&'static str, VsanHostWipeDiskStateEnum> = ::phf::Map {
    key: 2980949210194914378,
    disps: &[
        (1, 0),
    ],
    entries: &[
        ("WipeDiskState_Unknown", VsanHostWipeDiskStateEnum::WipeDiskStateUnknown),
        ("Failure", VsanHostWipeDiskStateEnum::Failure),
        ("Success", VsanHostWipeDiskStateEnum::Success),
        ("Wiping", VsanHostWipeDiskStateEnum::Wiping),
    ],
};

impl VsanHostWipeDiskStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VsanHostWipeDiskStateEnum::WipeDiskStateUnknown => "WipeDiskState_Unknown",
            VsanHostWipeDiskStateEnum::Wiping => "Wiping",
            VsanHostWipeDiskStateEnum::Success => "Success",
            VsanHostWipeDiskStateEnum::Failure => "Failure",
            VsanHostWipeDiskStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSAN_HOST_WIPE_DISK_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VsanHostWipeDiskStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VsanHostWipeDiskStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VsanHostWipeDiskStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VsanHostWipeDiskStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VsanHostWipeDiskStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VsanHostWipeDiskStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VsanHostWipeDiskStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VsanHostWipeDiskStateEnum> for &'a str {
    fn from(value: &'a VsanHostWipeDiskStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VsanHostWipeDiskStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static BASE_CONFIG_INFO_DISK_FILE_BACKING_INFO_PROVISIONING_TYPE_ENUM_MAP: phf::Map<&'static str, BaseConfigInfoDiskFileBackingInfoProvisioningTypeEnum> = ::phf::Map {
    key: 10121458955350035957,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("thin", BaseConfigInfoDiskFileBackingInfoProvisioningTypeEnum::Thin),
        ("eagerZeroedThick", BaseConfigInfoDiskFileBackingInfoProvisioningTypeEnum::EagerZeroedThick),
        ("lazyZeroedThick", BaseConfigInfoDiskFileBackingInfoProvisioningTypeEnum::LazyZeroedThick),
    ],
};

impl BaseConfigInfoDiskFileBackingInfoProvisioningTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            BaseConfigInfoDiskFileBackingInfoProvisioningTypeEnum::Thin => "thin",
            BaseConfigInfoDiskFileBackingInfoProvisioningTypeEnum::EagerZeroedThick => "eagerZeroedThick",
            BaseConfigInfoDiskFileBackingInfoProvisioningTypeEnum::LazyZeroedThick => "lazyZeroedThick",
            BaseConfigInfoDiskFileBackingInfoProvisioningTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        BASE_CONFIG_INFO_DISK_FILE_BACKING_INFO_PROVISIONING_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| BaseConfigInfoDiskFileBackingInfoProvisioningTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for BaseConfigInfoDiskFileBackingInfoProvisioningTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for BaseConfigInfoDiskFileBackingInfoProvisioningTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<BaseConfigInfoDiskFileBackingInfoProvisioningTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(BaseConfigInfoDiskFileBackingInfoProvisioningTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for BaseConfigInfoDiskFileBackingInfoProvisioningTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for BaseConfigInfoDiskFileBackingInfoProvisioningTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a BaseConfigInfoDiskFileBackingInfoProvisioningTypeEnum> for &'a str {
    fn from(value: &'a BaseConfigInfoDiskFileBackingInfoProvisioningTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for BaseConfigInfoDiskFileBackingInfoProvisioningTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSLM_DISK_INFO_FLAG_ENUM_MAP: phf::Map<&'static str, VslmDiskInfoFlagEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 5),
        (0, 3),
        (13, 14),
        (0, 0),
        (6, 4),
    ],
    entries: &[
        ("ioFilter", VslmDiskInfoFlagEnum::IoFilter),
        ("type", VslmDiskInfoFlagEnum::Type),
        ("backingObjectId", VslmDiskInfoFlagEnum::BackingObjectId),
        ("virtualDiskFormat", VslmDiskInfoFlagEnum::VirtualDiskFormat),
        ("id", VslmDiskInfoFlagEnum::Id),
        ("keyId", VslmDiskInfoFlagEnum::KeyId),
        ("tentativeState", VslmDiskInfoFlagEnum::TentativeState),
        ("keyProviderId", VslmDiskInfoFlagEnum::KeyProviderId),
        ("deviceName", VslmDiskInfoFlagEnum::DeviceName),
        ("cbtEnabled", VslmDiskInfoFlagEnum::CbtEnabled),
        ("createTime", VslmDiskInfoFlagEnum::CreateTime),
        ("descriptorVersion", VslmDiskInfoFlagEnum::DescriptorVersion),
        ("relocationDisabled", VslmDiskInfoFlagEnum::RelocationDisabled),
        ("controlFlags", VslmDiskInfoFlagEnum::ControlFlags),
        ("consumers", VslmDiskInfoFlagEnum::Consumers),
        ("name", VslmDiskInfoFlagEnum::Name),
        ("path", VslmDiskInfoFlagEnum::Path),
        ("nativeSnapshotSupported", VslmDiskInfoFlagEnum::NativeSnapshotSupported),
        ("keepAfterVmDelete", VslmDiskInfoFlagEnum::KeepAfterVmDelete),
        ("capacity", VslmDiskInfoFlagEnum::Capacity),
        ("parentPath", VslmDiskInfoFlagEnum::ParentPath),
        ("allocated", VslmDiskInfoFlagEnum::Allocated),
    ],
};

impl VslmDiskInfoFlagEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VslmDiskInfoFlagEnum::Id => "id",
            VslmDiskInfoFlagEnum::DescriptorVersion => "descriptorVersion",
            VslmDiskInfoFlagEnum::BackingObjectId => "backingObjectId",
            VslmDiskInfoFlagEnum::Path => "path",
            VslmDiskInfoFlagEnum::ParentPath => "parentPath",
            VslmDiskInfoFlagEnum::Name => "name",
            VslmDiskInfoFlagEnum::DeviceName => "deviceName",
            VslmDiskInfoFlagEnum::Capacity => "capacity",
            VslmDiskInfoFlagEnum::Allocated => "allocated",
            VslmDiskInfoFlagEnum::Type => "type",
            VslmDiskInfoFlagEnum::Consumers => "consumers",
            VslmDiskInfoFlagEnum::TentativeState => "tentativeState",
            VslmDiskInfoFlagEnum::CreateTime => "createTime",
            VslmDiskInfoFlagEnum::IoFilter => "ioFilter",
            VslmDiskInfoFlagEnum::ControlFlags => "controlFlags",
            VslmDiskInfoFlagEnum::KeepAfterVmDelete => "keepAfterVmDelete",
            VslmDiskInfoFlagEnum::RelocationDisabled => "relocationDisabled",
            VslmDiskInfoFlagEnum::KeyId => "keyId",
            VslmDiskInfoFlagEnum::KeyProviderId => "keyProviderId",
            VslmDiskInfoFlagEnum::NativeSnapshotSupported => "nativeSnapshotSupported",
            VslmDiskInfoFlagEnum::CbtEnabled => "cbtEnabled",
            VslmDiskInfoFlagEnum::VirtualDiskFormat => "virtualDiskFormat",
            VslmDiskInfoFlagEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSLM_DISK_INFO_FLAG_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VslmDiskInfoFlagEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VslmDiskInfoFlagEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VslmDiskInfoFlagEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VslmDiskInfoFlagEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VslmDiskInfoFlagEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VslmDiskInfoFlagEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VslmDiskInfoFlagEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VslmDiskInfoFlagEnum> for &'a str {
    fn from(value: &'a VslmDiskInfoFlagEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VslmDiskInfoFlagEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static V_STORAGE_OBJECT_CONSUMPTION_TYPE_ENUM_MAP: phf::Map<&'static str, VStorageObjectConsumptionTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("disk", VStorageObjectConsumptionTypeEnum::Disk),
    ],
};

impl VStorageObjectConsumptionTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VStorageObjectConsumptionTypeEnum::Disk => "disk",
            VStorageObjectConsumptionTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        V_STORAGE_OBJECT_CONSUMPTION_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VStorageObjectConsumptionTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VStorageObjectConsumptionTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VStorageObjectConsumptionTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VStorageObjectConsumptionTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VStorageObjectConsumptionTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VStorageObjectConsumptionTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VStorageObjectConsumptionTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VStorageObjectConsumptionTypeEnum> for &'a str {
    fn from(value: &'a VStorageObjectConsumptionTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VStorageObjectConsumptionTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSLM_V_STORAGE_OBJECT_CONTROL_FLAG_ENUM_MAP: phf::Map<&'static str, VslmVStorageObjectControlFlagEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("disableRelocation", VslmVStorageObjectControlFlagEnum::DisableRelocation),
        ("keepAfterDeleteVm", VslmVStorageObjectControlFlagEnum::KeepAfterDeleteVm),
        ("enableChangedBlockTracking", VslmVStorageObjectControlFlagEnum::EnableChangedBlockTracking),
    ],
};

impl VslmVStorageObjectControlFlagEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VslmVStorageObjectControlFlagEnum::KeepAfterDeleteVm => "keepAfterDeleteVm",
            VslmVStorageObjectControlFlagEnum::DisableRelocation => "disableRelocation",
            VslmVStorageObjectControlFlagEnum::EnableChangedBlockTracking => "enableChangedBlockTracking",
            VslmVStorageObjectControlFlagEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSLM_V_STORAGE_OBJECT_CONTROL_FLAG_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VslmVStorageObjectControlFlagEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VslmVStorageObjectControlFlagEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VslmVStorageObjectControlFlagEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VslmVStorageObjectControlFlagEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VslmVStorageObjectControlFlagEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VslmVStorageObjectControlFlagEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VslmVStorageObjectControlFlagEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VslmVStorageObjectControlFlagEnum> for &'a str {
    fn from(value: &'a VslmVStorageObjectControlFlagEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VslmVStorageObjectControlFlagEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static PROPERTY_CHANGE_OP_ENUM_MAP: phf::Map<&'static str, PropertyChangeOpEnum> = ::phf::Map {
    key: 15467950696543387533,
    disps: &[
        (3, 0),
    ],
    entries: &[
        ("assign", PropertyChangeOpEnum::Assign),
        ("remove", PropertyChangeOpEnum::Remove),
        ("add", PropertyChangeOpEnum::Add),
        ("indirectRemove", PropertyChangeOpEnum::IndirectRemove),
    ],
};

impl PropertyChangeOpEnum {
    pub fn as_str(&self) -> &str {
        match self {
            PropertyChangeOpEnum::Add => "add",
            PropertyChangeOpEnum::Remove => "remove",
            PropertyChangeOpEnum::Assign => "assign",
            PropertyChangeOpEnum::IndirectRemove => "indirectRemove",
            PropertyChangeOpEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        PROPERTY_CHANGE_OP_ENUM_MAP.get(s).cloned().unwrap_or_else(|| PropertyChangeOpEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for PropertyChangeOpEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for PropertyChangeOpEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<PropertyChangeOpEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(PropertyChangeOpEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for PropertyChangeOpEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for PropertyChangeOpEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a PropertyChangeOpEnum> for &'a str {
    fn from(value: &'a PropertyChangeOpEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for PropertyChangeOpEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static OBJECT_UPDATE_KIND_ENUM_MAP: phf::Map<&'static str, ObjectUpdateKindEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (2, 0),
    ],
    entries: &[
        ("leave", ObjectUpdateKindEnum::Leave),
        ("enter", ObjectUpdateKindEnum::Enter),
        ("modify", ObjectUpdateKindEnum::Modify),
    ],
};

impl ObjectUpdateKindEnum {
    pub fn as_str(&self) -> &str {
        match self {
            ObjectUpdateKindEnum::Modify => "modify",
            ObjectUpdateKindEnum::Enter => "enter",
            ObjectUpdateKindEnum::Leave => "leave",
            ObjectUpdateKindEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        OBJECT_UPDATE_KIND_ENUM_MAP.get(s).cloned().unwrap_or_else(|| ObjectUpdateKindEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for ObjectUpdateKindEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for ObjectUpdateKindEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<ObjectUpdateKindEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(ObjectUpdateKindEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for ObjectUpdateKindEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for ObjectUpdateKindEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a ObjectUpdateKindEnum> for &'a str {
    fn from(value: &'a ObjectUpdateKindEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for ObjectUpdateKindEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSLM_TASK_INFO_STATE_ENUM_MAP: phf::Map<&'static str, VslmTaskInfoStateEnum> = ::phf::Map {
    key: 7485420634051515786,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("running", VslmTaskInfoStateEnum::Running),
        ("error", VslmTaskInfoStateEnum::Error),
        ("success", VslmTaskInfoStateEnum::Success),
        ("queued", VslmTaskInfoStateEnum::Queued),
    ],
};

impl VslmTaskInfoStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VslmTaskInfoStateEnum::Queued => "queued",
            VslmTaskInfoStateEnum::Running => "running",
            VslmTaskInfoStateEnum::Success => "success",
            VslmTaskInfoStateEnum::Error => "error",
            VslmTaskInfoStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSLM_TASK_INFO_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VslmTaskInfoStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VslmTaskInfoStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VslmTaskInfoStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VslmTaskInfoStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VslmTaskInfoStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VslmTaskInfoStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VslmTaskInfoStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VslmTaskInfoStateEnum> for &'a str {
    fn from(value: &'a VslmTaskInfoStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VslmTaskInfoStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSLM_EVENT_TYPE_ENUM_MAP: phf::Map<&'static str, VslmEventTypeEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("postFcdMigrateEvent", VslmEventTypeEnum::PostFcdMigrateEvent),
        ("preFcdMigrateEvent", VslmEventTypeEnum::PreFcdMigrateEvent),
    ],
};

impl VslmEventTypeEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VslmEventTypeEnum::PreFcdMigrateEvent => "preFcdMigrateEvent",
            VslmEventTypeEnum::PostFcdMigrateEvent => "postFcdMigrateEvent",
            VslmEventTypeEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSLM_EVENT_TYPE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VslmEventTypeEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VslmEventTypeEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VslmEventTypeEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VslmEventTypeEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VslmEventTypeEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VslmEventTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VslmEventTypeEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VslmEventTypeEnum> for &'a str {
    fn from(value: &'a VslmEventTypeEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VslmEventTypeEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSLM_EVENT_VSLM_EVENT_INFO_STATE_ENUM_MAP: phf::Map<&'static str, VslmEventVslmEventInfoStateEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
    ],
    entries: &[
        ("success", VslmEventVslmEventInfoStateEnum::Success),
        ("error", VslmEventVslmEventInfoStateEnum::Error),
    ],
};

impl VslmEventVslmEventInfoStateEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VslmEventVslmEventInfoStateEnum::Success => "success",
            VslmEventVslmEventInfoStateEnum::Error => "error",
            VslmEventVslmEventInfoStateEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSLM_EVENT_VSLM_EVENT_INFO_STATE_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VslmEventVslmEventInfoStateEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VslmEventVslmEventInfoStateEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VslmEventVslmEventInfoStateEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VslmEventVslmEventInfoStateEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VslmEventVslmEventInfoStateEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VslmEventVslmEventInfoStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VslmEventVslmEventInfoStateEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VslmEventVslmEventInfoStateEnum> for &'a str {
    fn from(value: &'a VslmEventVslmEventInfoStateEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VslmEventVslmEventInfoStateEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSLM_VSO_V_STORAGE_OBJECT_QUERY_SPEC_QUERY_FIELD_ENUM_ENUM_MAP: phf::Map<&'static str, VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum> = ::phf::Map {
    key: 12913932095322966823,
    disps: &[
        (0, 0),
        (2, 1),
    ],
    entries: &[
        ("name", VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum::Name),
        ("capacity", VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum::Capacity),
        ("backingObjectId", VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum::BackingObjectId),
        ("id", VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum::Id),
        ("createTime", VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum::CreateTime),
        ("datastoreMoId", VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum::DatastoreMoId),
        ("metadataValue", VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum::MetadataValue),
        ("metadataKey", VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum::MetadataKey),
    ],
};

impl VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum::Id => "id",
            VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum::Name => "name",
            VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum::Capacity => "capacity",
            VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum::CreateTime => "createTime",
            VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum::BackingObjectId => "backingObjectId",
            VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum::DatastoreMoId => "datastoreMoId",
            VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum::MetadataKey => "metadataKey",
            VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum::MetadataValue => "metadataValue",
            VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSLM_VSO_V_STORAGE_OBJECT_QUERY_SPEC_QUERY_FIELD_ENUM_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum> for &'a str {
    fn from(value: &'a VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

static VSLM_VSO_V_STORAGE_OBJECT_QUERY_SPEC_QUERY_OPERATOR_ENUM_ENUM_MAP: phf::Map<&'static str, VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum> = ::phf::Map {
    key: 2126027241312876569,
    disps: &[
        (7, 7),
        (1, 0),
    ],
    entries: &[
        ("lessThan", VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum::LessThan),
        ("greaterThanOrEqual", VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum::GreaterThanOrEqual),
        ("equals", VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum::Equals),
        ("contains", VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum::Contains),
        ("endsWith", VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum::EndsWith),
        ("lessThanOrEqual", VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum::LessThanOrEqual),
        ("greaterThan", VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum::GreaterThan),
        ("notEquals", VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum::NotEquals),
        ("startsWith", VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum::StartsWith),
    ],
};

impl VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum {
    pub fn as_str(&self) -> &str {
        match self {
            VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum::Equals => "equals",
            VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum::NotEquals => "notEquals",
            VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum::LessThan => "lessThan",
            VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum::GreaterThan => "greaterThan",
            VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum::LessThanOrEqual => "lessThanOrEqual",
            VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum::GreaterThanOrEqual => "greaterThanOrEqual",
            VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum::Contains => "contains",
            VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum::StartsWith => "startsWith",
            VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum::EndsWith => "endsWith",
            VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum::Other_(s) => s,
        }
    }

    pub fn from_str(s: &str) -> Self {
        VSLM_VSO_V_STORAGE_OBJECT_QUERY_SPEC_QUERY_OPERATOR_ENUM_ENUM_MAP.get(s).cloned().unwrap_or_else(|| VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum::Other_(s.to_string()))
    }
}

impl miniserde::Serialize for VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum {
    fn begin(&self) -> miniserde::ser::Fragment<'_> {
        miniserde::ser::Fragment::Str(std::borrow::Cow::Borrowed(self.as_str()))
    }
}

impl miniserde::Deserialize for VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum {
    fn begin(out: &mut Option<Self>) -> &mut dyn miniserde::de::Visitor {
        Place::new(out)
    }
}

impl miniserde::de::Visitor for Place<VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum> {
    fn string(&mut self, s: &str) -> miniserde::Result<()> {
        self.out = Some(VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum::from_str(s));
        Ok(())
    }
}

impl std::fmt::Display for VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl std::fmt::Debug for VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.as_str())
    }
}

impl<'a> From<&'a VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum> for &'a str {
    fn from(value: &'a VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum) -> Self {
        value.as_str()
    }
}

impl AsRef<str> for VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}