vim_rs/types/enums.rs
1/// Possible values:
2/// - `Alarm`
3/// - `AlarmManager`
4/// - `AuthorizationManager`
5/// - `CertificateManager`
6/// - `ClusterComputeResource`
7/// - `ClusterEVCManager`
8/// - `ClusterProfile`
9/// - `ClusterProfileManager`
10/// - `ComputeResource`
11/// - `ContainerView`
12/// - `CryptoManager`
13/// - `CryptoManagerHost`
14/// - `CryptoManagerHostKMS`
15/// - `CryptoManagerKmip`
16/// - `CustomFieldsManager`
17/// - `CustomizationSpecManager`
18/// - `Datacenter`
19/// - `Datastore`
20/// - `DatastoreNamespaceManager`
21/// - `DiagnosticManager`
22/// - `DirectPathProfileManager`: ***Since:*** vSphere API Release 9.0.0.0
23/// - `DistributedVirtualPortgroup`
24/// - `DistributedVirtualSwitch`
25/// - `DistributedVirtualSwitchManager`
26/// - `EnvironmentBrowser`
27/// - `EventHistoryCollector`
28/// - `EventManager`
29/// - `ExtensibleManagedObject`
30/// - `ExtensionManager`
31/// - `FailoverClusterConfigurator`
32/// - `FailoverClusterManager`
33/// - `FileManager`
34/// - `Folder`
35/// - `GuestAliasManager`
36/// - `GuestAuthManager`
37/// - `GuestFileManager`
38/// - `GuestOperationsManager`
39/// - `GuestProcessManager`
40/// - `GuestWindowsRegistryManager`
41/// - `HealthUpdateManager`
42/// - `HistoryCollector`
43/// - `HostAccessManager`
44/// - `HostActiveDirectoryAuthentication`
45/// - `HostAssignableHardwareManager`
46/// - `HostAuthenticationManager`
47/// - `HostAuthenticationStore`
48/// - `HostAutoStartManager`
49/// - `HostBootDeviceSystem`
50/// - `HostCacheConfigurationManager`
51/// - `HostCertificateManager`
52/// - `HostCpuSchedulerSystem`
53/// - `HostDatastoreBrowser`
54/// - `HostDatastoreSystem`
55/// - `HostDateTimeSystem`
56/// - `HostDiagnosticSystem`
57/// - `HostDirectoryStore`
58/// - `HostEsxAgentHostManager`
59/// - `HostFirewallSystem`
60/// - `HostFirmwareSystem`
61/// - `HostGraphicsManager`
62/// - `HostHealthStatusSystem`
63/// - `HostImageConfigManager`
64/// - `HostKernelModuleSystem`
65/// - `HostLocalAccountManager`
66/// - `HostLocalAuthentication`
67/// - `HostMemorySystem`
68/// - `HostNetworkSystem`
69/// - `HostNvdimmSystem`
70/// - `HostPatchManager`
71/// - `HostPciPassthruSystem`
72/// - `HostPowerSystem`
73/// - `HostProfile`
74/// - `HostProfileManager`
75/// - `HostServiceSystem`
76/// - `HostSnmpSystem`
77/// - `HostSpecificationManager`
78/// - `HostStorageSystem`
79/// - `HostSystem`
80/// - `HostVFlashManager`
81/// - `HostVMotionSystem`
82/// - `HostVStorageObjectManager`
83/// - `HostVirtualNicManager`
84/// - `HostVsanHealthSystem`
85/// - `HostVsanInternalSystem`
86/// - `HostVsanSystem`
87/// - `HttpNfcLease`
88/// - `InventoryView`
89/// - `IoFilterManager`
90/// - `IpPoolManager`
91/// - `IscsiManager`
92/// - `LicenseAssignmentManager`
93/// - `LicenseManager`
94/// - `ListView`
95/// - `LocalizationManager`
96/// - `ManagedEntity`
97/// - `ManagedObjectView`
98/// - `MessageBusProxy`
99/// - `Network`
100/// - `OpaqueNetwork`
101/// - `OptionManager`
102/// - `OverheadMemoryManager`
103/// - `OvfManager`
104/// - `PerformanceManager`
105/// - `Profile`
106/// - `ProfileComplianceManager`
107/// - `ProfileManager`
108/// - `PropertyCollector`
109/// - `PropertyFilter`
110/// - `ResourcePlanningManager`
111/// - `ResourcePool`
112/// - `ScheduledTask`
113/// - `ScheduledTaskManager`
114/// - `SearchIndex`
115/// - `ServiceInstance`
116/// - `ServiceManager`
117/// - `SessionManager`
118/// - `SimpleCommand`
119/// - `SiteInfoManager`
120/// - `StoragePod`
121/// - `StorageQueryManager`
122/// - `StorageResourceManager`
123/// - `Task`
124/// - `TaskHistoryCollector`
125/// - `TaskManager`
126/// - `TenantTenantManager`
127/// - `UserDirectory`
128/// - `VStorageObjectManagerBase`
129/// - `VcenterVStorageObjectManager`
130/// - `View`
131/// - `ViewManager`
132/// - `VimClusterVsanVcDiskManagementSystem`
133/// - `VimClusterVsanVcStretchedClusterSystem`
134/// - `VirtualApp`
135/// - `VirtualDiskManager`
136/// - `VirtualMachine`
137/// - `VirtualMachineCompatibilityChecker`
138/// - `VirtualMachineGuestCustomizationManager`
139/// - `VirtualMachineProvisioningChecker`
140/// - `VirtualMachineSnapshot`
141/// - `VirtualizationManager`
142/// - `VmwareDistributedVirtualSwitch`
143/// - `VsanCapabilitySystem`
144/// - `VsanClusterHealthSystem`
145/// - `VsanClusterMgmtInternalSystem`
146/// - `VsanIscsiTargetSystem`
147/// - `VsanObjectSystem`
148/// - `VsanPerformanceManager`
149/// - `VsanSpaceReportSystem`
150/// - `VsanSystemEx`
151/// - `VsanUpgradeSystem`
152/// - `VsanUpgradeSystemEx`
153/// - `VsanVcClusterConfigSystem`
154/// - `VsanVcClusterHealthSystem`
155/// - `VsanVcsaDeployerSystem`
156/// - `Agency`
157/// - `Agent`
158/// - `EamObject`
159/// - `EamTask`
160/// - `EsxAgentManager`
161/// - `PbmCapabilityMetadataManager`
162/// - `PbmComplianceManager`
163/// - `PbmPlacementSolver`
164/// - `PbmProfileProfileManager`
165/// - `PbmProvider`
166/// - `PbmReplicationManager`
167/// - `PbmServiceInstance`
168/// - `PbmSessionManager`
169/// - `SmsProvider`
170/// - `SmsServiceInstance`
171/// - `SmsSessionManager`
172/// - `SmsStorageManager`
173/// - `SmsTask`
174/// - `VasaProvider`
175/// - `ManagedObject`
176/// - `CnsVolumeManager`
177/// - `HostSpbm`
178/// - `VsanClusterPowerSystem`
179/// - `VsanDiagnosticsSystem`
180/// - `VsanFileServiceSystem`
181/// - `VsanHostVdsSystem`
182/// - `VsanIoInsightManager`
183/// - `VsanMassCollector`
184/// - `VsanObjectManager`: ***Since:*** 8.0.0.4
185/// - `VsanPhoneHomeSystem`
186/// - `VsanPolicyManager`
187/// - `VsanRemoteDatastoreSystem`
188/// - `VsanResourceCheckSystem`
189/// - `VsanUpdateManager`
190/// - `VsanVdsSystem`
191/// - `VsanVumSystem`
192/// - `VslmServiceInstance`
193/// - `VslmSessionManager`
194/// - `VslmStorageLifecycleManager`
195/// - `VslmTask`
196/// - `VslmVStorageObjectManager`
197#[derive(Clone, Debug, PartialEq, Eq, Hash, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
198pub enum MoTypesEnum {
199 Alarm,
200 AlarmManager,
201 AuthorizationManager,
202 CertificateManager,
203 ClusterComputeResource,
204 #[serde(rename = "ClusterEVCManager")]
205 #[strum(serialize = "ClusterEVCManager")]
206 ClusterEvcManager,
207 ClusterProfile,
208 ClusterProfileManager,
209 ComputeResource,
210 ContainerView,
211 CryptoManager,
212 CryptoManagerHost,
213 #[serde(rename = "CryptoManagerHostKMS")]
214 #[strum(serialize = "CryptoManagerHostKMS")]
215 CryptoManagerHostKms,
216 CryptoManagerKmip,
217 CustomFieldsManager,
218 CustomizationSpecManager,
219 Datacenter,
220 Datastore,
221 DatastoreNamespaceManager,
222 DiagnosticManager,
223 DirectPathProfileManager,
224 DistributedVirtualPortgroup,
225 DistributedVirtualSwitch,
226 DistributedVirtualSwitchManager,
227 EnvironmentBrowser,
228 EventHistoryCollector,
229 EventManager,
230 ExtensibleManagedObject,
231 ExtensionManager,
232 FailoverClusterConfigurator,
233 FailoverClusterManager,
234 FileManager,
235 Folder,
236 GuestAliasManager,
237 GuestAuthManager,
238 GuestFileManager,
239 GuestOperationsManager,
240 GuestProcessManager,
241 GuestWindowsRegistryManager,
242 HealthUpdateManager,
243 HistoryCollector,
244 HostAccessManager,
245 HostActiveDirectoryAuthentication,
246 HostAssignableHardwareManager,
247 HostAuthenticationManager,
248 HostAuthenticationStore,
249 HostAutoStartManager,
250 HostBootDeviceSystem,
251 HostCacheConfigurationManager,
252 HostCertificateManager,
253 HostCpuSchedulerSystem,
254 HostDatastoreBrowser,
255 HostDatastoreSystem,
256 HostDateTimeSystem,
257 HostDiagnosticSystem,
258 HostDirectoryStore,
259 HostEsxAgentHostManager,
260 HostFirewallSystem,
261 HostFirmwareSystem,
262 HostGraphicsManager,
263 HostHealthStatusSystem,
264 HostImageConfigManager,
265 HostKernelModuleSystem,
266 HostLocalAccountManager,
267 HostLocalAuthentication,
268 HostMemorySystem,
269 HostNetworkSystem,
270 HostNvdimmSystem,
271 HostPatchManager,
272 HostPciPassthruSystem,
273 HostPowerSystem,
274 HostProfile,
275 HostProfileManager,
276 HostServiceSystem,
277 HostSnmpSystem,
278 HostSpecificationManager,
279 HostStorageSystem,
280 HostSystem,
281 HostVFlashManager,
282 HostVMotionSystem,
283 HostVStorageObjectManager,
284 HostVirtualNicManager,
285 HostVsanHealthSystem,
286 HostVsanInternalSystem,
287 HostVsanSystem,
288 HttpNfcLease,
289 InventoryView,
290 IoFilterManager,
291 IpPoolManager,
292 IscsiManager,
293 LicenseAssignmentManager,
294 LicenseManager,
295 ListView,
296 LocalizationManager,
297 ManagedEntity,
298 ManagedObjectView,
299 MessageBusProxy,
300 Network,
301 OpaqueNetwork,
302 OptionManager,
303 OverheadMemoryManager,
304 OvfManager,
305 PerformanceManager,
306 Profile,
307 ProfileComplianceManager,
308 ProfileManager,
309 PropertyCollector,
310 PropertyFilter,
311 ResourcePlanningManager,
312 ResourcePool,
313 ScheduledTask,
314 ScheduledTaskManager,
315 SearchIndex,
316 ServiceInstance,
317 ServiceManager,
318 SessionManager,
319 SimpleCommand,
320 SiteInfoManager,
321 StoragePod,
322 StorageQueryManager,
323 StorageResourceManager,
324 Task,
325 TaskHistoryCollector,
326 TaskManager,
327 TenantTenantManager,
328 UserDirectory,
329 VStorageObjectManagerBase,
330 VcenterVStorageObjectManager,
331 View,
332 ViewManager,
333 VimClusterVsanVcDiskManagementSystem,
334 VimClusterVsanVcStretchedClusterSystem,
335 VirtualApp,
336 VirtualDiskManager,
337 VirtualMachine,
338 VirtualMachineCompatibilityChecker,
339 VirtualMachineGuestCustomizationManager,
340 VirtualMachineProvisioningChecker,
341 VirtualMachineSnapshot,
342 VirtualizationManager,
343 VmwareDistributedVirtualSwitch,
344 VsanCapabilitySystem,
345 VsanClusterHealthSystem,
346 VsanClusterMgmtInternalSystem,
347 VsanIscsiTargetSystem,
348 VsanObjectSystem,
349 VsanPerformanceManager,
350 VsanSpaceReportSystem,
351 VsanSystemEx,
352 VsanUpgradeSystem,
353 VsanUpgradeSystemEx,
354 VsanVcClusterConfigSystem,
355 VsanVcClusterHealthSystem,
356 VsanVcsaDeployerSystem,
357 Agency,
358 Agent,
359 EamObject,
360 EamTask,
361 EsxAgentManager,
362 PbmCapabilityMetadataManager,
363 PbmComplianceManager,
364 PbmPlacementSolver,
365 PbmProfileProfileManager,
366 PbmProvider,
367 PbmReplicationManager,
368 PbmServiceInstance,
369 PbmSessionManager,
370 SmsProvider,
371 SmsServiceInstance,
372 SmsSessionManager,
373 SmsStorageManager,
374 SmsTask,
375 VasaProvider,
376 ManagedObject,
377 CnsVolumeManager,
378 HostSpbm,
379 VsanClusterPowerSystem,
380 VsanDiagnosticsSystem,
381 VsanFileServiceSystem,
382 VsanHostVdsSystem,
383 VsanIoInsightManager,
384 VsanMassCollector,
385 VsanObjectManager,
386 VsanPhoneHomeSystem,
387 VsanPolicyManager,
388 VsanRemoteDatastoreSystem,
389 VsanResourceCheckSystem,
390 VsanUpdateManager,
391 VsanVdsSystem,
392 VsanVumSystem,
393 VslmServiceInstance,
394 VslmSessionManager,
395 VslmStorageLifecycleManager,
396 VslmTask,
397 VslmVStorageObjectManager,
398 /// This variant handles values not known at compile time.
399 #[serde(untagged)]
400 #[strum(serialize = "__OTHER__")]
401 Other_(String),
402}
403/// Enumeration of reason codes representing the invalid data protection states.
404///
405/// Possible values:
406/// - `protectionDegraded`: Data protection of one or more disks associated with the protected entity is degraded.
407///
408/// The data protection must be disabled and re-enabled in order to have data protection supported.
409/// - `notProtected`
410/// - `invalidProtectionReasonUnknown`: A fallback value used when a client sees an unknown InvalidProtectionReason.
411#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
412pub enum DpInvalidProtectionReasonEnum {
413 #[serde(rename = "protectionDegraded")]
414 #[strum(serialize = "protectionDegraded")]
415 ProtectionDegraded,
416 #[serde(rename = "notProtected")]
417 #[strum(serialize = "notProtected")]
418 NotProtected,
419 #[serde(rename = "invalidProtectionReasonUnknown")]
420 #[strum(serialize = "invalidProtectionReasonUnknown")]
421 InvalidProtectionReasonUnknown,
422 /// This variant handles values not known at compile time.
423 #[serde(untagged)]
424 #[strum(serialize = "__OTHER__")]
425 Other_(String),
426}
427/// Indicates the type of migration that is in progress for a
428/// *DpProtectedEntity*.
429///
430/// Possible values:
431/// - `coldMigration`: A cold migration is in progress.
432/// - `hotMigration`: A hot migration is in progress.
433/// - `migrationTypeUnknown`: The value to be used when the older version client cannot recognize the enum value.
434#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
435pub enum DpMigrationTypeEnum {
436 #[serde(rename = "coldMigration")]
437 #[strum(serialize = "coldMigration")]
438 ColdMigration,
439 #[serde(rename = "hotMigration")]
440 #[strum(serialize = "hotMigration")]
441 HotMigration,
442 #[serde(rename = "migrationTypeUnknown")]
443 #[strum(serialize = "migrationTypeUnknown")]
444 MigrationTypeUnknown,
445 /// This variant handles values not known at compile time.
446 #[serde(untagged)]
447 #[strum(serialize = "__OTHER__")]
448 Other_(String),
449}
450/// Indicates the protection status for the *DpProtectedEntity*.
451///
452/// Possible values:
453/// - `pe_protected`: The ProtectedEntity is protected by vSphere Data Protection.
454/// - `pe_unprotected`: The ProtectedEntity is not protected by vSphere Data Protection.
455/// - `pe_partially_protected`: Only some elements of the ProtectedEntity are protected by vSphere Data Protection.
456///
457/// For example, if only some disks of a *DpVirtualMachineProtectedEntity* are protected.
458/// - `ProtectionStatusType_unknown`: Represents value when the lower version client cannot recognize the enum value.
459#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
460pub enum DpProtectionStatusTypeEnum {
461 #[serde(rename = "pe_protected")]
462 #[strum(serialize = "pe_protected")]
463 PeProtected,
464 #[serde(rename = "pe_unprotected")]
465 #[strum(serialize = "pe_unprotected")]
466 PeUnprotected,
467 #[serde(rename = "pe_partially_protected")]
468 #[strum(serialize = "pe_partially_protected")]
469 PePartiallyProtected,
470 #[serde(rename = "ProtectionStatusType_unknown")]
471 #[strum(serialize = "ProtectionStatusType_unknown")]
472 ProtectionStatusTypeUnknown,
473 /// This variant handles values not known at compile time.
474 #[serde(untagged)]
475 #[strum(serialize = "__OTHER__")]
476 Other_(String),
477}
478/// Indicates if the cluster supports vSphere Data Protection.
479///
480/// Possible values:
481/// - `supported`: The LWD VAIO filter is installed on all hosts in the cluster.
482///
483/// The cluster supports data protection.
484/// - `partially_supported`: The LWD VAIO filter is installed on some hosts in the cluster.
485///
486/// If protection in enabled on an entity, it cannot migrate to other nodes in the cluster until all the nodes have the filter installed.
487/// - `not_supported`: The LWD VAIO filter is not installed on any of the hosts in the cluster.
488///
489/// Entities cannot be protected in this cluster.
490/// - `ProtectionSupportType_unknown`: Represents value when the lower version client cannot recognize the enum value.
491#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
492pub enum DpProtectionSupportTypeEnum {
493 #[serde(rename = "supported")]
494 #[strum(serialize = "supported")]
495 Supported,
496 #[serde(rename = "partially_supported")]
497 #[strum(serialize = "partially_supported")]
498 PartiallySupported,
499 #[serde(rename = "not_supported")]
500 #[strum(serialize = "not_supported")]
501 NotSupported,
502 #[serde(rename = "ProtectionSupportType_unknown")]
503 #[strum(serialize = "ProtectionSupportType_unknown")]
504 ProtectionSupportTypeUnknown,
505 /// This variant handles values not known at compile time.
506 #[serde(untagged)]
507 #[strum(serialize = "__OTHER__")]
508 Other_(String),
509}
510/// Indicates the type of snapshot taken on a given protected entity.
511///
512/// Possible values:
513/// - `crashConsistent`: Crash Consistent snapshot.
514/// - `applicationConsistent`: Application Consistent snapshot.
515///
516/// Generally used for linux GOS to run pre-freeze and post-thaw scripts.
517/// - `vssAppConsistentFull`:
518///
519/// 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.
520///
521/// This is deprecated.
522/// - `vssAppConsistentCopy`:
523///
524/// 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.
525///
526/// This is deprecated.
527/// - `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.
528///
529/// It is generally used for restore operations like 'In-place' restore and 'Failback'.
530/// - `vssAppConsistent`
531/// - `snapshotTypeUnknown`: The value to be used when the older version client cannot recognize the enum value.
532#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
533pub enum DpSnapshotTypeEnum {
534 #[serde(rename = "crashConsistent")]
535 #[strum(serialize = "crashConsistent")]
536 CrashConsistent,
537 #[serde(rename = "applicationConsistent")]
538 #[strum(serialize = "applicationConsistent")]
539 ApplicationConsistent,
540 #[serde(rename = "vssAppConsistentFull")]
541 #[strum(serialize = "vssAppConsistentFull")]
542 VssAppConsistentFull,
543 #[serde(rename = "vssAppConsistentCopy")]
544 #[strum(serialize = "vssAppConsistentCopy")]
545 VssAppConsistentCopy,
546 #[serde(rename = "metadataOnly")]
547 #[strum(serialize = "metadataOnly")]
548 MetadataOnly,
549 #[serde(rename = "vssAppConsistent")]
550 #[strum(serialize = "vssAppConsistent")]
551 VssAppConsistent,
552 #[serde(rename = "snapshotTypeUnknown")]
553 #[strum(serialize = "snapshotTypeUnknown")]
554 SnapshotTypeUnknown,
555 /// This variant handles values not known at compile time.
556 #[serde(untagged)]
557 #[strum(serialize = "__OTHER__")]
558 Other_(String),
559}
560/// Indicates the type of sync operation to perform on a given protected entity.
561///
562/// Possible values:
563/// - `fullSync`: Full sync.
564///
565/// Transfer all allocated data.
566/// - `deltaSync`: Delta sync.
567///
568/// Transfer changed blocks since the last sync operation.
569/// - `syncTypeUnknown`: The value to be used when the older version client cannot recognize the enum value.
570#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
571pub enum DpSyncTypeEnum {
572 #[serde(rename = "fullSync")]
573 #[strum(serialize = "fullSync")]
574 FullSync,
575 #[serde(rename = "deltaSync")]
576 #[strum(serialize = "deltaSync")]
577 DeltaSync,
578 #[serde(rename = "syncTypeUnknown")]
579 #[strum(serialize = "syncTypeUnknown")]
580 SyncTypeUnknown,
581 /// This variant handles values not known at compile time.
582 #[serde(untagged)]
583 #[strum(serialize = "__OTHER__")]
584 Other_(String),
585}
586/// Enumeration of vSphere Data Protection capabilities (features).
587///
588/// Possible values:
589/// - `QueryPeInfo`: Support for QueryProtectedEntityInfo API.
590///
591/// Required minimal ESX vmodl version: '7.0.3.0'.
592/// - `PerDiskBaseSnapshotId`: Support for specifying per-disk base-snapshot ID when taking a vSphere Data Protection snapshot.
593///
594/// Required minimal ESX vmodl version: '8.0.0.1'.
595/// - `QuiescedSnapshot`: Support for vSphere Data Protection application consistent and quiesced snapshots.
596///
597/// Required minimal ESX vmodl version: '8.0.1.0'.
598/// - `RuntimeStats`: Support for querying DPD runtime stats with the QueryProtectedEntityInfo API.
599///
600/// Required minimal ESX vmodl version: '8.0.1.0'.
601/// - `PreservedExtents`: Support for DataIntegrity specific params (v1) when taking vSphere Data Protection snapshots.
602///
603/// Required minimal ESX vmodl version: '8.0.1.0', and ESX version of '8.0.1' and patch level of at least '0.25'.
604/// - `MultiPe`: Support for multi-PE consistency groups.
605///
606/// Required minimal ESX vmodl version: '8.0.2.0'.
607/// - `VsanNativeSnapshot`: Support for VSAN native snapshots.
608///
609/// Required minimal ESX vmodl version: '8.0.3.0'.
610/// - `SparseDiskEnhancement`: Enhancement for vSphere Data Protection operations over sparse disks.
611///
612/// Required minimal ESX vmodl version: '8.0.3.0'.
613/// - `VSphereDpCapabilities_Unknown`: Fallback value for an unknown VSphereDataProtectionCapabilities seen by a client.
614///
615/// ***Since:*** 8.0.0.4
616#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
617pub enum DpVSphereDataProtectionCapabilitiesEnum {
618 QueryPeInfo,
619 PerDiskBaseSnapshotId,
620 QuiescedSnapshot,
621 RuntimeStats,
622 PreservedExtents,
623 MultiPe,
624 VsanNativeSnapshot,
625 SparseDiskEnhancement,
626 #[serde(rename = "VSphereDpCapabilities_Unknown")]
627 #[strum(serialize = "VSphereDpCapabilities_Unknown")]
628 VSphereDpCapabilitiesUnknown,
629 /// This variant handles values not known at compile time.
630 #[serde(untagged)]
631 #[strum(serialize = "__OTHER__")]
632 Other_(String),
633}
634/// Indicates the backup context to be used for a VSS snapshot.
635///
636/// Applicable only
637/// for windows VMs. Refer to `VSS_SNAPSHOT_CONTEXT` enumeration on MSDN.
638///
639/// Possible values:
640/// - `vssBackupContextAuto`: This option lets the guest automatically select the right backup context among the values below.
641/// - `vssBackupContextBackup`: This correlates to `VSS_CTX_BACKUP`.
642///
643/// 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.
644/// - `vssBackupContextFileShareBackup`: This correlates to `VSS_CTX_FILE_SHARE_BACKUP`.
645///
646/// 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.
647/// - `vssBackupContextUnknown`: The value to be used when the older version client cannot recognize the enum value.
648#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
649pub enum DpVssBackupContextEnum {
650 #[serde(rename = "vssBackupContextAuto")]
651 #[strum(serialize = "vssBackupContextAuto")]
652 VssBackupContextAuto,
653 #[serde(rename = "vssBackupContextBackup")]
654 #[strum(serialize = "vssBackupContextBackup")]
655 VssBackupContextBackup,
656 #[serde(rename = "vssBackupContextFileShareBackup")]
657 #[strum(serialize = "vssBackupContextFileShareBackup")]
658 VssBackupContextFileShareBackup,
659 #[serde(rename = "vssBackupContextUnknown")]
660 #[strum(serialize = "vssBackupContextUnknown")]
661 VssBackupContextUnknown,
662 /// This variant handles values not known at compile time.
663 #[serde(untagged)]
664 #[strum(serialize = "__OTHER__")]
665 Other_(String),
666}
667/// Indicates the backup type for a VSS snapshot.
668///
669/// Applicable only for windows
670/// VMs. Refer to `VSS_BACKUP_TYPE` enumeration on MSDN.
671///
672/// Possible values:
673/// - `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.
674/// - `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.
675/// - `vssBackupTypeUnknown`: The value to be used when the older version client cannot recognize the enum value.
676#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
677pub enum DpVssBackupTypeEnum {
678 #[serde(rename = "vssBackupTypeFull")]
679 #[strum(serialize = "vssBackupTypeFull")]
680 VssBackupTypeFull,
681 #[serde(rename = "vssBackupTypeCopy")]
682 #[strum(serialize = "vssBackupTypeCopy")]
683 VssBackupTypeCopy,
684 #[serde(rename = "vssBackupTypeUnknown")]
685 #[strum(serialize = "vssBackupTypeUnknown")]
686 VssBackupTypeUnknown,
687 /// This variant handles values not known at compile time.
688 #[serde(untagged)]
689 #[strum(serialize = "__OTHER__")]
690 Other_(String),
691}
692/// Enumeration of the support level for a cluster in terms of vSphere Data
693/// Protection capabilities.
694///
695/// Possible values:
696/// - `supported`: The capability is supported on all hosts in the cluster.
697/// - `partially_supported`: The capability is supported on only some but not all of the hosts in the cluster.
698/// - `not_supported`: The capability is not supported on any of the hosts in the cluster.
699/// - `CapabilitySupportLevel_unknown`: Fallback value for an unknown CapabilitySupportLevel seen by a client.
700///
701/// ***Since:*** 8.0.0.4
702#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
703pub enum DpCapabilitySupportLevelEnum {
704 #[serde(rename = "supported")]
705 #[strum(serialize = "supported")]
706 Supported,
707 #[serde(rename = "partially_supported")]
708 #[strum(serialize = "partially_supported")]
709 PartiallySupported,
710 #[serde(rename = "not_supported")]
711 #[strum(serialize = "not_supported")]
712 NotSupported,
713 #[serde(rename = "CapabilitySupportLevel_unknown")]
714 #[strum(serialize = "CapabilitySupportLevel_unknown")]
715 CapabilitySupportLevelUnknown,
716 /// This variant handles values not known at compile time.
717 #[serde(untagged)]
718 #[strum(serialize = "__OTHER__")]
719 Other_(String),
720}
721/// Enumeration of type of SRM workflow.
722///
723/// Possible values:
724/// - `test_failover`: A test failover workflow.
725/// - `cleanup_test`: Clean up after a test failover.
726/// - `failover`: A failover workflow.
727/// - `reprotect`: A reprotect workflow.
728/// - `srmWorkflowUnknown`: A fallback value used when a client sees an unknown SrmWorkflow.
729///
730/// ***Since:*** 8.0.0.4
731#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
732pub enum DpDrSrmWorkflowEnum {
733 #[serde(rename = "test_failover")]
734 #[strum(serialize = "test_failover")]
735 TestFailover,
736 #[serde(rename = "cleanup_test")]
737 #[strum(serialize = "cleanup_test")]
738 CleanupTest,
739 #[serde(rename = "failover")]
740 #[strum(serialize = "failover")]
741 Failover,
742 #[serde(rename = "reprotect")]
743 #[strum(serialize = "reprotect")]
744 Reprotect,
745 #[serde(rename = "srmWorkflowUnknown")]
746 #[strum(serialize = "srmWorkflowUnknown")]
747 SrmWorkflowUnknown,
748 /// This variant handles values not known at compile time.
749 #[serde(untagged)]
750 #[strum(serialize = "__OTHER__")]
751 Other_(String),
752}
753/// Deprecated as of vSphere 9.0. Please refer to vLCM System VMs APIs.
754///
755/// Defines if the deployed VMs needs to run on different hosts.
756///
757/// Possible values:
758/// - `none`: Denotes no specific VM anti-affinity policy.
759/// - `soft`: Best effort is made the VMs to run on different hosts as long as
760/// this does not impact the ability of the host to satisfy current CPU
761/// or memory requirements for virtual machines on the system.
762///
763/// NOTE: Currently not supported - i.e. the agency configuration is
764/// considered as invalid.
765#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
766pub enum AgencyVmPlacementPolicyVmAntiAffinityEnum {
767 #[serde(rename = "none")]
768 #[strum(serialize = "none")]
769 None,
770 #[serde(rename = "soft")]
771 #[strum(serialize = "soft")]
772 Soft,
773 /// This variant handles values not known at compile time.
774 #[serde(untagged)]
775 #[strum(serialize = "__OTHER__")]
776 Other_(String),
777}
778/// Deprecated as of vSphere 9.0. Please refer to vLCM System VMs APIs.
779///
780/// Defines if the deployed VM is affinied to run on the same host it is
781/// deployed on.
782///
783/// Possible values:
784/// - `none`: Denotes no specific VM data affinity policy.
785/// - `soft`: Best effort is made the VM to run on the same host it is deployed on
786/// as long as this does not impact the ability of the host to satisfy
787/// current CPU or memory requirements for virtual machines on the
788/// system.
789///
790/// NOTE: Currently not supported - i.e. the agency configuration is
791/// considered as invalid.
792#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
793pub enum AgencyVmPlacementPolicyVmDataAffinityEnum {
794 #[serde(rename = "none")]
795 #[strum(serialize = "none")]
796 None,
797 #[serde(rename = "soft")]
798 #[strum(serialize = "soft")]
799 Soft,
800 /// This variant handles values not known at compile time.
801 #[serde(untagged)]
802 #[strum(serialize = "__OTHER__")]
803 Other_(String),
804}
805/// Deprecated as of vSphere 9.0. Please refer to vLCM APIs.
806///
807/// Supported authentication schemes used to access an OVF URL.
808///
809/// Possible values:
810/// - `NONE`: Accessing the OVF URL doesn't require authentication.
811/// - `VMWARE_SESSION_ID`: Accessing the OVF URL requires Vmware client sessionID.
812///
813/// ***Since:*** vEAM API 9.0
814#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
815pub enum AgentConfigInfoAuthenticationSchemeEnum {
816 #[serde(rename = "NONE")]
817 #[strum(serialize = "NONE")]
818 None,
819 #[serde(rename = "VMWARE_SESSION_ID")]
820 #[strum(serialize = "VMWARE_SESSION_ID")]
821 VmwareSessionId,
822 /// This variant handles values not known at compile time.
823 #[serde(untagged)]
824 #[strum(serialize = "__OTHER__")]
825 Other_(String),
826}
827/// Deprecated as of vSphere 9.0. Please refer to vLCM APIs.
828///
829/// Defines the type of disk provisioning for the target Agent VMs.
830///
831/// Possible values:
832/// - `none`: Denotes no specific type for disk provisioning.
833///
834/// Disks will be
835/// provisioned as defaulted by vSphere.
836/// - `thin`: Disks will be provisioned with only used space allocated.
837/// - `thick`: Disks will be provisioned with full size allocated.
838#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
839pub enum AgentConfigInfoOvfDiskProvisioningEnum {
840 #[serde(rename = "none")]
841 #[strum(serialize = "none")]
842 None,
843 #[serde(rename = "thin")]
844 #[strum(serialize = "thin")]
845 Thin,
846 #[serde(rename = "thick")]
847 #[strum(serialize = "thick")]
848 Thick,
849 /// This variant handles values not known at compile time.
850 #[serde(untagged)]
851 #[strum(serialize = "__OTHER__")]
852 Other_(String),
853}
854/// Represents the state of the VM lifecycle.
855///
856/// Possible values:
857/// - `provisioned`: The VM is provisioned and not powered-on.
858/// - `poweredOn`: The VM is powered on.
859/// - `prePowerOn`: The VM is about to be powered on as part of a VM upgrade workflow.
860#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
861pub enum AgentVmHookVmStateEnum {
862 #[serde(rename = "provisioned")]
863 #[strum(serialize = "provisioned")]
864 Provisioned,
865 #[serde(rename = "poweredOn")]
866 #[strum(serialize = "poweredOn")]
867 PoweredOn,
868 #[serde(rename = "prePowerOn")]
869 #[strum(serialize = "prePowerOn")]
870 PrePowerOn,
871 /// This variant handles values not known at compile time.
872 #[serde(untagged)]
873 #[strum(serialize = "__OTHER__")]
874 Other_(String),
875}
876/// Deprecated as of vSphere 9.0. Please refer to vLCM APIs.
877///
878/// The <code>GoalState</code> enumeration defines the goal of the entity.
879///
880/// Possible values:
881/// - `enabled`: The entity should be fully deployed and active.
882///
883/// If the entity is an
884/// *Agency*, it should install VIBs and deploy and power on all agent
885/// virtual machines. If the entity is an *Agent*, its VIB should be installed and its
886/// agent virtual machine should be deployed and powered on.
887/// - `disabled`: The entity should be fully deployed but inactive.
888///
889/// f the entity is an
890/// *Agency*, the behavior is similar to the <code>enabled</code> goal state, but
891/// agents are not powered on (if they have been powered on they are powered
892/// off).
893/// - `uninstalled`: The entity should be completely removed from the vCenter Server.
894///
895/// If the entity is an
896/// *Agency*, no more VIBs or agent virtual machines are deployed. All installed VIBs
897/// installed by the *Agency* are uninstalled and any deployed agent virtual machines
898/// are powered off (if they have been powered on) and deleted.
899/// If the entity is an *Agent*, its VIB is uninstalled and the virtual machine is
900/// powered off and deleted.
901#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
902pub enum EamObjectRuntimeInfoGoalStateEnum {
903 #[serde(rename = "enabled")]
904 #[strum(serialize = "enabled")]
905 Enabled,
906 #[serde(rename = "disabled")]
907 #[strum(serialize = "disabled")]
908 Disabled,
909 #[serde(rename = "uninstalled")]
910 #[strum(serialize = "uninstalled")]
911 Uninstalled,
912 /// This variant handles values not known at compile time.
913 #[serde(untagged)]
914 #[strum(serialize = "__OTHER__")]
915 Other_(String),
916}
917/// Deprecated as of vSphere 9.0. Please refer to vLCM APIs.
918///
919/// <code>Status</code> defines a health value that denotes how well the entity
920/// conforms to the goal state.
921///
922/// Possible values:
923/// - `green`: The entity is in perfect compliance with the goal state.
924/// - `yellow`: The entity is actively working to reach the desired goal state.
925/// - `red`: The entity has reached an issue which prevents it from reaching the desired goal
926/// state.
927///
928/// To remediate any offending issues, look at *EamObjectRuntimeInfo.issue*
929/// and use either *EamObject.Resolve* or
930/// *EamObject.ResolveAll*.
931#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
932pub enum EamObjectRuntimeInfoStatusEnum {
933 #[serde(rename = "green")]
934 #[strum(serialize = "green")]
935 Green,
936 #[serde(rename = "yellow")]
937 #[strum(serialize = "yellow")]
938 Yellow,
939 #[serde(rename = "red")]
940 #[strum(serialize = "red")]
941 Red,
942 /// This variant handles values not known at compile time.
943 #[serde(untagged)]
944 #[strum(serialize = "__OTHER__")]
945 Other_(String),
946}
947/// Deprecated as of vSphere 9.0. Please refer to vLCM Image APIs.
948///
949/// <code>MaintenanceModePolicy</code> defines how ESX Agent Manager is going
950/// to put into maintenance mode hosts which are part of a cluster not managed
951/// by vSphere Lifecycle Manager.
952///
953/// Possible values:
954/// - `singleHost`: Only a single host at a time will be put into maintenance mode.
955/// - `multipleHosts`: Hosts will be put into maintenance mode simultaneously.
956///
957/// If vSphere DRS
958/// is enabled, its recommendations will be used. Otherwise, it will be
959/// attempted to put in maintenance mode simultaneously as many host as
960/// possible.
961///
962/// ***Since:*** vEAM API 7.4
963#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
964pub enum EsxAgentManagerMaintenanceModePolicyEnum {
965 #[serde(rename = "singleHost")]
966 #[strum(serialize = "singleHost")]
967 SingleHost,
968 #[serde(rename = "multipleHosts")]
969 #[strum(serialize = "multipleHosts")]
970 MultipleHosts,
971 /// This variant handles values not known at compile time.
972 #[serde(untagged)]
973 #[strum(serialize = "__OTHER__")]
974 Other_(String),
975}
976/// Supported types of hooks for agents.
977///
978/// Possible values:
979/// - `POST_PROVISIONING`: Hook raised for an agent immediately after a Virtual Machine was
980/// created.
981/// - `POST_POWER_ON`: Hook raised for an agent immediately after a Virtual Machine was
982/// powered on.
983#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
984pub enum HooksHookTypeEnum {
985 #[serde(rename = "POST_PROVISIONING")]
986 #[strum(serialize = "POST_PROVISIONING")]
987 PostProvisioning,
988 #[serde(rename = "POST_POWER_ON")]
989 #[strum(serialize = "POST_POWER_ON")]
990 PostPowerOn,
991 /// This variant handles values not known at compile time.
992 #[serde(untagged)]
993 #[strum(serialize = "__OTHER__")]
994 Other_(String),
995}
996/// Reasons solution is not valid for application.
997///
998/// Possible values:
999/// - `INVALID_OVF_DESCRIPTOR`: The OVF descriptor provided in the VM source is invalid.
1000/// - `INACCESSBLE_VM_SOURCE`: The provided VM source is inaccessible from ESX Agent Manager.
1001/// - `INVALID_NETWORKS`: The provided networks are not suitable for application purposes.
1002/// - `INVALID_DATASTORES`: The provided datastores are not suitable for application purposes.
1003/// - `INVALID_RESOURCE_POOL`: The provided resource pool is not accessible or part of the cluster.
1004/// - `INVALID_FOLDER`: The provided folder is inaccessible or not part of the same datacenter
1005/// with the cluster.
1006/// - `INVALID_PROPERTIES`: The provided OVF properties are insufficient to satisfy the required
1007/// user configurable properties in the VM described in the vmSource.
1008/// - `INVALID_TRANSITION`: The legacy agency requested for transition is not valid/cannot be
1009/// mapped to systm Virtual Machines solution.
1010#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1011pub enum SolutionsInvalidReasonEnum {
1012 #[serde(rename = "INVALID_OVF_DESCRIPTOR")]
1013 #[strum(serialize = "INVALID_OVF_DESCRIPTOR")]
1014 InvalidOvfDescriptor,
1015 #[serde(rename = "INACCESSBLE_VM_SOURCE")]
1016 #[strum(serialize = "INACCESSBLE_VM_SOURCE")]
1017 InaccessbleVmSource,
1018 #[serde(rename = "INVALID_NETWORKS")]
1019 #[strum(serialize = "INVALID_NETWORKS")]
1020 InvalidNetworks,
1021 #[serde(rename = "INVALID_DATASTORES")]
1022 #[strum(serialize = "INVALID_DATASTORES")]
1023 InvalidDatastores,
1024 #[serde(rename = "INVALID_RESOURCE_POOL")]
1025 #[strum(serialize = "INVALID_RESOURCE_POOL")]
1026 InvalidResourcePool,
1027 #[serde(rename = "INVALID_FOLDER")]
1028 #[strum(serialize = "INVALID_FOLDER")]
1029 InvalidFolder,
1030 #[serde(rename = "INVALID_PROPERTIES")]
1031 #[strum(serialize = "INVALID_PROPERTIES")]
1032 InvalidProperties,
1033 #[serde(rename = "INVALID_TRANSITION")]
1034 #[strum(serialize = "INVALID_TRANSITION")]
1035 InvalidTransition,
1036 /// This variant handles values not known at compile time.
1037 #[serde(untagged)]
1038 #[strum(serialize = "__OTHER__")]
1039 Other_(String),
1040}
1041/// Describes possible reasons a solution is non compliant.
1042///
1043/// Possible values:
1044/// - `WORKING`: There is ongoing work to acheive the desired state.
1045/// - `ISSUE`: ESX Agent Manager has ecnountered am issue attempting to acheive the
1046/// desired state.
1047/// - `IN_HOOK`: ESX Agent Manager is awaiting user input to continue attempting to
1048/// acheive the desired state.
1049/// - `OBSOLETE_SPEC`: An obsoleted spec is currently in application for this solution.
1050///
1051/// This state should take precedence over:
1052/// - *WORKING*
1053/// - *ISSUE*
1054/// - *IN_HOOK*
1055/// - `NO_SPEC`: Application for this solutiona has never been requested with
1056/// *Solutions.Apply*.
1057#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1058pub enum SolutionsNonComplianceReasonEnum {
1059 #[serde(rename = "WORKING")]
1060 #[strum(serialize = "WORKING")]
1061 Working,
1062 #[serde(rename = "ISSUE")]
1063 #[strum(serialize = "ISSUE")]
1064 Issue,
1065 #[serde(rename = "IN_HOOK")]
1066 #[strum(serialize = "IN_HOOK")]
1067 InHook,
1068 #[serde(rename = "OBSOLETE_SPEC")]
1069 #[strum(serialize = "OBSOLETE_SPEC")]
1070 ObsoleteSpec,
1071 #[serde(rename = "NO_SPEC")]
1072 #[strum(serialize = "NO_SPEC")]
1073 NoSpec,
1074 /// This variant handles values not known at compile time.
1075 #[serde(untagged)]
1076 #[strum(serialize = "__OTHER__")]
1077 Other_(String),
1078}
1079/// Virtual Machine deployment optimization strategies.
1080///
1081/// Possible values:
1082/// - `ALL_CLONES`: Utilizes all cloning methods available, will create initial snapshots
1083/// on the Virtual Machines.
1084/// - `FULL_CLONES_ONLY`: Utilize only full copy cloning menthods, will create initial snapshots
1085/// on the Virtual Machines.
1086/// - `NO_CLONES`: Virtual Machiness will not be cloned from pre-existing deployment.
1087#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1088pub enum SolutionsVmDeploymentOptimizationEnum {
1089 #[serde(rename = "ALL_CLONES")]
1090 #[strum(serialize = "ALL_CLONES")]
1091 AllClones,
1092 #[serde(rename = "FULL_CLONES_ONLY")]
1093 #[strum(serialize = "FULL_CLONES_ONLY")]
1094 FullClonesOnly,
1095 #[serde(rename = "NO_CLONES")]
1096 #[strum(serialize = "NO_CLONES")]
1097 NoClones,
1098 /// This variant handles values not known at compile time.
1099 #[serde(untagged)]
1100 #[strum(serialize = "__OTHER__")]
1101 Other_(String),
1102}
1103/// Provisioning types for system Virtual Machines.
1104///
1105/// Possible values:
1106/// - `THIN`: Disks will be provisioned with only used space allocated.
1107/// - `THICK`: Disks will be provisioned with full size allocated.
1108#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1109pub enum SolutionsVmDiskProvisioningEnum {
1110 #[serde(rename = "THIN")]
1111 #[strum(serialize = "THIN")]
1112 Thin,
1113 #[serde(rename = "THICK")]
1114 #[strum(serialize = "THICK")]
1115 Thick,
1116 /// This variant handles values not known at compile time.
1117 #[serde(untagged)]
1118 #[strum(serialize = "__OTHER__")]
1119 Other_(String),
1120}
1121/// Defines the DRS placement policies applied on the VMs.
1122///
1123/// Possible values:
1124/// - `VM_VM_ANTI_AFFINITY`: VMs are anti-affined to each other.
1125#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1126pub enum SolutionsVmPlacementPolicyEnum {
1127 #[serde(rename = "VM_VM_ANTI_AFFINITY")]
1128 #[strum(serialize = "VM_VM_ANTI_AFFINITY")]
1129 VmVmAntiAffinity,
1130 /// This variant handles values not known at compile time.
1131 #[serde(untagged)]
1132 #[strum(serialize = "__OTHER__")]
1133 Other_(String),
1134}
1135/// This enum corresponds to the different packages whose logging
1136/// is configured independently by sps service.
1137///
1138/// Possible values:
1139/// - `pbm`: Modifies logging level of com.vmware.pbm package.
1140/// - `vslm`: Modifies logging level of com.vmware.vslm package.
1141/// - `sms`: Modifies logging level of com.vmware.vim.sms package.
1142/// - `spbm`: Modifies logging level of com.vmware.spbm package.
1143/// - `sps`: Modifies logging level of com.vmware.sps package.
1144/// - `httpclient_header`: Modifies logging level of httpclient wire header.
1145/// - `httpclient_content`: Modifies logging level of httpclient wire content.
1146/// - `vmomi`: Modifies logging level of com.vmware.vim.vmomi package.
1147#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1148pub enum PbmLoggingConfigurationComponentEnum {
1149 #[serde(rename = "pbm")]
1150 #[strum(serialize = "pbm")]
1151 Pbm,
1152 #[serde(rename = "vslm")]
1153 #[strum(serialize = "vslm")]
1154 Vslm,
1155 #[serde(rename = "sms")]
1156 #[strum(serialize = "sms")]
1157 Sms,
1158 #[serde(rename = "spbm")]
1159 #[strum(serialize = "spbm")]
1160 Spbm,
1161 #[serde(rename = "sps")]
1162 #[strum(serialize = "sps")]
1163 Sps,
1164 #[serde(rename = "httpclient_header")]
1165 #[strum(serialize = "httpclient_header")]
1166 HttpclientHeader,
1167 #[serde(rename = "httpclient_content")]
1168 #[strum(serialize = "httpclient_content")]
1169 HttpclientContent,
1170 #[serde(rename = "vmomi")]
1171 #[strum(serialize = "vmomi")]
1172 Vmomi,
1173 /// This variant handles values not known at compile time.
1174 #[serde(untagged)]
1175 #[strum(serialize = "__OTHER__")]
1176 Other_(String),
1177}
1178/// This enum corresponds to the different log levels supported
1179/// by sps service.
1180///
1181/// Possible values:
1182/// - `INFO`: Refers to INFO level logging
1183/// - `DEBUG`: Refers to DEBUG level logging.
1184/// - `TRACE`: Refers to TRACE level logging.
1185#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1186pub enum PbmLoggingConfigurationLogLevelEnum {
1187 #[serde(rename = "INFO")]
1188 #[strum(serialize = "INFO")]
1189 Info,
1190 #[serde(rename = "DEBUG")]
1191 #[strum(serialize = "DEBUG")]
1192 Debug,
1193 #[serde(rename = "TRACE")]
1194 #[strum(serialize = "TRACE")]
1195 Trace,
1196 /// This variant handles values not known at compile time.
1197 #[serde(untagged)]
1198 #[strum(serialize = "__OTHER__")]
1199 Other_(String),
1200}
1201/// This enum corresponds to the keystores used by
1202/// sps.
1203///
1204/// Possible values:
1205/// - `SMS`: Refers to SMS keystore
1206/// - `TRUSTED_ROOTS`: Refers to TRUSTED\_ROOTS keystore.
1207#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1208pub enum PbmDebugManagerKeystoreNameEnum {
1209 #[serde(rename = "SMS")]
1210 #[strum(serialize = "SMS")]
1211 Sms,
1212 #[serde(rename = "TRUSTED_ROOTS")]
1213 #[strum(serialize = "TRUSTED_ROOTS")]
1214 TrustedRoots,
1215 /// This variant handles values not known at compile time.
1216 #[serde(untagged)]
1217 #[strum(serialize = "__OTHER__")]
1218 Other_(String),
1219}
1220/// The *PbmObjectType_enum* enumerated type
1221/// defines vSphere Server object types that are known
1222/// to the Storage Policy Server.
1223///
1224/// See *PbmServerObjectRef*.*PbmServerObjectRef.objectType*.
1225///
1226/// Possible values:
1227/// - `virtualMachine`: Indicates a virtual machine, not including the disks, identified by the virtual machine
1228/// identifier _virtual-machine-mor_.
1229/// - `virtualMachineAndDisks`: Indicates the virtual machine and all its disks, identified by the virtual machine
1230/// identifier _virtual-machine-mor_.
1231/// - `virtualDiskId`: Indicates a virtual disk, identified by disk key
1232/// (_virtual-machine-mor_:_disk-key_).
1233/// - `virtualDiskUUID`: Indicates a virtual disk, identified by UUID - for First Class Storage Object support.
1234/// - `datastore`: Indicates a datastore.
1235/// - `vsanObjectId`: Indicates a VSAN object
1236/// - `fileShareId`: Indicates a file service
1237/// - `unknown`: Unknown object type.
1238#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1239pub enum PbmObjectTypeEnum {
1240 #[serde(rename = "virtualMachine")]
1241 #[strum(serialize = "virtualMachine")]
1242 VirtualMachine,
1243 #[serde(rename = "virtualMachineAndDisks")]
1244 #[strum(serialize = "virtualMachineAndDisks")]
1245 VirtualMachineAndDisks,
1246 #[serde(rename = "virtualDiskId")]
1247 #[strum(serialize = "virtualDiskId")]
1248 VirtualDiskId,
1249 #[serde(rename = "virtualDiskUUID")]
1250 #[strum(serialize = "virtualDiskUUID")]
1251 VirtualDiskUuid,
1252 #[serde(rename = "datastore")]
1253 #[strum(serialize = "datastore")]
1254 Datastore,
1255 #[serde(rename = "vsanObjectId")]
1256 #[strum(serialize = "vsanObjectId")]
1257 VsanObjectId,
1258 #[serde(rename = "fileShareId")]
1259 #[strum(serialize = "fileShareId")]
1260 FileShareId,
1261 #[serde(rename = "unknown")]
1262 #[strum(serialize = "unknown")]
1263 Unknown,
1264 /// This variant handles values not known at compile time.
1265 #[serde(untagged)]
1266 #[strum(serialize = "__OTHER__")]
1267 Other_(String),
1268}
1269/// The *PbmVvolType_enum* enumeration type
1270/// defines VVOL types.
1271///
1272/// VvolType's are referenced to specify which objectType
1273/// to fetch for default capability.
1274///
1275/// Possible values:
1276/// - `Config`: meta-data volume
1277/// - `Data`: vmdk volume
1278/// - `Swap`: swap volume
1279#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1280pub enum PbmVvolTypeEnum {
1281 Config,
1282 Data,
1283 Swap,
1284 /// This variant handles values not known at compile time.
1285 #[serde(untagged)]
1286 #[strum(serialize = "__OTHER__")]
1287 Other_(String),
1288}
1289/// List of operators that are supported for constructing policy.
1290///
1291/// Currently only tag based properties can use this operator.
1292/// Other operators can be added as required.
1293///
1294/// Possible values:
1295/// - `NOT`
1296#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1297pub enum PbmCapabilityOperatorEnum {
1298 #[serde(rename = "NOT")]
1299 #[strum(serialize = "NOT")]
1300 Not,
1301 /// This variant handles values not known at compile time.
1302 #[serde(untagged)]
1303 #[strum(serialize = "__OTHER__")]
1304 Other_(String),
1305}
1306/// Capability category type constants.
1307///
1308/// Possible values:
1309/// - `common`: Common and identical in all sub-profiles.
1310/// - `datastoreSpecific`: Part of a single sub-profile.
1311#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1312pub enum PbmCapabilitySchemaCapabilityCategoryEnum {
1313 #[serde(rename = "common")]
1314 #[strum(serialize = "common")]
1315 Common,
1316 #[serde(rename = "datastoreSpecific")]
1317 #[strum(serialize = "datastoreSpecific")]
1318 DatastoreSpecific,
1319 /// This variant handles values not known at compile time.
1320 #[serde(untagged)]
1321 #[strum(serialize = "__OTHER__")]
1322 Other_(String),
1323}
1324/// Denotes the line of service of a schema.
1325///
1326/// Possible values:
1327/// - `INSPECTION`
1328/// - `COMPRESSION`
1329/// - `ENCRYPTION`
1330/// - `REPLICATION`
1331/// - `CACHING`
1332/// - `PERSISTENCE`
1333/// - `DATA_PROVIDER`
1334/// - `DATASTORE_IO_CONTROL`
1335/// - `DATA_PROTECTION`
1336/// - `STRETCHED_CLUSTER`
1337#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1338pub enum PbmLineOfServiceInfoLineOfServiceEnumEnum {
1339 #[serde(rename = "INSPECTION")]
1340 #[strum(serialize = "INSPECTION")]
1341 Inspection,
1342 #[serde(rename = "COMPRESSION")]
1343 #[strum(serialize = "COMPRESSION")]
1344 Compression,
1345 #[serde(rename = "ENCRYPTION")]
1346 #[strum(serialize = "ENCRYPTION")]
1347 Encryption,
1348 #[serde(rename = "REPLICATION")]
1349 #[strum(serialize = "REPLICATION")]
1350 Replication,
1351 #[serde(rename = "CACHING")]
1352 #[strum(serialize = "CACHING")]
1353 Caching,
1354 #[serde(rename = "PERSISTENCE")]
1355 #[strum(serialize = "PERSISTENCE")]
1356 Persistence,
1357 #[serde(rename = "DATA_PROVIDER")]
1358 #[strum(serialize = "DATA_PROVIDER")]
1359 DataProvider,
1360 #[serde(rename = "DATASTORE_IO_CONTROL")]
1361 #[strum(serialize = "DATASTORE_IO_CONTROL")]
1362 DatastoreIoControl,
1363 #[serde(rename = "DATA_PROTECTION")]
1364 #[strum(serialize = "DATA_PROTECTION")]
1365 DataProtection,
1366 #[serde(rename = "STRETCHED_CLUSTER")]
1367 #[strum(serialize = "STRETCHED_CLUSTER")]
1368 StretchedCluster,
1369 /// This variant handles values not known at compile time.
1370 #[serde(untagged)]
1371 #[strum(serialize = "__OTHER__")]
1372 Other_(String),
1373}
1374/// The *PbmBuiltinGenericType_enum* enumerated type defines the list
1375/// of builtin generic datatypes.
1376///
1377/// See
1378/// *PbmCapabilityGenericTypeInfo*.*PbmCapabilityGenericTypeInfo.genericTypeName*.
1379///
1380/// A generic datatype indicates how to interpret a collection of values
1381/// of a specific datatype (*PbmCapabilityTypeInfo.typeName*).
1382///
1383/// Possible values:
1384/// - `VMW_RANGE`: Indicates a full or partial range of values (*PbmCapabilityRange*).
1385///
1386/// A full range specifies both <code>min</code> and <code>max</code> values.
1387/// A partial range specifies one or the other, <code>min</code> or <code>max</code>.
1388/// - `VMW_SET`: Indicates a single value or a discrete set of values
1389/// (*PbmCapabilityDiscreteSet*).
1390#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1391pub enum PbmBuiltinGenericTypeEnum {
1392 #[serde(rename = "VMW_RANGE")]
1393 #[strum(serialize = "VMW_RANGE")]
1394 VmwRange,
1395 #[serde(rename = "VMW_SET")]
1396 #[strum(serialize = "VMW_SET")]
1397 VmwSet,
1398 /// This variant handles values not known at compile time.
1399 #[serde(untagged)]
1400 #[strum(serialize = "__OTHER__")]
1401 Other_(String),
1402}
1403/// The *PbmBuiltinType_enum* enumerated type defines datatypes
1404/// for storage profiles.
1405///
1406/// Property metadata
1407/// (*PbmCapabilityPropertyMetadata*) uses the builtin types
1408/// to define data types for storage capabilities and requirements.
1409/// It may also specify the semantics that are applied to a collection
1410/// of builtin type values. See *PbmCapabilityTypeInfo*.
1411/// These semantics are specified as a generic builtin type.
1412/// See *PbmCapabilityGenericTypeInfo*.
1413/// The type information determines how capability constraints are interpreted
1414/// *PbmCapabilityPropertyInstance.value*).
1415///
1416/// Possible values:
1417/// - `XSD_LONG`: Unsigned long value.
1418///
1419/// This datatype supports the following constraint values.
1420/// - Single value
1421/// - Full or partial range of values (*PbmCapabilityRange*)
1422/// - Discrete set of values (*PbmCapabilityDiscreteSet*)
1423/// - `XSD_SHORT`: Datatype not supported.
1424/// - `XSD_INTEGER`: Datatype not supported.
1425///
1426/// Use XSD\_INT instead.
1427/// - `XSD_INT`: Integer value.
1428///
1429/// This datatype supports the following constraint values.
1430/// - Single value
1431/// - Full or partial range of values (*PbmCapabilityRange*)
1432/// - Discrete set of values (*PbmCapabilityDiscreteSet*)
1433/// - `XSD_STRING`: String value.
1434///
1435/// This datatype supports a single value
1436/// or a discrete set of values (*PbmCapabilityDiscreteSet*).
1437/// - `XSD_BOOLEAN`: Boolean value.
1438/// - `XSD_DOUBLE`: Double precision floating point value.
1439///
1440/// This datatype supports the following
1441/// constraint values.
1442/// - Single value
1443/// - Full or partial range of values (*PbmCapabilityRange*)
1444/// - Discrete set of values (*PbmCapabilityDiscreteSet*)
1445/// - `XSD_DATETIME`: Date and time value.
1446/// - `VMW_TIMESPAN`: Timespan value (*PbmCapabilityTimeSpan*).
1447///
1448/// This datatype supports
1449/// the following constraint values.
1450/// - Single value
1451/// - Full or partial range of values (*PbmCapabilityRange*)
1452/// - Discrete set of values (*PbmCapabilityDiscreteSet*)
1453/// - `VMW_POLICY`
1454#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1455pub enum PbmBuiltinTypeEnum {
1456 #[serde(rename = "XSD_LONG")]
1457 #[strum(serialize = "XSD_LONG")]
1458 XsdLong,
1459 #[serde(rename = "XSD_SHORT")]
1460 #[strum(serialize = "XSD_SHORT")]
1461 XsdShort,
1462 #[serde(rename = "XSD_INTEGER")]
1463 #[strum(serialize = "XSD_INTEGER")]
1464 XsdInteger,
1465 #[serde(rename = "XSD_INT")]
1466 #[strum(serialize = "XSD_INT")]
1467 XsdInt,
1468 #[serde(rename = "XSD_STRING")]
1469 #[strum(serialize = "XSD_STRING")]
1470 XsdString,
1471 #[serde(rename = "XSD_BOOLEAN")]
1472 #[strum(serialize = "XSD_BOOLEAN")]
1473 XsdBoolean,
1474 #[serde(rename = "XSD_DOUBLE")]
1475 #[strum(serialize = "XSD_DOUBLE")]
1476 XsdDouble,
1477 #[serde(rename = "XSD_DATETIME")]
1478 #[strum(serialize = "XSD_DATETIME")]
1479 XsdDatetime,
1480 #[serde(rename = "VMW_TIMESPAN")]
1481 #[strum(serialize = "VMW_TIMESPAN")]
1482 VmwTimespan,
1483 #[serde(rename = "VMW_POLICY")]
1484 #[strum(serialize = "VMW_POLICY")]
1485 VmwPolicy,
1486 /// This variant handles values not known at compile time.
1487 #[serde(untagged)]
1488 #[strum(serialize = "__OTHER__")]
1489 Other_(String),
1490}
1491/// The *PbmCapabilityTimeUnitType_enum* enumeration type
1492/// defines the supported list of time units for profiles that specify
1493/// time span capabilities and constraints.
1494///
1495/// See *PbmCapabilityTimeSpan*.
1496///
1497/// Possible values:
1498/// - `SECONDS`: Constraints and capabilities expressed in units of seconds.
1499/// - `MINUTES`: Constraints and capabilities expressed in units of minutes.
1500/// - `HOURS`: Constraints and capabilities expressed in units of hours.
1501/// - `DAYS`: Constraints and capabilities expressed in units of days.
1502/// - `WEEKS`: Constraints and capabilities expressed in units of weeks.
1503/// - `MONTHS`: Constraints and capabilities expressed in units of months.
1504/// - `YEARS`: Constraints and capabilities expressed in units of years.
1505#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1506pub enum PbmCapabilityTimeUnitTypeEnum {
1507 #[serde(rename = "SECONDS")]
1508 #[strum(serialize = "SECONDS")]
1509 Seconds,
1510 #[serde(rename = "MINUTES")]
1511 #[strum(serialize = "MINUTES")]
1512 Minutes,
1513 #[serde(rename = "HOURS")]
1514 #[strum(serialize = "HOURS")]
1515 Hours,
1516 #[serde(rename = "DAYS")]
1517 #[strum(serialize = "DAYS")]
1518 Days,
1519 #[serde(rename = "WEEKS")]
1520 #[strum(serialize = "WEEKS")]
1521 Weeks,
1522 #[serde(rename = "MONTHS")]
1523 #[strum(serialize = "MONTHS")]
1524 Months,
1525 #[serde(rename = "YEARS")]
1526 #[strum(serialize = "YEARS")]
1527 Years,
1528 /// This variant handles values not known at compile time.
1529 #[serde(untagged)]
1530 #[strum(serialize = "__OTHER__")]
1531 Other_(String),
1532}
1533/// The *PbmComplianceStatus_enum*
1534/// enumeration type defines the set of status values
1535/// for compliance operations.
1536///
1537/// See *PbmComplianceResult* and
1538/// *PbmRollupComplianceResult*.
1539///
1540/// Possible values:
1541/// - `compliant`: Entity is in compliance.
1542/// - `nonCompliant`: Entity is out of compliance.
1543/// - `unknown`: Compliance status of the entity is not known.
1544/// - `notApplicable`: Compliance computation is not applicable for this entity,
1545/// because it does not have any storage requirements that
1546/// apply to the object-based datastore on which this entity is placed.
1547/// - `outOfDate`: This is the same as *PbmComplianceResult.mismatch*
1548/// variable.
1549///
1550/// Compliance status becomes out-of-date when the profile
1551/// associated with the entity is edited and not applied. The compliance
1552/// status will remain in out-of-date compliance status until the latest
1553/// policy is applied to the entity.
1554#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1555pub enum PbmComplianceStatusEnum {
1556 #[serde(rename = "compliant")]
1557 #[strum(serialize = "compliant")]
1558 Compliant,
1559 #[serde(rename = "nonCompliant")]
1560 #[strum(serialize = "nonCompliant")]
1561 NonCompliant,
1562 #[serde(rename = "unknown")]
1563 #[strum(serialize = "unknown")]
1564 Unknown,
1565 #[serde(rename = "notApplicable")]
1566 #[strum(serialize = "notApplicable")]
1567 NotApplicable,
1568 #[serde(rename = "outOfDate")]
1569 #[strum(serialize = "outOfDate")]
1570 OutOfDate,
1571 /// This variant handles values not known at compile time.
1572 #[serde(untagged)]
1573 #[strum(serialize = "__OTHER__")]
1574 Other_(String),
1575}
1576/// The *PbmComplianceResultComplianceTaskStatus_enum*
1577/// enumeration type defines the set of task status for compliance
1578/// operations.
1579///
1580/// See *PbmComplianceResult* and
1581/// *PbmRollupComplianceResult*.
1582///
1583/// Possible values:
1584/// - `inProgress`: Compliance calculation is in progress.
1585/// - `success`: Compliance calculation has succeeded.
1586/// - `failed`: Compliance calculation failed due to some exception.
1587#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1588pub enum PbmComplianceResultComplianceTaskStatusEnum {
1589 #[serde(rename = "inProgress")]
1590 #[strum(serialize = "inProgress")]
1591 InProgress,
1592 #[serde(rename = "success")]
1593 #[strum(serialize = "success")]
1594 Success,
1595 #[serde(rename = "failed")]
1596 #[strum(serialize = "failed")]
1597 Failed,
1598 /// This variant handles values not known at compile time.
1599 #[serde(untagged)]
1600 #[strum(serialize = "__OTHER__")]
1601 Other_(String),
1602}
1603/// The enumeration type defines the set of health status values for an entity
1604/// that is part of entity health operation.
1605///
1606/// Possible values:
1607/// - `red`: For file share: 'red' if the file server for this file share is in error
1608/// state or any of its backing vSAN objects are degraded.
1609///
1610/// For FCD: 'red' if the datastore on which the FCD resides is not
1611/// accessible from any of the hosts it is mounted.
1612/// - `yellow`: For file share: 'yellow' if some backing objects are repairing, i.e.
1613///
1614/// warning state.
1615/// For FCD: 'yellow' if the datastore on which the entity resides is
1616/// accessible only from some of the hosts it is mounted but not all.
1617/// - `green`: For file share: 'green' if the file server for this file share is
1618/// running properly and all its backing vSAN objects are healthy.
1619///
1620/// For FCD: 'green' if the datastore on which the entity resides
1621/// is accessible from all the hosts it is mounted.
1622/// - `unknown`: If the health status of a file share is unknown, not valid for FCD.
1623#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1624pub enum PbmHealthStatusForEntityEnum {
1625 #[serde(rename = "red")]
1626 #[strum(serialize = "red")]
1627 Red,
1628 #[serde(rename = "yellow")]
1629 #[strum(serialize = "yellow")]
1630 Yellow,
1631 #[serde(rename = "green")]
1632 #[strum(serialize = "green")]
1633 Green,
1634 #[serde(rename = "unknown")]
1635 #[strum(serialize = "unknown")]
1636 Unknown,
1637 /// This variant handles values not known at compile time.
1638 #[serde(untagged)]
1639 #[strum(serialize = "__OTHER__")]
1640 Other_(String),
1641}
1642/// Possible values:
1643/// - `success`: Policy applied successfully.
1644/// - `failed`: Policy cannot be applied
1645/// - `invalid`: Policy cannot be applied
1646#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1647pub enum PbmAssociateAndApplyPolicyStatusPolicyStatusEnum {
1648 #[serde(rename = "success")]
1649 #[strum(serialize = "success")]
1650 Success,
1651 #[serde(rename = "failed")]
1652 #[strum(serialize = "failed")]
1653 Failed,
1654 #[serde(rename = "invalid")]
1655 #[strum(serialize = "invalid")]
1656 Invalid,
1657 /// This variant handles values not known at compile time.
1658 #[serde(untagged)]
1659 #[strum(serialize = "__OTHER__")]
1660 Other_(String),
1661}
1662/// The *PbmProfileCategoryEnum_enum*
1663/// enumerated type defines the profile categories for a capability-based
1664/// storage profile.
1665///
1666/// See
1667/// *PbmCapabilityProfile*.
1668///
1669/// Possible values:
1670/// - `REQUIREMENT`: Indicates a storage requirement.
1671///
1672/// Requirements are based on
1673/// storage capabilities.
1674/// - `RESOURCE`: Indicates a storage capability.
1675///
1676/// Storage capabilities
1677/// are defined by storage providers.
1678/// - `DATA_SERVICE_POLICY`: Indicates a data service policy that can be embedded into
1679/// another storage policy.
1680///
1681/// Policies of this type can't be assigned to
1682/// Virtual Machines or Virtual Disks.
1683#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1684pub enum PbmProfileCategoryEnumEnum {
1685 #[serde(rename = "REQUIREMENT")]
1686 #[strum(serialize = "REQUIREMENT")]
1687 Requirement,
1688 #[serde(rename = "RESOURCE")]
1689 #[strum(serialize = "RESOURCE")]
1690 Resource,
1691 #[serde(rename = "DATA_SERVICE_POLICY")]
1692 #[strum(serialize = "DATA_SERVICE_POLICY")]
1693 DataServicePolicy,
1694 /// This variant handles values not known at compile time.
1695 #[serde(untagged)]
1696 #[strum(serialize = "__OTHER__")]
1697 Other_(String),
1698}
1699/// System pre-created profile types.
1700///
1701/// Possible values:
1702/// - `VsanDefaultProfile`: Indicates the system pre-created editable VSAN default profile.
1703/// - `VVolDefaultProfile`: Indicates the system pre-created non-editable default profile
1704/// for VVOL datastores.
1705/// - `PmemDefaultProfile`:
1706///
1707/// Deprecated as of vSphere 9.0 APIs with no replacement.
1708///
1709/// Indicates the system pre-created non-editable default profile
1710/// for PMem datastores
1711/// - `VmcManagementProfile`: Indicates the system pre-created non-editable VMC default profile.
1712/// - `VsanMaxDefaultProfile`: Indicates the system pre-created non-editable VSANMAX default profile.
1713#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1714pub enum PbmSystemCreatedProfileTypeEnum {
1715 VsanDefaultProfile,
1716 VVolDefaultProfile,
1717 PmemDefaultProfile,
1718 VmcManagementProfile,
1719 VsanMaxDefaultProfile,
1720 /// This variant handles values not known at compile time.
1721 #[serde(untagged)]
1722 #[strum(serialize = "__OTHER__")]
1723 Other_(String),
1724}
1725/// The *PbmOperation_enum* enumerated type
1726/// defines the provisioning operation being performed on the entity like FCD, virtual machine.
1727///
1728/// Possible values:
1729/// - `CREATE`: Indicates create operation of an entity.
1730/// - `REGISTER`: Indicates register operation of an entity.
1731/// - `RECONFIGURE`: Indicates reconfigure operation of an entity.
1732/// - `MIGRATE`: Indicates migrate operation of an entity.
1733/// - `CLONE`: Indicates clone operation of an entity.
1734#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1735pub enum PbmOperationEnum {
1736 #[serde(rename = "CREATE")]
1737 #[strum(serialize = "CREATE")]
1738 Create,
1739 #[serde(rename = "REGISTER")]
1740 #[strum(serialize = "REGISTER")]
1741 Register,
1742 #[serde(rename = "RECONFIGURE")]
1743 #[strum(serialize = "RECONFIGURE")]
1744 Reconfigure,
1745 #[serde(rename = "MIGRATE")]
1746 #[strum(serialize = "MIGRATE")]
1747 Migrate,
1748 #[serde(rename = "CLONE")]
1749 #[strum(serialize = "CLONE")]
1750 Clone,
1751 /// This variant handles values not known at compile time.
1752 #[serde(untagged)]
1753 #[strum(serialize = "__OTHER__")]
1754 Other_(String),
1755}
1756/// Recognized types of an IO Filter.
1757///
1758/// String constant used in `IofilterInfo#filterType`.
1759/// These should match(upper case) the IO Filter classes as defined by IO Filter framework.
1760/// See https://opengrok.eng.vmware.com/source/xref/vmcore-main.perforce.1666/bora/scons/apps/esx/iofilterApps.sc#33
1761///
1762/// Possible values:
1763/// - `INSPECTION`
1764/// - `COMPRESSION`
1765/// - `ENCRYPTION`
1766/// - `REPLICATION`
1767/// - `CACHE`
1768/// - `DATAPROVIDER`
1769/// - `DATASTOREIOCONTROL`
1770#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1771pub enum PbmIofilterInfoFilterTypeEnum {
1772 #[serde(rename = "INSPECTION")]
1773 #[strum(serialize = "INSPECTION")]
1774 Inspection,
1775 #[serde(rename = "COMPRESSION")]
1776 #[strum(serialize = "COMPRESSION")]
1777 Compression,
1778 #[serde(rename = "ENCRYPTION")]
1779 #[strum(serialize = "ENCRYPTION")]
1780 Encryption,
1781 #[serde(rename = "REPLICATION")]
1782 #[strum(serialize = "REPLICATION")]
1783 Replication,
1784 #[serde(rename = "CACHE")]
1785 #[strum(serialize = "CACHE")]
1786 Cache,
1787 #[serde(rename = "DATAPROVIDER")]
1788 #[strum(serialize = "DATAPROVIDER")]
1789 Dataprovider,
1790 #[serde(rename = "DATASTOREIOCONTROL")]
1791 #[strum(serialize = "DATASTOREIOCONTROL")]
1792 Datastoreiocontrol,
1793 /// This variant handles values not known at compile time.
1794 #[serde(untagged)]
1795 #[strum(serialize = "__OTHER__")]
1796 Other_(String),
1797}
1798/// Volume allocation type constants.
1799///
1800/// Possible values:
1801/// - `FullyInitialized`: Space required is fully allocated and initialized.
1802///
1803/// It is wiped clean of any previous content on the
1804/// physical media. Gives faster runtime IO performance.
1805/// - `ReserveSpace`: Space required is fully allocated.
1806///
1807/// It may contain
1808/// stale data on the physical media.
1809/// - `ConserveSpaceWhenPossible`: Space required is allocated and zeroed on demand
1810/// as the space is used.
1811#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1812pub enum PbmPolicyAssociationVolumeAllocationTypeEnum {
1813 FullyInitialized,
1814 ReserveSpace,
1815 ConserveSpaceWhenPossible,
1816 /// This variant handles values not known at compile time.
1817 #[serde(untagged)]
1818 #[strum(serialize = "__OTHER__")]
1819 Other_(String),
1820}
1821/// The *PbmProfileResourceTypeEnum_enum* enumerated type defines the set of resource
1822/// types that are supported for profile management.
1823///
1824/// See *PbmProfileResourceType*.
1825///
1826/// Possible values:
1827/// - `STORAGE`: Indicates resources that support storage profiles.
1828#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1829pub enum PbmProfileResourceTypeEnumEnum {
1830 #[serde(rename = "STORAGE")]
1831 #[strum(serialize = "STORAGE")]
1832 Storage,
1833 /// This variant handles values not known at compile time.
1834 #[serde(untagged)]
1835 #[strum(serialize = "__OTHER__")]
1836 Other_(String),
1837}
1838/// The *PbmVmOperation_enum* enumerated type
1839/// defines the provisioning operation being performed on the virtual machine.
1840///
1841/// Possible values:
1842/// - `CREATE`: Indicates create operation of a virtual machine.
1843/// - `RECONFIGURE`: Indicates reconfigure operation of a virtual machine.
1844/// - `MIGRATE`: Indicates migrate operation of a virtual machine.
1845/// - `CLONE`: Indicates clone operation of a virtual machine.
1846#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1847pub enum PbmVmOperationEnum {
1848 #[serde(rename = "CREATE")]
1849 #[strum(serialize = "CREATE")]
1850 Create,
1851 #[serde(rename = "RECONFIGURE")]
1852 #[strum(serialize = "RECONFIGURE")]
1853 Reconfigure,
1854 #[serde(rename = "MIGRATE")]
1855 #[strum(serialize = "MIGRATE")]
1856 Migrate,
1857 #[serde(rename = "CLONE")]
1858 #[strum(serialize = "CLONE")]
1859 Clone,
1860 /// This variant handles values not known at compile time.
1861 #[serde(untagged)]
1862 #[strum(serialize = "__OTHER__")]
1863 Other_(String),
1864}
1865/// Types of entities supported by the service.
1866///
1867/// Possible values:
1868/// - `datacenter`
1869/// - `resourcePool`
1870/// - `storagePod`
1871/// - `cluster`
1872/// - `vm`
1873/// - `datastore`
1874/// - `host`
1875/// - `vmFile`
1876/// - `scsiPath`
1877/// - `scsiTarget`
1878/// - `scsiVolume`
1879/// - `scsiAdapter`
1880/// - `nasMount`
1881#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1882pub enum EntityReferenceEntityTypeEnum {
1883 #[serde(rename = "datacenter")]
1884 #[strum(serialize = "datacenter")]
1885 Datacenter,
1886 #[serde(rename = "resourcePool")]
1887 #[strum(serialize = "resourcePool")]
1888 ResourcePool,
1889 #[serde(rename = "storagePod")]
1890 #[strum(serialize = "storagePod")]
1891 StoragePod,
1892 #[serde(rename = "cluster")]
1893 #[strum(serialize = "cluster")]
1894 Cluster,
1895 #[serde(rename = "vm")]
1896 #[strum(serialize = "vm")]
1897 Vm,
1898 #[serde(rename = "datastore")]
1899 #[strum(serialize = "datastore")]
1900 Datastore,
1901 #[serde(rename = "host")]
1902 #[strum(serialize = "host")]
1903 Host,
1904 #[serde(rename = "vmFile")]
1905 #[strum(serialize = "vmFile")]
1906 VmFile,
1907 #[serde(rename = "scsiPath")]
1908 #[strum(serialize = "scsiPath")]
1909 ScsiPath,
1910 #[serde(rename = "scsiTarget")]
1911 #[strum(serialize = "scsiTarget")]
1912 ScsiTarget,
1913 #[serde(rename = "scsiVolume")]
1914 #[strum(serialize = "scsiVolume")]
1915 ScsiVolume,
1916 #[serde(rename = "scsiAdapter")]
1917 #[strum(serialize = "scsiAdapter")]
1918 ScsiAdapter,
1919 #[serde(rename = "nasMount")]
1920 #[strum(serialize = "nasMount")]
1921 NasMount,
1922 /// This variant handles values not known at compile time.
1923 #[serde(untagged)]
1924 #[strum(serialize = "__OTHER__")]
1925 Other_(String),
1926}
1927/// List of possible states of a task.
1928///
1929/// Possible values:
1930/// - `queued`: Task is put in the queue.
1931/// - `running`: Task is currently running.
1932/// - `success`: Task has completed.
1933/// - `error`: Task has encountered an error or has been canceled.
1934#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1935pub enum SmsTaskStateEnum {
1936 #[serde(rename = "queued")]
1937 #[strum(serialize = "queued")]
1938 Queued,
1939 #[serde(rename = "running")]
1940 #[strum(serialize = "running")]
1941 Running,
1942 #[serde(rename = "success")]
1943 #[strum(serialize = "success")]
1944 Success,
1945 #[serde(rename = "error")]
1946 #[strum(serialize = "error")]
1947 Error,
1948 /// This variant handles values not known at compile time.
1949 #[serde(untagged)]
1950 #[strum(serialize = "__OTHER__")]
1951 Other_(String),
1952}
1953/// A Category to indicate whether provider is of internal or external category.
1954///
1955/// This classification can help selectively enable few administrative functions
1956/// such as say unregistration of a provider.
1957///
1958/// Possible values:
1959/// - `internal`: An internal provider category indicates the set of providers such as IOFILTERS and VSAN.
1960/// - `external`: An external provider category indicates the set of providers are external and not belong
1961/// to say either of IOFILTERS or VSAN category.
1962#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1963pub enum VpCategoryEnum {
1964 #[serde(rename = "internal")]
1965 #[strum(serialize = "internal")]
1966 Internal,
1967 #[serde(rename = "external")]
1968 #[strum(serialize = "external")]
1969 External,
1970 /// This variant handles values not known at compile time.
1971 #[serde(untagged)]
1972 #[strum(serialize = "__OTHER__")]
1973 Other_(String),
1974}
1975/// The status of the provider certificate
1976///
1977/// Possible values:
1978/// - `valid`: Provider certificate is valid.
1979/// - `expirySoftLimitReached`: Provider certificate is within the soft limit threshold.
1980/// - `expiryHardLimitReached`: Provider certificate is within the hard limit threshold.
1981/// - `expired`: Provider certificate has expired.
1982/// - `invalid`: Provider certificate is revoked, malformed or missing.
1983#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
1984pub enum VasaProviderCertificateStatusEnum {
1985 #[serde(rename = "valid")]
1986 #[strum(serialize = "valid")]
1987 Valid,
1988 #[serde(rename = "expirySoftLimitReached")]
1989 #[strum(serialize = "expirySoftLimitReached")]
1990 ExpirySoftLimitReached,
1991 #[serde(rename = "expiryHardLimitReached")]
1992 #[strum(serialize = "expiryHardLimitReached")]
1993 ExpiryHardLimitReached,
1994 #[serde(rename = "expired")]
1995 #[strum(serialize = "expired")]
1996 Expired,
1997 #[serde(rename = "invalid")]
1998 #[strum(serialize = "invalid")]
1999 Invalid,
2000 /// This variant handles values not known at compile time.
2001 #[serde(untagged)]
2002 #[strum(serialize = "__OTHER__")]
2003 Other_(String),
2004}
2005/// Profiles supported by VASA Provider.
2006///
2007/// Possible values:
2008/// - `ProfileBasedManagement`: PBM profile
2009/// - `Replication`: Replication profile
2010#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2011pub enum ProviderProfileEnum {
2012 ProfileBasedManagement,
2013 Replication,
2014 /// This variant handles values not known at compile time.
2015 #[serde(untagged)]
2016 #[strum(serialize = "__OTHER__")]
2017 Other_(String),
2018}
2019/// VASA Provider type.
2020///
2021/// Possible values:
2022/// - `PERSISTENCE`: Persistence provider.
2023/// - `DATASERVICE`: DataService provider.
2024///
2025/// No storage supported for this type of provider.
2026/// - `UNKNOWN`: Type is unknown.
2027///
2028/// VASA provider type can be UNKNOWN when it is undergoing sync operation.
2029#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2030pub enum VpTypeEnum {
2031 #[serde(rename = "PERSISTENCE")]
2032 #[strum(serialize = "PERSISTENCE")]
2033 Persistence,
2034 #[serde(rename = "DATASERVICE")]
2035 #[strum(serialize = "DATASERVICE")]
2036 Dataservice,
2037 #[serde(rename = "UNKNOWN")]
2038 #[strum(serialize = "UNKNOWN")]
2039 Unknown,
2040 /// This variant handles values not known at compile time.
2041 #[serde(untagged)]
2042 #[strum(serialize = "__OTHER__")]
2043 Other_(String),
2044}
2045/// Deprecated as of SMS API 3.0, use *VasaProfile_enum*.
2046///
2047/// Profiles supported by VASA Provider.
2048///
2049/// Possible values:
2050/// - `blockDevice`: Block device profile
2051/// - `fileSystem`: File system profile
2052/// - `capability`: Storage capability profile
2053#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2054pub enum VasaProviderProfileEnum {
2055 #[serde(rename = "blockDevice")]
2056 #[strum(serialize = "blockDevice")]
2057 BlockDevice,
2058 #[serde(rename = "fileSystem")]
2059 #[strum(serialize = "fileSystem")]
2060 FileSystem,
2061 #[serde(rename = "capability")]
2062 #[strum(serialize = "capability")]
2063 Capability,
2064 /// This variant handles values not known at compile time.
2065 #[serde(untagged)]
2066 #[strum(serialize = "__OTHER__")]
2067 Other_(String),
2068}
2069/// The operational state of VASA Provider.
2070///
2071/// Possible values:
2072/// - `online`: VASA Provider is operating correctly.
2073/// - `offline`: VASA Provider is not responding, e.g.
2074///
2075/// communication error due to temporary
2076/// network outage. SMS keeps polling the provider in this state.
2077/// - `syncError`: VASA Provider is connected, but sync operation failed.
2078/// - `unknown`:
2079///
2080/// Deprecated as of SMS API 4.0, this status is deprecated.
2081///
2082/// VASA Provider is unreachable.
2083/// - `connected`: VASA Provider is connected, but has not triggered sync operation.
2084/// - `disconnected`: VASA Provider is disconnected, e.g.
2085///
2086/// failed to establish a valid
2087/// SSL connection to the provider. SMS stops communication with the
2088/// provider in this state. The user can reconnect to the provider by invoking
2089/// *VasaProvider.VasaProviderReconnect_Task*.
2090#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2091pub enum VasaProviderStatusEnum {
2092 #[serde(rename = "online")]
2093 #[strum(serialize = "online")]
2094 Online,
2095 #[serde(rename = "offline")]
2096 #[strum(serialize = "offline")]
2097 Offline,
2098 #[serde(rename = "syncError")]
2099 #[strum(serialize = "syncError")]
2100 SyncError,
2101 #[serde(rename = "unknown")]
2102 #[strum(serialize = "unknown")]
2103 Unknown,
2104 #[serde(rename = "connected")]
2105 #[strum(serialize = "connected")]
2106 Connected,
2107 #[serde(rename = "disconnected")]
2108 #[strum(serialize = "disconnected")]
2109 Disconnected,
2110 /// This variant handles values not known at compile time.
2111 #[serde(untagged)]
2112 #[strum(serialize = "__OTHER__")]
2113 Other_(String),
2114}
2115/// VASA provider authentication type.
2116///
2117/// Possible values:
2118/// - `LoginByToken`: Login using SAML token.
2119/// - `UseSessionId`: Use id of an existing session that has logged-in from somewhere else.
2120#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2121pub enum VasaAuthenticationTypeEnum {
2122 LoginByToken,
2123 UseSessionId,
2124 /// This variant handles values not known at compile time.
2125 #[serde(untagged)]
2126 #[strum(serialize = "__OTHER__")]
2127 Other_(String),
2128}
2129/// Enumeration of the supported Alarm Status values
2130///
2131/// Possible values:
2132/// - `Red`
2133/// - `Green`
2134/// - `Yellow`
2135#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2136pub enum SmsAlarmStatusEnum {
2137 Red,
2138 Green,
2139 Yellow,
2140 /// This variant handles values not known at compile time.
2141 #[serde(untagged)]
2142 #[strum(serialize = "__OTHER__")]
2143 Other_(String),
2144}
2145/// Possible values:
2146/// - `SpaceCapacityAlarm`
2147/// - `CapabilityAlarm`
2148/// - `StorageObjectAlarm`
2149/// - `ObjectAlarm`
2150/// - `ComplianceAlarm`
2151/// - `ManageabilityAlarm`
2152/// - `ReplicationAlarm`
2153/// - `CertificateAlarm`
2154#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2155pub enum AlarmTypeEnum {
2156 SpaceCapacityAlarm,
2157 CapabilityAlarm,
2158 StorageObjectAlarm,
2159 ObjectAlarm,
2160 ComplianceAlarm,
2161 ManageabilityAlarm,
2162 ReplicationAlarm,
2163 CertificateAlarm,
2164 /// This variant handles values not known at compile time.
2165 #[serde(untagged)]
2166 #[strum(serialize = "__OTHER__")]
2167 Other_(String),
2168}
2169/// List of possible BackingStoragePool types
2170///
2171/// Possible values:
2172/// - `thinProvisioningPool`
2173/// - `deduplicationPool`
2174/// - `thinAndDeduplicationCombinedPool`
2175#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2176pub enum BackingStoragePoolTypeEnum {
2177 #[serde(rename = "thinProvisioningPool")]
2178 #[strum(serialize = "thinProvisioningPool")]
2179 ThinProvisioningPool,
2180 #[serde(rename = "deduplicationPool")]
2181 #[strum(serialize = "deduplicationPool")]
2182 DeduplicationPool,
2183 #[serde(rename = "thinAndDeduplicationCombinedPool")]
2184 #[strum(serialize = "thinAndDeduplicationCombinedPool")]
2185 ThinAndDeduplicationCombinedPool,
2186 /// This variant handles values not known at compile time.
2187 #[serde(untagged)]
2188 #[strum(serialize = "__OTHER__")]
2189 Other_(String),
2190}
2191/// Enumeration of the supported Entity Type values.
2192///
2193/// Possible values:
2194/// - `StorageArrayEntity`
2195/// - `StorageProcessorEntity`
2196/// - `StoragePortEntity`
2197/// - `StorageLunEntity`
2198/// - `StorageFileSystemEntity`
2199/// - `StorageCapabilityEntity`
2200/// - `CapabilitySchemaEntity`
2201/// - `CapabilityProfileEntity`
2202/// - `DefaultProfileEntity`
2203/// - `ResourceAssociationEntity`
2204/// - `StorageContainerEntity`
2205/// - `StorageObjectEntity`
2206/// - `MessageCatalogEntity`
2207/// - `ProtocolEndpointEntity`
2208/// - `VirtualVolumeInfoEntity`
2209/// - `BackingStoragePoolEntity`
2210/// - `FaultDomainEntity`
2211/// - `ReplicationGroupEntity`
2212#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2213pub enum SmsEntityTypeEnum {
2214 StorageArrayEntity,
2215 StorageProcessorEntity,
2216 StoragePortEntity,
2217 StorageLunEntity,
2218 StorageFileSystemEntity,
2219 StorageCapabilityEntity,
2220 CapabilitySchemaEntity,
2221 CapabilityProfileEntity,
2222 DefaultProfileEntity,
2223 ResourceAssociationEntity,
2224 StorageContainerEntity,
2225 StorageObjectEntity,
2226 MessageCatalogEntity,
2227 ProtocolEndpointEntity,
2228 VirtualVolumeInfoEntity,
2229 BackingStoragePoolEntity,
2230 FaultDomainEntity,
2231 ReplicationGroupEntity,
2232 /// This variant handles values not known at compile time.
2233 #[serde(untagged)]
2234 #[strum(serialize = "__OTHER__")]
2235 Other_(String),
2236}
2237/// List of possible block device interfaces
2238///
2239/// Possible values:
2240/// - `fc`
2241/// - `iscsi`
2242/// - `fcoe`
2243/// - `otherBlock`
2244#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2245pub enum BlockDeviceInterfaceEnum {
2246 #[serde(rename = "fc")]
2247 #[strum(serialize = "fc")]
2248 Fc,
2249 #[serde(rename = "iscsi")]
2250 #[strum(serialize = "iscsi")]
2251 Iscsi,
2252 #[serde(rename = "fcoe")]
2253 #[strum(serialize = "fcoe")]
2254 Fcoe,
2255 #[serde(rename = "otherBlock")]
2256 #[strum(serialize = "otherBlock")]
2257 OtherBlock,
2258 /// This variant handles values not known at compile time.
2259 #[serde(untagged)]
2260 #[strum(serialize = "__OTHER__")]
2261 Other_(String),
2262}
2263/// List of possible file system interfaces
2264///
2265/// Possible values:
2266/// - `nfs`
2267/// - `otherFileSystem`
2268#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2269pub enum FileSystemInterfaceEnum {
2270 #[serde(rename = "nfs")]
2271 #[strum(serialize = "nfs")]
2272 Nfs,
2273 #[serde(rename = "otherFileSystem")]
2274 #[strum(serialize = "otherFileSystem")]
2275 OtherFileSystem,
2276 /// This variant handles values not known at compile time.
2277 #[serde(untagged)]
2278 #[strum(serialize = "__OTHER__")]
2279 Other_(String),
2280}
2281/// List of possible VASA profiles supported by Storage Array
2282///
2283/// Possible values:
2284/// - `blockDevice`: Block device profile
2285/// - `fileSystem`: File system profile
2286/// - `capability`: Storage capability profile
2287/// - `policy`: Policy profile
2288/// - `object`: Object based storage profile
2289/// - `statistics`: IO Statistics profile
2290/// - `storageDrsBlockDevice`: Storage DRS specific block device profile
2291/// - `storageDrsFileSystem`: Storage DRS specific file system profile
2292#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2293pub enum VasaProfileEnum {
2294 #[serde(rename = "blockDevice")]
2295 #[strum(serialize = "blockDevice")]
2296 BlockDevice,
2297 #[serde(rename = "fileSystem")]
2298 #[strum(serialize = "fileSystem")]
2299 FileSystem,
2300 #[serde(rename = "capability")]
2301 #[strum(serialize = "capability")]
2302 Capability,
2303 #[serde(rename = "policy")]
2304 #[strum(serialize = "policy")]
2305 Policy,
2306 #[serde(rename = "object")]
2307 #[strum(serialize = "object")]
2308 Object,
2309 #[serde(rename = "statistics")]
2310 #[strum(serialize = "statistics")]
2311 Statistics,
2312 #[serde(rename = "storageDrsBlockDevice")]
2313 #[strum(serialize = "storageDrsBlockDevice")]
2314 StorageDrsBlockDevice,
2315 #[serde(rename = "storageDrsFileSystem")]
2316 #[strum(serialize = "storageDrsFileSystem")]
2317 StorageDrsFileSystem,
2318 /// This variant handles values not known at compile time.
2319 #[serde(untagged)]
2320 #[strum(serialize = "__OTHER__")]
2321 Other_(String),
2322}
2323/// List of supported VVOL Container types
2324///
2325/// Possible values:
2326/// - `NFS`
2327/// - `NFS4x`
2328/// - `SCSI`
2329/// - `NVMe`
2330#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2331pub enum StorageContainerVvolContainerTypeEnumEnum {
2332 #[serde(rename = "NFS")]
2333 #[strum(serialize = "NFS")]
2334 Nfs,
2335 #[serde(rename = "NFS4x")]
2336 #[strum(serialize = "NFS4x")]
2337 Nfs4X,
2338 #[serde(rename = "SCSI")]
2339 #[strum(serialize = "SCSI")]
2340 Scsi,
2341 #[serde(rename = "NVMe")]
2342 #[strum(serialize = "NVMe")]
2343 NvMe,
2344 /// This variant handles values not known at compile time.
2345 #[serde(untagged)]
2346 #[strum(serialize = "__OTHER__")]
2347 Other_(String),
2348}
2349/// Possible values:
2350/// - `NFSV3_0`
2351#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2352pub enum FileSystemInterfaceVersionEnum {
2353 #[serde(rename = "NFSV3_0")]
2354 #[strum(serialize = "NFSV3_0")]
2355 Nfsv30,
2356 /// This variant handles values not known at compile time.
2357 #[serde(untagged)]
2358 #[strum(serialize = "__OTHER__")]
2359 Other_(String),
2360}
2361/// List of possible values for thin provisioning status alarm.
2362///
2363/// Possible values:
2364/// - `RED`
2365/// - `YELLOW`
2366/// - `GREEN`
2367#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2368pub enum ThinProvisioningStatusEnum {
2369 #[serde(rename = "RED")]
2370 #[strum(serialize = "RED")]
2371 Red,
2372 #[serde(rename = "YELLOW")]
2373 #[strum(serialize = "YELLOW")]
2374 Yellow,
2375 #[serde(rename = "GREEN")]
2376 #[strum(serialize = "GREEN")]
2377 Green,
2378 /// This variant handles values not known at compile time.
2379 #[serde(untagged)]
2380 #[strum(serialize = "__OTHER__")]
2381 Other_(String),
2382}
2383/// State of the replication group at the site of the query.
2384///
2385/// A replication group
2386/// may be in different states at the source site and each of the target sites.
2387/// Note that this state does not capture the health of the replication link. If
2388/// necessary, that can be an additional attribute.
2389///
2390/// Possible values:
2391/// - `SOURCE`: Replication Source
2392/// - `TARGET`: Replication target
2393/// - `FAILEDOVER`: The group failed over at this site of the query.
2394///
2395/// It has not yet been made
2396/// as a source of replication.
2397/// - `INTEST`: The group is InTest.
2398///
2399/// The testFailover devices list will be available from
2400/// the *TargetGroupMemberInfo*
2401/// - `REMOTE_FAILEDOVER`: Remote group was failed over, and this site is neither the source nor the
2402/// target.
2403#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2404pub enum ReplicationReplicationStateEnum {
2405 #[serde(rename = "SOURCE")]
2406 #[strum(serialize = "SOURCE")]
2407 Source,
2408 #[serde(rename = "TARGET")]
2409 #[strum(serialize = "TARGET")]
2410 Target,
2411 #[serde(rename = "FAILEDOVER")]
2412 #[strum(serialize = "FAILEDOVER")]
2413 Failedover,
2414 #[serde(rename = "INTEST")]
2415 #[strum(serialize = "INTEST")]
2416 Intest,
2417 #[serde(rename = "REMOTE_FAILEDOVER")]
2418 #[strum(serialize = "REMOTE_FAILEDOVER")]
2419 RemoteFailedover,
2420 /// This variant handles values not known at compile time.
2421 #[serde(untagged)]
2422 #[strum(serialize = "__OTHER__")]
2423 Other_(String),
2424}
2425/// Enum representing result of batch-APis.
2426///
2427/// Possible values:
2428/// - `success`
2429/// - `fail`
2430#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2431pub enum BatchResultResultEnum {
2432 #[serde(rename = "success")]
2433 #[strum(serialize = "success")]
2434 Success,
2435 #[serde(rename = "fail")]
2436 #[strum(serialize = "fail")]
2437 Fail,
2438 /// This variant handles values not known at compile time.
2439 #[serde(untagged)]
2440 #[strum(serialize = "__OTHER__")]
2441 Other_(String),
2442}
2443/// HCIWorkflowState identifies the state of the cluser from the perspective of HCI
2444/// workflow.
2445///
2446/// The workflow begins with in\_progress mode and can transition
2447/// to 'done' or 'invalid', both of which are terminal states.
2448///
2449/// Possible values:
2450/// - `in_progress`: Indicates cluster is getting configured or will be configured.
2451/// - `done`: Indicates cluster configuration is complete.
2452/// - `invalid`: Indicates the workflow was abandoned on the cluster before the
2453/// configuration could complete.
2454#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2455pub enum ClusterComputeResourceHciWorkflowStateEnum {
2456 #[serde(rename = "in_progress")]
2457 #[strum(serialize = "in_progress")]
2458 InProgress,
2459 #[serde(rename = "done")]
2460 #[strum(serialize = "done")]
2461 Done,
2462 #[serde(rename = "invalid")]
2463 #[strum(serialize = "invalid")]
2464 Invalid,
2465 /// This variant handles values not known at compile time.
2466 #[serde(untagged)]
2467 #[strum(serialize = "__OTHER__")]
2468 Other_(String),
2469}
2470/// Deprecated as of vSphere 9.0 with no replacement. In a future release
2471/// of vSphere, the vCLS functionality will be disabled, vCLS
2472/// system VMs will be deleted, and vCLS APIs will be removed.
2473///
2474/// Do not use.
2475///
2476/// Possible values:
2477/// - `healthy`: Indicates vCS health status is normal.
2478/// - `degraded`: Indicates only vCS is unhealthy.
2479/// - `nonhealthy`: Indicates vCS is unhealthy and other cluster services are impacted.
2480///
2481/// ***Since:*** vSphere API Release 7.0.1.1
2482#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2483pub enum ClusterComputeResourceVcsHealthStatusEnum {
2484 #[serde(rename = "healthy")]
2485 #[strum(serialize = "healthy")]
2486 Healthy,
2487 #[serde(rename = "degraded")]
2488 #[strum(serialize = "degraded")]
2489 Degraded,
2490 #[serde(rename = "nonhealthy")]
2491 #[strum(serialize = "nonhealthy")]
2492 Nonhealthy,
2493 /// This variant handles values not known at compile time.
2494 #[serde(untagged)]
2495 #[strum(serialize = "__OTHER__")]
2496 Other_(String),
2497}
2498/// The SPBM(Storage Policy Based Management) license state for a host
2499///
2500/// Possible values:
2501/// - `licensed`: The host is licensed
2502/// - `unlicensed`: The host is not licensed
2503/// - `unknown`: The host license information is unknown, this could happen if the
2504/// host is not in a available state
2505#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2506pub enum ComputeResourceHostSpbmLicenseInfoHostSpbmLicenseStateEnum {
2507 #[serde(rename = "licensed")]
2508 #[strum(serialize = "licensed")]
2509 Licensed,
2510 #[serde(rename = "unlicensed")]
2511 #[strum(serialize = "unlicensed")]
2512 Unlicensed,
2513 #[serde(rename = "unknown")]
2514 #[strum(serialize = "unknown")]
2515 Unknown,
2516 /// This variant handles values not known at compile time.
2517 #[serde(untagged)]
2518 #[strum(serialize = "__OTHER__")]
2519 Other_(String),
2520}
2521/// Possible values:
2522/// - `bootstrap`
2523/// - `stateless`
2524///
2525/// ***Since:*** vSphere API Release 9.0.0.0
2526#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2527pub enum ComputeResourceNetworkBootModeEnum {
2528 #[serde(rename = "bootstrap")]
2529 #[strum(serialize = "bootstrap")]
2530 Bootstrap,
2531 #[serde(rename = "stateless")]
2532 #[strum(serialize = "stateless")]
2533 Stateless,
2534 /// This variant handles values not known at compile time.
2535 #[serde(untagged)]
2536 #[strum(serialize = "__OTHER__")]
2537 Other_(String),
2538}
2539/// Config spec operation type.
2540///
2541/// Possible values:
2542/// - `add`: Indicates the addition of an element to the configuration.
2543/// - `edit`: Indicates the change of an element in the configuration.
2544/// - `remove`: Indicates the removal of an element in the configuration.
2545#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2546pub enum ConfigSpecOperationEnum {
2547 #[serde(rename = "add")]
2548 #[strum(serialize = "add")]
2549 Add,
2550 #[serde(rename = "edit")]
2551 #[strum(serialize = "edit")]
2552 Edit,
2553 #[serde(rename = "remove")]
2554 #[strum(serialize = "remove")]
2555 Remove,
2556 /// This variant handles values not known at compile time.
2557 #[serde(untagged)]
2558 #[strum(serialize = "__OTHER__")]
2559 Other_(String),
2560}
2561/// Possible values:
2562/// - `True`: Is accessible
2563/// - `False`: Is not accessible
2564#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2565pub enum DatastoreAccessibleEnum {
2566 True,
2567 False,
2568 /// This variant handles values not known at compile time.
2569 #[serde(untagged)]
2570 #[strum(serialize = "__OTHER__")]
2571 Other_(String),
2572}
2573/// The type of the sector size, such as, datastore and virtual disk,
2574/// for the 4k native disk/array support.
2575///
2576/// Possible values:
2577/// - `native_512`: 512 native sector size disk.
2578/// - `emulated_512`: 4K sector size disk in 512 emulation mode.
2579/// - `native_4k`: 4K native sector size disk.
2580///
2581/// ***Since:*** vSphere API Release 9.0.0.0
2582#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2583pub enum DatastoreSectorFormatEnum {
2584 #[serde(rename = "native_512")]
2585 #[strum(serialize = "native_512")]
2586 Native512,
2587 #[serde(rename = "emulated_512")]
2588 #[strum(serialize = "emulated_512")]
2589 Emulated512,
2590 #[serde(rename = "native_4k")]
2591 #[strum(serialize = "native_4k")]
2592 Native4K,
2593 /// This variant handles values not known at compile time.
2594 #[serde(untagged)]
2595 #[strum(serialize = "__OTHER__")]
2596 Other_(String),
2597}
2598/// Defines the current maintenance mode state of the datastore.
2599///
2600/// Possible values:
2601/// - `normal`: Default state.
2602/// - `enteringMaintenance`: Started entering maintenance mode, but not finished.
2603///
2604/// This could happen when waiting for user input or for
2605/// long-running vmotions to complete.
2606/// - `inMaintenance`: Successfully entered maintenance mode.
2607#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2608pub enum DatastoreSummaryMaintenanceModeStateEnum {
2609 #[serde(rename = "normal")]
2610 #[strum(serialize = "normal")]
2611 Normal,
2612 #[serde(rename = "enteringMaintenance")]
2613 #[strum(serialize = "enteringMaintenance")]
2614 EnteringMaintenance,
2615 #[serde(rename = "inMaintenance")]
2616 #[strum(serialize = "inMaintenance")]
2617 InMaintenance,
2618 /// This variant handles values not known at compile time.
2619 #[serde(untagged)]
2620 #[strum(serialize = "__OTHER__")]
2621 Other_(String),
2622}
2623/// Pre-defined constants for possible creators of log files.
2624///
2625/// Possible values:
2626/// - `vpxd`: VirtualCenter service
2627/// - `vpxa`: VirtualCenter agent
2628/// - `hostd`: Host agent
2629/// - `serverd`: Host server agent
2630/// - `install`: Installation
2631/// - `vpxClient`: Virtual infrastructure client
2632/// - `recordLog`: System Record Log
2633#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2634pub enum DiagnosticManagerLogCreatorEnum {
2635 #[serde(rename = "vpxd")]
2636 #[strum(serialize = "vpxd")]
2637 Vpxd,
2638 #[serde(rename = "vpxa")]
2639 #[strum(serialize = "vpxa")]
2640 Vpxa,
2641 #[serde(rename = "hostd")]
2642 #[strum(serialize = "hostd")]
2643 Hostd,
2644 #[serde(rename = "serverd")]
2645 #[strum(serialize = "serverd")]
2646 Serverd,
2647 #[serde(rename = "install")]
2648 #[strum(serialize = "install")]
2649 Install,
2650 #[serde(rename = "vpxClient")]
2651 #[strum(serialize = "vpxClient")]
2652 VpxClient,
2653 #[serde(rename = "recordLog")]
2654 #[strum(serialize = "recordLog")]
2655 RecordLog,
2656 /// This variant handles values not known at compile time.
2657 #[serde(untagged)]
2658 #[strum(serialize = "__OTHER__")]
2659 Other_(String),
2660}
2661/// Constants for defined formats.
2662///
2663/// For more information, see the comment for the format property.
2664///
2665/// Possible values:
2666/// - `plain`: A standard ASCII-based line-based log file.
2667#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2668pub enum DiagnosticManagerLogFormatEnum {
2669 #[serde(rename = "plain")]
2670 #[strum(serialize = "plain")]
2671 Plain,
2672 /// This variant handles values not known at compile time.
2673 #[serde(untagged)]
2674 #[strum(serialize = "__OTHER__")]
2675 Other_(String),
2676}
2677/// List of possible host infrastructure traffic classes
2678///
2679/// Possible values:
2680/// - `management`: Management Traffic
2681/// - `faultTolerance`: Fault Tolerance (FT) Traffic
2682/// - `vmotion`: vMotion Traffic
2683/// - `virtualMachine`: Virtual Machine Traffic
2684/// - `iSCSI`: iSCSI Traffic
2685/// - `nfs`: NFS Traffic
2686/// - `hbr`: vSphere Replication (VR) Traffic
2687/// - `vsan`: vSphere Storage Area Network Traffic
2688/// - `vdp`: vSphere Data Protection - Backup Traffic
2689/// - `backupNfc`: vSphere Backup NFC Traffic
2690///
2691/// ***Since:*** vSphere API Release 7.0.1.0
2692/// - `nvmetcp`: vSphere NVMETCP Traffic
2693///
2694/// ***Since:*** vSphere API Release 7.0.3.0
2695/// - `provisioning`: vSphere Provisioning Traffic
2696///
2697/// ***Since:*** vSphere API Release 9.0.0.0
2698#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2699pub enum DistributedVirtualSwitchHostInfrastructureTrafficClassEnum {
2700 #[serde(rename = "management")]
2701 #[strum(serialize = "management")]
2702 Management,
2703 #[serde(rename = "faultTolerance")]
2704 #[strum(serialize = "faultTolerance")]
2705 FaultTolerance,
2706 #[serde(rename = "vmotion")]
2707 #[strum(serialize = "vmotion")]
2708 Vmotion,
2709 #[serde(rename = "virtualMachine")]
2710 #[strum(serialize = "virtualMachine")]
2711 VirtualMachine,
2712 #[serde(rename = "iSCSI")]
2713 #[strum(serialize = "iSCSI")]
2714 IScsi,
2715 #[serde(rename = "nfs")]
2716 #[strum(serialize = "nfs")]
2717 Nfs,
2718 #[serde(rename = "hbr")]
2719 #[strum(serialize = "hbr")]
2720 Hbr,
2721 #[serde(rename = "vsan")]
2722 #[strum(serialize = "vsan")]
2723 Vsan,
2724 #[serde(rename = "vdp")]
2725 #[strum(serialize = "vdp")]
2726 Vdp,
2727 #[serde(rename = "backupNfc")]
2728 #[strum(serialize = "backupNfc")]
2729 BackupNfc,
2730 #[serde(rename = "nvmetcp")]
2731 #[strum(serialize = "nvmetcp")]
2732 Nvmetcp,
2733 #[serde(rename = "provisioning")]
2734 #[strum(serialize = "provisioning")]
2735 Provisioning,
2736 /// This variant handles values not known at compile time.
2737 #[serde(untagged)]
2738 #[strum(serialize = "__OTHER__")]
2739 Other_(String),
2740}
2741/// Network resource control version types.
2742///
2743/// Possible values:
2744/// - `version2`: Network Resource Control API version 2
2745/// - `version3`: Network Resource Control API version 3
2746#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2747pub enum DistributedVirtualSwitchNetworkResourceControlVersionEnum {
2748 #[serde(rename = "version2")]
2749 #[strum(serialize = "version2")]
2750 Version2,
2751 #[serde(rename = "version3")]
2752 #[strum(serialize = "version3")]
2753 Version3,
2754 /// This variant handles values not known at compile time.
2755 #[serde(untagged)]
2756 #[strum(serialize = "__OTHER__")]
2757 Other_(String),
2758}
2759/// List of possible teaming modes supported by the vNetwork Distributed
2760/// Switch.
2761///
2762/// The different policy modes define the way traffic is routed
2763/// through the different uplink ports in a team.
2764///
2765/// Possible values:
2766/// - `loadbalance_ip`: Routing based on IP hash
2767/// - `loadbalance_srcmac`: Route based on source MAC hash
2768/// - `loadbalance_srcid`: Route based on the source of the port ID
2769/// - `failover_explicit`: Use explicit failover order
2770/// - `loadbalance_loadbased`: Routing based by dynamically balancing traffic through the NICs
2771/// in a team.
2772///
2773/// This is the recommended teaming policy when the
2774/// network I/O control feature is enabled for the vNetwork
2775/// Distributed Switch.
2776#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2777pub enum DistributedVirtualSwitchNicTeamingPolicyModeEnum {
2778 #[serde(rename = "loadbalance_ip")]
2779 #[strum(serialize = "loadbalance_ip")]
2780 LoadbalanceIp,
2781 #[serde(rename = "loadbalance_srcmac")]
2782 #[strum(serialize = "loadbalance_srcmac")]
2783 LoadbalanceSrcmac,
2784 #[serde(rename = "loadbalance_srcid")]
2785 #[strum(serialize = "loadbalance_srcid")]
2786 LoadbalanceSrcid,
2787 #[serde(rename = "failover_explicit")]
2788 #[strum(serialize = "failover_explicit")]
2789 FailoverExplicit,
2790 #[serde(rename = "loadbalance_loadbased")]
2791 #[strum(serialize = "loadbalance_loadbased")]
2792 LoadbalanceLoadbased,
2793 /// This variant handles values not known at compile time.
2794 #[serde(untagged)]
2795 #[strum(serialize = "__OTHER__")]
2796 Other_(String),
2797}
2798/// The product spec operation types.
2799///
2800/// Possible values:
2801/// - `preInstall`: Push the switch's host component of the specified product info to the
2802/// host members of the switch at a fixed location known by the host.
2803/// - `upgrade`: Change the switch implementation to use the specified one.
2804///
2805/// If the
2806/// property values in the specified product info are different from
2807/// those of the corresponding properties in the switch's product info,
2808/// a host component preinstall and switch upgrade will be performed.
2809/// - `notifyAvailableUpgrade`: Set the product information for an available switch upgrade that
2810/// would be done by the switch implementation.
2811///
2812/// This operation will post
2813/// a config issue on the switch to signal the availability of an upgrade.
2814/// This operation is applicable only in the case when switch policy
2815/// *DVSPolicy.autoUpgradeAllowed*
2816/// is set to false.
2817/// - `proceedWithUpgrade`: If productSpec is set to be same as that in the
2818/// *DvsUpgradeAvailableEvent* configIssue, the switch
2819/// implementation will proceed with the upgrade.
2820///
2821/// To reject or stop the
2822/// upgrade, leave the productSpec unset. If productSpec is set but does not
2823/// match that in *DvsUpgradeAvailableEvent* configIssue,
2824/// a fault will be raised.
2825/// This operation is applicable only in the case when switch policy
2826/// *DVSPolicy.autoUpgradeAllowed*
2827/// is set to false.
2828/// - `updateBundleInfo`: Update the bundle URL and ID information.
2829///
2830/// If other properties in
2831/// the specified product info differ from the
2832/// corresponding properties of the switch's product info, a fault will
2833/// be thrown. Updating the bundle ID will result in installing the new host
2834/// component identified by the bundle ID.
2835#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2836pub enum DistributedVirtualSwitchProductSpecOperationTypeEnum {
2837 #[serde(rename = "preInstall")]
2838 #[strum(serialize = "preInstall")]
2839 PreInstall,
2840 #[serde(rename = "upgrade")]
2841 #[strum(serialize = "upgrade")]
2842 Upgrade,
2843 #[serde(rename = "notifyAvailableUpgrade")]
2844 #[strum(serialize = "notifyAvailableUpgrade")]
2845 NotifyAvailableUpgrade,
2846 #[serde(rename = "proceedWithUpgrade")]
2847 #[strum(serialize = "proceedWithUpgrade")]
2848 ProceedWithUpgrade,
2849 #[serde(rename = "updateBundleInfo")]
2850 #[strum(serialize = "updateBundleInfo")]
2851 UpdateBundleInfo,
2852 /// This variant handles values not known at compile time.
2853 #[serde(untagged)]
2854 #[strum(serialize = "__OTHER__")]
2855 Other_(String),
2856}
2857/// Correlation state as computed by storageRM
2858/// module on host.
2859///
2860/// Possible values:
2861/// - `Correlated`
2862/// - `Uncorrelated`
2863#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2864pub enum DrsInjectorWorkloadCorrelationStateEnum {
2865 Correlated,
2866 Uncorrelated,
2867 /// This variant handles values not known at compile time.
2868 #[serde(untagged)]
2869 #[strum(serialize = "__OTHER__")]
2870 Other_(String),
2871}
2872/// Possible values:
2873/// - `maintenance`: Add host in maintenance mode.
2874/// - `non_maintenance`: Add host in non-maintenance mode.
2875#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2876pub enum FolderDesiredHostStateEnum {
2877 #[serde(rename = "maintenance")]
2878 #[strum(serialize = "maintenance")]
2879 Maintenance,
2880 #[serde(rename = "non_maintenance")]
2881 #[strum(serialize = "non_maintenance")]
2882 NonMaintenance,
2883 /// This variant handles values not known at compile time.
2884 #[serde(untagged)]
2885 #[strum(serialize = "__OTHER__")]
2886 Other_(String),
2887}
2888/// Supported types of externally managed folder.
2889///
2890/// NSX Virtual Private Clouds(VPCs) is an abstraction layer that simplifies
2891/// setting up self-contained virtual private cloud networks within an NSX
2892/// project to consume networking and security services in a self-service
2893/// consumption model. It contains multiple subnets which represents an
2894/// independent layer 2 broadcast domain.
2895/// vCenter users can manage (create, update, delete) VPC and subnet under
2896/// *VPC_ROOT* folder. Requests are forwarded to NSX, and the VPCs
2897/// and subnets in NSX are realized as *VPC* and *SUBNET* folder
2898/// in vCenter.
2899/// A project in NSX is analogous to a tenant. NSX user can create VPC, segment,
2900/// and subnet within a project. These objects are represented as
2901/// *PROJECT*, *VPC*, *SEGMENT*, and *SUBNET* folder
2902/// under *PROJECT_ROOT* folder.
2903///
2904/// Possible values:
2905/// - `PROJECT_ROOT`: The root folder of *PROJECT* folders.
2906///
2907/// It is a child of the network folder of a data center and
2908/// may contain multiple *PROJECT* folders.
2909/// - `PROJECT`: The folder representing a project in NSX.
2910///
2911/// It is a child of the *PROJECT_ROOT* folder.
2912/// A project folder can contain multiple *VPC*,
2913/// and *SEGMENT* folders.
2914/// - `VPC_ROOT`: The folder containing VPC and subnet that can be managed by vCenter.
2915///
2916/// It is a child of the network folder of a data center.
2917/// It may contain multiple *VPC* folders.
2918/// - `VPC`: The folder representing a VPC in NSX.
2919///
2920/// It is a child of the *VPC_ROOT* folder or the *PROJECT*
2921/// folder.
2922/// It may contain multiple *SUBNET* folders.
2923/// - `SUBNET`: The folder representing a subnet in NSX.
2924///
2925/// It is a child of the *VPC* folder.
2926/// - `SEGMENT`: The folder representing a segment in NSX.
2927///
2928/// It is a child of the *PROJECT* folder.
2929/// - `SUPERVISOR`: The folder representing a vSphere IaaS Control Plane Supervisor.
2930///
2931/// It is a VM\_TYPE folder and child of vSphere Namespaces Root folder.
2932/// It may contain multiple namespace associated folder, i.e., folder with
2933/// *Folder.namespace* property set and vSphere IaaS Control Plane
2934/// Virtual Machines.
2935/// - `VSPHERE_POD`: The folder containing vSphere Pods.
2936///
2937/// It is a child of namespace associated folder, i.e., folder with
2938/// *Folder.namespace* property set and may contain vSphere Pods.
2939///
2940/// ***Since:*** vSphere API Release 9.0.0.0
2941#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2942pub enum FolderExternallyManagedFolderTypeEnum {
2943 #[serde(rename = "PROJECT_ROOT")]
2944 #[strum(serialize = "PROJECT_ROOT")]
2945 ProjectRoot,
2946 #[serde(rename = "PROJECT")]
2947 #[strum(serialize = "PROJECT")]
2948 Project,
2949 #[serde(rename = "VPC_ROOT")]
2950 #[strum(serialize = "VPC_ROOT")]
2951 VpcRoot,
2952 #[serde(rename = "VPC")]
2953 #[strum(serialize = "VPC")]
2954 Vpc,
2955 #[serde(rename = "SUBNET")]
2956 #[strum(serialize = "SUBNET")]
2957 Subnet,
2958 #[serde(rename = "SEGMENT")]
2959 #[strum(serialize = "SEGMENT")]
2960 Segment,
2961 #[serde(rename = "SUPERVISOR")]
2962 #[strum(serialize = "SUPERVISOR")]
2963 Supervisor,
2964 #[serde(rename = "VSPHERE_POD")]
2965 #[strum(serialize = "VSPHERE_POD")]
2966 VspherePod,
2967 /// This variant handles values not known at compile time.
2968 #[serde(untagged)]
2969 #[strum(serialize = "__OTHER__")]
2970 Other_(String),
2971}
2972/// Describes the current state of a replicated *VirtualMachine*
2973///
2974/// Possible values:
2975/// - `none`: The *VirtualMachine* has no current replication state.
2976///
2977/// This is a virtual machine that is configured for replication, but is
2978/// powered off and not undergoing offline replication.
2979/// - `paused`: The *VirtualMachine* replication is paused.
2980/// - `syncing`: One or more of the *VirtualMachine* disks is in the
2981/// process of an initial synchronization with the remote site.
2982/// - `idle`: The *VirtualMachine* is being replicated but is not
2983/// currently in the process of having a consistent instance created.
2984/// - `active`: The *VirtualMachine* is in the process of having
2985/// a consistent instance created.
2986/// - `error`: The *VirtualMachine* is unable to replicate due to
2987/// errors.
2988///
2989/// XXX Currently unused.
2990#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
2991pub enum ReplicationVmStateEnum {
2992 #[serde(rename = "none")]
2993 #[strum(serialize = "none")]
2994 None,
2995 #[serde(rename = "paused")]
2996 #[strum(serialize = "paused")]
2997 Paused,
2998 #[serde(rename = "syncing")]
2999 #[strum(serialize = "syncing")]
3000 Syncing,
3001 #[serde(rename = "idle")]
3002 #[strum(serialize = "idle")]
3003 Idle,
3004 #[serde(rename = "active")]
3005 #[strum(serialize = "active")]
3006 Active,
3007 #[serde(rename = "error")]
3008 #[strum(serialize = "error")]
3009 Error,
3010 /// This variant handles values not known at compile time.
3011 #[serde(untagged)]
3012 #[strum(serialize = "__OTHER__")]
3013 Other_(String),
3014}
3015/// Quiescing is a boolean flag in *ReplicationConfigSpec*
3016/// and QuiesceModeType describes the supported quiesce mode
3017/// for *VirtualMachine*.
3018///
3019/// If application quiescing fails, HBR would attempt
3020/// filesystem quiescing and if even filesystem quiescing
3021/// fails, then we would just create a crash consistent
3022/// instance.
3023///
3024/// Possible values:
3025/// - `application`: HBR supports application quescing for this
3026/// *VirtualMachine*.
3027/// - `filesystem`: HBR supports filesystem quescing for this
3028/// *VirtualMachine*.
3029/// - `none`: HBR does not support quescing for this
3030/// *VirtualMachine*.
3031#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
3032pub enum QuiesceModeEnum {
3033 #[serde(rename = "application")]
3034 #[strum(serialize = "application")]
3035 Application,
3036 #[serde(rename = "filesystem")]
3037 #[strum(serialize = "filesystem")]
3038 Filesystem,
3039 #[serde(rename = "none")]
3040 #[strum(serialize = "none")]
3041 None,
3042 /// This variant handles values not known at compile time.
3043 #[serde(untagged)]
3044 #[strum(serialize = "__OTHER__")]
3045 Other_(String),
3046}
3047/// Possible values:
3048/// - `Memory`
3049/// - `Power`
3050/// - `Fan`
3051/// - `Network`
3052/// - `Storage`
3053#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
3054pub enum HealthUpdateInfoComponentTypeEnum {
3055 Memory,
3056 Power,
3057 Fan,
3058 Network,
3059 Storage,
3060 /// This variant handles values not known at compile time.
3061 #[serde(untagged)]
3062 #[strum(serialize = "__OTHER__")]
3063 Other_(String),
3064}
3065/// Defines a host's connection state.
3066///
3067/// Possible values:
3068/// - `connected`: Connected to the server.
3069///
3070/// For ESX Server, this is always the setting.
3071/// - `notResponding`: VirtualCenter is not receiving heartbeats from the server.
3072///
3073/// The state
3074/// automatically changes to connected once heartbeats are received
3075/// again. This state is typically used to trigger an alarm on the host.
3076/// - `disconnected`: The user has explicitly taken the host down.
3077///
3078/// VirtualCenter does not expect to
3079/// receive heartbeats from the host. The next time a heartbeat is received, the
3080/// host is moved to the connected state again and an event is logged.
3081#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
3082pub enum HostSystemConnectionStateEnum {
3083 #[serde(rename = "connected")]
3084 #[strum(serialize = "connected")]
3085 Connected,
3086 #[serde(rename = "notResponding")]
3087 #[strum(serialize = "notResponding")]
3088 NotResponding,
3089 #[serde(rename = "disconnected")]
3090 #[strum(serialize = "disconnected")]
3091 Disconnected,
3092 /// This variant handles values not known at compile time.
3093 #[serde(untagged)]
3094 #[strum(serialize = "__OTHER__")]
3095 Other_(String),
3096}
3097/// Defines a host's encryption state
3098///
3099/// Possible values:
3100/// - `incapable`: The host is not safe for receiving sensitive material.
3101/// - `prepared`: The host is prepared for receiving sensitive material
3102/// but does not have a host key set yet.
3103/// - `safe`: The host is crypto safe and has a host key set.
3104/// - `pendingIncapable`: The host is explicitly crypto disabled and pending reboot to be
3105/// applied.
3106///
3107/// When host is in this state, creating encrypted virtual
3108/// machines is not allowed, but still need a reboot to totally clean
3109/// up and enter incapable state.
3110#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
3111pub enum HostCryptoStateEnum {
3112 #[serde(rename = "incapable")]
3113 #[strum(serialize = "incapable")]
3114 Incapable,
3115 #[serde(rename = "prepared")]
3116 #[strum(serialize = "prepared")]
3117 Prepared,
3118 #[serde(rename = "safe")]
3119 #[strum(serialize = "safe")]
3120 Safe,
3121 #[serde(rename = "pendingIncapable")]
3122 #[strum(serialize = "pendingIncapable")]
3123 PendingIncapable,
3124 /// This variant handles values not known at compile time.
3125 #[serde(untagged)]
3126 #[strum(serialize = "__OTHER__")]
3127 Other_(String),
3128}
3129/// Defines a host's power state.
3130///
3131/// Possible values:
3132/// - `poweredOn`: The host is powered on.
3133///
3134/// A host that is entering standby mode
3135/// *entering* is also in this state.
3136/// - `poweredOff`: The host was specifically powered off by the user through
3137/// VirtualCenter.
3138///
3139/// This state is not a cetain state, because
3140/// after VirtualCenter issues the command to power off the host,
3141/// the host might crash, or kill all the processes but fail to
3142/// power off.
3143/// - `standBy`: The host was specifically put in standby mode, either
3144/// explicitly by the user, or automatically by DPM.
3145///
3146/// This state
3147/// is not a cetain state, because after VirtualCenter issues the
3148/// command to put the host in standby state, the host might
3149/// crash, or kill all the processes but fail to power off. A host
3150/// that is exiting standby mode *exiting*
3151/// is also in this state.
3152/// - `unknown`: If the host is disconnected, or notResponding, we cannot
3153/// possibly have knowledge of its power state.
3154///
3155/// Hence, the host
3156/// is marked as unknown.
3157#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
3158pub enum HostSystemPowerStateEnum {
3159 #[serde(rename = "poweredOn")]
3160 #[strum(serialize = "poweredOn")]
3161 PoweredOn,
3162 #[serde(rename = "poweredOff")]
3163 #[strum(serialize = "poweredOff")]
3164 PoweredOff,
3165 #[serde(rename = "standBy")]
3166 #[strum(serialize = "standBy")]
3167 StandBy,
3168 #[serde(rename = "unknown")]
3169 #[strum(serialize = "unknown")]
3170 Unknown,
3171 /// This variant handles values not known at compile time.
3172 #[serde(untagged)]
3173 #[strum(serialize = "__OTHER__")]
3174 Other_(String),
3175}
3176/// Valid state for host profile remediation.
3177///
3178/// Possible values:
3179/// - `remediationReady`: Before precheck remediation and remediation.
3180/// - `precheckRemediationRunning`: Preecheck remediation is running.
3181/// - `precheckRemediationComplete`: Preecheck remediation succeeded.
3182/// - `precheckRemediationFailed`: Preecheck remediation failed.
3183/// - `remediationRunning`: Remediation is running.
3184/// - `remediationFailed`: Remediation failed.
3185#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
3186pub enum HostSystemRemediationStateStateEnum {
3187 #[serde(rename = "remediationReady")]
3188 #[strum(serialize = "remediationReady")]
3189 RemediationReady,
3190 #[serde(rename = "precheckRemediationRunning")]
3191 #[strum(serialize = "precheckRemediationRunning")]
3192 PrecheckRemediationRunning,
3193 #[serde(rename = "precheckRemediationComplete")]
3194 #[strum(serialize = "precheckRemediationComplete")]
3195 PrecheckRemediationComplete,
3196 #[serde(rename = "precheckRemediationFailed")]
3197 #[strum(serialize = "precheckRemediationFailed")]
3198 PrecheckRemediationFailed,
3199 #[serde(rename = "remediationRunning")]
3200 #[strum(serialize = "remediationRunning")]
3201 RemediationRunning,
3202 #[serde(rename = "remediationFailed")]
3203 #[strum(serialize = "remediationFailed")]
3204 RemediationFailed,
3205 /// This variant handles values not known at compile time.
3206 #[serde(untagged)]
3207 #[strum(serialize = "__OTHER__")]
3208 Other_(String),
3209}
3210/// Defines a host's standby mode.
3211///
3212/// Possible values:
3213/// - `entering`: The host is entering standby mode.
3214/// - `exiting`: The host is exiting standby mode.
3215/// - `in`: The host is in standby mode.
3216/// - `none`: The host is not in standy mode, and it is not
3217/// in the process of entering/exiting standby mode.
3218#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
3219pub enum HostStandbyModeEnum {
3220 #[serde(rename = "entering")]
3221 #[strum(serialize = "entering")]
3222 Entering,
3223 #[serde(rename = "exiting")]
3224 #[strum(serialize = "exiting")]
3225 Exiting,
3226 #[serde(rename = "in")]
3227 #[strum(serialize = "in")]
3228 In,
3229 #[serde(rename = "none")]
3230 #[strum(serialize = "none")]
3231 None,
3232 /// This variant handles values not known at compile time.
3233 #[serde(untagged)]
3234 #[strum(serialize = "__OTHER__")]
3235 Other_(String),
3236}
3237/// List of supported algorithms for checksum calculation.
3238///
3239/// Possible values:
3240/// - `sha1`
3241/// - `sha256`
3242#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
3243pub enum HttpNfcLeaseManifestEntryChecksumTypeEnum {
3244 #[serde(rename = "sha1")]
3245 #[strum(serialize = "sha1")]
3246 Sha1,
3247 #[serde(rename = "sha256")]
3248 #[strum(serialize = "sha256")]
3249 Sha256,
3250 /// This variant handles values not known at compile time.
3251 #[serde(untagged)]
3252 #[strum(serialize = "__OTHER__")]
3253 Other_(String),
3254}
3255/// List of supported modes by HttpNfcLease
3256///
3257/// Possible values:
3258/// - `pushOrGet`: Client pushes or downloads individual files from/to
3259/// each host/url provided by this lease in *HttpNfcLease.info*
3260/// - `pull`: Mode where hosts itself pull files from source URLs.
3261///
3262/// See *HttpNfcLease.HttpNfcLeasePullFromUrls_Task*
3263#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
3264pub enum HttpNfcLeaseModeEnum {
3265 #[serde(rename = "pushOrGet")]
3266 #[strum(serialize = "pushOrGet")]
3267 PushOrGet,
3268 #[serde(rename = "pull")]
3269 #[strum(serialize = "pull")]
3270 Pull,
3271 /// This variant handles values not known at compile time.
3272 #[serde(untagged)]
3273 #[strum(serialize = "__OTHER__")]
3274 Other_(String),
3275}
3276/// List of possible states of a lease.
3277///
3278/// Possible values:
3279/// - `initializing`: When the lease is being initialized.
3280/// - `ready`: When the lease is ready and disks may be transferred.
3281/// - `done`: When the import/export session is completed, and the lease
3282/// is no longer held.
3283/// - `error`: When an error has occurred.
3284#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
3285pub enum HttpNfcLeaseStateEnum {
3286 #[serde(rename = "initializing")]
3287 #[strum(serialize = "initializing")]
3288 Initializing,
3289 #[serde(rename = "ready")]
3290 #[strum(serialize = "ready")]
3291 Ready,
3292 #[serde(rename = "done")]
3293 #[strum(serialize = "done")]
3294 Done,
3295 #[serde(rename = "error")]
3296 #[strum(serialize = "error")]
3297 Error,
3298 /// This variant handles values not known at compile time.
3299 #[serde(untagged)]
3300 #[strum(serialize = "__OTHER__")]
3301 Other_(String),
3302}
3303/// Defines the type of an IO Filter.
3304///
3305/// Possible values:
3306/// - `cache`: Cache.
3307/// - `replication`: Replication.
3308/// - `encryption`: Encryption.
3309/// - `compression`: Compression.
3310/// - `inspection`: Inspection.
3311/// - `datastoreIoControl`: Datastore I/O Control.
3312/// - `dataProvider`: Data Provider.
3313/// - `dataCapture`: Lightweight Data Capture.
3314///
3315/// ***Since:*** vSphere API Release 7.0.2.1
3316#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
3317pub enum IoFilterTypeEnum {
3318 #[serde(rename = "cache")]
3319 #[strum(serialize = "cache")]
3320 Cache,
3321 #[serde(rename = "replication")]
3322 #[strum(serialize = "replication")]
3323 Replication,
3324 #[serde(rename = "encryption")]
3325 #[strum(serialize = "encryption")]
3326 Encryption,
3327 #[serde(rename = "compression")]
3328 #[strum(serialize = "compression")]
3329 Compression,
3330 #[serde(rename = "inspection")]
3331 #[strum(serialize = "inspection")]
3332 Inspection,
3333 #[serde(rename = "datastoreIoControl")]
3334 #[strum(serialize = "datastoreIoControl")]
3335 DatastoreIoControl,
3336 #[serde(rename = "dataProvider")]
3337 #[strum(serialize = "dataProvider")]
3338 DataProvider,
3339 #[serde(rename = "dataCapture")]
3340 #[strum(serialize = "dataCapture")]
3341 DataCapture,
3342 /// This variant handles values not known at compile time.
3343 #[serde(untagged)]
3344 #[strum(serialize = "__OTHER__")]
3345 Other_(String),
3346}
3347/// Defines the type of operation for an IO Filter.
3348///
3349/// Possible values:
3350/// - `install`: Install an IO Filter.
3351/// - `uninstall`: Uninstall an IO Filter.
3352/// - `upgrade`: Upgrade an IO Filter.
3353#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
3354pub enum IoFilterOperationEnum {
3355 #[serde(rename = "install")]
3356 #[strum(serialize = "install")]
3357 Install,
3358 #[serde(rename = "uninstall")]
3359 #[strum(serialize = "uninstall")]
3360 Uninstall,
3361 #[serde(rename = "upgrade")]
3362 #[strum(serialize = "upgrade")]
3363 Upgrade,
3364 /// This variant handles values not known at compile time.
3365 #[serde(untagged)]
3366 #[strum(serialize = "__OTHER__")]
3367 Other_(String),
3368}
3369/// Enumeration of the nominal latency-sensitive values which can be
3370/// used to specify the latency-sensitivity level of the application.
3371///
3372/// In terms of latency-sensitivity the values relate:
3373/// high>medium>normal>low.
3374///
3375/// Possible values:
3376/// - `low`: The relative latency-sensitivity low value.
3377/// - `normal`: The relative latency-sensitivity normal value.
3378///
3379/// This is the default latency-sensitivity value.
3380/// - `medium`: The relative latency-sensitivity medium value.
3381/// - `high`: The relative latency-sensitivity high value.
3382/// - `custom`:
3383///
3384/// Deprecated as of vSphere API Ver 6.0. Value will be ignored and
3385/// treated as "normal" latency sensitivity.
3386///
3387/// The custom absolute latency-sensitivity specified in
3388/// *LatencySensitivity.sensitivity* property is used to
3389/// define the latency-sensitivity.
3390///
3391/// When this value is set to *LatencySensitivity.level* the
3392/// *LatencySensitivity.sensitivity* property should be
3393/// set also.
3394#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
3395pub enum LatencySensitivitySensitivityLevelEnum {
3396 #[serde(rename = "low")]
3397 #[strum(serialize = "low")]
3398 Low,
3399 #[serde(rename = "normal")]
3400 #[strum(serialize = "normal")]
3401 Normal,
3402 #[serde(rename = "medium")]
3403 #[strum(serialize = "medium")]
3404 Medium,
3405 #[serde(rename = "high")]
3406 #[strum(serialize = "high")]
3407 High,
3408 #[serde(rename = "custom")]
3409 #[strum(serialize = "custom")]
3410 Custom,
3411 /// This variant handles values not known at compile time.
3412 #[serde(untagged)]
3413 #[strum(serialize = "__OTHER__")]
3414 Other_(String),
3415}
3416/// Cost units apply to licenses for the purpose of determining
3417/// how many licenses are needed.
3418///
3419/// Possible values:
3420/// - `host`: One license is acquired per host.
3421/// - `cpuCore`: One license is acquired per CPU core.
3422/// - `cpuPackage`: One license is acquired per CPU package.
3423/// - `server`: One license is acquired per server.
3424/// - `vm`: One license is acquired per virtual machine.
3425#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
3426pub enum LicenseFeatureInfoUnitEnum {
3427 #[serde(rename = "host")]
3428 #[strum(serialize = "host")]
3429 Host,
3430 #[serde(rename = "cpuCore")]
3431 #[strum(serialize = "cpuCore")]
3432 CpuCore,
3433 #[serde(rename = "cpuPackage")]
3434 #[strum(serialize = "cpuPackage")]
3435 CpuPackage,
3436 #[serde(rename = "server")]
3437 #[strum(serialize = "server")]
3438 Server,
3439 #[serde(rename = "vm")]
3440 #[strum(serialize = "vm")]
3441 Vm,
3442 /// This variant handles values not known at compile time.
3443 #[serde(untagged)]
3444 #[strum(serialize = "__OTHER__")]
3445 Other_(String),
3446}
3447/// Some licenses may only be allowed to load from a specified source.
3448///
3449/// This enum indicates what restrictions exist for this license if any.
3450///
3451/// Possible values:
3452/// - `unrestricted`: The feature does not have a source restriction.
3453/// - `served`: The feature's license can only be served.
3454/// - `file`: The feature's license can only come from a file.
3455#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
3456pub enum LicenseFeatureInfoSourceRestrictionEnum {
3457 #[serde(rename = "unrestricted")]
3458 #[strum(serialize = "unrestricted")]
3459 Unrestricted,
3460 #[serde(rename = "served")]
3461 #[strum(serialize = "served")]
3462 Served,
3463 #[serde(rename = "file")]
3464 #[strum(serialize = "file")]
3465 File,
3466 /// This variant handles values not known at compile time.
3467 #[serde(untagged)]
3468 #[strum(serialize = "__OTHER__")]
3469 Other_(String),
3470}
3471/// Describes the state of the feature.
3472///
3473/// Possible values:
3474/// - `enabled`: The current edition license has implicitly enabled this additional feature.
3475/// - `disabled`: The current edition license does not allow this additional feature.
3476/// - `optional`: The current edition license allows this additional feature.
3477///
3478/// The
3479/// *LicenseManager.EnableFeature* and *LicenseManager.DisableFeature* methods can be used to enable or disable
3480/// this feature.
3481#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
3482pub enum LicenseFeatureInfoStateEnum {
3483 #[serde(rename = "enabled")]
3484 #[strum(serialize = "enabled")]
3485 Enabled,
3486 #[serde(rename = "disabled")]
3487 #[strum(serialize = "disabled")]
3488 Disabled,
3489 #[serde(rename = "optional")]
3490 #[strum(serialize = "optional")]
3491 Optional,
3492 /// This variant handles values not known at compile time.
3493 #[serde(untagged)]
3494 #[strum(serialize = "__OTHER__")]
3495 Other_(String),
3496}
3497/// Identifiers of currently supported resources.
3498///
3499/// Possible values:
3500/// - `numCpuPackages`: Number of CPU packages on this host.
3501/// - `numCpuCores`: Number of licensable CPU cores/compute-units on this host.
3502/// - `memorySize`: Total size of memory installed on this host, measured in kilobytes.
3503/// - `memoryForVms`: Total size of memory configured for VMs on this host, measured in kilobytes.
3504/// - `numVmsStarted`: Number of VMs already running on this host.
3505/// - `numVmsStarting`: Number of VMs that are currently powering-on, immigrating, etc.
3506/// - `vsanCapacity`: vSAN capacity in TiB on this host.
3507///
3508/// ***Since:*** vSphere API Release 8.0.3.0
3509#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
3510pub enum HostLicensableResourceKeyEnum {
3511 #[serde(rename = "numCpuPackages")]
3512 #[strum(serialize = "numCpuPackages")]
3513 NumCpuPackages,
3514 #[serde(rename = "numCpuCores")]
3515 #[strum(serialize = "numCpuCores")]
3516 NumCpuCores,
3517 #[serde(rename = "memorySize")]
3518 #[strum(serialize = "memorySize")]
3519 MemorySize,
3520 #[serde(rename = "memoryForVms")]
3521 #[strum(serialize = "memoryForVms")]
3522 MemoryForVms,
3523 #[serde(rename = "numVmsStarted")]
3524 #[strum(serialize = "numVmsStarted")]
3525 NumVmsStarted,
3526 #[serde(rename = "numVmsStarting")]
3527 #[strum(serialize = "numVmsStarting")]
3528 NumVmsStarting,
3529 #[serde(rename = "vsanCapacity")]
3530 #[strum(serialize = "vsanCapacity")]
3531 VsanCapacity,
3532 /// This variant handles values not known at compile time.
3533 #[serde(untagged)]
3534 #[strum(serialize = "__OTHER__")]
3535 Other_(String),
3536}
3537/// Deprecated as of VI API 2.5, use *LicenseManager.QueryLicenseSourceAvailability*
3538/// to obtain an array of *LicenseAvailabilityInfo* data
3539/// objects.
3540///
3541/// Licensed features have unique keys to identify them.
3542///
3543/// Possible values:
3544/// - `esxFull`: The edition license for the ESX Server, Standard edition.
3545///
3546/// This is a per
3547/// CPU package license.
3548/// - `esxVmtn`: The edition license for the ESX server, VMTN edition.
3549///
3550/// This is a per CPU package
3551/// license.
3552/// - `esxExpress`: The edition license for the ESX server, Starter edition.
3553///
3554/// This is a per CPU
3555/// package license.
3556/// - `san`: Enable use of SAN.
3557///
3558/// This is a per CPU package license.
3559/// - `iscsi`: Enable use of iSCSI.
3560///
3561/// This is a per CPU package license.
3562/// - `nas`: Enable use of NAS.
3563///
3564/// This is a per CPU package license.
3565/// - `vsmp`: Enable up to 4-way VSMP feature.
3566///
3567/// This is a per CPU package license.
3568/// - `backup`: Enable ESX Server consolidated backup feature.
3569///
3570/// This is a per CPU package
3571/// license.
3572/// - `vc`: The edition license for a VirtualCenter server, full edition.
3573///
3574/// This license
3575/// is independent of the number of CPU packages for the VirtualCenter host.
3576/// - `vcExpress`: The edition license for a VirtualCenter server, starter edition.
3577///
3578/// This license
3579/// limits the number of hosts (esxHost or serverHost) that can be managed by the
3580/// VirtualCenter product.
3581/// - `esxHost`: Enable VirtualCenter ESX Server host management functionality.
3582///
3583/// This is a per
3584/// ESX server CPU package license.
3585/// - `gsxHost`: Enable VirtualCenter GSX Server host management functionality.
3586///
3587/// This is a per
3588/// GSX server CPU package license.
3589/// - `serverHost`: Enable VirtualCenter VMware server host management functionality.
3590///
3591/// This is a per
3592/// VMware server CPU package license.
3593/// - `drsPower`: Enable VirtualCenter DRS Power Management Functionality.
3594///
3595/// This is a per CPU package
3596/// - `vmotion`: Enable VMotion.
3597///
3598/// This is a per ESX server CPU package license.
3599/// - `drs`: Enable VirtualCenter Distributed Resource Scheduler.
3600///
3601/// This is a per ESX server
3602/// CPU package license.
3603/// - `das`: Enable VirtualCenter HA.
3604///
3605/// This is a per ESX server CPU package license.
3606#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
3607pub enum LicenseManagerLicenseKeyEnum {
3608 #[serde(rename = "esxFull")]
3609 #[strum(serialize = "esxFull")]
3610 EsxFull,
3611 #[serde(rename = "esxVmtn")]
3612 #[strum(serialize = "esxVmtn")]
3613 EsxVmtn,
3614 #[serde(rename = "esxExpress")]
3615 #[strum(serialize = "esxExpress")]
3616 EsxExpress,
3617 #[serde(rename = "san")]
3618 #[strum(serialize = "san")]
3619 San,
3620 #[serde(rename = "iscsi")]
3621 #[strum(serialize = "iscsi")]
3622 Iscsi,
3623 #[serde(rename = "nas")]
3624 #[strum(serialize = "nas")]
3625 Nas,
3626 #[serde(rename = "vsmp")]
3627 #[strum(serialize = "vsmp")]
3628 Vsmp,
3629 #[serde(rename = "backup")]
3630 #[strum(serialize = "backup")]
3631 Backup,
3632 #[serde(rename = "vc")]
3633 #[strum(serialize = "vc")]
3634 Vc,
3635 #[serde(rename = "vcExpress")]
3636 #[strum(serialize = "vcExpress")]
3637 VcExpress,
3638 #[serde(rename = "esxHost")]
3639 #[strum(serialize = "esxHost")]
3640 EsxHost,
3641 #[serde(rename = "gsxHost")]
3642 #[strum(serialize = "gsxHost")]
3643 GsxHost,
3644 #[serde(rename = "serverHost")]
3645 #[strum(serialize = "serverHost")]
3646 ServerHost,
3647 #[serde(rename = "drsPower")]
3648 #[strum(serialize = "drsPower")]
3649 DrsPower,
3650 #[serde(rename = "vmotion")]
3651 #[strum(serialize = "vmotion")]
3652 Vmotion,
3653 #[serde(rename = "drs")]
3654 #[strum(serialize = "drs")]
3655 Drs,
3656 #[serde(rename = "das")]
3657 #[strum(serialize = "das")]
3658 Das,
3659 /// This variant handles values not known at compile time.
3660 #[serde(untagged)]
3661 #[strum(serialize = "__OTHER__")]
3662 Other_(String),
3663}
3664/// Deprecated as of vSphere API 4.0, this is not used by the system.
3665///
3666/// State of licensing subsystem.
3667///
3668/// Possible values:
3669/// - `initializing`: Setting or resetting configuration in progress.
3670/// - `normal`: Running within operating parameters.
3671/// - `marginal`: License source unavailable, using license cache.
3672/// - `fault`: Initialization has failed or grace period expired.
3673#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
3674pub enum LicenseManagerStateEnum {
3675 #[serde(rename = "initializing")]
3676 #[strum(serialize = "initializing")]
3677 Initializing,
3678 #[serde(rename = "normal")]
3679 #[strum(serialize = "normal")]
3680 Normal,
3681 #[serde(rename = "marginal")]
3682 #[strum(serialize = "marginal")]
3683 Marginal,
3684 #[serde(rename = "fault")]
3685 #[strum(serialize = "fault")]
3686 Fault,
3687 /// This variant handles values not known at compile time.
3688 #[serde(untagged)]
3689 #[strum(serialize = "__OTHER__")]
3690 Other_(String),
3691}
3692/// Describes the reservation state of a license.
3693///
3694/// Possible values:
3695/// - `notUsed`: This license is currently unused by the system, or the feature does not
3696/// apply.
3697///
3698/// For example, a DRS license appears as NotUsed if the host is not
3699/// part of a DRS-enabled cluster.
3700/// - `noLicense`: This indicates that the license has expired or the system attempted to acquire
3701/// the license but was not successful in reserving it.
3702/// - `unlicensedUse`: The LicenseManager failed to acquire a license but the implementation
3703/// policy allows us to use the licensed feature anyway.
3704///
3705/// This is possible, for
3706/// example, when a license server becomes unavailable after a license had been
3707/// successfully reserved from it.
3708/// - `licensed`: The required number of licenses have been acquired from the license source.
3709#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
3710pub enum LicenseReservationInfoStateEnum {
3711 #[serde(rename = "notUsed")]
3712 #[strum(serialize = "notUsed")]
3713 NotUsed,
3714 #[serde(rename = "noLicense")]
3715 #[strum(serialize = "noLicense")]
3716 NoLicense,
3717 #[serde(rename = "unlicensedUse")]
3718 #[strum(serialize = "unlicensedUse")]
3719 UnlicensedUse,
3720 #[serde(rename = "licensed")]
3721 #[strum(serialize = "licensed")]
3722 Licensed,
3723 /// This variant handles values not known at compile time.
3724 #[serde(untagged)]
3725 #[strum(serialize = "__OTHER__")]
3726 Other_(String),
3727}
3728/// The Status enumeration defines a general "health" value for a managed entity.
3729///
3730/// Possible values:
3731/// - `gray`: The status is unknown.
3732/// - `green`: The entity is OK.
3733/// - `yellow`: The entity might have a problem.
3734/// - `red`: The entity definitely has a problem.
3735#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
3736pub enum ManagedEntityStatusEnum {
3737 #[serde(rename = "gray")]
3738 #[strum(serialize = "gray")]
3739 Gray,
3740 #[serde(rename = "green")]
3741 #[strum(serialize = "green")]
3742 Green,
3743 #[serde(rename = "yellow")]
3744 #[strum(serialize = "yellow")]
3745 Yellow,
3746 #[serde(rename = "red")]
3747 #[strum(serialize = "red")]
3748 Red,
3749 /// This variant handles values not known at compile time.
3750 #[serde(untagged)]
3751 #[strum(serialize = "__OTHER__")]
3752 Other_(String),
3753}
3754/// The type of an OST node.
3755///
3756/// Each OST node corresponds to an element in the OVF descriptor. See *OvfConsumerOstNode*
3757/// for a description of the different node types.
3758///
3759/// Possible values:
3760/// - `envelope`
3761/// - `virtualSystem`
3762/// - `virtualSystemCollection`
3763#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
3764pub enum OvfConsumerOstNodeTypeEnum {
3765 #[serde(rename = "envelope")]
3766 #[strum(serialize = "envelope")]
3767 Envelope,
3768 #[serde(rename = "virtualSystem")]
3769 #[strum(serialize = "virtualSystem")]
3770 VirtualSystem,
3771 #[serde(rename = "virtualSystemCollection")]
3772 #[strum(serialize = "virtualSystemCollection")]
3773 VirtualSystemCollection,
3774 /// This variant handles values not known at compile time.
3775 #[serde(untagged)]
3776 #[strum(serialize = "__OTHER__")]
3777 Other_(String),
3778}
3779/// Types of disk provisioning that can be set for the disk in the deployed OVF
3780/// package.
3781///
3782/// Possible values:
3783/// - `monolithicSparse`: A sparse (allocate on demand) monolithic disk.
3784///
3785/// Disks in this format can
3786/// be used with other VMware products.
3787/// - `monolithicFlat`: A preallocated monolithic disk.
3788///
3789/// Disks in this format can be used with
3790/// other VMware products.
3791/// - `twoGbMaxExtentSparse`: A sparse (allocate on demand) disk with 2GB maximum extent size.
3792///
3793/// Disks in this format can be used with other VMware products. The 2GB
3794/// extent size makes these disks easier to burn to dvd or use on
3795/// filesystems that don't support large files.
3796/// - `twoGbMaxExtentFlat`: A preallocated disk with 2GB maximum extent size.
3797///
3798/// Disks in this format
3799/// can be used with other VMware products. The 2GB extent size
3800/// makes these disks easier to burn to dvd or use on filesystems that
3801/// don't support large files.
3802/// - `thin`: Space required for thin-provisioned virtual disk is allocated and
3803/// zeroed on demand as the space is used.
3804/// - `thick`: A thick disk has all space allocated at creation time
3805/// and the space is zeroed on demand as the space is used.
3806/// - `seSparse`: A sparse (allocate on demand) format with additional space
3807/// optimizations.
3808/// - `eagerZeroedThick`: An eager zeroed thick disk has all space allocated and wiped clean
3809/// of any previous contents on the physical media at creation time.
3810///
3811/// Such disks may take longer time during creation compared to other
3812/// disk formats.
3813/// - `sparse`: Depending on the host type, Sparse is mapped to either
3814/// MonolithicSparse or Thin.
3815/// - `flat`: Depending on the host type, Flat is mapped to either
3816/// MonolithicFlat or Thick.
3817#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
3818pub enum OvfCreateImportSpecParamsDiskProvisioningTypeEnum {
3819 #[serde(rename = "monolithicSparse")]
3820 #[strum(serialize = "monolithicSparse")]
3821 MonolithicSparse,
3822 #[serde(rename = "monolithicFlat")]
3823 #[strum(serialize = "monolithicFlat")]
3824 MonolithicFlat,
3825 #[serde(rename = "twoGbMaxExtentSparse")]
3826 #[strum(serialize = "twoGbMaxExtentSparse")]
3827 TwoGbMaxExtentSparse,
3828 #[serde(rename = "twoGbMaxExtentFlat")]
3829 #[strum(serialize = "twoGbMaxExtentFlat")]
3830 TwoGbMaxExtentFlat,
3831 #[serde(rename = "thin")]
3832 #[strum(serialize = "thin")]
3833 Thin,
3834 #[serde(rename = "thick")]
3835 #[strum(serialize = "thick")]
3836 Thick,
3837 #[serde(rename = "seSparse")]
3838 #[strum(serialize = "seSparse")]
3839 SeSparse,
3840 #[serde(rename = "eagerZeroedThick")]
3841 #[strum(serialize = "eagerZeroedThick")]
3842 EagerZeroedThick,
3843 #[serde(rename = "sparse")]
3844 #[strum(serialize = "sparse")]
3845 Sparse,
3846 #[serde(rename = "flat")]
3847 #[strum(serialize = "flat")]
3848 Flat,
3849 /// This variant handles values not known at compile time.
3850 #[serde(untagged)]
3851 #[strum(serialize = "__OTHER__")]
3852 Other_(String),
3853}
3854/// Indicates how multiple samples of a specific counter type are
3855/// transformed into a single statistical value.
3856///
3857/// Possible values:
3858/// - `average`: The actual value collected or the average of all values collected
3859/// during the summary period.
3860/// - `maximum`: The maximum value of the performance counter value over the
3861/// summarization period.
3862/// - `minimum`: The minimum value of the performance counter value over the
3863/// summarization period.
3864/// - `latest`: The most recent value of the performance counter over the
3865/// summarization period.
3866/// - `summation`: The sum of all the values of the performance counter over the
3867/// summarization period.
3868/// - `none`: The counter is never rolled up.
3869#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
3870pub enum PerfSummaryTypeEnum {
3871 #[serde(rename = "average")]
3872 #[strum(serialize = "average")]
3873 Average,
3874 #[serde(rename = "maximum")]
3875 #[strum(serialize = "maximum")]
3876 Maximum,
3877 #[serde(rename = "minimum")]
3878 #[strum(serialize = "minimum")]
3879 Minimum,
3880 #[serde(rename = "latest")]
3881 #[strum(serialize = "latest")]
3882 Latest,
3883 #[serde(rename = "summation")]
3884 #[strum(serialize = "summation")]
3885 Summation,
3886 #[serde(rename = "none")]
3887 #[strum(serialize = "none")]
3888 None,
3889 /// This variant handles values not known at compile time.
3890 #[serde(untagged)]
3891 #[strum(serialize = "__OTHER__")]
3892 Other_(String),
3893}
3894/// Indicates the type of statistical measurement that a counter’s
3895/// value represents.
3896///
3897/// Valid types are “absolute”,
3898/// “delta”, or “rate”.
3899///
3900/// Possible values:
3901/// - `absolute`: Represents an actual value, level, or state of the counter.
3902///
3903/// For
3904/// example, the “uptime” counter (**system** group)
3905/// represents the actual number of seconds since startup. The
3906/// “capacity” counter represents the actual configured size
3907/// of the specified datastore. In other words, number of samples,
3908/// samplingPeriod, and intervals have no bearing on an
3909/// “absolute” counter“s value.
3910/// - `delta`: Represents an amount of change for the counter during the *PerfInterval.samplingPeriod* as compared to the previous
3911/// *interval*.
3912///
3913/// The first sampling interval
3914/// - `rate`: Represents a value that has been normalized over the *PerfInterval.samplingPeriod*, enabling values for the same
3915/// counter type to be compared, regardless of interval.
3916///
3917/// For example,
3918/// the number of reads per second.
3919#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
3920pub enum PerfStatsTypeEnum {
3921 #[serde(rename = "absolute")]
3922 #[strum(serialize = "absolute")]
3923 Absolute,
3924 #[serde(rename = "delta")]
3925 #[strum(serialize = "delta")]
3926 Delta,
3927 #[serde(rename = "rate")]
3928 #[strum(serialize = "rate")]
3929 Rate,
3930 /// This variant handles values not known at compile time.
3931 #[serde(untagged)]
3932 #[strum(serialize = "__OTHER__")]
3933 Other_(String),
3934}
3935/// Indicates the unit of measure represented by a counter or statistical
3936/// value.
3937///
3938/// Possible values:
3939/// - `percent`: Percentage values in units of 1/100th of a percent.
3940///
3941/// For example 100
3942/// represents 1%.
3943/// - `kiloBytes`: Kilobytes.
3944/// - `megaBytes`: Megabytes.
3945/// - `megaHertz`: Megahertz.
3946/// - `number`: A quantity of items, for example, the number of CPUs.
3947/// - `microsecond`: The time in microseconds.
3948/// - `millisecond`: The time in milliseconds.
3949/// - `second`: The time in seconds.
3950/// - `kiloBytesPerSecond`: Kilobytes per second.
3951/// - `megaBytesPerSecond`: Megabytes per second.
3952/// - `watt`: Watts
3953/// - `joule`: Joules
3954/// - `teraBytes`: Terabytes.
3955/// - `celsius`: Temperature in celsius.
3956/// - `nanosecond`: The time in nanoseconds.
3957///
3958/// ***Since:*** vSphere API Release 8.0.0.1
3959#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
3960pub enum PerformanceManagerUnitEnum {
3961 #[serde(rename = "percent")]
3962 #[strum(serialize = "percent")]
3963 Percent,
3964 #[serde(rename = "kiloBytes")]
3965 #[strum(serialize = "kiloBytes")]
3966 KiloBytes,
3967 #[serde(rename = "megaBytes")]
3968 #[strum(serialize = "megaBytes")]
3969 MegaBytes,
3970 #[serde(rename = "megaHertz")]
3971 #[strum(serialize = "megaHertz")]
3972 MegaHertz,
3973 #[serde(rename = "number")]
3974 #[strum(serialize = "number")]
3975 Number,
3976 #[serde(rename = "microsecond")]
3977 #[strum(serialize = "microsecond")]
3978 Microsecond,
3979 #[serde(rename = "millisecond")]
3980 #[strum(serialize = "millisecond")]
3981 Millisecond,
3982 #[serde(rename = "second")]
3983 #[strum(serialize = "second")]
3984 Second,
3985 #[serde(rename = "kiloBytesPerSecond")]
3986 #[strum(serialize = "kiloBytesPerSecond")]
3987 KiloBytesPerSecond,
3988 #[serde(rename = "megaBytesPerSecond")]
3989 #[strum(serialize = "megaBytesPerSecond")]
3990 MegaBytesPerSecond,
3991 #[serde(rename = "watt")]
3992 #[strum(serialize = "watt")]
3993 Watt,
3994 #[serde(rename = "joule")]
3995 #[strum(serialize = "joule")]
3996 Joule,
3997 #[serde(rename = "teraBytes")]
3998 #[strum(serialize = "teraBytes")]
3999 TeraBytes,
4000 #[serde(rename = "celsius")]
4001 #[strum(serialize = "celsius")]
4002 Celsius,
4003 #[serde(rename = "nanosecond")]
4004 #[strum(serialize = "nanosecond")]
4005 Nanosecond,
4006 /// This variant handles values not known at compile time.
4007 #[serde(untagged)]
4008 #[strum(serialize = "__OTHER__")]
4009 Other_(String),
4010}
4011/// The format in which performance counter data is returned.
4012///
4013/// Possible values:
4014/// - `normal`: Counters returned in an array of data objects.
4015/// - `csv`: Counters returned in comma-separate value (CSV) format.
4016#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
4017pub enum PerfFormatEnum {
4018 #[serde(rename = "normal")]
4019 #[strum(serialize = "normal")]
4020 Normal,
4021 #[serde(rename = "csv")]
4022 #[strum(serialize = "csv")]
4023 Csv,
4024 /// This variant handles values not known at compile time.
4025 #[serde(untagged)]
4026 #[strum(serialize = "__OTHER__")]
4027 Other_(String),
4028}
4029/// Defines the type of placement
4030///
4031/// Possible values:
4032/// - `createAndPowerOn`: Create a new VM that should be powered-on in the near future.
4033/// - `reconfigure`: Reconfigure a powered-off or a powered-on VM.
4034/// - `relocate`: Relocate a powered-off or a powered-on VM.
4035///
4036/// ***Since:*** vSphere API Release 9.0.0.0
4037#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
4038pub enum PlaceVmsXClusterSpecPlacementTypeEnum {
4039 #[serde(rename = "createAndPowerOn")]
4040 #[strum(serialize = "createAndPowerOn")]
4041 CreateAndPowerOn,
4042 #[serde(rename = "reconfigure")]
4043 #[strum(serialize = "reconfigure")]
4044 Reconfigure,
4045 #[serde(rename = "relocate")]
4046 #[strum(serialize = "relocate")]
4047 Relocate,
4048 /// This variant handles values not known at compile time.
4049 #[serde(untagged)]
4050 #[strum(serialize = "__OTHER__")]
4051 Other_(String),
4052}
4053/// Possible values:
4054/// - `disabled`: Do not scale shares
4055/// - `scaleCpuAndMemoryShares`: Scale both CPU and memory shares
4056#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
4057pub enum ResourceConfigSpecScaleSharesBehaviorEnum {
4058 #[serde(rename = "disabled")]
4059 #[strum(serialize = "disabled")]
4060 Disabled,
4061 #[serde(rename = "scaleCpuAndMemoryShares")]
4062 #[strum(serialize = "scaleCpuAndMemoryShares")]
4063 ScaleCpuAndMemoryShares,
4064 /// This variant handles values not known at compile time.
4065 #[serde(untagged)]
4066 #[strum(serialize = "__OTHER__")]
4067 Other_(String),
4068}
4069/// Types of a host's compatibility with a designated virtual machine
4070/// that is a candidate for VMotion.
4071///
4072/// Used with queryVMotionCompatibility
4073/// both as inputs (to designate which compatibility types to test for)
4074/// and as outputs (to specify which compatibility types apply for
4075/// each host).
4076///
4077/// Possible values:
4078/// - `cpu`: The host's CPU features are compatible with the
4079/// the virtual machine's requirements.
4080/// - `software`: The software platform on the host supports VMotion
4081/// and is compatible with the virtual machine.
4082#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
4083pub enum VMotionCompatibilityTypeEnum {
4084 #[serde(rename = "cpu")]
4085 #[strum(serialize = "cpu")]
4086 Cpu,
4087 #[serde(rename = "software")]
4088 #[strum(serialize = "software")]
4089 Software,
4090 /// This variant handles values not known at compile time.
4091 #[serde(untagged)]
4092 #[strum(serialize = "__OTHER__")]
4093 Other_(String),
4094}
4095/// Deprecated as of vSphere API 4.0, use *CheckTestType_enum* instead.
4096///
4097/// Types of tests available for validateMigration.
4098///
4099/// Possible values:
4100/// - `sourceTests`: Tests that examine only the configuration
4101/// of the virtual machine and its current host; the destination
4102/// resource pool and host or cluster are irrelevant.
4103/// - `compatibilityTests`: Tests that examine both the virtual
4104/// machine and the destination host or cluster; the destination
4105/// resource pool is irrelevant.
4106///
4107/// This set excludes tests that fall
4108/// into the diskAccessibilityTests group.
4109/// - `diskAccessibilityTests`: Tests that check that the
4110/// destination host or cluster can see the datastores where the virtual
4111/// machine's virtual disks are currently located.
4112///
4113/// The destination
4114/// resource pool is irrelevant. If you are planning to relocate the
4115/// virtual disks, do not use these tests; instead examine the relevant
4116/// datastore objects for your planned disk locations to see if they
4117/// are accessible to the destination host.
4118/// - `resourceTests`: Tests that check that the destination resource
4119/// pool can support the virtual machine if it is powered on.
4120///
4121/// The
4122/// destination host or cluster is relevant because it will affect the
4123/// amount of overhead memory required to run the virtual machine.
4124#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
4125pub enum ValidateMigrationTestTypeEnum {
4126 #[serde(rename = "sourceTests")]
4127 #[strum(serialize = "sourceTests")]
4128 SourceTests,
4129 #[serde(rename = "compatibilityTests")]
4130 #[strum(serialize = "compatibilityTests")]
4131 CompatibilityTests,
4132 #[serde(rename = "diskAccessibilityTests")]
4133 #[strum(serialize = "diskAccessibilityTests")]
4134 DiskAccessibilityTests,
4135 #[serde(rename = "resourceTests")]
4136 #[strum(serialize = "resourceTests")]
4137 ResourceTests,
4138 /// This variant handles values not known at compile time.
4139 #[serde(untagged)]
4140 #[strum(serialize = "__OTHER__")]
4141 Other_(String),
4142}
4143/// Possible values:
4144/// - `HttpNfcServiceTicket`: Ticket used for HttpNfc access to a file or disk on a datastore
4145/// - `HostServiceTicket`: Ticket used for service request on a host
4146/// - `VcServiceTicket`: Ticket used for service request on a VC
4147///
4148/// ***Since:*** vSphere API Release 7.0.2.0
4149#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
4150pub enum SessionManagerGenericServiceTicketTicketTypeEnum {
4151 HttpNfcServiceTicket,
4152 HostServiceTicket,
4153 VcServiceTicket,
4154 /// This variant handles values not known at compile time.
4155 #[serde(untagged)]
4156 #[strum(serialize = "__OTHER__")]
4157 Other_(String),
4158}
4159/// HTTP request methods.
4160///
4161/// Possible values:
4162/// - `httpOptions`
4163/// - `httpGet`
4164/// - `httpHead`
4165/// - `httpPost`
4166/// - `httpPut`
4167/// - `httpDelete`
4168/// - `httpTrace`
4169/// - `httpConnect`
4170#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
4171pub enum SessionManagerHttpServiceRequestSpecMethodEnum {
4172 #[serde(rename = "httpOptions")]
4173 #[strum(serialize = "httpOptions")]
4174 HttpOptions,
4175 #[serde(rename = "httpGet")]
4176 #[strum(serialize = "httpGet")]
4177 HttpGet,
4178 #[serde(rename = "httpHead")]
4179 #[strum(serialize = "httpHead")]
4180 HttpHead,
4181 #[serde(rename = "httpPost")]
4182 #[strum(serialize = "httpPost")]
4183 HttpPost,
4184 #[serde(rename = "httpPut")]
4185 #[strum(serialize = "httpPut")]
4186 HttpPut,
4187 #[serde(rename = "httpDelete")]
4188 #[strum(serialize = "httpDelete")]
4189 HttpDelete,
4190 #[serde(rename = "httpTrace")]
4191 #[strum(serialize = "httpTrace")]
4192 HttpTrace,
4193 #[serde(rename = "httpConnect")]
4194 #[strum(serialize = "httpConnect")]
4195 HttpConnect,
4196 /// This variant handles values not known at compile time.
4197 #[serde(untagged)]
4198 #[strum(serialize = "__OTHER__")]
4199 Other_(String),
4200}
4201/// Simplified shares notation.
4202///
4203/// These designations have different meanings for different resources.
4204///
4205/// Possible values:
4206/// - `low`: For CPU: Shares = 500 \* number of virtual CPUs
4207/// For Memory: Shares = 5 \* virtual machine memory size in megabytes
4208/// For Disk: Shares = 500
4209/// For Network: Shares = 0.25 \* *DVSFeatureCapability.networkResourcePoolHighShareValue*
4210/// - `normal`: For CPU: Shares = 1000 \* number of virtual CPUs
4211/// For Memory: Shares = 10 \* virtual machine memory size in megabytes
4212/// For Disk: Shares = 1000
4213/// For Network: Shares = 0.5 \* *DVSFeatureCapability.networkResourcePoolHighShareValue*
4214/// - `high`: For CPU: Shares = 2000 \* number of virtual CPUs
4215/// For Memory: Shares = 20 \* virtual machine memory size in megabytes
4216/// For Disk: Shares = 2000
4217/// For Network: Shares = *DVSFeatureCapability.networkResourcePoolHighShareValue*
4218/// - `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.
4219#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
4220pub enum SharesLevelEnum {
4221 #[serde(rename = "low")]
4222 #[strum(serialize = "low")]
4223 Low,
4224 #[serde(rename = "normal")]
4225 #[strum(serialize = "normal")]
4226 Normal,
4227 #[serde(rename = "high")]
4228 #[strum(serialize = "high")]
4229 High,
4230 #[serde(rename = "custom")]
4231 #[strum(serialize = "custom")]
4232 Custom,
4233 /// This variant handles values not known at compile time.
4234 #[serde(untagged)]
4235 #[strum(serialize = "__OTHER__")]
4236 Other_(String),
4237}
4238/// The encoding of the resultant return data.
4239///
4240/// This is a hint to the client side
4241/// to indicate the format of the information being returned.
4242///
4243/// Possible values:
4244/// - `CSV`: Comma separated values
4245/// - `HEX`: Hex encoded binary data
4246/// - `STRING`
4247#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
4248pub enum SimpleCommandEncodingEnum {
4249 #[serde(rename = "CSV")]
4250 #[strum(serialize = "CSV")]
4251 Csv,
4252 #[serde(rename = "HEX")]
4253 #[strum(serialize = "HEX")]
4254 Hex,
4255 #[serde(rename = "STRING")]
4256 #[strum(serialize = "STRING")]
4257 String,
4258 /// This variant handles values not known at compile time.
4259 #[serde(untagged)]
4260 #[strum(serialize = "__OTHER__")]
4261 Other_(String),
4262}
4263/// Deprecated as of vSphere8.0 U3, and there is no replacement for it.
4264///
4265/// User specification of congestion threshold mode on a given datastore
4266///
4267/// For more information, see
4268/// *StorageIORMInfo.congestionThreshold*
4269///
4270/// Possible values:
4271/// - `automatic`: Storagage IO Control will choose appropriate congestion threshold value
4272/// for that datastore to operate at given percentage of peak throughput.
4273///
4274/// This is the default setting
4275/// - `manual`: Use user specified Storage IO Control congestion threshold value
4276#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
4277pub enum StorageIormThresholdModeEnum {
4278 #[serde(rename = "automatic")]
4279 #[strum(serialize = "automatic")]
4280 Automatic,
4281 #[serde(rename = "manual")]
4282 #[strum(serialize = "manual")]
4283 Manual,
4284 /// This variant handles values not known at compile time.
4285 #[serde(untagged)]
4286 #[strum(serialize = "__OTHER__")]
4287 Other_(String),
4288}
4289/// This option specifies how to select tasks based on child relationships
4290/// in the inventory hierarchy.
4291///
4292/// If a managed entity has children, their tasks
4293/// can be retrieved with this filter option.
4294///
4295/// Possible values:
4296/// - `self`: Returns tasks that pertain only to the specified managed entity,
4297/// and not its children.
4298/// - `children`: Returns tasks pertaining to child entities only.
4299///
4300/// Excludes
4301/// tasks pertaining to the specified managed entity itself.
4302/// - `all`: Returns tasks pertaining either to the specified managed entity
4303/// or to its child entities.
4304#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
4305pub enum TaskFilterSpecRecursionOptionEnum {
4306 #[serde(rename = "self")]
4307 #[strum(serialize = "self")]
4308 Self_,
4309 #[serde(rename = "children")]
4310 #[strum(serialize = "children")]
4311 Children,
4312 #[serde(rename = "all")]
4313 #[strum(serialize = "all")]
4314 All,
4315 /// This variant handles values not known at compile time.
4316 #[serde(untagged)]
4317 #[strum(serialize = "__OTHER__")]
4318 Other_(String),
4319}
4320/// This option specifies a time stamp governing the selection of tasks.
4321///
4322/// Possible values:
4323/// - `queuedTime`: The time stamp when the task was created and queued.
4324/// - `startedTime`: The time stamp when the task started.
4325/// - `completedTime`: The time stamp when the task finished.
4326#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
4327pub enum TaskFilterSpecTimeOptionEnum {
4328 #[serde(rename = "queuedTime")]
4329 #[strum(serialize = "queuedTime")]
4330 QueuedTime,
4331 #[serde(rename = "startedTime")]
4332 #[strum(serialize = "startedTime")]
4333 StartedTime,
4334 #[serde(rename = "completedTime")]
4335 #[strum(serialize = "completedTime")]
4336 CompletedTime,
4337 /// This variant handles values not known at compile time.
4338 #[serde(untagged)]
4339 #[strum(serialize = "__OTHER__")]
4340 Other_(String),
4341}
4342/// List of possible states of a task.
4343///
4344/// Possible values:
4345/// - `queued`: When there are too many tasks for threads to handle.
4346/// - `running`: When the busy thread is freed from its current task by
4347/// finishing the task, it picks a queued task to run.
4348///
4349/// Then the queued tasks are marked as running.
4350/// - `success`: When a running task has completed.
4351/// - `error`: When a running task has encountered an error.
4352#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
4353pub enum TaskInfoStateEnum {
4354 #[serde(rename = "queued")]
4355 #[strum(serialize = "queued")]
4356 Queued,
4357 #[serde(rename = "running")]
4358 #[strum(serialize = "running")]
4359 Running,
4360 #[serde(rename = "success")]
4361 #[strum(serialize = "success")]
4362 Success,
4363 #[serde(rename = "error")]
4364 #[strum(serialize = "error")]
4365 Error,
4366 /// This variant handles values not known at compile time.
4367 #[serde(untagged)]
4368 #[strum(serialize = "__OTHER__")]
4369 Other_(String),
4370}
4371/// The VAppState type defines the set of states a vApp can be
4372/// in.
4373///
4374/// The transitory states between started and stopped is modeled explicitly,
4375/// since the starting or stopping of a vApp is typically a time-consuming
4376/// process that might take minutes to complete.
4377///
4378/// Possible values:
4379/// - `started`: The vApp is currently powered on .
4380/// - `stopped`: The vApp is currently powered off or suspended.
4381/// - `starting`: The vApp is in the process of starting.
4382/// - `stopping`: The vApp is in the process of stopping.
4383#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
4384pub enum VirtualAppVAppStateEnum {
4385 #[serde(rename = "started")]
4386 #[strum(serialize = "started")]
4387 Started,
4388 #[serde(rename = "stopped")]
4389 #[strum(serialize = "stopped")]
4390 Stopped,
4391 #[serde(rename = "starting")]
4392 #[strum(serialize = "starting")]
4393 Starting,
4394 #[serde(rename = "stopping")]
4395 #[strum(serialize = "stopping")]
4396 Stopping,
4397 /// This variant handles values not known at compile time.
4398 #[serde(untagged)]
4399 #[strum(serialize = "__OTHER__")]
4400 Other_(String),
4401}
4402/// The types of virtual disk adapters used by virtual disks
4403///
4404/// Possible values:
4405/// - `ide`: Use IDE emulation for the virtual disk
4406/// - `busLogic`: Use BusLogic emulation for the virtual disk
4407/// - `lsiLogic`: Use LSILogic emulation for the virtual disk
4408#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
4409pub enum VirtualDiskAdapterTypeEnum {
4410 #[serde(rename = "ide")]
4411 #[strum(serialize = "ide")]
4412 Ide,
4413 #[serde(rename = "busLogic")]
4414 #[strum(serialize = "busLogic")]
4415 BusLogic,
4416 #[serde(rename = "lsiLogic")]
4417 #[strum(serialize = "lsiLogic")]
4418 LsiLogic,
4419 /// This variant handles values not known at compile time.
4420 #[serde(untagged)]
4421 #[strum(serialize = "__OTHER__")]
4422 Other_(String),
4423}
4424/// The types of virtual disks that can be created or cloned.
4425///
4426/// Possible values:
4427/// - `preallocated`: A preallocated disk has all space allocated at creation time
4428/// and the space is zeroed on demand as the space is used.
4429/// - `thin`: Space required for thin-provisioned virtual disk is allocated and
4430/// zeroed on demand as the space is used.
4431/// - `seSparse`: A sparse (allocate on demand) format with additional space
4432/// optimizations.
4433/// - `rdm`: Virtual compatibility mode raw disk mapping.
4434///
4435/// An rdm virtual disk
4436/// grants access to the entire raw disk and the virtual disk can
4437/// participate in snapshots.
4438/// - `rdmp`: Physical compatibility mode (pass-through) raw disk mapping.
4439///
4440/// An rdmp
4441/// virtual disk passes SCSI commands directly to the hardware, but the
4442/// virtual disk cannot participate in snapshots.
4443/// - `raw`: Raw device.
4444/// - `delta`: A redo log disk.
4445///
4446/// This format is only applicable as a destination format
4447/// in a clone operation, and not usable for disk creation.
4448/// - `sparse2Gb`: A sparse disk with 2GB maximum extent size.
4449///
4450/// Disks in this format
4451/// can be used with other VMware products. The 2GB extent size
4452/// makes these disks easier to burn to dvd or use on filesystems that
4453/// don't support large files. This format is only applicable as a
4454/// destination format in a clone operation, and not usable for disk
4455/// creation.
4456/// - `thick2Gb`: A thick disk with 2GB maximum extent size.
4457///
4458/// Disks in this format
4459/// can be used with other VMware products. The 2GB extent size
4460/// makes these disks easier to burn to dvd or use on filesystems that
4461/// don't support large files. This format is only applicable as a
4462/// destination format in a clone operation, and not usable for disk
4463/// creation.
4464/// - `eagerZeroedThick`: An eager zeroed thick disk has all space allocated and wiped clean
4465/// of any previous contents on the physical media at creation time.
4466///
4467/// Such disks may take longer time during creation compared to other
4468/// disk formats.
4469/// - `sparseMonolithic`: A sparse monolithic disk.
4470///
4471/// Disks in this format can be used with other
4472/// VMware products. This format is only applicable as a destination
4473/// format in a clone operation, and not usable for disk creation.
4474/// - `flatMonolithic`: A preallocated monolithic disk.
4475///
4476/// Disks in this format can be used with
4477/// other VMware products. This format is only applicable as a destination
4478/// format in a clone operation, and not usable for disk creation.
4479/// - `thick`:
4480///
4481/// Deprecated as of vSphere API 4.x, use *eagerZeroedThick* instead
4482/// for clustering application, and *preallocated* for other applications.
4483///
4484/// A thick disk has all space allocated at creation time.
4485///
4486/// This
4487/// space may contain stale data on the physical media. Thick disks
4488/// are primarily used for virtual machine clustering, but they are
4489/// generally insecure and should not be used. Due to better performance
4490/// and security properties, the use of the 'preallocated' format is
4491/// preferred over this format.
4492#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
4493pub enum VirtualDiskTypeEnum {
4494 #[serde(rename = "preallocated")]
4495 #[strum(serialize = "preallocated")]
4496 Preallocated,
4497 #[serde(rename = "thin")]
4498 #[strum(serialize = "thin")]
4499 Thin,
4500 #[serde(rename = "seSparse")]
4501 #[strum(serialize = "seSparse")]
4502 SeSparse,
4503 #[serde(rename = "rdm")]
4504 #[strum(serialize = "rdm")]
4505 Rdm,
4506 #[serde(rename = "rdmp")]
4507 #[strum(serialize = "rdmp")]
4508 Rdmp,
4509 #[serde(rename = "raw")]
4510 #[strum(serialize = "raw")]
4511 Raw,
4512 #[serde(rename = "delta")]
4513 #[strum(serialize = "delta")]
4514 Delta,
4515 #[serde(rename = "sparse2Gb")]
4516 #[strum(serialize = "sparse2Gb")]
4517 Sparse2Gb,
4518 #[serde(rename = "thick2Gb")]
4519 #[strum(serialize = "thick2Gb")]
4520 Thick2Gb,
4521 #[serde(rename = "eagerZeroedThick")]
4522 #[strum(serialize = "eagerZeroedThick")]
4523 EagerZeroedThick,
4524 #[serde(rename = "sparseMonolithic")]
4525 #[strum(serialize = "sparseMonolithic")]
4526 SparseMonolithic,
4527 #[serde(rename = "flatMonolithic")]
4528 #[strum(serialize = "flatMonolithic")]
4529 FlatMonolithic,
4530 #[serde(rename = "thick")]
4531 #[strum(serialize = "thick")]
4532 Thick,
4533 /// This variant handles values not known at compile time.
4534 #[serde(untagged)]
4535 #[strum(serialize = "__OTHER__")]
4536 Other_(String),
4537}
4538/// Application heartbeat status type.
4539///
4540/// Possible values:
4541/// - `appStatusGray`: Heartbeat status is disabled
4542/// - `appStatusGreen`: Heartbeat status is OK
4543/// - `appStatusRed`: Heartbeating has stopped
4544#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
4545pub enum VirtualMachineAppHeartbeatStatusTypeEnum {
4546 #[serde(rename = "appStatusGray")]
4547 #[strum(serialize = "appStatusGray")]
4548 AppStatusGray,
4549 #[serde(rename = "appStatusGreen")]
4550 #[strum(serialize = "appStatusGreen")]
4551 AppStatusGreen,
4552 #[serde(rename = "appStatusRed")]
4553 #[strum(serialize = "appStatusRed")]
4554 AppStatusRed,
4555 /// This variant handles values not known at compile time.
4556 #[serde(untagged)]
4557 #[strum(serialize = "__OTHER__")]
4558 Other_(String),
4559}
4560/// The connectivity state of a virtual machine.
4561///
4562/// When the API is provided directly by
4563/// a server product, such as ESX Server, then the disconnected state is not
4564/// possible. However, when accessed through VirtualCenter, the state of a virtual
4565/// machine is set to disconnected if the hosts that manage the virtual
4566/// machine becomes unavailable.
4567///
4568/// Possible values:
4569/// - `connected`: The server has access to the virtual machine.
4570/// - `disconnected`: The server is currently disconnected from the virtual machine, since its
4571/// host is disconnected.
4572///
4573/// See general comment for this enumerated type for more
4574/// details.
4575/// - `orphaned`: The virtual machine is no longer registered on the host it is associated
4576/// with.
4577///
4578/// For example, a virtual machine that is unregistered or deleted
4579/// directly on a host managed by VirtualCenter shows up in this state.
4580/// - `inaccessible`: One or more of the virtual machine configuration files are inaccessible.
4581///
4582/// For
4583/// example, this can be due to transient disk failures. In this case, no
4584/// configuration can be returned for a virtual machine.
4585/// - `invalid`: The virtual machine configuration format is invalid.
4586///
4587/// Thus, it is accessible
4588/// on disk, but corrupted in a way that does not allow the server to read the
4589/// content. In this case, no configuration can be returned for a virtual
4590/// machine.
4591#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
4592pub enum VirtualMachineConnectionStateEnum {
4593 #[serde(rename = "connected")]
4594 #[strum(serialize = "connected")]
4595 Connected,
4596 #[serde(rename = "disconnected")]
4597 #[strum(serialize = "disconnected")]
4598 Disconnected,
4599 #[serde(rename = "orphaned")]
4600 #[strum(serialize = "orphaned")]
4601 Orphaned,
4602 #[serde(rename = "inaccessible")]
4603 #[strum(serialize = "inaccessible")]
4604 Inaccessible,
4605 #[serde(rename = "invalid")]
4606 #[strum(serialize = "invalid")]
4607 Invalid,
4608 /// This variant handles values not known at compile time.
4609 #[serde(untagged)]
4610 #[strum(serialize = "__OTHER__")]
4611 Other_(String),
4612}
4613/// The crypto state of a encrypted virtual machine.
4614///
4615/// Possible values:
4616/// - `unlocked`: The virtual machine is in unlocked state.
4617/// - `locked`: The virtual machine is in locked state for the configuration key missing
4618/// on the ESX host where the VM is registered.
4619#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
4620pub enum VirtualMachineCryptoStateEnum {
4621 #[serde(rename = "unlocked")]
4622 #[strum(serialize = "unlocked")]
4623 Unlocked,
4624 #[serde(rename = "locked")]
4625 #[strum(serialize = "locked")]
4626 Locked,
4627 /// This variant handles values not known at compile time.
4628 #[serde(untagged)]
4629 #[strum(serialize = "__OTHER__")]
4630 Other_(String),
4631}
4632/// The FaultToleranceState type defines a simple set of states for a
4633/// fault tolerant virtual machine:
4634/// disabled, starting, and enabled.
4635///
4636/// Possible values:
4637/// - `notConfigured`: This state indicates that the virtual machine has not been
4638/// configured for fault tolerance.
4639/// - `disabled`: For a virtual machine that is the primary in a fault tolerant group,
4640/// this state indicates that the virtual machine has at least one
4641/// registered secondary, but no secondary is enabled.
4642///
4643/// For a virtual machine that is the secondary in a fault tolerant
4644/// group, this state indicates that the secondary is disabled.
4645/// - `enabled`: For a virtual machine that is the primary in a fault tolerant group,
4646/// this state indicates that the virtual machine is not currently
4647/// powered on, but has at least one enabled secondary
4648/// For a virtual machine that is the secondary in a fault tolerant
4649/// group, this state indicates that the secondary is enabled, but is
4650/// not currently powered on.
4651/// - `needSecondary`: For a virtual machine that is the primary in a fault tolerant group,
4652/// this state indicates that the virtual machine is powered on and
4653/// has at least one enabled secondary, but no secondary is currently
4654/// active.
4655///
4656/// This state is not valid for a virtual machine that is a secondary
4657/// in a fault tolerant group.
4658/// - `starting`: For a virtual machine that is the primary in a fault tolerant group,
4659/// this state indicates that the virtual machine is powered on and has
4660/// at least one secondary that is synchronizing its state with the
4661/// primary.
4662///
4663/// For a virtual machine that is the secondary in a fault tolerant
4664/// group, this state indicates that the secondary is powered on and is
4665/// synchronizing its state with the primary virtual machine.
4666/// - `running`: This state indicates that the virtual machine is running with fault
4667/// tolerance protection.
4668#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
4669pub enum VirtualMachineFaultToleranceStateEnum {
4670 #[serde(rename = "notConfigured")]
4671 #[strum(serialize = "notConfigured")]
4672 NotConfigured,
4673 #[serde(rename = "disabled")]
4674 #[strum(serialize = "disabled")]
4675 Disabled,
4676 #[serde(rename = "enabled")]
4677 #[strum(serialize = "enabled")]
4678 Enabled,
4679 #[serde(rename = "needSecondary")]
4680 #[strum(serialize = "needSecondary")]
4681 NeedSecondary,
4682 #[serde(rename = "starting")]
4683 #[strum(serialize = "starting")]
4684 Starting,
4685 #[serde(rename = "running")]
4686 #[strum(serialize = "running")]
4687 Running,
4688 /// This variant handles values not known at compile time.
4689 #[serde(untagged)]
4690 #[strum(serialize = "__OTHER__")]
4691 Other_(String),
4692}
4693/// The FaultToleranceType defines the type of fault tolerance, if any,
4694/// the virtual machine is configured for.
4695///
4696/// Possible values:
4697/// - `unset`: FT not set
4698/// - `recordReplay`: Record/replay
4699/// - `checkpointing`: Checkpointing
4700#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
4701pub enum VirtualMachineFaultToleranceTypeEnum {
4702 #[serde(rename = "unset")]
4703 #[strum(serialize = "unset")]
4704 Unset,
4705 #[serde(rename = "recordReplay")]
4706 #[strum(serialize = "recordReplay")]
4707 RecordReplay,
4708 #[serde(rename = "checkpointing")]
4709 #[strum(serialize = "checkpointing")]
4710 Checkpointing,
4711 /// This variant handles values not known at compile time.
4712 #[serde(untagged)]
4713 #[strum(serialize = "__OTHER__")]
4714 Other_(String),
4715}
4716/// MovePriority is an enumeration of values that indicate the priority of the task
4717/// that moves a virtual machine from one host to another or one storage location
4718/// to another.
4719///
4720/// Note this priority can affect both the source and target hosts.
4721///
4722/// Possible values:
4723/// - `lowPriority`: The task of moving this virtual machine is low priority.
4724/// - `highPriority`: The task of moving this virtual machine is high priority.
4725/// - `defaultPriority`: The task of moving this virtual machine is the default priority.
4726#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
4727pub enum VirtualMachineMovePriorityEnum {
4728 #[serde(rename = "lowPriority")]
4729 #[strum(serialize = "lowPriority")]
4730 LowPriority,
4731 #[serde(rename = "highPriority")]
4732 #[strum(serialize = "highPriority")]
4733 HighPriority,
4734 #[serde(rename = "defaultPriority")]
4735 #[strum(serialize = "defaultPriority")]
4736 DefaultPriority,
4737 /// This variant handles values not known at compile time.
4738 #[serde(untagged)]
4739 #[strum(serialize = "__OTHER__")]
4740 Other_(String),
4741}
4742/// The NeedSecondaryReason type defines all reasons a virtual machine is
4743/// in the needSecondary Fault Tolerance state following a failure.
4744///
4745/// Possible values:
4746/// - `initializing`: Initializing FT
4747/// - `divergence`: Divergence
4748/// - `lostConnection`: Lose connection to secondary
4749/// - `partialHardwareFailure`: Partial hardware failure
4750/// - `userAction`: Terminated by user
4751/// - `checkpointError`: Checkpoint error
4752/// - `other`: All other reasons
4753#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
4754pub enum VirtualMachineNeedSecondaryReasonEnum {
4755 #[serde(rename = "initializing")]
4756 #[strum(serialize = "initializing")]
4757 Initializing,
4758 #[serde(rename = "divergence")]
4759 #[strum(serialize = "divergence")]
4760 Divergence,
4761 #[serde(rename = "lostConnection")]
4762 #[strum(serialize = "lostConnection")]
4763 LostConnection,
4764 #[serde(rename = "partialHardwareFailure")]
4765 #[strum(serialize = "partialHardwareFailure")]
4766 PartialHardwareFailure,
4767 #[serde(rename = "userAction")]
4768 #[strum(serialize = "userAction")]
4769 UserAction,
4770 #[serde(rename = "checkpointError")]
4771 #[strum(serialize = "checkpointError")]
4772 CheckpointError,
4773 #[serde(rename = "other")]
4774 #[strum(serialize = "other")]
4775 Other,
4776 /// This variant handles values not known at compile time.
4777 #[serde(untagged)]
4778 #[strum(serialize = "__OTHER__")]
4779 Other_(String),
4780}
4781/// The PowerState type defines a simple set of states for a virtual machine:
4782/// poweredOn, poweredOff, and suspended.
4783///
4784/// This type does not model substates,
4785/// such as when a task is running to change the virtual machine state.
4786/// If the virtual machine is in a state with a task in progress, it
4787/// transitions to a new state when the task completes. For example, a virtual
4788/// machine continues to be in the poweredOn state while a suspend task
4789/// is running, and changes to the suspended state once the task finishes.
4790///
4791/// As a consequence of this approach, clients interested in monitoring
4792/// the status of a virtual machine should typically track the
4793/// *activeTask* data object in addition to the
4794/// *powerState* object.
4795///
4796/// Possible values:
4797/// - `poweredOff`: The virtual machine is currently powered off.
4798/// - `poweredOn`: The virtual machine is currently powered on.
4799/// - `suspended`: The virtual machine is currently suspended.
4800#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
4801pub enum VirtualMachinePowerStateEnum {
4802 #[serde(rename = "poweredOff")]
4803 #[strum(serialize = "poweredOff")]
4804 PoweredOff,
4805 #[serde(rename = "poweredOn")]
4806 #[strum(serialize = "poweredOn")]
4807 PoweredOn,
4808 #[serde(rename = "suspended")]
4809 #[strum(serialize = "suspended")]
4810 Suspended,
4811 /// This variant handles values not known at compile time.
4812 #[serde(untagged)]
4813 #[strum(serialize = "__OTHER__")]
4814 Other_(String),
4815}
4816/// Deprecated as of vSphere API 6.0.
4817///
4818/// The RecordReplayState type defines a simple set of record and replay
4819/// states for a virtual machine.
4820///
4821/// Possible values:
4822/// - `recording`: The virtual machine is recording.
4823/// - `replaying`: The virtual machine is replaying.
4824/// - `inactive`: The virtual machine is currently not participating
4825/// in record or replay.
4826#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
4827pub enum VirtualMachineRecordReplayStateEnum {
4828 #[serde(rename = "recording")]
4829 #[strum(serialize = "recording")]
4830 Recording,
4831 #[serde(rename = "replaying")]
4832 #[strum(serialize = "replaying")]
4833 Replaying,
4834 #[serde(rename = "inactive")]
4835 #[strum(serialize = "inactive")]
4836 Inactive,
4837 /// This variant handles values not known at compile time.
4838 #[serde(untagged)]
4839 #[strum(serialize = "__OTHER__")]
4840 Other_(String),
4841}
4842/// The virtual machine ticket type.
4843///
4844/// Possible values:
4845/// - `mks`:
4846///
4847/// Deprecated as of vSphere API 8.0. Use *webmks* instead.
4848///
4849/// Remote mouse-keyboard-screen ticket.
4850/// - `device`:
4851///
4852/// Deprecated as of vSphere 8.0 API. Use *webRemoteDevice*
4853/// instead.
4854///
4855/// Remote device ticket.
4856/// - `guestControl`:
4857///
4858/// Deprecated as of vSphere 6.6.3 API. Use
4859/// *GuestOperationsManager* instead.
4860///
4861/// Guest operation ticket.
4862/// - `webmks`: Mouse-keyboard-screen over WebSocket ticket.
4863///
4864/// MKS protocol is VNC (a.k.a. RFB) protocol with
4865/// VMware extensions; the protocol gracefully degrades
4866/// to standard VNC if extensions are not available.
4867/// wss://{Ticket.host}/ticket/{Ticket.ticket}
4868/// - `guestIntegrity`: Guest Integrity over WebSocket ticket.
4869///
4870/// This ticket grants the client read-only access to guest integrity
4871/// messages and alerts.
4872/// - `webRemoteDevice`: Remote device over WebSocket ticket.
4873#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
4874pub enum VirtualMachineTicketTypeEnum {
4875 #[serde(rename = "mks")]
4876 #[strum(serialize = "mks")]
4877 Mks,
4878 #[serde(rename = "device")]
4879 #[strum(serialize = "device")]
4880 Device,
4881 #[serde(rename = "guestControl")]
4882 #[strum(serialize = "guestControl")]
4883 GuestControl,
4884 #[serde(rename = "webmks")]
4885 #[strum(serialize = "webmks")]
4886 Webmks,
4887 #[serde(rename = "guestIntegrity")]
4888 #[strum(serialize = "guestIntegrity")]
4889 GuestIntegrity,
4890 #[serde(rename = "webRemoteDevice")]
4891 #[strum(serialize = "webRemoteDevice")]
4892 WebRemoteDevice,
4893 /// This variant handles values not known at compile time.
4894 #[serde(untagged)]
4895 #[strum(serialize = "__OTHER__")]
4896 Other_(String),
4897}
4898/// Defines the set operators that can be used to join the sets identified by nested
4899/// constraints in a *VsanCompositeConstraint* instance.
4900///
4901/// Possible values:
4902/// - `AND`: joins multiple VsanResourceConstraint with AND
4903/// - `OR`: joins multiple VsanResourceConstraint with OR
4904/// - `EXCEPT`: negate with multiple VsanResourceConstraint
4905/// - `VsanCompositeConstraintConjoinerEnum_Unknown`
4906#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
4907pub enum VsanCompositeConstraintConjoinerEnumEnum {
4908 #[serde(rename = "AND")]
4909 #[strum(serialize = "AND")]
4910 And,
4911 #[serde(rename = "OR")]
4912 #[strum(serialize = "OR")]
4913 Or,
4914 #[serde(rename = "EXCEPT")]
4915 #[strum(serialize = "EXCEPT")]
4916 Except,
4917 #[serde(rename = "VsanCompositeConstraintConjoinerEnum_Unknown")]
4918 #[strum(serialize = "VsanCompositeConstraintConjoinerEnum_Unknown")]
4919 VsanCompositeConstraintConjoinerEnumUnknown,
4920 /// This variant handles values not known at compile time.
4921 #[serde(untagged)]
4922 #[strum(serialize = "__OTHER__")]
4923 Other_(String),
4924}
4925/// Enumerate the choice for specify the target ManagedObject.
4926///
4927/// It can be one of
4928/// the following:
4929///
4930/// Possible values:
4931/// - `ALL_HOSTS`: Retrieve properties for all HostSystem objects
4932/// - `ALL_VSAN_ENABLED_HOSTS`: Retrieve properties for all vSAN enabled HostSystem objects
4933/// - `ALL_CLUSTERS`: Retrieve properties for all ClusterComputeResource objects
4934/// - `ALL_VSAN_ENABLED_CLUSTERS`: Retrieve properties for all vSAN enabled ClusterComputeResource objects
4935/// - `VCENTER`: Retrieve properties for vCenter level objects like tasks, events etc
4936/// - `SERVICE_INSTANCE`: Retrieve properties for service content, such as vCenter instanceUuid, build number etc
4937/// - `ALL_VSAN_ENABLED_HOSTS_EXCEPT_WITNESS`: Retrieve properties for all vSAN enabled HostSystem objects except witness hosts
4938/// - `ALL_DATASTORES`
4939/// - `ALL_VSAN_DATASTORES`
4940/// - `ALL_VMFS_DATASTORES`
4941/// - `VsanMassCollectorObjectCollectionEnum_Unknown`
4942#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
4943pub enum VsanMassCollectorObjectCollectionEnumEnum {
4944 #[serde(rename = "ALL_HOSTS")]
4945 #[strum(serialize = "ALL_HOSTS")]
4946 AllHosts,
4947 #[serde(rename = "ALL_VSAN_ENABLED_HOSTS")]
4948 #[strum(serialize = "ALL_VSAN_ENABLED_HOSTS")]
4949 AllVsanEnabledHosts,
4950 #[serde(rename = "ALL_CLUSTERS")]
4951 #[strum(serialize = "ALL_CLUSTERS")]
4952 AllClusters,
4953 #[serde(rename = "ALL_VSAN_ENABLED_CLUSTERS")]
4954 #[strum(serialize = "ALL_VSAN_ENABLED_CLUSTERS")]
4955 AllVsanEnabledClusters,
4956 #[serde(rename = "VCENTER")]
4957 #[strum(serialize = "VCENTER")]
4958 Vcenter,
4959 #[serde(rename = "SERVICE_INSTANCE")]
4960 #[strum(serialize = "SERVICE_INSTANCE")]
4961 ServiceInstance,
4962 #[serde(rename = "ALL_VSAN_ENABLED_HOSTS_EXCEPT_WITNESS")]
4963 #[strum(serialize = "ALL_VSAN_ENABLED_HOSTS_EXCEPT_WITNESS")]
4964 AllVsanEnabledHostsExceptWitness,
4965 #[serde(rename = "ALL_DATASTORES")]
4966 #[strum(serialize = "ALL_DATASTORES")]
4967 AllDatastores,
4968 #[serde(rename = "ALL_VSAN_DATASTORES")]
4969 #[strum(serialize = "ALL_VSAN_DATASTORES")]
4970 AllVsanDatastores,
4971 #[serde(rename = "ALL_VMFS_DATASTORES")]
4972 #[strum(serialize = "ALL_VMFS_DATASTORES")]
4973 AllVmfsDatastores,
4974 #[serde(rename = "VsanMassCollectorObjectCollectionEnum_Unknown")]
4975 #[strum(serialize = "VsanMassCollectorObjectCollectionEnum_Unknown")]
4976 VsanMassCollectorObjectCollectionEnumUnknown,
4977 /// This variant handles values not known at compile time.
4978 #[serde(untagged)]
4979 #[strum(serialize = "__OTHER__")]
4980 Other_(String),
4981}
4982/// Defines the possible operators to use for comparison of the resource
4983/// model properties.
4984///
4985/// Possible values:
4986/// - `EQUALS`: Check for equality of values
4987/// - `GREATER`: Filters values if greater than specified constraint value.
4988/// - `SMALLER`: Filters values if smaller than specified constraint value.
4989/// - `POP`
4990/// - `CONTAINS`: Matches value to check if it contains the specified constraint value.
4991/// - `TEXTUALLY_MATCHES`: Uses Python regex re.match() function.
4992/// - `VsanPropertyConstraintComparatorEnum_Unknown`
4993#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
4994pub enum VsanPropertyConstraintComparatorEnumEnum {
4995 #[serde(rename = "EQUALS")]
4996 #[strum(serialize = "EQUALS")]
4997 Equals,
4998 #[serde(rename = "GREATER")]
4999 #[strum(serialize = "GREATER")]
5000 Greater,
5001 #[serde(rename = "SMALLER")]
5002 #[strum(serialize = "SMALLER")]
5003 Smaller,
5004 #[serde(rename = "POP")]
5005 #[strum(serialize = "POP")]
5006 Pop,
5007 #[serde(rename = "CONTAINS")]
5008 #[strum(serialize = "CONTAINS")]
5009 Contains,
5010 #[serde(rename = "TEXTUALLY_MATCHES")]
5011 #[strum(serialize = "TEXTUALLY_MATCHES")]
5012 TextuallyMatches,
5013 #[serde(rename = "VsanPropertyConstraintComparatorEnum_Unknown")]
5014 #[strum(serialize = "VsanPropertyConstraintComparatorEnum_Unknown")]
5015 VsanPropertyConstraintComparatorEnumUnknown,
5016 /// This variant handles values not known at compile time.
5017 #[serde(untagged)]
5018 #[strum(serialize = "__OTHER__")]
5019 Other_(String),
5020}
5021/// Type of disk group operation performed.
5022///
5023/// Possible values:
5024/// - `add`: Disk group is being (re-)added.
5025/// - `remove`: Disk group is being removed.
5026#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
5027pub enum VsanUpgradeSystemUpgradeHistoryDiskGroupOpTypeEnum {
5028 #[serde(rename = "add")]
5029 #[strum(serialize = "add")]
5030 Add,
5031 #[serde(rename = "remove")]
5032 #[strum(serialize = "remove")]
5033 Remove,
5034 /// This variant handles values not known at compile time.
5035 #[serde(untagged)]
5036 #[strum(serialize = "__OTHER__")]
5037 Other_(String),
5038}
5039/// These constant strings can be used as parameters in user-specified
5040/// email subject and body templates as well as in scripts.
5041///
5042/// The action processor
5043/// in VirtualCenter substitutes the run-time values for the parameters.
5044/// For example, an email subject provided by the client could be the string:
5045/// `Alarm - {alarmName} Description:\n{eventDescription}`.
5046/// Or a script action provided could be: `myScript {alarmName}`.
5047///
5048/// Possible values:
5049/// - `targetName`: The name of the entity where the alarm is triggered.
5050/// - `alarmName`: The name of the triggering alarm.
5051/// - `oldStatus`: The status prior to the alarm being triggered.
5052/// - `newStatus`: The status after the alarm is triggered.
5053/// - `triggeringSummary`: A summary of information involved in triggering the alarm.
5054/// - `declaringSummary`: A summary of declarations made during the triggering of the alarm.
5055/// - `eventDescription`: The event description.
5056/// - `target`: The object of the entity where the alarm is associated.
5057/// - `alarm`: The object of the triggering alarm.
5058#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
5059pub enum ActionParameterEnum {
5060 #[serde(rename = "targetName")]
5061 #[strum(serialize = "targetName")]
5062 TargetName,
5063 #[serde(rename = "alarmName")]
5064 #[strum(serialize = "alarmName")]
5065 AlarmName,
5066 #[serde(rename = "oldStatus")]
5067 #[strum(serialize = "oldStatus")]
5068 OldStatus,
5069 #[serde(rename = "newStatus")]
5070 #[strum(serialize = "newStatus")]
5071 NewStatus,
5072 #[serde(rename = "triggeringSummary")]
5073 #[strum(serialize = "triggeringSummary")]
5074 TriggeringSummary,
5075 #[serde(rename = "declaringSummary")]
5076 #[strum(serialize = "declaringSummary")]
5077 DeclaringSummary,
5078 #[serde(rename = "eventDescription")]
5079 #[strum(serialize = "eventDescription")]
5080 EventDescription,
5081 #[serde(rename = "target")]
5082 #[strum(serialize = "target")]
5083 Target,
5084 #[serde(rename = "alarm")]
5085 #[strum(serialize = "alarm")]
5086 Alarm,
5087 /// This variant handles values not known at compile time.
5088 #[serde(untagged)]
5089 #[strum(serialize = "__OTHER__")]
5090 Other_(String),
5091}
5092/// Alarm entity type
5093///
5094/// Possible values:
5095/// - `entityTypeAll`: Alarms on all entity types.
5096/// - `entityTypeHost`: Host alarms
5097/// - `entityTypeVm`: VM alarms
5098#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
5099pub enum AlarmFilterSpecAlarmTypeByEntityEnum {
5100 #[serde(rename = "entityTypeAll")]
5101 #[strum(serialize = "entityTypeAll")]
5102 EntityTypeAll,
5103 #[serde(rename = "entityTypeHost")]
5104 #[strum(serialize = "entityTypeHost")]
5105 EntityTypeHost,
5106 #[serde(rename = "entityTypeVm")]
5107 #[strum(serialize = "entityTypeVm")]
5108 EntityTypeVm,
5109 /// This variant handles values not known at compile time.
5110 #[serde(untagged)]
5111 #[strum(serialize = "__OTHER__")]
5112 Other_(String),
5113}
5114/// Alarm triggering type.
5115///
5116/// The main divisions are event triggered and
5117/// metric- or state-based alarms.
5118///
5119/// Possible values:
5120/// - `triggerTypeAll`: All alarm types.
5121/// - `triggerTypeEvent`: Event based alarms
5122/// - `triggerTypeMetric`: Metric or state alarms
5123#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
5124pub enum AlarmFilterSpecAlarmTypeByTriggerEnum {
5125 #[serde(rename = "triggerTypeAll")]
5126 #[strum(serialize = "triggerTypeAll")]
5127 TriggerTypeAll,
5128 #[serde(rename = "triggerTypeEvent")]
5129 #[strum(serialize = "triggerTypeEvent")]
5130 TriggerTypeEvent,
5131 #[serde(rename = "triggerTypeMetric")]
5132 #[strum(serialize = "triggerTypeMetric")]
5133 TriggerTypeMetric,
5134 /// This variant handles values not known at compile time.
5135 #[serde(untagged)]
5136 #[strum(serialize = "__OTHER__")]
5137 Other_(String),
5138}
5139/// Basic Comparison operators
5140///
5141/// Possible values:
5142/// - `equals`: attribute equals specified value
5143/// - `notEqualTo`: attribute does not equal specified value
5144/// - `startsWith`: attribute starts with specified value
5145/// - `doesNotStartWith`: attribute does not start with specified value
5146/// - `endsWith`: attribute ends with specified value
5147/// - `doesNotEndWith`: attribute does not end with specified value
5148#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
5149pub enum EventAlarmExpressionComparisonOperatorEnum {
5150 #[serde(rename = "equals")]
5151 #[strum(serialize = "equals")]
5152 Equals,
5153 #[serde(rename = "notEqualTo")]
5154 #[strum(serialize = "notEqualTo")]
5155 NotEqualTo,
5156 #[serde(rename = "startsWith")]
5157 #[strum(serialize = "startsWith")]
5158 StartsWith,
5159 #[serde(rename = "doesNotStartWith")]
5160 #[strum(serialize = "doesNotStartWith")]
5161 DoesNotStartWith,
5162 #[serde(rename = "endsWith")]
5163 #[strum(serialize = "endsWith")]
5164 EndsWith,
5165 #[serde(rename = "doesNotEndWith")]
5166 #[strum(serialize = "doesNotEndWith")]
5167 DoesNotEndWith,
5168 /// This variant handles values not known at compile time.
5169 #[serde(untagged)]
5170 #[strum(serialize = "__OTHER__")]
5171 Other_(String),
5172}
5173/// The operation on the target metric item.
5174///
5175/// Possible values:
5176/// - `isAbove`: Test if the target metric item is above the given red or yellow values.
5177/// - `isBelow`: Test if the target metric item is below the given red or yellow values.
5178#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
5179pub enum MetricAlarmOperatorEnum {
5180 #[serde(rename = "isAbove")]
5181 #[strum(serialize = "isAbove")]
5182 IsAbove,
5183 #[serde(rename = "isBelow")]
5184 #[strum(serialize = "isBelow")]
5185 IsBelow,
5186 /// This variant handles values not known at compile time.
5187 #[serde(untagged)]
5188 #[strum(serialize = "__OTHER__")]
5189 Other_(String),
5190}
5191/// The operation on the target state.
5192///
5193/// Possible values:
5194/// - `isEqual`: Test if the target state matches the given red or yellow states.
5195/// - `isUnequal`: Test if the target state does not match the given red or yellow states.
5196#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
5197pub enum StateAlarmOperatorEnum {
5198 #[serde(rename = "isEqual")]
5199 #[strum(serialize = "isEqual")]
5200 IsEqual,
5201 #[serde(rename = "isUnequal")]
5202 #[strum(serialize = "isUnequal")]
5203 IsUnequal,
5204 /// This variant handles values not known at compile time.
5205 #[serde(untagged)]
5206 #[strum(serialize = "__OTHER__")]
5207 Other_(String),
5208}
5209/// Pre-defined constants for possible action types.
5210///
5211/// Virtual Center
5212/// uses this information to coordinate with the clients.
5213///
5214/// Possible values:
5215/// - `MigrationV1`: Migration action type
5216/// - `VmPowerV1`: Virtual machine power action type
5217/// - `HostPowerV1`: Host power action type
5218/// - `HostMaintenanceV1`: Host entering maintenance mode action type
5219/// - `StorageMigrationV1`: Storage migration action type
5220/// - `StoragePlacementV1`: Initial placement action for a virtual machine or a virtual disk
5221/// - `PlacementV1`: Initial placement action for a virtual machine and its virtual disks
5222/// - `HostInfraUpdateHaV1`: Host changing infrastructure update ha mode action type.
5223#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
5224pub enum ActionTypeEnum {
5225 MigrationV1,
5226 VmPowerV1,
5227 HostPowerV1,
5228 HostMaintenanceV1,
5229 StorageMigrationV1,
5230 StoragePlacementV1,
5231 PlacementV1,
5232 HostInfraUpdateHaV1,
5233 /// This variant handles values not known at compile time.
5234 #[serde(untagged)]
5235 #[strum(serialize = "__OTHER__")]
5236 Other_(String),
5237}
5238/// Defines the detailed cluster wide power action.
5239///
5240/// Possible values:
5241/// - `clusterPoweredOn`: indicate the cluster is in running state.
5242/// - `haDisabled`: vSphere HA is disabled.
5243/// - `supportedVMsPoweredOff`: the supported system VMs are powered off.
5244/// - `vcVMPoweredOff`: power off the VC VM if the VC VM is on vSAN.
5245/// - `vsanMemberShipUpdateDisabled`: vSAN membership updates is disabled.
5246/// - `vsanDOMPauseAllCCPsSet`: DOMPauseAllCCPs is set.
5247/// - `hostsInMM`: all hosts are in maintenance mode.
5248/// - `hostsPoweredOff`: power-off operations have been triggered on all hosts.
5249/// - `clusterPoweredOff`: indicate the cluster is in shutdown state.
5250/// - `hostsOutOfMM`: all hosts are out of maintenance mode.
5251/// - `vsanMemberShipUpdateEnabled`: vSAN membership updates is enabled.
5252/// - `vsanDOMPauseAllCCPsUnset`: DOMPauseAllCCPs is unset.
5253/// - `vcVMPoweredOn`: power on the VC VMs if it the VC VM is on vSAN.
5254/// - `supportedVMsPoweredOn`: the supported system VMs are powered on.
5255/// - `haEnabled`: vSphere HA is enabled.
5256/// - `infraVMsRecorded`
5257/// - `hostsInfraVMsPoweredoff`
5258/// - `hostsInfraVMsPoweredon`
5259/// - `ClusterPowerStatus_Unknown`: represent the value when the lower version client cannot recognize the enum value.
5260#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
5261pub enum ClusterPowerStatusEnum {
5262 #[serde(rename = "clusterPoweredOn")]
5263 #[strum(serialize = "clusterPoweredOn")]
5264 ClusterPoweredOn,
5265 #[serde(rename = "haDisabled")]
5266 #[strum(serialize = "haDisabled")]
5267 HaDisabled,
5268 #[serde(rename = "supportedVMsPoweredOff")]
5269 #[strum(serialize = "supportedVMsPoweredOff")]
5270 SupportedVMsPoweredOff,
5271 #[serde(rename = "vcVMPoweredOff")]
5272 #[strum(serialize = "vcVMPoweredOff")]
5273 VcVmPoweredOff,
5274 #[serde(rename = "vsanMemberShipUpdateDisabled")]
5275 #[strum(serialize = "vsanMemberShipUpdateDisabled")]
5276 VsanMemberShipUpdateDisabled,
5277 #[serde(rename = "vsanDOMPauseAllCCPsSet")]
5278 #[strum(serialize = "vsanDOMPauseAllCCPsSet")]
5279 VsanDomPauseAllCcPsSet,
5280 #[serde(rename = "hostsInMM")]
5281 #[strum(serialize = "hostsInMM")]
5282 HostsInMm,
5283 #[serde(rename = "hostsPoweredOff")]
5284 #[strum(serialize = "hostsPoweredOff")]
5285 HostsPoweredOff,
5286 #[serde(rename = "clusterPoweredOff")]
5287 #[strum(serialize = "clusterPoweredOff")]
5288 ClusterPoweredOff,
5289 #[serde(rename = "hostsOutOfMM")]
5290 #[strum(serialize = "hostsOutOfMM")]
5291 HostsOutOfMm,
5292 #[serde(rename = "vsanMemberShipUpdateEnabled")]
5293 #[strum(serialize = "vsanMemberShipUpdateEnabled")]
5294 VsanMemberShipUpdateEnabled,
5295 #[serde(rename = "vsanDOMPauseAllCCPsUnset")]
5296 #[strum(serialize = "vsanDOMPauseAllCCPsUnset")]
5297 VsanDomPauseAllCcPsUnset,
5298 #[serde(rename = "vcVMPoweredOn")]
5299 #[strum(serialize = "vcVMPoweredOn")]
5300 VcVmPoweredOn,
5301 #[serde(rename = "supportedVMsPoweredOn")]
5302 #[strum(serialize = "supportedVMsPoweredOn")]
5303 SupportedVMsPoweredOn,
5304 #[serde(rename = "haEnabled")]
5305 #[strum(serialize = "haEnabled")]
5306 HaEnabled,
5307 #[serde(rename = "infraVMsRecorded")]
5308 #[strum(serialize = "infraVMsRecorded")]
5309 InfraVMsRecorded,
5310 #[serde(rename = "hostsInfraVMsPoweredoff")]
5311 #[strum(serialize = "hostsInfraVMsPoweredoff")]
5312 HostsInfraVMsPoweredoff,
5313 #[serde(rename = "hostsInfraVMsPoweredon")]
5314 #[strum(serialize = "hostsInfraVMsPoweredon")]
5315 HostsInfraVMsPoweredon,
5316 #[serde(rename = "ClusterPowerStatus_Unknown")]
5317 #[strum(serialize = "ClusterPowerStatus_Unknown")]
5318 ClusterPowerStatusUnknown,
5319 /// This variant handles values not known at compile time.
5320 #[serde(untagged)]
5321 #[strum(serialize = "__OTHER__")]
5322 Other_(String),
5323}
5324/// Possible values:
5325/// - `onDemand`: Put each host into the crypto safe state automatically when needed.
5326/// - `forceEnable`: Put each host into the crypto safe state immediately.
5327#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
5328pub enum ClusterCryptoConfigInfoCryptoModeEnum {
5329 #[serde(rename = "onDemand")]
5330 #[strum(serialize = "onDemand")]
5331 OnDemand,
5332 #[serde(rename = "forceEnable")]
5333 #[strum(serialize = "forceEnable")]
5334 ForceEnable,
5335 /// This variant handles values not known at compile time.
5336 #[serde(untagged)]
5337 #[strum(serialize = "__OTHER__")]
5338 Other_(String),
5339}
5340/// The *ClusterDasAamNodeStateDasState_enum* enumerated type defines
5341/// values for host HA configuration and runtime state properties
5342/// (*ClusterDasAamNodeState.configState* and
5343/// *ClusterDasAamNodeState.runtimeState*).
5344///
5345/// Possible values:
5346/// - `uninitialized`: HA has never been enabled on the the host.
5347/// - `initialized`: HA agents have been installed but are not running on the the host.
5348/// - `configuring`: HA configuration is in progress.
5349/// - `unconfiguring`: HA configuration is being removed.
5350/// - `running`: HA agent is running on this host.
5351/// - `error`: There is an error condition.
5352///
5353/// This can represent a configuration
5354/// error or a host agent runtime error.
5355/// - `agentShutdown`: The HA agent has been shut down.
5356/// - `nodeFailed`: The host is not reachable.
5357///
5358/// This can represent a host failure
5359/// or an isolated host.
5360#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
5361pub enum ClusterDasAamNodeStateDasStateEnum {
5362 #[serde(rename = "uninitialized")]
5363 #[strum(serialize = "uninitialized")]
5364 Uninitialized,
5365 #[serde(rename = "initialized")]
5366 #[strum(serialize = "initialized")]
5367 Initialized,
5368 #[serde(rename = "configuring")]
5369 #[strum(serialize = "configuring")]
5370 Configuring,
5371 #[serde(rename = "unconfiguring")]
5372 #[strum(serialize = "unconfiguring")]
5373 Unconfiguring,
5374 #[serde(rename = "running")]
5375 #[strum(serialize = "running")]
5376 Running,
5377 #[serde(rename = "error")]
5378 #[strum(serialize = "error")]
5379 Error,
5380 #[serde(rename = "agentShutdown")]
5381 #[strum(serialize = "agentShutdown")]
5382 AgentShutdown,
5383 #[serde(rename = "nodeFailed")]
5384 #[strum(serialize = "nodeFailed")]
5385 NodeFailed,
5386 /// This variant handles values not known at compile time.
5387 #[serde(untagged)]
5388 #[strum(serialize = "__OTHER__")]
5389 Other_(String),
5390}
5391/// The policy to determine the candidates from which vCenter Server can
5392/// choose heartbeat datastores.
5393///
5394/// Possible values:
5395/// - `userSelectedDs`: vCenter Server chooses heartbeat datastores from the set specified
5396/// by the user (see *ClusterDasConfigInfo.heartbeatDatastore*).
5397///
5398/// More specifically,
5399/// datastores not included in the set will not be chosen. Note that if
5400/// *ClusterDasConfigInfo.heartbeatDatastore* is empty, datastore heartbeating will
5401/// be disabled for HA.
5402/// - `allFeasibleDs`: vCenter Server chooses heartbeat datastores from all the feasible ones,
5403/// i.e., the datastores that are accessible to more than one host in
5404/// the cluster.
5405///
5406/// The choice will be made without giving preference to those
5407/// specified by the user (see *ClusterDasConfigInfo.heartbeatDatastore*).
5408/// - `allFeasibleDsWithUserPreference`: vCenter Server chooses heartbeat datastores from all the feasible ones
5409/// while giving preference to those specified by the user (see *ClusterDasConfigInfo.heartbeatDatastore*).
5410///
5411/// More specifically, the datastores not included in *ClusterDasConfigInfo.heartbeatDatastore* will be
5412/// chosen if and only if the specified ones are not sufficient.
5413#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
5414pub enum ClusterDasConfigInfoHbDatastoreCandidateEnum {
5415 #[serde(rename = "userSelectedDs")]
5416 #[strum(serialize = "userSelectedDs")]
5417 UserSelectedDs,
5418 #[serde(rename = "allFeasibleDs")]
5419 #[strum(serialize = "allFeasibleDs")]
5420 AllFeasibleDs,
5421 #[serde(rename = "allFeasibleDsWithUserPreference")]
5422 #[strum(serialize = "allFeasibleDsWithUserPreference")]
5423 AllFeasibleDsWithUserPreference,
5424 /// This variant handles values not known at compile time.
5425 #[serde(untagged)]
5426 #[strum(serialize = "__OTHER__")]
5427 Other_(String),
5428}
5429/// Possible states of an HA service.
5430///
5431/// All services support the
5432/// disabled and enabled states.
5433///
5434/// Possible values:
5435/// - `disabled`: HA service is disabled.
5436/// - `enabled`: HA service is enabled.
5437#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
5438pub enum ClusterDasConfigInfoServiceStateEnum {
5439 #[serde(rename = "disabled")]
5440 #[strum(serialize = "disabled")]
5441 Disabled,
5442 #[serde(rename = "enabled")]
5443 #[strum(serialize = "enabled")]
5444 Enabled,
5445 /// This variant handles values not known at compile time.
5446 #[serde(untagged)]
5447 #[strum(serialize = "__OTHER__")]
5448 Other_(String),
5449}
5450/// The *ClusterDasConfigInfoVmMonitoringState_enum* enum defines values that indicate
5451/// the state of Virtual Machine Health Monitoring.
5452///
5453/// Health Monitoring
5454/// uses the vmTools (guest) and application agent heartbeat modules.
5455/// You can configure HA to respond to heartbeat failures of either one
5456/// or both modules. You can also disable the HA response to heartbeat failures.
5457/// - To set the cluster default for health monitoring, use the
5458/// ClusterConfigSpecEx.dasConfig.*ClusterDasConfigInfo.vmMonitoring* property.
5459/// - To set health monitoring for a virtual machine, use the
5460/// ClusterConfigSpecEx.dasVmConfigSpec.info.dasSettings.*ClusterDasVmSettings.vmToolsMonitoringSettings* property.
5461/// - To retrieve the current state of health monitoring (cluster setting), use the
5462/// ClusterConfigInfoEx.dasConfig.*ClusterDasConfigInfo.vmMonitoring*
5463/// property.
5464/// - To retrieve the current state of health monitoring for a virtual machine, use the
5465/// ClusterConfigInfoEx.dasVmConfig\[\].dasSettings.vmToolsMonitoringSettings.*ClusterVmToolsMonitoringSettings.vmMonitoring*
5466/// property.
5467///
5468/// Possible values:
5469/// - `vmMonitoringDisabled`: Virtual machine health monitoring is disabled.
5470///
5471/// In this state,
5472/// HA response to guest and application heartbeat failures are disabled.
5473/// - `vmMonitoringOnly`: HA response to guest heartbeat failure is enabled.
5474///
5475/// To retrieve the guest heartbeat status, use the
5476/// *VirtualMachine*.*VirtualMachine.guestHeartbeatStatus*
5477/// property.
5478/// - `vmAndAppMonitoring`: HA response to both guest and application heartbeat failure is enabled.
5479/// - To retrieve the guest heartbeat status, use the
5480/// *VirtualMachine*.*VirtualMachine.guestHeartbeatStatus*
5481/// property.
5482/// - To retrieve the application heartbeat status, use the
5483/// *GuestInfo*.*GuestInfo.appHeartbeatStatus*
5484/// property.
5485#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
5486pub enum ClusterDasConfigInfoVmMonitoringStateEnum {
5487 #[serde(rename = "vmMonitoringDisabled")]
5488 #[strum(serialize = "vmMonitoringDisabled")]
5489 VmMonitoringDisabled,
5490 #[serde(rename = "vmMonitoringOnly")]
5491 #[strum(serialize = "vmMonitoringOnly")]
5492 VmMonitoringOnly,
5493 #[serde(rename = "vmAndAppMonitoring")]
5494 #[strum(serialize = "vmAndAppMonitoring")]
5495 VmAndAppMonitoring,
5496 /// This variant handles values not known at compile time.
5497 #[serde(untagged)]
5498 #[strum(serialize = "__OTHER__")]
5499 Other_(String),
5500}
5501/// The *ClusterDasFdmAvailabilityState_enum* enumeration describes the
5502/// availability states of hosts in a vSphere HA cluster.
5503///
5504/// In the HA
5505/// architecture, a agent called the Fault Domain Manager runs on
5506/// each active host. These agents elect a master and the others become
5507/// its slaves. The availability state assigned to a given host is
5508/// determined from information reported by the Fault Domain Manager
5509/// running on the host, by a Fault Domain Manager that has been elected
5510/// master, and by vCenter Server. See *ClusterDasFdmHostState*
5511/// for more information about the vSphere HA architecture.
5512///
5513/// Possible values:
5514/// - `uninitialized`: The Fault Domain Manager for the host has not yet been
5515/// initialized.
5516///
5517/// Hence the host is not part of a vSphere HA
5518/// fault domain. This state is reported by vCenter Server or
5519/// by the host itself.
5520/// - `election`: The Fault Domain Manager on the host has been initialized and
5521/// the host is either waiting to join the existing master or
5522/// is participating in an election for a new master.
5523///
5524/// This state
5525/// is reported by vCenter Server or by the host itself.
5526/// - `master`: The Fault Domain Manager on the host has been elected a
5527/// master.
5528///
5529/// This state is reported by the the host itself.
5530/// - `connectedToMaster`: The normal operating state for a slave host.
5531///
5532/// In this state,
5533/// the host is exchanging heartbeats with a master over
5534/// the management network, and is thus connected to it. If
5535/// there is a management network partition, the slave will be
5536/// in this state only if it is in the same partition as the master.
5537/// This state is reported by the master of a slave host.
5538/// - `networkPartitionedFromMaster`: A slave host is alive and has management network connectivity, but
5539/// the management network has been partitioned.
5540///
5541/// This state is reported
5542/// by masters that are in a partition other than the one containing the
5543/// slave host; the master in the slave's partition will report the slave state
5544/// as *connectedToMaster*.
5545/// - `networkIsolated`: A host is alive but is isolated from the management network.
5546///
5547/// See *ClusterDasVmSettingsIsolationResponse_enum* for the criteria
5548/// used to determine whether a host is isolated.
5549/// - `hostDown`: The slave host appears to be down.
5550///
5551/// This state is reported by the
5552/// master of a slave host.
5553/// - `initializationError`: An error occurred when initilizating the Fault Domain Manager
5554/// on a host due to a problem with installing the
5555/// agent or configuring it.
5556///
5557/// This condition can often be cleared by
5558/// reconfiguring HA for the host. This state is reported by vCenter
5559/// Server.
5560/// - `uninitializationError`: An error occurred when unconfiguring the Fault Domain Manager
5561/// running on a host.
5562///
5563/// In order to clear this condition the host might
5564/// need to be reconnected to the cluster and reconfigured first.
5565/// This state is reported by vCenter
5566/// Server.
5567/// - `fdmUnreachable`: The Fault Domain Manager (FDM) on the host cannot be reached.
5568///
5569/// This
5570/// state is reported in two unlikely situations.
5571/// - First, it is reported by
5572/// a master if the host responds to ICMP pings sent by the master over the
5573/// management network but the FDM on the host cannot be reached by the master.
5574/// This situation will occur if the FDM is unable to run or exit the
5575/// uninitialized state.
5576/// - Second, it is reported by vCenter Server if it cannot connect to a
5577/// master nor the FDM for the host. This situation would occur if all hosts
5578/// in the cluster failed but vCenter Server is still running. It may also
5579/// occur if all FDMs are unable to run or exit the uninitialized state.
5580/// - `retry`: Config/Reconfig/upgrade operation has failed in first attempt and
5581/// a retry of these operations is scheduled.
5582///
5583/// If any of the retry attempts succeed, the state is set to initialized.
5584/// If all retry attempts fail, the state is set to initializationError.
5585/// This state is reported by vCenter.
5586///
5587/// ***Since:*** vSphere API Release 8.0.0.0
5588#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
5589pub enum ClusterDasFdmAvailabilityStateEnum {
5590 #[serde(rename = "uninitialized")]
5591 #[strum(serialize = "uninitialized")]
5592 Uninitialized,
5593 #[serde(rename = "election")]
5594 #[strum(serialize = "election")]
5595 Election,
5596 #[serde(rename = "master")]
5597 #[strum(serialize = "master")]
5598 Master,
5599 #[serde(rename = "connectedToMaster")]
5600 #[strum(serialize = "connectedToMaster")]
5601 ConnectedToMaster,
5602 #[serde(rename = "networkPartitionedFromMaster")]
5603 #[strum(serialize = "networkPartitionedFromMaster")]
5604 NetworkPartitionedFromMaster,
5605 #[serde(rename = "networkIsolated")]
5606 #[strum(serialize = "networkIsolated")]
5607 NetworkIsolated,
5608 #[serde(rename = "hostDown")]
5609 #[strum(serialize = "hostDown")]
5610 HostDown,
5611 #[serde(rename = "initializationError")]
5612 #[strum(serialize = "initializationError")]
5613 InitializationError,
5614 #[serde(rename = "uninitializationError")]
5615 #[strum(serialize = "uninitializationError")]
5616 UninitializationError,
5617 #[serde(rename = "fdmUnreachable")]
5618 #[strum(serialize = "fdmUnreachable")]
5619 FdmUnreachable,
5620 #[serde(rename = "retry")]
5621 #[strum(serialize = "retry")]
5622 Retry,
5623 /// This variant handles values not known at compile time.
5624 #[serde(untagged)]
5625 #[strum(serialize = "__OTHER__")]
5626 Other_(String),
5627}
5628/// Deprecated as of VI API 2.5, use *ClusterDasVmSettingsRestartPriority_enum*.
5629///
5630/// The priority of the virtual machine determines the preference
5631/// given to it if sufficient capacity is not available to power
5632/// on all failed virtual machines.
5633///
5634/// For example, high priority
5635/// virtual machines on a host get preference over low priority
5636/// virtual machines.
5637///
5638/// Possible values:
5639/// - `disabled`: vSphere HA is disabled for this virtual machine.
5640/// - `low`: Virtual machines with this priority have a lower chance of powering on after a
5641/// failure if there is insufficient capacity on hosts to meet all virtual machine
5642/// needs.
5643/// - `medium`: Virtual machines with this priority have an intermediate chance of powering
5644/// on after a failure if there is insufficient capacity on hosts to meet all
5645/// virtual machine needs.
5646/// - `high`: Virtual machines with this priority have a higher chance of powering on after a
5647/// failure if there is insufficient capacity on hosts to meet all virtual machine
5648/// needs.
5649#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
5650pub enum DasVmPriorityEnum {
5651 #[serde(rename = "disabled")]
5652 #[strum(serialize = "disabled")]
5653 Disabled,
5654 #[serde(rename = "low")]
5655 #[strum(serialize = "low")]
5656 Low,
5657 #[serde(rename = "medium")]
5658 #[strum(serialize = "medium")]
5659 Medium,
5660 #[serde(rename = "high")]
5661 #[strum(serialize = "high")]
5662 High,
5663 /// This variant handles values not known at compile time.
5664 #[serde(untagged)]
5665 #[strum(serialize = "__OTHER__")]
5666 Other_(String),
5667}
5668/// The *ClusterDasVmSettingsIsolationResponse_enum* enum defines
5669/// values that indicate whether or not the virtual machine should be
5670/// powered off if a host determines that it is isolated from the rest of
5671/// the cluster.
5672///
5673/// Host network isolation occurs when a host is still running but it can no
5674/// longer communicate with other hosts in the cluster and it cannot ping
5675/// the configured isolation address(es). When the HA agent on a host loses
5676/// contact with the other hosts, it will ping the isolation addresses. If
5677/// the pings fail, the host will declare itself isolated.
5678///
5679/// Once the HA agent declares the host isolated, it will initiate the
5680/// isolation response workflow after a 30 second delay. You can use the FDM
5681/// advanced option fdm.isolationPolicyDelaySec to increase the delay. For
5682/// each virtual machine, the HA agent attempts to determine if a master is
5683/// responsible for restarting the virtual machine. If it cannot make the
5684/// determination, or there is a master that is responsible, the agent will
5685/// apply the configured isolation response. This workflow will continue
5686/// until the configuration policy, has been applied to all virtual
5687/// machines, the agent reconnects to another HA agent in the cluster, or
5688/// the isolation address pings start succeeding. If there is a master agent
5689/// in the cluster, it will attempt to restart the virtual machines that
5690/// were powered off during isolation.
5691///
5692/// By default, the isolated host leaves its virtual machines powered on.
5693/// You can override the isolation response default with a cluster-wide
5694/// setting (*ClusterDasConfigInfo.defaultVmSettings*)
5695/// or a virtual machine setting
5696/// (*ClusterDasVmSettings.isolationResponse*).
5697/// - All isolation response values are valid for the
5698/// *ClusterDasVmSettings.isolationResponse*
5699/// property specified in a single virtual machine HA configuration.
5700/// - All values except for <code>clusterIsolationResponse</code> are valid
5701/// for the cluster-wide default HA configuration for virtual machines
5702/// (*ClusterDasConfigInfo.defaultVmSettings*).
5703///
5704/// If you ensure that your network infrastructure is sufficiently redundant
5705/// and that at least one network path is available at all times, host network
5706/// isolation should be a rare occurrence.
5707///
5708/// Possible values:
5709/// - `none`: Do not power off the virtual machine in the event of a host network
5710/// isolation.
5711/// - `powerOff`: Power off the virtual machine in the event of a host network
5712/// isolation.
5713/// - `shutdown`: Shut down the virtual machine guest operating system in the event of
5714/// a host network isolation.
5715///
5716/// If the guest operating system fails to
5717/// shutdown within five minutes, HA will initiate a forced power off.
5718///
5719/// When you use the shutdown isolation response, failover can take
5720/// longer (compared to the
5721/// *powerOff*
5722/// response) because the virtual machine cannot fail over until it is
5723/// shutdown.
5724/// - `clusterIsolationResponse`: Use the default isolation response defined for the cluster
5725/// that contains this virtual machine.
5726#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
5727pub enum ClusterDasVmSettingsIsolationResponseEnum {
5728 #[serde(rename = "none")]
5729 #[strum(serialize = "none")]
5730 None,
5731 #[serde(rename = "powerOff")]
5732 #[strum(serialize = "powerOff")]
5733 PowerOff,
5734 #[serde(rename = "shutdown")]
5735 #[strum(serialize = "shutdown")]
5736 Shutdown,
5737 #[serde(rename = "clusterIsolationResponse")]
5738 #[strum(serialize = "clusterIsolationResponse")]
5739 ClusterIsolationResponse,
5740 /// This variant handles values not known at compile time.
5741 #[serde(untagged)]
5742 #[strum(serialize = "__OTHER__")]
5743 Other_(String),
5744}
5745/// The *ClusterDasVmSettingsRestartPriority_enum* enum defines
5746/// virtual machine restart priority values to resolve resource contention.
5747///
5748/// The priority determines the preference that HA gives to a virtual
5749/// machine if sufficient capacity is not available to power on all failed
5750/// virtual machines. For example, high priority virtual machines on a host
5751/// get preference over low priority virtual machines.
5752///
5753/// All priority values are valid for the restart priority specified in a
5754/// single virtual machine HA configuration (*ClusterDasVmConfigInfo.dasSettings*).
5755/// All values except for <code>clusterRestartPriority</code> are valid for
5756/// the cluster-wide default HA configuration for virtual machines
5757/// (*ClusterDasConfigInfo.defaultVmSettings*).
5758///
5759/// Possible values:
5760/// - `disabled`: vSphere HA is disabled for this virtual machine.
5761/// - `lowest`: Virtual machines with this priority have the lowest chance of
5762/// powering on after a failure if there is insufficient capacity on
5763/// hosts to meet all virtual machine needs.
5764/// - `low`: Virtual machines with this priority have a lower chance of powering
5765/// on after a failure if there is insufficient capacity on hosts to meet
5766/// all virtual machine needs.
5767/// - `medium`: Virtual machines with this priority have an intermediate chance of
5768/// powering on after a failure if there is insufficient capacity on
5769/// hosts to meet all virtual machine needs.
5770/// - `high`: Virtual machines with this priority have a higher chance of powering
5771/// on after a failure if there is insufficient capacity on hosts to meet
5772/// all virtual machine needs.
5773/// - `highest`: Virtual machines with this priority have the highest chance of
5774/// powering on after a failure if there is insufficient capacity on
5775/// hosts to meet all virtual machine needs.
5776/// - `clusterRestartPriority`: Virtual machines with this priority use the default restart
5777/// priority defined for the cluster that contains this virtual machine.
5778#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
5779pub enum ClusterDasVmSettingsRestartPriorityEnum {
5780 #[serde(rename = "disabled")]
5781 #[strum(serialize = "disabled")]
5782 Disabled,
5783 #[serde(rename = "lowest")]
5784 #[strum(serialize = "lowest")]
5785 Lowest,
5786 #[serde(rename = "low")]
5787 #[strum(serialize = "low")]
5788 Low,
5789 #[serde(rename = "medium")]
5790 #[strum(serialize = "medium")]
5791 Medium,
5792 #[serde(rename = "high")]
5793 #[strum(serialize = "high")]
5794 High,
5795 #[serde(rename = "highest")]
5796 #[strum(serialize = "highest")]
5797 Highest,
5798 #[serde(rename = "clusterRestartPriority")]
5799 #[strum(serialize = "clusterRestartPriority")]
5800 ClusterRestartPriority,
5801 /// This variant handles values not known at compile time.
5802 #[serde(untagged)]
5803 #[strum(serialize = "__OTHER__")]
5804 Other_(String),
5805}
5806/// Possible values:
5807/// - `manual`: Specifies that VirtualCenter should generate recommendations
5808/// for host power operations, but should not execute the
5809/// recommendations automatically.
5810/// - `automated`: Specifies that VirtualCenter should generate recommendations
5811/// for host power operations, and should execute the
5812/// recommendations automatically.
5813#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
5814pub enum DpmBehaviorEnum {
5815 #[serde(rename = "manual")]
5816 #[strum(serialize = "manual")]
5817 Manual,
5818 #[serde(rename = "automated")]
5819 #[strum(serialize = "automated")]
5820 Automated,
5821 /// This variant handles values not known at compile time.
5822 #[serde(untagged)]
5823 #[strum(serialize = "__OTHER__")]
5824 Other_(String),
5825}
5826/// Possible values:
5827/// - `manual`: Specifies that VirtualCenter should generate recommendations for
5828/// virtual machine migration and for placement with a host,
5829/// but should not implement the recommendations automatically.
5830/// - `partiallyAutomated`: Specifies that VirtualCenter should generate recommendations for
5831/// virtual machine migration and for placement with a host,
5832/// but should automatically implement only the placement at power on.
5833/// - `fullyAutomated`: Specifies that VirtualCenter should automate both the migration
5834/// of virtual machines and their placement with a host at power on.
5835#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
5836pub enum DrsBehaviorEnum {
5837 #[serde(rename = "manual")]
5838 #[strum(serialize = "manual")]
5839 Manual,
5840 #[serde(rename = "partiallyAutomated")]
5841 #[strum(serialize = "partiallyAutomated")]
5842 PartiallyAutomated,
5843 #[serde(rename = "fullyAutomated")]
5844 #[strum(serialize = "fullyAutomated")]
5845 FullyAutomated,
5846 /// This variant handles values not known at compile time.
5847 #[serde(untagged)]
5848 #[strum(serialize = "__OTHER__")]
5849 Other_(String),
5850}
5851/// Deprecated as of VI API 2.5 use *RecommendationReasonCode_enum*.
5852///
5853/// List of defined migration reason codes:
5854///
5855/// Possible values:
5856/// - `fairnessCpuAvg`: Balance average CPU utilization.
5857/// - `fairnessMemAvg`: Balance average memory utilization.
5858/// - `jointAffin`: Fulfill affinity rule.
5859/// - `antiAffin`: Fulfill anti-affinity rule.
5860/// - `hostMaint`: Host entering maintenance mode.
5861#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
5862pub enum DrsRecommendationReasonCodeEnum {
5863 #[serde(rename = "fairnessCpuAvg")]
5864 #[strum(serialize = "fairnessCpuAvg")]
5865 FairnessCpuAvg,
5866 #[serde(rename = "fairnessMemAvg")]
5867 #[strum(serialize = "fairnessMemAvg")]
5868 FairnessMemAvg,
5869 #[serde(rename = "jointAffin")]
5870 #[strum(serialize = "jointAffin")]
5871 JointAffin,
5872 #[serde(rename = "antiAffin")]
5873 #[strum(serialize = "antiAffin")]
5874 AntiAffin,
5875 #[serde(rename = "hostMaint")]
5876 #[strum(serialize = "hostMaint")]
5877 HostMaint,
5878 /// This variant handles values not known at compile time.
5879 #[serde(untagged)]
5880 #[strum(serialize = "__OTHER__")]
5881 Other_(String),
5882}
5883/// Describes the operation type of the action.
5884///
5885/// enterexitQuarantine suggests
5886/// that the host is only exiting the quarantine state (i.e. not the
5887/// maintenance mode).
5888///
5889/// Possible values:
5890/// - `enterQuarantine`
5891/// - `exitQuarantine`
5892/// - `enterMaintenance`
5893#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
5894pub enum ClusterHostInfraUpdateHaModeActionOperationTypeEnum {
5895 #[serde(rename = "enterQuarantine")]
5896 #[strum(serialize = "enterQuarantine")]
5897 EnterQuarantine,
5898 #[serde(rename = "exitQuarantine")]
5899 #[strum(serialize = "exitQuarantine")]
5900 ExitQuarantine,
5901 #[serde(rename = "enterMaintenance")]
5902 #[strum(serialize = "enterMaintenance")]
5903 EnterMaintenance,
5904 /// This variant handles values not known at compile time.
5905 #[serde(untagged)]
5906 #[strum(serialize = "__OTHER__")]
5907 Other_(String),
5908}
5909/// Possible values:
5910/// - `powerOn`: Power On Operation
5911/// - `powerOff`: Power Off Operation.
5912///
5913/// Power off operation puts the host in
5914/// a state that can be woken up remotely.
5915#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
5916pub enum HostPowerOperationTypeEnum {
5917 #[serde(rename = "powerOn")]
5918 #[strum(serialize = "powerOn")]
5919 PowerOn,
5920 #[serde(rename = "powerOff")]
5921 #[strum(serialize = "powerOff")]
5922 PowerOff,
5923 /// This variant handles values not known at compile time.
5924 #[serde(untagged)]
5925 #[strum(serialize = "__OTHER__")]
5926 Other_(String),
5927}
5928/// Possible values:
5929/// - `Manual`: With this behavior configured, the proposed DRS recommendations
5930/// require manual approval before they are executed.
5931/// - `Automated`: With this behavior configured, the proposed DRS recommendations are
5932/// executed immediately.
5933#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
5934pub enum ClusterInfraUpdateHaConfigInfoBehaviorTypeEnum {
5935 Manual,
5936 Automated,
5937 /// This variant handles values not known at compile time.
5938 #[serde(untagged)]
5939 #[strum(serialize = "__OTHER__")]
5940 Other_(String),
5941}
5942/// Possible values:
5943/// - `QuarantineMode`: With this behavior configured, a degraded host will be recommended
5944/// to be placed in Quarantine Mode.
5945/// - `MaintenanceMode`: With this behavior configured, a degraded host will be recommended
5946/// to be placed in Maintenance Mode.
5947#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
5948pub enum ClusterInfraUpdateHaConfigInfoRemediationTypeEnum {
5949 QuarantineMode,
5950 MaintenanceMode,
5951 /// This variant handles values not known at compile time.
5952 #[serde(untagged)]
5953 #[strum(serialize = "__OTHER__")]
5954 Other_(String),
5955}
5956/// Defines the type of placement
5957///
5958/// Possible values:
5959/// - `create`: Create a new VM
5960/// - `reconfigure`: Reconfigure a VM
5961/// - `relocate`: Relocate a VM
5962/// - `clone`: Clone a VM
5963#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
5964pub enum PlacementSpecPlacementTypeEnum {
5965 #[serde(rename = "create")]
5966 #[strum(serialize = "create")]
5967 Create,
5968 #[serde(rename = "reconfigure")]
5969 #[strum(serialize = "reconfigure")]
5970 Reconfigure,
5971 #[serde(rename = "relocate")]
5972 #[strum(serialize = "relocate")]
5973 Relocate,
5974 #[serde(rename = "clone")]
5975 #[strum(serialize = "clone")]
5976 Clone,
5977 /// This variant handles values not known at compile time.
5978 #[serde(untagged)]
5979 #[strum(serialize = "__OTHER__")]
5980 Other_(String),
5981}
5982/// Defines the options for a Datacenter::powerOnVm() invocation.
5983///
5984/// Possible values:
5985/// - `OverrideAutomationLevel`: Override the DRS automation level.
5986///
5987/// Value type: *DrsBehavior_enum*
5988/// Default value: current behavior
5989/// - `ReserveResources`: Reserve resources for the powering-on VMs throughout the
5990/// power-on session.
5991///
5992/// When this option is set to true, the server
5993/// will return at most one recommended host per manual VM, and
5994/// the VM's reservations are held on the recommended host until
5995/// the VM is actually powered on (either by applying the
5996/// recommendation or by a power-on request on the VM), or until
5997/// the recommendation is cancelled, or until the recommendation
5998/// expires. The expiration time is currently set to 10
5999/// minutes. This option does not have an effect on automatic VMs
6000/// since their recommendations are executed immediately. This
6001/// option is effective on DRS clusters only.
6002/// Value type: boolean
6003/// Default value: false
6004#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
6005pub enum ClusterPowerOnVmOptionEnum {
6006 OverrideAutomationLevel,
6007 ReserveResources,
6008 /// This variant handles values not known at compile time.
6009 #[serde(untagged)]
6010 #[strum(serialize = "__OTHER__")]
6011 Other_(String),
6012}
6013/// List of defined migration reason codes:
6014///
6015/// Possible values:
6016/// - `fairnessCpuAvg`: Balance average CPU utilization.
6017/// - `fairnessMemAvg`: Balance average memory utilization.
6018/// - `jointAffin`: Fulfill affinity rule.
6019/// - `antiAffin`: Fulfill anti-affinity rule.
6020/// - `hostMaint`: Host entering maintenance mode.
6021/// - `enterStandby`: Host entering standby mode.
6022/// - `reservationCpu`: balance CPU reservations
6023/// - `reservationMem`: balance memory reservations
6024/// - `powerOnVm`: Power on virtual machine
6025/// - `powerSaving`: Power off host for power savings
6026/// - `increaseCapacity`: Power on host to increase cluster capacity
6027/// - `checkResource`: Sanity-check resource pool hierarchy
6028/// - `unreservedCapacity`: Maintain unreserved capacity
6029/// - `vmHostHardAffinity`: Fix hard VM/host affinity rule violation
6030/// - `vmHostSoftAffinity`: Fix soft VM/host affinity rule violation
6031/// - `balanceDatastoreSpaceUsage`: Balance datastore space usage.
6032/// - `balanceDatastoreIOLoad`:
6033///
6034/// Deprecated as of vSphere8.0 U3, and there is no replacement for it.
6035///
6036/// Balance datastore I/O workload.
6037/// - `balanceDatastoreIOPSReservation`:
6038///
6039/// Deprecated as of vSphere8.0 U3, and there is no replacement for it.
6040///
6041/// Balance datastore IOPS reservation
6042/// - `datastoreMaint`: Datastore entering maintenance mode.
6043/// - `virtualDiskJointAffin`: Fix virtual disk affinity rule violation.
6044/// - `virtualDiskAntiAffin`: Fix virtual disk anti-affinity rule violation.
6045/// - `datastoreSpaceOutage`: Fix the issue that a datastore run out of space.
6046/// - `storagePlacement`: Satisfy storage initial placement requests.
6047/// - `iolbDisabledInternal`:
6048///
6049/// Deprecated as of vSphere8.0 U3, and there is no replacement for it.
6050///
6051/// IO load balancing was disabled internally.
6052/// - `xvmotionPlacement`: Satisfy unified vmotion placement requests.
6053/// - `networkBandwidthReservation`: Fix network bandwidth reservation violation
6054/// - `hostInDegradation`: Host is partially degraded.
6055/// - `hostExitDegradation`: Host is not degraded.
6056/// - `maxVmsConstraint`: Fix maxVms constraint violation
6057/// - `ftConstraints`: Fix ft maxVMs and maxVcpus constraint violations
6058/// - `vmHostAffinityPolicy`: Fix VM/host affinity policy violation
6059/// - `vmHostAntiAffinityPolicy`: Fix VM/host anti-affinity policy violation
6060/// - `vmAntiAffinityPolicy`: Fix VM-VM anti-affinity policy violations
6061/// - `balanceVsanUsage`: ***Since:*** vSphere API Release 7.0.2.0
6062/// - `ahPlacementOptimization`: Optimize assignable hardware resource orchestration
6063///
6064/// ***Since:*** vSphere API Release 8.0.2.0
6065/// - `vmxUpgrade`: Upgrade virtual machine to new vmx binary
6066///
6067/// ***Since:*** vSphere API Release 8.0.3.0
6068#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
6069pub enum RecommendationReasonCodeEnum {
6070 #[serde(rename = "fairnessCpuAvg")]
6071 #[strum(serialize = "fairnessCpuAvg")]
6072 FairnessCpuAvg,
6073 #[serde(rename = "fairnessMemAvg")]
6074 #[strum(serialize = "fairnessMemAvg")]
6075 FairnessMemAvg,
6076 #[serde(rename = "jointAffin")]
6077 #[strum(serialize = "jointAffin")]
6078 JointAffin,
6079 #[serde(rename = "antiAffin")]
6080 #[strum(serialize = "antiAffin")]
6081 AntiAffin,
6082 #[serde(rename = "hostMaint")]
6083 #[strum(serialize = "hostMaint")]
6084 HostMaint,
6085 #[serde(rename = "enterStandby")]
6086 #[strum(serialize = "enterStandby")]
6087 EnterStandby,
6088 #[serde(rename = "reservationCpu")]
6089 #[strum(serialize = "reservationCpu")]
6090 ReservationCpu,
6091 #[serde(rename = "reservationMem")]
6092 #[strum(serialize = "reservationMem")]
6093 ReservationMem,
6094 #[serde(rename = "powerOnVm")]
6095 #[strum(serialize = "powerOnVm")]
6096 PowerOnVm,
6097 #[serde(rename = "powerSaving")]
6098 #[strum(serialize = "powerSaving")]
6099 PowerSaving,
6100 #[serde(rename = "increaseCapacity")]
6101 #[strum(serialize = "increaseCapacity")]
6102 IncreaseCapacity,
6103 #[serde(rename = "checkResource")]
6104 #[strum(serialize = "checkResource")]
6105 CheckResource,
6106 #[serde(rename = "unreservedCapacity")]
6107 #[strum(serialize = "unreservedCapacity")]
6108 UnreservedCapacity,
6109 #[serde(rename = "vmHostHardAffinity")]
6110 #[strum(serialize = "vmHostHardAffinity")]
6111 VmHostHardAffinity,
6112 #[serde(rename = "vmHostSoftAffinity")]
6113 #[strum(serialize = "vmHostSoftAffinity")]
6114 VmHostSoftAffinity,
6115 #[serde(rename = "balanceDatastoreSpaceUsage")]
6116 #[strum(serialize = "balanceDatastoreSpaceUsage")]
6117 BalanceDatastoreSpaceUsage,
6118 #[serde(rename = "balanceDatastoreIOLoad")]
6119 #[strum(serialize = "balanceDatastoreIOLoad")]
6120 BalanceDatastoreIoLoad,
6121 #[serde(rename = "balanceDatastoreIOPSReservation")]
6122 #[strum(serialize = "balanceDatastoreIOPSReservation")]
6123 BalanceDatastoreIopsReservation,
6124 #[serde(rename = "datastoreMaint")]
6125 #[strum(serialize = "datastoreMaint")]
6126 DatastoreMaint,
6127 #[serde(rename = "virtualDiskJointAffin")]
6128 #[strum(serialize = "virtualDiskJointAffin")]
6129 VirtualDiskJointAffin,
6130 #[serde(rename = "virtualDiskAntiAffin")]
6131 #[strum(serialize = "virtualDiskAntiAffin")]
6132 VirtualDiskAntiAffin,
6133 #[serde(rename = "datastoreSpaceOutage")]
6134 #[strum(serialize = "datastoreSpaceOutage")]
6135 DatastoreSpaceOutage,
6136 #[serde(rename = "storagePlacement")]
6137 #[strum(serialize = "storagePlacement")]
6138 StoragePlacement,
6139 #[serde(rename = "iolbDisabledInternal")]
6140 #[strum(serialize = "iolbDisabledInternal")]
6141 IolbDisabledInternal,
6142 #[serde(rename = "xvmotionPlacement")]
6143 #[strum(serialize = "xvmotionPlacement")]
6144 XvmotionPlacement,
6145 #[serde(rename = "networkBandwidthReservation")]
6146 #[strum(serialize = "networkBandwidthReservation")]
6147 NetworkBandwidthReservation,
6148 #[serde(rename = "hostInDegradation")]
6149 #[strum(serialize = "hostInDegradation")]
6150 HostInDegradation,
6151 #[serde(rename = "hostExitDegradation")]
6152 #[strum(serialize = "hostExitDegradation")]
6153 HostExitDegradation,
6154 #[serde(rename = "maxVmsConstraint")]
6155 #[strum(serialize = "maxVmsConstraint")]
6156 MaxVmsConstraint,
6157 #[serde(rename = "ftConstraints")]
6158 #[strum(serialize = "ftConstraints")]
6159 FtConstraints,
6160 #[serde(rename = "vmHostAffinityPolicy")]
6161 #[strum(serialize = "vmHostAffinityPolicy")]
6162 VmHostAffinityPolicy,
6163 #[serde(rename = "vmHostAntiAffinityPolicy")]
6164 #[strum(serialize = "vmHostAntiAffinityPolicy")]
6165 VmHostAntiAffinityPolicy,
6166 #[serde(rename = "vmAntiAffinityPolicy")]
6167 #[strum(serialize = "vmAntiAffinityPolicy")]
6168 VmAntiAffinityPolicy,
6169 #[serde(rename = "balanceVsanUsage")]
6170 #[strum(serialize = "balanceVsanUsage")]
6171 BalanceVsanUsage,
6172 #[serde(rename = "ahPlacementOptimization")]
6173 #[strum(serialize = "ahPlacementOptimization")]
6174 AhPlacementOptimization,
6175 #[serde(rename = "vmxUpgrade")]
6176 #[strum(serialize = "vmxUpgrade")]
6177 VmxUpgrade,
6178 /// This variant handles values not known at compile time.
6179 #[serde(untagged)]
6180 #[strum(serialize = "__OTHER__")]
6181 Other_(String),
6182}
6183/// Pre-defined constants for possible recommendation types.
6184///
6185/// Virtual Center
6186/// uses this information to coordinate with the clients.
6187///
6188/// Possible values:
6189/// - `V1`
6190#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
6191pub enum RecommendationTypeEnum {
6192 V1,
6193 /// This variant handles values not known at compile time.
6194 #[serde(untagged)]
6195 #[strum(serialize = "__OTHER__")]
6196 Other_(String),
6197}
6198/// Defines the set of status values for compliance operations.
6199///
6200/// Possible values:
6201/// - `compliant`: Entity is compliant.
6202/// - `nonCompliant`: Entity is not compliant.
6203/// - `unknown`: Compliance status of the entity is unknown.
6204/// - `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.
6205#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
6206pub enum VsanStorageComplianceStatusEnum {
6207 #[serde(rename = "compliant")]
6208 #[strum(serialize = "compliant")]
6209 Compliant,
6210 #[serde(rename = "nonCompliant")]
6211 #[strum(serialize = "nonCompliant")]
6212 NonCompliant,
6213 #[serde(rename = "unknown")]
6214 #[strum(serialize = "unknown")]
6215 Unknown,
6216 #[serde(rename = "notApplicable")]
6217 #[strum(serialize = "notApplicable")]
6218 NotApplicable,
6219 /// This variant handles values not known at compile time.
6220 #[serde(untagged)]
6221 #[strum(serialize = "__OTHER__")]
6222 Other_(String),
6223}
6224/// Possible values:
6225/// - `SYSTEM_MANAGED`: System VMs are fully managed by the system.
6226/// - `ABSENT`: System VMs are absent on the managed entity.
6227///
6228/// ***Since:*** vSphere API Release 8.0.2.0
6229#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
6230pub enum ClusterSystemVMsConfigInfoDeploymentModeEnum {
6231 #[serde(rename = "SYSTEM_MANAGED")]
6232 #[strum(serialize = "SYSTEM_MANAGED")]
6233 SystemManaged,
6234 #[serde(rename = "ABSENT")]
6235 #[strum(serialize = "ABSENT")]
6236 Absent,
6237 /// This variant handles values not known at compile time.
6238 #[serde(untagged)]
6239 #[strum(serialize = "__OTHER__")]
6240 Other_(String),
6241}
6242/// Possible values:
6243/// - `ClusterWithoutOneWitnessHost`
6244/// - `ClusterWithoutTwoDataFaultDomains`
6245/// - `ClusterWithMultipleUnicastAgents`
6246/// - `WitnessPreferredFaultDomainInvalid`
6247/// - `WitnessPreferredFaultDomainNotExist`
6248/// - `WitnessInsideVcCluster`
6249/// - `WitnessFaultDomainInvalid`
6250/// - `HostUnicastAgentUnset`
6251/// - `WitnessWithNoDiskMapping`
6252/// - `HostWithNoStretchedClusterSupport`
6253/// - `HostWithInvalidUnicastAgent`
6254/// - `SharedWitnessClusterDataHostNumExceed`
6255/// - `SharedWitnessComponentLimitScaledDown`
6256/// - `VSANStretchedClusterConfigIssueEnum_Unknown`
6257#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
6258pub enum VimClusterVsanStretchedClusterConfigIssueEnumEnum {
6259 ClusterWithoutOneWitnessHost,
6260 ClusterWithoutTwoDataFaultDomains,
6261 ClusterWithMultipleUnicastAgents,
6262 WitnessPreferredFaultDomainInvalid,
6263 WitnessPreferredFaultDomainNotExist,
6264 WitnessInsideVcCluster,
6265 WitnessFaultDomainInvalid,
6266 HostUnicastAgentUnset,
6267 WitnessWithNoDiskMapping,
6268 HostWithNoStretchedClusterSupport,
6269 HostWithInvalidUnicastAgent,
6270 SharedWitnessClusterDataHostNumExceed,
6271 SharedWitnessComponentLimitScaledDown,
6272 #[serde(rename = "VSANStretchedClusterConfigIssueEnum_Unknown")]
6273 #[strum(serialize = "VSANStretchedClusterConfigIssueEnum_Unknown")]
6274 VsanStretchedClusterConfigIssueEnumUnknown,
6275 /// This variant handles values not known at compile time.
6276 #[serde(untagged)]
6277 #[strum(serialize = "__OTHER__")]
6278 Other_(String),
6279}
6280/// The VM policy settings that determine the response to
6281/// storage failures.
6282///
6283/// Possible values:
6284/// - `disabled`: VM Component Protection service will not monitor or react to
6285/// the component failure.
6286///
6287/// This setting does not affect other vSphere
6288/// HA services such as Host Monitoring or VM Health Monitoring.
6289/// - `warning`: VM Component Protection service will monitor component failures but
6290/// will not restart an affected VM.
6291///
6292/// Rather it will notify users about
6293/// the component failures. This setting does not affect other vSphere HA
6294/// services such as Host Monitoring or VM Health Monitoring.
6295/// - `restartConservative`: VM Component Protection service protects VMs conservatively.
6296///
6297/// With this
6298/// setting, when the service can't determine that capacity is available to
6299/// restart a VM, it will favor keeping the VM running.
6300/// - `restartAggressive`: VM Component Protection service protects VMs aggressively.
6301///
6302/// With this setting,
6303/// the service will terminate an affected VM even if it can't determine that
6304/// capacity exists to restart the VM.
6305/// - `clusterDefault`: VM will use the cluster default setting.
6306///
6307/// This option is only meaningful for
6308/// per-VM settings.
6309#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
6310pub enum ClusterVmComponentProtectionSettingsStorageVmReactionEnum {
6311 #[serde(rename = "disabled")]
6312 #[strum(serialize = "disabled")]
6313 Disabled,
6314 #[serde(rename = "warning")]
6315 #[strum(serialize = "warning")]
6316 Warning,
6317 #[serde(rename = "restartConservative")]
6318 #[strum(serialize = "restartConservative")]
6319 RestartConservative,
6320 #[serde(rename = "restartAggressive")]
6321 #[strum(serialize = "restartAggressive")]
6322 RestartAggressive,
6323 #[serde(rename = "clusterDefault")]
6324 #[strum(serialize = "clusterDefault")]
6325 ClusterDefault,
6326 /// This variant handles values not known at compile time.
6327 #[serde(untagged)]
6328 #[strum(serialize = "__OTHER__")]
6329 Other_(String),
6330}
6331/// If an APD condition clears after an APD timeout condition has been declared and before
6332/// VM Component Protection service terminated the VM, the guestOS and application may
6333/// no longer be operational.
6334///
6335/// VM Component Protection may be configured to reset the
6336/// VM (*VirtualMachine.ResetVM_Task*) to restore the service of guest applications.
6337///
6338/// Possible values:
6339/// - `none`: VM Component Protection service will not react after APD condition is cleared.
6340/// - `reset`: VM Component Protection service will reset the VM after APD condition is cleared.
6341///
6342/// Note this only applies if the subject VM is still powered on.
6343/// - `useClusterDefault`: VM will use the cluster default setting.
6344///
6345/// This option is only meaningful for
6346/// per-VM settings.
6347#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
6348pub enum ClusterVmComponentProtectionSettingsVmReactionOnApdClearedEnum {
6349 #[serde(rename = "none")]
6350 #[strum(serialize = "none")]
6351 None,
6352 #[serde(rename = "reset")]
6353 #[strum(serialize = "reset")]
6354 Reset,
6355 #[serde(rename = "useClusterDefault")]
6356 #[strum(serialize = "useClusterDefault")]
6357 UseClusterDefault,
6358 /// This variant handles values not known at compile time.
6359 #[serde(untagged)]
6360 #[strum(serialize = "__OTHER__")]
6361 Other_(String),
6362}
6363/// Condition for VM's readiness
6364///
6365/// Possible values:
6366/// - `none`: No ready condition specified.
6367///
6368/// In case of vSphere HA, higher restart priority VMs are still
6369/// placed before lower priority VMs.
6370/// - `poweredOn`: VM is powered on.
6371/// - `guestHbStatusGreen`: VM guest operating system is up and responding normally (VM tools
6372/// heartbeat status is green).
6373/// - `appHbStatusGreen`: An application running inside the VM is responding normally.
6374///
6375/// To enable Application Monitoring, you must first obtain the
6376/// appropriate SDK (or be using an application that supports VMware
6377/// Application Monitoring) and use it to set up customized heartbeats
6378/// for the applications you want to monitor.
6379/// See *ClusterDasConfigInfo.vmMonitoring*.
6380/// - `useClusterDefault`: VM will use the cluster default setting.
6381///
6382/// This option is only
6383/// meaningful for per-VM settings.
6384#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
6385pub enum ClusterVmReadinessReadyConditionEnum {
6386 #[serde(rename = "none")]
6387 #[strum(serialize = "none")]
6388 None,
6389 #[serde(rename = "poweredOn")]
6390 #[strum(serialize = "poweredOn")]
6391 PoweredOn,
6392 #[serde(rename = "guestHbStatusGreen")]
6393 #[strum(serialize = "guestHbStatusGreen")]
6394 GuestHbStatusGreen,
6395 #[serde(rename = "appHbStatusGreen")]
6396 #[strum(serialize = "appHbStatusGreen")]
6397 AppHbStatusGreen,
6398 #[serde(rename = "useClusterDefault")]
6399 #[strum(serialize = "useClusterDefault")]
6400 UseClusterDefault,
6401 /// This variant handles values not known at compile time.
6402 #[serde(untagged)]
6403 #[strum(serialize = "__OTHER__")]
6404 Other_(String),
6405}
6406/// Represents various baseline preference types.
6407///
6408/// Any patch or update release is considered part of the same "release family",
6409/// while both updates to the major version number (e.g. 7.0) or to the minor
6410/// version number (e.g. 7.1) would be considered different "release families".
6411///
6412/// Possible values:
6413/// - `latestRelease`: recommend latest release compatible with cluster hardware, it could be either new major release or update release in current release family.
6414///
6415/// (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.)
6416/// - `latestPatch`: latest patch contains all bug fixes and updates for the current release family.
6417///
6418/// 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.)
6419/// - `noRecommendation`: do not generate baseline recommendation for current vSAN cluster.
6420/// - `VsanBaselinePreferenceType_Unknown`
6421#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
6422pub enum VsanBaselinePreferenceTypeEnum {
6423 #[serde(rename = "latestRelease")]
6424 #[strum(serialize = "latestRelease")]
6425 LatestRelease,
6426 #[serde(rename = "latestPatch")]
6427 #[strum(serialize = "latestPatch")]
6428 LatestPatch,
6429 #[serde(rename = "noRecommendation")]
6430 #[strum(serialize = "noRecommendation")]
6431 NoRecommendation,
6432 #[serde(rename = "VsanBaselinePreferenceType_Unknown")]
6433 #[strum(serialize = "VsanBaselinePreferenceType_Unknown")]
6434 VsanBaselinePreferenceTypeUnknown,
6435 /// This variant handles values not known at compile time.
6436 #[serde(untagged)]
6437 #[strum(serialize = "__OTHER__")]
6438 Other_(String),
6439}
6440/// Represents a condition that an object is in when retrieving capability on
6441/// it.
6442///
6443/// A host can be in multiple conditions at the same time. Currently we
6444/// have the following ones.
6445///
6446/// Possible values:
6447/// - `unknown`: Not able to get/calculate the host's capabilities, thus empty capability list returned.
6448/// - `oldversion`: Host version is before ESXi 6.0 U1.
6449/// - `disconnected`: Host is in disconnected state.
6450/// - `calculated`: Capabilities are not retrieved from the host but are calculated based on host's version.
6451#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
6452pub enum VsanCapabilityStatusEnum {
6453 #[serde(rename = "unknown")]
6454 #[strum(serialize = "unknown")]
6455 Unknown,
6456 #[serde(rename = "oldversion")]
6457 #[strum(serialize = "oldversion")]
6458 Oldversion,
6459 #[serde(rename = "disconnected")]
6460 #[strum(serialize = "disconnected")]
6461 Disconnected,
6462 #[serde(rename = "calculated")]
6463 #[strum(serialize = "calculated")]
6464 Calculated,
6465 /// This variant handles values not known at compile time.
6466 #[serde(untagged)]
6467 #[strum(serialize = "__OTHER__")]
6468 Other_(String),
6469}
6470/// Represents a feature capability (for 8.x and previous releases).
6471///
6472/// Possible values:
6473/// - `capability`: The current feature for retrieving Capabilities.
6474/// - `allflash`: Creating AllFlash disk groups.
6475/// - `stretchedcluster`: Creating a stretched cluster, adding and removing witness host.
6476/// - `dataefficiency`: Enabling/disabling Deduplication and Compression.
6477/// - `clusterconfig`: Create/Configure a vSAN cluster and related features with a single call.
6478/// - `upgrade`: Upgrade disk groups to a higher version.
6479/// - `objectidentities`: Retrieve a greater set of virtual objects.
6480/// - `iscsitargets`: iscsi feature provides iSCSI protocol on top of vSAN.
6481/// - `witnessmanagement`: The enable/disable vSAN operation and changing claiming policy.
6482/// - `perfsvcverbosemode`: Allow users to configure performance service to run in verbose mode, in which extra stats are collected for support cases and dev debugging.
6483/// - `encryption`: Software data at rest encryption for vSAN.
6484/// - `decomwhatif`: Query what-if result for decommissioning host or disk.
6485/// - `throttleresync`: Improve throttling options & resumable resync.
6486/// - `unicastmode`: Enforce unicast mode in vSAN.
6487/// - `device4ksupport`: 4k disks supporting status in vSAN
6488/// - `nestedfd`: Nested fault domains for stretched clusters.
6489/// - `complianceprecheck`: Calculate required additional capacity to make all vms compliant.
6490/// - `vumintegration`: vSAN upgrades through VUM integration.
6491/// - `firmwareupdate`: vSAN firmware/driver update feature that allow users to remediate outdated driver or firmware in an automated and simple fashion for supported hardware.
6492/// - `fullStackFw`: (deprecated since vSphere 8.0) allows users to update full stack of firmware for vSAN hosts.
6493/// - `configassist`: Configuration Assist UI provided in vSphere Web Client to help vSAN deployment.
6494/// - `umap`: TRIM/UNMAP for space reclamation on vSAN.
6495/// - `localdataprotection`: Support for data protection on a vSAN cluster.
6496/// - `archivaldataprotection`: Support for data protection to NFS datastores.
6497/// - `pr1741414fixed`: GetPreferredfaultDomain on stretched cluster and VmdkLoadTest work correctly operation are automatically performed by the VsanVcClusterConfig API.
6498/// - `cloudhealth`: Enable/Disable Cloud Connected Analytics
6499/// - `perfanalysis`: Enable/Disable Performance Analytics
6500/// - `fcd`: Enable/Disable First Class Disk Support in vSAN
6501/// - `healthcheck2018q2`: Enable/Disable suites of health group checks on 2018q2 releases
6502/// - `enhancedresyncapi`: Support *VsanSystemEx.VsanQuerySyncingVsanObjects*.
6503/// - `genericnestedfd`: Nested fault domain for non-stretched cluster.
6504/// - `hostaffinity`: Support for Host Affinity
6505/// - `perfsvcautoconfig`: The capability of enable/disable vSAN performance service automatically when configure vSAN.
6506/// - `unicasttest`: For unicast performance test capability.
6507///
6508/// (Obsoleted, DO NOT USE)
6509/// - `vsanrdma`
6510/// - `vumbaselinerecommendation`
6511/// - `supportinsight`
6512/// - `netperftest`: For network performance test capability.
6513/// - `masspropertycollector`: For vSAN mass property collector capability by extending property collector to collect multiple properties and APIs execution result as a batch mode
6514/// - `whatifcapacity`: For vSAN datastore What-If capacity report capability.
6515/// - `historicalcapacity`: For vSAN datastore historical capacity report capability.
6516/// - `policyassociation`: Support SPBM to use vSAN as source of truth for policy association.
6517/// - `policyhostapi`
6518/// - `diagnosticmode`: For vSAN diagnostic mode capability.
6519/// - `purgeinaccessiblevmswapobjects`: Support for purging inaccessible VM swap objects
6520/// - `recreatediskgroup`: Support for recreating disk groups
6521/// - `repairtimerinresyncstats`: Support for retrieving repair time runtime information
6522/// - `clusteradvancedoptions`: Support for cluster advanced options
6523/// - `updatevumreleasecatalogoffline`: Support for VUM release catalog offline update
6524/// - `performanceforsupport`: Capability of performance metrics collection for vSAN support
6525/// - `gethcllastupdateonvc`: Indicates if the cluster parameter is optional in the *VsanVcClusterHealthSystem.VsanVcClusterGetHclInfo* method.
6526/// - `automaticrebalance`
6527/// - `verbosemodeconfiguration`
6528/// - `resyncetaimprovement`
6529/// - `fileservices`
6530/// - `fileservicekerberos`
6531/// - `fileservicesmb`
6532/// - `fileservicenfsv3`
6533/// - `fileservicesc`
6534/// - `fileservicesnapshot`
6535/// - `fileserviceowe`
6536/// - `fileservice80`
6537/// - `fileservicescale`
6538/// - `resourceprecheck`
6539/// - `upgraderesourceprecheck`
6540/// - `vitonlineresize`
6541/// - `vitstretchedcluster`
6542/// - `largecapacitydrive`
6543/// - `nondatamovementdfc`
6544/// - `cnsvolumes`
6545/// - `filevolumes`
6546/// - `diagnosticsfeedback`
6547/// - `hostreservedcapacity`
6548/// - `vmlevelcapacity`
6549/// - `improvedcapacityscreen`
6550/// - `slackspacecapacity`
6551/// - `sharedwitness`
6552/// - `VsanCapabilityType_Unknown`
6553/// - `supportApiVersion`
6554/// - `vsanmetadatanode`
6555/// - `pmanintegration`
6556/// - `wcpappplatform`
6557/// - `diskresourceprecheck`
6558/// - `metricsconfig`
6559/// - `ioinsight`
6560/// - `apidevversionenabled`
6561/// - `nativelargeclustersupport`
6562/// - `historicalhealth`
6563/// - `dataintransitencryption`
6564/// - `perfsvctwoyaxisgraph`
6565/// - `compressiononly`
6566/// - `remotedatastore`
6567/// - `vsanmanagedvmfs`
6568/// - `capacityreservation`
6569/// - `securewipe`
6570/// - `validateconfigspec`
6571/// - `vsananalyticsevents`
6572/// - `vsandefaultgatewaysupported`
6573/// - `pspairgap`
6574/// - `vsanmanagedpmem`
6575/// - `capacityevaluationonvc`
6576/// - `readlocalitytodrs`
6577/// - `vsanencrkmx`
6578/// - `vsan2encr`
6579/// - `dit4sw`
6580/// - `vsanclient`
6581/// - `capacityoversubscription`
6582/// - `vsandiagnostics`
6583/// - `capacitycustomizablethresholds`
6584/// - `hcimeshpolicy`
6585/// - `topcontributors`
6586/// - `vsandirectdiskdecom`
6587/// - `diskmgmtredesign`
6588/// - `datapersistresourcecheck`
6589/// - `clusterpoweraction`
6590/// - `clusterpowerselfcontain`
6591/// - `duplicatepciidfix`
6592/// - `healthcorrelation`
6593/// - `volumerelocation`
6594/// - `iodiagnostics`
6595/// - `vsanrebuildtrim`
6596/// - `elasticpolicy`
6597/// - `vsanEsaConfigure`
6598/// - `hdcsintegration`
6599/// - `vsanesasingletier`
6600/// - `vsanperfhighresolution`
6601/// - `cnsreconfigpolicy`
6602/// - `vsanhostdomlatencysort`
6603/// - `sha256thumbprint`
6604/// - `minrebalancethreshold`
6605/// - `vsan2hcimesh`
6606/// - `dfcobjectsmanagement`
6607/// - `healthremediation`
6608/// - `hcimeshstretchedcluster`
6609/// - `vsanxvchcimesh`
6610/// - `vsan2deeprekey`
6611/// - `vsandsdefaultpolicy`
6612/// - `vsanperfsvc80u2`
6613/// - `vsankeyexpiration`
6614/// - `vsanxvchcimeshv2`
6615/// - `dhci`
6616/// - `snapservice`: ***Since:*** 8.0.0.4
6617/// - `vsan2disableencryption`: ***Since:*** 8.0.0.4
6618/// - `iodiagmultiplevms`: ***Since:*** 8.0.0.4
6619/// - `vsanxvchcimeshv3`: ***Since:*** 8.0.0.4
6620#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
6621pub enum VsanCapabilityTypeEnum {
6622 #[serde(rename = "capability")]
6623 #[strum(serialize = "capability")]
6624 Capability,
6625 #[serde(rename = "allflash")]
6626 #[strum(serialize = "allflash")]
6627 Allflash,
6628 #[serde(rename = "stretchedcluster")]
6629 #[strum(serialize = "stretchedcluster")]
6630 Stretchedcluster,
6631 #[serde(rename = "dataefficiency")]
6632 #[strum(serialize = "dataefficiency")]
6633 Dataefficiency,
6634 #[serde(rename = "clusterconfig")]
6635 #[strum(serialize = "clusterconfig")]
6636 Clusterconfig,
6637 #[serde(rename = "upgrade")]
6638 #[strum(serialize = "upgrade")]
6639 Upgrade,
6640 #[serde(rename = "objectidentities")]
6641 #[strum(serialize = "objectidentities")]
6642 Objectidentities,
6643 #[serde(rename = "iscsitargets")]
6644 #[strum(serialize = "iscsitargets")]
6645 Iscsitargets,
6646 #[serde(rename = "witnessmanagement")]
6647 #[strum(serialize = "witnessmanagement")]
6648 Witnessmanagement,
6649 #[serde(rename = "perfsvcverbosemode")]
6650 #[strum(serialize = "perfsvcverbosemode")]
6651 Perfsvcverbosemode,
6652 #[serde(rename = "encryption")]
6653 #[strum(serialize = "encryption")]
6654 Encryption,
6655 #[serde(rename = "decomwhatif")]
6656 #[strum(serialize = "decomwhatif")]
6657 Decomwhatif,
6658 #[serde(rename = "throttleresync")]
6659 #[strum(serialize = "throttleresync")]
6660 Throttleresync,
6661 #[serde(rename = "unicastmode")]
6662 #[strum(serialize = "unicastmode")]
6663 Unicastmode,
6664 #[serde(rename = "device4ksupport")]
6665 #[strum(serialize = "device4ksupport")]
6666 Device4Ksupport,
6667 #[serde(rename = "nestedfd")]
6668 #[strum(serialize = "nestedfd")]
6669 Nestedfd,
6670 #[serde(rename = "complianceprecheck")]
6671 #[strum(serialize = "complianceprecheck")]
6672 Complianceprecheck,
6673 #[serde(rename = "vumintegration")]
6674 #[strum(serialize = "vumintegration")]
6675 Vumintegration,
6676 #[serde(rename = "firmwareupdate")]
6677 #[strum(serialize = "firmwareupdate")]
6678 Firmwareupdate,
6679 #[serde(rename = "fullStackFw")]
6680 #[strum(serialize = "fullStackFw")]
6681 FullStackFw,
6682 #[serde(rename = "configassist")]
6683 #[strum(serialize = "configassist")]
6684 Configassist,
6685 #[serde(rename = "umap")]
6686 #[strum(serialize = "umap")]
6687 Umap,
6688 #[serde(rename = "localdataprotection")]
6689 #[strum(serialize = "localdataprotection")]
6690 Localdataprotection,
6691 #[serde(rename = "archivaldataprotection")]
6692 #[strum(serialize = "archivaldataprotection")]
6693 Archivaldataprotection,
6694 #[serde(rename = "pr1741414fixed")]
6695 #[strum(serialize = "pr1741414fixed")]
6696 Pr1741414Fixed,
6697 #[serde(rename = "cloudhealth")]
6698 #[strum(serialize = "cloudhealth")]
6699 Cloudhealth,
6700 #[serde(rename = "perfanalysis")]
6701 #[strum(serialize = "perfanalysis")]
6702 Perfanalysis,
6703 #[serde(rename = "fcd")]
6704 #[strum(serialize = "fcd")]
6705 Fcd,
6706 #[serde(rename = "healthcheck2018q2")]
6707 #[strum(serialize = "healthcheck2018q2")]
6708 Healthcheck2018Q2,
6709 #[serde(rename = "enhancedresyncapi")]
6710 #[strum(serialize = "enhancedresyncapi")]
6711 Enhancedresyncapi,
6712 #[serde(rename = "genericnestedfd")]
6713 #[strum(serialize = "genericnestedfd")]
6714 Genericnestedfd,
6715 #[serde(rename = "hostaffinity")]
6716 #[strum(serialize = "hostaffinity")]
6717 Hostaffinity,
6718 #[serde(rename = "perfsvcautoconfig")]
6719 #[strum(serialize = "perfsvcautoconfig")]
6720 Perfsvcautoconfig,
6721 #[serde(rename = "unicasttest")]
6722 #[strum(serialize = "unicasttest")]
6723 Unicasttest,
6724 #[serde(rename = "vsanrdma")]
6725 #[strum(serialize = "vsanrdma")]
6726 Vsanrdma,
6727 #[serde(rename = "vumbaselinerecommendation")]
6728 #[strum(serialize = "vumbaselinerecommendation")]
6729 Vumbaselinerecommendation,
6730 #[serde(rename = "supportinsight")]
6731 #[strum(serialize = "supportinsight")]
6732 Supportinsight,
6733 #[serde(rename = "netperftest")]
6734 #[strum(serialize = "netperftest")]
6735 Netperftest,
6736 #[serde(rename = "masspropertycollector")]
6737 #[strum(serialize = "masspropertycollector")]
6738 Masspropertycollector,
6739 #[serde(rename = "whatifcapacity")]
6740 #[strum(serialize = "whatifcapacity")]
6741 Whatifcapacity,
6742 #[serde(rename = "historicalcapacity")]
6743 #[strum(serialize = "historicalcapacity")]
6744 Historicalcapacity,
6745 #[serde(rename = "policyassociation")]
6746 #[strum(serialize = "policyassociation")]
6747 Policyassociation,
6748 #[serde(rename = "policyhostapi")]
6749 #[strum(serialize = "policyhostapi")]
6750 Policyhostapi,
6751 #[serde(rename = "diagnosticmode")]
6752 #[strum(serialize = "diagnosticmode")]
6753 Diagnosticmode,
6754 #[serde(rename = "purgeinaccessiblevmswapobjects")]
6755 #[strum(serialize = "purgeinaccessiblevmswapobjects")]
6756 Purgeinaccessiblevmswapobjects,
6757 #[serde(rename = "recreatediskgroup")]
6758 #[strum(serialize = "recreatediskgroup")]
6759 Recreatediskgroup,
6760 #[serde(rename = "repairtimerinresyncstats")]
6761 #[strum(serialize = "repairtimerinresyncstats")]
6762 Repairtimerinresyncstats,
6763 #[serde(rename = "clusteradvancedoptions")]
6764 #[strum(serialize = "clusteradvancedoptions")]
6765 Clusteradvancedoptions,
6766 #[serde(rename = "updatevumreleasecatalogoffline")]
6767 #[strum(serialize = "updatevumreleasecatalogoffline")]
6768 Updatevumreleasecatalogoffline,
6769 #[serde(rename = "performanceforsupport")]
6770 #[strum(serialize = "performanceforsupport")]
6771 Performanceforsupport,
6772 #[serde(rename = "gethcllastupdateonvc")]
6773 #[strum(serialize = "gethcllastupdateonvc")]
6774 Gethcllastupdateonvc,
6775 #[serde(rename = "automaticrebalance")]
6776 #[strum(serialize = "automaticrebalance")]
6777 Automaticrebalance,
6778 #[serde(rename = "verbosemodeconfiguration")]
6779 #[strum(serialize = "verbosemodeconfiguration")]
6780 Verbosemodeconfiguration,
6781 #[serde(rename = "resyncetaimprovement")]
6782 #[strum(serialize = "resyncetaimprovement")]
6783 Resyncetaimprovement,
6784 #[serde(rename = "fileservices")]
6785 #[strum(serialize = "fileservices")]
6786 Fileservices,
6787 #[serde(rename = "fileservicekerberos")]
6788 #[strum(serialize = "fileservicekerberos")]
6789 Fileservicekerberos,
6790 #[serde(rename = "fileservicesmb")]
6791 #[strum(serialize = "fileservicesmb")]
6792 Fileservicesmb,
6793 #[serde(rename = "fileservicenfsv3")]
6794 #[strum(serialize = "fileservicenfsv3")]
6795 Fileservicenfsv3,
6796 #[serde(rename = "fileservicesc")]
6797 #[strum(serialize = "fileservicesc")]
6798 Fileservicesc,
6799 #[serde(rename = "fileservicesnapshot")]
6800 #[strum(serialize = "fileservicesnapshot")]
6801 Fileservicesnapshot,
6802 #[serde(rename = "fileserviceowe")]
6803 #[strum(serialize = "fileserviceowe")]
6804 Fileserviceowe,
6805 #[serde(rename = "fileservice80")]
6806 #[strum(serialize = "fileservice80")]
6807 Fileservice80,
6808 #[serde(rename = "fileservicescale")]
6809 #[strum(serialize = "fileservicescale")]
6810 Fileservicescale,
6811 #[serde(rename = "resourceprecheck")]
6812 #[strum(serialize = "resourceprecheck")]
6813 Resourceprecheck,
6814 #[serde(rename = "upgraderesourceprecheck")]
6815 #[strum(serialize = "upgraderesourceprecheck")]
6816 Upgraderesourceprecheck,
6817 #[serde(rename = "vitonlineresize")]
6818 #[strum(serialize = "vitonlineresize")]
6819 Vitonlineresize,
6820 #[serde(rename = "vitstretchedcluster")]
6821 #[strum(serialize = "vitstretchedcluster")]
6822 Vitstretchedcluster,
6823 #[serde(rename = "largecapacitydrive")]
6824 #[strum(serialize = "largecapacitydrive")]
6825 Largecapacitydrive,
6826 #[serde(rename = "nondatamovementdfc")]
6827 #[strum(serialize = "nondatamovementdfc")]
6828 Nondatamovementdfc,
6829 #[serde(rename = "cnsvolumes")]
6830 #[strum(serialize = "cnsvolumes")]
6831 Cnsvolumes,
6832 #[serde(rename = "filevolumes")]
6833 #[strum(serialize = "filevolumes")]
6834 Filevolumes,
6835 #[serde(rename = "diagnosticsfeedback")]
6836 #[strum(serialize = "diagnosticsfeedback")]
6837 Diagnosticsfeedback,
6838 #[serde(rename = "hostreservedcapacity")]
6839 #[strum(serialize = "hostreservedcapacity")]
6840 Hostreservedcapacity,
6841 #[serde(rename = "vmlevelcapacity")]
6842 #[strum(serialize = "vmlevelcapacity")]
6843 Vmlevelcapacity,
6844 #[serde(rename = "improvedcapacityscreen")]
6845 #[strum(serialize = "improvedcapacityscreen")]
6846 Improvedcapacityscreen,
6847 #[serde(rename = "slackspacecapacity")]
6848 #[strum(serialize = "slackspacecapacity")]
6849 Slackspacecapacity,
6850 #[serde(rename = "sharedwitness")]
6851 #[strum(serialize = "sharedwitness")]
6852 Sharedwitness,
6853 #[serde(rename = "VsanCapabilityType_Unknown")]
6854 #[strum(serialize = "VsanCapabilityType_Unknown")]
6855 VsanCapabilityTypeUnknown,
6856 #[serde(rename = "supportApiVersion")]
6857 #[strum(serialize = "supportApiVersion")]
6858 SupportApiVersion,
6859 #[serde(rename = "vsanmetadatanode")]
6860 #[strum(serialize = "vsanmetadatanode")]
6861 Vsanmetadatanode,
6862 #[serde(rename = "pmanintegration")]
6863 #[strum(serialize = "pmanintegration")]
6864 Pmanintegration,
6865 #[serde(rename = "wcpappplatform")]
6866 #[strum(serialize = "wcpappplatform")]
6867 Wcpappplatform,
6868 #[serde(rename = "diskresourceprecheck")]
6869 #[strum(serialize = "diskresourceprecheck")]
6870 Diskresourceprecheck,
6871 #[serde(rename = "metricsconfig")]
6872 #[strum(serialize = "metricsconfig")]
6873 Metricsconfig,
6874 #[serde(rename = "ioinsight")]
6875 #[strum(serialize = "ioinsight")]
6876 Ioinsight,
6877 #[serde(rename = "apidevversionenabled")]
6878 #[strum(serialize = "apidevversionenabled")]
6879 Apidevversionenabled,
6880 #[serde(rename = "nativelargeclustersupport")]
6881 #[strum(serialize = "nativelargeclustersupport")]
6882 Nativelargeclustersupport,
6883 #[serde(rename = "historicalhealth")]
6884 #[strum(serialize = "historicalhealth")]
6885 Historicalhealth,
6886 #[serde(rename = "dataintransitencryption")]
6887 #[strum(serialize = "dataintransitencryption")]
6888 Dataintransitencryption,
6889 #[serde(rename = "perfsvctwoyaxisgraph")]
6890 #[strum(serialize = "perfsvctwoyaxisgraph")]
6891 Perfsvctwoyaxisgraph,
6892 #[serde(rename = "compressiononly")]
6893 #[strum(serialize = "compressiononly")]
6894 Compressiononly,
6895 #[serde(rename = "remotedatastore")]
6896 #[strum(serialize = "remotedatastore")]
6897 Remotedatastore,
6898 #[serde(rename = "vsanmanagedvmfs")]
6899 #[strum(serialize = "vsanmanagedvmfs")]
6900 Vsanmanagedvmfs,
6901 #[serde(rename = "capacityreservation")]
6902 #[strum(serialize = "capacityreservation")]
6903 Capacityreservation,
6904 #[serde(rename = "securewipe")]
6905 #[strum(serialize = "securewipe")]
6906 Securewipe,
6907 #[serde(rename = "validateconfigspec")]
6908 #[strum(serialize = "validateconfigspec")]
6909 Validateconfigspec,
6910 #[serde(rename = "vsananalyticsevents")]
6911 #[strum(serialize = "vsananalyticsevents")]
6912 Vsananalyticsevents,
6913 #[serde(rename = "vsandefaultgatewaysupported")]
6914 #[strum(serialize = "vsandefaultgatewaysupported")]
6915 Vsandefaultgatewaysupported,
6916 #[serde(rename = "pspairgap")]
6917 #[strum(serialize = "pspairgap")]
6918 Pspairgap,
6919 #[serde(rename = "vsanmanagedpmem")]
6920 #[strum(serialize = "vsanmanagedpmem")]
6921 Vsanmanagedpmem,
6922 #[serde(rename = "capacityevaluationonvc")]
6923 #[strum(serialize = "capacityevaluationonvc")]
6924 Capacityevaluationonvc,
6925 #[serde(rename = "readlocalitytodrs")]
6926 #[strum(serialize = "readlocalitytodrs")]
6927 Readlocalitytodrs,
6928 #[serde(rename = "vsanencrkmx")]
6929 #[strum(serialize = "vsanencrkmx")]
6930 Vsanencrkmx,
6931 #[serde(rename = "vsan2encr")]
6932 #[strum(serialize = "vsan2encr")]
6933 Vsan2Encr,
6934 #[serde(rename = "dit4sw")]
6935 #[strum(serialize = "dit4sw")]
6936 Dit4Sw,
6937 #[serde(rename = "vsanclient")]
6938 #[strum(serialize = "vsanclient")]
6939 Vsanclient,
6940 #[serde(rename = "capacityoversubscription")]
6941 #[strum(serialize = "capacityoversubscription")]
6942 Capacityoversubscription,
6943 #[serde(rename = "vsandiagnostics")]
6944 #[strum(serialize = "vsandiagnostics")]
6945 Vsandiagnostics,
6946 #[serde(rename = "capacitycustomizablethresholds")]
6947 #[strum(serialize = "capacitycustomizablethresholds")]
6948 Capacitycustomizablethresholds,
6949 #[serde(rename = "hcimeshpolicy")]
6950 #[strum(serialize = "hcimeshpolicy")]
6951 Hcimeshpolicy,
6952 #[serde(rename = "topcontributors")]
6953 #[strum(serialize = "topcontributors")]
6954 Topcontributors,
6955 #[serde(rename = "vsandirectdiskdecom")]
6956 #[strum(serialize = "vsandirectdiskdecom")]
6957 Vsandirectdiskdecom,
6958 #[serde(rename = "diskmgmtredesign")]
6959 #[strum(serialize = "diskmgmtredesign")]
6960 Diskmgmtredesign,
6961 #[serde(rename = "datapersistresourcecheck")]
6962 #[strum(serialize = "datapersistresourcecheck")]
6963 Datapersistresourcecheck,
6964 #[serde(rename = "clusterpoweraction")]
6965 #[strum(serialize = "clusterpoweraction")]
6966 Clusterpoweraction,
6967 #[serde(rename = "clusterpowerselfcontain")]
6968 #[strum(serialize = "clusterpowerselfcontain")]
6969 Clusterpowerselfcontain,
6970 #[serde(rename = "duplicatepciidfix")]
6971 #[strum(serialize = "duplicatepciidfix")]
6972 Duplicatepciidfix,
6973 #[serde(rename = "healthcorrelation")]
6974 #[strum(serialize = "healthcorrelation")]
6975 Healthcorrelation,
6976 #[serde(rename = "volumerelocation")]
6977 #[strum(serialize = "volumerelocation")]
6978 Volumerelocation,
6979 #[serde(rename = "iodiagnostics")]
6980 #[strum(serialize = "iodiagnostics")]
6981 Iodiagnostics,
6982 #[serde(rename = "vsanrebuildtrim")]
6983 #[strum(serialize = "vsanrebuildtrim")]
6984 Vsanrebuildtrim,
6985 #[serde(rename = "elasticpolicy")]
6986 #[strum(serialize = "elasticpolicy")]
6987 Elasticpolicy,
6988 #[serde(rename = "vsanEsaConfigure")]
6989 #[strum(serialize = "vsanEsaConfigure")]
6990 VsanEsaConfigure,
6991 #[serde(rename = "hdcsintegration")]
6992 #[strum(serialize = "hdcsintegration")]
6993 Hdcsintegration,
6994 #[serde(rename = "vsanesasingletier")]
6995 #[strum(serialize = "vsanesasingletier")]
6996 Vsanesasingletier,
6997 #[serde(rename = "vsanperfhighresolution")]
6998 #[strum(serialize = "vsanperfhighresolution")]
6999 Vsanperfhighresolution,
7000 #[serde(rename = "cnsreconfigpolicy")]
7001 #[strum(serialize = "cnsreconfigpolicy")]
7002 Cnsreconfigpolicy,
7003 #[serde(rename = "vsanhostdomlatencysort")]
7004 #[strum(serialize = "vsanhostdomlatencysort")]
7005 Vsanhostdomlatencysort,
7006 #[serde(rename = "sha256thumbprint")]
7007 #[strum(serialize = "sha256thumbprint")]
7008 Sha256Thumbprint,
7009 #[serde(rename = "minrebalancethreshold")]
7010 #[strum(serialize = "minrebalancethreshold")]
7011 Minrebalancethreshold,
7012 #[serde(rename = "vsan2hcimesh")]
7013 #[strum(serialize = "vsan2hcimesh")]
7014 Vsan2Hcimesh,
7015 #[serde(rename = "dfcobjectsmanagement")]
7016 #[strum(serialize = "dfcobjectsmanagement")]
7017 Dfcobjectsmanagement,
7018 #[serde(rename = "healthremediation")]
7019 #[strum(serialize = "healthremediation")]
7020 Healthremediation,
7021 #[serde(rename = "hcimeshstretchedcluster")]
7022 #[strum(serialize = "hcimeshstretchedcluster")]
7023 Hcimeshstretchedcluster,
7024 #[serde(rename = "vsanxvchcimesh")]
7025 #[strum(serialize = "vsanxvchcimesh")]
7026 Vsanxvchcimesh,
7027 #[serde(rename = "vsan2deeprekey")]
7028 #[strum(serialize = "vsan2deeprekey")]
7029 Vsan2Deeprekey,
7030 #[serde(rename = "vsandsdefaultpolicy")]
7031 #[strum(serialize = "vsandsdefaultpolicy")]
7032 Vsandsdefaultpolicy,
7033 #[serde(rename = "vsanperfsvc80u2")]
7034 #[strum(serialize = "vsanperfsvc80u2")]
7035 Vsanperfsvc80U2,
7036 #[serde(rename = "vsankeyexpiration")]
7037 #[strum(serialize = "vsankeyexpiration")]
7038 Vsankeyexpiration,
7039 #[serde(rename = "vsanxvchcimeshv2")]
7040 #[strum(serialize = "vsanxvchcimeshv2")]
7041 Vsanxvchcimeshv2,
7042 #[serde(rename = "dhci")]
7043 #[strum(serialize = "dhci")]
7044 Dhci,
7045 #[serde(rename = "snapservice")]
7046 #[strum(serialize = "snapservice")]
7047 Snapservice,
7048 #[serde(rename = "vsan2disableencryption")]
7049 #[strum(serialize = "vsan2disableencryption")]
7050 Vsan2Disableencryption,
7051 #[serde(rename = "iodiagmultiplevms")]
7052 #[strum(serialize = "iodiagmultiplevms")]
7053 Iodiagmultiplevms,
7054 #[serde(rename = "vsanxvchcimeshv3")]
7055 #[strum(serialize = "vsanxvchcimeshv3")]
7056 Vsanxvchcimeshv3,
7057 /// This variant handles values not known at compile time.
7058 #[serde(untagged)]
7059 #[strum(serialize = "__OTHER__")]
7060 Other_(String),
7061}
7062/// Represents a feature capability for 9.0 release.
7063///
7064/// Possible values:
7065/// - `vsanreplication`
7066/// - `vsandedicatedvmknic`
7067/// - `globaldedup`
7068/// - `vsanstretchedclient`
7069/// - `vsaniscsivip`
7070/// - `vsansitemaintenance`
7071#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
7072pub enum VsanCapabilityType90Enum {
7073 #[serde(rename = "vsanreplication")]
7074 #[strum(serialize = "vsanreplication")]
7075 Vsanreplication,
7076 #[serde(rename = "vsandedicatedvmknic")]
7077 #[strum(serialize = "vsandedicatedvmknic")]
7078 Vsandedicatedvmknic,
7079 #[serde(rename = "globaldedup")]
7080 #[strum(serialize = "globaldedup")]
7081 Globaldedup,
7082 #[serde(rename = "vsanstretchedclient")]
7083 #[strum(serialize = "vsanstretchedclient")]
7084 Vsanstretchedclient,
7085 #[serde(rename = "vsaniscsivip")]
7086 #[strum(serialize = "vsaniscsivip")]
7087 Vsaniscsivip,
7088 #[serde(rename = "vsansitemaintenance")]
7089 #[strum(serialize = "vsansitemaintenance")]
7090 Vsansitemaintenance,
7091 /// This variant handles values not known at compile time.
7092 #[serde(untagged)]
7093 #[strum(serialize = "__OTHER__")]
7094 Other_(String),
7095}
7096/// The vSAN cluster health action ID enumeration.
7097///
7098/// Actions are remediation operations user can take to resolve health issues.
7099/// Each action is identified by ID. The user performs the action by calling the
7100/// associated first-class API. But it's not always appropriate to trigger such
7101/// operation and user need to use judgment of the situation to decide. This is
7102/// why the action is not automatically executed, as it may be the wrong choice
7103/// in some situations.
7104/// Some actions don't directly correspond to an API, but rather a workflow, in
7105/// the case of the UI a wizard.
7106///
7107/// Possible values:
7108/// - `RepairClusterObjectsAction`: Mapped to *VsanVcClusterHealthSystem.VsanHealthRepairClusterObjectsImmediate* API.
7109/// - `UploadHclDb`: Mapped to *VsanVcClusterHealthSystem.VsanVcUploadHclDb* API.
7110/// - `UpdateHclDbFromInternet`: Mapped to *VsanVcClusterHealthSystem.VsanVcUpdateHclDbFromWeb* API.
7111/// - `EnableHealthService`: Deprecated.
7112/// - `DiskBalance`: Mapped to *VsanVcClusterHealthSystem.VsanRebalanceCluster* API.
7113/// - `StopDiskBalance`: Mapped to *VsanVcClusterHealthSystem.VsanStopRebalanceCluster* API.
7114/// - `RemediateDedup`: Mapped to *VsanUpgradeSystemEx.PerformVsanUpgradeEx* API.
7115/// - `UpgradeVsanDiskFormat`: Mapped to *VsanUpgradeSystemEx.PerformVsanUpgradeEx* API.
7116/// - `CreateDVS`: Mapped to UI workflow "Create VDS".
7117/// - `ConfigureHA`: Mapped to UI workflow "Configure HA".
7118/// - `ConfigureDRS`: Mapped to UI workflow "Configure DRS".
7119/// - `ConfigureVSAN`: Mapped to UI workflow "Configure vSAN".
7120/// - `ClaimVSANDisks`: Mapped to UI workflow "Claim vSAN Disks".
7121/// - `ClusterUpgrade`: Mapped to UI workflow "vSAN On-click Upgrade Wizard".
7122/// - `CreateVMKnic`: Mapped to UI workflow "Create vmknic Wizard".
7123/// - `CreateVMKnicWithVMotion`: Mapped to UI workflow "Create vmknic with vMotion Wizard".
7124/// - `RunBurnInTest`: Mapped to UI workflow "Run Storage performance test".
7125/// - `EnableIscsiTargetService`: Mapped to UI workflow "Enable vSAN iSCSI service".
7126/// - `EnablePerformanceServiceAction`: Mapped to *VsanPerformanceManager.VsanPerfCreateStatsObjectTask* API.
7127/// - `RemediateClusterConfig`: Mapped to UI workflow "Remediate inconsistent configuration".
7128/// - `EnableCeip`: Mapped to UI workflow "Customer Experience Improvement Program (CEIP) page".
7129/// - `LoginVumIsoDepot`: Mapped to *VsanVumSystem.FetchIsoDepotCookie* API.
7130/// - `PurgeInaccessSwapObjs`: Mapped to UI workflow "Purge Inaccessible VM Swap Objects".
7131/// - `UploadReleaseCatalog`: Mapped to UI workflow "Update release catalog from file".
7132/// - `ConfigureAutomaticRebalance`
7133/// - `RemediateFileService`
7134/// - `RelayoutVsanObjects`
7135/// - `RemediateFileServiceImbalance`
7136/// - `SelectNvme`
7137/// - `CreateFileServiceDomain`
7138/// - `RemediateIscsiLunsRuntimeStatus`
7139/// - `ShallowRekey`
7140/// - `VsanClusterHealthActionIdEnum_Unknown`
7141#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
7142pub enum VsanClusterHealthActionIdEnumEnum {
7143 RepairClusterObjectsAction,
7144 UploadHclDb,
7145 UpdateHclDbFromInternet,
7146 EnableHealthService,
7147 DiskBalance,
7148 StopDiskBalance,
7149 RemediateDedup,
7150 UpgradeVsanDiskFormat,
7151 #[serde(rename = "CreateDVS")]
7152 #[strum(serialize = "CreateDVS")]
7153 CreateDvs,
7154 #[serde(rename = "ConfigureHA")]
7155 #[strum(serialize = "ConfigureHA")]
7156 ConfigureHa,
7157 #[serde(rename = "ConfigureDRS")]
7158 #[strum(serialize = "ConfigureDRS")]
7159 ConfigureDrs,
7160 #[serde(rename = "ConfigureVSAN")]
7161 #[strum(serialize = "ConfigureVSAN")]
7162 ConfigureVsan,
7163 #[serde(rename = "ClaimVSANDisks")]
7164 #[strum(serialize = "ClaimVSANDisks")]
7165 ClaimVsanDisks,
7166 ClusterUpgrade,
7167 #[serde(rename = "CreateVMKnic")]
7168 #[strum(serialize = "CreateVMKnic")]
7169 CreateVmKnic,
7170 #[serde(rename = "CreateVMKnicWithVMotion")]
7171 #[strum(serialize = "CreateVMKnicWithVMotion")]
7172 CreateVmKnicWithVMotion,
7173 RunBurnInTest,
7174 EnableIscsiTargetService,
7175 EnablePerformanceServiceAction,
7176 RemediateClusterConfig,
7177 EnableCeip,
7178 LoginVumIsoDepot,
7179 PurgeInaccessSwapObjs,
7180 UploadReleaseCatalog,
7181 ConfigureAutomaticRebalance,
7182 RemediateFileService,
7183 RelayoutVsanObjects,
7184 RemediateFileServiceImbalance,
7185 SelectNvme,
7186 CreateFileServiceDomain,
7187 RemediateIscsiLunsRuntimeStatus,
7188 ShallowRekey,
7189 #[serde(rename = "VsanClusterHealthActionIdEnum_Unknown")]
7190 #[strum(serialize = "VsanClusterHealthActionIdEnum_Unknown")]
7191 VsanClusterHealthActionIdEnumUnknown,
7192 /// This variant handles values not known at compile time.
7193 #[serde(untagged)]
7194 #[strum(serialize = "__OTHER__")]
7195 Other_(String),
7196}
7197/// The vSAN cluster health category enumeration.
7198///
7199/// Each of non-green health check belongs to a specific category
7200/// according to its actual user impact. The health score can be
7201/// calculated based on it.
7202///
7203/// Possible values:
7204/// - `DataAvailability`: The health category which impacts the vSAN object data availability and need user immediate action to avoid possible data loss.
7205/// - `InfraAvailability`: The health category which impacts the vSAN cluster infrastructure availability like host/network/disk health.
7206///
7207/// Notice it may impact data availability eventually.
7208/// - `DataPerformance`: The health category which impacts the vSAN object data performance like congestion health.
7209/// - `InfraPerformance`: The health category which impacts the vSAN cluster infrastructure performance like network latency health.
7210///
7211/// Notice it may impact user data performance eventually.
7212/// - `CapacityUtilization`: The health category which impacts the vSAN cluster capacity utilization.
7213/// - `SoftResourceUtilization`: The health category which impacts the vSAN software resource utilization like component health.
7214/// - `Compliance`: The health category of which health warning is not compliant with vSAN cluster requirement or recommendation.
7215///
7216/// 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.
7217/// - `VsanClusterHealthCategoryEnum_Unknown`
7218#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
7219pub enum VsanClusterHealthCategoryEnumEnum {
7220 DataAvailability,
7221 InfraAvailability,
7222 DataPerformance,
7223 InfraPerformance,
7224 CapacityUtilization,
7225 SoftResourceUtilization,
7226 Compliance,
7227 #[serde(rename = "VsanClusterHealthCategoryEnum_Unknown")]
7228 #[strum(serialize = "VsanClusterHealthCategoryEnum_Unknown")]
7229 VsanClusterHealthCategoryEnumUnknown,
7230 /// This variant handles values not known at compile time.
7231 #[serde(untagged)]
7232 #[strum(serialize = "__OTHER__")]
7233 Other_(String),
7234}
7235/// The vSAN Datastore type.
7236///
7237/// It can be used in
7238/// *QueryVsanManagedStorageSpaceUsageSpec*.
7239///
7240/// Possible values:
7241/// - `vsan`: The vSAN storage type.
7242/// - `vsandirect`: The vSAN direct storage type.
7243/// - `pmem`:
7244///
7245/// Deprecated as of vSphere 9.0 APIs with no replacement.
7246///
7247/// Do not use.
7248/// - `VsanDatastoreType_Unknown`: represent the value when the lower version client cannot recognize the
7249/// enum value.
7250#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
7251pub enum VsanDatastoreTypeEnum {
7252 #[serde(rename = "vsan")]
7253 #[strum(serialize = "vsan")]
7254 Vsan,
7255 #[serde(rename = "vsandirect")]
7256 #[strum(serialize = "vsandirect")]
7257 Vsandirect,
7258 #[serde(rename = "pmem")]
7259 #[strum(serialize = "pmem")]
7260 Pmem,
7261 #[serde(rename = "VsanDatastoreType_Unknown")]
7262 #[strum(serialize = "VsanDatastoreType_Unknown")]
7263 VsanDatastoreTypeUnknown,
7264 /// This variant handles values not known at compile time.
7265 #[serde(untagged)]
7266 #[strum(serialize = "__OTHER__")]
7267 Other_(String),
7268}
7269/// The type of the disk group to created.
7270///
7271/// Possible values:
7272/// - `allflash`
7273/// - `hybrid`
7274/// - `vsandirect`
7275/// - `pmem`:
7276///
7277/// Deprecated as of vSphere 9.0 APIs with no replacement.
7278///
7279/// Do not use.
7280/// - `VsanDiskGroupCreationType_Unknown`
7281#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
7282pub enum VimClusterVsanDiskGroupCreationTypeEnum {
7283 #[serde(rename = "allflash")]
7284 #[strum(serialize = "allflash")]
7285 Allflash,
7286 #[serde(rename = "hybrid")]
7287 #[strum(serialize = "hybrid")]
7288 Hybrid,
7289 #[serde(rename = "vsandirect")]
7290 #[strum(serialize = "vsandirect")]
7291 Vsandirect,
7292 #[serde(rename = "pmem")]
7293 #[strum(serialize = "pmem")]
7294 Pmem,
7295 #[serde(rename = "VsanDiskGroupCreationType_Unknown")]
7296 #[strum(serialize = "VsanDiskGroupCreationType_Unknown")]
7297 VsanDiskGroupCreationTypeUnknown,
7298 /// This variant handles values not known at compile time.
7299 #[serde(untagged)]
7300 #[strum(serialize = "__OTHER__")]
7301 Other_(String),
7302}
7303/// Type of ioinsight instance, which can be either running or completed.
7304///
7305/// Possible values:
7306/// - `running`: Indicate the query is only for ioinsight instance which is still running.
7307/// - `completed`: Query is for ioinsight instance which has stopped successfully.
7308/// - `crashed`: Indicate an ioinsight instance is crashed for some unexpected reason.
7309/// - `VsanIoInsightInstanceState_unknown`
7310#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
7311pub enum VsanIoInsightInstanceStateEnum {
7312 #[serde(rename = "running")]
7313 #[strum(serialize = "running")]
7314 Running,
7315 #[serde(rename = "completed")]
7316 #[strum(serialize = "completed")]
7317 Completed,
7318 #[serde(rename = "crashed")]
7319 #[strum(serialize = "crashed")]
7320 Crashed,
7321 #[serde(rename = "VsanIoInsightInstanceState_unknown")]
7322 #[strum(serialize = "VsanIoInsightInstanceState_unknown")]
7323 VsanIoInsightInstanceStateUnknown,
7324 /// This variant handles values not known at compile time.
7325 #[serde(untagged)]
7326 #[strum(serialize = "__OTHER__")]
7327 Other_(String),
7328}
7329/// Defines iSCSI LUN status, supported values are Online, Offline.
7330///
7331/// Possible values:
7332/// - `Online`: LUN is a configuration status, which is a desired state.
7333///
7334/// If LUN is online, initiators can discover the LUN after login to the target.
7335/// - `Offline`: LUN is a configuration status, which is a desired state.
7336///
7337/// If LUN is offline, initiators can not discover the LUN after login to the target, all existing connections are closed.
7338/// - `VsanIscsiLUNStatus_Unknown`
7339#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
7340pub enum VsanIscsiLunStatusEnum {
7341 Online,
7342 Offline,
7343 #[serde(rename = "VsanIscsiLUNStatus_Unknown")]
7344 #[strum(serialize = "VsanIscsiLUNStatus_Unknown")]
7345 VsanIscsiLunStatusUnknown,
7346 /// This variant handles values not known at compile time.
7347 #[serde(untagged)]
7348 #[strum(serialize = "__OTHER__")]
7349 Other_(String),
7350}
7351/// Defines iSCSI LUN runtime status type for iSCSI target service.
7352///
7353/// Possible values:
7354/// - `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.
7355/// - `Offline`: LUN is not loaded in kernel.
7356///
7357/// If LUN runtime status is offline, initiators can't discover it after login to the target.
7358/// - `VsanIscsiLUNRuntimeStatusType_Unknown`
7359#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
7360pub enum VsanIscsiLunRuntimeStatusTypeEnum {
7361 Online,
7362 Offline,
7363 #[serde(rename = "VsanIscsiLUNRuntimeStatusType_Unknown")]
7364 #[strum(serialize = "VsanIscsiLUNRuntimeStatusType_Unknown")]
7365 VsanIscsiLunRuntimeStatusTypeUnknown,
7366 /// This variant handles values not known at compile time.
7367 #[serde(untagged)]
7368 #[strum(serialize = "__OTHER__")]
7369 Other_(String),
7370}
7371/// Defines iSCSI authentication type.
7372///
7373/// Possible values:
7374/// - `NoAuth`: No authentication is used, the target can be connected by any initiator.
7375/// - `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.
7376/// - `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.
7377/// - `VsanIscsiTargetAuthType_Unknown`
7378#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
7379pub enum VsanIscsiTargetAuthTypeEnum {
7380 NoAuth,
7381 #[serde(rename = "CHAP")]
7382 #[strum(serialize = "CHAP")]
7383 Chap,
7384 #[serde(rename = "CHAP_Mutual")]
7385 #[strum(serialize = "CHAP_Mutual")]
7386 ChapMutual,
7387 #[serde(rename = "VsanIscsiTargetAuthType_Unknown")]
7388 #[strum(serialize = "VsanIscsiTargetAuthType_Unknown")]
7389 VsanIscsiTargetAuthTypeUnknown,
7390 /// This variant handles values not known at compile time.
7391 #[serde(untagged)]
7392 #[strum(serialize = "__OTHER__")]
7393 Other_(String),
7394}
7395/// Defines iSCSI target service process status.
7396///
7397/// Possible values:
7398/// - `Running`: Process is running.
7399/// - `Stopped`: Process is stopped.
7400/// - `VsanIscsiTargetServiceProcessStatus_Unknown`
7401#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
7402pub enum VsanIscsiTargetServiceProcessStatusEnum {
7403 Running,
7404 Stopped,
7405 #[serde(rename = "VsanIscsiTargetServiceProcessStatus_Unknown")]
7406 #[strum(serialize = "VsanIscsiTargetServiceProcessStatus_Unknown")]
7407 VsanIscsiTargetServiceProcessStatusUnknown,
7408 /// This variant handles values not known at compile time.
7409 #[serde(untagged)]
7410 #[strum(serialize = "__OTHER__")]
7411 Other_(String),
7412}
7413/// Defines the possible types for the vSAN objects in 8.x and previous
7414/// releases.
7415///
7416/// Possible values:
7417/// - `vmswap`: The VM swap files.
7418/// - `vdisk`: The virtual disks.
7419/// - `namespace`: The VM home objects.
7420/// - `vmem`: The VM snapshot memory files.
7421/// - `statsdb`: The vSAN performance management objects.
7422/// - `iscsiTarget`: The vSAN iSCSI home and target objects.
7423/// - `iscsiLun`: The vSAN iSCSI LUNs.
7424/// - `other`: Other vSAN objects.
7425/// - `fileSystemOverhead`: vSAN File system overhead.
7426/// - `dedupOverhead`: Deduplication and compression overhead.
7427/// - `spaceUnderDedupConsideration`
7428/// - `checksumOverhead`: Checksum overhead.
7429/// - `improvedVirtualDisk`: First Class Disks.
7430/// - `transientSpace`
7431/// - `slackSpaceCapRequiredForHost`
7432/// - `resynPauseThresholdForHost`
7433/// - `minSpaceRequiredForVsanOp`
7434/// - `hostRebuildCapacity`
7435/// - `physicalTransientSpace`
7436/// - `haMetadataObject`
7437/// - `fileServiceRoot`
7438/// - `attachedCnsVolBlock`
7439/// - `detachedCnsVolBlock`
7440/// - `attachedCnsVolFile`
7441/// - `detachedCnsVolFile`
7442/// - `cnsVolFile`
7443/// - `fileShare`
7444/// - `extension`
7445/// - `hbrDisk`
7446/// - `hbrCfg`
7447/// - `hbrPersist`
7448/// - `traceobject`
7449/// - `esaObjectOverhead`
7450/// - `VsanObjectTypeEnum_Unknown`
7451#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
7452pub enum VsanObjectTypeEnumEnum {
7453 #[serde(rename = "vmswap")]
7454 #[strum(serialize = "vmswap")]
7455 Vmswap,
7456 #[serde(rename = "vdisk")]
7457 #[strum(serialize = "vdisk")]
7458 Vdisk,
7459 #[serde(rename = "namespace")]
7460 #[strum(serialize = "namespace")]
7461 Namespace,
7462 #[serde(rename = "vmem")]
7463 #[strum(serialize = "vmem")]
7464 Vmem,
7465 #[serde(rename = "statsdb")]
7466 #[strum(serialize = "statsdb")]
7467 Statsdb,
7468 #[serde(rename = "iscsiTarget")]
7469 #[strum(serialize = "iscsiTarget")]
7470 IscsiTarget,
7471 #[serde(rename = "iscsiLun")]
7472 #[strum(serialize = "iscsiLun")]
7473 IscsiLun,
7474 #[serde(rename = "other")]
7475 #[strum(serialize = "other")]
7476 Other,
7477 #[serde(rename = "fileSystemOverhead")]
7478 #[strum(serialize = "fileSystemOverhead")]
7479 FileSystemOverhead,
7480 #[serde(rename = "dedupOverhead")]
7481 #[strum(serialize = "dedupOverhead")]
7482 DedupOverhead,
7483 #[serde(rename = "spaceUnderDedupConsideration")]
7484 #[strum(serialize = "spaceUnderDedupConsideration")]
7485 SpaceUnderDedupConsideration,
7486 #[serde(rename = "checksumOverhead")]
7487 #[strum(serialize = "checksumOverhead")]
7488 ChecksumOverhead,
7489 #[serde(rename = "improvedVirtualDisk")]
7490 #[strum(serialize = "improvedVirtualDisk")]
7491 ImprovedVirtualDisk,
7492 #[serde(rename = "transientSpace")]
7493 #[strum(serialize = "transientSpace")]
7494 TransientSpace,
7495 #[serde(rename = "slackSpaceCapRequiredForHost")]
7496 #[strum(serialize = "slackSpaceCapRequiredForHost")]
7497 SlackSpaceCapRequiredForHost,
7498 #[serde(rename = "resynPauseThresholdForHost")]
7499 #[strum(serialize = "resynPauseThresholdForHost")]
7500 ResynPauseThresholdForHost,
7501 #[serde(rename = "minSpaceRequiredForVsanOp")]
7502 #[strum(serialize = "minSpaceRequiredForVsanOp")]
7503 MinSpaceRequiredForVsanOp,
7504 #[serde(rename = "hostRebuildCapacity")]
7505 #[strum(serialize = "hostRebuildCapacity")]
7506 HostRebuildCapacity,
7507 #[serde(rename = "physicalTransientSpace")]
7508 #[strum(serialize = "physicalTransientSpace")]
7509 PhysicalTransientSpace,
7510 #[serde(rename = "haMetadataObject")]
7511 #[strum(serialize = "haMetadataObject")]
7512 HaMetadataObject,
7513 #[serde(rename = "fileServiceRoot")]
7514 #[strum(serialize = "fileServiceRoot")]
7515 FileServiceRoot,
7516 #[serde(rename = "attachedCnsVolBlock")]
7517 #[strum(serialize = "attachedCnsVolBlock")]
7518 AttachedCnsVolBlock,
7519 #[serde(rename = "detachedCnsVolBlock")]
7520 #[strum(serialize = "detachedCnsVolBlock")]
7521 DetachedCnsVolBlock,
7522 #[serde(rename = "attachedCnsVolFile")]
7523 #[strum(serialize = "attachedCnsVolFile")]
7524 AttachedCnsVolFile,
7525 #[serde(rename = "detachedCnsVolFile")]
7526 #[strum(serialize = "detachedCnsVolFile")]
7527 DetachedCnsVolFile,
7528 #[serde(rename = "cnsVolFile")]
7529 #[strum(serialize = "cnsVolFile")]
7530 CnsVolFile,
7531 #[serde(rename = "fileShare")]
7532 #[strum(serialize = "fileShare")]
7533 FileShare,
7534 #[serde(rename = "extension")]
7535 #[strum(serialize = "extension")]
7536 Extension,
7537 #[serde(rename = "hbrDisk")]
7538 #[strum(serialize = "hbrDisk")]
7539 HbrDisk,
7540 #[serde(rename = "hbrCfg")]
7541 #[strum(serialize = "hbrCfg")]
7542 HbrCfg,
7543 #[serde(rename = "hbrPersist")]
7544 #[strum(serialize = "hbrPersist")]
7545 HbrPersist,
7546 #[serde(rename = "traceobject")]
7547 #[strum(serialize = "traceobject")]
7548 Traceobject,
7549 #[serde(rename = "esaObjectOverhead")]
7550 #[strum(serialize = "esaObjectOverhead")]
7551 EsaObjectOverhead,
7552 #[serde(rename = "VsanObjectTypeEnum_Unknown")]
7553 #[strum(serialize = "VsanObjectTypeEnum_Unknown")]
7554 VsanObjectTypeEnumUnknown,
7555 /// This variant handles values not known at compile time.
7556 #[serde(untagged)]
7557 #[strum(serialize = "__OTHER__")]
7558 Other_(String),
7559}
7560/// Defines the possible types for the vSAN objects in 9.0 release.
7561///
7562/// Possible values:
7563/// - `dedupSharedUserData`
7564#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
7565pub enum VsanObjectTypeEnum90Enum {
7566 #[serde(rename = "dedupSharedUserData")]
7567 #[strum(serialize = "dedupSharedUserData")]
7568 DedupSharedUserData,
7569 /// This variant handles values not known at compile time.
7570 #[serde(untagged)]
7571 #[strum(serialize = "__OTHER__")]
7572 Other_(String),
7573}
7574/// The query type indicating the goal of the vSAN performance diagnostic
7575/// query, with the following values.
7576///
7577/// Possible values:
7578/// - `tput`: This query type is for a benchmarking test diagnosing if the best throughput was achieved on the vSAN cluster.
7579/// - `iops`: This query type is for a benchmarking test diagnosing if the best IOPS was achieved on the vSAN cluster.
7580/// - `lat`: This query type is for a benchmarking test diagnosing if the best latency was achieved on the vSAN cluster.
7581/// - `eval`: This query type is for general evaluation of the cluster.
7582///
7583/// This mode is available for experiments only and not certified for production use.
7584/// - `VsanPerfDiagnosticQueryType_Unknown`
7585#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
7586pub enum VsanPerfDiagnosticQueryTypeEnum {
7587 #[serde(rename = "tput")]
7588 #[strum(serialize = "tput")]
7589 Tput,
7590 #[serde(rename = "iops")]
7591 #[strum(serialize = "iops")]
7592 Iops,
7593 #[serde(rename = "lat")]
7594 #[strum(serialize = "lat")]
7595 Lat,
7596 #[serde(rename = "eval")]
7597 #[strum(serialize = "eval")]
7598 Eval,
7599 #[serde(rename = "VsanPerfDiagnosticQueryType_Unknown")]
7600 #[strum(serialize = "VsanPerfDiagnosticQueryType_Unknown")]
7601 VsanPerfDiagnosticQueryTypeUnknown,
7602 /// This variant handles values not known at compile time.
7603 #[serde(untagged)]
7604 #[strum(serialize = "__OTHER__")]
7605 Other_(String),
7606}
7607/// Stats unit types indicate the unit display for UI
7608/// Valid types are:
7609///
7610/// Possible values:
7611/// - `number`: a number (int) without unit, like IOPS.
7612/// - `time_ms`: a time unit (int) measured by milliseconds.
7613/// - `percentage`: a number (int) between 0 and 100, representing the percentage.
7614/// - `size_bytes`: a unit for the size measured by bytes.
7615/// - `rate_bytes`: a rate unit for bytes per second.
7616/// - `permille`: a number (int) between 0 and 1000, representing the permille.
7617/// - `time_s`
7618/// - `time_us`
7619/// - `time_ns`
7620/// - `VsanPerfStatsUnitType_Unknown`
7621#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
7622pub enum VsanPerfStatsUnitTypeEnum {
7623 #[serde(rename = "number")]
7624 #[strum(serialize = "number")]
7625 Number,
7626 #[serde(rename = "time_ms")]
7627 #[strum(serialize = "time_ms")]
7628 TimeMs,
7629 #[serde(rename = "percentage")]
7630 #[strum(serialize = "percentage")]
7631 Percentage,
7632 #[serde(rename = "size_bytes")]
7633 #[strum(serialize = "size_bytes")]
7634 SizeBytes,
7635 #[serde(rename = "rate_bytes")]
7636 #[strum(serialize = "rate_bytes")]
7637 RateBytes,
7638 #[serde(rename = "permille")]
7639 #[strum(serialize = "permille")]
7640 Permille,
7641 #[serde(rename = "time_s")]
7642 #[strum(serialize = "time_s")]
7643 TimeS,
7644 #[serde(rename = "time_us")]
7645 #[strum(serialize = "time_us")]
7646 TimeUs,
7647 #[serde(rename = "time_ns")]
7648 #[strum(serialize = "time_ns")]
7649 TimeNs,
7650 #[serde(rename = "VsanPerfStatsUnitType_Unknown")]
7651 #[strum(serialize = "VsanPerfStatsUnitType_Unknown")]
7652 VsanPerfStatsUnitTypeUnknown,
7653 /// This variant handles values not known at compile time.
7654 #[serde(untagged)]
7655 #[strum(serialize = "__OTHER__")]
7656 Other_(String),
7657}
7658/// The type of statistical measurement that a metric value represents.
7659///
7660/// Valid types are:
7661///
7662/// Possible values:
7663/// - `absolute`: Represents an actual value, level, or state of the counter.
7664///
7665/// 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.
7666/// - `delta`: Represents an amount of change for the metric during the sampling period as compared to the previous interval.
7667/// - `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.
7668///
7669/// For example, the number of reads per second.
7670/// - `VsanPerfStatsType_Unknown`
7671#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
7672pub enum VsanPerfStatsTypeEnum {
7673 #[serde(rename = "absolute")]
7674 #[strum(serialize = "absolute")]
7675 Absolute,
7676 #[serde(rename = "delta")]
7677 #[strum(serialize = "delta")]
7678 Delta,
7679 #[serde(rename = "rate")]
7680 #[strum(serialize = "rate")]
7681 Rate,
7682 #[serde(rename = "VsanPerfStatsType_Unknown")]
7683 #[strum(serialize = "VsanPerfStatsType_Unknown")]
7684 VsanPerfStatsTypeUnknown,
7685 /// This variant handles values not known at compile time.
7686 #[serde(untagged)]
7687 #[strum(serialize = "__OTHER__")]
7688 Other_(String),
7689}
7690/// Stats summarization types indicate how multiple samples of a specific metric
7691/// are transformed or aggregated into a single statistical value.
7692///
7693/// Valid types are:
7694///
7695/// Possible values:
7696/// - `average`: The actual value collected or the average of all values collected during the summary period.
7697/// - `maximum`: The maximum value of the performance metric value over the summarization period.
7698/// - `minimum`: The minimum value of the performance metric value over the summarization period.
7699/// - `latest`: The most recent value of the performance metric over the summarization period.
7700/// - `summation`: The sum of all the values of the performance metric over the summarization period.
7701/// - `none`: The counter is never rolled up.
7702/// - `VsanPerfSummaryType_Unknown`
7703#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
7704pub enum VsanPerfSummaryTypeEnum {
7705 #[serde(rename = "average")]
7706 #[strum(serialize = "average")]
7707 Average,
7708 #[serde(rename = "maximum")]
7709 #[strum(serialize = "maximum")]
7710 Maximum,
7711 #[serde(rename = "minimum")]
7712 #[strum(serialize = "minimum")]
7713 Minimum,
7714 #[serde(rename = "latest")]
7715 #[strum(serialize = "latest")]
7716 Latest,
7717 #[serde(rename = "summation")]
7718 #[strum(serialize = "summation")]
7719 Summation,
7720 #[serde(rename = "none")]
7721 #[strum(serialize = "none")]
7722 None,
7723 #[serde(rename = "VsanPerfSummaryType_Unknown")]
7724 #[strum(serialize = "VsanPerfSummaryType_Unknown")]
7725 VsanPerfSummaryTypeUnknown,
7726 /// This variant handles values not known at compile time.
7727 #[serde(untagged)]
7728 #[strum(serialize = "__OTHER__")]
7729 Other_(String),
7730}
7731/// The direction of threshold value indicates whether it is upper limit or
7732/// lower limit.
7733///
7734/// Possible values:
7735/// - `upper`: The threshold is an upper limit.
7736///
7737/// When the performance metric value exceeds the threshold, it will display warnings in graph.
7738/// - `lower`: The threshold is a lower limit.
7739///
7740/// When the performance metric value is lower than the threshold, it will display warnings in graph.
7741/// - `VsanPerfThresholdDirectionType_Unknown`
7742#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
7743pub enum VsanPerfThresholdDirectionTypeEnum {
7744 #[serde(rename = "upper")]
7745 #[strum(serialize = "upper")]
7746 Upper,
7747 #[serde(rename = "lower")]
7748 #[strum(serialize = "lower")]
7749 Lower,
7750 #[serde(rename = "VsanPerfThresholdDirectionType_Unknown")]
7751 #[strum(serialize = "VsanPerfThresholdDirectionType_Unknown")]
7752 VsanPerfThresholdDirectionTypeUnknown,
7753 /// This variant handles values not known at compile time.
7754 #[serde(untagged)]
7755 #[strum(serialize = "__OTHER__")]
7756 Other_(String),
7757}
7758/// Defines the error code of *VsanObjectSystem.RelayoutObjects*.
7759///
7760/// Possible values:
7761/// - `outOfResources`: indicates resources are not enough.
7762/// - `generic`: indicates all failures not covered by the errors defined above.
7763/// - `VsanRelayoutObjectsErrorCode_Unknown`: represent the value when the lower version client cannot recognize the enum value.
7764#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
7765pub enum VsanRelayoutObjectsErrorCodeEnum {
7766 #[serde(rename = "outOfResources")]
7767 #[strum(serialize = "outOfResources")]
7768 OutOfResources,
7769 #[serde(rename = "generic")]
7770 #[strum(serialize = "generic")]
7771 Generic,
7772 #[serde(rename = "VsanRelayoutObjectsErrorCode_Unknown")]
7773 #[strum(serialize = "VsanRelayoutObjectsErrorCode_Unknown")]
7774 VsanRelayoutObjectsErrorCodeUnknown,
7775 /// This variant handles values not known at compile time.
7776 #[serde(untagged)]
7777 #[strum(serialize = "__OTHER__")]
7778 Other_(String),
7779}
7780/// The vSAN Entity type.
7781///
7782/// An Entity may include vSAN objects like
7783/// virtual machine or fault domain.
7784///
7785/// Possible values:
7786/// - `VM`: The virtual machine which may contain the vSAN objects like VMDK, swap etc
7787/// - `FileShare`: The file share which may be backed by one or more vSAN objects
7788/// - `Host`: The host which may contain the vSAN objects
7789/// - `FaultDomain`: The fault domain which may contain the vSAN objects
7790/// - `VsanSpaceReportingEntityType_Unknown`: represent the value when the lower version client cannot recognize the enum value.
7791#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
7792pub enum VsanSpaceReportingEntityTypeEnum {
7793 #[serde(rename = "VM")]
7794 #[strum(serialize = "VM")]
7795 Vm,
7796 FileShare,
7797 Host,
7798 FaultDomain,
7799 #[serde(rename = "VsanSpaceReportingEntityType_Unknown")]
7800 #[strum(serialize = "VsanSpaceReportingEntityType_Unknown")]
7801 VsanSpaceReportingEntityTypeUnknown,
7802 /// This variant handles values not known at compile time.
7803 #[serde(untagged)]
7804 #[strum(serialize = "__OTHER__")]
7805 Other_(String),
7806}
7807/// The supported vSAN health log level enumeration for Storage Infrastructure / vSAN
7808///
7809/// Possible values:
7810/// - `INFO`
7811/// - `WARNING`
7812/// - `ERROR`
7813/// - `DEBUG`
7814/// - `CRITICAL`
7815/// - `VsanHealthLogLevelEnum_Unknown`
7816#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
7817pub enum VsanHealthLogLevelEnumEnum {
7818 #[serde(rename = "INFO")]
7819 #[strum(serialize = "INFO")]
7820 Info,
7821 #[serde(rename = "WARNING")]
7822 #[strum(serialize = "WARNING")]
7823 Warning,
7824 #[serde(rename = "ERROR")]
7825 #[strum(serialize = "ERROR")]
7826 Error,
7827 #[serde(rename = "DEBUG")]
7828 #[strum(serialize = "DEBUG")]
7829 Debug,
7830 #[serde(rename = "CRITICAL")]
7831 #[strum(serialize = "CRITICAL")]
7832 Critical,
7833 #[serde(rename = "VsanHealthLogLevelEnum_Unknown")]
7834 #[strum(serialize = "VsanHealthLogLevelEnum_Unknown")]
7835 VsanHealthLogLevelEnumUnknown,
7836 /// This variant handles values not known at compile time.
7837 #[serde(untagged)]
7838 #[strum(serialize = "__OTHER__")]
7839 Other_(String),
7840}
7841/// Enumerates flavors of container orchestrator cluster for which
7842/// volume operations are being performed.
7843///
7844/// Possible values:
7845/// - `VANILLA`: represents vanilla flavor of container cluster.
7846/// - `WORKLOAD`: represents WCP or supervisor container cluster.
7847/// - `GUEST_CLUSTER`: represents container cluster deployed as a guest cluster within a WCP or supervisor cluster.
7848/// - `ClusterFlavor_Unknown`
7849#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
7850pub enum CnsClusterFlavorEnum {
7851 #[serde(rename = "VANILLA")]
7852 #[strum(serialize = "VANILLA")]
7853 Vanilla,
7854 #[serde(rename = "WORKLOAD")]
7855 #[strum(serialize = "WORKLOAD")]
7856 Workload,
7857 #[serde(rename = "GUEST_CLUSTER")]
7858 #[strum(serialize = "GUEST_CLUSTER")]
7859 GuestCluster,
7860 #[serde(rename = "ClusterFlavor_Unknown")]
7861 #[strum(serialize = "ClusterFlavor_Unknown")]
7862 ClusterFlavorUnknown,
7863 /// This variant handles values not known at compile time.
7864 #[serde(untagged)]
7865 #[strum(serialize = "__OTHER__")]
7866 Other_(String),
7867}
7868/// Enumerates types of container orchestrator cluster for which volume operations
7869/// are being performed.
7870///
7871///
7872/// This is a list of supported container orchestrator cluster types. Also the
7873/// ClusterType value can be used to list all the volumes that exist for the
7874/// specified type of container orchestrator.
7875///
7876/// Possible values:
7877/// - `KUBERNETES`: for container orchestrator cluster of type Kubernetes.
7878/// - `ClusterType_Unknown`: represent the value when the lower version client cannot recognize the enum value.
7879#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
7880pub enum CnsClusterTypeEnum {
7881 #[serde(rename = "KUBERNETES")]
7882 #[strum(serialize = "KUBERNETES")]
7883 Kubernetes,
7884 #[serde(rename = "ClusterType_Unknown")]
7885 #[strum(serialize = "ClusterType_Unknown")]
7886 ClusterTypeUnknown,
7887 /// This variant handles values not known at compile time.
7888 #[serde(untagged)]
7889 #[strum(serialize = "__OTHER__")]
7890 Other_(String),
7891}
7892/// Enumerates types of Kubernetes entities for which CNS would be storing metadata for.
7893///
7894/// Possible values:
7895/// - `PERSISTENT_VOLUME`: represents persistent volume entity in Kubernetes
7896/// - `PERSISTENT_VOLUME_CLAIM`: represents persistent volume claim entity in Kubernetes
7897/// - `POD`: represents pod entity in Kubernetes
7898/// - `KubernetesEntityType_Unknown`: represent the value when the lower version client cannot recognize the enum value
7899#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
7900pub enum CnsKubernetesEntityTypeEnum {
7901 #[serde(rename = "PERSISTENT_VOLUME")]
7902 #[strum(serialize = "PERSISTENT_VOLUME")]
7903 PersistentVolume,
7904 #[serde(rename = "PERSISTENT_VOLUME_CLAIM")]
7905 #[strum(serialize = "PERSISTENT_VOLUME_CLAIM")]
7906 PersistentVolumeClaim,
7907 #[serde(rename = "POD")]
7908 #[strum(serialize = "POD")]
7909 Pod,
7910 #[serde(rename = "KubernetesEntityType_Unknown")]
7911 #[strum(serialize = "KubernetesEntityType_Unknown")]
7912 KubernetesEntityTypeUnknown,
7913 /// This variant handles values not known at compile time.
7914 #[serde(untagged)]
7915 #[strum(serialize = "__OTHER__")]
7916 Other_(String),
7917}
7918/// Enumerates the metrics output format.
7919///
7920/// Possible values:
7921/// - `PROMETHEUS`: metrics are returned in Prometheus format
7922/// - `WAVEFRONT`: metrics are returned in Wavefront format
7923/// - `MetricFormat_Unknown`: represent the value when the lower version client cannot recognize the enum value
7924#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
7925pub enum MetricFormatEnum {
7926 #[serde(rename = "PROMETHEUS")]
7927 #[strum(serialize = "PROMETHEUS")]
7928 Prometheus,
7929 #[serde(rename = "WAVEFRONT")]
7930 #[strum(serialize = "WAVEFRONT")]
7931 Wavefront,
7932 #[serde(rename = "MetricFormat_Unknown")]
7933 #[strum(serialize = "MetricFormat_Unknown")]
7934 MetricFormatUnknown,
7935 /// This variant handles values not known at compile time.
7936 #[serde(untagged)]
7937 #[strum(serialize = "__OTHER__")]
7938 Other_(String),
7939}
7940/// Enumerates types of metrics for 8.x and previous releases.
7941///
7942/// Possible values:
7943/// - `VOLUME`: represents volume metrics
7944/// - `DATASTORE`: represents datastore metrics
7945/// - `CLUSTER`: represents cluster metrics *CnsClusterType_enum*
7946/// - `DISTRIBUTION`
7947/// - `STORAGE_POLICY`
7948/// - `OP_STATS`: represents operation statistics
7949/// - `SAAS_METRICS`
7950/// - `MetricType_Unknown`: represent the value when the lower version client cannot recognize the enum value
7951#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
7952pub enum MetricTypeEnum {
7953 #[serde(rename = "VOLUME")]
7954 #[strum(serialize = "VOLUME")]
7955 Volume,
7956 #[serde(rename = "DATASTORE")]
7957 #[strum(serialize = "DATASTORE")]
7958 Datastore,
7959 #[serde(rename = "CLUSTER")]
7960 #[strum(serialize = "CLUSTER")]
7961 Cluster,
7962 #[serde(rename = "DISTRIBUTION")]
7963 #[strum(serialize = "DISTRIBUTION")]
7964 Distribution,
7965 #[serde(rename = "STORAGE_POLICY")]
7966 #[strum(serialize = "STORAGE_POLICY")]
7967 StoragePolicy,
7968 #[serde(rename = "OP_STATS")]
7969 #[strum(serialize = "OP_STATS")]
7970 OpStats,
7971 #[serde(rename = "SAAS_METRICS")]
7972 #[strum(serialize = "SAAS_METRICS")]
7973 SaasMetrics,
7974 #[serde(rename = "MetricType_Unknown")]
7975 #[strum(serialize = "MetricType_Unknown")]
7976 MetricTypeUnknown,
7977 /// This variant handles values not known at compile time.
7978 #[serde(untagged)]
7979 #[strum(serialize = "__OTHER__")]
7980 Other_(String),
7981}
7982/// Enumerates types of query selection name.
7983///
7984/// This is a reflection of the
7985/// attributes in *CnsVolume*.
7986///
7987/// Possible values:
7988/// - `VOLUME_METADATA`
7989/// - `DATASTORE_URL`
7990/// - `POLICY_ID`
7991/// - `VOLUME_TYPE`: Select *CnsVolume.volumeType*.
7992/// - `VOLUME_NAME`: Select *CnsVolume.name*.
7993/// - `BACKING_OBJECT_DETAILS`: Select *CnsVolume.backingObjectDetails*.
7994/// - `COMPLIANCE_STATUS`: Select *CnsVolume.complianceStatus*
7995/// - `DATASTORE_ACCESSIBILITY_STATUS`: Select *CnsVolume.datastoreAccessibilityStatus*
7996/// - `HEALTH_STATUS`
7997/// - `QuerySelectionNameType_Unknown`: represent the value when the lower version client cannot recognize the enum value
7998#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
7999pub enum QuerySelectionNameTypeEnum {
8000 #[serde(rename = "VOLUME_METADATA")]
8001 #[strum(serialize = "VOLUME_METADATA")]
8002 VolumeMetadata,
8003 #[serde(rename = "DATASTORE_URL")]
8004 #[strum(serialize = "DATASTORE_URL")]
8005 DatastoreUrl,
8006 #[serde(rename = "POLICY_ID")]
8007 #[strum(serialize = "POLICY_ID")]
8008 PolicyId,
8009 #[serde(rename = "VOLUME_TYPE")]
8010 #[strum(serialize = "VOLUME_TYPE")]
8011 VolumeType,
8012 #[serde(rename = "VOLUME_NAME")]
8013 #[strum(serialize = "VOLUME_NAME")]
8014 VolumeName,
8015 #[serde(rename = "BACKING_OBJECT_DETAILS")]
8016 #[strum(serialize = "BACKING_OBJECT_DETAILS")]
8017 BackingObjectDetails,
8018 #[serde(rename = "COMPLIANCE_STATUS")]
8019 #[strum(serialize = "COMPLIANCE_STATUS")]
8020 ComplianceStatus,
8021 #[serde(rename = "DATASTORE_ACCESSIBILITY_STATUS")]
8022 #[strum(serialize = "DATASTORE_ACCESSIBILITY_STATUS")]
8023 DatastoreAccessibilityStatus,
8024 #[serde(rename = "HEALTH_STATUS")]
8025 #[strum(serialize = "HEALTH_STATUS")]
8026 HealthStatus,
8027 #[serde(rename = "QuerySelectionNameType_Unknown")]
8028 #[strum(serialize = "QuerySelectionNameType_Unknown")]
8029 QuerySelectionNameTypeUnknown,
8030 /// This variant handles values not known at compile time.
8031 #[serde(untagged)]
8032 #[strum(serialize = "__OTHER__")]
8033 Other_(String),
8034}
8035/// Enumerate types of container volume based on the type of backing for the
8036/// volume.
8037///
8038/// Possible values:
8039/// - `BLOCK`: for volume backed by a block device.
8040/// - `FILE`
8041/// - `VolumeType_Unknown`: represent the value when the older version client cannot recognize the enum value.
8042#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8043pub enum CnsVolumeTypeEnum {
8044 #[serde(rename = "BLOCK")]
8045 #[strum(serialize = "BLOCK")]
8046 Block,
8047 #[serde(rename = "FILE")]
8048 #[strum(serialize = "FILE")]
8049 File,
8050 #[serde(rename = "VolumeType_Unknown")]
8051 #[strum(serialize = "VolumeType_Unknown")]
8052 VolumeTypeUnknown,
8053 /// This variant handles values not known at compile time.
8054 #[serde(untagged)]
8055 #[strum(serialize = "__OTHER__")]
8056 Other_(String),
8057}
8058/// Network Filter on Failure Type.
8059///
8060/// It specifies whether all the
8061/// packets will be allowed or all the packets will be denied when
8062/// Filter fails to configure.
8063///
8064/// Possible values:
8065/// - `failOpen`: Allows all the packets when the Filter fails to configure.
8066/// - `failClosed`: Denies all the packets when the Filter fails to configure.
8067#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8068pub enum DvsFilterOnFailureEnum {
8069 #[serde(rename = "failOpen")]
8070 #[strum(serialize = "failOpen")]
8071 FailOpen,
8072 #[serde(rename = "failClosed")]
8073 #[strum(serialize = "failClosed")]
8074 FailClosed,
8075 /// This variant handles values not known at compile time.
8076 #[serde(untagged)]
8077 #[strum(serialize = "__OTHER__")]
8078 Other_(String),
8079}
8080/// Set of possible values for
8081/// *DVPortStatus*.*DVPortStatus.vmDirectPathGen2InactiveReasonNetwork*.
8082///
8083/// Possible values:
8084/// - `portNptIncompatibleDvs`: The switch for which this port is defined does not support VMDirectPath Gen 2.
8085///
8086/// See
8087/// *DVSFeatureCapability*.*DVSFeatureCapability.vmDirectPathGen2Supported*.
8088/// - `portNptNoCompatibleNics`: None of the physical NICs used as uplinks for this port support
8089/// VMDirectPath Gen 2.
8090///
8091/// See also *PhysicalNic.vmDirectPathGen2Supported*.
8092/// - `portNptNoVirtualFunctionsAvailable`: At least some of the physical NICs used as uplinks for this port
8093/// support VMDirectPath Gen 2, but all available network-passthrough
8094/// resources are in use by other ports.
8095/// - `portNptDisabledForPort`: VMDirectPath Gen 2 has been explicitly disabled for this port.
8096#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8097pub enum DvPortStatusVmDirectPathGen2InactiveReasonNetworkEnum {
8098 #[serde(rename = "portNptIncompatibleDvs")]
8099 #[strum(serialize = "portNptIncompatibleDvs")]
8100 PortNptIncompatibleDvs,
8101 #[serde(rename = "portNptNoCompatibleNics")]
8102 #[strum(serialize = "portNptNoCompatibleNics")]
8103 PortNptNoCompatibleNics,
8104 #[serde(rename = "portNptNoVirtualFunctionsAvailable")]
8105 #[strum(serialize = "portNptNoVirtualFunctionsAvailable")]
8106 PortNptNoVirtualFunctionsAvailable,
8107 #[serde(rename = "portNptDisabledForPort")]
8108 #[strum(serialize = "portNptDisabledForPort")]
8109 PortNptDisabledForPort,
8110 /// This variant handles values not known at compile time.
8111 #[serde(untagged)]
8112 #[strum(serialize = "__OTHER__")]
8113 Other_(String),
8114}
8115/// Set of possible values for
8116/// *DVPortStatus*.*DVPortStatus.vmDirectPathGen2InactiveReasonOther*.
8117///
8118/// Possible values:
8119/// - `portNptIncompatibleHost`: The host for which this port is defined does not support VMDirectPath Gen 2.
8120///
8121/// See *HostCapability*.*HostCapability.vmDirectPathGen2Supported*
8122/// - `portNptIncompatibleConnectee`: Configuration or state of the port's connectee prevents
8123/// VMDirectPath Gen 2.
8124///
8125/// See
8126/// *VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeState.vmDirectPathGen2InactiveReasonVm*
8127/// and/or
8128/// *VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeState.vmDirectPathGen2InactiveReasonExtended*
8129/// in the appropriate element of the RuntimeInfo.device array of the
8130/// virtual machine connected to this port.
8131#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8132pub enum DvPortStatusVmDirectPathGen2InactiveReasonOtherEnum {
8133 #[serde(rename = "portNptIncompatibleHost")]
8134 #[strum(serialize = "portNptIncompatibleHost")]
8135 PortNptIncompatibleHost,
8136 #[serde(rename = "portNptIncompatibleConnectee")]
8137 #[strum(serialize = "portNptIncompatibleConnectee")]
8138 PortNptIncompatibleConnectee,
8139 /// This variant handles values not known at compile time.
8140 #[serde(untagged)]
8141 #[strum(serialize = "__OTHER__")]
8142 Other_(String),
8143}
8144/// The *DistributedVirtualPortgroupBackingType_enum* enum defines
8145/// the distributed virtual portgroup backing type.
8146///
8147/// Possible values:
8148/// - `standard`: The portgroup is created by vCenter.
8149/// - `nsx`: The portgroup is created by NSX manager.
8150///
8151/// For NSX backing type, We only support ephemeral portgroup type.
8152/// If *DistributedVirtualPortgroupPortgroupType_enum* is
8153/// ephemeral, A *DistributedVirtualPort* will be
8154/// dynamicly created by NSX when the virtual machine is reconfigured
8155/// to connect to the portgroup.
8156#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8157pub enum DistributedVirtualPortgroupBackingTypeEnum {
8158 #[serde(rename = "standard")]
8159 #[strum(serialize = "standard")]
8160 Standard,
8161 #[serde(rename = "nsx")]
8162 #[strum(serialize = "nsx")]
8163 Nsx,
8164 /// This variant handles values not known at compile time.
8165 #[serde(untagged)]
8166 #[strum(serialize = "__OTHER__")]
8167 Other_(String),
8168}
8169/// The meta tag names recognizable in the
8170/// *DVPortgroupConfigInfo.portNameFormat* string.
8171///
8172/// Possible values:
8173/// - `dvsName`: This tag will be expanded to the name of the switch.
8174/// - `portgroupName`: This tag will be expanded to the name of the portgroup.
8175/// - `portIndex`: This tag will be expanded to the current index of the port.
8176#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8177pub enum DistributedVirtualPortgroupMetaTagNameEnum {
8178 #[serde(rename = "dvsName")]
8179 #[strum(serialize = "dvsName")]
8180 DvsName,
8181 #[serde(rename = "portgroupName")]
8182 #[strum(serialize = "portgroupName")]
8183 PortgroupName,
8184 #[serde(rename = "portIndex")]
8185 #[strum(serialize = "portIndex")]
8186 PortIndex,
8187 /// This variant handles values not known at compile time.
8188 #[serde(untagged)]
8189 #[strum(serialize = "__OTHER__")]
8190 Other_(String),
8191}
8192/// The *DistributedVirtualPortgroupPortgroupType_enum* enum defines
8193/// the distributed virtual portgroup types
8194/// (*DistributedVirtualPortgroup*.*DistributedVirtualPortgroup.config*.*DVPortgroupConfigInfo.type*).
8195///
8196/// Early binding specifies a static set of ports that are created
8197/// when you create the distributed virtual portgroup. An ephemeral portgroup uses dynamic
8198/// ports that are created when you power on a virtual machine.
8199///
8200/// Possible values:
8201/// - `earlyBinding`: A free *DistributedVirtualPort* will be selected and assigned to
8202/// a *VirtualMachine* when the virtual machine is reconfigured to
8203/// connect to the portgroup.
8204/// - `lateBinding`:
8205///
8206/// Deprecated as of vSphere API 5.0.
8207///
8208/// A free *DistributedVirtualPort* will be selected and
8209/// assigned to a *VirtualMachine* when the virtual machine is
8210/// powered on.
8211/// - `ephemeral`: A *DistributedVirtualPort* will be created and assigned to a
8212/// *VirtualMachine* when the virtual machine is powered on, and will
8213/// be deleted when the virtual machine is powered off.
8214///
8215/// An ephemeral portgroup has
8216/// no limit on the number of ports that can be a part of this portgroup.
8217/// In cases where the vCenter Server is unavailable the host can
8218/// create conflict ports in this portgroup to be used by a virtual machine
8219/// at power on.
8220#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8221pub enum DistributedVirtualPortgroupPortgroupTypeEnum {
8222 #[serde(rename = "earlyBinding")]
8223 #[strum(serialize = "earlyBinding")]
8224 EarlyBinding,
8225 #[serde(rename = "lateBinding")]
8226 #[strum(serialize = "lateBinding")]
8227 LateBinding,
8228 #[serde(rename = "ephemeral")]
8229 #[strum(serialize = "ephemeral")]
8230 Ephemeral,
8231 /// This variant handles values not known at compile time.
8232 #[serde(untagged)]
8233 #[strum(serialize = "__OTHER__")]
8234 Other_(String),
8235}
8236/// The *EntityType_enum* enum identifies
8237/// the type of entity that was exported
8238/// (*DistributedVirtualSwitchManager.DVSManagerExportEntity_Task*).
8239///
8240/// Possible values:
8241/// - `distributedVirtualSwitch`: Indicates the exported entity is a *DistributedVirtualSwitch*.
8242/// - `distributedVirtualPortgroup`: Indicates the exported entity is a *DistributedVirtualPortgroup*.
8243#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8244pub enum EntityTypeEnum {
8245 #[serde(rename = "distributedVirtualSwitch")]
8246 #[strum(serialize = "distributedVirtualSwitch")]
8247 DistributedVirtualSwitch,
8248 #[serde(rename = "distributedVirtualPortgroup")]
8249 #[strum(serialize = "distributedVirtualPortgroup")]
8250 DistributedVirtualPortgroup,
8251 /// This variant handles values not known at compile time.
8252 #[serde(untagged)]
8253 #[strum(serialize = "__OTHER__")]
8254 Other_(String),
8255}
8256/// The *EntityImportType_enum* enum defines the import type for a
8257/// *DistributedVirtualSwitchManager*.*DistributedVirtualSwitchManager.DVSManagerImportEntity_Task*
8258/// operation.
8259///
8260/// Possible values:
8261/// - `createEntityWithNewIdentifier`: Create the entity with new identifiers.
8262///
8263/// Specify the
8264/// *EntityBackupConfig*.*EntityBackupConfig.name* and
8265/// *EntityBackupConfig*.*EntityBackupConfig.container*
8266/// properties.
8267///
8268/// The Server ignores any value for the
8269/// *EntityBackupConfig*.*EntityBackupConfig.key*
8270/// property.
8271/// - `createEntityWithOriginalIdentifier`: Recreate the entities with the original identifiers of the entity from which backup was created.
8272///
8273/// The Server throws an exception if an entity with the same identifier already exists.
8274/// This option will also add the host members to the *DistributedVirtualSwitch* and will
8275/// try to get the virtual machine networking back with the same *DistributedVirtualPortgroup*.
8276/// Specify a *Folder* as the
8277/// *EntityBackupConfig*.*EntityBackupConfig.container*
8278/// for *EntityBackupConfig*.*EntityBackupConfig.entityType*
8279/// "distributedVirtualSwitch".
8280///
8281/// The Server ignores any values for the
8282/// *EntityBackupConfig*.*EntityBackupConfig.key* and
8283/// *EntityBackupConfig*.*EntityBackupConfig.name*
8284/// properties.
8285/// - `applyToEntitySpecified`: Apply the configuration specified in the
8286/// *EntityBackupConfig*.*EntityBackupConfig.configBlob*
8287/// property to the entity specified in the
8288/// *EntityBackupConfig*.*EntityBackupConfig.entityType* and
8289/// *EntityBackupConfig*.*EntityBackupConfig.key*
8290/// properties.
8291///
8292/// If you specify
8293/// *EntityBackupConfig*.*EntityBackupConfig.name*,
8294/// the Server uses the specified name to rename the entity.
8295///
8296/// The Server ignores any value for the
8297/// *EntityBackupConfig*.*EntityBackupConfig.container*
8298/// property.
8299#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8300pub enum EntityImportTypeEnum {
8301 #[serde(rename = "createEntityWithNewIdentifier")]
8302 #[strum(serialize = "createEntityWithNewIdentifier")]
8303 CreateEntityWithNewIdentifier,
8304 #[serde(rename = "createEntityWithOriginalIdentifier")]
8305 #[strum(serialize = "createEntityWithOriginalIdentifier")]
8306 CreateEntityWithOriginalIdentifier,
8307 #[serde(rename = "applyToEntitySpecified")]
8308 #[strum(serialize = "applyToEntitySpecified")]
8309 ApplyToEntitySpecified,
8310 /// This variant handles values not known at compile time.
8311 #[serde(untagged)]
8312 #[strum(serialize = "__OTHER__")]
8313 Other_(String),
8314}
8315/// Possible values:
8316/// - `blocked`: The port link state: blocked.
8317/// - `unblocked`: The port link state: unblocked.
8318#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8319pub enum DvsFilterSpecLinkConfigEnum {
8320 #[serde(rename = "blocked")]
8321 #[strum(serialize = "blocked")]
8322 Blocked,
8323 #[serde(rename = "unblocked")]
8324 #[strum(serialize = "unblocked")]
8325 Unblocked,
8326 /// This variant handles values not known at compile time.
8327 #[serde(untagged)]
8328 #[strum(serialize = "__OTHER__")]
8329 Other_(String),
8330}
8331/// Possible values:
8332/// - `down`: The port link state: down.
8333/// - `up`: The port link state: up.
8334#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8335pub enum DvsFilterSpecLinkStateEnum {
8336 #[serde(rename = "down")]
8337 #[strum(serialize = "down")]
8338 Down,
8339 #[serde(rename = "up")]
8340 #[strum(serialize = "up")]
8341 Up,
8342 /// This variant handles values not known at compile time.
8343 #[serde(untagged)]
8344 #[strum(serialize = "__OTHER__")]
8345 Other_(String),
8346}
8347/// The enum defines the distributed virtual switch mode.
8348///
8349/// Possible values:
8350/// - `normal`: traditional package processing mode.
8351/// - `mux`: ENS mode which skips packet parsing and flow table lookup.
8352///
8353/// ***Since:*** vSphere API Release 8.0.0.1
8354#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8355pub enum HostDvsConfigSpecSwitchModeEnum {
8356 #[serde(rename = "normal")]
8357 #[strum(serialize = "normal")]
8358 Normal,
8359 #[serde(rename = "mux")]
8360 #[strum(serialize = "mux")]
8361 Mux,
8362 /// This variant handles values not known at compile time.
8363 #[serde(untagged)]
8364 #[strum(serialize = "__OTHER__")]
8365 Other_(String),
8366}
8367/// The reason for DPU failover.
8368///
8369/// Possible values:
8370/// - `crash`: The failover is caused by DPU crash.
8371/// - `linkDown`: The failover is caused by DPU's vmnic(s) link down.
8372/// - `userInitiated`: The failover is triggered by the user.
8373///
8374/// ***Since:*** vSphere API Release 8.0.3.0
8375#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8376pub enum HostDistributedVirtualSwitchManagerFailoverReasonEnum {
8377 #[serde(rename = "crash")]
8378 #[strum(serialize = "crash")]
8379 Crash,
8380 #[serde(rename = "linkDown")]
8381 #[strum(serialize = "linkDown")]
8382 LinkDown,
8383 #[serde(rename = "userInitiated")]
8384 #[strum(serialize = "userInitiated")]
8385 UserInitiated,
8386 /// This variant handles values not known at compile time.
8387 #[serde(untagged)]
8388 #[strum(serialize = "__OTHER__")]
8389 Other_(String),
8390}
8391/// The stage of DPU failover.
8392///
8393/// Possible values:
8394/// - `STAGE_1`
8395///
8396/// ***Since:*** vSphere API Release 8.0.3.0
8397#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8398pub enum HostDistributedVirtualSwitchManagerFailoverStageEnum {
8399 #[serde(rename = "STAGE_1")]
8400 #[strum(serialize = "STAGE_1")]
8401 Stage1,
8402 /// This variant handles values not known at compile time.
8403 #[serde(untagged)]
8404 #[strum(serialize = "__OTHER__")]
8405 Other_(String),
8406}
8407/// Describes the state of the host proxy switch.
8408///
8409/// Possible values:
8410/// - `up`: The host proxy switch is up and running.
8411/// - `pending`: The host proxy switch is waiting to be initialized.
8412/// - `outOfSync`: The proxy switch configuration is not the same as the
8413/// distributed virtual switch configuration in the vCenter Server.
8414/// - `warning`: The host requires attention.
8415/// - `disconnected`: The host is disconnected or it is not responding.
8416/// - `down`: The host proxy is down.
8417#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8418pub enum DistributedVirtualSwitchHostMemberHostComponentStateEnum {
8419 #[serde(rename = "up")]
8420 #[strum(serialize = "up")]
8421 Up,
8422 #[serde(rename = "pending")]
8423 #[strum(serialize = "pending")]
8424 Pending,
8425 #[serde(rename = "outOfSync")]
8426 #[strum(serialize = "outOfSync")]
8427 OutOfSync,
8428 #[serde(rename = "warning")]
8429 #[strum(serialize = "warning")]
8430 Warning,
8431 #[serde(rename = "disconnected")]
8432 #[strum(serialize = "disconnected")]
8433 Disconnected,
8434 #[serde(rename = "down")]
8435 #[strum(serialize = "down")]
8436 Down,
8437 /// This variant handles values not known at compile time.
8438 #[serde(untagged)]
8439 #[strum(serialize = "__OTHER__")]
8440 Other_(String),
8441}
8442/// Describe the runtime state of the uplink.
8443///
8444/// Possible values:
8445/// - `active`
8446/// - `standby`
8447#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8448pub enum DistributedVirtualSwitchHostMemberHostUplinkStateStateEnum {
8449 #[serde(rename = "active")]
8450 #[strum(serialize = "active")]
8451 Active,
8452 #[serde(rename = "standby")]
8453 #[strum(serialize = "standby")]
8454 Standby,
8455 /// This variant handles values not known at compile time.
8456 #[serde(untagged)]
8457 #[strum(serialize = "__OTHER__")]
8458 Other_(String),
8459}
8460/// Transport zone type.
8461///
8462/// Possible values:
8463/// - `vlan`: VLAN based networking
8464/// - `overlay`: VXLAN based networking
8465#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8466pub enum DistributedVirtualSwitchHostMemberTransportZoneTypeEnum {
8467 #[serde(rename = "vlan")]
8468 #[strum(serialize = "vlan")]
8469 Vlan,
8470 #[serde(rename = "overlay")]
8471 #[strum(serialize = "overlay")]
8472 Overlay,
8473 /// This variant handles values not known at compile time.
8474 #[serde(untagged)]
8475 #[strum(serialize = "__OTHER__")]
8476 Other_(String),
8477}
8478/// The connectee types.
8479///
8480/// Possible values:
8481/// - `pnic`: The port connects to a Physical NIC.
8482/// - `vmVnic`: The port connects to a Virtual NIC in a Virtual Machine.
8483/// - `hostConsoleVnic`: The port connects to a console Virtual NIC on a host.
8484/// - `hostVmkVnic`: The port connects to a VMkernel Virtual NIC on a host.
8485/// - `systemCrxVnic`: The port connects to a Virtual NIC in a System CRX VM.
8486///
8487/// ***Since:*** vSphere API Release 8.0.1.0
8488#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8489pub enum DistributedVirtualSwitchPortConnecteeConnecteeTypeEnum {
8490 #[serde(rename = "pnic")]
8491 #[strum(serialize = "pnic")]
8492 Pnic,
8493 #[serde(rename = "vmVnic")]
8494 #[strum(serialize = "vmVnic")]
8495 VmVnic,
8496 #[serde(rename = "hostConsoleVnic")]
8497 #[strum(serialize = "hostConsoleVnic")]
8498 HostConsoleVnic,
8499 #[serde(rename = "hostVmkVnic")]
8500 #[strum(serialize = "hostVmkVnic")]
8501 HostVmkVnic,
8502 #[serde(rename = "systemCrxVnic")]
8503 #[strum(serialize = "systemCrxVnic")]
8504 SystemCrxVnic,
8505 /// This variant handles values not known at compile time.
8506 #[serde(untagged)]
8507 #[strum(serialize = "__OTHER__")]
8508 Other_(String),
8509}
8510/// Network Traffic Rule direction types.
8511///
8512/// It specifies whether rule
8513/// needs to be applied for packets which are incoming/outgoing or both.
8514///
8515/// Possible values:
8516/// - `incomingPackets`: This specifies that the network rule has to be applied only for
8517/// incoming packets.
8518/// - `outgoingPackets`: This specifies that the network rule has to be applied only for
8519/// outgoing packets.
8520/// - `both`: This specifies that the network rule has to be applied only for
8521/// both incoming and outgoing packets.
8522#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8523pub enum DvsNetworkRuleDirectionTypeEnum {
8524 #[serde(rename = "incomingPackets")]
8525 #[strum(serialize = "incomingPackets")]
8526 IncomingPackets,
8527 #[serde(rename = "outgoingPackets")]
8528 #[strum(serialize = "outgoingPackets")]
8529 OutgoingPackets,
8530 #[serde(rename = "both")]
8531 #[strum(serialize = "both")]
8532 Both,
8533 /// This variant handles values not known at compile time.
8534 #[serde(untagged)]
8535 #[strum(serialize = "__OTHER__")]
8536 Other_(String),
8537}
8538/// Link Aggregation Control Protocol API versions.
8539///
8540/// Possible values:
8541/// - `singleLag`:
8542///
8543/// Deprecated as of vSphere API 7.0u1.
8544///
8545/// One Link Aggregation Control Protocol group in the switch
8546/// - `multipleLag`: Multiple Link Aggregation Control Protocol in the switch.
8547#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8548pub enum VMwareDvsLacpApiVersionEnum {
8549 #[serde(rename = "singleLag")]
8550 #[strum(serialize = "singleLag")]
8551 SingleLag,
8552 #[serde(rename = "multipleLag")]
8553 #[strum(serialize = "multipleLag")]
8554 MultipleLag,
8555 /// This variant handles values not known at compile time.
8556 #[serde(untagged)]
8557 #[strum(serialize = "__OTHER__")]
8558 Other_(String),
8559}
8560/// Load balance algorithm in a Link Aggregation Control Protocol group.
8561///
8562/// Possible values:
8563/// - `srcMac`: Source MAC address
8564/// - `destMac`: Destination MAC address
8565/// - `srcDestMac`: Source and destination MAC address
8566/// - `destIpVlan`: Destination IP and VLAN
8567/// - `srcIpVlan`: Source IP and VLAN
8568/// - `srcDestIpVlan`: Source and destination IP and VLAN
8569/// - `destTcpUdpPort`: Destination TCP/UDP port number
8570/// - `srcTcpUdpPort`: Source TCP/UDP port number
8571/// - `srcDestTcpUdpPort`: Source and destination TCP/UDP port number
8572/// - `destIpTcpUdpPort`: Destination IP and TCP/UDP port number
8573/// - `srcIpTcpUdpPort`: Source IP and TCP/UDP port number
8574/// - `srcDestIpTcpUdpPort`: Source and destination IP and TCP/UDP port number
8575/// - `destIpTcpUdpPortVlan`: Destination IP, TCP/UDP port number and VLAN
8576/// - `srcIpTcpUdpPortVlan`: Source IP, TCP/UDP port number and VLAN
8577/// - `srcDestIpTcpUdpPortVlan`: Source and destination IP,
8578/// source and destination TCP/UDP port number and VLAN.
8579/// - `destIp`: Destination IP
8580/// - `srcIp`: Source IP
8581/// - `srcDestIp`: Source and Destination IP
8582/// - `vlan`: VLAN only
8583/// - `srcPortId`: Source Virtual Port Id
8584#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8585pub enum VMwareDvsLacpLoadBalanceAlgorithmEnum {
8586 #[serde(rename = "srcMac")]
8587 #[strum(serialize = "srcMac")]
8588 SrcMac,
8589 #[serde(rename = "destMac")]
8590 #[strum(serialize = "destMac")]
8591 DestMac,
8592 #[serde(rename = "srcDestMac")]
8593 #[strum(serialize = "srcDestMac")]
8594 SrcDestMac,
8595 #[serde(rename = "destIpVlan")]
8596 #[strum(serialize = "destIpVlan")]
8597 DestIpVlan,
8598 #[serde(rename = "srcIpVlan")]
8599 #[strum(serialize = "srcIpVlan")]
8600 SrcIpVlan,
8601 #[serde(rename = "srcDestIpVlan")]
8602 #[strum(serialize = "srcDestIpVlan")]
8603 SrcDestIpVlan,
8604 #[serde(rename = "destTcpUdpPort")]
8605 #[strum(serialize = "destTcpUdpPort")]
8606 DestTcpUdpPort,
8607 #[serde(rename = "srcTcpUdpPort")]
8608 #[strum(serialize = "srcTcpUdpPort")]
8609 SrcTcpUdpPort,
8610 #[serde(rename = "srcDestTcpUdpPort")]
8611 #[strum(serialize = "srcDestTcpUdpPort")]
8612 SrcDestTcpUdpPort,
8613 #[serde(rename = "destIpTcpUdpPort")]
8614 #[strum(serialize = "destIpTcpUdpPort")]
8615 DestIpTcpUdpPort,
8616 #[serde(rename = "srcIpTcpUdpPort")]
8617 #[strum(serialize = "srcIpTcpUdpPort")]
8618 SrcIpTcpUdpPort,
8619 #[serde(rename = "srcDestIpTcpUdpPort")]
8620 #[strum(serialize = "srcDestIpTcpUdpPort")]
8621 SrcDestIpTcpUdpPort,
8622 #[serde(rename = "destIpTcpUdpPortVlan")]
8623 #[strum(serialize = "destIpTcpUdpPortVlan")]
8624 DestIpTcpUdpPortVlan,
8625 #[serde(rename = "srcIpTcpUdpPortVlan")]
8626 #[strum(serialize = "srcIpTcpUdpPortVlan")]
8627 SrcIpTcpUdpPortVlan,
8628 #[serde(rename = "srcDestIpTcpUdpPortVlan")]
8629 #[strum(serialize = "srcDestIpTcpUdpPortVlan")]
8630 SrcDestIpTcpUdpPortVlan,
8631 #[serde(rename = "destIp")]
8632 #[strum(serialize = "destIp")]
8633 DestIp,
8634 #[serde(rename = "srcIp")]
8635 #[strum(serialize = "srcIp")]
8636 SrcIp,
8637 #[serde(rename = "srcDestIp")]
8638 #[strum(serialize = "srcDestIp")]
8639 SrcDestIp,
8640 #[serde(rename = "vlan")]
8641 #[strum(serialize = "vlan")]
8642 Vlan,
8643 #[serde(rename = "srcPortId")]
8644 #[strum(serialize = "srcPortId")]
8645 SrcPortId,
8646 /// This variant handles values not known at compile time.
8647 #[serde(untagged)]
8648 #[strum(serialize = "__OTHER__")]
8649 Other_(String),
8650}
8651/// Possible values:
8652/// - `allow`
8653/// - `drop`
8654#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8655pub enum DvsMacLimitPolicyTypeEnum {
8656 #[serde(rename = "allow")]
8657 #[strum(serialize = "allow")]
8658 Allow,
8659 #[serde(rename = "drop")]
8660 #[strum(serialize = "drop")]
8661 Drop,
8662 /// This variant handles values not known at compile time.
8663 #[serde(untagged)]
8664 #[strum(serialize = "__OTHER__")]
8665 Other_(String),
8666}
8667/// Multicast Filtering mode.
8668///
8669/// Possible values:
8670/// - `legacyFiltering`: Legacy filtering mode
8671/// - `snooping`: IGMP/MLD snooping mode
8672#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8673pub enum VMwareDvsMulticastFilteringModeEnum {
8674 #[serde(rename = "legacyFiltering")]
8675 #[strum(serialize = "legacyFiltering")]
8676 LegacyFiltering,
8677 #[serde(rename = "snooping")]
8678 #[strum(serialize = "snooping")]
8679 Snooping,
8680 /// This variant handles values not known at compile time.
8681 #[serde(untagged)]
8682 #[strum(serialize = "__OTHER__")]
8683 Other_(String),
8684}
8685/// The PVLAN port types.
8686///
8687/// Possible values:
8688/// - `promiscuous`: The port can communicate with all other ports within the same PVLAN,
8689/// including the isolated and community ports .
8690/// - `isolated`: The port can only communicate with the promiscuous ports within the
8691/// same PVLAN, any other traffics are blocked.
8692/// - `community`: The ports communicates with other community ports and with
8693/// promiscuous ports within the same PVLAN.
8694///
8695/// any other traffics are
8696/// blocked.
8697#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8698pub enum VmwareDistributedVirtualSwitchPvlanPortTypeEnum {
8699 #[serde(rename = "promiscuous")]
8700 #[strum(serialize = "promiscuous")]
8701 Promiscuous,
8702 #[serde(rename = "isolated")]
8703 #[strum(serialize = "isolated")]
8704 Isolated,
8705 #[serde(rename = "community")]
8706 #[strum(serialize = "community")]
8707 Community,
8708 /// This variant handles values not known at compile time.
8709 #[serde(untagged)]
8710 #[strum(serialize = "__OTHER__")]
8711 Other_(String),
8712}
8713/// The teaming health check match status.
8714///
8715/// Possible values:
8716/// - `iphashMatch`: The value of 'loadbalance\_ip' is used in a uplink teaming policy
8717/// *VmwareUplinkPortTeamingPolicy.policy*
8718/// in the vSphere Distributed Switch, and the external physical switch
8719/// has the matching EtherChannel configuration.
8720/// - `nonIphashMatch`: The value of 'loadbalance\_ip' is not used in a uplink teaming policy
8721/// *VmwareUplinkPortTeamingPolicy.policy*
8722/// in the vSphere Distributed Switch, and the external physical switch
8723/// does not have EtherChannel configuration.
8724/// - `iphashMismatch`: The value of 'loadbalance\_ip' is used in a uplink teaming policy
8725/// *VmwareUplinkPortTeamingPolicy.policy*
8726/// in the vSphere Distributed Switch, but the external physical switch
8727/// does not have the matching EtherChannel configuration.
8728/// - `nonIphashMismatch`: The value of 'loadbalance\_ip' is not used in a uplink teaming policy
8729/// *VmwareUplinkPortTeamingPolicy.policy*
8730/// in the vSphere Distributed Switch, but the external physical switch
8731/// has EtherChannel configuration.
8732#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8733pub enum VMwareDvsTeamingMatchStatusEnum {
8734 #[serde(rename = "iphashMatch")]
8735 #[strum(serialize = "iphashMatch")]
8736 IphashMatch,
8737 #[serde(rename = "nonIphashMatch")]
8738 #[strum(serialize = "nonIphashMatch")]
8739 NonIphashMatch,
8740 #[serde(rename = "iphashMismatch")]
8741 #[strum(serialize = "iphashMismatch")]
8742 IphashMismatch,
8743 #[serde(rename = "nonIphashMismatch")]
8744 #[strum(serialize = "nonIphashMismatch")]
8745 NonIphashMismatch,
8746 /// This variant handles values not known at compile time.
8747 #[serde(untagged)]
8748 #[strum(serialize = "__OTHER__")]
8749 Other_(String),
8750}
8751/// Link Aggregation Control Protocol policy modes.
8752///
8753/// Possible values:
8754/// - `active`: Link Aggregation Control Protocol always sends frames along the configured uplinks
8755/// - `passive`: Link Aggregation Control Protocol acts as "speak when spoken to".
8756#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8757pub enum VMwareUplinkLacpModeEnum {
8758 #[serde(rename = "active")]
8759 #[strum(serialize = "active")]
8760 Active,
8761 #[serde(rename = "passive")]
8762 #[strum(serialize = "passive")]
8763 Passive,
8764 /// This variant handles values not known at compile time.
8765 #[serde(untagged)]
8766 #[strum(serialize = "__OTHER__")]
8767 Other_(String),
8768}
8769/// Link Aggregation Control Protocol timeout policy modes.
8770///
8771/// Possible values:
8772/// - `fast`: Set long timeout for vmnics in one LACP LAG.
8773///
8774/// Device send fast LACPDUs
8775/// - `slow`: Set short timeout for vmnics in one LACP LAG.
8776///
8777/// Device send slow LACPDUs
8778///
8779/// ***Since:*** vSphere API Release 7.0.2.0
8780#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8781pub enum VMwareUplinkLacpTimeoutModeEnum {
8782 #[serde(rename = "fast")]
8783 #[strum(serialize = "fast")]
8784 Fast,
8785 #[serde(rename = "slow")]
8786 #[strum(serialize = "slow")]
8787 Slow,
8788 /// This variant handles values not known at compile time.
8789 #[serde(untagged)]
8790 #[strum(serialize = "__OTHER__")]
8791 Other_(String),
8792}
8793/// Distributed Port Mirroring session Encapsulation types.
8794///
8795/// Possible values:
8796/// - `gre`: Encapsulate original packets with GRE protocol
8797/// - `erspan2`: Encapsulate original packets with ERSPAN Type2 protocol
8798/// - `erspan3`: Encapsulate original packets with ERSPAN Type3 protocol
8799#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8800pub enum VMwareDvsVspanSessionEncapTypeEnum {
8801 #[serde(rename = "gre")]
8802 #[strum(serialize = "gre")]
8803 Gre,
8804 #[serde(rename = "erspan2")]
8805 #[strum(serialize = "erspan2")]
8806 Erspan2,
8807 #[serde(rename = "erspan3")]
8808 #[strum(serialize = "erspan3")]
8809 Erspan3,
8810 /// This variant handles values not known at compile time.
8811 #[serde(untagged)]
8812 #[strum(serialize = "__OTHER__")]
8813 Other_(String),
8814}
8815/// Distributed Port Mirroring session types.
8816///
8817/// Possible values:
8818/// - `mixedDestMirror`:
8819///
8820/// Deprecated as of vSphere API 5.1.
8821///
8822/// In mixedDestMirror session, Distributed Ports can be used as source entities,
8823/// and both Distributed Ports and Uplink Ports Name can be used as destination entities.
8824/// - `dvPortMirror`: In dvPortMirror session, Distributed Ports can be used as both source
8825/// and destination entities.
8826/// - `remoteMirrorSource`: In remoteMirrorSource session, Distributed Ports can be used as source entities,
8827/// and uplink ports name can be used as destination entities.
8828/// - `remoteMirrorDest`: In remoteMirrorDest session, vlan Ids can be used as source entities,
8829/// and Distributed Ports can be used as destination entities.
8830/// - `encapsulatedRemoteMirrorSource`: In encapsulatedRemoteMirrorSource session, Distributed Ports can be used as source entities,
8831/// and Ip address can be used as destination entities.
8832#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8833pub enum VMwareDvsVspanSessionTypeEnum {
8834 #[serde(rename = "mixedDestMirror")]
8835 #[strum(serialize = "mixedDestMirror")]
8836 MixedDestMirror,
8837 #[serde(rename = "dvPortMirror")]
8838 #[strum(serialize = "dvPortMirror")]
8839 DvPortMirror,
8840 #[serde(rename = "remoteMirrorSource")]
8841 #[strum(serialize = "remoteMirrorSource")]
8842 RemoteMirrorSource,
8843 #[serde(rename = "remoteMirrorDest")]
8844 #[strum(serialize = "remoteMirrorDest")]
8845 RemoteMirrorDest,
8846 #[serde(rename = "encapsulatedRemoteMirrorSource")]
8847 #[strum(serialize = "encapsulatedRemoteMirrorSource")]
8848 EncapsulatedRemoteMirrorSource,
8849 /// This variant handles values not known at compile time.
8850 #[serde(untagged)]
8851 #[strum(serialize = "__OTHER__")]
8852 Other_(String),
8853}
8854/// Key management type.
8855///
8856/// Possible values:
8857/// - `unknown`
8858/// - `internal`
8859/// - `external`
8860///
8861/// ***Since:*** vSphere API Release 8.0.1.0
8862#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8863pub enum CryptoManagerHostKeyManagementTypeEnum {
8864 #[serde(rename = "unknown")]
8865 #[strum(serialize = "unknown")]
8866 Unknown,
8867 #[serde(rename = "internal")]
8868 #[strum(serialize = "internal")]
8869 Internal,
8870 #[serde(rename = "external")]
8871 #[strum(serialize = "external")]
8872 External,
8873 /// This variant handles values not known at compile time.
8874 #[serde(untagged)]
8875 #[strum(serialize = "__OTHER__")]
8876 Other_(String),
8877}
8878/// Possible values:
8879/// - `KeyStateMissingInCache`: Key not found in VC cache and does not specify a provider
8880/// - `KeyStateClusterInvalid`: Key provider is invalid
8881/// - `KeyStateClusterUnreachable`: Can not reach the key provider
8882/// - `KeyStateMissingInKMS`: Key not found in KMS
8883/// - `KeyStateNotActiveOrEnabled`: Key not active or enabled
8884/// - `KeyStateManagedByTrustAuthority`: Key is managed by Trust Authority
8885/// - `KeyStateManagedByNKP`: Key is managed by Native Key Provider
8886///
8887/// ***Since:*** vSphere API Release 8.0.3.0
8888/// - `NoPermissionToAccessKeyProvider`: No permission to access key provider
8889///
8890/// ***Since:*** vSphere API Release 8.0.3.0
8891/// - `WrappingKeyMissingInKMS`: Wrapping Key not found in KMS
8892///
8893/// ***Since:*** vSphere API Release 9.0.0.0
8894/// - `WrappingKeyNotActiveOrEnabled`: Wrapping Key not active or enabled
8895///
8896/// ***Since:*** vSphere API Release 9.0.0.0
8897#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8898pub enum CryptoManagerKmipCryptoKeyStatusKeyUnavailableReasonEnum {
8899 KeyStateMissingInCache,
8900 KeyStateClusterInvalid,
8901 KeyStateClusterUnreachable,
8902 #[serde(rename = "KeyStateMissingInKMS")]
8903 #[strum(serialize = "KeyStateMissingInKMS")]
8904 KeyStateMissingInKms,
8905 KeyStateNotActiveOrEnabled,
8906 KeyStateManagedByTrustAuthority,
8907 #[serde(rename = "KeyStateManagedByNKP")]
8908 #[strum(serialize = "KeyStateManagedByNKP")]
8909 KeyStateManagedByNkp,
8910 NoPermissionToAccessKeyProvider,
8911 #[serde(rename = "WrappingKeyMissingInKMS")]
8912 #[strum(serialize = "WrappingKeyMissingInKMS")]
8913 WrappingKeyMissingInKms,
8914 WrappingKeyNotActiveOrEnabled,
8915 /// This variant handles values not known at compile time.
8916 #[serde(untagged)]
8917 #[strum(serialize = "__OTHER__")]
8918 Other_(String),
8919}
8920/// Key type.
8921///
8922/// Possible values:
8923/// - `rawKey`: Key is fetched directly from KMS.
8924/// - `wrappedKey`: Key is wrapped by a wrapping key from KMS.
8925///
8926/// The wrapping key details are specified in
8927/// *KmipClusterInfoWrappingKeyIdKeyInfo*
8928/// or
8929/// *KmipClusterInfoWrappingRotationIntervalKeyInfo*.
8930///
8931/// ***Since:*** vSphere API Release 9.0.0.0
8932#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8933pub enum KmipClusterInfoKeyTypeEnum {
8934 #[serde(rename = "rawKey")]
8935 #[strum(serialize = "rawKey")]
8936 RawKey,
8937 #[serde(rename = "wrappedKey")]
8938 #[strum(serialize = "wrappedKey")]
8939 WrappedKey,
8940 /// This variant handles values not known at compile time.
8941 #[serde(untagged)]
8942 #[strum(serialize = "__OTHER__")]
8943 Other_(String),
8944}
8945/// Key provider management type.
8946///
8947/// Possible values:
8948/// - `unknown`
8949/// - `vCenter`
8950/// - `trustAuthority`
8951/// - `nativeProvider`: ***Since:*** vSphere API Release 7.0.2.0
8952#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8953pub enum KmipClusterInfoKmsManagementTypeEnum {
8954 #[serde(rename = "unknown")]
8955 #[strum(serialize = "unknown")]
8956 Unknown,
8957 #[serde(rename = "vCenter")]
8958 #[strum(serialize = "vCenter")]
8959 VCenter,
8960 #[serde(rename = "trustAuthority")]
8961 #[strum(serialize = "trustAuthority")]
8962 TrustAuthority,
8963 #[serde(rename = "nativeProvider")]
8964 #[strum(serialize = "nativeProvider")]
8965 NativeProvider,
8966 /// This variant handles values not known at compile time.
8967 #[serde(untagged)]
8968 #[strum(serialize = "__OTHER__")]
8969 Other_(String),
8970}
8971/// Possible values:
8972/// - `userDefinedScriptDisabled`: The user defined script is disabled during customization
8973/// - `customizationDisabled`: The guest customization is disabled by VMware Tools
8974///
8975/// ***Since:*** vSphere API Release 7.0.1.0
8976/// - `rawDataIsNotSupported`: The cloud-init version is too old to support cloud-init raw data
8977///
8978/// ***Since:*** vSphere API Release 7.0.3.0
8979/// - `wrongMetadataFormat`: The cloud-init meta data is not valid format
8980///
8981/// ***Since:*** vSphere API Release 7.0.3.0
8982#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
8983pub enum CustomizationFailedReasonCodeEnum {
8984 #[serde(rename = "userDefinedScriptDisabled")]
8985 #[strum(serialize = "userDefinedScriptDisabled")]
8986 UserDefinedScriptDisabled,
8987 #[serde(rename = "customizationDisabled")]
8988 #[strum(serialize = "customizationDisabled")]
8989 CustomizationDisabled,
8990 #[serde(rename = "rawDataIsNotSupported")]
8991 #[strum(serialize = "rawDataIsNotSupported")]
8992 RawDataIsNotSupported,
8993 #[serde(rename = "wrongMetadataFormat")]
8994 #[strum(serialize = "wrongMetadataFormat")]
8995 WrongMetadataFormat,
8996 /// This variant handles values not known at compile time.
8997 #[serde(untagged)]
8998 #[strum(serialize = "__OTHER__")]
8999 Other_(String),
9000}
9001/// The port blocked/unblocked state.
9002///
9003/// Possible values:
9004/// - `unset`: The dvs port is in unset state
9005/// - `blocked`: The dvs port is in blocked state
9006/// - `unblocked`: The dvs port is in unblocked state
9007/// - `unknown`: The dvs port is in unknown state
9008#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9009pub enum DvsEventPortBlockStateEnum {
9010 #[serde(rename = "unset")]
9011 #[strum(serialize = "unset")]
9012 Unset,
9013 #[serde(rename = "blocked")]
9014 #[strum(serialize = "blocked")]
9015 Blocked,
9016 #[serde(rename = "unblocked")]
9017 #[strum(serialize = "unblocked")]
9018 Unblocked,
9019 #[serde(rename = "unknown")]
9020 #[strum(serialize = "unknown")]
9021 Unknown,
9022 /// This variant handles values not known at compile time.
9023 #[serde(untagged)]
9024 #[strum(serialize = "__OTHER__")]
9025 Other_(String),
9026}
9027/// Severity level constants.
9028///
9029/// Possible values:
9030/// - `error`: Something that must be corrected
9031/// - `warning`: Should be corrected, but the system can continue operating normally
9032/// - `info`: An informational message
9033/// - `user`: A user-related message
9034#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9035pub enum EventEventSeverityEnum {
9036 #[serde(rename = "error")]
9037 #[strum(serialize = "error")]
9038 Error,
9039 #[serde(rename = "warning")]
9040 #[strum(serialize = "warning")]
9041 Warning,
9042 #[serde(rename = "info")]
9043 #[strum(serialize = "info")]
9044 Info,
9045 #[serde(rename = "user")]
9046 #[strum(serialize = "user")]
9047 User,
9048 /// This variant handles values not known at compile time.
9049 #[serde(untagged)]
9050 #[strum(serialize = "__OTHER__")]
9051 Other_(String),
9052}
9053/// Possible values:
9054/// - `info`: Returns informational events.
9055/// - `warning`: Returns warning events.
9056/// - `error`: Returns error events.
9057/// - `user`: Returns events pertaining to users.
9058#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9059pub enum EventCategoryEnum {
9060 #[serde(rename = "info")]
9061 #[strum(serialize = "info")]
9062 Info,
9063 #[serde(rename = "warning")]
9064 #[strum(serialize = "warning")]
9065 Warning,
9066 #[serde(rename = "error")]
9067 #[strum(serialize = "error")]
9068 Error,
9069 #[serde(rename = "user")]
9070 #[strum(serialize = "user")]
9071 User,
9072 /// This variant handles values not known at compile time.
9073 #[serde(untagged)]
9074 #[strum(serialize = "__OTHER__")]
9075 Other_(String),
9076}
9077/// This option specifies how to select events based on child relationships
9078/// in the inventory hierarchy.
9079///
9080/// If a managed entity has children, their events
9081/// can be retrieved with this filter option.
9082///
9083/// Possible values:
9084/// - `self`: Returns events that pertain only to the specified managed entity,
9085/// and not its children.
9086/// - `children`: Returns events pertaining to child entities only.
9087///
9088/// Excludes
9089/// events pertaining to the specified managed entity itself.
9090/// - `all`: Returns events pertaining either to the specified managed entity
9091/// or to its child entities.
9092#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9093pub enum EventFilterSpecRecursionOptionEnum {
9094 #[serde(rename = "self")]
9095 #[strum(serialize = "self")]
9096 Self_,
9097 #[serde(rename = "children")]
9098 #[strum(serialize = "children")]
9099 Children,
9100 #[serde(rename = "all")]
9101 #[strum(serialize = "all")]
9102 All,
9103 /// This variant handles values not known at compile time.
9104 #[serde(untagged)]
9105 #[strum(serialize = "__OTHER__")]
9106 Other_(String),
9107}
9108/// Possible values:
9109/// - `configFailed`: Error while configuring/unconfiguring HA
9110/// - `timeout`: Timeout while communicating with HA agent
9111/// - `communicationInitFailed`: HA communication initialization failed
9112/// - `healthCheckScriptFailed`: Health check script failed
9113/// - `agentFailed`: HA agent has an error
9114/// - `agentShutdown`: HA agent was shutdown
9115/// - `isolationAddressUnpingable`: HA isolation address unpingable
9116/// - `other`: Other reason
9117#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9118pub enum HostDasErrorEventHostDasErrorReasonEnum {
9119 #[serde(rename = "configFailed")]
9120 #[strum(serialize = "configFailed")]
9121 ConfigFailed,
9122 #[serde(rename = "timeout")]
9123 #[strum(serialize = "timeout")]
9124 Timeout,
9125 #[serde(rename = "communicationInitFailed")]
9126 #[strum(serialize = "communicationInitFailed")]
9127 CommunicationInitFailed,
9128 #[serde(rename = "healthCheckScriptFailed")]
9129 #[strum(serialize = "healthCheckScriptFailed")]
9130 HealthCheckScriptFailed,
9131 #[serde(rename = "agentFailed")]
9132 #[strum(serialize = "agentFailed")]
9133 AgentFailed,
9134 #[serde(rename = "agentShutdown")]
9135 #[strum(serialize = "agentShutdown")]
9136 AgentShutdown,
9137 #[serde(rename = "isolationAddressUnpingable")]
9138 #[strum(serialize = "isolationAddressUnpingable")]
9139 IsolationAddressUnpingable,
9140 #[serde(rename = "other")]
9141 #[strum(serialize = "other")]
9142 Other,
9143 /// This variant handles values not known at compile time.
9144 #[serde(untagged)]
9145 #[strum(serialize = "__OTHER__")]
9146 Other_(String),
9147}
9148/// Possible values:
9149/// - `sslThumbprintVerifyFailed`: Failed to verify SSL thumbprint
9150/// - `licenseExpired`: License expired for the host
9151/// - `agentUpgrade`: Agent is being upgraded
9152/// - `userRequest`: User requested disconnect
9153/// - `insufficientLicenses`: License not available after host upgrade
9154/// - `agentOutOfDate`: Agent is out of date
9155/// - `passwordDecryptFailure`: Failed to decrypt password
9156/// - `unknown`: Unknown reason
9157/// - `vcVRAMCapacityExceeded`: The vRAM capacity of vCenter will be exceeded
9158#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9159pub enum HostDisconnectedEventReasonCodeEnum {
9160 #[serde(rename = "sslThumbprintVerifyFailed")]
9161 #[strum(serialize = "sslThumbprintVerifyFailed")]
9162 SslThumbprintVerifyFailed,
9163 #[serde(rename = "licenseExpired")]
9164 #[strum(serialize = "licenseExpired")]
9165 LicenseExpired,
9166 #[serde(rename = "agentUpgrade")]
9167 #[strum(serialize = "agentUpgrade")]
9168 AgentUpgrade,
9169 #[serde(rename = "userRequest")]
9170 #[strum(serialize = "userRequest")]
9171 UserRequest,
9172 #[serde(rename = "insufficientLicenses")]
9173 #[strum(serialize = "insufficientLicenses")]
9174 InsufficientLicenses,
9175 #[serde(rename = "agentOutOfDate")]
9176 #[strum(serialize = "agentOutOfDate")]
9177 AgentOutOfDate,
9178 #[serde(rename = "passwordDecryptFailure")]
9179 #[strum(serialize = "passwordDecryptFailure")]
9180 PasswordDecryptFailure,
9181 #[serde(rename = "unknown")]
9182 #[strum(serialize = "unknown")]
9183 Unknown,
9184 #[serde(rename = "vcVRAMCapacityExceeded")]
9185 #[strum(serialize = "vcVRAMCapacityExceeded")]
9186 VcVramCapacityExceeded,
9187 /// This variant handles values not known at compile time.
9188 #[serde(untagged)]
9189 #[strum(serialize = "__OTHER__")]
9190 Other_(String),
9191}
9192/// Possible values:
9193/// - `vmtoolsHeartbeatFailure`: vmtools heartbeat failure
9194/// - `appHeartbeatFailure`: application heartbeat failure
9195/// - `appImmediateResetRequest`: immediate reset request
9196/// - `vmcpResetApdCleared`: reset issued by VMCP when APD cleared
9197#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9198pub enum VmDasBeingResetEventReasonCodeEnum {
9199 #[serde(rename = "vmtoolsHeartbeatFailure")]
9200 #[strum(serialize = "vmtoolsHeartbeatFailure")]
9201 VmtoolsHeartbeatFailure,
9202 #[serde(rename = "appHeartbeatFailure")]
9203 #[strum(serialize = "appHeartbeatFailure")]
9204 AppHeartbeatFailure,
9205 #[serde(rename = "appImmediateResetRequest")]
9206 #[strum(serialize = "appImmediateResetRequest")]
9207 AppImmediateResetRequest,
9208 #[serde(rename = "vmcpResetApdCleared")]
9209 #[strum(serialize = "vmcpResetApdCleared")]
9210 VmcpResetApdCleared,
9211 /// This variant handles values not known at compile time.
9212 #[serde(untagged)]
9213 #[strum(serialize = "__OTHER__")]
9214 Other_(String),
9215}
9216/// The reason for the failure.
9217///
9218/// Possible values:
9219/// - `incompatibleHost`: Remote host is incompatible for secondary virtual machine.
9220///
9221/// For instance, the host doesn't have access to the virtual machine's
9222/// network or datastore.
9223/// - `loginFailed`: Login to remote host failed.
9224/// - `registerVmFailed`: Registration of the secondary virtual machine
9225/// on the remote host failed.
9226/// - `migrateFailed`: Migration failed.
9227#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9228pub enum VmFailedStartingSecondaryEventFailureReasonEnum {
9229 #[serde(rename = "incompatibleHost")]
9230 #[strum(serialize = "incompatibleHost")]
9231 IncompatibleHost,
9232 #[serde(rename = "loginFailed")]
9233 #[strum(serialize = "loginFailed")]
9234 LoginFailed,
9235 #[serde(rename = "registerVmFailed")]
9236 #[strum(serialize = "registerVmFailed")]
9237 RegisterVmFailed,
9238 #[serde(rename = "migrateFailed")]
9239 #[strum(serialize = "migrateFailed")]
9240 MigrateFailed,
9241 /// This variant handles values not known at compile time.
9242 #[serde(untagged)]
9243 #[strum(serialize = "__OTHER__")]
9244 Other_(String),
9245}
9246/// Possible values:
9247/// - `shutdown`: The virtual machine was shut down
9248/// - `poweredOff`: The virtual machine was powered off because shut down failed
9249#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9250pub enum VmShutdownOnIsolationEventOperationEnum {
9251 #[serde(rename = "shutdown")]
9252 #[strum(serialize = "shutdown")]
9253 Shutdown,
9254 #[serde(rename = "poweredOff")]
9255 #[strum(serialize = "poweredOff")]
9256 PoweredOff,
9257 /// This variant handles values not known at compile time.
9258 #[serde(untagged)]
9259 #[strum(serialize = "__OTHER__")]
9260 Other_(String),
9261}
9262/// Types of affinities.
9263///
9264/// Possible values:
9265/// - `memory`
9266/// - `cpu`
9267#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9268pub enum AffinityTypeEnum {
9269 #[serde(rename = "memory")]
9270 #[strum(serialize = "memory")]
9271 Memory,
9272 #[serde(rename = "cpu")]
9273 #[strum(serialize = "cpu")]
9274 Cpu,
9275 /// This variant handles values not known at compile time.
9276 #[serde(untagged)]
9277 #[strum(serialize = "__OTHER__")]
9278 Other_(String),
9279}
9280/// Possible values:
9281/// - `NotEnoughSpaceOnDevice`: There is not enough storage space on the host to install the agent.
9282/// - `PrepareToUpgradeFailed`: Failed to initialize the upgrade directory on the host.
9283/// - `AgentNotRunning`: The agent was installed but is not running.
9284/// - `AgentNotReachable`: The agent was installed but did not respond to requests.
9285/// - `InstallTimedout`: The agent install took too long.
9286/// - `SignatureVerificationFailed`: The signature verification for the installer failed.
9287/// - `AgentUploadFailed`: Failed to upload the agent installer.
9288/// - `AgentUploadTimedout`: The agent upload took too long.
9289/// - `UnknownInstallerError`: The agent installer failed for an unknown reason.
9290#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9291pub enum AgentInstallFailedReasonEnum {
9292 NotEnoughSpaceOnDevice,
9293 PrepareToUpgradeFailed,
9294 AgentNotRunning,
9295 AgentNotReachable,
9296 InstallTimedout,
9297 SignatureVerificationFailed,
9298 AgentUploadFailed,
9299 AgentUploadTimedout,
9300 UnknownInstallerError,
9301 /// This variant handles values not known at compile time.
9302 #[serde(untagged)]
9303 #[strum(serialize = "__OTHER__")]
9304 Other_(String),
9305}
9306/// Possible values:
9307/// - `APDTimeoutDisabled`: APD timeout has been disabled on one of the host
9308#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9309pub enum CannotEnableVmcpForClusterReasonEnum {
9310 #[serde(rename = "APDTimeoutDisabled")]
9311 #[strum(serialize = "APDTimeoutDisabled")]
9312 ApdTimeoutDisabled,
9313 /// This variant handles values not known at compile time.
9314 #[serde(untagged)]
9315 #[strum(serialize = "__OTHER__")]
9316 Other_(String),
9317}
9318/// Possible values:
9319/// - `resourcePool`: Move out of the resouce pool
9320/// - `cluster`: Move out of the cluster
9321#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9322pub enum CannotMoveFaultToleranceVmMoveTypeEnum {
9323 #[serde(rename = "resourcePool")]
9324 #[strum(serialize = "resourcePool")]
9325 ResourcePool,
9326 #[serde(rename = "cluster")]
9327 #[strum(serialize = "cluster")]
9328 Cluster,
9329 /// This variant handles values not known at compile time.
9330 #[serde(untagged)]
9331 #[strum(serialize = "__OTHER__")]
9332 Other_(String),
9333}
9334/// Possible values:
9335/// - `suspend`: suspend
9336/// - `powerOff`: power off
9337/// - `guestShutdown`: guest shutdown
9338/// - `guestSuspend`: guest suspend
9339#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9340pub enum CannotPowerOffVmInClusterOperationEnum {
9341 #[serde(rename = "suspend")]
9342 #[strum(serialize = "suspend")]
9343 Suspend,
9344 #[serde(rename = "powerOff")]
9345 #[strum(serialize = "powerOff")]
9346 PowerOff,
9347 #[serde(rename = "guestShutdown")]
9348 #[strum(serialize = "guestShutdown")]
9349 GuestShutdown,
9350 #[serde(rename = "guestSuspend")]
9351 #[strum(serialize = "guestSuspend")]
9352 GuestSuspend,
9353 /// This variant handles values not known at compile time.
9354 #[serde(untagged)]
9355 #[strum(serialize = "__OTHER__")]
9356 Other_(String),
9357}
9358/// Possible values:
9359/// - `NetworkReservationNotSupported`: Network does not support reservation
9360/// - `MismatchedNetworkPolicies`: Source and destination networks do not have same security policies
9361/// - `MismatchedDvsVersionOrVendor`: Source and destination DVS do not have same version or vendor
9362/// - `VMotionToUnsupportedNetworkType`: VMotion to unsupported destination network type
9363/// - `NetworkUnderMaintenance`: The network is under maintenance
9364/// - `MismatchedEnsMode`: Source and destination networks do not have same ENS(Enhanced Network Stack) mode
9365/// - `MismatchedRealTimeDvs`: Source and destination networks do not have the same real-time flag
9366///
9367/// ***Since:*** vSphere API Release 8.0.3.1
9368#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9369pub enum CannotUseNetworkReasonEnum {
9370 NetworkReservationNotSupported,
9371 MismatchedNetworkPolicies,
9372 MismatchedDvsVersionOrVendor,
9373 VMotionToUnsupportedNetworkType,
9374 NetworkUnderMaintenance,
9375 MismatchedEnsMode,
9376 MismatchedRealTimeDvs,
9377 /// This variant handles values not known at compile time.
9378 #[serde(untagged)]
9379 #[strum(serialize = "__OTHER__")]
9380 Other_(String),
9381}
9382/// Possible values:
9383/// - `HostNetworkMisconfiguration`: There is a problem with the host network configuration.
9384/// - `HostMisconfiguration`: There is a problem with the host configuration.
9385/// - `InsufficientPrivileges`: The privileges were insuffient for the operation.
9386/// - `NoPrimaryAgentAvailable`: There was no running primary agent available to contact.
9387///
9388/// Check that your other hosts don't have HA errors
9389/// - `Other`: The HA configuration failed for other reasons.
9390/// - `NoDatastoresConfigured`: No datastores defined for this host
9391/// - `CreateConfigVvolFailed`: Failure to create config vvol
9392/// - `VSanNotSupportedOnHost`: Host in vSAN cluster does not support vSAN.
9393/// - `DasNetworkMisconfiguration`: There is a problem with the cluster network configuration.
9394/// - `SetDesiredImageSpecFailed`: Setting desired imageSpec in Personality Manager failed
9395/// - `ApplyHAVibsOnClusterFailed`: The ApplyHA call to Personality Manager failed
9396#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9397pub enum DasConfigFaultDasConfigFaultReasonEnum {
9398 HostNetworkMisconfiguration,
9399 HostMisconfiguration,
9400 InsufficientPrivileges,
9401 NoPrimaryAgentAvailable,
9402 Other,
9403 NoDatastoresConfigured,
9404 CreateConfigVvolFailed,
9405 VSanNotSupportedOnHost,
9406 DasNetworkMisconfiguration,
9407 SetDesiredImageSpecFailed,
9408 #[serde(rename = "ApplyHAVibsOnClusterFailed")]
9409 #[strum(serialize = "ApplyHAVibsOnClusterFailed")]
9410 ApplyHaVibsOnClusterFailed,
9411 /// This variant handles values not known at compile time.
9412 #[serde(untagged)]
9413 #[strum(serialize = "__OTHER__")]
9414 Other_(String),
9415}
9416/// Reasons why a virtual device would not be supported on a host.
9417///
9418/// Possible values:
9419/// - `host`: The host does not support this virtual device at all.
9420/// - `guest`: The device is supported by the host in general, but not for
9421/// the specific guest OS the virtual machine is using.
9422/// - `ft`: The device is supported by the host and guest OS, but not for
9423/// the vSphere Fault Tolerance.
9424///
9425/// ***Since:*** vSphere API Release 8.0.3.0
9426#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9427pub enum DeviceNotSupportedReasonEnum {
9428 #[serde(rename = "host")]
9429 #[strum(serialize = "host")]
9430 Host,
9431 #[serde(rename = "guest")]
9432 #[strum(serialize = "guest")]
9433 Guest,
9434 #[serde(rename = "ft")]
9435 #[strum(serialize = "ft")]
9436 Ft,
9437 /// This variant handles values not known at compile time.
9438 #[serde(untagged)]
9439 #[strum(serialize = "__OTHER__")]
9440 Other_(String),
9441}
9442/// The disallowed change type.
9443///
9444/// Possible values:
9445/// - `hotExtendDisk`: Online extend disk operation.
9446#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9447pub enum DisallowedChangeByServiceDisallowedChangeEnum {
9448 #[serde(rename = "hotExtendDisk")]
9449 #[strum(serialize = "hotExtendDisk")]
9450 HotExtendDisk,
9451 /// This variant handles values not known at compile time.
9452 #[serde(untagged)]
9453 #[strum(serialize = "__OTHER__")]
9454 Other_(String),
9455}
9456/// HostSelectionType defines how the host was selected
9457///
9458/// Possible values:
9459/// - `user`: The host was specified by the user
9460/// - `vc`: The host was selected by Virtual Center
9461/// - `drs`: The host was selected by DRS
9462#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9463pub enum FtIssuesOnHostHostSelectionTypeEnum {
9464 #[serde(rename = "user")]
9465 #[strum(serialize = "user")]
9466 User,
9467 #[serde(rename = "vc")]
9468 #[strum(serialize = "vc")]
9469 Vc,
9470 #[serde(rename = "drs")]
9471 #[strum(serialize = "drs")]
9472 Drs,
9473 /// This variant handles values not known at compile time.
9474 #[serde(untagged)]
9475 #[strum(serialize = "__OTHER__")]
9476 Other_(String),
9477}
9478/// Possible values:
9479/// - `Datastore`
9480#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9481pub enum HostHasComponentFailureHostComponentTypeEnum {
9482 Datastore,
9483 /// This variant handles values not known at compile time.
9484 #[serde(untagged)]
9485 #[strum(serialize = "__OTHER__")]
9486 Other_(String),
9487}
9488/// Reasons why fault tolerance is not supported on the host.
9489///
9490/// Possible values:
9491/// - `product`: The product does not support fault tolerance.
9492/// - `processor`: The product supports fault tolerance but the host CPU does not.
9493#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9494pub enum HostIncompatibleForFaultToleranceReasonEnum {
9495 #[serde(rename = "product")]
9496 #[strum(serialize = "product")]
9497 Product,
9498 #[serde(rename = "processor")]
9499 #[strum(serialize = "processor")]
9500 Processor,
9501 /// This variant handles values not known at compile time.
9502 #[serde(untagged)]
9503 #[strum(serialize = "__OTHER__")]
9504 Other_(String),
9505}
9506/// Reasons why record/replay is not supported on a host.
9507///
9508/// Possible values:
9509/// - `product`: The product does not support record/replay.
9510/// - `processor`: The product supports record/replay but the host CPU does not.
9511#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9512pub enum HostIncompatibleForRecordReplayReasonEnum {
9513 #[serde(rename = "product")]
9514 #[strum(serialize = "product")]
9515 Product,
9516 #[serde(rename = "processor")]
9517 #[strum(serialize = "processor")]
9518 Processor,
9519 /// This variant handles values not known at compile time.
9520 #[serde(untagged)]
9521 #[strum(serialize = "__OTHER__")]
9522 Other_(String),
9523}
9524/// Possible values:
9525/// - `rpo`: Host does not support the RPO configured for VM replication.
9526/// - `netCompression`: Host does not support network compression configured for VM
9527/// replication.
9528#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9529pub enum IncompatibleHostForVmReplicationIncompatibleReasonEnum {
9530 #[serde(rename = "rpo")]
9531 #[strum(serialize = "rpo")]
9532 Rpo,
9533 #[serde(rename = "netCompression")]
9534 #[strum(serialize = "netCompression")]
9535 NetCompression,
9536 /// This variant handles values not known at compile time.
9537 #[serde(untagged)]
9538 #[strum(serialize = "__OTHER__")]
9539 Other_(String),
9540}
9541/// Possible values:
9542/// - `admissionControl`: Policies for admission control
9543/// - `userHeartbeatDs`: User-specified heartbeat datastores
9544/// - `vmConfig`: VM override
9545#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9546pub enum InvalidDasConfigArgumentEntryForInvalidArgumentEnum {
9547 #[serde(rename = "admissionControl")]
9548 #[strum(serialize = "admissionControl")]
9549 AdmissionControl,
9550 #[serde(rename = "userHeartbeatDs")]
9551 #[strum(serialize = "userHeartbeatDs")]
9552 UserHeartbeatDs,
9553 #[serde(rename = "vmConfig")]
9554 #[strum(serialize = "vmConfig")]
9555 VmConfig,
9556 /// This variant handles values not known at compile time.
9557 #[serde(untagged)]
9558 #[strum(serialize = "__OTHER__")]
9559 Other_(String),
9560}
9561/// Possible values:
9562/// - `incompatibleVersion`: The associated host and profile version are incompatible.
9563/// - `missingReferenceHost`: There is no reference host associated with the profile.
9564#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9565pub enum InvalidProfileReferenceHostReasonEnum {
9566 #[serde(rename = "incompatibleVersion")]
9567 #[strum(serialize = "incompatibleVersion")]
9568 IncompatibleVersion,
9569 #[serde(rename = "missingReferenceHost")]
9570 #[strum(serialize = "missingReferenceHost")]
9571 MissingReferenceHost,
9572 /// This variant handles values not known at compile time.
9573 #[serde(untagged)]
9574 #[strum(serialize = "__OTHER__")]
9575 Other_(String),
9576}
9577/// Possible values:
9578/// - `keyEntityMismatch`: The license and the entity to which it is to be assigned are not compatible.
9579/// - `downgradeDisallowed`: The license downgrade is disallowed because some features are in use.
9580/// - `inventoryNotManageableByVirtualCenter`: The inventory has hosts which are not manageable by vCenter unless in evaluation.
9581/// - `hostsUnmanageableByVirtualCenterWithoutLicenseServer`: The inventory has hosts that need the license server to be configured unless vCenter is in evaluation
9582#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9583pub enum LicenseAssignmentFailedReasonEnum {
9584 #[serde(rename = "keyEntityMismatch")]
9585 #[strum(serialize = "keyEntityMismatch")]
9586 KeyEntityMismatch,
9587 #[serde(rename = "downgradeDisallowed")]
9588 #[strum(serialize = "downgradeDisallowed")]
9589 DowngradeDisallowed,
9590 #[serde(rename = "inventoryNotManageableByVirtualCenter")]
9591 #[strum(serialize = "inventoryNotManageableByVirtualCenter")]
9592 InventoryNotManageableByVirtualCenter,
9593 #[serde(rename = "hostsUnmanageableByVirtualCenterWithoutLicenseServer")]
9594 #[strum(serialize = "hostsUnmanageableByVirtualCenterWithoutLicenseServer")]
9595 HostsUnmanageableByVirtualCenterWithoutLicenseServer,
9596 /// This variant handles values not known at compile time.
9597 #[serde(untagged)]
9598 #[strum(serialize = "__OTHER__")]
9599 Other_(String),
9600}
9601/// Possible values:
9602/// - `virtualVmxnet3`: vmxnet3 virtual Ethernet adapter
9603/// - `paraVirtualSCSIController`: paravirtualized SCSI controller
9604#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9605pub enum NotSupportedDeviceForFtDeviceTypeEnum {
9606 #[serde(rename = "virtualVmxnet3")]
9607 #[strum(serialize = "virtualVmxnet3")]
9608 VirtualVmxnet3,
9609 #[serde(rename = "paraVirtualSCSIController")]
9610 #[strum(serialize = "paraVirtualSCSIController")]
9611 ParaVirtualScsiController,
9612 /// This variant handles values not known at compile time.
9613 #[serde(untagged)]
9614 #[strum(serialize = "__OTHER__")]
9615 Other_(String),
9616}
9617/// Reasons why the number of virtual CPUs is incompatible.
9618///
9619/// Possible values:
9620/// - `recordReplay`:
9621///
9622/// Deprecated as of vSphere API 6.0.
9623///
9624/// The virtual machine needs to support record/replay functionality.
9625/// - `faultTolerance`: The virtual machine is enabled for fault tolerance.
9626#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9627pub enum NumVirtualCpusIncompatibleReasonEnum {
9628 #[serde(rename = "recordReplay")]
9629 #[strum(serialize = "recordReplay")]
9630 RecordReplay,
9631 #[serde(rename = "faultTolerance")]
9632 #[strum(serialize = "faultTolerance")]
9633 FaultTolerance,
9634 /// This variant handles values not known at compile time.
9635 #[serde(untagged)]
9636 #[strum(serialize = "__OTHER__")]
9637 Other_(String),
9638}
9639/// Possible values:
9640/// - `NoCompatibleNonQuarantinedHost`: The cluster does not contain any non-quarantined host satisfying the
9641/// VM/host affinity rules for the VM.
9642/// - `CorrectionDisallowed`: The current DRS migration priority setting disallows generating a
9643/// recommendation to prevent VMs on quarantined hosts.
9644///
9645/// Thus, the
9646/// violation will not be corrected.
9647/// - `CorrectionImpact`: DRS has determined that evacuation of VMs from quarantined hosts
9648/// impacts respecting cluster constraints or performance goals so they
9649/// are not evacuated.
9650#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9651pub enum QuarantineModeFaultFaultTypeEnum {
9652 NoCompatibleNonQuarantinedHost,
9653 CorrectionDisallowed,
9654 CorrectionImpact,
9655 /// This variant handles values not known at compile time.
9656 #[serde(untagged)]
9657 #[strum(serialize = "__OTHER__")]
9658 Other_(String),
9659}
9660/// Possible values:
9661/// - `diskNotFound`: Could not look up device by key
9662/// - `diskTypeNotSupported`: Replication not supported for disk type or backend
9663/// - `invalidDiskKey`: Invalid key value
9664/// - `invalidDiskReplicationId`: Invalid disk replication ID string
9665/// - `duplicateDiskReplicationId`: Another disk in the VM has the same replication ID
9666/// - `invalidPersistentFilePath`: Invalid path (string) for the persistent file
9667/// - `reconfigureDiskReplicationIdNotAllowed`: Attempting to re-configure the disk's replication ID
9668#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9669pub enum ReplicationDiskConfigFaultReasonForFaultEnum {
9670 #[serde(rename = "diskNotFound")]
9671 #[strum(serialize = "diskNotFound")]
9672 DiskNotFound,
9673 #[serde(rename = "diskTypeNotSupported")]
9674 #[strum(serialize = "diskTypeNotSupported")]
9675 DiskTypeNotSupported,
9676 #[serde(rename = "invalidDiskKey")]
9677 #[strum(serialize = "invalidDiskKey")]
9678 InvalidDiskKey,
9679 #[serde(rename = "invalidDiskReplicationId")]
9680 #[strum(serialize = "invalidDiskReplicationId")]
9681 InvalidDiskReplicationId,
9682 #[serde(rename = "duplicateDiskReplicationId")]
9683 #[strum(serialize = "duplicateDiskReplicationId")]
9684 DuplicateDiskReplicationId,
9685 #[serde(rename = "invalidPersistentFilePath")]
9686 #[strum(serialize = "invalidPersistentFilePath")]
9687 InvalidPersistentFilePath,
9688 #[serde(rename = "reconfigureDiskReplicationIdNotAllowed")]
9689 #[strum(serialize = "reconfigureDiskReplicationIdNotAllowed")]
9690 ReconfigureDiskReplicationIdNotAllowed,
9691 /// This variant handles values not known at compile time.
9692 #[serde(untagged)]
9693 #[strum(serialize = "__OTHER__")]
9694 Other_(String),
9695}
9696/// Possible values:
9697/// - `incompatibleHwVersion`: Incompatible VM hardware version
9698/// - `invalidVmReplicationId`: Invalid VM Replication ID string
9699/// - `invalidGenerationNumber`: Invalid generation number in VM's configuration
9700/// - `outOfBoundsRpoValue`: Invalid RPO value (out of bounds)
9701/// - `invalidDestinationIpAddress`: Invalid destination IP address
9702/// - `invalidDestinationPort`: Invalid destination port
9703/// - `invalidExtraVmOptions`: Malformed extra options list
9704/// - `staleGenerationNumber`: Mis-matching generation number (stale)
9705/// - `reconfigureVmReplicationIdNotAllowed`: Attempting to re-configure the VM replication ID
9706/// - `cannotRetrieveVmReplicationConfiguration`: Could not retrieve the VM configuration
9707/// - `replicationAlreadyEnabled`: Attempting to re-enable replication for the VM
9708/// - `invalidPriorConfiguration`: The existing replication configuration of the VM is broken
9709/// (applicable to re-configuration only).
9710/// - `replicationNotEnabled`: Attempting to re-configure or disable replication for a VM
9711/// for which replication has not been enabled.
9712/// - `replicationConfigurationFailed`: Failed to commit the new replication properties for the VM.
9713/// - `encryptedVm`: VM is encrypted
9714/// - `invalidThumbprint`: Remote certificate thumbprint is invalid
9715/// - `incompatibleDevice`: VM hardware contains devices incompatible with replication
9716#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9717pub enum ReplicationVmConfigFaultReasonForFaultEnum {
9718 #[serde(rename = "incompatibleHwVersion")]
9719 #[strum(serialize = "incompatibleHwVersion")]
9720 IncompatibleHwVersion,
9721 #[serde(rename = "invalidVmReplicationId")]
9722 #[strum(serialize = "invalidVmReplicationId")]
9723 InvalidVmReplicationId,
9724 #[serde(rename = "invalidGenerationNumber")]
9725 #[strum(serialize = "invalidGenerationNumber")]
9726 InvalidGenerationNumber,
9727 #[serde(rename = "outOfBoundsRpoValue")]
9728 #[strum(serialize = "outOfBoundsRpoValue")]
9729 OutOfBoundsRpoValue,
9730 #[serde(rename = "invalidDestinationIpAddress")]
9731 #[strum(serialize = "invalidDestinationIpAddress")]
9732 InvalidDestinationIpAddress,
9733 #[serde(rename = "invalidDestinationPort")]
9734 #[strum(serialize = "invalidDestinationPort")]
9735 InvalidDestinationPort,
9736 #[serde(rename = "invalidExtraVmOptions")]
9737 #[strum(serialize = "invalidExtraVmOptions")]
9738 InvalidExtraVmOptions,
9739 #[serde(rename = "staleGenerationNumber")]
9740 #[strum(serialize = "staleGenerationNumber")]
9741 StaleGenerationNumber,
9742 #[serde(rename = "reconfigureVmReplicationIdNotAllowed")]
9743 #[strum(serialize = "reconfigureVmReplicationIdNotAllowed")]
9744 ReconfigureVmReplicationIdNotAllowed,
9745 #[serde(rename = "cannotRetrieveVmReplicationConfiguration")]
9746 #[strum(serialize = "cannotRetrieveVmReplicationConfiguration")]
9747 CannotRetrieveVmReplicationConfiguration,
9748 #[serde(rename = "replicationAlreadyEnabled")]
9749 #[strum(serialize = "replicationAlreadyEnabled")]
9750 ReplicationAlreadyEnabled,
9751 #[serde(rename = "invalidPriorConfiguration")]
9752 #[strum(serialize = "invalidPriorConfiguration")]
9753 InvalidPriorConfiguration,
9754 #[serde(rename = "replicationNotEnabled")]
9755 #[strum(serialize = "replicationNotEnabled")]
9756 ReplicationNotEnabled,
9757 #[serde(rename = "replicationConfigurationFailed")]
9758 #[strum(serialize = "replicationConfigurationFailed")]
9759 ReplicationConfigurationFailed,
9760 #[serde(rename = "encryptedVm")]
9761 #[strum(serialize = "encryptedVm")]
9762 EncryptedVm,
9763 #[serde(rename = "invalidThumbprint")]
9764 #[strum(serialize = "invalidThumbprint")]
9765 InvalidThumbprint,
9766 #[serde(rename = "incompatibleDevice")]
9767 #[strum(serialize = "incompatibleDevice")]
9768 IncompatibleDevice,
9769 /// This variant handles values not known at compile time.
9770 #[serde(untagged)]
9771 #[strum(serialize = "__OTHER__")]
9772 Other_(String),
9773}
9774/// Possible values:
9775/// - `notConfigured`: *VirtualMachine* is not configured for replication
9776/// - `poweredOff`: *VirtualMachine* is powered off (and is not undergoing
9777/// offline replication)
9778/// - `suspended`: *VirtualMachine* is suspended (and is not undergoing
9779/// offline replication)
9780/// - `poweredOn`: *VirtualMachine* is powered on
9781/// - `offlineReplicating`: *VirtualMachine* is in the process of creating an
9782/// an offline instance.
9783/// - `invalidState`: *VirtualMachine* is in an invalid state
9784/// - `invalidInstanceId`: The specified instanceId does not match the *VirtualMachine*
9785/// instanceId
9786/// - `closeDiskError`: *VirtualMachine* is in the process of creating an
9787/// offline instance and we are trying to disable it.
9788///
9789/// The first step is to close the offline disk. If closing disks
9790/// is not successful, throw this fault.
9791/// - `groupExist`: *VirtualMachine* is trying to create a group already
9792/// owned by another VM.
9793#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9794pub enum ReplicationVmFaultReasonForFaultEnum {
9795 #[serde(rename = "notConfigured")]
9796 #[strum(serialize = "notConfigured")]
9797 NotConfigured,
9798 #[serde(rename = "poweredOff")]
9799 #[strum(serialize = "poweredOff")]
9800 PoweredOff,
9801 #[serde(rename = "suspended")]
9802 #[strum(serialize = "suspended")]
9803 Suspended,
9804 #[serde(rename = "poweredOn")]
9805 #[strum(serialize = "poweredOn")]
9806 PoweredOn,
9807 #[serde(rename = "offlineReplicating")]
9808 #[strum(serialize = "offlineReplicating")]
9809 OfflineReplicating,
9810 #[serde(rename = "invalidState")]
9811 #[strum(serialize = "invalidState")]
9812 InvalidState,
9813 #[serde(rename = "invalidInstanceId")]
9814 #[strum(serialize = "invalidInstanceId")]
9815 InvalidInstanceId,
9816 #[serde(rename = "closeDiskError")]
9817 #[strum(serialize = "closeDiskError")]
9818 CloseDiskError,
9819 #[serde(rename = "groupExist")]
9820 #[strum(serialize = "groupExist")]
9821 GroupExist,
9822 /// This variant handles values not known at compile time.
9823 #[serde(untagged)]
9824 #[strum(serialize = "__OTHER__")]
9825 Other_(String),
9826}
9827/// Possible values:
9828/// - `fullSync`: Initial synchronization with the remote site
9829/// - `delta`: Delta updates to generate a consistent instance
9830#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9831pub enum ReplicationVmInProgressFaultActivityEnum {
9832 #[serde(rename = "fullSync")]
9833 #[strum(serialize = "fullSync")]
9834 FullSync,
9835 #[serde(rename = "delta")]
9836 #[strum(serialize = "delta")]
9837 Delta,
9838 /// This variant handles values not known at compile time.
9839 #[serde(untagged)]
9840 #[strum(serialize = "__OTHER__")]
9841 Other_(String),
9842}
9843/// Possible values:
9844/// - `licenseAssignmentFailed`: A general failure has occurred during assigning license to the 3rd party module
9845/// - `moduleNotInstalled`: The 3rd party module we are trying to license is not installed.
9846#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9847pub enum ThirdPartyLicenseAssignmentFailedReasonEnum {
9848 #[serde(rename = "licenseAssignmentFailed")]
9849 #[strum(serialize = "licenseAssignmentFailed")]
9850 LicenseAssignmentFailed,
9851 #[serde(rename = "moduleNotInstalled")]
9852 #[strum(serialize = "moduleNotInstalled")]
9853 ModuleNotInstalled,
9854 /// This variant handles values not known at compile time.
9855 #[serde(untagged)]
9856 #[strum(serialize = "__OTHER__")]
9857 Other_(String),
9858}
9859/// Possible values:
9860/// - `CacheModeNotSupported`
9861/// - `CacheConsistencyTypeNotSupported`
9862/// - `CacheBlockSizeNotSupported`
9863/// - `CacheReservationNotSupported`
9864/// - `DiskSizeNotSupported`
9865#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9866pub enum VFlashModuleNotSupportedReasonEnum {
9867 CacheModeNotSupported,
9868 CacheConsistencyTypeNotSupported,
9869 CacheBlockSizeNotSupported,
9870 CacheReservationNotSupported,
9871 DiskSizeNotSupported,
9872 /// This variant handles values not known at compile time.
9873 #[serde(untagged)]
9874 #[strum(serialize = "__OTHER__")]
9875 Other_(String),
9876}
9877/// Possible values:
9878/// - `haNotEnabled`: HA is not enabled on the cluster
9879/// - `moreThanOneSecondary`: There is already a secondary virtual machine for the primary
9880/// virtual machine
9881/// - `recordReplayNotSupported`:
9882///
9883/// Deprecated as of vSphere API 6.0.
9884///
9885/// The virtual machine does not support record/replay.
9886///
9887/// Vm::Capability.RecordReplaySupported is false.
9888/// - `replayNotSupported`:
9889///
9890/// Deprecated as of vSphere API 6.0.
9891///
9892/// It is not possible to turn on Fault Tolerance on this powered-on VM.
9893///
9894/// The support for record/replay should be enabled or Fault Tolerance
9895/// turned on, when this VM is powered off.
9896/// - `templateVm`: The virtual machine is a template
9897/// - `multipleVCPU`: The virtual machine has more than one virtual CPU
9898/// - `hostInactive`: The host is not active
9899/// - `ftUnsupportedHardware`: The host ftSupported flag is not set because of hardware issues
9900/// - `ftUnsupportedProduct`: The host ftSupported flag is not set because of it is a
9901/// VMware Server 2.0
9902/// - `missingVMotionNic`: No VMotion license or VMotion nic is not configured on the host
9903/// - `missingFTLoggingNic`: FT logging nic is not configured on the host
9904/// - `thinDisk`: The virtual machine has thin provisioned disks
9905/// - `verifySSLCertificateFlagNotSet`: The "check host certificate" flag is not set
9906/// - `hasSnapshots`: The virtual machine has one or more snapshots
9907/// - `noConfig`: No configuration information is available for the virtual machine
9908/// - `ftSecondaryVm`: The virtual machine is a fault tolerance secondary virtual machine
9909/// - `hasLocalDisk`: The virtual machine has one or more disks on local datastore
9910/// - `esxAgentVm`: The virtual machine is an ESX agent VM
9911/// - `video3dEnabled`: The virtual machine video device has 3D enabled
9912/// - `hasUnsupportedDisk`
9913/// - `insufficientBandwidth`: FT logging nic does not have desired bandwidth
9914/// - `hasNestedHVConfiguration`: The host does not support fault tolerant VM with nested HV or VBS
9915/// enabled.
9916/// - `hasVFlashConfiguration`: The virtual machine has a vFlash memory device or/and disks with
9917/// vFlash cache configured.
9918/// - `unsupportedProduct`: VMware product installed on the host does not support
9919/// fault tolerance
9920/// - `cpuHvUnsupported`: Host CPU does not support hardware virtualization
9921/// - `cpuHwmmuUnsupported`: Host CPU does not support hardware MMU virtualization
9922/// - `cpuHvDisabled`: Host CPU is compatible for replay-based FT, but hardware
9923/// virtualization has been disabled in the BIOS.
9924/// - `hasEFIFirmware`: The virtual machine firmware is of type EFI
9925/// - `tooManyVCPUs`: The host does not support fault tolerance virtual machines
9926/// with the specified number of virtual CPUs.
9927/// - `tooMuchMemory`: The host does not support fault tolerance virtual machines
9928/// with the specified amount of memory.
9929/// - `vMotionNotLicensed`: No VMotion license
9930///
9931/// ***Since:*** vSphere API Release 8.0.3.0
9932/// - `ftNotLicensed`: Host does not have proper FT license
9933///
9934/// ***Since:*** vSphere API Release 8.0.3.0
9935/// - `haAgentIssue`: Host does not have HA agent running properly
9936///
9937/// ***Since:*** vSphere API Release 8.0.3.0
9938/// - `unsupportedSPBM`: The VM has unsupported storage policy
9939///
9940/// ***Since:*** vSphere API Release 8.0.3.0
9941/// - `hasLinkedCloneDisk`: The virtual machine has virtual disk in linked-clone mode
9942///
9943/// ***Since:*** vSphere API Release 8.0.3.0
9944/// - `unsupportedPMemHAFailOver`: Virtual Machine with Pmem HA Failover is not supported
9945///
9946/// ***Since:*** vSphere API Release 7.0.2.0
9947/// - `unsupportedEncryptedDisk`: Virtual Machine with encrypted virtual disk is not supported.
9948///
9949/// ***Since:*** vSphere API Release 8.0.3.0
9950/// - `ftMetroClusterNotEditable`: The virtual machine does not allow to enable or disable FT Metro
9951/// Cluster while FT is turned on.
9952///
9953/// ***Since:*** vSphere API Release 8.0.3.0
9954/// - `noHostGroupConfigured`: Cannot turn on vSphere Fault Tolerance on a FT Metro Cluster enabled VM
9955/// with no Host Group configured.
9956///
9957/// ***Since:*** vSphere API Release 8.0.3.0
9958#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
9959pub enum VmFaultToleranceConfigIssueReasonForIssueEnum {
9960 #[serde(rename = "haNotEnabled")]
9961 #[strum(serialize = "haNotEnabled")]
9962 HaNotEnabled,
9963 #[serde(rename = "moreThanOneSecondary")]
9964 #[strum(serialize = "moreThanOneSecondary")]
9965 MoreThanOneSecondary,
9966 #[serde(rename = "recordReplayNotSupported")]
9967 #[strum(serialize = "recordReplayNotSupported")]
9968 RecordReplayNotSupported,
9969 #[serde(rename = "replayNotSupported")]
9970 #[strum(serialize = "replayNotSupported")]
9971 ReplayNotSupported,
9972 #[serde(rename = "templateVm")]
9973 #[strum(serialize = "templateVm")]
9974 TemplateVm,
9975 #[serde(rename = "multipleVCPU")]
9976 #[strum(serialize = "multipleVCPU")]
9977 MultipleVcpu,
9978 #[serde(rename = "hostInactive")]
9979 #[strum(serialize = "hostInactive")]
9980 HostInactive,
9981 #[serde(rename = "ftUnsupportedHardware")]
9982 #[strum(serialize = "ftUnsupportedHardware")]
9983 FtUnsupportedHardware,
9984 #[serde(rename = "ftUnsupportedProduct")]
9985 #[strum(serialize = "ftUnsupportedProduct")]
9986 FtUnsupportedProduct,
9987 #[serde(rename = "missingVMotionNic")]
9988 #[strum(serialize = "missingVMotionNic")]
9989 MissingVMotionNic,
9990 #[serde(rename = "missingFTLoggingNic")]
9991 #[strum(serialize = "missingFTLoggingNic")]
9992 MissingFtLoggingNic,
9993 #[serde(rename = "thinDisk")]
9994 #[strum(serialize = "thinDisk")]
9995 ThinDisk,
9996 #[serde(rename = "verifySSLCertificateFlagNotSet")]
9997 #[strum(serialize = "verifySSLCertificateFlagNotSet")]
9998 VerifySslCertificateFlagNotSet,
9999 #[serde(rename = "hasSnapshots")]
10000 #[strum(serialize = "hasSnapshots")]
10001 HasSnapshots,
10002 #[serde(rename = "noConfig")]
10003 #[strum(serialize = "noConfig")]
10004 NoConfig,
10005 #[serde(rename = "ftSecondaryVm")]
10006 #[strum(serialize = "ftSecondaryVm")]
10007 FtSecondaryVm,
10008 #[serde(rename = "hasLocalDisk")]
10009 #[strum(serialize = "hasLocalDisk")]
10010 HasLocalDisk,
10011 #[serde(rename = "esxAgentVm")]
10012 #[strum(serialize = "esxAgentVm")]
10013 EsxAgentVm,
10014 #[serde(rename = "video3dEnabled")]
10015 #[strum(serialize = "video3dEnabled")]
10016 Video3DEnabled,
10017 #[serde(rename = "hasUnsupportedDisk")]
10018 #[strum(serialize = "hasUnsupportedDisk")]
10019 HasUnsupportedDisk,
10020 #[serde(rename = "insufficientBandwidth")]
10021 #[strum(serialize = "insufficientBandwidth")]
10022 InsufficientBandwidth,
10023 #[serde(rename = "hasNestedHVConfiguration")]
10024 #[strum(serialize = "hasNestedHVConfiguration")]
10025 HasNestedHvConfiguration,
10026 #[serde(rename = "hasVFlashConfiguration")]
10027 #[strum(serialize = "hasVFlashConfiguration")]
10028 HasVFlashConfiguration,
10029 #[serde(rename = "unsupportedProduct")]
10030 #[strum(serialize = "unsupportedProduct")]
10031 UnsupportedProduct,
10032 #[serde(rename = "cpuHvUnsupported")]
10033 #[strum(serialize = "cpuHvUnsupported")]
10034 CpuHvUnsupported,
10035 #[serde(rename = "cpuHwmmuUnsupported")]
10036 #[strum(serialize = "cpuHwmmuUnsupported")]
10037 CpuHwmmuUnsupported,
10038 #[serde(rename = "cpuHvDisabled")]
10039 #[strum(serialize = "cpuHvDisabled")]
10040 CpuHvDisabled,
10041 #[serde(rename = "hasEFIFirmware")]
10042 #[strum(serialize = "hasEFIFirmware")]
10043 HasEfiFirmware,
10044 #[serde(rename = "tooManyVCPUs")]
10045 #[strum(serialize = "tooManyVCPUs")]
10046 TooManyVcpUs,
10047 #[serde(rename = "tooMuchMemory")]
10048 #[strum(serialize = "tooMuchMemory")]
10049 TooMuchMemory,
10050 #[serde(rename = "vMotionNotLicensed")]
10051 #[strum(serialize = "vMotionNotLicensed")]
10052 VMotionNotLicensed,
10053 #[serde(rename = "ftNotLicensed")]
10054 #[strum(serialize = "ftNotLicensed")]
10055 FtNotLicensed,
10056 #[serde(rename = "haAgentIssue")]
10057 #[strum(serialize = "haAgentIssue")]
10058 HaAgentIssue,
10059 #[serde(rename = "unsupportedSPBM")]
10060 #[strum(serialize = "unsupportedSPBM")]
10061 UnsupportedSpbm,
10062 #[serde(rename = "hasLinkedCloneDisk")]
10063 #[strum(serialize = "hasLinkedCloneDisk")]
10064 HasLinkedCloneDisk,
10065 #[serde(rename = "unsupportedPMemHAFailOver")]
10066 #[strum(serialize = "unsupportedPMemHAFailOver")]
10067 UnsupportedPMemHaFailOver,
10068 #[serde(rename = "unsupportedEncryptedDisk")]
10069 #[strum(serialize = "unsupportedEncryptedDisk")]
10070 UnsupportedEncryptedDisk,
10071 #[serde(rename = "ftMetroClusterNotEditable")]
10072 #[strum(serialize = "ftMetroClusterNotEditable")]
10073 FtMetroClusterNotEditable,
10074 #[serde(rename = "noHostGroupConfigured")]
10075 #[strum(serialize = "noHostGroupConfigured")]
10076 NoHostGroupConfigured,
10077 /// This variant handles values not known at compile time.
10078 #[serde(untagged)]
10079 #[strum(serialize = "__OTHER__")]
10080 Other_(String),
10081}
10082/// Possible values:
10083/// - `virtualFloppy`: virtual floppy
10084/// - `virtualCdrom`: virtual Cdrom
10085/// - `virtualSerialPort`: virtual serial port
10086/// - `virtualParallelPort`: virtual parallel port
10087/// - `virtualDisk`: virtual disk
10088#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10089pub enum VmFaultToleranceInvalidFileBackingDeviceTypeEnum {
10090 #[serde(rename = "virtualFloppy")]
10091 #[strum(serialize = "virtualFloppy")]
10092 VirtualFloppy,
10093 #[serde(rename = "virtualCdrom")]
10094 #[strum(serialize = "virtualCdrom")]
10095 VirtualCdrom,
10096 #[serde(rename = "virtualSerialPort")]
10097 #[strum(serialize = "virtualSerialPort")]
10098 VirtualSerialPort,
10099 #[serde(rename = "virtualParallelPort")]
10100 #[strum(serialize = "virtualParallelPort")]
10101 VirtualParallelPort,
10102 #[serde(rename = "virtualDisk")]
10103 #[strum(serialize = "virtualDisk")]
10104 VirtualDisk,
10105 /// This variant handles values not known at compile time.
10106 #[serde(untagged)]
10107 #[strum(serialize = "__OTHER__")]
10108 Other_(String),
10109}
10110/// Possible values:
10111/// - `svmotion`: storage vmotion resolution
10112/// - `relocate`: relocate resolution
10113#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10114pub enum WillLoseHaProtectionResolutionEnum {
10115 #[serde(rename = "svmotion")]
10116 #[strum(serialize = "svmotion")]
10117 Svmotion,
10118 #[serde(rename = "relocate")]
10119 #[strum(serialize = "relocate")]
10120 Relocate,
10121 /// This variant handles values not known at compile time.
10122 #[serde(untagged)]
10123 #[strum(serialize = "__OTHER__")]
10124 Other_(String),
10125}
10126/// Possible values:
10127/// - `SHA1`
10128#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10129pub enum HostActiveDirectoryAuthenticationCertificateDigestEnum {
10130 #[serde(rename = "SHA1")]
10131 #[strum(serialize = "SHA1")]
10132 Sha1,
10133 /// This variant handles values not known at compile time.
10134 #[serde(untagged)]
10135 #[strum(serialize = "__OTHER__")]
10136 Other_(String),
10137}
10138/// Possible values:
10139/// - `unknown`: The Active Directory integration provider does not support
10140/// domain trust checks.
10141/// - `ok`: No problems with the domain membership.
10142/// - `noServers`: The host thinks it's part of a domain,
10143/// but no domain controllers could be reached to confirm.
10144/// - `clientTrustBroken`: The client side of the trust relationship is broken.
10145/// - `serverTrustBroken`: The server side of the trust relationship is broken
10146/// (or bad machine password).
10147/// - `inconsistentTrust`: Unexpected domain controller responded.
10148/// - `otherProblem`: There's some problem with the domain membership.
10149#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10150pub enum HostActiveDirectoryInfoDomainMembershipStatusEnum {
10151 #[serde(rename = "unknown")]
10152 #[strum(serialize = "unknown")]
10153 Unknown,
10154 #[serde(rename = "ok")]
10155 #[strum(serialize = "ok")]
10156 Ok,
10157 #[serde(rename = "noServers")]
10158 #[strum(serialize = "noServers")]
10159 NoServers,
10160 #[serde(rename = "clientTrustBroken")]
10161 #[strum(serialize = "clientTrustBroken")]
10162 ClientTrustBroken,
10163 #[serde(rename = "serverTrustBroken")]
10164 #[strum(serialize = "serverTrustBroken")]
10165 ServerTrustBroken,
10166 #[serde(rename = "inconsistentTrust")]
10167 #[strum(serialize = "inconsistentTrust")]
10168 InconsistentTrust,
10169 #[serde(rename = "otherProblem")]
10170 #[strum(serialize = "otherProblem")]
10171 OtherProblem,
10172 /// This variant handles values not known at compile time.
10173 #[serde(untagged)]
10174 #[strum(serialize = "__OTHER__")]
10175 Other_(String),
10176}
10177/// Possible values:
10178/// - `none`: No action is taken for this virtual machine.
10179///
10180/// This virtual machine is
10181/// not a part of the auto-start sequence. This can be used for both auto-start
10182/// and auto-start settings.
10183/// - `systemDefault`: The default system action is taken for this virtual machine when it is next in
10184/// the auto-start order.
10185///
10186/// This can be used for both auto-start and auto-start
10187/// settings.
10188/// - `powerOn`: This virtual machine is powered on when it is next in the auto-start order.
10189/// - `powerOff`: This virtual machine is powered off when it is next in the auto-stop order.
10190///
10191/// This is the default stopAction.
10192/// - `guestShutdown`: The guest operating system for a virtual machine is shut down when that
10193/// virtual machine in next in the auto-stop order.
10194/// - `suspend`: This virtual machine is suspended when it is next in the auto-stop order.
10195#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10196pub enum AutoStartActionEnum {
10197 #[serde(rename = "none")]
10198 #[strum(serialize = "none")]
10199 None,
10200 #[serde(rename = "systemDefault")]
10201 #[strum(serialize = "systemDefault")]
10202 SystemDefault,
10203 #[serde(rename = "powerOn")]
10204 #[strum(serialize = "powerOn")]
10205 PowerOn,
10206 #[serde(rename = "powerOff")]
10207 #[strum(serialize = "powerOff")]
10208 PowerOff,
10209 #[serde(rename = "guestShutdown")]
10210 #[strum(serialize = "guestShutdown")]
10211 GuestShutdown,
10212 #[serde(rename = "suspend")]
10213 #[strum(serialize = "suspend")]
10214 Suspend,
10215 /// This variant handles values not known at compile time.
10216 #[serde(untagged)]
10217 #[strum(serialize = "__OTHER__")]
10218 Other_(String),
10219}
10220/// Determines if the virtual machine should start after receiving a heartbeat,
10221/// ignore heartbeats and start after the startDelay has elapsed, or follow the
10222/// system default before powering on.
10223///
10224/// When a virtual machine is next in the start
10225/// order, the system either waits a specified period of time for a virtual
10226/// machine to power on or it waits until it receives a successful heartbeat from a
10227/// powered on virtual machine. By default, this is set to no.
10228///
10229/// Possible values:
10230/// - `yes`: The system waits until receiving a heartbeat before powering on the next
10231/// machine in the order.
10232/// - `no`: The system does not wait to receive a heartbeat before powering on the next
10233/// machine in the order.
10234///
10235/// This is the default setting.
10236/// - `systemDefault`: The system uses the default value to determine whether or not to wait to
10237/// receive a heartbeat before powering on the next machine in the order.
10238#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10239pub enum AutoStartWaitHeartbeatSettingEnum {
10240 #[serde(rename = "yes")]
10241 #[strum(serialize = "yes")]
10242 Yes,
10243 #[serde(rename = "no")]
10244 #[strum(serialize = "no")]
10245 No,
10246 #[serde(rename = "systemDefault")]
10247 #[strum(serialize = "systemDefault")]
10248 SystemDefault,
10249 /// This variant handles values not known at compile time.
10250 #[serde(untagged)]
10251 #[strum(serialize = "__OTHER__")]
10252 Other_(String),
10253}
10254/// Enumeration of the supported firmware types.
10255///
10256/// Possible values:
10257/// - `BIOS`
10258/// - `UEFI`
10259///
10260/// ***Since:*** vSphere API Release 8.0.2.0
10261#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10262pub enum HostBiosInfoFirmwareTypeEnum {
10263 #[serde(rename = "BIOS")]
10264 #[strum(serialize = "BIOS")]
10265 Bios,
10266 #[serde(rename = "UEFI")]
10267 #[strum(serialize = "UEFI")]
10268 Uefi,
10269 /// This variant handles values not known at compile time.
10270 #[serde(untagged)]
10271 #[strum(serialize = "__OTHER__")]
10272 Other_(String),
10273}
10274/// Deprecated as of vSphere API 7.0, use
10275/// *VmFaultToleranceConfigIssueReasonForIssue_enum*.
10276///
10277/// Set of possible values for
10278/// *HostCapability.ftCompatibilityIssues*
10279///
10280/// Possible values:
10281/// - `vMotionNotLicensed`: No VMotion license
10282/// - `missingVMotionNic`: VMotion nic is not configured on the host
10283/// - `missingFTLoggingNic`: FT logging nic is not configured on the host
10284/// - `ftNotLicensed`: Host does not have proper FT license
10285/// - `haAgentIssue`: Host does not have HA agent running properly
10286/// - `unsupportedProduct`: VMware product installed on the host does not support
10287/// fault tolerance
10288/// - `cpuHvUnsupported`: Host CPU does not support hardware virtualization
10289/// - `cpuHwmmuUnsupported`: Host CPU does not support hardware MMU virtualization
10290/// - `cpuHvDisabled`: Host CPU is compatible for replay-based FT, but hardware
10291/// virtualization has been disabled in the BIOS.
10292#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10293pub enum HostCapabilityFtUnsupportedReasonEnum {
10294 #[serde(rename = "vMotionNotLicensed")]
10295 #[strum(serialize = "vMotionNotLicensed")]
10296 VMotionNotLicensed,
10297 #[serde(rename = "missingVMotionNic")]
10298 #[strum(serialize = "missingVMotionNic")]
10299 MissingVMotionNic,
10300 #[serde(rename = "missingFTLoggingNic")]
10301 #[strum(serialize = "missingFTLoggingNic")]
10302 MissingFtLoggingNic,
10303 #[serde(rename = "ftNotLicensed")]
10304 #[strum(serialize = "ftNotLicensed")]
10305 FtNotLicensed,
10306 #[serde(rename = "haAgentIssue")]
10307 #[strum(serialize = "haAgentIssue")]
10308 HaAgentIssue,
10309 #[serde(rename = "unsupportedProduct")]
10310 #[strum(serialize = "unsupportedProduct")]
10311 UnsupportedProduct,
10312 #[serde(rename = "cpuHvUnsupported")]
10313 #[strum(serialize = "cpuHvUnsupported")]
10314 CpuHvUnsupported,
10315 #[serde(rename = "cpuHwmmuUnsupported")]
10316 #[strum(serialize = "cpuHwmmuUnsupported")]
10317 CpuHwmmuUnsupported,
10318 #[serde(rename = "cpuHvDisabled")]
10319 #[strum(serialize = "cpuHvDisabled")]
10320 CpuHvDisabled,
10321 /// This variant handles values not known at compile time.
10322 #[serde(untagged)]
10323 #[strum(serialize = "__OTHER__")]
10324 Other_(String),
10325}
10326/// Deprecated as of vSphere API 6.0.
10327///
10328/// Set of possible values for
10329/// *HostCapability.replayUnsupportedReason* and
10330/// *HostCapability.replayCompatibilityIssues*.
10331///
10332/// Possible values:
10333/// - `incompatibleProduct`
10334/// - `incompatibleCpu`
10335/// - `hvDisabled`
10336/// - `cpuidLimitSet`
10337/// - `oldBIOS`
10338/// - `unknown`
10339#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10340pub enum HostReplayUnsupportedReasonEnum {
10341 #[serde(rename = "incompatibleProduct")]
10342 #[strum(serialize = "incompatibleProduct")]
10343 IncompatibleProduct,
10344 #[serde(rename = "incompatibleCpu")]
10345 #[strum(serialize = "incompatibleCpu")]
10346 IncompatibleCpu,
10347 #[serde(rename = "hvDisabled")]
10348 #[strum(serialize = "hvDisabled")]
10349 HvDisabled,
10350 #[serde(rename = "cpuidLimitSet")]
10351 #[strum(serialize = "cpuidLimitSet")]
10352 CpuidLimitSet,
10353 #[serde(rename = "oldBIOS")]
10354 #[strum(serialize = "oldBIOS")]
10355 OldBios,
10356 #[serde(rename = "unknown")]
10357 #[strum(serialize = "unknown")]
10358 Unknown,
10359 /// This variant handles values not known at compile time.
10360 #[serde(untagged)]
10361 #[strum(serialize = "__OTHER__")]
10362 Other_(String),
10363}
10364/// Set of VMFS unmap API version.
10365///
10366/// Possible values:
10367/// - `priority`: only the unmap priority is supported
10368/// - `fixed`: the unmap bandwidth can be set as a fixed value
10369/// - `dynamic`: the unmap bandwidth can be set as a range, where the actual
10370/// bandwidth will be dynamically throttled by the backened
10371#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10372pub enum HostCapabilityUnmapMethodSupportedEnum {
10373 #[serde(rename = "priority")]
10374 #[strum(serialize = "priority")]
10375 Priority,
10376 #[serde(rename = "fixed")]
10377 #[strum(serialize = "fixed")]
10378 Fixed,
10379 #[serde(rename = "dynamic")]
10380 #[strum(serialize = "dynamic")]
10381 Dynamic,
10382 /// This variant handles values not known at compile time.
10383 #[serde(untagged)]
10384 #[strum(serialize = "__OTHER__")]
10385 Other_(String),
10386}
10387/// Set of possible values for *HostCapability.vmDirectPathGen2UnsupportedReason*.
10388///
10389/// Possible values:
10390/// - `hostNptIncompatibleProduct`: The host software does not support VMDirectPath Gen 2.
10391/// - `hostNptIncompatibleHardware`: The host hardware does not support VMDirectPath Gen 2.
10392///
10393/// Note that
10394/// this is a general capability for the host and is independent of
10395/// support by a given physical NIC.
10396/// - `hostNptDisabled`: The host is configured to disable VMDirectPath Gen 2.
10397#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10398pub enum HostCapabilityVmDirectPathGen2UnsupportedReasonEnum {
10399 #[serde(rename = "hostNptIncompatibleProduct")]
10400 #[strum(serialize = "hostNptIncompatibleProduct")]
10401 HostNptIncompatibleProduct,
10402 #[serde(rename = "hostNptIncompatibleHardware")]
10403 #[strum(serialize = "hostNptIncompatibleHardware")]
10404 HostNptIncompatibleHardware,
10405 #[serde(rename = "hostNptDisabled")]
10406 #[strum(serialize = "hostNptDisabled")]
10407 HostNptDisabled,
10408 /// This variant handles values not known at compile time.
10409 #[serde(untagged)]
10410 #[strum(serialize = "__OTHER__")]
10411 Other_(String),
10412}
10413/// The status of a given certificate as computed per the soft and the hard
10414/// thresholds in vCenter Server.
10415///
10416///
10417///
10418/// There are two different thresholds for the host certificate
10419/// expirations; a soft threshold (which constitutes of two phases) and a
10420/// hard threshold.
10421///
10422///
10423/// Soft Threshold:
10424///
10425/// Phase One: vCenter Server will publish an event at
10426/// this time to let the user know about the status, but, no alarms or
10427/// warnings are raised.
10428///
10429/// Phase Two: During this phase, vCenter Server will publish an event and
10430/// indicate the certificate status as expiring in the UI.
10431///
10432///
10433/// Hard Threshold:
10434///
10435/// vCenter Server will publish an alarm and indicate via the UI that the
10436/// certificate expiration is imminent.
10437///
10438/// Possible values:
10439/// - `unknown`: The certificate status is unknown.
10440/// - `expired`: The certificate has expired.
10441/// - `expiring`: The certificate is expiring shortly.
10442///
10443/// (soft threshold - 1)
10444/// - `expiringShortly`: The certificate is expiring shortly.
10445///
10446/// (soft threshold - 2)
10447/// - `expirationImminent`: The certificate expiration is imminent.
10448///
10449/// (hard threshold)
10450/// - `good`: The certificate is good.
10451#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10452pub enum HostCertificateManagerCertificateInfoCertificateStatusEnum {
10453 #[serde(rename = "unknown")]
10454 #[strum(serialize = "unknown")]
10455 Unknown,
10456 #[serde(rename = "expired")]
10457 #[strum(serialize = "expired")]
10458 Expired,
10459 #[serde(rename = "expiring")]
10460 #[strum(serialize = "expiring")]
10461 Expiring,
10462 #[serde(rename = "expiringShortly")]
10463 #[strum(serialize = "expiringShortly")]
10464 ExpiringShortly,
10465 #[serde(rename = "expirationImminent")]
10466 #[strum(serialize = "expirationImminent")]
10467 ExpirationImminent,
10468 #[serde(rename = "good")]
10469 #[strum(serialize = "good")]
10470 Good,
10471 /// This variant handles values not known at compile time.
10472 #[serde(untagged)]
10473 #[strum(serialize = "__OTHER__")]
10474 Other_(String),
10475}
10476/// Certificate type supported by Host
10477///
10478/// Possible values:
10479/// - `Machine`: Machine certificate of the Host
10480/// - `VASAClient`: VASA Client certificate used for communication with VASA Provider
10481///
10482/// ***Since:*** vSphere API Release 8.0.1.0
10483#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10484pub enum HostCertificateManagerCertificateKindEnum {
10485 Machine,
10486 #[serde(rename = "VASAClient")]
10487 #[strum(serialize = "VASAClient")]
10488 VasaClient,
10489 /// This variant handles values not known at compile time.
10490 #[serde(untagged)]
10491 #[strum(serialize = "__OTHER__")]
10492 Other_(String),
10493}
10494/// This is a global mode on a configuration specification indicating
10495/// whether the structure represents the desired state or the set of
10496/// operations to apply on the managed object.
10497///
10498/// Possible values:
10499/// - `modify`: Indicates that the structure represents the
10500/// set of operations to apply on the managed object.
10501/// - `replace`: Indicates that the structure represents the
10502/// desired state of the managed object.
10503#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10504pub enum HostConfigChangeModeEnum {
10505 #[serde(rename = "modify")]
10506 #[strum(serialize = "modify")]
10507 Modify,
10508 #[serde(rename = "replace")]
10509 #[strum(serialize = "replace")]
10510 Replace,
10511 /// This variant handles values not known at compile time.
10512 #[serde(untagged)]
10513 #[strum(serialize = "__OTHER__")]
10514 Other_(String),
10515}
10516/// This list indicates the operation that should be performed for an
10517/// entity.
10518///
10519/// Possible values:
10520/// - `add`: Indicates the addition of an entity to the configuration.
10521/// - `remove`: Indicates the removal of an entity from the configuration.
10522/// - `edit`: Indicates changes on the entity.
10523///
10524/// The entity must exist or a
10525/// *NotFound* error will be thrown.
10526/// - `ignore`: Indicates that an entity will be ignored: it won't be added when it
10527/// doesn't exist, or removed/changed when it exists.
10528#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10529pub enum HostConfigChangeOperationEnum {
10530 #[serde(rename = "add")]
10531 #[strum(serialize = "add")]
10532 Add,
10533 #[serde(rename = "remove")]
10534 #[strum(serialize = "remove")]
10535 Remove,
10536 #[serde(rename = "edit")]
10537 #[strum(serialize = "edit")]
10538 Edit,
10539 #[serde(rename = "ignore")]
10540 #[strum(serialize = "ignore")]
10541 Ignore,
10542 /// This variant handles values not known at compile time.
10543 #[serde(untagged)]
10544 #[strum(serialize = "__OTHER__")]
10545 Other_(String),
10546}
10547/// This list indicates the owner of an entity.
10548///
10549/// Possible values:
10550/// - `NSX`: The owner is NSX (Network Virtualization and Security).
10551/// - `VSAN`: The owner is vSAN (VMware Virtual Storage Area Network).
10552///
10553/// ***Since:*** vSphere API Release 9.0.0.0
10554#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10555pub enum HostConfigChangeOwnerEnum {
10556 #[serde(rename = "NSX")]
10557 #[strum(serialize = "NSX")]
10558 Nsx,
10559 #[serde(rename = "VSAN")]
10560 #[strum(serialize = "VSAN")]
10561 Vsan,
10562 /// This variant handles values not known at compile time.
10563 #[serde(untagged)]
10564 #[strum(serialize = "__OTHER__")]
10565 Other_(String),
10566}
10567/// Possible values:
10568/// - `unknown`
10569/// - `intel`
10570/// - `amd`
10571/// - `hygon`
10572#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10573pub enum HostCpuPackageVendorEnum {
10574 #[serde(rename = "unknown")]
10575 #[strum(serialize = "unknown")]
10576 Unknown,
10577 #[serde(rename = "intel")]
10578 #[strum(serialize = "intel")]
10579 Intel,
10580 #[serde(rename = "amd")]
10581 #[strum(serialize = "amd")]
10582 Amd,
10583 #[serde(rename = "hygon")]
10584 #[strum(serialize = "hygon")]
10585 Hygon,
10586 /// This variant handles values not known at compile time.
10587 #[serde(untagged)]
10588 #[strum(serialize = "__OTHER__")]
10589 Other_(String),
10590}
10591/// Possible values for Current CPU power management policy
10592///
10593/// Possible values:
10594/// - `off`
10595/// - `staticPolicy`
10596/// - `dynamicPolicy`
10597#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10598pub enum HostCpuPowerManagementInfoPolicyTypeEnum {
10599 #[serde(rename = "off")]
10600 #[strum(serialize = "off")]
10601 Off,
10602 #[serde(rename = "staticPolicy")]
10603 #[strum(serialize = "staticPolicy")]
10604 StaticPolicy,
10605 #[serde(rename = "dynamicPolicy")]
10606 #[strum(serialize = "dynamicPolicy")]
10607 DynamicPolicy,
10608 /// This variant handles values not known at compile time.
10609 #[serde(untagged)]
10610 #[strum(serialize = "__OTHER__")]
10611 Other_(String),
10612}
10613/// Possible values:
10614/// - `systemDefault`: The CPU scheduler on this host is running without any modifications
10615/// or mitigations.
10616/// - `scav1`: The CPU scheduler on this host is using only one hyperthread per
10617/// core to mitigate a security vulnerability.
10618/// - `scav2`: The CPU scheduler on this host is using hyperthreads, with
10619/// Side-Channel aware scheduling to mitigate a security vulnerability.
10620///
10621/// ***Since:*** vSphere API Release 8.0.3.0
10622#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10623pub enum HostCpuSchedulerInfoCpuSchedulerPolicyInfoEnum {
10624 #[serde(rename = "systemDefault")]
10625 #[strum(serialize = "systemDefault")]
10626 SystemDefault,
10627 #[serde(rename = "scav1")]
10628 #[strum(serialize = "scav1")]
10629 Scav1,
10630 #[serde(rename = "scav2")]
10631 #[strum(serialize = "scav2")]
10632 Scav2,
10633 /// This variant handles values not known at compile time.
10634 #[serde(untagged)]
10635 #[strum(serialize = "__OTHER__")]
10636 Other_(String),
10637}
10638/// Types of time synchronization protocols.
10639///
10640/// Possible values:
10641/// - `ntp`: Network Time Protocol (NTP).
10642/// - `ptp`: Precision Time Protocol (PTP).
10643#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10644pub enum HostDateTimeInfoProtocolEnum {
10645 #[serde(rename = "ntp")]
10646 #[strum(serialize = "ntp")]
10647 Ntp,
10648 #[serde(rename = "ptp")]
10649 #[strum(serialize = "ptp")]
10650 Ptp,
10651 /// This variant handles values not known at compile time.
10652 #[serde(untagged)]
10653 #[strum(serialize = "__OTHER__")]
10654 Other_(String),
10655}
10656/// The type of diagnostic partition.
10657///
10658/// Private diagnostic partition has one
10659/// slot, so can only be used by one host. Shared diagnostic parititon
10660/// needs multiple slots so to be usable by multiple hosts.
10661///
10662/// Possible values:
10663/// - `singleHost`
10664/// - `multiHost`
10665#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10666pub enum DiagnosticPartitionTypeEnum {
10667 #[serde(rename = "singleHost")]
10668 #[strum(serialize = "singleHost")]
10669 SingleHost,
10670 #[serde(rename = "multiHost")]
10671 #[strum(serialize = "multiHost")]
10672 MultiHost,
10673 /// This variant handles values not known at compile time.
10674 #[serde(untagged)]
10675 #[strum(serialize = "__OTHER__")]
10676 Other_(String),
10677}
10678/// Type of partition indicating the type of storage on which the partition
10679/// resides.
10680///
10681/// If the diagnostic partition is local only, it will only need
10682/// one slot. If the diagnostic partition is on shared storage, it could
10683/// be used by multiple hosts. As a result, it will need multiple slots.
10684///
10685/// Possible values:
10686/// - `directAttached`
10687/// - `networkAttached`
10688#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10689pub enum DiagnosticPartitionStorageTypeEnum {
10690 #[serde(rename = "directAttached")]
10691 #[strum(serialize = "directAttached")]
10692 DirectAttached,
10693 #[serde(rename = "networkAttached")]
10694 #[strum(serialize = "networkAttached")]
10695 NetworkAttached,
10696 /// This variant handles values not known at compile time.
10697 #[serde(untagged)]
10698 #[strum(serialize = "__OTHER__")]
10699 Other_(String),
10700}
10701/// The set of digest methods that can be used by TPM to calculate the PCR
10702/// values.
10703///
10704/// Possible values:
10705/// - `SHA1`
10706/// - `MD5`:
10707///
10708/// Deprecated as of vSphere API 6.7.
10709///
10710/// MD5.
10711/// - `SHA256`
10712/// - `SHA384`
10713/// - `SHA512`
10714/// - `SM3_256`
10715#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10716pub enum HostDigestInfoDigestMethodTypeEnum {
10717 #[serde(rename = "SHA1")]
10718 #[strum(serialize = "SHA1")]
10719 Sha1,
10720 #[serde(rename = "MD5")]
10721 #[strum(serialize = "MD5")]
10722 Md5,
10723 #[serde(rename = "SHA256")]
10724 #[strum(serialize = "SHA256")]
10725 Sha256,
10726 #[serde(rename = "SHA384")]
10727 #[strum(serialize = "SHA384")]
10728 Sha384,
10729 #[serde(rename = "SHA512")]
10730 #[strum(serialize = "SHA512")]
10731 Sha512,
10732 #[serde(rename = "SM3_256")]
10733 #[strum(serialize = "SM3_256")]
10734 Sm3256,
10735 /// This variant handles values not known at compile time.
10736 #[serde(untagged)]
10737 #[strum(serialize = "__OTHER__")]
10738 Other_(String),
10739}
10740/// This enum specifies the supported digest verification settings.
10741///
10742/// For NVMe over TCP connections, both header and data digests may be
10743/// requested during the process of establishing the connection.
10744/// For details, see:
10745/// - NVM Express Technical Proposal 8000 - NVMe/TCP Transport,
10746/// Section 7.4.6, "PDU Header and Data Digests"
10747///
10748/// Possible values:
10749/// - `digestDisabled`: Both header and data digest verification are disabled.
10750/// - `headerOnly`: Only header digest verification is enabled.
10751/// - `dataOnly`: Only data digest verification is enabled.
10752/// - `headerAndData`: Both header and data digest verification are enabled.
10753///
10754/// ***Since:*** vSphere API Release 7.0.3.0
10755#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10756pub enum HostDigestVerificationSettingEnum {
10757 #[serde(rename = "digestDisabled")]
10758 #[strum(serialize = "digestDisabled")]
10759 DigestDisabled,
10760 #[serde(rename = "headerOnly")]
10761 #[strum(serialize = "headerOnly")]
10762 HeaderOnly,
10763 #[serde(rename = "dataOnly")]
10764 #[strum(serialize = "dataOnly")]
10765 DataOnly,
10766 #[serde(rename = "headerAndData")]
10767 #[strum(serialize = "headerAndData")]
10768 HeaderAndData,
10769 /// This variant handles values not known at compile time.
10770 #[serde(untagged)]
10771 #[strum(serialize = "__OTHER__")]
10772 Other_(String),
10773}
10774/// List of partition format types.
10775///
10776/// This denotes the partition table layout.
10777///
10778/// Possible values:
10779/// - `gpt`
10780/// - `mbr`
10781/// - `unknown`
10782#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10783pub enum HostDiskPartitionInfoPartitionFormatEnum {
10784 #[serde(rename = "gpt")]
10785 #[strum(serialize = "gpt")]
10786 Gpt,
10787 #[serde(rename = "mbr")]
10788 #[strum(serialize = "mbr")]
10789 Mbr,
10790 #[serde(rename = "unknown")]
10791 #[strum(serialize = "unknown")]
10792 Unknown,
10793 /// This variant handles values not known at compile time.
10794 #[serde(untagged)]
10795 #[strum(serialize = "__OTHER__")]
10796 Other_(String),
10797}
10798/// List of symbol partition types
10799///
10800/// Possible values:
10801/// - `none`
10802/// - `vmfs`
10803/// - `linuxNative`
10804/// - `linuxSwap`
10805/// - `extended`
10806/// - `ntfs`
10807/// - `vmkDiagnostic`
10808/// - `vffs`
10809#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10810pub enum HostDiskPartitionInfoTypeEnum {
10811 #[serde(rename = "none")]
10812 #[strum(serialize = "none")]
10813 None,
10814 #[serde(rename = "vmfs")]
10815 #[strum(serialize = "vmfs")]
10816 Vmfs,
10817 #[serde(rename = "linuxNative")]
10818 #[strum(serialize = "linuxNative")]
10819 LinuxNative,
10820 #[serde(rename = "linuxSwap")]
10821 #[strum(serialize = "linuxSwap")]
10822 LinuxSwap,
10823 #[serde(rename = "extended")]
10824 #[strum(serialize = "extended")]
10825 Extended,
10826 #[serde(rename = "ntfs")]
10827 #[strum(serialize = "ntfs")]
10828 Ntfs,
10829 #[serde(rename = "vmkDiagnostic")]
10830 #[strum(serialize = "vmkDiagnostic")]
10831 VmkDiagnostic,
10832 #[serde(rename = "vffs")]
10833 #[strum(serialize = "vffs")]
10834 Vffs,
10835 /// This variant handles values not known at compile time.
10836 #[serde(untagged)]
10837 #[strum(serialize = "__OTHER__")]
10838 Other_(String),
10839}
10840/// Set of possible values for
10841/// *HostFeatureVersionInfo.key*, which
10842/// is a unique key that identifies a feature.
10843///
10844/// Possible values:
10845/// - `faultTolerance`: VMware Fault Tolerance feature.
10846///
10847/// For pre-4.1 hosts, the
10848/// version value reported will be empty in which case
10849/// *AboutInfo.build* should be used. For all
10850/// other hosts, the version number reported will be a component-specific
10851/// version identifier of the form X.Y.Z, where:
10852/// X refers to host agent Fault Tolerance version number,
10853/// Y refers to VMX Fault Tolerance version number,
10854/// Z refers to VMkernal Fault Tolerance version
10855#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10856pub enum HostFeatureVersionKeyEnum {
10857 #[serde(rename = "faultTolerance")]
10858 #[strum(serialize = "faultTolerance")]
10859 FaultTolerance,
10860 /// This variant handles values not known at compile time.
10861 #[serde(untagged)]
10862 #[strum(serialize = "__OTHER__")]
10863 Other_(String),
10864}
10865/// The operating mode of the adapter.
10866///
10867/// Possible values:
10868/// - `fabric`
10869/// - `loop`
10870/// - `pointToPoint`
10871/// - `unknown`
10872#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10873pub enum FibreChannelPortTypeEnum {
10874 #[serde(rename = "fabric")]
10875 #[strum(serialize = "fabric")]
10876 Fabric,
10877 #[serde(rename = "loop")]
10878 #[strum(serialize = "loop")]
10879 Loop,
10880 #[serde(rename = "pointToPoint")]
10881 #[strum(serialize = "pointToPoint")]
10882 PointToPoint,
10883 #[serde(rename = "unknown")]
10884 #[strum(serialize = "unknown")]
10885 Unknown,
10886 /// This variant handles values not known at compile time.
10887 #[serde(untagged)]
10888 #[strum(serialize = "__OTHER__")]
10889 Other_(String),
10890}
10891/// Status of volume's support for vStorage hardware acceleration.
10892///
10893/// The ESX Server determines the status based on the capabilities
10894/// of the devices that support the file system volume.
10895/// When a host boots, the support status is unknown.
10896/// As the ESX host attempts hardware-accelerated operations,
10897/// it determines whether the storage device supports hardware
10898/// acceleration and sets the *HostFileSystemMountInfo.vStorageSupport*
10899/// property accordingly.
10900///
10901/// Possible values:
10902/// - `vStorageSupported`: Storage device supports hardware acceleration.
10903///
10904/// The ESX host will use the feature to offload certain
10905/// storage-related operations to the device.
10906/// - `vStorageUnsupported`: Storage device does not support hardware acceleration.
10907///
10908/// The ESX host will handle all storage-related operations.
10909/// - `vStorageUnknown`: Initial support status value.
10910#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10911pub enum FileSystemMountInfoVStorageSupportStatusEnum {
10912 #[serde(rename = "vStorageSupported")]
10913 #[strum(serialize = "vStorageSupported")]
10914 VStorageSupported,
10915 #[serde(rename = "vStorageUnsupported")]
10916 #[strum(serialize = "vStorageUnsupported")]
10917 VStorageUnsupported,
10918 #[serde(rename = "vStorageUnknown")]
10919 #[strum(serialize = "vStorageUnknown")]
10920 VStorageUnknown,
10921 /// This variant handles values not known at compile time.
10922 #[serde(untagged)]
10923 #[strum(serialize = "__OTHER__")]
10924 Other_(String),
10925}
10926/// Type of file system volume.
10927///
10928/// Possible values:
10929/// - `VMFS`: VMware File System (ESX Server only).
10930///
10931/// If this is set,
10932/// the type of the file system volume is VMFS.
10933/// - `NFS`: Network file system v3 linux & esx servers only.
10934///
10935/// If this is
10936/// set, the type of the file system volume is NFS v3.
10937/// - `NFS41`: Network file system v4.1 linux & esx servers only.
10938///
10939/// If this is
10940/// set, the type of the file system volume is NFS v4.1 or later.
10941/// - `CIFS`: Common Internet File System.
10942///
10943/// If this is set, the type of the
10944/// file system volume is Common Internet File System.
10945/// - `vsan`: VSAN File System (ESX Server only).
10946/// - `VFFS`: vFlash File System (ESX Server only).
10947///
10948/// If this is set, the type of the file system volume is VFFS.
10949/// - `VVOL`: vvol File System (ESX Server only).
10950/// - `PMEM`:
10951///
10952/// Deprecated as of vSphere 9.0 APIs with no replacement.
10953///
10954/// Persistent Memory File System (ESX Server only).
10955/// - `vsanD`: VSAN direct file system.
10956///
10957/// ***Since:*** vSphere API Release 7.0.1.0
10958/// - `OTHER`: Used if the file system is not one of the specified file systems.
10959///
10960/// Used mostly for reporting purposes. The other types are described
10961/// by the otherType property.
10962#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
10963pub enum HostFileSystemVolumeFileSystemTypeEnum {
10964 #[serde(rename = "VMFS")]
10965 #[strum(serialize = "VMFS")]
10966 Vmfs,
10967 #[serde(rename = "NFS")]
10968 #[strum(serialize = "NFS")]
10969 Nfs,
10970 #[serde(rename = "NFS41")]
10971 #[strum(serialize = "NFS41")]
10972 Nfs41,
10973 #[serde(rename = "CIFS")]
10974 #[strum(serialize = "CIFS")]
10975 Cifs,
10976 #[serde(rename = "vsan")]
10977 #[strum(serialize = "vsan")]
10978 Vsan,
10979 #[serde(rename = "VFFS")]
10980 #[strum(serialize = "VFFS")]
10981 Vffs,
10982 #[serde(rename = "VVOL")]
10983 #[strum(serialize = "VVOL")]
10984 Vvol,
10985 #[serde(rename = "PMEM")]
10986 #[strum(serialize = "PMEM")]
10987 Pmem,
10988 #[serde(rename = "vsanD")]
10989 #[strum(serialize = "vsanD")]
10990 VsanD,
10991 #[serde(rename = "OTHER")]
10992 #[strum(serialize = "OTHER")]
10993 Other,
10994 /// This variant handles values not known at compile time.
10995 #[serde(untagged)]
10996 #[strum(serialize = "__OTHER__")]
10997 Other_(String),
10998}
10999/// List of available firewall ruleset ids
11000///
11001/// Possible values:
11002/// - `faultTolerance`
11003/// - `fdm`
11004/// - `updateManager`
11005/// - `vpxHeartbeats`
11006///
11007/// ***Since:*** vSphere API Release 8.0.2.0
11008#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11009pub enum HostFirewallSystemRuleSetIdEnum {
11010 #[serde(rename = "faultTolerance")]
11011 #[strum(serialize = "faultTolerance")]
11012 FaultTolerance,
11013 #[serde(rename = "fdm")]
11014 #[strum(serialize = "fdm")]
11015 Fdm,
11016 #[serde(rename = "updateManager")]
11017 #[strum(serialize = "updateManager")]
11018 UpdateManager,
11019 #[serde(rename = "vpxHeartbeats")]
11020 #[strum(serialize = "vpxHeartbeats")]
11021 VpxHeartbeats,
11022 /// This variant handles values not known at compile time.
11023 #[serde(untagged)]
11024 #[strum(serialize = "__OTHER__")]
11025 Other_(String),
11026}
11027/// List of available service names
11028///
11029/// Possible values:
11030/// - `vpxa`
11031///
11032/// ***Since:*** vSphere API Release 8.0.2.0
11033#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11034pub enum HostFirewallSystemServiceNameEnum {
11035 #[serde(rename = "vpxa")]
11036 #[strum(serialize = "vpxa")]
11037 Vpxa,
11038 /// This variant handles values not known at compile time.
11039 #[serde(untagged)]
11040 #[strum(serialize = "__OTHER__")]
11041 Other_(String),
11042}
11043/// The vendor definition for type of Field Replaceable Unit (FRU).
11044///
11045/// Possible values:
11046/// - `undefined`
11047/// - `board`
11048/// - `product`
11049#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11050pub enum HostFruFruTypeEnum {
11051 #[serde(rename = "undefined")]
11052 #[strum(serialize = "undefined")]
11053 Undefined,
11054 #[serde(rename = "board")]
11055 #[strum(serialize = "board")]
11056 Board,
11057 #[serde(rename = "product")]
11058 #[strum(serialize = "product")]
11059 Product,
11060 /// This variant handles values not known at compile time.
11061 #[serde(untagged)]
11062 #[strum(serialize = "__OTHER__")]
11063 Other_(String),
11064}
11065/// Supported values for graphics type.
11066///
11067/// Possible values:
11068/// - `shared`: Shared graphics (ex.
11069///
11070/// virtual shared graphics acceleration).
11071/// - `sharedDirect`: Shared direct graphics (ex.
11072///
11073/// vendor vGPU shared passthrough).
11074#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11075pub enum HostGraphicsConfigGraphicsTypeEnum {
11076 #[serde(rename = "shared")]
11077 #[strum(serialize = "shared")]
11078 Shared,
11079 #[serde(rename = "sharedDirect")]
11080 #[strum(serialize = "sharedDirect")]
11081 SharedDirect,
11082 /// This variant handles values not known at compile time.
11083 #[serde(untagged)]
11084 #[strum(serialize = "__OTHER__")]
11085 Other_(String),
11086}
11087/// Supported values for shared passthrough assignment policy
11088///
11089/// Possible values:
11090/// - `performance`: Performance policy: assign VM to GPU with fewest VMs.
11091/// - `consolidation`: Consolidation policy: group like VMs on GPU until fully loaded.
11092#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11093pub enum HostGraphicsConfigSharedPassthruAssignmentPolicyEnum {
11094 #[serde(rename = "performance")]
11095 #[strum(serialize = "performance")]
11096 Performance,
11097 #[serde(rename = "consolidation")]
11098 #[strum(serialize = "consolidation")]
11099 Consolidation,
11100 /// This variant handles values not known at compile time.
11101 #[serde(untagged)]
11102 #[strum(serialize = "__OTHER__")]
11103 Other_(String),
11104}
11105/// Supported values for vGPU mode.
11106///
11107/// Possible values:
11108/// - `sameSize`: vGPU time-sliced same size.
11109/// - `mixedSize`: vGPU time-sliced mixed size.
11110///
11111/// ***Since:*** vSphere API Release 8.0.3.0
11112#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11113pub enum HostGraphicsConfigVgpuModeEnum {
11114 #[serde(rename = "sameSize")]
11115 #[strum(serialize = "sameSize")]
11116 SameSize,
11117 #[serde(rename = "mixedSize")]
11118 #[strum(serialize = "mixedSize")]
11119 MixedSize,
11120 /// This variant handles values not known at compile time.
11121 #[serde(untagged)]
11122 #[strum(serialize = "__OTHER__")]
11123 Other_(String),
11124}
11125/// Possible values for graphics type.
11126///
11127/// Possible values:
11128/// - `basic`: Basic graphics when no host driver is available.
11129/// - `shared`: Shared graphics (ex.
11130///
11131/// virtual shared graphics acceleration).
11132/// - `direct`: Direct graphics (ex.
11133///
11134/// passthrough).
11135/// - `sharedDirect`: Shared direct graphics (ex.
11136///
11137/// vGPU shared passthrough).
11138#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11139pub enum HostGraphicsInfoGraphicsTypeEnum {
11140 #[serde(rename = "basic")]
11141 #[strum(serialize = "basic")]
11142 Basic,
11143 #[serde(rename = "shared")]
11144 #[strum(serialize = "shared")]
11145 Shared,
11146 #[serde(rename = "direct")]
11147 #[strum(serialize = "direct")]
11148 Direct,
11149 #[serde(rename = "sharedDirect")]
11150 #[strum(serialize = "sharedDirect")]
11151 SharedDirect,
11152 /// This variant handles values not known at compile time.
11153 #[serde(untagged)]
11154 #[strum(serialize = "__OTHER__")]
11155 Other_(String),
11156}
11157/// Possible values for vGPU mode.
11158///
11159/// Possible values:
11160/// - `none`: vGPU mode not applicable.
11161/// - `sameSize`: vGPU time-sliced same size.
11162/// - `mixedSize`: vGPU time-sliced mixed size.
11163/// - `multiInstanceGpu`: vGPU multi-instance GPU.
11164///
11165/// ***Since:*** vSphere API Release 8.0.3.0
11166#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11167pub enum HostGraphicsInfoVgpuModeEnum {
11168 #[serde(rename = "none")]
11169 #[strum(serialize = "none")]
11170 None,
11171 #[serde(rename = "sameSize")]
11172 #[strum(serialize = "sameSize")]
11173 SameSize,
11174 #[serde(rename = "mixedSize")]
11175 #[strum(serialize = "mixedSize")]
11176 MixedSize,
11177 #[serde(rename = "multiInstanceGpu")]
11178 #[strum(serialize = "multiInstanceGpu")]
11179 MultiInstanceGpu,
11180 /// This variant handles values not known at compile time.
11181 #[serde(untagged)]
11182 #[strum(serialize = "__OTHER__")]
11183 Other_(String),
11184}
11185/// The current status of the hardware
11186///
11187/// Possible values:
11188/// - `Unknown`: The implementation cannot report on the current status of the
11189/// physical element
11190/// - `Green`: The physical element is functioning as expected
11191/// - `Yellow`: All functionality is available but some might be degraded.
11192/// - `Red`: The physical element is failing.
11193///
11194/// It is possible that some or all
11195/// functionalities of this physical element is degraded or not working.
11196#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11197pub enum HostHardwareElementStatusEnum {
11198 Unknown,
11199 Green,
11200 Yellow,
11201 Red,
11202 /// This variant handles values not known at compile time.
11203 #[serde(untagged)]
11204 #[strum(serialize = "__OTHER__")]
11205 Other_(String),
11206}
11207/// Defines different access modes that a user may have on the host for
11208/// direct host connections.
11209///
11210/// The assumption here is that when the host is managed by vCenter,
11211/// we don't need fine-grained control on local user permissions like the
11212/// interface provided by *AuthorizationManager*.
11213///
11214/// Possible values:
11215/// - `accessNone`: Indicates that the user has no explicitly defined permissions or roles.
11216///
11217/// This is used when we want to remove all permissions for some user.
11218///
11219/// Note that this is not the same as *accessNoAccess*.
11220/// - `accessAdmin`: Describes a propagating Admin role on the root inventory object
11221/// (root folder) on the host, and no other non-Admin role on any other
11222/// object.
11223///
11224/// The same permissions are needed to login to local or remote
11225/// shell (ESXiShell or SSH).
11226/// - `accessNoAccess`: Describes a propagating NoAccess role on the root inventory object
11227/// (root folder) on the host, and no other roles.
11228///
11229/// Even if the user has another (redundant) NoAccess role on some other
11230/// inventory object, then the access mode for this user will be
11231/// classified as *accessOther*.
11232///
11233/// This mode may be used to restrict a specific user account without
11234/// restricting the access mode for the group to which the user belongs.
11235/// - `accessReadOnly`: Describes a propagating ReadOnly role on the root inventory object
11236/// (root folder) on the host, and no other roles.
11237///
11238/// Even if the user has another (redundant) ReadOnly role on some other
11239/// inventory object, then the access mode for this user will be
11240/// *accessOther*.
11241/// - `accessOther`: Describes a combination of one or more roles/permissions which are
11242/// none of the above.
11243#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11244pub enum HostAccessModeEnum {
11245 #[serde(rename = "accessNone")]
11246 #[strum(serialize = "accessNone")]
11247 AccessNone,
11248 #[serde(rename = "accessAdmin")]
11249 #[strum(serialize = "accessAdmin")]
11250 AccessAdmin,
11251 #[serde(rename = "accessNoAccess")]
11252 #[strum(serialize = "accessNoAccess")]
11253 AccessNoAccess,
11254 #[serde(rename = "accessReadOnly")]
11255 #[strum(serialize = "accessReadOnly")]
11256 AccessReadOnly,
11257 #[serde(rename = "accessOther")]
11258 #[strum(serialize = "accessOther")]
11259 AccessOther,
11260 /// This variant handles values not known at compile time.
11261 #[serde(untagged)]
11262 #[strum(serialize = "__OTHER__")]
11263 Other_(String),
11264}
11265/// Defines the possible states of lockdown mode.
11266///
11267/// Possible values:
11268/// - `lockdownDisabled`: Indicates that lockdown mode is disabled.
11269/// - `lockdownNormal`: Indicates that lockdown mode is enabled with service DCUI
11270/// (Direct Console User Interface) running.
11271/// - `lockdownStrict`: Indicates that lockdown mode is enabled with service DCUI stopped.
11272///
11273/// If the host is in "strict" lockdown mode then no one will be able
11274/// to exit lockdown mode through DCUI in emergency situations,
11275/// i.e. when the connection to vCenter server is permanently lost.
11276#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11277pub enum HostLockdownModeEnum {
11278 #[serde(rename = "lockdownDisabled")]
11279 #[strum(serialize = "lockdownDisabled")]
11280 LockdownDisabled,
11281 #[serde(rename = "lockdownNormal")]
11282 #[strum(serialize = "lockdownNormal")]
11283 LockdownNormal,
11284 #[serde(rename = "lockdownStrict")]
11285 #[strum(serialize = "lockdownStrict")]
11286 LockdownStrict,
11287 /// This variant handles values not known at compile time.
11288 #[serde(untagged)]
11289 #[strum(serialize = "__OTHER__")]
11290 Other_(String),
11291}
11292/// Acceptance level definitions
11293///
11294/// Possible values:
11295/// - `vmware_certified`: "VMware-certified"
11296/// - `vmware_accepted`: "VMware-accepted"
11297/// - `partner`: "Partner-supported"
11298/// - `community`: "Community-supported"
11299#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11300pub enum HostImageAcceptanceLevelEnum {
11301 #[serde(rename = "vmware_certified")]
11302 #[strum(serialize = "vmware_certified")]
11303 VmwareCertified,
11304 #[serde(rename = "vmware_accepted")]
11305 #[strum(serialize = "vmware_accepted")]
11306 VmwareAccepted,
11307 #[serde(rename = "partner")]
11308 #[strum(serialize = "partner")]
11309 Partner,
11310 #[serde(rename = "community")]
11311 #[strum(serialize = "community")]
11312 Community,
11313 /// This variant handles values not known at compile time.
11314 #[serde(untagged)]
11315 #[strum(serialize = "__OTHER__")]
11316 Other_(String),
11317}
11318/// The type of CHAP authentication setting to use.
11319///
11320/// prohibited : do not use CHAP.
11321/// preferred : use CHAP if successfully negotiated,
11322/// but allow non-CHAP connections as fallback
11323/// discouraged : use non-CHAP, but allow CHAP connectsion as fallback
11324/// required : use CHAP for connection strictly, and fail if CHAP
11325/// negotiation fails.
11326/// Defaults to preferred on first configuration if unspecified.
11327///
11328/// Possible values:
11329/// - `chapProhibited`
11330/// - `chapDiscouraged`
11331/// - `chapPreferred`
11332/// - `chapRequired`
11333#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11334pub enum HostInternetScsiHbaChapAuthenticationTypeEnum {
11335 #[serde(rename = "chapProhibited")]
11336 #[strum(serialize = "chapProhibited")]
11337 ChapProhibited,
11338 #[serde(rename = "chapDiscouraged")]
11339 #[strum(serialize = "chapDiscouraged")]
11340 ChapDiscouraged,
11341 #[serde(rename = "chapPreferred")]
11342 #[strum(serialize = "chapPreferred")]
11343 ChapPreferred,
11344 #[serde(rename = "chapRequired")]
11345 #[strum(serialize = "chapRequired")]
11346 ChapRequired,
11347 /// This variant handles values not known at compile time.
11348 #[serde(untagged)]
11349 #[strum(serialize = "__OTHER__")]
11350 Other_(String),
11351}
11352/// The type of integrity checks to use.
11353///
11354/// The digest setting for header
11355/// and data traffic can be separately configured.
11356/// prohibited : do not use digest.
11357/// preferred : use digest if successfully negotiated, but skip the use
11358/// of digest otherwise.
11359/// discouraged : do not use digest if target allows, otherwise use digest.
11360/// required : use digest strictly, and fail if target does not support
11361/// digest.
11362/// Defaults to preferred on first configuration if unspecified.
11363///
11364/// Possible values:
11365/// - `digestProhibited`
11366/// - `digestDiscouraged`
11367/// - `digestPreferred`
11368/// - `digestRequired`
11369#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11370pub enum HostInternetScsiHbaDigestTypeEnum {
11371 #[serde(rename = "digestProhibited")]
11372 #[strum(serialize = "digestProhibited")]
11373 DigestProhibited,
11374 #[serde(rename = "digestDiscouraged")]
11375 #[strum(serialize = "digestDiscouraged")]
11376 DigestDiscouraged,
11377 #[serde(rename = "digestPreferred")]
11378 #[strum(serialize = "digestPreferred")]
11379 DigestPreferred,
11380 #[serde(rename = "digestRequired")]
11381 #[strum(serialize = "digestRequired")]
11382 DigestRequired,
11383 /// This variant handles values not known at compile time.
11384 #[serde(untagged)]
11385 #[strum(serialize = "__OTHER__")]
11386 Other_(String),
11387}
11388/// The available iSNS discovery methods.
11389///
11390/// Possible values:
11391/// - `isnsStatic`
11392/// - `isnsDhcp`
11393/// - `isnsSlp`
11394#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11395pub enum InternetScsiSnsDiscoveryMethodEnum {
11396 #[serde(rename = "isnsStatic")]
11397 #[strum(serialize = "isnsStatic")]
11398 IsnsStatic,
11399 #[serde(rename = "isnsDhcp")]
11400 #[strum(serialize = "isnsDhcp")]
11401 IsnsDhcp,
11402 #[serde(rename = "isnsSlp")]
11403 #[strum(serialize = "isnsSlp")]
11404 IsnsSlp,
11405 /// This variant handles values not known at compile time.
11406 #[serde(untagged)]
11407 #[strum(serialize = "__OTHER__")]
11408 Other_(String),
11409}
11410/// The available SLP discovery methods.
11411///
11412/// Possible values:
11413/// - `slpDhcp`: Use DHCP to find the SLP DAs.
11414/// - `slpAutoUnicast`: Use broadcasting to find SLP DAs.
11415///
11416/// Only DAs on the current subnet will be found.
11417/// - `slpAutoMulticast`: Use the well known multicast address to find DAs.
11418/// - `slpManual`: User specified address for a DA.
11419#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11420pub enum SlpDiscoveryMethodEnum {
11421 #[serde(rename = "slpDhcp")]
11422 #[strum(serialize = "slpDhcp")]
11423 SlpDhcp,
11424 #[serde(rename = "slpAutoUnicast")]
11425 #[strum(serialize = "slpAutoUnicast")]
11426 SlpAutoUnicast,
11427 #[serde(rename = "slpAutoMulticast")]
11428 #[strum(serialize = "slpAutoMulticast")]
11429 SlpAutoMulticast,
11430 #[serde(rename = "slpManual")]
11431 #[strum(serialize = "slpManual")]
11432 SlpManual,
11433 /// This variant handles values not known at compile time.
11434 #[serde(untagged)]
11435 #[strum(serialize = "__OTHER__")]
11436 Other_(String),
11437}
11438/// enum listing possible IPv6 address configuration methods.
11439///
11440/// Possible values:
11441/// - `DHCP`: DHCP
11442/// - `AutoConfigured`: Auto configured.
11443///
11444/// Auto configured Link local address and Router Advertisement addresses
11445/// would be of this type.
11446/// - `Static`: Static address.
11447///
11448/// Typically user specified addresses will be static addresses.
11449/// User can specify link local address. Only Static addresses can be added or removed.
11450/// - `Other`: Other or unknown type.
11451#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11452pub enum HostInternetScsiHbaIscsiIpv6AddressAddressConfigurationTypeEnum {
11453 #[serde(rename = "DHCP")]
11454 #[strum(serialize = "DHCP")]
11455 Dhcp,
11456 AutoConfigured,
11457 Static,
11458 Other,
11459 /// This variant handles values not known at compile time.
11460 #[serde(untagged)]
11461 #[strum(serialize = "__OTHER__")]
11462 Other_(String),
11463}
11464/// enum listing IPv6 address operations.
11465///
11466/// Possible values:
11467/// - `add`
11468/// - `remove`
11469#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11470pub enum HostInternetScsiHbaIscsiIpv6AddressIPv6AddressOperationEnum {
11471 #[serde(rename = "add")]
11472 #[strum(serialize = "add")]
11473 Add,
11474 #[serde(rename = "remove")]
11475 #[strum(serialize = "remove")]
11476 Remove,
11477 /// This variant handles values not known at compile time.
11478 #[serde(untagged)]
11479 #[strum(serialize = "__OTHER__")]
11480 Other_(String),
11481}
11482/// The binding mode of the adapter.
11483///
11484/// Possible values:
11485/// - `notsupported`
11486/// - `optional`
11487/// - `required`
11488#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11489pub enum HostInternetScsiHbaNetworkBindingSupportTypeEnum {
11490 #[serde(rename = "notsupported")]
11491 #[strum(serialize = "notsupported")]
11492 Notsupported,
11493 #[serde(rename = "optional")]
11494 #[strum(serialize = "optional")]
11495 Optional,
11496 #[serde(rename = "required")]
11497 #[strum(serialize = "required")]
11498 Required,
11499 /// This variant handles values not known at compile time.
11500 #[serde(untagged)]
11501 #[strum(serialize = "__OTHER__")]
11502 Other_(String),
11503}
11504/// The method of discovery of an iScsi target.
11505///
11506/// staticMethod: static discovery
11507/// sendTargetsMethod: sendtarget discovery
11508/// slpMethod: Service Location Protocol discovery
11509/// isnsMethod: Internet Storage Name Service discovery
11510/// unknownMethod: discovery method not identified by iscsi stack
11511///
11512/// Possible values:
11513/// - `staticMethod`
11514/// - `sendTargetMethod`
11515/// - `slpMethod`
11516/// - `isnsMethod`
11517/// - `unknownMethod`
11518#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11519pub enum HostInternetScsiHbaStaticTargetTargetDiscoveryMethodEnum {
11520 #[serde(rename = "staticMethod")]
11521 #[strum(serialize = "staticMethod")]
11522 StaticMethod,
11523 #[serde(rename = "sendTargetMethod")]
11524 #[strum(serialize = "sendTargetMethod")]
11525 SendTargetMethod,
11526 #[serde(rename = "slpMethod")]
11527 #[strum(serialize = "slpMethod")]
11528 SlpMethod,
11529 #[serde(rename = "isnsMethod")]
11530 #[strum(serialize = "isnsMethod")]
11531 IsnsMethod,
11532 #[serde(rename = "unknownMethod")]
11533 #[strum(serialize = "unknownMethod")]
11534 UnknownMethod,
11535 /// This variant handles values not known at compile time.
11536 #[serde(untagged)]
11537 #[strum(serialize = "__OTHER__")]
11538 Other_(String),
11539}
11540/// This specifies how the ipv6 address is configured for the interface.
11541///
11542/// We follow rfc4293 in defining the values for the configType.
11543///
11544/// Possible values:
11545/// - `other`: Any other type of address configuration other than the below
11546/// mentioned ones will fall under this category.
11547///
11548/// For e.g., automatic
11549/// address configuration for the link local address falls under
11550/// this type.
11551/// - `manual`: The address is configured manually.
11552/// - `dhcp`: The address is configured through dhcp.
11553/// - `linklayer`: The address is obtained through stateless autoconfiguration.
11554/// - `random`: The address is chosen by the system at random
11555/// e.g., an IPv4 address within 169.254/16, or an RFC
11556/// 3041 privacy address.
11557#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11558pub enum HostIpConfigIpV6AddressConfigTypeEnum {
11559 #[serde(rename = "other")]
11560 #[strum(serialize = "other")]
11561 Other,
11562 #[serde(rename = "manual")]
11563 #[strum(serialize = "manual")]
11564 Manual,
11565 #[serde(rename = "dhcp")]
11566 #[strum(serialize = "dhcp")]
11567 Dhcp,
11568 #[serde(rename = "linklayer")]
11569 #[strum(serialize = "linklayer")]
11570 Linklayer,
11571 #[serde(rename = "random")]
11572 #[strum(serialize = "random")]
11573 Random,
11574 /// This variant handles values not known at compile time.
11575 #[serde(untagged)]
11576 #[strum(serialize = "__OTHER__")]
11577 Other_(String),
11578}
11579/// Possible values:
11580/// - `preferred`: Indicates that this is a valid address.
11581/// - `deprecated`: Indicates that this is a valid but deprecated address
11582/// that should no longer be used as a source address.
11583/// - `invalid`: Indicates that this isn't a valid.
11584/// - `inaccessible`: Indicates that the address is not accessible because
11585/// interface is not operational.
11586/// - `unknown`: Indicates that the status cannot be determined.
11587/// - `tentative`: Indicates that the uniqueness of the
11588/// address on the link is presently being verified.
11589/// - `duplicate`: Indicates the address has been determined to be non-unique
11590/// on the link, this address will not be reachable.
11591#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11592pub enum HostIpConfigIpV6AddressStatusEnum {
11593 #[serde(rename = "preferred")]
11594 #[strum(serialize = "preferred")]
11595 Preferred,
11596 #[serde(rename = "deprecated")]
11597 #[strum(serialize = "deprecated")]
11598 Deprecated,
11599 #[serde(rename = "invalid")]
11600 #[strum(serialize = "invalid")]
11601 Invalid,
11602 #[serde(rename = "inaccessible")]
11603 #[strum(serialize = "inaccessible")]
11604 Inaccessible,
11605 #[serde(rename = "unknown")]
11606 #[strum(serialize = "unknown")]
11607 Unknown,
11608 #[serde(rename = "tentative")]
11609 #[strum(serialize = "tentative")]
11610 Tentative,
11611 #[serde(rename = "duplicate")]
11612 #[strum(serialize = "duplicate")]
11613 Duplicate,
11614 /// This variant handles values not known at compile time.
11615 #[serde(untagged)]
11616 #[strum(serialize = "__OTHER__")]
11617 Other_(String),
11618}
11619/// Possible values:
11620/// - `notUsed`: There are no paths on this Virtual NIC
11621/// - `active`: All paths on this Virtual NIC are standby paths from SCSI stack
11622/// perspective.
11623/// - `standBy`: One or more paths on the Virtual NIC are active paths to
11624/// storage.
11625///
11626/// Unbinding this Virtual NIC will cause storage path
11627/// transitions.
11628/// - `lastActive`: One or more paths on the Virtual NIC is the last active
11629/// path to a particular storage device.
11630#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11631pub enum IscsiPortInfoPathStatusEnum {
11632 #[serde(rename = "notUsed")]
11633 #[strum(serialize = "notUsed")]
11634 NotUsed,
11635 #[serde(rename = "active")]
11636 #[strum(serialize = "active")]
11637 Active,
11638 #[serde(rename = "standBy")]
11639 #[strum(serialize = "standBy")]
11640 StandBy,
11641 #[serde(rename = "lastActive")]
11642 #[strum(serialize = "lastActive")]
11643 LastActive,
11644 /// This variant handles values not known at compile time.
11645 #[serde(untagged)]
11646 #[strum(serialize = "__OTHER__")]
11647 Other_(String),
11648}
11649/// The Discovery Protocol operation.
11650///
11651/// Possible values:
11652/// - `none`: Don't listen for incoming discovery packets and don't sent discover
11653/// packets for the switch either.
11654/// - `listen`: Listen for incoming discovery packets but don't sent discovery packet
11655/// for the switch.
11656/// - `advertise`: Sent discovery packets for the switch, but don't listen for incoming
11657/// discovery packets.
11658/// - `both`: Sent discovery packets for the switch and listen for incoming
11659/// discovery packets.
11660#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11661pub enum LinkDiscoveryProtocolConfigOperationTypeEnum {
11662 #[serde(rename = "none")]
11663 #[strum(serialize = "none")]
11664 None,
11665 #[serde(rename = "listen")]
11666 #[strum(serialize = "listen")]
11667 Listen,
11668 #[serde(rename = "advertise")]
11669 #[strum(serialize = "advertise")]
11670 Advertise,
11671 #[serde(rename = "both")]
11672 #[strum(serialize = "both")]
11673 Both,
11674 /// This variant handles values not known at compile time.
11675 #[serde(untagged)]
11676 #[strum(serialize = "__OTHER__")]
11677 Other_(String),
11678}
11679/// The Discovery Protocol types.
11680///
11681/// Possible values:
11682/// - `cdp`: Cisco Discovery Protocol
11683/// - `lldp`: Link Layer Discovery Protocol
11684#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11685pub enum LinkDiscoveryProtocolConfigProtocolTypeEnum {
11686 #[serde(rename = "cdp")]
11687 #[strum(serialize = "cdp")]
11688 Cdp,
11689 #[serde(rename = "lldp")]
11690 #[strum(serialize = "lldp")]
11691 Lldp,
11692 /// This variant handles values not known at compile time.
11693 #[serde(untagged)]
11694 #[strum(serialize = "__OTHER__")]
11695 Other_(String),
11696}
11697/// This enum defines the possible types of file types that can be reserved
11698/// or deleted
11699///
11700/// Possible values:
11701/// - `File`
11702/// - `VirtualDisk`
11703/// - `Directory`
11704#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11705pub enum HostLowLevelProvisioningManagerFileTypeEnum {
11706 File,
11707 VirtualDisk,
11708 Directory,
11709 /// This variant handles values not known at compile time.
11710 #[serde(untagged)]
11711 #[strum(serialize = "__OTHER__")]
11712 Other_(String),
11713}
11714/// The target of the disk reload.
11715///
11716/// Possible values:
11717/// - `currentConfig`: Specifies the reload of the current config of the virtual machine.
11718/// - `snapshotConfig`: Specifies the reload of the snapshot config of the virtual machine.
11719///
11720/// If the virtual machine has multiple snapshots, all of the snapshot's
11721/// config will be reloaded.
11722#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11723pub enum HostLowLevelProvisioningManagerReloadTargetEnum {
11724 #[serde(rename = "currentConfig")]
11725 #[strum(serialize = "currentConfig")]
11726 CurrentConfig,
11727 #[serde(rename = "snapshotConfig")]
11728 #[strum(serialize = "snapshotConfig")]
11729 SnapshotConfig,
11730 /// This variant handles values not known at compile time.
11731 #[serde(untagged)]
11732 #[strum(serialize = "__OTHER__")]
11733 Other_(String),
11734}
11735/// Possible values:
11736/// - `hostUpgrade`
11737#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11738pub enum HostMaintenanceSpecPurposeEnum {
11739 #[serde(rename = "hostUpgrade")]
11740 #[strum(serialize = "hostUpgrade")]
11741 HostUpgrade,
11742 /// This variant handles values not known at compile time.
11743 #[serde(untagged)]
11744 #[strum(serialize = "__OTHER__")]
11745 Other_(String),
11746}
11747/// Means for allocating additional memory for virtual machines.
11748///
11749/// Possible values:
11750/// - `swapNone`: Fit all virtual machine memory into reserved host memory.
11751/// - `swapSome`: Allow some virtual machine memory to be swapped.
11752/// - `swapMost`: Allow most virtual machine memory to be swapped.
11753#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11754pub enum VirtualMachineMemoryAllocationPolicyEnum {
11755 #[serde(rename = "swapNone")]
11756 #[strum(serialize = "swapNone")]
11757 SwapNone,
11758 #[serde(rename = "swapSome")]
11759 #[strum(serialize = "swapSome")]
11760 SwapSome,
11761 #[serde(rename = "swapMost")]
11762 #[strum(serialize = "swapMost")]
11763 SwapMost,
11764 /// This variant handles values not known at compile time.
11765 #[serde(untagged)]
11766 #[strum(serialize = "__OTHER__")]
11767 Other_(String),
11768}
11769/// Enumeration of flags pertaining to a memory tier.
11770///
11771/// Here are some examples of what the flags will look like for various memory
11772/// configurations:
11773/// - Traditional memory (*noTiering*): The host has a DRAM tier
11774/// for the main memory and nothing else. The DRAM tier will have the
11775/// *memoryTier* flag.
11776/// - App Direct mode (*noTiering*): The host has a DRAM tier
11777/// and a PMem tier, but the two are independent and unrelated. The PMem tier is
11778/// non-volatile and is exposed as an NVDIMM device. Applications can decide whether to
11779/// direct the reads and writes to DRAM or PMem by using the appropriate system call. The
11780/// DRAM tier will have the *memoryTier* flag and the PMem tier will
11781/// have the *persistentTier* flag.
11782/// - Memory mode (*hardwareTiering*): The host has a DRAM tier
11783/// and a PMem tier, but the DRAM is hidden from applications and is just a cache
11784/// for the PMem main memory. The PMem tier is volatile, and is abstracted by the hardware
11785/// layer to look like traditional memory. Applications can read from/write to memory
11786/// using the traditional memory system calls. The memory controller in the hardware will
11787/// internally direct those to the DRAM cache first, and on a cache miss redirect them to
11788/// the PMem main memory. The DRAM tier will have the *cachingTier*
11789/// flag and the PMem tier will have the *memoryTier* flag.
11790///
11791/// Possible values:
11792/// - `memoryTier`: Flag indicating that the tier is the primary memory tier visible from the
11793/// host.
11794/// - `persistentTier`:
11795///
11796/// Deprecated as of vSphere 9.0 APIs with no replacement.
11797///
11798/// Flag indicating that the tier is used as non-volatile storage, e.g.
11799///
11800/// PMem in
11801/// App Direct mode.
11802/// - `cachingTier`: Flag indicating that the tier is a cache for main memory.
11803/// - `unmappableTier`: ***Since:*** vSphere API Release 8.0.3.0
11804///
11805/// ***Since:*** vSphere API Release 7.0.3.0
11806#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11807pub enum HostMemoryTierFlagsEnum {
11808 #[serde(rename = "memoryTier")]
11809 #[strum(serialize = "memoryTier")]
11810 MemoryTier,
11811 #[serde(rename = "persistentTier")]
11812 #[strum(serialize = "persistentTier")]
11813 PersistentTier,
11814 #[serde(rename = "cachingTier")]
11815 #[strum(serialize = "cachingTier")]
11816 CachingTier,
11817 #[serde(rename = "unmappableTier")]
11818 #[strum(serialize = "unmappableTier")]
11819 UnmappableTier,
11820 /// This variant handles values not known at compile time.
11821 #[serde(untagged)]
11822 #[strum(serialize = "__OTHER__")]
11823 Other_(String),
11824}
11825/// Enumeration of supported types of memory tiers.
11826///
11827/// Possible values:
11828/// - `DRAM`: Dynamic random-access memory.
11829/// - `PMem`:
11830///
11831/// Deprecated as of vSphere 9.0 APIs with no replacement.
11832///
11833/// Persistent memory.
11834/// - `NVMe`: NVMe memory.
11835///
11836/// ***Since:*** vSphere API Release 8.0.3.0
11837///
11838/// ***Since:*** vSphere API Release 7.0.3.0
11839#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11840pub enum HostMemoryTierTypeEnum {
11841 #[serde(rename = "DRAM")]
11842 #[strum(serialize = "DRAM")]
11843 Dram,
11844 PMem,
11845 #[serde(rename = "NVMe")]
11846 #[strum(serialize = "NVMe")]
11847 NvMe,
11848 /// This variant handles values not known at compile time.
11849 #[serde(untagged)]
11850 #[strum(serialize = "__OTHER__")]
11851 Other_(String),
11852}
11853/// Enumeration of the supported kinds of memory tiering configurations.
11854///
11855/// Possible values:
11856/// - `noTiering`: The traditional memory configuration without any tiers.
11857/// - `hardwareTiering`: The memory configuration where a tier is hardware-controlled and invisible to
11858/// applications, e.g.
11859///
11860/// Intel's Memory Mode.
11861/// - `softwareTiering`: The memory configuration where all memory tiers are managed by software (ESX).
11862///
11863/// ***Since:*** vSphere API Release 8.0.3.0
11864///
11865/// ***Since:*** vSphere API Release 7.0.3.0
11866#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11867pub enum HostMemoryTieringTypeEnum {
11868 #[serde(rename = "noTiering")]
11869 #[strum(serialize = "noTiering")]
11870 NoTiering,
11871 #[serde(rename = "hardwareTiering")]
11872 #[strum(serialize = "hardwareTiering")]
11873 HardwareTiering,
11874 #[serde(rename = "softwareTiering")]
11875 #[strum(serialize = "softwareTiering")]
11876 SoftwareTiering,
11877 /// This variant handles values not known at compile time.
11878 #[serde(untagged)]
11879 #[strum(serialize = "__OTHER__")]
11880 Other_(String),
11881}
11882/// Defines the access mode of the datastore.
11883///
11884/// Possible values:
11885/// - `readWrite`: The host system has read/write access to the file system.
11886/// - `readOnly`: The host system has read-only access to the file system.
11887#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11888pub enum HostMountModeEnum {
11889 #[serde(rename = "readWrite")]
11890 #[strum(serialize = "readWrite")]
11891 ReadWrite,
11892 #[serde(rename = "readOnly")]
11893 #[strum(serialize = "readOnly")]
11894 ReadOnly,
11895 /// This variant handles values not known at compile time.
11896 #[serde(untagged)]
11897 #[strum(serialize = "__OTHER__")]
11898 Other_(String),
11899}
11900/// A datastore can become inaccessible due to a number of reasons as
11901/// defined in this enum *HostMountInfoInaccessibleReason_enum*.
11902///
11903/// The reason for a datastore being inaccessible is reported in
11904/// *HostMountInfo.inaccessibleReason*.
11905/// APD ("All Paths Down") is a condition where a SAN or NFS storage has
11906/// become inaccessible for unknown reasons. It only indicates loss of
11907/// connectivity and does not indicate storage device failure or
11908/// LUN removal (Permanent Device Loss or PDL)
11909/// A difference between APD and PDL is that APD may recover
11910/// in which case all use cases will start to work as before. In case of PDL
11911/// the failed datastore/device is unlikely to recover and hence the device
11912/// path information and data cache will be emptied. If the PDL condition
11913/// recovers, the failed datastores have to be added back to the host. Once
11914/// in PDL a datastore cannot be added back until there are no longer any
11915/// open files on the datastore.
11916/// PDL is not linked to the APD and can happen at any time with or without APD
11917/// preceding. If APD and PDL occur at the same time, APD will be reported first.
11918/// Once (and if) the APD condition clears, PermanentDataLoss will be reported if
11919/// PDL condition still exists.
11920///
11921/// Possible values:
11922/// - `AllPathsDown_Start`: AllPathsDown\_Start value is reported when all paths down state is detected
11923/// - `AllPathsDown_Timeout`: After a wait for a system default time (which is user modifiable)
11924/// to ascertain the state is indeed an APD, AllPathsDown\_Timeout property
11925/// is reported.
11926///
11927/// The host advanced option used to set timeout period
11928/// is "/Misc/APDTimeout"
11929/// After the datastore property is set to AllPathsDown\_Timeout, all data i/o
11930/// to the datastore will be fast-failed (failed immediately).
11931/// - `PermanentDeviceLoss`: A PDL condition is reported as PermanentDeviceLoss.
11932#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11933pub enum HostMountInfoInaccessibleReasonEnum {
11934 #[serde(rename = "AllPathsDown_Start")]
11935 #[strum(serialize = "AllPathsDown_Start")]
11936 AllPathsDownStart,
11937 #[serde(rename = "AllPathsDown_Timeout")]
11938 #[strum(serialize = "AllPathsDown_Timeout")]
11939 AllPathsDownTimeout,
11940 PermanentDeviceLoss,
11941 /// This variant handles values not known at compile time.
11942 #[serde(untagged)]
11943 #[strum(serialize = "__OTHER__")]
11944 Other_(String),
11945}
11946/// NFS mount request can be failed due to a number of reasons as
11947/// defined in this enum *HostMountInfoMountFailedReason_enum*.
11948///
11949/// The reason for the mount failure is reported in
11950/// *HostMountInfo.mountFailedReason*. This is applicable only for those
11951/// datastores to which mount retry is configured.
11952///
11953/// Possible values:
11954/// - `CONNECT_FAILURE`: Failed to get port or connect.
11955///
11956/// Or MOUNT/FSINFO RPC failed.
11957/// - `MOUNT_NOT_SUPPORTED`: Server doesn't support MOUNT\_PROGRAM/MOUNT\_PROGRAM\_VERSION.
11958/// - `NFS_NOT_SUPPORTED`: Server doesn't support NFS\_PROGRAM/NFS\_PROGRAM\_VERSION.
11959/// - `MOUNT_DENIED`: No permission to mount the remote volume or it doesn't exist.
11960/// - `MOUNT_NOT_DIR`: Remote path not a directory.
11961/// - `VOLUME_LIMIT_EXCEEDED`: Maximum NFS volumes have been mounted.
11962/// - `CONN_LIMIT_EXCEEDED`: Maximum connections for NFS has been reached.
11963/// - `MOUNT_EXISTS`: Volume already mounted or a different mount exists with same label.
11964/// - `OTHERS`: Any other reason which is not present in above list.
11965///
11966/// ***Since:*** vSphere API Release 8.0.0.1
11967#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
11968pub enum HostMountInfoMountFailedReasonEnum {
11969 #[serde(rename = "CONNECT_FAILURE")]
11970 #[strum(serialize = "CONNECT_FAILURE")]
11971 ConnectFailure,
11972 #[serde(rename = "MOUNT_NOT_SUPPORTED")]
11973 #[strum(serialize = "MOUNT_NOT_SUPPORTED")]
11974 MountNotSupported,
11975 #[serde(rename = "NFS_NOT_SUPPORTED")]
11976 #[strum(serialize = "NFS_NOT_SUPPORTED")]
11977 NfsNotSupported,
11978 #[serde(rename = "MOUNT_DENIED")]
11979 #[strum(serialize = "MOUNT_DENIED")]
11980 MountDenied,
11981 #[serde(rename = "MOUNT_NOT_DIR")]
11982 #[strum(serialize = "MOUNT_NOT_DIR")]
11983 MountNotDir,
11984 #[serde(rename = "VOLUME_LIMIT_EXCEEDED")]
11985 #[strum(serialize = "VOLUME_LIMIT_EXCEEDED")]
11986 VolumeLimitExceeded,
11987 #[serde(rename = "CONN_LIMIT_EXCEEDED")]
11988 #[strum(serialize = "CONN_LIMIT_EXCEEDED")]
11989 ConnLimitExceeded,
11990 #[serde(rename = "MOUNT_EXISTS")]
11991 #[strum(serialize = "MOUNT_EXISTS")]
11992 MountExists,
11993 #[serde(rename = "OTHERS")]
11994 #[strum(serialize = "OTHERS")]
11995 Others,
11996 /// This variant handles values not known at compile time.
11997 #[serde(untagged)]
11998 #[strum(serialize = "__OTHER__")]
11999 Other_(String),
12000}
12001/// Set of constants defining the possible states of a multipath path.
12002///
12003/// Possible values:
12004/// - `standby`
12005/// - `active`
12006/// - `disabled`
12007/// - `dead`
12008/// - `unknown`
12009#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12010pub enum MultipathStateEnum {
12011 #[serde(rename = "standby")]
12012 #[strum(serialize = "standby")]
12013 Standby,
12014 #[serde(rename = "active")]
12015 #[strum(serialize = "active")]
12016 Active,
12017 #[serde(rename = "disabled")]
12018 #[strum(serialize = "disabled")]
12019 Disabled,
12020 #[serde(rename = "dead")]
12021 #[strum(serialize = "dead")]
12022 Dead,
12023 #[serde(rename = "unknown")]
12024 #[strum(serialize = "unknown")]
12025 Unknown,
12026 /// This variant handles values not known at compile time.
12027 #[serde(untagged)]
12028 #[strum(serialize = "__OTHER__")]
12029 Other_(String),
12030}
12031/// Security type supported.
12032///
12033/// Possible values:
12034/// - `AUTH_SYS`: Authentication based on traditional UNIX identifiers (UID and GID).
12035///
12036/// Server trusts the IDs sent by the client for each request and uses them
12037/// to perform access control. Current implementation only supports
12038/// AUTH\_SYS with root user.
12039/// - `SEC_KRB5`: Ensures RPC header authentication using Kerberos session keys.
12040///
12041/// When
12042/// this option is enabled, the client uses the information specified in
12043/// *HostNasVolumeUserInfo* to establish shared keys with the server using
12044/// Kerberos. These shared keys are used to generate and verify message
12045/// authentication codes for RPC header of NFS requests and responses,
12046/// respectively. This method does not secure NFS file data.
12047/// - `SEC_KRB5I`: Extends SEC\_KRB5 to generate and verify message authentication codes
12048/// for the payload of NFS requests and responses respectively.
12049///
12050/// This
12051/// ensures the integrity of the NFS file data.
12052/// - `SEC_KRB5P`: Extends *SEC_KRB5I* to send and receive encrypted NFS packets over
12053/// the wire.
12054///
12055/// *SEC_KRB5P* provides data privacy in addition to data
12056/// integrity for NFS files. To date, SEC\_KRB5P provides the highest form of
12057/// security for NFS payload.
12058///
12059/// ***Since:*** vSphere API Release 9.0.0.0
12060#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12061pub enum HostNasVolumeSecurityTypeEnum {
12062 #[serde(rename = "AUTH_SYS")]
12063 #[strum(serialize = "AUTH_SYS")]
12064 AuthSys,
12065 #[serde(rename = "SEC_KRB5")]
12066 #[strum(serialize = "SEC_KRB5")]
12067 SecKrb5,
12068 #[serde(rename = "SEC_KRB5I")]
12069 #[strum(serialize = "SEC_KRB5I")]
12070 SecKrb5I,
12071 #[serde(rename = "SEC_KRB5P")]
12072 #[strum(serialize = "SEC_KRB5P")]
12073 SecKrb5P,
12074 /// This variant handles values not known at compile time.
12075 #[serde(untagged)]
12076 #[strum(serialize = "__OTHER__")]
12077 Other_(String),
12078}
12079/// Define TCP congestion control algorithm used by an instance
12080///
12081/// Possible values:
12082/// - `newreno`: New Reno Algorithm.
12083///
12084/// See http://tools.ietf.org/html/rfc3782 for detail.
12085/// - `cubic`: Cubic Algorithm.
12086///
12087/// See http://tools.ietf.org/id/draft-rhee-tcp-cubic-00.txt for detail.
12088#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12089pub enum HostNetStackInstanceCongestionControlAlgorithmTypeEnum {
12090 #[serde(rename = "newreno")]
12091 #[strum(serialize = "newreno")]
12092 Newreno,
12093 #[serde(rename = "cubic")]
12094 #[strum(serialize = "cubic")]
12095 Cubic,
12096 /// This variant handles values not known at compile time.
12097 #[serde(untagged)]
12098 #[strum(serialize = "__OTHER__")]
12099 Other_(String),
12100}
12101/// Define the instance identifier for different traffic type
12102///
12103/// Possible values:
12104/// - `defaultTcpipStack`: The default stack used by applications
12105/// - `vmotion`: Stack key used for vMotion applications
12106/// - `vSphereProvisioning`: Stack key used for vSphere provisioning NFC traffic
12107/// - `mirror`: Stack key used for port mirroring
12108///
12109/// ***Since:*** vSphere API Release 8.0.0.1
12110/// - `ops`: Stack key used for ops applications
12111///
12112/// ***Since:*** vSphere API Release 8.0.0.1
12113#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12114pub enum HostNetStackInstanceSystemStackKeyEnum {
12115 #[serde(rename = "defaultTcpipStack")]
12116 #[strum(serialize = "defaultTcpipStack")]
12117 DefaultTcpipStack,
12118 #[serde(rename = "vmotion")]
12119 #[strum(serialize = "vmotion")]
12120 Vmotion,
12121 #[serde(rename = "vSphereProvisioning")]
12122 #[strum(serialize = "vSphereProvisioning")]
12123 VSphereProvisioning,
12124 #[serde(rename = "mirror")]
12125 #[strum(serialize = "mirror")]
12126 Mirror,
12127 #[serde(rename = "ops")]
12128 #[strum(serialize = "ops")]
12129 Ops,
12130 /// This variant handles values not known at compile time.
12131 #[serde(untagged)]
12132 #[strum(serialize = "__OTHER__")]
12133 Other_(String),
12134}
12135/// Health state of the numeric sensor as reported by the sensor probes.
12136///
12137/// Same data reported using command line: esxcli hardware ipmi sdr list
12138///
12139/// Possible values:
12140/// - `unknown`: The implementation cannot report on the current health state of the
12141/// physical element
12142/// - `green`: The sensor is operating under normal conditions
12143/// - `yellow`: The sensor is operating under conditions that are non-critical.
12144/// - `red`: The sensor is operating under critical or fatal conditions.
12145///
12146/// This may
12147/// directly affect the functioning of both the sensor and related
12148/// components.
12149#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12150pub enum HostNumericSensorHealthStateEnum {
12151 #[serde(rename = "unknown")]
12152 #[strum(serialize = "unknown")]
12153 Unknown,
12154 #[serde(rename = "green")]
12155 #[strum(serialize = "green")]
12156 Green,
12157 #[serde(rename = "yellow")]
12158 #[strum(serialize = "yellow")]
12159 Yellow,
12160 #[serde(rename = "red")]
12161 #[strum(serialize = "red")]
12162 Red,
12163 /// This variant handles values not known at compile time.
12164 #[serde(untagged)]
12165 #[strum(serialize = "__OTHER__")]
12166 Other_(String),
12167}
12168/// Sensor Types for specific hardware component are either based on
12169/// class of sensor or what the sensor monitors to allow for grouping
12170///
12171/// Possible values:
12172/// - `fan`: Fan sensor
12173/// - `power`: Power sensor
12174/// - `temperature`: Temperature sensor
12175/// - `voltage`: Voltage Sensor
12176/// - `other`: Other sensor.
12177/// - `processor`: Processor sensor.
12178/// - `memory`: Memory sensor.
12179/// - `storage`: disk/storage sensor.
12180/// - `systemBoard`: system board sensor.
12181/// - `battery`: Battery sensor.
12182/// - `bios`: BIOS/firmware related sensor.
12183/// - `cable`: cable related sensor.
12184/// - `watchdog`: Watchdog related sensor.
12185#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12186pub enum HostNumericSensorTypeEnum {
12187 #[serde(rename = "fan")]
12188 #[strum(serialize = "fan")]
12189 Fan,
12190 #[serde(rename = "power")]
12191 #[strum(serialize = "power")]
12192 Power,
12193 #[serde(rename = "temperature")]
12194 #[strum(serialize = "temperature")]
12195 Temperature,
12196 #[serde(rename = "voltage")]
12197 #[strum(serialize = "voltage")]
12198 Voltage,
12199 #[serde(rename = "other")]
12200 #[strum(serialize = "other")]
12201 Other,
12202 #[serde(rename = "processor")]
12203 #[strum(serialize = "processor")]
12204 Processor,
12205 #[serde(rename = "memory")]
12206 #[strum(serialize = "memory")]
12207 Memory,
12208 #[serde(rename = "storage")]
12209 #[strum(serialize = "storage")]
12210 Storage,
12211 #[serde(rename = "systemBoard")]
12212 #[strum(serialize = "systemBoard")]
12213 SystemBoard,
12214 #[serde(rename = "battery")]
12215 #[strum(serialize = "battery")]
12216 Battery,
12217 #[serde(rename = "bios")]
12218 #[strum(serialize = "bios")]
12219 Bios,
12220 #[serde(rename = "cable")]
12221 #[strum(serialize = "cable")]
12222 Cable,
12223 #[serde(rename = "watchdog")]
12224 #[strum(serialize = "watchdog")]
12225 Watchdog,
12226 /// This variant handles values not known at compile time.
12227 #[serde(untagged)]
12228 #[strum(serialize = "__OTHER__")]
12229 Other_(String),
12230}
12231/// Overall state of NVDIMM
12232///
12233/// Possible values:
12234/// - `normal`: NVDIMM state is normal
12235/// - `error`: Error in NVDIMM state.
12236///
12237/// Potential data loss.
12238#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12239pub enum NvdimmNvdimmHealthInfoStateEnum {
12240 #[serde(rename = "normal")]
12241 #[strum(serialize = "normal")]
12242 Normal,
12243 #[serde(rename = "error")]
12244 #[strum(serialize = "error")]
12245 Error,
12246 /// This variant handles values not known at compile time.
12247 #[serde(untagged)]
12248 #[strum(serialize = "__OTHER__")]
12249 Other_(String),
12250}
12251/// State of interleave set
12252///
12253/// Possible values:
12254/// - `invalid`: Interleave set is invalid
12255/// - `active`: Interleave set is valid and active
12256#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12257pub enum NvdimmInterleaveSetStateEnum {
12258 #[serde(rename = "invalid")]
12259 #[strum(serialize = "invalid")]
12260 Invalid,
12261 #[serde(rename = "active")]
12262 #[strum(serialize = "active")]
12263 Active,
12264 /// This variant handles values not known at compile time.
12265 #[serde(untagged)]
12266 #[strum(serialize = "__OTHER__")]
12267 Other_(String),
12268}
12269/// Overall health state for a namespace
12270///
12271/// Possible values:
12272/// - `normal`: Namespace health is normal
12273/// - `missing`: Namespace health is missing
12274/// - `labelMissing`: Namespace health label is missing
12275/// - `interleaveBroken`: Namespace health interleave broken
12276/// - `labelInconsistent`: Namespace health label is inconsistent
12277#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12278pub enum NvdimmNamespaceDetailsHealthStatusEnum {
12279 #[serde(rename = "normal")]
12280 #[strum(serialize = "normal")]
12281 Normal,
12282 #[serde(rename = "missing")]
12283 #[strum(serialize = "missing")]
12284 Missing,
12285 #[serde(rename = "labelMissing")]
12286 #[strum(serialize = "labelMissing")]
12287 LabelMissing,
12288 #[serde(rename = "interleaveBroken")]
12289 #[strum(serialize = "interleaveBroken")]
12290 InterleaveBroken,
12291 #[serde(rename = "labelInconsistent")]
12292 #[strum(serialize = "labelInconsistent")]
12293 LabelInconsistent,
12294 /// This variant handles values not known at compile time.
12295 #[serde(untagged)]
12296 #[strum(serialize = "__OTHER__")]
12297 Other_(String),
12298}
12299/// State of Namespace
12300///
12301/// Possible values:
12302/// - `invalid`: Namespace is invalid
12303/// - `notInUse`: Namespace is valid but not in use
12304/// - `inUse`: Namespace is valid and is in use
12305#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12306pub enum NvdimmNamespaceDetailsStateEnum {
12307 #[serde(rename = "invalid")]
12308 #[strum(serialize = "invalid")]
12309 Invalid,
12310 #[serde(rename = "notInUse")]
12311 #[strum(serialize = "notInUse")]
12312 NotInUse,
12313 #[serde(rename = "inUse")]
12314 #[strum(serialize = "inUse")]
12315 InUse,
12316 /// This variant handles values not known at compile time.
12317 #[serde(untagged)]
12318 #[strum(serialize = "__OTHER__")]
12319 Other_(String),
12320}
12321/// Overall health state for a namespace
12322///
12323/// Possible values:
12324/// - `normal`: Namespace health is normal
12325/// - `missing`: Namespace health is missing
12326/// - `labelMissing`: Namespace health label is missing
12327/// - `interleaveBroken`: Namespace health interleave broken
12328/// - `labelInconsistent`: Namespace health label is inconsistent
12329/// - `bttCorrupt`: Namespace health BTT is corrupt
12330/// - `badBlockSize`: Namespace health encountered bad block
12331#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12332pub enum NvdimmNamespaceHealthStatusEnum {
12333 #[serde(rename = "normal")]
12334 #[strum(serialize = "normal")]
12335 Normal,
12336 #[serde(rename = "missing")]
12337 #[strum(serialize = "missing")]
12338 Missing,
12339 #[serde(rename = "labelMissing")]
12340 #[strum(serialize = "labelMissing")]
12341 LabelMissing,
12342 #[serde(rename = "interleaveBroken")]
12343 #[strum(serialize = "interleaveBroken")]
12344 InterleaveBroken,
12345 #[serde(rename = "labelInconsistent")]
12346 #[strum(serialize = "labelInconsistent")]
12347 LabelInconsistent,
12348 #[serde(rename = "bttCorrupt")]
12349 #[strum(serialize = "bttCorrupt")]
12350 BttCorrupt,
12351 #[serde(rename = "badBlockSize")]
12352 #[strum(serialize = "badBlockSize")]
12353 BadBlockSize,
12354 /// This variant handles values not known at compile time.
12355 #[serde(untagged)]
12356 #[strum(serialize = "__OTHER__")]
12357 Other_(String),
12358}
12359/// State of Namespace
12360///
12361/// Possible values:
12362/// - `invalid`: Namespace is invalid
12363/// - `notInUse`: Namespace is valid but not in use
12364/// - `inUse`: Namespace is valid and is in use
12365#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12366pub enum NvdimmNamespaceStateEnum {
12367 #[serde(rename = "invalid")]
12368 #[strum(serialize = "invalid")]
12369 Invalid,
12370 #[serde(rename = "notInUse")]
12371 #[strum(serialize = "notInUse")]
12372 NotInUse,
12373 #[serde(rename = "inUse")]
12374 #[strum(serialize = "inUse")]
12375 InUse,
12376 /// This variant handles values not known at compile time.
12377 #[serde(untagged)]
12378 #[strum(serialize = "__OTHER__")]
12379 Other_(String),
12380}
12381/// Type of namespace.
12382///
12383/// Possible values:
12384/// - `blockNamespace`: Block mode namespace
12385/// - `persistentNamespace`: Persistent mode namespace
12386#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12387pub enum NvdimmNamespaceTypeEnum {
12388 #[serde(rename = "blockNamespace")]
12389 #[strum(serialize = "blockNamespace")]
12390 BlockNamespace,
12391 #[serde(rename = "persistentNamespace")]
12392 #[strum(serialize = "persistentNamespace")]
12393 PersistentNamespace,
12394 /// This variant handles values not known at compile time.
12395 #[serde(untagged)]
12396 #[strum(serialize = "__OTHER__")]
12397 Other_(String),
12398}
12399/// An indicator of how a memory range is being used
12400///
12401/// Possible values:
12402/// - `volatileRange`: Identifies the region to be volatile
12403/// - `persistentRange`: Identifies the region to be persistent
12404/// - `controlRange`: NVDIMM control region
12405/// - `blockRange`: NVDIMM block data window region
12406/// - `volatileVirtualDiskRange`: NVDIMM volatile virtual disk region
12407/// - `volatileVirtualCDRange`: NVDIMM volatile virtual CD region
12408/// - `persistentVirtualDiskRange`: NVDIMM persistent virtual disk region
12409/// - `persistentVirtualCDRange`: NVDIMM persistent virtual CD region
12410#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12411pub enum NvdimmRangeTypeEnum {
12412 #[serde(rename = "volatileRange")]
12413 #[strum(serialize = "volatileRange")]
12414 VolatileRange,
12415 #[serde(rename = "persistentRange")]
12416 #[strum(serialize = "persistentRange")]
12417 PersistentRange,
12418 #[serde(rename = "controlRange")]
12419 #[strum(serialize = "controlRange")]
12420 ControlRange,
12421 #[serde(rename = "blockRange")]
12422 #[strum(serialize = "blockRange")]
12423 BlockRange,
12424 #[serde(rename = "volatileVirtualDiskRange")]
12425 #[strum(serialize = "volatileVirtualDiskRange")]
12426 VolatileVirtualDiskRange,
12427 #[serde(rename = "volatileVirtualCDRange")]
12428 #[strum(serialize = "volatileVirtualCDRange")]
12429 VolatileVirtualCdRange,
12430 #[serde(rename = "persistentVirtualDiskRange")]
12431 #[strum(serialize = "persistentVirtualDiskRange")]
12432 PersistentVirtualDiskRange,
12433 #[serde(rename = "persistentVirtualCDRange")]
12434 #[strum(serialize = "persistentVirtualCDRange")]
12435 PersistentVirtualCdRange,
12436 /// This variant handles values not known at compile time.
12437 #[serde(untagged)]
12438 #[strum(serialize = "__OTHER__")]
12439 Other_(String),
12440}
12441/// This enum represents the supported NVM subsystem types.
12442///
12443/// Possible values:
12444/// - `discovery`: A Discovery service, composed of Discovery controllers.
12445/// - `nvm`: An NVM subsystem whose controllers may have attached namespaces.
12446#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12447pub enum HostNvmeDiscoveryLogSubsystemTypeEnum {
12448 #[serde(rename = "discovery")]
12449 #[strum(serialize = "discovery")]
12450 Discovery,
12451 #[serde(rename = "nvm")]
12452 #[strum(serialize = "nvm")]
12453 Nvm,
12454 /// This variant handles values not known at compile time.
12455 #[serde(untagged)]
12456 #[strum(serialize = "__OTHER__")]
12457 Other_(String),
12458}
12459/// This enum represents the supported types of transport requirements.
12460///
12461/// Possible values:
12462/// - `secureChannelRequired`: A fabric secure channel is required.
12463/// - `secureChannelNotRequired`: A fabric secure channel is not required.
12464/// - `requirementsNotSpecified`: Requirements are not specified
12465#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12466pub enum HostNvmeDiscoveryLogTransportRequirementsEnum {
12467 #[serde(rename = "secureChannelRequired")]
12468 #[strum(serialize = "secureChannelRequired")]
12469 SecureChannelRequired,
12470 #[serde(rename = "secureChannelNotRequired")]
12471 #[strum(serialize = "secureChannelNotRequired")]
12472 SecureChannelNotRequired,
12473 #[serde(rename = "requirementsNotSpecified")]
12474 #[strum(serialize = "requirementsNotSpecified")]
12475 RequirementsNotSpecified,
12476 /// This variant handles values not known at compile time.
12477 #[serde(untagged)]
12478 #[strum(serialize = "__OTHER__")]
12479 Other_(String),
12480}
12481/// This enum specifies the supported address families for
12482/// NVME over Fabrics.
12483///
12484/// For details, see:
12485/// - "NVM Express over Fabrics 1.0", Section 5.3, Figure 34,
12486/// "Discovery Log Page Entry"
12487///
12488/// Possible values:
12489/// - `ipv4`: IPv4 address, format specified in IETF RFC 791.
12490/// - `ipv6`: IPv6 address, format specified in IETF RFC 2373.
12491/// - `infiniBand`: InfiniBand address family.
12492/// - `fc`: Fibre Channel address family.
12493/// - `loopback`: Intra-host transport.
12494/// - `unknown`: Unrecognized address family.
12495#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12496pub enum HostNvmeTransportParametersNvmeAddressFamilyEnum {
12497 #[serde(rename = "ipv4")]
12498 #[strum(serialize = "ipv4")]
12499 Ipv4,
12500 #[serde(rename = "ipv6")]
12501 #[strum(serialize = "ipv6")]
12502 Ipv6,
12503 #[serde(rename = "infiniBand")]
12504 #[strum(serialize = "infiniBand")]
12505 InfiniBand,
12506 #[serde(rename = "fc")]
12507 #[strum(serialize = "fc")]
12508 Fc,
12509 #[serde(rename = "loopback")]
12510 #[strum(serialize = "loopback")]
12511 Loopback,
12512 #[serde(rename = "unknown")]
12513 #[strum(serialize = "unknown")]
12514 Unknown,
12515 /// This variant handles values not known at compile time.
12516 #[serde(untagged)]
12517 #[strum(serialize = "__OTHER__")]
12518 Other_(String),
12519}
12520/// The set of NVM Express over Fabrics transport types.
12521///
12522/// For details, see:
12523/// - "NVM Express over Fabrics 1.0", Section 1.5.1,
12524/// "Fabrics and Transports".
12525///
12526/// Possible values:
12527/// - `pcie`: PCI Express transport type
12528/// - `fibreChannel`: Fibre Channel transport type
12529/// - `rdma`: Remote Direct Memory Access transport type
12530/// - `tcp`: Transmission Control Protocol transport type
12531///
12532/// ***Since:*** vSphere API Release 7.0.3.0
12533/// - `loopback`: Intra-host transport.
12534/// - `unsupported`: The transport type is not among the currently supported ones.
12535#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12536pub enum HostNvmeTransportTypeEnum {
12537 #[serde(rename = "pcie")]
12538 #[strum(serialize = "pcie")]
12539 Pcie,
12540 #[serde(rename = "fibreChannel")]
12541 #[strum(serialize = "fibreChannel")]
12542 FibreChannel,
12543 #[serde(rename = "rdma")]
12544 #[strum(serialize = "rdma")]
12545 Rdma,
12546 #[serde(rename = "tcp")]
12547 #[strum(serialize = "tcp")]
12548 Tcp,
12549 #[serde(rename = "loopback")]
12550 #[strum(serialize = "loopback")]
12551 Loopback,
12552 #[serde(rename = "unsupported")]
12553 #[strum(serialize = "unsupported")]
12554 Unsupported,
12555 /// This variant handles values not known at compile time.
12556 #[serde(untagged)]
12557 #[strum(serialize = "__OTHER__")]
12558 Other_(String),
12559}
12560/// Possible values:
12561/// - `up`: The opaque switch is up and running.
12562/// - `warning`: The opaque switch requires attention.
12563/// - `down`: The opaque switch is down.
12564/// - `maintenance`: The opaque switch is under upgrade.
12565#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12566pub enum HostOpaqueSwitchOpaqueSwitchStateEnum {
12567 #[serde(rename = "up")]
12568 #[strum(serialize = "up")]
12569 Up,
12570 #[serde(rename = "warning")]
12571 #[strum(serialize = "warning")]
12572 Warning,
12573 #[serde(rename = "down")]
12574 #[strum(serialize = "down")]
12575 Down,
12576 #[serde(rename = "maintenance")]
12577 #[strum(serialize = "maintenance")]
12578 Maintenance,
12579 /// This variant handles values not known at compile time.
12580 #[serde(untagged)]
12581 #[strum(serialize = "__OTHER__")]
12582 Other_(String),
12583}
12584/// The following enum describes some common kinds of partial maintenance modes,
12585/// as well as their special semantics.
12586///
12587/// Possible values:
12588/// - `quickPatchPartialMM`: When the host is in the quick patch partial maintenance mode, it is safe to
12589/// perform a quick patch.
12590///
12591/// When the host is in this partial maintenance mode, any virtual machines
12592/// and/or pods placed on it will continue to run but operations which may
12593/// lead to new workloads starting on the host such as power on or incoming
12594/// vmotions may be blocked.
12595/// It is generally unsafe to reboot the host in this state.
12596///
12597/// ***Since:*** vSphere API Release 8.0.3.0
12598///
12599/// ***Since:*** vSphere API Release 8.0.3.0
12600#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12601pub enum HostPartialMaintenanceModeIdEnum {
12602 #[serde(rename = "quickPatchPartialMM")]
12603 #[strum(serialize = "quickPatchPartialMM")]
12604 QuickPatchPartialMm,
12605 /// This variant handles values not known at compile time.
12606 #[serde(untagged)]
12607 #[strum(serialize = "__OTHER__")]
12608 Other_(String),
12609}
12610/// The following enum contains the list of possible statuses associated
12611/// with each partial maintenance mode.
12612///
12613/// Possible values:
12614/// - `notInPartialMM`: The host is not in the particular partial maintenance mode.
12615/// - `enteringPartialMM`: The host is in the process of entering the particular partial maintenance
12616/// mode.
12617/// - `exitingPartialMM`: The host is in the process of exiting the particular partial maintenance
12618/// mode.
12619/// - `inPartialMM`: The host is in the particular partial maintenance mode.
12620///
12621/// ***Since:*** vSphere API Release 8.0.3.0
12622#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12623pub enum HostPartialMaintenanceModeStatusEnum {
12624 #[serde(rename = "notInPartialMM")]
12625 #[strum(serialize = "notInPartialMM")]
12626 NotInPartialMm,
12627 #[serde(rename = "enteringPartialMM")]
12628 #[strum(serialize = "enteringPartialMM")]
12629 EnteringPartialMm,
12630 #[serde(rename = "exitingPartialMM")]
12631 #[strum(serialize = "exitingPartialMM")]
12632 ExitingPartialMm,
12633 #[serde(rename = "inPartialMM")]
12634 #[strum(serialize = "inPartialMM")]
12635 InPartialMm,
12636 /// This variant handles values not known at compile time.
12637 #[serde(untagged)]
12638 #[strum(serialize = "__OTHER__")]
12639 Other_(String),
12640}
12641/// The installation state if the update is installed on the server.
12642///
12643/// Possible values:
12644/// - `hostRestarted`: The server has been restarted since the update installation.
12645/// - `imageActive`: Indicates if the newly installed image is active on the server
12646#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12647pub enum HostPatchManagerInstallStateEnum {
12648 #[serde(rename = "hostRestarted")]
12649 #[strum(serialize = "hostRestarted")]
12650 HostRestarted,
12651 #[serde(rename = "imageActive")]
12652 #[strum(serialize = "imageActive")]
12653 ImageActive,
12654 /// This variant handles values not known at compile time.
12655 #[serde(untagged)]
12656 #[strum(serialize = "__OTHER__")]
12657 Other_(String),
12658}
12659/// The integrity validation status.
12660///
12661/// Possible values:
12662/// - `validated`: The update is successfully validated.
12663/// - `keyNotFound`: The integrity can not be verified since a public key to
12664/// verify the update cannot be found.
12665/// - `keyRevoked`: A public key to verify the update has been revoked.
12666/// - `keyExpired`: A public key to verify the update is expired.
12667/// - `digestMismatch`: A digital signature of the update does not match.
12668/// - `notEnoughSignatures`: Not enough signed signatures on the update.
12669/// - `validationError`: The integrity validation failed.
12670#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12671pub enum HostPatchManagerIntegrityStatusEnum {
12672 #[serde(rename = "validated")]
12673 #[strum(serialize = "validated")]
12674 Validated,
12675 #[serde(rename = "keyNotFound")]
12676 #[strum(serialize = "keyNotFound")]
12677 KeyNotFound,
12678 #[serde(rename = "keyRevoked")]
12679 #[strum(serialize = "keyRevoked")]
12680 KeyRevoked,
12681 #[serde(rename = "keyExpired")]
12682 #[strum(serialize = "keyExpired")]
12683 KeyExpired,
12684 #[serde(rename = "digestMismatch")]
12685 #[strum(serialize = "digestMismatch")]
12686 DigestMismatch,
12687 #[serde(rename = "notEnoughSignatures")]
12688 #[strum(serialize = "notEnoughSignatures")]
12689 NotEnoughSignatures,
12690 #[serde(rename = "validationError")]
12691 #[strum(serialize = "validationError")]
12692 ValidationError,
12693 /// This variant handles values not known at compile time.
12694 #[serde(untagged)]
12695 #[strum(serialize = "__OTHER__")]
12696 Other_(String),
12697}
12698/// Reasons why an update is not applicable to the ESX host.
12699///
12700/// Possible values:
12701/// - `obsoleted`: The update is made obsolete by other patches installed on the host.
12702/// - `missingPatch`: The update depends on another update that is neither installed
12703/// nor in the scanned list of updates.
12704/// - `missingLib`: The update depends on certain libraries or RPMs that are not
12705/// available.
12706/// - `hasDependentPatch`: The update depends on an update that is not installed but is
12707/// in the scanned list of updates.
12708/// - `conflictPatch`: The update conflicts with certain updates that are already
12709/// installed on the host.
12710/// - `conflictLib`: The update conflicts with RPMs or libraries installed on the
12711/// host.
12712#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12713pub enum HostPatchManagerReasonEnum {
12714 #[serde(rename = "obsoleted")]
12715 #[strum(serialize = "obsoleted")]
12716 Obsoleted,
12717 #[serde(rename = "missingPatch")]
12718 #[strum(serialize = "missingPatch")]
12719 MissingPatch,
12720 #[serde(rename = "missingLib")]
12721 #[strum(serialize = "missingLib")]
12722 MissingLib,
12723 #[serde(rename = "hasDependentPatch")]
12724 #[strum(serialize = "hasDependentPatch")]
12725 HasDependentPatch,
12726 #[serde(rename = "conflictPatch")]
12727 #[strum(serialize = "conflictPatch")]
12728 ConflictPatch,
12729 #[serde(rename = "conflictLib")]
12730 #[strum(serialize = "conflictLib")]
12731 ConflictLib,
12732 /// This variant handles values not known at compile time.
12733 #[serde(untagged)]
12734 #[strum(serialize = "__OTHER__")]
12735 Other_(String),
12736}
12737/// Possible values:
12738/// - `userOptOut`: Indicates that the user has opted out the Physical NIC from resource pool
12739/// based scheduling.
12740/// - `hardwareUnsupported`: Indicates that the NIC device does is not capable of resource pool
12741/// based scheduling.
12742#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12743pub enum PhysicalNicResourcePoolSchedulerDisallowedReasonEnum {
12744 #[serde(rename = "userOptOut")]
12745 #[strum(serialize = "userOptOut")]
12746 UserOptOut,
12747 #[serde(rename = "hardwareUnsupported")]
12748 #[strum(serialize = "hardwareUnsupported")]
12749 HardwareUnsupported,
12750 /// This variant handles values not known at compile time.
12751 #[serde(untagged)]
12752 #[strum(serialize = "__OTHER__")]
12753 Other_(String),
12754}
12755/// Set of possible values for *PhysicalNic.vmDirectPathGen2SupportedMode*.
12756///
12757/// Possible values:
12758/// - `upt`
12759#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12760pub enum PhysicalNicVmDirectPathGen2SupportedModeEnum {
12761 #[serde(rename = "upt")]
12762 #[strum(serialize = "upt")]
12763 Upt,
12764 /// This variant handles values not known at compile time.
12765 #[serde(untagged)]
12766 #[strum(serialize = "__OTHER__")]
12767 Other_(String),
12768}
12769/// The type of component connected to a port group.
12770///
12771/// Possible values:
12772/// - `virtualMachine`: A virtual machine is connected to this port group.
12773/// - `systemManagement`: A system management entity (service console)
12774/// is connected to this port group.
12775/// - `host`: The VMkernel is connected to this port group.
12776/// - `unknown`: This port group serves an entity of unspecified kind.
12777#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12778pub enum PortGroupConnecteeTypeEnum {
12779 #[serde(rename = "virtualMachine")]
12780 #[strum(serialize = "virtualMachine")]
12781 VirtualMachine,
12782 #[serde(rename = "systemManagement")]
12783 #[strum(serialize = "systemManagement")]
12784 SystemManagement,
12785 #[serde(rename = "host")]
12786 #[strum(serialize = "host")]
12787 Host,
12788 #[serde(rename = "unknown")]
12789 #[strum(serialize = "unknown")]
12790 Unknown,
12791 /// This variant handles values not known at compile time.
12792 #[serde(untagged)]
12793 #[strum(serialize = "__OTHER__")]
12794 Other_(String),
12795}
12796/// Deprecated from all vmodl version above @released("6.0").
12797///
12798/// ProtocolEndpoint Type.
12799///
12800/// Possible values:
12801/// - `block`
12802/// - `nas`
12803#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12804pub enum HostProtocolEndpointPeTypeEnum {
12805 #[serde(rename = "block")]
12806 #[strum(serialize = "block")]
12807 Block,
12808 #[serde(rename = "nas")]
12809 #[strum(serialize = "nas")]
12810 Nas,
12811 /// This variant handles values not known at compile time.
12812 #[serde(untagged)]
12813 #[strum(serialize = "__OTHER__")]
12814 Other_(String),
12815}
12816/// ProtocolEndpoint type.
12817///
12818/// Possible values:
12819/// - `scsi`
12820/// - `nfs`
12821/// - `nfs4x`
12822#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12823pub enum HostProtocolEndpointProtocolEndpointTypeEnum {
12824 #[serde(rename = "scsi")]
12825 #[strum(serialize = "scsi")]
12826 Scsi,
12827 #[serde(rename = "nfs")]
12828 #[strum(serialize = "nfs")]
12829 Nfs,
12830 #[serde(rename = "nfs4x")]
12831 #[strum(serialize = "nfs4x")]
12832 Nfs4X,
12833 /// This variant handles values not known at compile time.
12834 #[serde(untagged)]
12835 #[strum(serialize = "__OTHER__")]
12836 Other_(String),
12837}
12838/// PTP capable network device type.
12839///
12840/// Possible values:
12841/// - `none`: No device.
12842/// - `virtualNic`: Virtual network adapter.
12843/// - `pciPassthruNic`: A network PCI device capable of PTP hardware timestamping,
12844/// enabled for passthru.
12845///
12846/// See *HostPciPassthruSystem*
12847/// for information on PCI devices enabled for passthru available
12848/// on the host.
12849///
12850/// ***Since:*** vSphere API Release 7.0.3.0
12851#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12852pub enum HostPtpConfigDeviceTypeEnum {
12853 #[serde(rename = "none")]
12854 #[strum(serialize = "none")]
12855 None,
12856 #[serde(rename = "virtualNic")]
12857 #[strum(serialize = "virtualNic")]
12858 VirtualNic,
12859 #[serde(rename = "pciPassthruNic")]
12860 #[strum(serialize = "pciPassthruNic")]
12861 PciPassthruNic,
12862 /// This variant handles values not known at compile time.
12863 #[serde(untagged)]
12864 #[strum(serialize = "__OTHER__")]
12865 Other_(String),
12866}
12867/// Possible values:
12868/// - `nvmeQualifiedName`: The NVMe Qualified Name (NQN) of this host.
12869/// - `vvolNvmeQualifiedName`: The NVMe Qualified Name (NQN) of this host used by Vvol.
12870///
12871/// ***Since:*** vSphere API Release 8.0.0.0
12872///
12873/// ***Since:*** vSphere API Release 7.0.3.0
12874#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12875pub enum HostQualifiedNameTypeEnum {
12876 #[serde(rename = "nvmeQualifiedName")]
12877 #[strum(serialize = "nvmeQualifiedName")]
12878 NvmeQualifiedName,
12879 #[serde(rename = "vvolNvmeQualifiedName")]
12880 #[strum(serialize = "vvolNvmeQualifiedName")]
12881 VvolNvmeQualifiedName,
12882 /// This variant handles values not known at compile time.
12883 #[serde(untagged)]
12884 #[strum(serialize = "__OTHER__")]
12885 Other_(String),
12886}
12887/// Possible RDMA device connection states.
12888///
12889/// These correspond
12890/// to possible link states as defined by the
12891/// Infiniband (TM) specification.
12892///
12893/// Further details can be found in:
12894/// - "Infiniband (TM) Architecture Specification, Volume 1"
12895/// section 7.2 "Link states"
12896///
12897/// Possible values:
12898/// - `unknown`: Connection state unknown.
12899///
12900/// Indicates that the driver returned
12901/// unexpected or no connection state information.
12902/// - `down`: Device down.
12903///
12904/// Indicates that both the logical link and
12905/// underlying physical link are down. Packets
12906/// are discarded.
12907/// - `init`: Device initializing.
12908///
12909/// Indicates that the physical link is up, but
12910/// the logical link is still initializing.
12911/// Only subnet management and flow control link
12912/// packets can be received and transmitted.
12913/// - `armed`: Device armed.
12914///
12915/// Indicates that the physical link is up, but
12916/// the logical link is not yet fully configured.
12917/// Packets can be received, but non-SMPs
12918/// (subnet management packets) to be sent are discarded.
12919/// - `active`: Device active.
12920///
12921/// Indicates that both the physical and logical
12922/// link are up. Packets can be transmitted and received.
12923/// - `activeDefer`: Device in active defer state.
12924///
12925/// Indicates that the logical link was active, but the
12926/// physical link has suffered a failure. If it recovers
12927/// within a timeout, the connection state will return to active,
12928/// otherwise it will move to down.
12929#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12930pub enum HostRdmaDeviceConnectionStateEnum {
12931 #[serde(rename = "unknown")]
12932 #[strum(serialize = "unknown")]
12933 Unknown,
12934 #[serde(rename = "down")]
12935 #[strum(serialize = "down")]
12936 Down,
12937 #[serde(rename = "init")]
12938 #[strum(serialize = "init")]
12939 Init,
12940 #[serde(rename = "armed")]
12941 #[strum(serialize = "armed")]
12942 Armed,
12943 #[serde(rename = "active")]
12944 #[strum(serialize = "active")]
12945 Active,
12946 #[serde(rename = "activeDefer")]
12947 #[strum(serialize = "activeDefer")]
12948 ActiveDefer,
12949 /// This variant handles values not known at compile time.
12950 #[serde(untagged)]
12951 #[strum(serialize = "__OTHER__")]
12952 Other_(String),
12953}
12954/// Enumeration of network protocols supported by RDMA capable NIC.
12955///
12956/// Possible values:
12957/// - `RoCEv2`: Supported protocol is RDMA over Converged Ethernet (RoCEv2) version 2.
12958#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12959pub enum RdmaProtocolEnum {
12960 RoCEv2,
12961 /// This variant handles values not known at compile time.
12962 #[serde(untagged)]
12963 #[strum(serialize = "__OTHER__")]
12964 Other_(String),
12965}
12966/// Enumeration of port directions.
12967///
12968/// Possible values:
12969/// - `inbound`
12970/// - `outbound`
12971#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12972pub enum HostFirewallRuleDirectionEnum {
12973 #[serde(rename = "inbound")]
12974 #[strum(serialize = "inbound")]
12975 Inbound,
12976 #[serde(rename = "outbound")]
12977 #[strum(serialize = "outbound")]
12978 Outbound,
12979 /// This variant handles values not known at compile time.
12980 #[serde(untagged)]
12981 #[strum(serialize = "__OTHER__")]
12982 Other_(String),
12983}
12984/// Enumeration of port types.
12985///
12986/// Possible values:
12987/// - `src`
12988/// - `dst`
12989#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
12990pub enum HostFirewallRulePortTypeEnum {
12991 #[serde(rename = "src")]
12992 #[strum(serialize = "src")]
12993 Src,
12994 #[serde(rename = "dst")]
12995 #[strum(serialize = "dst")]
12996 Dst,
12997 /// This variant handles values not known at compile time.
12998 #[serde(untagged)]
12999 #[strum(serialize = "__OTHER__")]
13000 Other_(String),
13001}
13002/// Set of valid port protocols.
13003///
13004/// Possible values:
13005/// - `tcp`
13006/// - `udp`
13007#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13008pub enum HostFirewallRuleProtocolEnum {
13009 #[serde(rename = "tcp")]
13010 #[strum(serialize = "tcp")]
13011 Tcp,
13012 #[serde(rename = "udp")]
13013 #[strum(serialize = "udp")]
13014 Udp,
13015 /// This variant handles values not known at compile time.
13016 #[serde(untagged)]
13017 #[strum(serialize = "__OTHER__")]
13018 Other_(String),
13019}
13020/// Define the instance state type
13021///
13022/// Possible values:
13023/// - `inactive`: The instance is deleted or not running
13024/// - `active`: The instance is running
13025/// - `deactivating`: The instance is in the progress of asynchronous deletion
13026/// - `activating`: Reserved state for future proofing asynchronous creation
13027#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13028pub enum HostRuntimeInfoNetStackInstanceRuntimeInfoStateEnum {
13029 #[serde(rename = "inactive")]
13030 #[strum(serialize = "inactive")]
13031 Inactive,
13032 #[serde(rename = "active")]
13033 #[strum(serialize = "active")]
13034 Active,
13035 #[serde(rename = "deactivating")]
13036 #[strum(serialize = "deactivating")]
13037 Deactivating,
13038 #[serde(rename = "activating")]
13039 #[strum(serialize = "activating")]
13040 Activating,
13041 /// This variant handles values not known at compile time.
13042 #[serde(untagged)]
13043 #[strum(serialize = "__OTHER__")]
13044 Other_(String),
13045}
13046/// Valid protection modes for persistent state encryption.
13047///
13048/// Possible values:
13049/// - `none`: Encryption is not protected.
13050/// - `tpm`: Encryption is TPM protected.
13051///
13052/// ***Since:*** vSphere API Release 7.0.3.0
13053#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13054pub enum HostRuntimeInfoStateEncryptionInfoProtectionModeEnum {
13055 #[serde(rename = "none")]
13056 #[strum(serialize = "none")]
13057 None,
13058 #[serde(rename = "tpm")]
13059 #[strum(serialize = "tpm")]
13060 Tpm,
13061 /// This variant handles values not known at compile time.
13062 #[serde(untagged)]
13063 #[strum(serialize = "__OTHER__")]
13064 Other_(String),
13065}
13066/// Defines if the host is ready for NVDS to VDS migration.
13067///
13068/// Possible values:
13069/// - `ready`: The host is ready for NVDS to VDS migration.
13070/// - `notNeeded`: The host does not need NVDS to VDS migration
13071/// - `unknown`: The host is disconnected from VC.
13072///
13073/// ***Since:*** vSphere API Release 7.0.2.0
13074#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13075pub enum HostRuntimeInfoStatelessNvdsMigrationStateEnum {
13076 #[serde(rename = "ready")]
13077 #[strum(serialize = "ready")]
13078 Ready,
13079 #[serde(rename = "notNeeded")]
13080 #[strum(serialize = "notNeeded")]
13081 NotNeeded,
13082 #[serde(rename = "unknown")]
13083 #[strum(serialize = "unknown")]
13084 Unknown,
13085 /// This variant handles values not known at compile time.
13086 #[serde(untagged)]
13087 #[strum(serialize = "__OTHER__")]
13088 Other_(String),
13089}
13090/// The types of disk drives.
13091///
13092/// Possible values:
13093/// - `native512`: 512 native sector size drive.
13094/// - `emulated512`: 4K sector size drive in 512 emulation mode.
13095/// - `native4k`: 4K native sector size drive.
13096/// - `SoftwareEmulated4k`: Software emulated 4k.
13097/// - `unknown`: Unknown type.
13098#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13099pub enum ScsiDiskTypeEnum {
13100 #[serde(rename = "native512")]
13101 #[strum(serialize = "native512")]
13102 Native512,
13103 #[serde(rename = "emulated512")]
13104 #[strum(serialize = "emulated512")]
13105 Emulated512,
13106 #[serde(rename = "native4k")]
13107 #[strum(serialize = "native4k")]
13108 Native4K,
13109 #[serde(rename = "SoftwareEmulated4k")]
13110 #[strum(serialize = "SoftwareEmulated4k")]
13111 SoftwareEmulated4K,
13112 #[serde(rename = "unknown")]
13113 #[strum(serialize = "unknown")]
13114 Unknown,
13115 /// This variant handles values not known at compile time.
13116 #[serde(untagged)]
13117 #[strum(serialize = "__OTHER__")]
13118 Other_(String),
13119}
13120/// An indicator of the utility of Descriptor in being used as an
13121/// identifier that is stable, unique, and correlatable.
13122///
13123/// Possible values:
13124/// - `highQuality`: The Descriptor has an identifier that is useful for identification
13125/// and correlation across hosts.
13126/// - `mediumQuality`: The Descriptor has an identifier that may be used for identification
13127/// and correlation across hosts.
13128/// - `lowQuality`: The Descriptor has an identifier that should not be used for
13129/// identification and correlation across hosts.
13130/// - `unknownQuality`: The Descriptor has an identifier that may or may not be useful for
13131/// identification and correlation across hosts.
13132#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13133pub enum ScsiLunDescriptorQualityEnum {
13134 #[serde(rename = "highQuality")]
13135 #[strum(serialize = "highQuality")]
13136 HighQuality,
13137 #[serde(rename = "mediumQuality")]
13138 #[strum(serialize = "mediumQuality")]
13139 MediumQuality,
13140 #[serde(rename = "lowQuality")]
13141 #[strum(serialize = "lowQuality")]
13142 LowQuality,
13143 #[serde(rename = "unknownQuality")]
13144 #[strum(serialize = "unknownQuality")]
13145 UnknownQuality,
13146 /// This variant handles values not known at compile time.
13147 #[serde(untagged)]
13148 #[strum(serialize = "__OTHER__")]
13149 Other_(String),
13150}
13151/// The list of Device Protocols.
13152///
13153/// Device protocol could be either NVMe or SCSI
13154///
13155/// Possible values:
13156/// - `NVMe`
13157/// - `SCSI`
13158///
13159/// ***Since:*** vSphere API Release 8.0.1.0
13160#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13161pub enum DeviceProtocolEnum {
13162 #[serde(rename = "NVMe")]
13163 #[strum(serialize = "NVMe")]
13164 NvMe,
13165 #[serde(rename = "SCSI")]
13166 #[strum(serialize = "SCSI")]
13167 Scsi,
13168 /// This variant handles values not known at compile time.
13169 #[serde(untagged)]
13170 #[strum(serialize = "__OTHER__")]
13171 Other_(String),
13172}
13173/// Possible values:
13174/// - `LUN_RESERVED_UNKNOWN`
13175/// - `LUN_RESERVED_YES`
13176/// - `LUN_RESERVED_NO`
13177/// - `LUN_RESERVED_NOT_SUPPORTED`
13178///
13179/// ***Since:*** vSphere API Release 8.0.3.0
13180#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13181pub enum ScsiLunLunReservationStatusEnum {
13182 #[serde(rename = "LUN_RESERVED_UNKNOWN")]
13183 #[strum(serialize = "LUN_RESERVED_UNKNOWN")]
13184 LunReservedUnknown,
13185 #[serde(rename = "LUN_RESERVED_YES")]
13186 #[strum(serialize = "LUN_RESERVED_YES")]
13187 LunReservedYes,
13188 #[serde(rename = "LUN_RESERVED_NO")]
13189 #[strum(serialize = "LUN_RESERVED_NO")]
13190 LunReservedNo,
13191 #[serde(rename = "LUN_RESERVED_NOT_SUPPORTED")]
13192 #[strum(serialize = "LUN_RESERVED_NOT_SUPPORTED")]
13193 LunReservedNotSupported,
13194 /// This variant handles values not known at compile time.
13195 #[serde(untagged)]
13196 #[strum(serialize = "__OTHER__")]
13197 Other_(String),
13198}
13199/// The list of SCSI device types.
13200///
13201/// These values correspond to values
13202/// published in the SCSI specification.
13203///
13204/// Possible values:
13205/// - `disk`
13206/// - `tape`
13207/// - `printer`
13208/// - `processor`
13209/// - `worm`
13210/// - `cdrom`
13211/// - `scanner`
13212/// - `opticalDevice`
13213/// - `mediaChanger`
13214/// - `communications`
13215/// - `storageArrayController`
13216/// - `enclosure`
13217/// - `unknown`
13218#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13219pub enum ScsiLunTypeEnum {
13220 #[serde(rename = "disk")]
13221 #[strum(serialize = "disk")]
13222 Disk,
13223 #[serde(rename = "tape")]
13224 #[strum(serialize = "tape")]
13225 Tape,
13226 #[serde(rename = "printer")]
13227 #[strum(serialize = "printer")]
13228 Printer,
13229 #[serde(rename = "processor")]
13230 #[strum(serialize = "processor")]
13231 Processor,
13232 #[serde(rename = "worm")]
13233 #[strum(serialize = "worm")]
13234 Worm,
13235 #[serde(rename = "cdrom")]
13236 #[strum(serialize = "cdrom")]
13237 Cdrom,
13238 #[serde(rename = "scanner")]
13239 #[strum(serialize = "scanner")]
13240 Scanner,
13241 #[serde(rename = "opticalDevice")]
13242 #[strum(serialize = "opticalDevice")]
13243 OpticalDevice,
13244 #[serde(rename = "mediaChanger")]
13245 #[strum(serialize = "mediaChanger")]
13246 MediaChanger,
13247 #[serde(rename = "communications")]
13248 #[strum(serialize = "communications")]
13249 Communications,
13250 #[serde(rename = "storageArrayController")]
13251 #[strum(serialize = "storageArrayController")]
13252 StorageArrayController,
13253 #[serde(rename = "enclosure")]
13254 #[strum(serialize = "enclosure")]
13255 Enclosure,
13256 #[serde(rename = "unknown")]
13257 #[strum(serialize = "unknown")]
13258 Unknown,
13259 /// This variant handles values not known at compile time.
13260 #[serde(untagged)]
13261 #[strum(serialize = "__OTHER__")]
13262 Other_(String),
13263}
13264/// The Operational state of the LUN
13265///
13266/// Possible values:
13267/// - `unknownState`: The LUN state is unknown.
13268/// - `ok`: The LUN is on and available.
13269/// - `error`: The LUN is dead and/or not reachable.
13270/// - `off`: The LUN is off.
13271/// - `quiesced`: The LUN is inactive.
13272/// - `degraded`: One or more paths to the LUN are down, but I/O
13273/// is still possible.
13274///
13275/// Further path failures may
13276/// result in lost connectivity.
13277/// - `lostCommunication`: No more paths are available to the LUN.
13278/// - `timeout`: All Paths have been down for the timeout condition
13279/// determined by a user-configurable host advanced option.
13280#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13281pub enum ScsiLunStateEnum {
13282 #[serde(rename = "unknownState")]
13283 #[strum(serialize = "unknownState")]
13284 UnknownState,
13285 #[serde(rename = "ok")]
13286 #[strum(serialize = "ok")]
13287 Ok,
13288 #[serde(rename = "error")]
13289 #[strum(serialize = "error")]
13290 Error,
13291 #[serde(rename = "off")]
13292 #[strum(serialize = "off")]
13293 Off,
13294 #[serde(rename = "quiesced")]
13295 #[strum(serialize = "quiesced")]
13296 Quiesced,
13297 #[serde(rename = "degraded")]
13298 #[strum(serialize = "degraded")]
13299 Degraded,
13300 #[serde(rename = "lostCommunication")]
13301 #[strum(serialize = "lostCommunication")]
13302 LostCommunication,
13303 #[serde(rename = "timeout")]
13304 #[strum(serialize = "timeout")]
13305 Timeout,
13306 /// This variant handles values not known at compile time.
13307 #[serde(untagged)]
13308 #[strum(serialize = "__OTHER__")]
13309 Other_(String),
13310}
13311/// Storage array hardware acceleration support status.
13312///
13313/// When a host boots, the support status is unknown.
13314/// As a host attempts hardware-accelerated operations,
13315/// it determines whether the storage device supports hardware acceleration
13316/// and sets the *ScsiLun.vStorageSupport* property accordingly.
13317///
13318/// Possible values:
13319/// - `vStorageSupported`: Storage device supports hardware acceleration.
13320///
13321/// The ESX host will use the feature to offload certain
13322/// storage-related operations to the device.
13323/// - `vStorageUnsupported`: Storage device does not support hardware acceleration.
13324///
13325/// The ESX host will handle all storage-related operations.
13326/// - `vStorageUnknown`: Initial support status value.
13327#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13328pub enum ScsiLunVStorageSupportStatusEnum {
13329 #[serde(rename = "vStorageSupported")]
13330 #[strum(serialize = "vStorageSupported")]
13331 VStorageSupported,
13332 #[serde(rename = "vStorageUnsupported")]
13333 #[strum(serialize = "vStorageUnsupported")]
13334 VStorageUnsupported,
13335 #[serde(rename = "vStorageUnknown")]
13336 #[strum(serialize = "vStorageUnknown")]
13337 VStorageUnknown,
13338 /// This variant handles values not known at compile time.
13339 #[serde(untagged)]
13340 #[strum(serialize = "__OTHER__")]
13341 Other_(String),
13342}
13343/// Set of valid service policy strings.
13344///
13345/// Possible values:
13346/// - `on`: Service should be started when the host starts up.
13347/// - `automatic`: Service should run if and only if it has open firewall ports.
13348/// - `off`: Service should not be started when the host starts up.
13349#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13350pub enum HostServicePolicyEnum {
13351 #[serde(rename = "on")]
13352 #[strum(serialize = "on")]
13353 On,
13354 #[serde(rename = "automatic")]
13355 #[strum(serialize = "automatic")]
13356 Automatic,
13357 #[serde(rename = "off")]
13358 #[strum(serialize = "off")]
13359 Off,
13360 /// This variant handles values not known at compile time.
13361 #[serde(untagged)]
13362 #[strum(serialize = "__OTHER__")]
13363 Other_(String),
13364}
13365/// Possible values:
13366/// - `uninitialized`
13367/// - `initialized`
13368/// - `working`
13369///
13370/// ***Since:*** vSphere API Release 7.0.1.0
13371#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13372pub enum HostSevInfoSevStateEnum {
13373 #[serde(rename = "uninitialized")]
13374 #[strum(serialize = "uninitialized")]
13375 Uninitialized,
13376 #[serde(rename = "initialized")]
13377 #[strum(serialize = "initialized")]
13378 Initialized,
13379 #[serde(rename = "working")]
13380 #[strum(serialize = "working")]
13381 Working,
13382 /// This variant handles values not known at compile time.
13383 #[serde(untagged)]
13384 #[strum(serialize = "__OTHER__")]
13385 Other_(String),
13386}
13387/// Flexible Launch Enclave (FLC) modes.
13388///
13389/// Possible values:
13390/// - `off`: Flexible Launch Enclave (FLC) is not available on the host.
13391///
13392/// The
13393/// "launch enclave MSRs" are initialized with Intel's public key hash.
13394/// - `locked`: FLC is available and the "launch Enclave MSRs" are locked and
13395/// initialized with the provided public key hash.
13396/// - `unlocked`: FLC is available and the "launch enclave MSRs" are writeable and
13397/// initialized with Intel's public key hash.
13398#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13399pub enum HostSgxInfoFlcModesEnum {
13400 #[serde(rename = "off")]
13401 #[strum(serialize = "off")]
13402 Off,
13403 #[serde(rename = "locked")]
13404 #[strum(serialize = "locked")]
13405 Locked,
13406 #[serde(rename = "unlocked")]
13407 #[strum(serialize = "unlocked")]
13408 Unlocked,
13409 /// This variant handles values not known at compile time.
13410 #[serde(untagged)]
13411 #[strum(serialize = "__OTHER__")]
13412 Other_(String),
13413}
13414/// Host SGX states.
13415///
13416/// Possible values:
13417/// - `notPresent`: SGX is not present in the CPU.
13418/// - `disabledBIOS`: SGX is disabled in the BIOS.
13419/// - `disabledCFW101`: SGX is disabled because CPU erratum CFW101 is present.
13420/// - `disabledCPUMismatch`: SGX is disabled due to a mismatch in the SGX capabilities
13421/// exposed by different CPUs.
13422/// - `disabledNoFLC`: SGX is disabled because the CPU does not support FLC.
13423/// - `disabledNUMAUnsup`: SGX is disabled because the host uses NUMA, which is not
13424/// supported with SGX.
13425/// - `disabledMaxEPCRegs`: SGX is disabled because the host exceeds the maximum supported
13426/// number of EPC regions.
13427/// - `enabled`: SGX is enabled.
13428#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13429pub enum HostSgxInfoSgxStatesEnum {
13430 #[serde(rename = "notPresent")]
13431 #[strum(serialize = "notPresent")]
13432 NotPresent,
13433 #[serde(rename = "disabledBIOS")]
13434 #[strum(serialize = "disabledBIOS")]
13435 DisabledBios,
13436 #[serde(rename = "disabledCFW101")]
13437 #[strum(serialize = "disabledCFW101")]
13438 DisabledCfw101,
13439 #[serde(rename = "disabledCPUMismatch")]
13440 #[strum(serialize = "disabledCPUMismatch")]
13441 DisabledCpuMismatch,
13442 #[serde(rename = "disabledNoFLC")]
13443 #[strum(serialize = "disabledNoFLC")]
13444 DisabledNoFlc,
13445 #[serde(rename = "disabledNUMAUnsup")]
13446 #[strum(serialize = "disabledNUMAUnsup")]
13447 DisabledNumaUnsup,
13448 #[serde(rename = "disabledMaxEPCRegs")]
13449 #[strum(serialize = "disabledMaxEPCRegs")]
13450 DisabledMaxEpcRegs,
13451 #[serde(rename = "enabled")]
13452 #[strum(serialize = "enabled")]
13453 Enabled,
13454 /// This variant handles values not known at compile time.
13455 #[serde(untagged)]
13456 #[strum(serialize = "__OTHER__")]
13457 Other_(String),
13458}
13459/// SGX registration status for ESX host.
13460///
13461/// Possible values:
13462/// - `notApplicable`: SGX is not available or the host is unisocket.
13463/// - `incomplete`: SGX registration is incomplete.
13464/// - `complete`: SGX registration is complete.
13465///
13466/// ***Since:*** vSphere API Release 8.0.0.1
13467#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13468pub enum HostSgxRegistrationInfoRegistrationStatusEnum {
13469 #[serde(rename = "notApplicable")]
13470 #[strum(serialize = "notApplicable")]
13471 NotApplicable,
13472 #[serde(rename = "incomplete")]
13473 #[strum(serialize = "incomplete")]
13474 Incomplete,
13475 #[serde(rename = "complete")]
13476 #[strum(serialize = "complete")]
13477 Complete,
13478 /// This variant handles values not known at compile time.
13479 #[serde(untagged)]
13480 #[strum(serialize = "__OTHER__")]
13481 Other_(String),
13482}
13483/// SGX host registration type.
13484///
13485/// Possible values:
13486/// - `manifest`: Indicates that an Initial Platform Establishment
13487/// or TCB recovery registration is pending.
13488/// - `addPackage`: Indicates that new CPU package was added.
13489///
13490/// ***Since:*** vSphere API Release 8.0.0.1
13491#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13492pub enum HostSgxRegistrationInfoRegistrationTypeEnum {
13493 #[serde(rename = "manifest")]
13494 #[strum(serialize = "manifest")]
13495 Manifest,
13496 #[serde(rename = "addPackage")]
13497 #[strum(serialize = "addPackage")]
13498 AddPackage,
13499 /// This variant handles values not known at compile time.
13500 #[serde(untagged)]
13501 #[strum(serialize = "__OTHER__")]
13502 Other_(String),
13503}
13504/// SNMP Agent supported capabilities enum
13505///
13506/// Possible values:
13507/// - `COMPLETE`: Implements test notifications and allows agent configuration
13508/// - `DIAGNOSTICS`: Implements only test notification capability only
13509/// - `CONFIGURATION`: Allows for agent configuration only
13510#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13511pub enum HostSnmpAgentCapabilityEnum {
13512 #[serde(rename = "COMPLETE")]
13513 #[strum(serialize = "COMPLETE")]
13514 Complete,
13515 #[serde(rename = "DIAGNOSTICS")]
13516 #[strum(serialize = "DIAGNOSTICS")]
13517 Diagnostics,
13518 #[serde(rename = "CONFIGURATION")]
13519 #[strum(serialize = "CONFIGURATION")]
13520 Configuration,
13521 /// This variant handles values not known at compile time.
13522 #[serde(untagged)]
13523 #[strum(serialize = "__OTHER__")]
13524 Other_(String),
13525}
13526/// These are the constraint relationships between software packages.
13527///
13528/// Possible values:
13529/// - `equals`
13530/// - `lessThan`
13531/// - `lessThanEqual`
13532/// - `greaterThanEqual`
13533/// - `greaterThan`
13534#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13535pub enum SoftwarePackageConstraintEnum {
13536 #[serde(rename = "equals")]
13537 #[strum(serialize = "equals")]
13538 Equals,
13539 #[serde(rename = "lessThan")]
13540 #[strum(serialize = "lessThan")]
13541 LessThan,
13542 #[serde(rename = "lessThanEqual")]
13543 #[strum(serialize = "lessThanEqual")]
13544 LessThanEqual,
13545 #[serde(rename = "greaterThanEqual")]
13546 #[strum(serialize = "greaterThanEqual")]
13547 GreaterThanEqual,
13548 #[serde(rename = "greaterThan")]
13549 #[strum(serialize = "greaterThan")]
13550 GreaterThan,
13551 /// This variant handles values not known at compile time.
13552 #[serde(untagged)]
13553 #[strum(serialize = "__OTHER__")]
13554 Other_(String),
13555}
13556/// Possible values:
13557/// - `bootbank`: This package is installed into bootbank in storage.
13558/// - `tools`: This package is installed into tools partition in storage.
13559/// - `meta`: This package contains install related data without
13560/// content to install.
13561#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13562pub enum SoftwarePackageVibTypeEnum {
13563 #[serde(rename = "bootbank")]
13564 #[strum(serialize = "bootbank")]
13565 Bootbank,
13566 #[serde(rename = "tools")]
13567 #[strum(serialize = "tools")]
13568 Tools,
13569 #[serde(rename = "meta")]
13570 #[strum(serialize = "meta")]
13571 Meta,
13572 /// This variant handles values not known at compile time.
13573 #[serde(untagged)]
13574 #[strum(serialize = "__OTHER__")]
13575 Other_(String),
13576}
13577/// The set of supported host bus adapter protocols.
13578///
13579/// Possible values:
13580/// - `scsi`: The Small Computer System Interface (SCSI) protocol.
13581/// - `nvme`: The Non-Volatile Memory Express (NVME) protocol.
13582#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13583pub enum HostStorageProtocolEnum {
13584 #[serde(rename = "scsi")]
13585 #[strum(serialize = "scsi")]
13586 Scsi,
13587 #[serde(rename = "nvme")]
13588 #[strum(serialize = "nvme")]
13589 Nvme,
13590 /// This variant handles values not known at compile time.
13591 #[serde(untagged)]
13592 #[strum(serialize = "__OTHER__")]
13593 Other_(String),
13594}
13595/// Possible values:
13596/// - `AssetTag`: The Asset tag of the system
13597/// - `ServiceTag`: The Service tag of the system
13598/// - `OemSpecificString`: OEM specific string
13599/// - `EnclosureSerialNumberTag`: The Enclosure Serial Number tag of the system
13600/// - `SerialNumberTag`: The Serial Number tag of the system
13601#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13602pub enum HostSystemIdentificationInfoIdentifierEnum {
13603 AssetTag,
13604 ServiceTag,
13605 OemSpecificString,
13606 EnclosureSerialNumberTag,
13607 SerialNumberTag,
13608 /// This variant handles values not known at compile time.
13609 #[serde(untagged)]
13610 #[strum(serialize = "__OTHER__")]
13611 Other_(String),
13612}
13613/// Possible values:
13614/// - `initializing`
13615/// - `initialized`
13616/// - `configured`
13617/// - `ready`
13618///
13619/// ***Since:*** vSphere API Release 9.0.0.0
13620#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13621pub enum HostTdxInfoTdxStateEnum {
13622 #[serde(rename = "initializing")]
13623 #[strum(serialize = "initializing")]
13624 Initializing,
13625 #[serde(rename = "initialized")]
13626 #[strum(serialize = "initialized")]
13627 Initialized,
13628 #[serde(rename = "configured")]
13629 #[strum(serialize = "configured")]
13630 Configured,
13631 #[serde(rename = "ready")]
13632 #[strum(serialize = "ready")]
13633 Ready,
13634 /// This variant handles values not known at compile time.
13635 #[serde(untagged)]
13636 #[strum(serialize = "__OTHER__")]
13637 Other_(String),
13638}
13639/// Status constants of TPM attestation.
13640///
13641/// Possible values:
13642/// - `notAccepted`: TPM attestation failed.
13643/// - `accepted`: TPM attestation succeeded.
13644#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13645pub enum HostTpmAttestationInfoAcceptanceStatusEnum {
13646 #[serde(rename = "notAccepted")]
13647 #[strum(serialize = "notAccepted")]
13648 NotAccepted,
13649 #[serde(rename = "accepted")]
13650 #[strum(serialize = "accepted")]
13651 Accepted,
13652 /// This variant handles values not known at compile time.
13653 #[serde(untagged)]
13654 #[strum(serialize = "__OTHER__")]
13655 Other_(String),
13656}
13657/// Possible values:
13658/// - `attested`: Attestation succeeded.
13659/// - `notAttested`: Attestation failed.
13660/// - `unknown`: Attestation status is unknown.
13661///
13662/// ***Since:*** vSphere API Release 7.0.1.0
13663#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13664pub enum HostTrustAuthorityAttestationInfoAttestationStatusEnum {
13665 #[serde(rename = "attested")]
13666 #[strum(serialize = "attested")]
13667 Attested,
13668 #[serde(rename = "notAttested")]
13669 #[strum(serialize = "notAttested")]
13670 NotAttested,
13671 #[serde(rename = "unknown")]
13672 #[strum(serialize = "unknown")]
13673 Unknown,
13674 /// This variant handles values not known at compile time.
13675 #[serde(untagged)]
13676 #[strum(serialize = "__OTHER__")]
13677 Other_(String),
13678}
13679/// Reasons for identifying the disk extent
13680/// as copy of VMFS volume extent.
13681///
13682/// Possible values:
13683/// - `diskIdMismatch`: The VMFS detected 'diskid' does not match with
13684/// LVM detected 'diskId'
13685/// - `uuidConflict`: VMFS 'uuid' does not match
13686#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13687pub enum HostUnresolvedVmfsExtentUnresolvedReasonEnum {
13688 #[serde(rename = "diskIdMismatch")]
13689 #[strum(serialize = "diskIdMismatch")]
13690 DiskIdMismatch,
13691 #[serde(rename = "uuidConflict")]
13692 #[strum(serialize = "uuidConflict")]
13693 UuidConflict,
13694 /// This variant handles values not known at compile time.
13695 #[serde(untagged)]
13696 #[strum(serialize = "__OTHER__")]
13697 Other_(String),
13698}
13699/// Possible values:
13700/// - `resignature`: Resignature the Unresolved VMFS volume.
13701///
13702/// In the event the volume to be resignatured contains multiple
13703/// extents but only a single copy of each extent exists, only the
13704/// head extent needs to be specified.
13705/// - `forceMount`: Keep the original Uuid of the VMFS volume and mount it
13706///
13707/// In the event the volume to be force mounted contains multiple
13708/// extents but only a single copy of each extent exists, only the
13709/// head extent needs to be specified.
13710#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13711pub enum HostUnresolvedVmfsResolutionSpecVmfsUuidResolutionEnum {
13712 #[serde(rename = "resignature")]
13713 #[strum(serialize = "resignature")]
13714 Resignature,
13715 #[serde(rename = "forceMount")]
13716 #[strum(serialize = "forceMount")]
13717 ForceMount,
13718 /// This variant handles values not known at compile time.
13719 #[serde(untagged)]
13720 #[strum(serialize = "__OTHER__")]
13721 Other_(String),
13722}
13723/// Possible values:
13724/// - `vmotion`: The VirtualNic is used for VMotion.
13725/// - `faultToleranceLogging`: The VirtualNic is used for Fault Tolerance logging.
13726/// - `vSphereReplication`: The VirtualNic is used for vSphere Replication LWD traffic
13727/// (i.e From the primary host to the VR server).
13728/// - `vSphereReplicationNFC`: The VirtualNic is used for vSphere Replication NFC traffic (i.e.
13729///
13730/// From
13731/// the VR server to the secondary host).
13732/// - `management`: The VirtualNic is used for management network traffic .
13733///
13734/// This nicType is available only when the system does not
13735/// support service console adapters.
13736///
13737/// See also *HostNetCapabilities.usesServiceConsoleNic*.
13738/// - `vsan`: The VirtualNic is used for Virtual SAN data traffic.
13739///
13740/// To enable or disable a VirtualNic for VSAN networking,
13741/// use *HostVsanSystem.UpdateVsan_Task*.
13742///
13743/// See also *HostVsanSystem*, *HostVsanSystem.UpdateVsan_Task*, *ComputeResource.ReconfigureComputeResource_Task*.
13744/// - `vSphereProvisioning`: The VirtualNic is used for vSphere provisioning NFC traffic
13745/// (i.e.
13746///
13747/// the NFC traffic between ESX hosts as a part of a VC initiated
13748/// provisioning operations like cold-migrations, clones, snapshot and
13749/// cold data in hot migration).
13750/// - `vsanWitness`: The VirtualNic is used for Virtual SAN witness traffic.
13751///
13752/// Witness traffic vmknic is required for Virtual SAN stretched cluster,
13753/// to help on communication between Virtual SAN data node and witness
13754/// node.
13755/// To enable or disable a VirtualNic for Virtual SAN networking,
13756/// use *HostVsanSystem.UpdateVsan_Task*.
13757///
13758/// See also *HostVsanSystem*, *HostVsanSystem.UpdateVsan_Task*.
13759/// - `vSphereBackupNFC`: The VirtualNic is used for vSphere backup NFC traffic
13760/// (i.e.
13761///
13762/// the NFC traffic between backup appliance and ESX hosts).
13763/// - `ptp`: The VirtualNic is used for Precision Time Protocol (PTP).
13764/// - `nvmeTcp`: The VirtualNic is used for NVMe over TCP traffic.
13765///
13766/// ***Since:*** vSphere API Release 7.0.3.0
13767/// - `nvmeRdma`: The VirtualNic is used for NVMe over RDMA traffic.
13768///
13769/// ***Since:*** vSphere API Release 7.0.3.0
13770/// - `vsanExternal`: The VirtualNic is used for external vSAN traffic.
13771///
13772/// ***Since:*** vSphere API Release 9.0.0.0
13773#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13774pub enum HostVirtualNicManagerNicTypeEnum {
13775 #[serde(rename = "vmotion")]
13776 #[strum(serialize = "vmotion")]
13777 Vmotion,
13778 #[serde(rename = "faultToleranceLogging")]
13779 #[strum(serialize = "faultToleranceLogging")]
13780 FaultToleranceLogging,
13781 #[serde(rename = "vSphereReplication")]
13782 #[strum(serialize = "vSphereReplication")]
13783 VSphereReplication,
13784 #[serde(rename = "vSphereReplicationNFC")]
13785 #[strum(serialize = "vSphereReplicationNFC")]
13786 VSphereReplicationNfc,
13787 #[serde(rename = "management")]
13788 #[strum(serialize = "management")]
13789 Management,
13790 #[serde(rename = "vsan")]
13791 #[strum(serialize = "vsan")]
13792 Vsan,
13793 #[serde(rename = "vSphereProvisioning")]
13794 #[strum(serialize = "vSphereProvisioning")]
13795 VSphereProvisioning,
13796 #[serde(rename = "vsanWitness")]
13797 #[strum(serialize = "vsanWitness")]
13798 VsanWitness,
13799 #[serde(rename = "vSphereBackupNFC")]
13800 #[strum(serialize = "vSphereBackupNFC")]
13801 VSphereBackupNfc,
13802 #[serde(rename = "ptp")]
13803 #[strum(serialize = "ptp")]
13804 Ptp,
13805 #[serde(rename = "nvmeTcp")]
13806 #[strum(serialize = "nvmeTcp")]
13807 NvmeTcp,
13808 #[serde(rename = "nvmeRdma")]
13809 #[strum(serialize = "nvmeRdma")]
13810 NvmeRdma,
13811 #[serde(rename = "vsanExternal")]
13812 #[strum(serialize = "vsanExternal")]
13813 VsanExternal,
13814 /// This variant handles values not known at compile time.
13815 #[serde(untagged)]
13816 #[strum(serialize = "__OTHER__")]
13817 Other_(String),
13818}
13819/// Set of possible values for mode field in AccessSpec.
13820///
13821/// Possible values:
13822/// - `grant`: Grant access to specified services in addition to existing services.
13823/// - `replace`: Replace existing services with specified services.
13824/// - `revoke`: Revoke the specified services.
13825#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13826pub enum HostVmciAccessManagerModeEnum {
13827 #[serde(rename = "grant")]
13828 #[strum(serialize = "grant")]
13829 Grant,
13830 #[serde(rename = "replace")]
13831 #[strum(serialize = "replace")]
13832 Replace,
13833 #[serde(rename = "revoke")]
13834 #[strum(serialize = "revoke")]
13835 Revoke,
13836 /// This variant handles values not known at compile time.
13837 #[serde(untagged)]
13838 #[strum(serialize = "__OTHER__")]
13839 Other_(String),
13840}
13841/// VMFS unmap bandwidth policy.
13842///
13843/// VMFS unmap reclaims unused storage space.
13844/// This specifies the bandwidth policy option of unmaps.
13845///
13846/// Possible values:
13847/// - `fixed`: Unmap bandwidth is a fixed value.
13848/// - `dynamic`: Unmaps bandwidth is a dynamic value with lower and upper limits
13849#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13850pub enum HostVmfsVolumeUnmapBandwidthPolicyEnum {
13851 #[serde(rename = "fixed")]
13852 #[strum(serialize = "fixed")]
13853 Fixed,
13854 #[serde(rename = "dynamic")]
13855 #[strum(serialize = "dynamic")]
13856 Dynamic,
13857 /// This variant handles values not known at compile time.
13858 #[serde(untagged)]
13859 #[strum(serialize = "__OTHER__")]
13860 Other_(String),
13861}
13862/// VMFS unmap priority.
13863///
13864/// VMFS unmap reclaims unused storage space.
13865/// This specifies the processing rate of unmaps.
13866///
13867/// Possible values:
13868/// - `none`: Unmap is disabled.
13869/// - `low`: Unmaps are processed at low rate.
13870#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13871pub enum HostVmfsVolumeUnmapPriorityEnum {
13872 #[serde(rename = "none")]
13873 #[strum(serialize = "none")]
13874 None,
13875 #[serde(rename = "low")]
13876 #[strum(serialize = "low")]
13877 Low,
13878 /// This variant handles values not known at compile time.
13879 #[serde(untagged)]
13880 #[strum(serialize = "__OTHER__")]
13881 Other_(String),
13882}
13883/// Enumeration indicates the vSAN disk controller type.
13884///
13885/// Possible values:
13886/// - `NVMe`: The controller is an NVMe controller.
13887/// - `SCSI`: The controller is a SCSI controller.
13888/// - `VsanControllerType_Unknown`: Represent the value when the lower version client cannot recognize the enum value.
13889#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13890pub enum VsanControllerTypeEnum {
13891 #[serde(rename = "NVMe")]
13892 #[strum(serialize = "NVMe")]
13893 NvMe,
13894 #[serde(rename = "SCSI")]
13895 #[strum(serialize = "SCSI")]
13896 Scsi,
13897 #[serde(rename = "VsanControllerType_Unknown")]
13898 #[strum(serialize = "VsanControllerType_Unknown")]
13899 VsanControllerTypeUnknown,
13900 /// This variant handles values not known at compile time.
13901 #[serde(untagged)]
13902 #[strum(serialize = "__OTHER__")]
13903 Other_(String),
13904}
13905/// The vSAN disk balance state enumeration.
13906///
13907/// Possible values:
13908/// - `rebalanceoff`: Rebalancing needed but is turned off.
13909/// - `rebalanceentitydecom`: Disk/diskgroup or related node is decommissioning or rebalancing temporarily disabled.
13910/// - `rebalancediskunhealthy`: Disk that needs rebalancing is unhealthy.
13911/// - `imbalancewithintolerance`: Imbalance is within reactive/proactive tolerance.
13912/// - `reactiverebalanceinprogress`: Reactive rebalancing in progress.
13913/// - `reactiverebalancefailed`: Reactive rebalancing needed but failed due to lack of resources or failing to find components that can be moved due to policy restrictions.
13914/// - `proactiveneededbutdisabled`: Proactive rebalancing needed but disabled.
13915/// - `proactiverebalanceinprogress`: Proactive rebalancing in progress.
13916/// - `proactiverebalancefailed`: Proactive rebalancing needed but failed due to lack of resources or failing to find components that can be moved due to policy restrictions.
13917/// - `proactivenotmustdo`: Proactive rebalancing can be activated but it's not a must do like due to no enough resource
13918/// - `VsanDiskBalanceState_Unknown`
13919#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13920pub enum VsanDiskBalanceStateEnum {
13921 #[serde(rename = "rebalanceoff")]
13922 #[strum(serialize = "rebalanceoff")]
13923 Rebalanceoff,
13924 #[serde(rename = "rebalanceentitydecom")]
13925 #[strum(serialize = "rebalanceentitydecom")]
13926 Rebalanceentitydecom,
13927 #[serde(rename = "rebalancediskunhealthy")]
13928 #[strum(serialize = "rebalancediskunhealthy")]
13929 Rebalancediskunhealthy,
13930 #[serde(rename = "imbalancewithintolerance")]
13931 #[strum(serialize = "imbalancewithintolerance")]
13932 Imbalancewithintolerance,
13933 #[serde(rename = "reactiverebalanceinprogress")]
13934 #[strum(serialize = "reactiverebalanceinprogress")]
13935 Reactiverebalanceinprogress,
13936 #[serde(rename = "reactiverebalancefailed")]
13937 #[strum(serialize = "reactiverebalancefailed")]
13938 Reactiverebalancefailed,
13939 #[serde(rename = "proactiveneededbutdisabled")]
13940 #[strum(serialize = "proactiveneededbutdisabled")]
13941 Proactiveneededbutdisabled,
13942 #[serde(rename = "proactiverebalanceinprogress")]
13943 #[strum(serialize = "proactiverebalanceinprogress")]
13944 Proactiverebalanceinprogress,
13945 #[serde(rename = "proactiverebalancefailed")]
13946 #[strum(serialize = "proactiverebalancefailed")]
13947 Proactiverebalancefailed,
13948 #[serde(rename = "proactivenotmustdo")]
13949 #[strum(serialize = "proactivenotmustdo")]
13950 Proactivenotmustdo,
13951 #[serde(rename = "VsanDiskBalanceState_Unknown")]
13952 #[strum(serialize = "VsanDiskBalanceState_Unknown")]
13953 VsanDiskBalanceStateUnknown,
13954 /// This variant handles values not known at compile time.
13955 #[serde(untagged)]
13956 #[strum(serialize = "__OTHER__")]
13957 Other_(String),
13958}
13959/// The vSAN encryption issue enumeration.
13960///
13961/// Possible values:
13962/// - `enabledwhenclusterdisabled`: Encryption is enabled on the host/disk when the cluster has encryption disabled.
13963/// - `disabledwhenclusterenabled`: Encryption is disabled on the host/disk when the cluster has encryption enabled.
13964/// - `keyencryptionkeyinconsistent`: The Encryption Key on the host/disk is inconsistent with the cluster encryption configuration.
13965/// - `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.
13966/// - `kmsinfoinconsistent`: The Key Management Servers information on the host/disk is inconsistent with the cluster encryption configuration.
13967/// - `servercertificatesinconsistent`: The server certifications on the host is inconsistent with the cluster encryption configuration.
13968/// - `clientcertificateinconsistent`: The client certification on the host is inconsistent with the cluster encryption configuration.
13969/// - `clientkeyinconsistent`: The client private key on the host is inconsistent with the cluster encryption configuration.
13970/// - `hostkeyinconsistent`: The host key for host core dump encryption is inconsistent with the cluster encryption configuration.
13971/// - `erasedisksbeforeuseinconsistent`: The configuration of erasing disks before use on the host is inconsistent with the cluster encryption configuration.
13972/// - `cmknotinenabledstate`
13973/// - `cmkcannotretrieve`
13974/// - `hostkeynotavailable`
13975/// - `keknotavailable`
13976/// - `hostencryptiondekidinconsistent`
13977/// - `objectencryptioninconsistent`
13978/// - `keyencryptionkeyverifierinconsistent`
13979/// - `dataencryptionkeyverifierinconsistent`
13980/// - `olddataencryptionkeyinconsistent`
13981/// - `hosthaswrongdekid`
13982/// - `hosthaswrongolddekid`
13983/// - `hosthaspendingdeeprekey`
13984/// - `diskhaswrongdekid`
13985/// - `diskhaswrongpendingdekid`
13986/// - `diskhaspendingdeeprekey`
13987/// - `dataencryptionkeyverifierofdiskmetainconsistent`
13988/// - `changingstateinconsistent`: ***Since:*** 8.0.0.4
13989/// - `changingstatenotfinished`: ***Since:*** 8.0.0.4
13990/// - `VsanEncryptionIssue_Unknown`
13991#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
13992pub enum VsanEncryptionIssueEnum {
13993 #[serde(rename = "enabledwhenclusterdisabled")]
13994 #[strum(serialize = "enabledwhenclusterdisabled")]
13995 Enabledwhenclusterdisabled,
13996 #[serde(rename = "disabledwhenclusterenabled")]
13997 #[strum(serialize = "disabledwhenclusterenabled")]
13998 Disabledwhenclusterenabled,
13999 #[serde(rename = "keyencryptionkeyinconsistent")]
14000 #[strum(serialize = "keyencryptionkeyinconsistent")]
14001 Keyencryptionkeyinconsistent,
14002 #[serde(rename = "dataencryptionkeyinconsistent")]
14003 #[strum(serialize = "dataencryptionkeyinconsistent")]
14004 Dataencryptionkeyinconsistent,
14005 #[serde(rename = "kmsinfoinconsistent")]
14006 #[strum(serialize = "kmsinfoinconsistent")]
14007 Kmsinfoinconsistent,
14008 #[serde(rename = "servercertificatesinconsistent")]
14009 #[strum(serialize = "servercertificatesinconsistent")]
14010 Servercertificatesinconsistent,
14011 #[serde(rename = "clientcertificateinconsistent")]
14012 #[strum(serialize = "clientcertificateinconsistent")]
14013 Clientcertificateinconsistent,
14014 #[serde(rename = "clientkeyinconsistent")]
14015 #[strum(serialize = "clientkeyinconsistent")]
14016 Clientkeyinconsistent,
14017 #[serde(rename = "hostkeyinconsistent")]
14018 #[strum(serialize = "hostkeyinconsistent")]
14019 Hostkeyinconsistent,
14020 #[serde(rename = "erasedisksbeforeuseinconsistent")]
14021 #[strum(serialize = "erasedisksbeforeuseinconsistent")]
14022 Erasedisksbeforeuseinconsistent,
14023 #[serde(rename = "cmknotinenabledstate")]
14024 #[strum(serialize = "cmknotinenabledstate")]
14025 Cmknotinenabledstate,
14026 #[serde(rename = "cmkcannotretrieve")]
14027 #[strum(serialize = "cmkcannotretrieve")]
14028 Cmkcannotretrieve,
14029 #[serde(rename = "hostkeynotavailable")]
14030 #[strum(serialize = "hostkeynotavailable")]
14031 Hostkeynotavailable,
14032 #[serde(rename = "keknotavailable")]
14033 #[strum(serialize = "keknotavailable")]
14034 Keknotavailable,
14035 #[serde(rename = "hostencryptiondekidinconsistent")]
14036 #[strum(serialize = "hostencryptiondekidinconsistent")]
14037 Hostencryptiondekidinconsistent,
14038 #[serde(rename = "objectencryptioninconsistent")]
14039 #[strum(serialize = "objectencryptioninconsistent")]
14040 Objectencryptioninconsistent,
14041 #[serde(rename = "keyencryptionkeyverifierinconsistent")]
14042 #[strum(serialize = "keyencryptionkeyverifierinconsistent")]
14043 Keyencryptionkeyverifierinconsistent,
14044 #[serde(rename = "dataencryptionkeyverifierinconsistent")]
14045 #[strum(serialize = "dataencryptionkeyverifierinconsistent")]
14046 Dataencryptionkeyverifierinconsistent,
14047 #[serde(rename = "olddataencryptionkeyinconsistent")]
14048 #[strum(serialize = "olddataencryptionkeyinconsistent")]
14049 Olddataencryptionkeyinconsistent,
14050 #[serde(rename = "hosthaswrongdekid")]
14051 #[strum(serialize = "hosthaswrongdekid")]
14052 Hosthaswrongdekid,
14053 #[serde(rename = "hosthaswrongolddekid")]
14054 #[strum(serialize = "hosthaswrongolddekid")]
14055 Hosthaswrongolddekid,
14056 #[serde(rename = "hosthaspendingdeeprekey")]
14057 #[strum(serialize = "hosthaspendingdeeprekey")]
14058 Hosthaspendingdeeprekey,
14059 #[serde(rename = "diskhaswrongdekid")]
14060 #[strum(serialize = "diskhaswrongdekid")]
14061 Diskhaswrongdekid,
14062 #[serde(rename = "diskhaswrongpendingdekid")]
14063 #[strum(serialize = "diskhaswrongpendingdekid")]
14064 Diskhaswrongpendingdekid,
14065 #[serde(rename = "diskhaspendingdeeprekey")]
14066 #[strum(serialize = "diskhaspendingdeeprekey")]
14067 Diskhaspendingdeeprekey,
14068 #[serde(rename = "dataencryptionkeyverifierofdiskmetainconsistent")]
14069 #[strum(serialize = "dataencryptionkeyverifierofdiskmetainconsistent")]
14070 Dataencryptionkeyverifierofdiskmetainconsistent,
14071 #[serde(rename = "changingstateinconsistent")]
14072 #[strum(serialize = "changingstateinconsistent")]
14073 Changingstateinconsistent,
14074 #[serde(rename = "changingstatenotfinished")]
14075 #[strum(serialize = "changingstatenotfinished")]
14076 Changingstatenotfinished,
14077 #[serde(rename = "VsanEncryptionIssue_Unknown")]
14078 #[strum(serialize = "VsanEncryptionIssue_Unknown")]
14079 VsanEncryptionIssueUnknown,
14080 /// This variant handles values not known at compile time.
14081 #[serde(untagged)]
14082 #[strum(serialize = "__OTHER__")]
14083 Other_(String),
14084}
14085/// The vSAN host QueryCheckLimits option type.
14086///
14087/// it is used to query more detailed
14088/// data aggregated at host level from disks or disk groups.
14089///
14090/// Possible values:
14091/// - `logicalCapacity`: The logical capacity at host level
14092/// - `logicalCapacityUsed`: The logical capacity used at host level
14093/// - `diskTransientCapacityUsed`: The disk transient capacity used at host level
14094/// - `dgTransientCapacityUsed`: The disk group transient capacity used at host level
14095/// - `dedupMetadata`: The dedup metadata size
14096/// - `VsanHostQueryCheckLimitsOptionType_Unknown`
14097#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
14098pub enum VsanHostQueryCheckLimitsOptionTypeEnum {
14099 #[serde(rename = "logicalCapacity")]
14100 #[strum(serialize = "logicalCapacity")]
14101 LogicalCapacity,
14102 #[serde(rename = "logicalCapacityUsed")]
14103 #[strum(serialize = "logicalCapacityUsed")]
14104 LogicalCapacityUsed,
14105 #[serde(rename = "diskTransientCapacityUsed")]
14106 #[strum(serialize = "diskTransientCapacityUsed")]
14107 DiskTransientCapacityUsed,
14108 #[serde(rename = "dgTransientCapacityUsed")]
14109 #[strum(serialize = "dgTransientCapacityUsed")]
14110 DgTransientCapacityUsed,
14111 #[serde(rename = "dedupMetadata")]
14112 #[strum(serialize = "dedupMetadata")]
14113 DedupMetadata,
14114 #[serde(rename = "VsanHostQueryCheckLimitsOptionType_Unknown")]
14115 #[strum(serialize = "VsanHostQueryCheckLimitsOptionType_Unknown")]
14116 VsanHostQueryCheckLimitsOptionTypeUnknown,
14117 /// This variant handles values not known at compile time.
14118 #[serde(untagged)]
14119 #[strum(serialize = "__OTHER__")]
14120 Other_(String),
14121}
14122/// State of ioinsight tool on ESXi host, which is designed to monitor and
14123/// collect all virtual disks I/O performance metrics of target virtual
14124/// machines.
14125///
14126/// Currently ioinsight state includes the following values, and
14127/// running/stopped are normal state.
14128///
14129/// Possible values:
14130/// - `running`: ioinsight is in running for VMDKs I/O performance metrics monitor.
14131/// - `stopped`: ioinsight is stopped and doesn't monitor any VMDK.
14132/// - `notFound`: ioinsight binary is not found on this host.
14133/// - `VsanIoInsightState_unknown`: represent the value when the lower version client cannot recognize the enum value
14134#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
14135pub enum VsanIoInsightStateEnum {
14136 #[serde(rename = "running")]
14137 #[strum(serialize = "running")]
14138 Running,
14139 #[serde(rename = "stopped")]
14140 #[strum(serialize = "stopped")]
14141 Stopped,
14142 #[serde(rename = "notFound")]
14143 #[strum(serialize = "notFound")]
14144 NotFound,
14145 #[serde(rename = "VsanIoInsightState_unknown")]
14146 #[strum(serialize = "VsanIoInsightState_unknown")]
14147 VsanIoInsightStateUnknown,
14148 /// This variant handles values not known at compile time.
14149 #[serde(untagged)]
14150 #[strum(serialize = "__OTHER__")]
14151 Other_(String),
14152}
14153/// The vSAN object health state enumeration.
14154///
14155/// Possible values:
14156/// - `inaccessible`: An object has suffered more failures (permanent or temporary) than it was configured to tolerate, and is currently unavailable and inaccessible.
14157/// - `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.
14158///
14159/// The object is accessible and I/O is flowing.
14160/// - `reducedavailabilitywithnorebuilddelaytimer`: The object has suffered a failure, but vSAN was able to tolerate it.
14161///
14162/// 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.
14163/// - `reducedavailabilitywithactiverebuild`: The object has suffered a failure, but it was configured to be able to tolerate the failure.
14164/// - `datamove`: Objects in this state are fully compliant with their policy and are healthy, but vSAN is actively rebuilding them.
14165/// - `nonavailabilityrelatedreconfig`: The object is fully in compliance with the NumberOfFailuresToTolerate policy and the data movement is to satisfy another policy change.
14166/// - `nonavailabilityrelatedincompliance`: This is a catch all state when none of the other states apply.
14167///
14168/// 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.
14169/// - `healthy`: The object is in perfect condition, exactly aligned with its policy, and is not currently being moved or otherwise worked on.
14170/// - `reducedavailabilitywithpolicypending`
14171/// - `reducedavailabilitywithpolicypendingfailed`
14172/// - `reducedavailabilitywithpausedrebuild`
14173/// - `nonavailabilityrelatedincompliancewithpolicypending`
14174/// - `nonavailabilityrelatedincompliancewithpolicypendingfailed`
14175/// - `nonavailabilityrelatedincompliancewithpausedrebuild`
14176/// - `remoteAccessible`
14177/// - `VsanObjectHealthState_Unknown`
14178#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
14179pub enum VsanObjectHealthStateEnum {
14180 #[serde(rename = "inaccessible")]
14181 #[strum(serialize = "inaccessible")]
14182 Inaccessible,
14183 #[serde(rename = "reducedavailabilitywithnorebuild")]
14184 #[strum(serialize = "reducedavailabilitywithnorebuild")]
14185 Reducedavailabilitywithnorebuild,
14186 #[serde(rename = "reducedavailabilitywithnorebuilddelaytimer")]
14187 #[strum(serialize = "reducedavailabilitywithnorebuilddelaytimer")]
14188 Reducedavailabilitywithnorebuilddelaytimer,
14189 #[serde(rename = "reducedavailabilitywithactiverebuild")]
14190 #[strum(serialize = "reducedavailabilitywithactiverebuild")]
14191 Reducedavailabilitywithactiverebuild,
14192 #[serde(rename = "datamove")]
14193 #[strum(serialize = "datamove")]
14194 Datamove,
14195 #[serde(rename = "nonavailabilityrelatedreconfig")]
14196 #[strum(serialize = "nonavailabilityrelatedreconfig")]
14197 Nonavailabilityrelatedreconfig,
14198 #[serde(rename = "nonavailabilityrelatedincompliance")]
14199 #[strum(serialize = "nonavailabilityrelatedincompliance")]
14200 Nonavailabilityrelatedincompliance,
14201 #[serde(rename = "healthy")]
14202 #[strum(serialize = "healthy")]
14203 Healthy,
14204 #[serde(rename = "reducedavailabilitywithpolicypending")]
14205 #[strum(serialize = "reducedavailabilitywithpolicypending")]
14206 Reducedavailabilitywithpolicypending,
14207 #[serde(rename = "reducedavailabilitywithpolicypendingfailed")]
14208 #[strum(serialize = "reducedavailabilitywithpolicypendingfailed")]
14209 Reducedavailabilitywithpolicypendingfailed,
14210 #[serde(rename = "reducedavailabilitywithpausedrebuild")]
14211 #[strum(serialize = "reducedavailabilitywithpausedrebuild")]
14212 Reducedavailabilitywithpausedrebuild,
14213 #[serde(rename = "nonavailabilityrelatedincompliancewithpolicypending")]
14214 #[strum(serialize = "nonavailabilityrelatedincompliancewithpolicypending")]
14215 Nonavailabilityrelatedincompliancewithpolicypending,
14216 #[serde(rename = "nonavailabilityrelatedincompliancewithpolicypendingfailed")]
14217 #[strum(serialize = "nonavailabilityrelatedincompliancewithpolicypendingfailed")]
14218 Nonavailabilityrelatedincompliancewithpolicypendingfailed,
14219 #[serde(rename = "nonavailabilityrelatedincompliancewithpausedrebuild")]
14220 #[strum(serialize = "nonavailabilityrelatedincompliancewithpausedrebuild")]
14221 Nonavailabilityrelatedincompliancewithpausedrebuild,
14222 #[serde(rename = "remoteAccessible")]
14223 #[strum(serialize = "remoteAccessible")]
14224 RemoteAccessible,
14225 #[serde(rename = "VsanObjectHealthState_Unknown")]
14226 #[strum(serialize = "VsanObjectHealthState_Unknown")]
14227 VsanObjectHealthStateUnknown,
14228 /// This variant handles values not known at compile time.
14229 #[serde(untagged)]
14230 #[strum(serialize = "__OTHER__")]
14231 Other_(String),
14232}
14233/// The vSAN interhost connectivity health state.
14234///
14235/// Possible values:
14236/// - `STATE_GOOD`: connection to peer is healthy.
14237/// - `STATE_SSL_ERROR`: connection to peer failed with ssl error.
14238/// - `STATE_CONNECTION_REFUSED_ERROR`: connection to peer failed with connection refused error.
14239/// - `STATE_SOCKET_TIMEOUT`: connection to peer failed with socket timeout error.
14240/// - `STATE_HTTP_EXCEPTION`: connection to peer failed with http exception.
14241/// - `STATE_MEMORY_ERROR`: connection to peer failed with memory error.
14242/// - `STATE_SYSTEM_ERROR`: connection to peer failed with system rrror.
14243/// - `STATE_OS_ERROR`: connection to peer failed with os error.
14244/// - `STATE_GENERAL_EXCEPTION`: connection to peer failed with general exception.
14245/// - `STATE_UNKNOWN`: connectino to peer failed with unknown issue.
14246#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
14247pub enum VsanPeerHostConnectivityHealthStateEnum {
14248 #[serde(rename = "STATE_GOOD")]
14249 #[strum(serialize = "STATE_GOOD")]
14250 StateGood,
14251 #[serde(rename = "STATE_SSL_ERROR")]
14252 #[strum(serialize = "STATE_SSL_ERROR")]
14253 StateSslError,
14254 #[serde(rename = "STATE_CONNECTION_REFUSED_ERROR")]
14255 #[strum(serialize = "STATE_CONNECTION_REFUSED_ERROR")]
14256 StateConnectionRefusedError,
14257 #[serde(rename = "STATE_SOCKET_TIMEOUT")]
14258 #[strum(serialize = "STATE_SOCKET_TIMEOUT")]
14259 StateSocketTimeout,
14260 #[serde(rename = "STATE_HTTP_EXCEPTION")]
14261 #[strum(serialize = "STATE_HTTP_EXCEPTION")]
14262 StateHttpException,
14263 #[serde(rename = "STATE_MEMORY_ERROR")]
14264 #[strum(serialize = "STATE_MEMORY_ERROR")]
14265 StateMemoryError,
14266 #[serde(rename = "STATE_SYSTEM_ERROR")]
14267 #[strum(serialize = "STATE_SYSTEM_ERROR")]
14268 StateSystemError,
14269 #[serde(rename = "STATE_OS_ERROR")]
14270 #[strum(serialize = "STATE_OS_ERROR")]
14271 StateOsError,
14272 #[serde(rename = "STATE_GENERAL_EXCEPTION")]
14273 #[strum(serialize = "STATE_GENERAL_EXCEPTION")]
14274 StateGeneralException,
14275 #[serde(rename = "STATE_UNKNOWN")]
14276 #[strum(serialize = "STATE_UNKNOWN")]
14277 StateUnknown,
14278 /// This variant handles values not known at compile time.
14279 #[serde(untagged)]
14280 #[strum(serialize = "__OTHER__")]
14281 Other_(String),
14282}
14283/// The vSAN S.M.A.R.T.
14284///
14285/// parameter enumeration.
14286///
14287/// Possible values:
14288/// - `smarthealthstatus`: Health Status.
14289/// - `smartmediawearoutindicator`: Media Wearout Indicator.
14290/// - `smartwriteerrorcount`: Write Error Count.
14291/// - `smartreaderrorcount`: Read Error Count.
14292/// - `smartpoweronhours`: Power-on Hours.
14293/// - `smartpowercyclecount`: Power Cycle Count.
14294/// - `smartreallocatedsectorct`: Reallocated Sector Count.
14295/// - `smartrawreaderrorrate`: Raw Read Error Rate.
14296/// - `smartdrivetemperature`: Drive Temperature.
14297/// - `smartdriveratedmaxtemperature`: Driver Rated Max Temperature.
14298/// - `smartwritesectorstotct`: Write Sectors TOT Count.
14299/// - `smartreadsectorstotct`: Read Sectors TOT Count.
14300/// - `smartinitialbadblockcount`: Initial Bad Block Count.
14301/// - `VsanSmartParameterType_Unknown`
14302#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
14303pub enum VsanSmartParameterTypeEnum {
14304 #[serde(rename = "smarthealthstatus")]
14305 #[strum(serialize = "smarthealthstatus")]
14306 Smarthealthstatus,
14307 #[serde(rename = "smartmediawearoutindicator")]
14308 #[strum(serialize = "smartmediawearoutindicator")]
14309 Smartmediawearoutindicator,
14310 #[serde(rename = "smartwriteerrorcount")]
14311 #[strum(serialize = "smartwriteerrorcount")]
14312 Smartwriteerrorcount,
14313 #[serde(rename = "smartreaderrorcount")]
14314 #[strum(serialize = "smartreaderrorcount")]
14315 Smartreaderrorcount,
14316 #[serde(rename = "smartpoweronhours")]
14317 #[strum(serialize = "smartpoweronhours")]
14318 Smartpoweronhours,
14319 #[serde(rename = "smartpowercyclecount")]
14320 #[strum(serialize = "smartpowercyclecount")]
14321 Smartpowercyclecount,
14322 #[serde(rename = "smartreallocatedsectorct")]
14323 #[strum(serialize = "smartreallocatedsectorct")]
14324 Smartreallocatedsectorct,
14325 #[serde(rename = "smartrawreaderrorrate")]
14326 #[strum(serialize = "smartrawreaderrorrate")]
14327 Smartrawreaderrorrate,
14328 #[serde(rename = "smartdrivetemperature")]
14329 #[strum(serialize = "smartdrivetemperature")]
14330 Smartdrivetemperature,
14331 #[serde(rename = "smartdriveratedmaxtemperature")]
14332 #[strum(serialize = "smartdriveratedmaxtemperature")]
14333 Smartdriveratedmaxtemperature,
14334 #[serde(rename = "smartwritesectorstotct")]
14335 #[strum(serialize = "smartwritesectorstotct")]
14336 Smartwritesectorstotct,
14337 #[serde(rename = "smartreadsectorstotct")]
14338 #[strum(serialize = "smartreadsectorstotct")]
14339 Smartreadsectorstotct,
14340 #[serde(rename = "smartinitialbadblockcount")]
14341 #[strum(serialize = "smartinitialbadblockcount")]
14342 Smartinitialbadblockcount,
14343 #[serde(rename = "VsanSmartParameterType_Unknown")]
14344 #[strum(serialize = "VsanSmartParameterType_Unknown")]
14345 VsanSmartParameterTypeUnknown,
14346 /// This variant handles values not known at compile time.
14347 #[serde(untagged)]
14348 #[strum(serialize = "__OTHER__")]
14349 Other_(String),
14350}
14351/// This specifies how an IP address was obtained for a given interface.
14352///
14353/// See RFC 4293 IpAddressOriginTC.
14354///
14355/// Possible values:
14356/// - `other`: Any other type of address configuration other than the below
14357/// mentioned ones will fall under this category.
14358///
14359/// For e.g., automatic
14360/// address configuration for the link local address falls under
14361/// this type.
14362/// - `manual`: The address is configured manually.
14363///
14364/// The term 'static' is a synonym.
14365/// - `dhcp`: The address is configured through dhcp.
14366/// - `linklayer`: The address is obtained through stateless autoconfiguration (autoconf).
14367///
14368/// See RFC 4862, IPv6 Stateless Address Autoconfiguration.
14369/// - `random`: The address is chosen by the system at random
14370/// e.g., an IPv4 address within 169.254/16, or an RFC 3041 privacy address.
14371#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
14372pub enum NetIpConfigInfoIpAddressOriginEnum {
14373 #[serde(rename = "other")]
14374 #[strum(serialize = "other")]
14375 Other,
14376 #[serde(rename = "manual")]
14377 #[strum(serialize = "manual")]
14378 Manual,
14379 #[serde(rename = "dhcp")]
14380 #[strum(serialize = "dhcp")]
14381 Dhcp,
14382 #[serde(rename = "linklayer")]
14383 #[strum(serialize = "linklayer")]
14384 Linklayer,
14385 #[serde(rename = "random")]
14386 #[strum(serialize = "random")]
14387 Random,
14388 /// This variant handles values not known at compile time.
14389 #[serde(untagged)]
14390 #[strum(serialize = "__OTHER__")]
14391 Other_(String),
14392}
14393/// Possible values:
14394/// - `preferred`: Indicates that this is a valid address.
14395/// - `deprecated`: Indicates that this is a valid but deprecated address
14396/// that should no longer be used as a source address.
14397/// - `invalid`: Indicates that this isn't a valid.
14398/// - `inaccessible`: Indicates that the address is not accessible because
14399/// interface is not operational.
14400/// - `unknown`: Indicates that the status cannot be determined.
14401/// - `tentative`: Indicates that the uniqueness of the
14402/// address on the link is presently being verified.
14403/// - `duplicate`: Indicates the address has been determined to be non-unique
14404/// on the link, this address will not be reachable.
14405#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
14406pub enum NetIpConfigInfoIpAddressStatusEnum {
14407 #[serde(rename = "preferred")]
14408 #[strum(serialize = "preferred")]
14409 Preferred,
14410 #[serde(rename = "deprecated")]
14411 #[strum(serialize = "deprecated")]
14412 Deprecated,
14413 #[serde(rename = "invalid")]
14414 #[strum(serialize = "invalid")]
14415 Invalid,
14416 #[serde(rename = "inaccessible")]
14417 #[strum(serialize = "inaccessible")]
14418 Inaccessible,
14419 #[serde(rename = "unknown")]
14420 #[strum(serialize = "unknown")]
14421 Unknown,
14422 #[serde(rename = "tentative")]
14423 #[strum(serialize = "tentative")]
14424 Tentative,
14425 #[serde(rename = "duplicate")]
14426 #[strum(serialize = "duplicate")]
14427 Duplicate,
14428 /// This variant handles values not known at compile time.
14429 #[serde(untagged)]
14430 #[strum(serialize = "__OTHER__")]
14431 Other_(String),
14432}
14433/// IP Stack keeps state on entries in IpNetToMedia table to perform
14434/// physical address lookups for IP addresses.
14435///
14436/// Here are the standard
14437/// states per @see RFC 4293 ipNetToMediaType.
14438///
14439/// Possible values:
14440/// - `other`: This implementation is reporting something other than
14441/// what states are listed below.
14442/// - `invalid`: The IP Stack has marked this entry as not useable.
14443/// - `dynamic`: This entry has been learned using ARP or NDP.
14444/// - `manual`: This entry was set manually.
14445#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
14446pub enum NetIpStackInfoEntryTypeEnum {
14447 #[serde(rename = "other")]
14448 #[strum(serialize = "other")]
14449 Other,
14450 #[serde(rename = "invalid")]
14451 #[strum(serialize = "invalid")]
14452 Invalid,
14453 #[serde(rename = "dynamic")]
14454 #[strum(serialize = "dynamic")]
14455 Dynamic,
14456 #[serde(rename = "manual")]
14457 #[strum(serialize = "manual")]
14458 Manual,
14459 /// This variant handles values not known at compile time.
14460 #[serde(untagged)]
14461 #[strum(serialize = "__OTHER__")]
14462 Other_(String),
14463}
14464/// The set of values used to determine ordering of default routers.
14465///
14466/// See RFC 4293 ipDefaultRouterPreference.
14467///
14468/// Possible values:
14469/// - `reserved`
14470/// - `low`
14471/// - `medium`
14472/// - `high`
14473#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
14474pub enum NetIpStackInfoPreferenceEnum {
14475 #[serde(rename = "reserved")]
14476 #[strum(serialize = "reserved")]
14477 Reserved,
14478 #[serde(rename = "low")]
14479 #[strum(serialize = "low")]
14480 Low,
14481 #[serde(rename = "medium")]
14482 #[strum(serialize = "medium")]
14483 Medium,
14484 #[serde(rename = "high")]
14485 #[strum(serialize = "high")]
14486 High,
14487 /// This variant handles values not known at compile time.
14488 #[serde(untagged)]
14489 #[strum(serialize = "__OTHER__")]
14490 Other_(String),
14491}
14492/// NetBIOS configuration mode.
14493///
14494/// Possible values:
14495/// - `unknown`: Mode of NetBIOS is unknown.
14496/// - `enabled`: NetBIOS is enabled.
14497/// - `disabled`: NetBIOS is disabled.
14498/// - `enabledViaDHCP`: DHCP server decides whether or not to use NetBIOS.
14499#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
14500pub enum NetBiosConfigInfoModeEnum {
14501 #[serde(rename = "unknown")]
14502 #[strum(serialize = "unknown")]
14503 Unknown,
14504 #[serde(rename = "enabled")]
14505 #[strum(serialize = "enabled")]
14506 Enabled,
14507 #[serde(rename = "disabled")]
14508 #[strum(serialize = "disabled")]
14509 Disabled,
14510 #[serde(rename = "enabledViaDHCP")]
14511 #[strum(serialize = "enabledViaDHCP")]
14512 EnabledViaDhcp,
14513 /// This variant handles values not known at compile time.
14514 #[serde(untagged)]
14515 #[strum(serialize = "__OTHER__")]
14516 Other_(String),
14517}
14518/// This list specifies the type of operation being performed on the array.
14519///
14520/// Possible values:
14521/// - `add`: indicates an addition to the array.
14522/// - `remove`: indicates the removal of an element in the
14523/// array.
14524///
14525/// In this case the key field must contain the key of the element
14526/// to be removed.
14527/// - `edit`: indicates changes to an element in the array.
14528#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
14529pub enum ArrayUpdateOperationEnum {
14530 #[serde(rename = "add")]
14531 #[strum(serialize = "add")]
14532 Add,
14533 #[serde(rename = "remove")]
14534 #[strum(serialize = "remove")]
14535 Remove,
14536 #[serde(rename = "edit")]
14537 #[strum(serialize = "edit")]
14538 Edit,
14539 /// This variant handles values not known at compile time.
14540 #[serde(untagged)]
14541 #[strum(serialize = "__OTHER__")]
14542 Other_(String),
14543}
14544/// Possible values:
14545/// - `compliant`: Entity is in Compliance
14546/// - `nonCompliant`: Entity is out of Compliance
14547/// - `unknown`: Compliance status of the entity is not known
14548/// - `running`: Compliance check on this host is running.
14549#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
14550pub enum ComplianceResultStatusEnum {
14551 #[serde(rename = "compliant")]
14552 #[strum(serialize = "compliant")]
14553 Compliant,
14554 #[serde(rename = "nonCompliant")]
14555 #[strum(serialize = "nonCompliant")]
14556 NonCompliant,
14557 #[serde(rename = "unknown")]
14558 #[strum(serialize = "unknown")]
14559 Unknown,
14560 #[serde(rename = "running")]
14561 #[strum(serialize = "running")]
14562 Running,
14563 /// This variant handles values not known at compile time.
14564 #[serde(untagged)]
14565 #[strum(serialize = "__OTHER__")]
14566 Other_(String),
14567}
14568/// Enumerates different operations supported for comparing
14569/// numerical values.
14570///
14571/// Possible values:
14572/// - `lessThan`
14573/// - `lessThanEqual`
14574/// - `equal`
14575/// - `notEqual`
14576/// - `greaterThanEqual`
14577/// - `greaterThan`
14578#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
14579pub enum ProfileNumericComparatorEnum {
14580 #[serde(rename = "lessThan")]
14581 #[strum(serialize = "lessThan")]
14582 LessThan,
14583 #[serde(rename = "lessThanEqual")]
14584 #[strum(serialize = "lessThanEqual")]
14585 LessThanEqual,
14586 #[serde(rename = "equal")]
14587 #[strum(serialize = "equal")]
14588 Equal,
14589 #[serde(rename = "notEqual")]
14590 #[strum(serialize = "notEqual")]
14591 NotEqual,
14592 #[serde(rename = "greaterThanEqual")]
14593 #[strum(serialize = "greaterThanEqual")]
14594 GreaterThanEqual,
14595 #[serde(rename = "greaterThan")]
14596 #[strum(serialize = "greaterThan")]
14597 GreaterThan,
14598 /// This variant handles values not known at compile time.
14599 #[serde(untagged)]
14600 #[strum(serialize = "__OTHER__")]
14601 Other_(String),
14602}
14603/// The relation type to be supported.
14604///
14605/// Possible values:
14606/// - `dynamic_relation`: The relation to a subprofile or a parameter.
14607/// - `extensible_relation`: The values from sources other than the parameter/profile or the static
14608/// value list are allowed.
14609/// - `localizable_relation`: The value list contains localization keys instead of values.
14610/// - `static_relation`: The relation is defined by static valid value list.
14611/// - `validation_relation`: The relation is defined for validation purpose.
14612#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
14613pub enum ProfileParameterMetadataRelationTypeEnum {
14614 #[serde(rename = "dynamic_relation")]
14615 #[strum(serialize = "dynamic_relation")]
14616 DynamicRelation,
14617 #[serde(rename = "extensible_relation")]
14618 #[strum(serialize = "extensible_relation")]
14619 ExtensibleRelation,
14620 #[serde(rename = "localizable_relation")]
14621 #[strum(serialize = "localizable_relation")]
14622 LocalizableRelation,
14623 #[serde(rename = "static_relation")]
14624 #[strum(serialize = "static_relation")]
14625 StaticRelation,
14626 #[serde(rename = "validation_relation")]
14627 #[strum(serialize = "validation_relation")]
14628 ValidationRelation,
14629 /// This variant handles values not known at compile time.
14630 #[serde(untagged)]
14631 #[strum(serialize = "__OTHER__")]
14632 Other_(String),
14633}
14634/// Type of services for which Profile can be requested for
14635///
14636/// Possible values:
14637/// - `DRS`: Distributed Resource Scheduling
14638/// - `HA`: High Availability
14639/// - `DPM`: Distributed Power Management
14640/// - `FT`: Fault tolerance
14641#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
14642pub enum ClusterProfileServiceTypeEnum {
14643 #[serde(rename = "DRS")]
14644 #[strum(serialize = "DRS")]
14645 Drs,
14646 #[serde(rename = "HA")]
14647 #[strum(serialize = "HA")]
14648 Ha,
14649 #[serde(rename = "DPM")]
14650 #[strum(serialize = "DPM")]
14651 Dpm,
14652 #[serde(rename = "FT")]
14653 #[strum(serialize = "FT")]
14654 Ft,
14655 /// This variant handles values not known at compile time.
14656 #[serde(untagged)]
14657 #[strum(serialize = "__OTHER__")]
14658 Other_(String),
14659}
14660/// Defines the result status values for a
14661/// *HostProfile*.*HostProfile.ExecuteHostProfile*
14662/// operation.
14663///
14664/// The result data is contained in the
14665/// *ProfileExecuteResult* data object.
14666///
14667/// Possible values:
14668/// - `success`: Profile execution was successful.
14669///
14670/// You can use the output configuration data
14671/// to apply the profile to a host.
14672/// - `needInput`: Additional data is required to complete the operation.
14673///
14674/// The data requirements are defined in the list of policy options for the profile
14675/// (*ApplyProfile*.*ApplyProfile.policy*\[\]).
14676/// - `error`: Profile execution generated an error.
14677///
14678/// See *ProfileExecuteResult*.*ProfileExecuteResult.error*.
14679#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
14680pub enum ProfileExecuteResultStatusEnum {
14681 #[serde(rename = "success")]
14682 #[strum(serialize = "success")]
14683 Success,
14684 #[serde(rename = "needInput")]
14685 #[strum(serialize = "needInput")]
14686 NeedInput,
14687 #[serde(rename = "error")]
14688 #[strum(serialize = "error")]
14689 Error,
14690 /// This variant handles values not known at compile time.
14691 #[serde(untagged)]
14692 #[strum(serialize = "__OTHER__")]
14693 Other_(String),
14694}
14695/// Types of host profile update.
14696///
14697/// Possible values:
14698/// - `HostBased`: Update host profile from host.
14699/// - `Import`: Import host profile.
14700/// - `Edit`: Edit host profile.
14701/// - `Compose`: Compose setting from host profile.
14702#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
14703pub enum HostProfileValidationFailureInfoUpdateTypeEnum {
14704 HostBased,
14705 Import,
14706 Edit,
14707 Compose,
14708 /// This variant handles values not known at compile time.
14709 #[serde(untagged)]
14710 #[strum(serialize = "__OTHER__")]
14711 Other_(String),
14712}
14713/// This defines validation state values for host profile.
14714///
14715/// Possible values:
14716/// - `Ready`
14717/// - `Running`
14718/// - `Failed`
14719#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
14720pub enum HostProfileValidationStateEnum {
14721 Ready,
14722 Running,
14723 Failed,
14724 /// This variant handles values not known at compile time.
14725 #[serde(untagged)]
14726 #[strum(serialize = "__OTHER__")]
14727 Other_(String),
14728}
14729/// The *HostProfileManagerAnswerFileStatus_enum* enum
14730/// defines possible values for answer file status.
14731///
14732/// Possible values:
14733/// - `valid`: Answer file is valid.
14734/// - `invalid`: Answer file is not valid.
14735///
14736/// The file is either missing or incomplete.
14737/// - To produce an answer file, pass host-specific data (user input) to the
14738/// *HostProfileManager*.*HostProfileManager.ApplyHostConfig_Task*
14739/// method.
14740/// - To produce a complete answer file, call the
14741/// *HostProfile*.*HostProfile.ExecuteHostProfile*
14742/// method and fill in any missing parameters in the returned
14743/// *ProfileExecuteResult*.*ProfileExecuteResult.requireInput*
14744/// list. After you execute the profile successfully, you can pass the complete required
14745/// input list to the apply method.
14746/// - `unknown`: Answer file status is not known.
14747#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
14748pub enum HostProfileManagerAnswerFileStatusEnum {
14749 #[serde(rename = "valid")]
14750 #[strum(serialize = "valid")]
14751 Valid,
14752 #[serde(rename = "invalid")]
14753 #[strum(serialize = "invalid")]
14754 Invalid,
14755 #[serde(rename = "unknown")]
14756 #[strum(serialize = "unknown")]
14757 Unknown,
14758 /// This variant handles values not known at compile time.
14759 #[serde(untagged)]
14760 #[strum(serialize = "__OTHER__")]
14761 Other_(String),
14762}
14763/// Possible values:
14764/// - `success`: Remediation succeeded.
14765/// - `failed`: Remediation failed.
14766/// - `reboot_failed`: Remediation succeeded but reboot after remediation failed.
14767///
14768/// May treat this as a warning.
14769/// - `stateless_reboot_failed`: Stateless reboot for remediation failed.
14770/// - `check_compliance_failed`: Remediation and reboot succeeded but check compliance after reboot
14771/// failed.
14772///
14773/// May treat this as a warning.
14774/// - `state_not_satisfied`: The required state is not satisfied so host profiel apply cannot
14775/// be done.
14776/// - `exit_maintenancemode_failed`: Exit maintenance mode failed.
14777/// - `canceled`: The remediation was canceled.
14778#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
14779pub enum ApplyHostProfileConfigurationResultStatusEnum {
14780 #[serde(rename = "success")]
14781 #[strum(serialize = "success")]
14782 Success,
14783 #[serde(rename = "failed")]
14784 #[strum(serialize = "failed")]
14785 Failed,
14786 #[serde(rename = "reboot_failed")]
14787 #[strum(serialize = "reboot_failed")]
14788 RebootFailed,
14789 #[serde(rename = "stateless_reboot_failed")]
14790 #[strum(serialize = "stateless_reboot_failed")]
14791 StatelessRebootFailed,
14792 #[serde(rename = "check_compliance_failed")]
14793 #[strum(serialize = "check_compliance_failed")]
14794 CheckComplianceFailed,
14795 #[serde(rename = "state_not_satisfied")]
14796 #[strum(serialize = "state_not_satisfied")]
14797 StateNotSatisfied,
14798 #[serde(rename = "exit_maintenancemode_failed")]
14799 #[strum(serialize = "exit_maintenancemode_failed")]
14800 ExitMaintenancemodeFailed,
14801 #[serde(rename = "canceled")]
14802 #[strum(serialize = "canceled")]
14803 Canceled,
14804 /// This variant handles values not known at compile time.
14805 #[serde(untagged)]
14806 #[strum(serialize = "__OTHER__")]
14807 Other_(String),
14808}
14809/// The composition status class.
14810///
14811/// Possible values:
14812/// - `success`
14813/// - `error`
14814#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
14815pub enum HostProfileManagerCompositionResultResultElementStatusEnum {
14816 #[serde(rename = "success")]
14817 #[strum(serialize = "success")]
14818 Success,
14819 #[serde(rename = "error")]
14820 #[strum(serialize = "error")]
14821 Error,
14822 /// This variant handles values not known at compile time.
14823 #[serde(untagged)]
14824 #[strum(serialize = "__OTHER__")]
14825 Other_(String),
14826}
14827/// The composition validation status class.
14828///
14829/// Possible values:
14830/// - `success`
14831/// - `error`
14832#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
14833pub enum HostProfileManagerCompositionValidationResultResultElementStatusEnum {
14834 #[serde(rename = "success")]
14835 #[strum(serialize = "success")]
14836 Success,
14837 #[serde(rename = "error")]
14838 #[strum(serialize = "error")]
14839 Error,
14840 /// This variant handles values not known at compile time.
14841 #[serde(untagged)]
14842 #[strum(serialize = "__OTHER__")]
14843 Other_(String),
14844}
14845/// The *HostProfileManagerTaskListRequirement_enum* enum
14846/// defines possible values for requirements when applying a *HostConfigSpec*
14847/// object returned as part of a <code>generateConfigTaskList</code>
14848/// operation.
14849///
14850/// Possible values:
14851/// - `maintenanceModeRequired`: The ESXi host must be in maintenance mode before the task list can be
14852/// applied.
14853/// - `rebootRequired`: The ESXi host must be rebooted after the task list is applied in order
14854/// for the new settings in the *HostConfigSpec* to take
14855/// effect on the host.
14856#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
14857pub enum HostProfileManagerTaskListRequirementEnum {
14858 #[serde(rename = "maintenanceModeRequired")]
14859 #[strum(serialize = "maintenanceModeRequired")]
14860 MaintenanceModeRequired,
14861 #[serde(rename = "rebootRequired")]
14862 #[strum(serialize = "rebootRequired")]
14863 RebootRequired,
14864 /// This variant handles values not known at compile time.
14865 #[serde(untagged)]
14866 #[strum(serialize = "__OTHER__")]
14867 Other_(String),
14868}
14869/// Defines the result status values for a validating answer file.
14870///
14871/// Possible values:
14872/// - `success`: Answer File validation was successful.
14873/// - `failed`: Answer File validation failed.
14874/// - `failed_defaults`: Answer File validation failed to generate default.
14875#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
14876pub enum AnswerFileValidationInfoStatusEnum {
14877 #[serde(rename = "success")]
14878 #[strum(serialize = "success")]
14879 Success,
14880 #[serde(rename = "failed")]
14881 #[strum(serialize = "failed")]
14882 Failed,
14883 #[serde(rename = "failed_defaults")]
14884 #[strum(serialize = "failed_defaults")]
14885 FailedDefaults,
14886 /// This variant handles values not known at compile time.
14887 #[serde(untagged)]
14888 #[strum(serialize = "__OTHER__")]
14889 Other_(String),
14890}
14891/// Possible values:
14892/// - `sunday`
14893/// - `monday`
14894/// - `tuesday`
14895/// - `wednesday`
14896/// - `thursday`
14897/// - `friday`
14898/// - `saturday`
14899#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
14900pub enum DayOfWeekEnum {
14901 #[serde(rename = "sunday")]
14902 #[strum(serialize = "sunday")]
14903 Sunday,
14904 #[serde(rename = "monday")]
14905 #[strum(serialize = "monday")]
14906 Monday,
14907 #[serde(rename = "tuesday")]
14908 #[strum(serialize = "tuesday")]
14909 Tuesday,
14910 #[serde(rename = "wednesday")]
14911 #[strum(serialize = "wednesday")]
14912 Wednesday,
14913 #[serde(rename = "thursday")]
14914 #[strum(serialize = "thursday")]
14915 Thursday,
14916 #[serde(rename = "friday")]
14917 #[strum(serialize = "friday")]
14918 Friday,
14919 #[serde(rename = "saturday")]
14920 #[strum(serialize = "saturday")]
14921 Saturday,
14922 /// This variant handles values not known at compile time.
14923 #[serde(untagged)]
14924 #[strum(serialize = "__OTHER__")]
14925 Other_(String),
14926}
14927/// Possible values:
14928/// - `first`
14929/// - `second`
14930/// - `third`
14931/// - `fourth`
14932/// - `last`
14933#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
14934pub enum WeekOfMonthEnum {
14935 #[serde(rename = "first")]
14936 #[strum(serialize = "first")]
14937 First,
14938 #[serde(rename = "second")]
14939 #[strum(serialize = "second")]
14940 Second,
14941 #[serde(rename = "third")]
14942 #[strum(serialize = "third")]
14943 Third,
14944 #[serde(rename = "fourth")]
14945 #[strum(serialize = "fourth")]
14946 Fourth,
14947 #[serde(rename = "last")]
14948 #[strum(serialize = "last")]
14949 Last,
14950 /// This variant handles values not known at compile time.
14951 #[serde(untagged)]
14952 #[strum(serialize = "__OTHER__")]
14953 Other_(String),
14954}
14955/// Rule scope determines conditions when an affinity rule is
14956/// satisfied.
14957///
14958/// The following uses affinity rule as example.
14959/// cluster: All Vms in the rule list are placed in a single cluster.
14960/// host: All Vms in the rule list are placed in a single host.
14961/// storagePod: All Vms in the rule list are placed in a single storagePod.
14962/// datastore: All Vms in the rule list are placed in a single datastore.
14963///
14964/// Possible values:
14965/// - `cluster`: clusters are the scope
14966/// - `host`: individual hosts are the scope
14967/// - `storagePod`: datastore cluster is teh scope
14968/// - `datastore`: individual datastores are the scope
14969#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
14970pub enum PlacementAffinityRuleRuleScopeEnum {
14971 #[serde(rename = "cluster")]
14972 #[strum(serialize = "cluster")]
14973 Cluster,
14974 #[serde(rename = "host")]
14975 #[strum(serialize = "host")]
14976 Host,
14977 #[serde(rename = "storagePod")]
14978 #[strum(serialize = "storagePod")]
14979 StoragePod,
14980 #[serde(rename = "datastore")]
14981 #[strum(serialize = "datastore")]
14982 Datastore,
14983 /// This variant handles values not known at compile time.
14984 #[serde(untagged)]
14985 #[strum(serialize = "__OTHER__")]
14986 Other_(String),
14987}
14988/// Rule type determines how the affinity rule is to be enforced:
14989/// affinity: Vms in the list are kept together within the rule
14990/// scope.
14991///
14992/// anti-affinity: Vms in the rule list are kept separate
14993/// across the objects in the rule scope.
14994/// soft rule: The enforcement is best effort.
14995///
14996/// Possible values:
14997/// - `affinity`: Affinity
14998/// - `antiAffinity`: Anti-Affinity
14999/// - `softAffinity`: Best-effort affinity
15000/// - `softAntiAffinity`: Best-effort anti-affinity
15001#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15002pub enum PlacementAffinityRuleRuleTypeEnum {
15003 #[serde(rename = "affinity")]
15004 #[strum(serialize = "affinity")]
15005 Affinity,
15006 #[serde(rename = "antiAffinity")]
15007 #[strum(serialize = "antiAffinity")]
15008 AntiAffinity,
15009 #[serde(rename = "softAffinity")]
15010 #[strum(serialize = "softAffinity")]
15011 SoftAffinity,
15012 #[serde(rename = "softAntiAffinity")]
15013 #[strum(serialize = "softAntiAffinity")]
15014 SoftAntiAffinity,
15015 /// This variant handles values not known at compile time.
15016 #[serde(untagged)]
15017 #[strum(serialize = "__OTHER__")]
15018 Other_(String),
15019}
15020/// Storage DRS behavior.
15021///
15022/// Possible values:
15023/// - `manual`: Specifies that VirtualCenter should generate recommendations for
15024/// virtual disk migration and for placement with a datastore,
15025/// but should not execute the recommendations automatically.
15026/// - `automated`: Specifies that VirtualCenter should generate recommendations
15027/// for virtual disk migration and for placement with a
15028/// datastore.
15029///
15030/// The recommendations for virtual disk migrations
15031/// will be executed automatically, but the placement
15032/// recommendations will be done manually.
15033#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15034pub enum StorageDrsPodConfigInfoBehaviorEnum {
15035 #[serde(rename = "manual")]
15036 #[strum(serialize = "manual")]
15037 Manual,
15038 #[serde(rename = "automated")]
15039 #[strum(serialize = "automated")]
15040 Automated,
15041 /// This variant handles values not known at compile time.
15042 #[serde(untagged)]
15043 #[strum(serialize = "__OTHER__")]
15044 Other_(String),
15045}
15046/// Defines the two ways a space utilization threshold can be specified.
15047///
15048/// Possible values:
15049/// - `utilization`: Default mode: threshold as a percentage of datastore capacity
15050/// - `freeSpace`: Threshold as an absolute value of free space in GBs
15051#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15052pub enum StorageDrsSpaceLoadBalanceConfigSpaceThresholdModeEnum {
15053 #[serde(rename = "utilization")]
15054 #[strum(serialize = "utilization")]
15055 Utilization,
15056 #[serde(rename = "freeSpace")]
15057 #[strum(serialize = "freeSpace")]
15058 FreeSpace,
15059 /// This variant handles values not known at compile time.
15060 #[serde(untagged)]
15061 #[strum(serialize = "__OTHER__")]
15062 Other_(String),
15063}
15064/// Defines the storage placement operation type.
15065///
15066/// Possible values:
15067/// - `create`: Create a VM.
15068/// - `reconfigure`: Reconfigure a VM.
15069/// - `relocate`: Relocate a VM.
15070/// - `clone`: Clone a VM.
15071#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15072pub enum StoragePlacementSpecPlacementTypeEnum {
15073 #[serde(rename = "create")]
15074 #[strum(serialize = "create")]
15075 Create,
15076 #[serde(rename = "reconfigure")]
15077 #[strum(serialize = "reconfigure")]
15078 Reconfigure,
15079 #[serde(rename = "relocate")]
15080 #[strum(serialize = "relocate")]
15081 Relocate,
15082 #[serde(rename = "clone")]
15083 #[strum(serialize = "clone")]
15084 Clone,
15085 /// This variant handles values not known at compile time.
15086 #[serde(untagged)]
15087 #[strum(serialize = "__OTHER__")]
15088 Other_(String),
15089}
15090/// Rule type determines how the virtual disks in a vm can be grouped
15091/// together.
15092///
15093/// Possible values:
15094/// - `affinity`: Virtual disks in the list are grouped together and placed on
15095/// the same data store.
15096/// - `antiAffinity`: Virtual disks in the list are placed on different data stores.
15097/// - `disabled`: SDRS will be disabled for the disks in the list.
15098#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15099pub enum VirtualDiskRuleSpecRuleTypeEnum {
15100 #[serde(rename = "affinity")]
15101 #[strum(serialize = "affinity")]
15102 Affinity,
15103 #[serde(rename = "antiAffinity")]
15104 #[strum(serialize = "antiAffinity")]
15105 AntiAffinity,
15106 #[serde(rename = "disabled")]
15107 #[strum(serialize = "disabled")]
15108 Disabled,
15109 /// This variant handles values not known at compile time.
15110 #[serde(untagged)]
15111 #[strum(serialize = "__OTHER__")]
15112 Other_(String),
15113}
15114/// The cloned VMs can either be provisioned the same way as the VMs
15115/// they are a clone of, thin provisioned or thick provisioned, or
15116/// linked clones (i.e., using delta disks).
15117///
15118/// Possible values:
15119/// - `sameAsSource`: Each disk in the cloned virtual machines will have the same
15120/// type of disk as the source vApp.
15121/// - `thin`: Each disk in the cloned virtual machines is allocated in full
15122/// size now and committed on demand.
15123///
15124/// This is only supported on
15125/// VMFS-3 and newer datastores. Other types of datastores may
15126/// create thick disks.
15127/// - `thick`: Each disk in the cloned virtual machines are allocated and
15128/// committed in full size immediately.
15129#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15130pub enum VAppCloneSpecProvisioningTypeEnum {
15131 #[serde(rename = "sameAsSource")]
15132 #[strum(serialize = "sameAsSource")]
15133 SameAsSource,
15134 #[serde(rename = "thin")]
15135 #[strum(serialize = "thin")]
15136 Thin,
15137 #[serde(rename = "thick")]
15138 #[strum(serialize = "thick")]
15139 Thick,
15140 /// This variant handles values not known at compile time.
15141 #[serde(untagged)]
15142 #[strum(serialize = "__OTHER__")]
15143 Other_(String),
15144}
15145/// Possible values:
15146/// - `none`: No action is taken for this virtual machine.
15147///
15148/// This virtual machine is
15149/// not a part of the auto-start sequence. This can be used for both auto-start
15150/// and auto-start settings.
15151/// - `powerOn`: This virtual machine is powered on when it is next in the auto-start order.
15152/// - `powerOff`: This virtual machine is powered off when it is next in the auto-stop order.
15153///
15154/// This is the default stopAction.
15155/// - `guestShutdown`: The guest operating system for a virtual machine is shut down when that
15156/// virtual machine in next in the auto-stop order.
15157/// - `suspend`: This virtual machine is suspended when it is next in the auto-stop order.
15158#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15159pub enum VAppAutoStartActionEnum {
15160 #[serde(rename = "none")]
15161 #[strum(serialize = "none")]
15162 None,
15163 #[serde(rename = "powerOn")]
15164 #[strum(serialize = "powerOn")]
15165 PowerOn,
15166 #[serde(rename = "powerOff")]
15167 #[strum(serialize = "powerOff")]
15168 PowerOff,
15169 #[serde(rename = "guestShutdown")]
15170 #[strum(serialize = "guestShutdown")]
15171 GuestShutdown,
15172 #[serde(rename = "suspend")]
15173 #[strum(serialize = "suspend")]
15174 Suspend,
15175 /// This variant handles values not known at compile time.
15176 #[serde(untagged)]
15177 #[strum(serialize = "__OTHER__")]
15178 Other_(String),
15179}
15180/// IP allocation schemes supported by the guest.
15181///
15182/// Possible values:
15183/// - `dhcp`: The vApp supports DHCP to acquire IP configuration.
15184/// - `ovfenv`: The vApp supports setting the IP configuration through the
15185/// properties provided in the OVF environment.
15186#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15187pub enum VAppIpAssignmentInfoAllocationSchemesEnum {
15188 #[serde(rename = "dhcp")]
15189 #[strum(serialize = "dhcp")]
15190 Dhcp,
15191 #[serde(rename = "ovfenv")]
15192 #[strum(serialize = "ovfenv")]
15193 Ovfenv,
15194 /// This variant handles values not known at compile time.
15195 #[serde(untagged)]
15196 #[strum(serialize = "__OTHER__")]
15197 Other_(String),
15198}
15199/// IP allocation policy for a deployment.
15200///
15201/// Possible values:
15202/// - `dhcpPolicy`: Specifies that DHCP must be used to allocate IP addresses to the vApp
15203/// - `transientPolicy`: Specifies that IP allocation is done through the range managed by the
15204/// vSphere platform.
15205///
15206/// The IP addresses are allocated when needed, typically at
15207/// power-on, and deallocated during power-off. There is no guarantee that a
15208/// vApp will get the same IP address when restarted.
15209/// - `fixedPolicy`: Specifies that IP addresses are configured manually when the vApp is deployed
15210/// and will be kept until reconfigured or the vApp destroyed.
15211///
15212/// This will ensure
15213/// that a vApp gets a consistent IP for its life-time.
15214/// - `fixedAllocatedPolicy`: Specifies that IP allocation is done through the range managed by the VI
15215/// platform.
15216///
15217/// The IP addresses are allocated at first power-on, and remain
15218/// allocated at power-off. This will ensure that a vApp gets a consistent
15219/// IP for its life-time.
15220#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15221pub enum VAppIpAssignmentInfoIpAllocationPolicyEnum {
15222 #[serde(rename = "dhcpPolicy")]
15223 #[strum(serialize = "dhcpPolicy")]
15224 DhcpPolicy,
15225 #[serde(rename = "transientPolicy")]
15226 #[strum(serialize = "transientPolicy")]
15227 TransientPolicy,
15228 #[serde(rename = "fixedPolicy")]
15229 #[strum(serialize = "fixedPolicy")]
15230 FixedPolicy,
15231 #[serde(rename = "fixedAllocatedPolicy")]
15232 #[strum(serialize = "fixedAllocatedPolicy")]
15233 FixedAllocatedPolicy,
15234 /// This variant handles values not known at compile time.
15235 #[serde(untagged)]
15236 #[strum(serialize = "__OTHER__")]
15237 Other_(String),
15238}
15239/// IP protocols supported by the guest.
15240///
15241/// Possible values:
15242/// - `IPv4`: The vApp supports IPv4 protocol.
15243/// - `IPv6`: The vApp supports IPv6 protocol.
15244#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15245pub enum VAppIpAssignmentInfoProtocolsEnum {
15246 IPv4,
15247 IPv6,
15248 /// This variant handles values not known at compile time.
15249 #[serde(untagged)]
15250 #[strum(serialize = "__OTHER__")]
15251 Other_(String),
15252}
15253/// Possible values:
15254/// - `configured`: VCHA cluster is configured.
15255/// - `notConfigured`: VCHA cluster is not configured.
15256/// - `invalid`: VCHA cluster is in an invalid/dirty state.
15257/// - `prepared`: VC appliance has been prepared for VCHA cluster configuration.
15258#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15259pub enum VchaStateEnum {
15260 #[serde(rename = "configured")]
15261 #[strum(serialize = "configured")]
15262 Configured,
15263 #[serde(rename = "notConfigured")]
15264 #[strum(serialize = "notConfigured")]
15265 NotConfigured,
15266 #[serde(rename = "invalid")]
15267 #[strum(serialize = "invalid")]
15268 Invalid,
15269 #[serde(rename = "prepared")]
15270 #[strum(serialize = "prepared")]
15271 Prepared,
15272 /// This variant handles values not known at compile time.
15273 #[serde(untagged)]
15274 #[strum(serialize = "__OTHER__")]
15275 Other_(String),
15276}
15277/// VchaClusterMode enum defines the possible modes for a VCHA Cluster.
15278///
15279/// Possible values:
15280/// - `enabled`: VCHA Cluster is enabled.
15281///
15282/// State replication between the Active and
15283/// Passive node is enabled and automatic failover is allowed.
15284/// - `disabled`: VCHA Cluster is disabled.
15285///
15286/// State replication between the Active and
15287/// Passive node is disabled and automatic failover is not allowed.
15288/// - `maintenance`: VCHA Cluster is in maintenance mode.
15289///
15290/// State replication between the
15291/// Active and Passive node is enabled but automatic failover
15292/// is not allowed.
15293#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15294pub enum VchaClusterModeEnum {
15295 #[serde(rename = "enabled")]
15296 #[strum(serialize = "enabled")]
15297 Enabled,
15298 #[serde(rename = "disabled")]
15299 #[strum(serialize = "disabled")]
15300 Disabled,
15301 #[serde(rename = "maintenance")]
15302 #[strum(serialize = "maintenance")]
15303 Maintenance,
15304 /// This variant handles values not known at compile time.
15305 #[serde(untagged)]
15306 #[strum(serialize = "__OTHER__")]
15307 Other_(String),
15308}
15309/// VchaClusterState enum defines the possible states for a VCHA Cluster.
15310///
15311/// Possible values:
15312/// - `healthy`: All three nodes in a VCHA Cluster are healthy and connected.
15313///
15314/// State
15315/// replication between Active and Passive node is working and both
15316/// nodes are in sync.
15317/// - `degraded`: A VCHA Cluster is said to be in a degraded state for
15318/// either or all of the following reasons:
15319/// \- There is a node loss.
15320///
15321/// \- State replication between the Active and Passive node fails.
15322/// - `isolated`: All three nodes are isolated from each other.
15323#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15324pub enum VchaClusterStateEnum {
15325 #[serde(rename = "healthy")]
15326 #[strum(serialize = "healthy")]
15327 Healthy,
15328 #[serde(rename = "degraded")]
15329 #[strum(serialize = "degraded")]
15330 Degraded,
15331 #[serde(rename = "isolated")]
15332 #[strum(serialize = "isolated")]
15333 Isolated,
15334 /// This variant handles values not known at compile time.
15335 #[serde(untagged)]
15336 #[strum(serialize = "__OTHER__")]
15337 Other_(String),
15338}
15339/// Possible values:
15340/// - `active`: Node is having a role of Active.
15341///
15342/// In this role, node runs a vCenter
15343/// Server that serves client requests.
15344/// - `passive`: Node is having a role of Passive.
15345///
15346/// In this role node, runs as a standby
15347/// for the Active vCenter Server and receives state updates. This node
15348/// takes over the role of Active vCenter Server upon failover.
15349/// - `witness`: Node is having a role of Witness.
15350///
15351/// In this role, node acts as a quorom
15352/// node for avoiding the classic split-brain problem.
15353#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15354pub enum VchaNodeRoleEnum {
15355 #[serde(rename = "active")]
15356 #[strum(serialize = "active")]
15357 Active,
15358 #[serde(rename = "passive")]
15359 #[strum(serialize = "passive")]
15360 Passive,
15361 #[serde(rename = "witness")]
15362 #[strum(serialize = "witness")]
15363 Witness,
15364 /// This variant handles values not known at compile time.
15365 #[serde(untagged)]
15366 #[strum(serialize = "__OTHER__")]
15367 Other_(String),
15368}
15369/// VchaNodeState enum defines possible state a node can be in a
15370/// VCHA Cluster.
15371///
15372/// Possible values:
15373/// - `up`: Node is up and has joined the VCHA Cluster.
15374/// - `down`: Node is down and has left the VCHA Cluster.
15375#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15376pub enum VchaNodeStateEnum {
15377 #[serde(rename = "up")]
15378 #[strum(serialize = "up")]
15379 Up,
15380 #[serde(rename = "down")]
15381 #[strum(serialize = "down")]
15382 Down,
15383 /// This variant handles values not known at compile time.
15384 #[serde(untagged)]
15385 #[strum(serialize = "__OTHER__")]
15386 Other_(String),
15387}
15388/// Possible values:
15389/// - `ipv4`: PXE (or Apple NetBoot) over IPv4.
15390///
15391/// The default.
15392/// - `ipv6`: PXE over IPv6.
15393///
15394/// Only meaningful for EFI virtual machines.
15395#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15396pub enum VirtualMachineBootOptionsNetworkBootProtocolTypeEnum {
15397 #[serde(rename = "ipv4")]
15398 #[strum(serialize = "ipv4")]
15399 Ipv4,
15400 #[serde(rename = "ipv6")]
15401 #[strum(serialize = "ipv6")]
15402 Ipv6,
15403 /// This variant handles values not known at compile time.
15404 #[serde(untagged)]
15405 #[strum(serialize = "__OTHER__")]
15406 Other_(String),
15407}
15408/// Set of supported hash algorithms for thumbprints.
15409///
15410/// Possible values:
15411/// - `sha256`: SHA256
15412///
15413/// ***Since:*** vSphere API Release 7.0.3.1
15414#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15415pub enum VirtualMachineCertThumbprintHashAlgorithmEnum {
15416 #[serde(rename = "sha256")]
15417 #[strum(serialize = "sha256")]
15418 Sha256,
15419 /// This variant handles values not known at compile time.
15420 #[serde(untagged)]
15421 #[strum(serialize = "__OTHER__")]
15422 Other_(String),
15423}
15424/// TPM provisioning policies used when cloning a VM with a virtual TPM
15425/// device.
15426///
15427/// Possible values:
15428/// - `copy`: The virtual TPM is copied.
15429///
15430/// The virtual machine clone will have access
15431/// to the original virtual machine's TPM secrets.
15432/// - `replace`: The virtual TPM is replaced with a new one.
15433///
15434/// The virtual machine clone
15435/// will not have access to the original virtual machine's TPM secrets.
15436///
15437/// ***Since:*** vSphere API Release 8.0.0.1
15438#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15439pub enum VirtualMachineCloneSpecTpmProvisionPolicyEnum {
15440 #[serde(rename = "copy")]
15441 #[strum(serialize = "copy")]
15442 Copy,
15443 #[serde(rename = "replace")]
15444 #[strum(serialize = "replace")]
15445 Replace,
15446 /// This variant handles values not known at compile time.
15447 #[serde(untagged)]
15448 #[strum(serialize = "__OTHER__")]
15449 Other_(String),
15450}
15451/// The NPIV WWN source type.
15452///
15453/// Possible values:
15454/// - `vc`: This set of WWNs is generated by VC server.
15455/// - `host`: This set of WWNs is generated by Host Agent.
15456/// - `external`: This set of WWNs is provided by the client.
15457#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15458pub enum VirtualMachineConfigInfoNpivWwnTypeEnum {
15459 #[serde(rename = "vc")]
15460 #[strum(serialize = "vc")]
15461 Vc,
15462 #[serde(rename = "host")]
15463 #[strum(serialize = "host")]
15464 Host,
15465 #[serde(rename = "external")]
15466 #[strum(serialize = "external")]
15467 External,
15468 /// This variant handles values not known at compile time.
15469 #[serde(untagged)]
15470 #[strum(serialize = "__OTHER__")]
15471 Other_(String),
15472}
15473/// Available choices for virtual machine swapfile placement policy.
15474///
15475/// This is
15476/// the set of legal values for the virtual machine configuration's
15477/// *swapPlacement* property. All
15478/// values except for "inherit" and "vmConfigured" are also valid values for
15479/// a compute resource configuration's
15480/// *vmSwapPlacement*
15481/// property.
15482///
15483/// Possible values:
15484/// - `inherit`: Honor the virtual machine swapfile placement policy of the compute
15485/// resource that contains this virtual machine.
15486/// - `vmDirectory`: Store the swapfile in the same directory as the virtual machine.
15487/// - `hostLocal`: Store the swapfile in the datastore specified by the
15488/// *localSwapDatastore*
15489/// property of the virtual machine's host, if that property is set and
15490/// indicates a datastore with sufficient free space.
15491///
15492/// Otherwise store the
15493/// swapfile in the same directory as the virtual machine.
15494///
15495/// Note: This setting may degrade VMotion performance.
15496#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15497pub enum VirtualMachineConfigInfoSwapPlacementTypeEnum {
15498 #[serde(rename = "inherit")]
15499 #[strum(serialize = "inherit")]
15500 Inherit,
15501 #[serde(rename = "vmDirectory")]
15502 #[strum(serialize = "vmDirectory")]
15503 VmDirectory,
15504 #[serde(rename = "hostLocal")]
15505 #[strum(serialize = "hostLocal")]
15506 HostLocal,
15507 /// This variant handles values not known at compile time.
15508 #[serde(untagged)]
15509 #[strum(serialize = "__OTHER__")]
15510 Other_(String),
15511}
15512/// The set of valid encrypted Fault Tolerance modes for a VM.
15513///
15514/// If the VM is encrypted, its encrypted Fault Tolerance mode
15515/// will be required.
15516///
15517/// Possible values:
15518/// - `ftEncryptionDisabled`: Do not use encrypted Fault Tolerance, even if available.
15519/// - `ftEncryptionOpportunistic`: Use encrypted Fault Tolerance if source and destination hosts
15520/// support it, fall back to unencrypted Fault Tolerance otherwise.
15521///
15522/// This is the default option.
15523/// - `ftEncryptionRequired`: Allow only encrypted Fault Tolerance.
15524///
15525/// If either the source or
15526/// destination host does not support encrypted Fault Tolerance,
15527/// do not allow the Fault Tolerance to occur.
15528///
15529/// ***Since:*** vSphere API Release 7.0.2.0
15530#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15531pub enum VirtualMachineConfigSpecEncryptedFtModesEnum {
15532 #[serde(rename = "ftEncryptionDisabled")]
15533 #[strum(serialize = "ftEncryptionDisabled")]
15534 FtEncryptionDisabled,
15535 #[serde(rename = "ftEncryptionOpportunistic")]
15536 #[strum(serialize = "ftEncryptionOpportunistic")]
15537 FtEncryptionOpportunistic,
15538 #[serde(rename = "ftEncryptionRequired")]
15539 #[strum(serialize = "ftEncryptionRequired")]
15540 FtEncryptionRequired,
15541 /// This variant handles values not known at compile time.
15542 #[serde(untagged)]
15543 #[strum(serialize = "__OTHER__")]
15544 Other_(String),
15545}
15546/// The set of valid encrypted vMotion modes for a VM.
15547///
15548/// If the VM is encrypted, its encrypted vMotion mode will be required.
15549///
15550/// Possible values:
15551/// - `disabled`: Do not use encrypted vMotion, even if available.
15552/// - `opportunistic`: Use encrypted vMotion if source and destination hosts support it,
15553/// fall back to unencrypted vMotion otherwise.
15554///
15555/// This is the default option.
15556/// - `required`: Allow only encrypted vMotion.
15557///
15558/// If the source or destination host does
15559/// not support vMotion encryption, do not allow the vMotion to occur.
15560#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15561pub enum VirtualMachineConfigSpecEncryptedVMotionModesEnum {
15562 #[serde(rename = "disabled")]
15563 #[strum(serialize = "disabled")]
15564 Disabled,
15565 #[serde(rename = "opportunistic")]
15566 #[strum(serialize = "opportunistic")]
15567 Opportunistic,
15568 #[serde(rename = "required")]
15569 #[strum(serialize = "required")]
15570 Required,
15571 /// This variant handles values not known at compile time.
15572 #[serde(untagged)]
15573 #[strum(serialize = "__OTHER__")]
15574 Other_(String),
15575}
15576/// The root WWN operation mode.
15577///
15578/// Possible values:
15579/// - `generate`: Generate a new set of WWNs and assign it to the virtual machine.
15580/// - `set`: Take a client-specified set of WWNs (specified in "wwn" property) and
15581/// assign them to the virtual machine.
15582///
15583/// If the new WWN quntity are more
15584/// than existing then we will append them to the existing list of WWNs.
15585/// - `remove`: Remove the currently assigned WWNs from the virtual machine.
15586/// - `extend`: Generate a new set of WWNs and append them to the existing list
15587#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15588pub enum VirtualMachineConfigSpecNpivWwnOpEnum {
15589 #[serde(rename = "generate")]
15590 #[strum(serialize = "generate")]
15591 Generate,
15592 #[serde(rename = "set")]
15593 #[strum(serialize = "set")]
15594 Set,
15595 #[serde(rename = "remove")]
15596 #[strum(serialize = "remove")]
15597 Remove,
15598 #[serde(rename = "extend")]
15599 #[strum(serialize = "extend")]
15600 Extend,
15601 /// This variant handles values not known at compile time.
15602 #[serde(untagged)]
15603 #[strum(serialize = "__OTHER__")]
15604 Other_(String),
15605}
15606/// The list of possible default power operations available for the virtual machine
15607///
15608/// Possible values:
15609/// - `soft`
15610/// - `hard`
15611/// - `preset`
15612#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15613pub enum VirtualMachinePowerOpTypeEnum {
15614 #[serde(rename = "soft")]
15615 #[strum(serialize = "soft")]
15616 Soft,
15617 #[serde(rename = "hard")]
15618 #[strum(serialize = "hard")]
15619 Hard,
15620 #[serde(rename = "preset")]
15621 #[strum(serialize = "preset")]
15622 Preset,
15623 /// This variant handles values not known at compile time.
15624 #[serde(untagged)]
15625 #[strum(serialize = "__OTHER__")]
15626 Other_(String),
15627}
15628/// The list of possible standby actions that the virtual machine can take
15629/// for S1 ACPI.
15630///
15631/// Possible values:
15632/// - `checkpoint`
15633/// - `powerOnSuspend`
15634#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15635pub enum VirtualMachineStandbyActionTypeEnum {
15636 #[serde(rename = "checkpoint")]
15637 #[strum(serialize = "checkpoint")]
15638 Checkpoint,
15639 #[serde(rename = "powerOnSuspend")]
15640 #[strum(serialize = "powerOnSuspend")]
15641 PowerOnSuspend,
15642 /// This variant handles values not known at compile time.
15643 #[serde(untagged)]
15644 #[strum(serialize = "__OTHER__")]
15645 Other_(String),
15646}
15647/// Possible values:
15648/// - `vmNptIncompatibleHost`: The virtual machine's host does not support VMDirectPath Gen 2.
15649///
15650/// See also *HostCapability.vmDirectPathGen2Supported*.
15651/// - `vmNptIncompatibleNetwork`: The configuration or state of the attached network prevents
15652/// VMDirectPath Gen 2.
15653///
15654/// Refer to
15655/// *vmDirectPathGen2InactiveReasonNetwork*
15656/// and/or
15657/// *vmDirectPathGen2InactiveReasonExtended*
15658/// in the RuntimeInfo of the DistributedVirtualPort connected to this
15659/// device.
15660#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15661pub enum VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonOtherEnum {
15662 #[serde(rename = "vmNptIncompatibleHost")]
15663 #[strum(serialize = "vmNptIncompatibleHost")]
15664 VmNptIncompatibleHost,
15665 #[serde(rename = "vmNptIncompatibleNetwork")]
15666 #[strum(serialize = "vmNptIncompatibleNetwork")]
15667 VmNptIncompatibleNetwork,
15668 /// This variant handles values not known at compile time.
15669 #[serde(untagged)]
15670 #[strum(serialize = "__OTHER__")]
15671 Other_(String),
15672}
15673/// Possible values:
15674/// - `vmNptIncompatibleGuest`: The virtual machine's guest OS does not support
15675/// VMDirectPath Gen 2.
15676/// - `vmNptIncompatibleGuestDriver`: The virtual machine's guest network driver does not support
15677/// VMDirectPath Gen 2.
15678/// - `vmNptIncompatibleAdapterType`: The device type does not support VMDirectPath Gen 2.
15679///
15680/// See also *VirtualEthernetCardOption.vmDirectPathGen2Supported*.
15681/// - `vmNptDisabledOrDisconnectedAdapter`: The virtual machine's network adapter is disabled or
15682/// disconnected, and thus is not participating in VMDirectPath Gen 2.
15683/// - `vmNptIncompatibleAdapterFeatures`: The virtual machine's network adapter has features enabled
15684/// which preclude it participating in VMDirectPath Gen 2 such
15685/// as INT-x or PXE booting.
15686/// - `vmNptIncompatibleBackingType`: The device backing is not a DistributedVirtualPortBacking.
15687/// - `vmNptInsufficientMemoryReservation`: The virtual machine does not have full memory reservation
15688/// required to activate VMDirectPath Gen 2.
15689/// - `vmNptFaultToleranceOrRecordReplayConfigured`:
15690///
15691/// Deprecated as of vSphere API 6.0.
15692///
15693/// The virtual machine is configured for Fault Tolerance or
15694/// Record & Replay, which prevents VMDirectPath Gen 2.
15695/// - `vmNptConflictingIOChainConfigured`: Some networking feature has placed a conflicting IOChain on
15696/// the network adapter, which prevents VMDirectPath Gen 2.
15697///
15698/// Examples
15699/// include DVFilter.
15700/// - `vmNptMonitorBlocks`: The virtual machine monitor is exercising functionality which
15701/// which prevents VMDirectPath Gen 2.
15702/// - `vmNptConflictingOperationInProgress`: VMDirectPath Gen 2 is temporarily suspended while the virtual
15703/// machine executes an operation such as suspend.
15704/// - `vmNptRuntimeError`: VMDirectPath Gen 2 is unavailable due to an unforeseen runtime error
15705/// in the virtualization platform (typically resource constraints.)
15706/// - `vmNptOutOfIntrVector`: VMDirectPath Gen 2 is unavailable due to host run out of intr
15707/// vector in host.
15708///
15709/// Guest can configure the vNIC to use less rx/tx
15710/// queues or use MSI instead of MSIX.
15711/// - `vmNptVMCIActive`: VMDirectPath Gen 2 is unavailable due to Incompatibe feature
15712/// VMCI is active in the current VM.
15713///
15714/// Kill the relevant VMCI
15715/// application(s) and restart the VM will allow the vNIC(s) to enter
15716/// passthrough mode.
15717#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15718pub enum VirtualMachineDeviceRuntimeInfoVirtualEthernetCardRuntimeStateVmDirectPathGen2InactiveReasonVmEnum {
15719 #[serde(rename = "vmNptIncompatibleGuest")]
15720 #[strum(serialize = "vmNptIncompatibleGuest")]
15721 VmNptIncompatibleGuest,
15722 #[serde(rename = "vmNptIncompatibleGuestDriver")]
15723 #[strum(serialize = "vmNptIncompatibleGuestDriver")]
15724 VmNptIncompatibleGuestDriver,
15725 #[serde(rename = "vmNptIncompatibleAdapterType")]
15726 #[strum(serialize = "vmNptIncompatibleAdapterType")]
15727 VmNptIncompatibleAdapterType,
15728 #[serde(rename = "vmNptDisabledOrDisconnectedAdapter")]
15729 #[strum(serialize = "vmNptDisabledOrDisconnectedAdapter")]
15730 VmNptDisabledOrDisconnectedAdapter,
15731 #[serde(rename = "vmNptIncompatibleAdapterFeatures")]
15732 #[strum(serialize = "vmNptIncompatibleAdapterFeatures")]
15733 VmNptIncompatibleAdapterFeatures,
15734 #[serde(rename = "vmNptIncompatibleBackingType")]
15735 #[strum(serialize = "vmNptIncompatibleBackingType")]
15736 VmNptIncompatibleBackingType,
15737 #[serde(rename = "vmNptInsufficientMemoryReservation")]
15738 #[strum(serialize = "vmNptInsufficientMemoryReservation")]
15739 VmNptInsufficientMemoryReservation,
15740 #[serde(rename = "vmNptFaultToleranceOrRecordReplayConfigured")]
15741 #[strum(serialize = "vmNptFaultToleranceOrRecordReplayConfigured")]
15742 VmNptFaultToleranceOrRecordReplayConfigured,
15743 #[serde(rename = "vmNptConflictingIOChainConfigured")]
15744 #[strum(serialize = "vmNptConflictingIOChainConfigured")]
15745 VmNptConflictingIoChainConfigured,
15746 #[serde(rename = "vmNptMonitorBlocks")]
15747 #[strum(serialize = "vmNptMonitorBlocks")]
15748 VmNptMonitorBlocks,
15749 #[serde(rename = "vmNptConflictingOperationInProgress")]
15750 #[strum(serialize = "vmNptConflictingOperationInProgress")]
15751 VmNptConflictingOperationInProgress,
15752 #[serde(rename = "vmNptRuntimeError")]
15753 #[strum(serialize = "vmNptRuntimeError")]
15754 VmNptRuntimeError,
15755 #[serde(rename = "vmNptOutOfIntrVector")]
15756 #[strum(serialize = "vmNptOutOfIntrVector")]
15757 VmNptOutOfIntrVector,
15758 #[serde(rename = "vmNptVMCIActive")]
15759 #[strum(serialize = "vmNptVMCIActive")]
15760 VmNptVmciActive,
15761 /// This variant handles values not known at compile time.
15762 #[serde(untagged)]
15763 #[strum(serialize = "__OTHER__")]
15764 Other_(String),
15765}
15766/// File-type constants.
15767///
15768/// Possible values:
15769/// - `config`: Config (vmx) file.
15770/// - `extendedConfig`: Extended config (vmxf) file.
15771/// - `diskDescriptor`: Disk descriptor (vmdk) file.
15772/// - `diskExtent`: Disk extent (-flat/-delta/-s/-rdm/-rdmp.vmdk) file.
15773/// - `digestDescriptor`: Disk digest descriptor file.
15774/// - `digestExtent`: Disk digest extent file.
15775/// - `diskReplicationState`: Host based replicated disk persistent state (psf) file.
15776/// - `log`: Log (log) file.
15777/// - `stat`: Virtual machine statistics (stat) file.
15778/// - `namespaceData`: Namespace data file.
15779/// - `dataSetsDiskModeStore`: DataSets disk mode store (dsd) file.
15780///
15781/// ***Since:*** vSphere API Release 8.0.0.0
15782/// - `dataSetsVmModeStore`: DataSets vm mode store (dsv) file.
15783///
15784/// ***Since:*** vSphere API Release 8.0.0.0
15785/// - `nvram`: Non-volatile RAM (nvram) file.
15786/// - `snapshotData`: Snapshot data (vmsn) file.
15787/// - `snapshotMemory`: Snapshot memory (vmem) file.
15788/// - `snapshotList`: Snapshot metadata (vmsd) file.
15789/// - `snapshotManifestList`: Snapshot manifest metadata (-aux.xml) file.
15790///
15791/// This file is still being created but is no longer necessary since
15792/// the manifest metadata is now available in the snapshot metadata
15793/// (vmsd) file in vSphere 5.0. This type will be deprecated when
15794/// vSphere 4.1 is no longer supported.
15795/// - `suspend`: Suspend (vmss) file.
15796/// - `suspendMemory`: Suspend (vmem) file.
15797/// - `swap`: Swap (vswp) file.
15798/// - `uwswap`: File generated by VMware ESX kernel for a running virtual
15799/// machine.
15800/// - `core`: Core (core) file.
15801/// - `screenshot`: Screenshot file.
15802/// - `ftMetadata`: Fault Tolerance metadata file.
15803/// - `guestCustomization`: Guest image customization file.
15804#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15805pub enum VirtualMachineFileLayoutExFileTypeEnum {
15806 #[serde(rename = "config")]
15807 #[strum(serialize = "config")]
15808 Config,
15809 #[serde(rename = "extendedConfig")]
15810 #[strum(serialize = "extendedConfig")]
15811 ExtendedConfig,
15812 #[serde(rename = "diskDescriptor")]
15813 #[strum(serialize = "diskDescriptor")]
15814 DiskDescriptor,
15815 #[serde(rename = "diskExtent")]
15816 #[strum(serialize = "diskExtent")]
15817 DiskExtent,
15818 #[serde(rename = "digestDescriptor")]
15819 #[strum(serialize = "digestDescriptor")]
15820 DigestDescriptor,
15821 #[serde(rename = "digestExtent")]
15822 #[strum(serialize = "digestExtent")]
15823 DigestExtent,
15824 #[serde(rename = "diskReplicationState")]
15825 #[strum(serialize = "diskReplicationState")]
15826 DiskReplicationState,
15827 #[serde(rename = "log")]
15828 #[strum(serialize = "log")]
15829 Log,
15830 #[serde(rename = "stat")]
15831 #[strum(serialize = "stat")]
15832 Stat,
15833 #[serde(rename = "namespaceData")]
15834 #[strum(serialize = "namespaceData")]
15835 NamespaceData,
15836 #[serde(rename = "dataSetsDiskModeStore")]
15837 #[strum(serialize = "dataSetsDiskModeStore")]
15838 DataSetsDiskModeStore,
15839 #[serde(rename = "dataSetsVmModeStore")]
15840 #[strum(serialize = "dataSetsVmModeStore")]
15841 DataSetsVmModeStore,
15842 #[serde(rename = "nvram")]
15843 #[strum(serialize = "nvram")]
15844 Nvram,
15845 #[serde(rename = "snapshotData")]
15846 #[strum(serialize = "snapshotData")]
15847 SnapshotData,
15848 #[serde(rename = "snapshotMemory")]
15849 #[strum(serialize = "snapshotMemory")]
15850 SnapshotMemory,
15851 #[serde(rename = "snapshotList")]
15852 #[strum(serialize = "snapshotList")]
15853 SnapshotList,
15854 #[serde(rename = "snapshotManifestList")]
15855 #[strum(serialize = "snapshotManifestList")]
15856 SnapshotManifestList,
15857 #[serde(rename = "suspend")]
15858 #[strum(serialize = "suspend")]
15859 Suspend,
15860 #[serde(rename = "suspendMemory")]
15861 #[strum(serialize = "suspendMemory")]
15862 SuspendMemory,
15863 #[serde(rename = "swap")]
15864 #[strum(serialize = "swap")]
15865 Swap,
15866 #[serde(rename = "uwswap")]
15867 #[strum(serialize = "uwswap")]
15868 Uwswap,
15869 #[serde(rename = "core")]
15870 #[strum(serialize = "core")]
15871 Core,
15872 #[serde(rename = "screenshot")]
15873 #[strum(serialize = "screenshot")]
15874 Screenshot,
15875 #[serde(rename = "ftMetadata")]
15876 #[strum(serialize = "ftMetadata")]
15877 FtMetadata,
15878 #[serde(rename = "guestCustomization")]
15879 #[strum(serialize = "guestCustomization")]
15880 GuestCustomization,
15881 /// This variant handles values not known at compile time.
15882 #[serde(untagged)]
15883 #[strum(serialize = "__OTHER__")]
15884 Other_(String),
15885}
15886/// Deprecated as of vSphere API 6.7.
15887///
15888/// Set of possible values for *VirtualMachineFlagInfo.htSharing*.
15889///
15890/// Possible values:
15891/// - `any`: VCPUs may freely share cores at any time with any other
15892/// VCPUs (default for all virtual machines on a hyperthreaded
15893/// system).
15894/// - `none`: VCPUs should not share cores with each other or with VCPUs
15895/// from other virtual machines.
15896///
15897/// That is, each VCPU from this
15898/// virtual machine should always get a whole core to itself,
15899/// with the other logical CPU on that core being placed into
15900/// the "halted" state.
15901/// - `internal`: Similar to "none", in that VCPUs from this virtual machine
15902/// will not be allowed to share cores with VCPUs from other
15903/// virtual machines.
15904///
15905/// However, other VCPUs from the same virtual
15906/// machine will be allowed to share cores together. This
15907/// configuration option is only permitted for SMP virtual
15908/// machines. If applied to a uniprocessor virtual machine, it
15909/// will be converted to the "none" sharing option.
15910#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15911pub enum VirtualMachineHtSharingEnum {
15912 #[serde(rename = "any")]
15913 #[strum(serialize = "any")]
15914 Any,
15915 #[serde(rename = "none")]
15916 #[strum(serialize = "none")]
15917 None,
15918 #[serde(rename = "internal")]
15919 #[strum(serialize = "internal")]
15920 Internal,
15921 /// This variant handles values not known at compile time.
15922 #[serde(untagged)]
15923 #[strum(serialize = "__OTHER__")]
15924 Other_(String),
15925}
15926/// Set of possible values for *VirtualMachineFlagInfo.monitorType*.
15927///
15928/// Possible values:
15929/// - `release`: Run vmx in default mode, matching the build type of vmkernel.
15930/// - `debug`: Run vmx in debug mode.
15931/// - `stats`: Run vmx in stats mode.
15932#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15933pub enum VirtualMachineFlagInfoMonitorTypeEnum {
15934 #[serde(rename = "release")]
15935 #[strum(serialize = "release")]
15936 Release,
15937 #[serde(rename = "debug")]
15938 #[strum(serialize = "debug")]
15939 Debug,
15940 #[serde(rename = "stats")]
15941 #[strum(serialize = "stats")]
15942 Stats,
15943 /// This variant handles values not known at compile time.
15944 #[serde(untagged)]
15945 #[strum(serialize = "__OTHER__")]
15946 Other_(String),
15947}
15948/// Set of possible values for *VirtualMachineFlagInfo.snapshotPowerOffBehavior*.
15949///
15950/// Possible values:
15951/// - `powerOff`: Just power off the virtual machine.
15952/// - `revert`: Revert to the snapshot.
15953/// - `prompt`: Prompt the user for instructions at power-off time.
15954/// - `take`: Take a new snapshot.
15955#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15956pub enum VirtualMachinePowerOffBehaviorEnum {
15957 #[serde(rename = "powerOff")]
15958 #[strum(serialize = "powerOff")]
15959 PowerOff,
15960 #[serde(rename = "revert")]
15961 #[strum(serialize = "revert")]
15962 Revert,
15963 #[serde(rename = "prompt")]
15964 #[strum(serialize = "prompt")]
15965 Prompt,
15966 #[serde(rename = "take")]
15967 #[strum(serialize = "take")]
15968 Take,
15969 /// This variant handles values not known at compile time.
15970 #[serde(untagged)]
15971 #[strum(serialize = "__OTHER__")]
15972 Other_(String),
15973}
15974/// Set of possible values for *VirtualMachineFlagInfo.virtualExecUsage*.
15975///
15976/// Possible values:
15977/// - `hvAuto`: Determine automatically whether to use hardware virtualization (HV) support.
15978/// - `hvOn`: Use hardware virtualization (HV) support if the physical hardware supports it.
15979/// - `hvOff`: Do not use hardware virtualization (HV) support.
15980#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
15981pub enum VirtualMachineFlagInfoVirtualExecUsageEnum {
15982 #[serde(rename = "hvAuto")]
15983 #[strum(serialize = "hvAuto")]
15984 HvAuto,
15985 #[serde(rename = "hvOn")]
15986 #[strum(serialize = "hvOn")]
15987 HvOn,
15988 #[serde(rename = "hvOff")]
15989 #[strum(serialize = "hvOff")]
15990 HvOff,
15991 /// This variant handles values not known at compile time.
15992 #[serde(untagged)]
15993 #[strum(serialize = "__OTHER__")]
15994 Other_(String),
15995}
15996/// Set of possible values for *VirtualMachineFlagInfo.virtualMmuUsage*.
15997///
15998/// Possible values:
15999/// - `automatic`: Determine automatically whether to use nested page table hardware support.
16000/// - `on`: Use nested paging hardware support if the physical hardware supports it.
16001/// - `off`: Do not use nested page table hardware support.
16002#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
16003pub enum VirtualMachineFlagInfoVirtualMmuUsageEnum {
16004 #[serde(rename = "automatic")]
16005 #[strum(serialize = "automatic")]
16006 Automatic,
16007 #[serde(rename = "on")]
16008 #[strum(serialize = "on")]
16009 On,
16010 #[serde(rename = "off")]
16011 #[strum(serialize = "off")]
16012 Off,
16013 /// This variant handles values not known at compile time.
16014 #[serde(untagged)]
16015 #[strum(serialize = "__OTHER__")]
16016 Other_(String),
16017}
16018/// Fork child type.
16019///
16020/// A child could be type of none, persistent, or
16021/// nonpersistent.
16022///
16023/// Possible values:
16024/// - `none`: The virtual machine is not a child.
16025/// - `persistent`: The virtual machine is a persistent child.
16026/// - `nonpersistent`: The virtual machine is a non-persistent child.
16027#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
16028pub enum VirtualMachineForkConfigInfoChildTypeEnum {
16029 #[serde(rename = "none")]
16030 #[strum(serialize = "none")]
16031 None,
16032 #[serde(rename = "persistent")]
16033 #[strum(serialize = "persistent")]
16034 Persistent,
16035 #[serde(rename = "nonpersistent")]
16036 #[strum(serialize = "nonpersistent")]
16037 Nonpersistent,
16038 /// This variant handles values not known at compile time.
16039 #[serde(untagged)]
16040 #[strum(serialize = "__OTHER__")]
16041 Other_(String),
16042}
16043/// Application state type.
16044///
16045/// Possible values:
16046/// - `none`: The application state wasn't set from the guest by the application agent.
16047///
16048/// This is the default.
16049/// - `appStateOk`: The guest's application agent declared its state as normal and doesn't
16050/// require any action
16051/// - `appStateNeedReset`: Guest's application agent asks for immediate reset
16052#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
16053pub enum GuestInfoAppStateTypeEnum {
16054 #[serde(rename = "none")]
16055 #[strum(serialize = "none")]
16056 None,
16057 #[serde(rename = "appStateOk")]
16058 #[strum(serialize = "appStateOk")]
16059 AppStateOk,
16060 #[serde(rename = "appStateNeedReset")]
16061 #[strum(serialize = "appStateNeedReset")]
16062 AppStateNeedReset,
16063 /// This variant handles values not known at compile time.
16064 #[serde(untagged)]
16065 #[strum(serialize = "__OTHER__")]
16066 Other_(String),
16067}
16068/// Guest customization status
16069///
16070/// Possible values:
16071/// - `TOOLSDEPLOYPKG_IDLE`: No guest customizationSpec has been applied for the VM
16072/// - `TOOLSDEPLOYPKG_PENDING`: The guest customizationSpec has been applied for the VM,
16073/// but the customization process has not yet started inside the guest OS
16074/// - `TOOLSDEPLOYPKG_RUNNING`: The customization process is currently running inside the guest OS
16075/// - `TOOLSDEPLOYPKG_SUCCEEDED`: The customization process has completed successfully inside the
16076/// guest OS
16077/// - `TOOLSDEPLOYPKG_FAILED`: The customizatio process has failed inside the guest OS
16078///
16079/// ***Since:*** vSphere API Release 7.0.2.0
16080#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
16081pub enum GuestInfoCustomizationStatusEnum {
16082 #[serde(rename = "TOOLSDEPLOYPKG_IDLE")]
16083 #[strum(serialize = "TOOLSDEPLOYPKG_IDLE")]
16084 ToolsdeploypkgIdle,
16085 #[serde(rename = "TOOLSDEPLOYPKG_PENDING")]
16086 #[strum(serialize = "TOOLSDEPLOYPKG_PENDING")]
16087 ToolsdeploypkgPending,
16088 #[serde(rename = "TOOLSDEPLOYPKG_RUNNING")]
16089 #[strum(serialize = "TOOLSDEPLOYPKG_RUNNING")]
16090 ToolsdeploypkgRunning,
16091 #[serde(rename = "TOOLSDEPLOYPKG_SUCCEEDED")]
16092 #[strum(serialize = "TOOLSDEPLOYPKG_SUCCEEDED")]
16093 ToolsdeploypkgSucceeded,
16094 #[serde(rename = "TOOLSDEPLOYPKG_FAILED")]
16095 #[strum(serialize = "TOOLSDEPLOYPKG_FAILED")]
16096 ToolsdeploypkgFailed,
16097 /// This variant handles values not known at compile time.
16098 #[serde(untagged)]
16099 #[strum(serialize = "__OTHER__")]
16100 Other_(String),
16101}
16102/// The possible hints that the guest could display about current tasks
16103/// inside the guest.
16104///
16105/// Possible values:
16106/// - `running`
16107/// - `shuttingDown`
16108/// - `resetting`
16109/// - `standby`
16110/// - `notRunning`
16111/// - `unknown`
16112#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
16113pub enum VirtualMachineGuestStateEnum {
16114 #[serde(rename = "running")]
16115 #[strum(serialize = "running")]
16116 Running,
16117 #[serde(rename = "shuttingDown")]
16118 #[strum(serialize = "shuttingDown")]
16119 ShuttingDown,
16120 #[serde(rename = "resetting")]
16121 #[strum(serialize = "resetting")]
16122 Resetting,
16123 #[serde(rename = "standby")]
16124 #[strum(serialize = "standby")]
16125 Standby,
16126 #[serde(rename = "notRunning")]
16127 #[strum(serialize = "notRunning")]
16128 NotRunning,
16129 #[serde(rename = "unknown")]
16130 #[strum(serialize = "unknown")]
16131 Unknown,
16132 /// This variant handles values not known at compile time.
16133 #[serde(untagged)]
16134 #[strum(serialize = "__OTHER__")]
16135 Other_(String),
16136}
16137/// The installation type of tools in the VM.
16138///
16139/// Possible values:
16140/// - `guestToolsTypeUnknown`: Installation type is not known.
16141///
16142/// Most likely tools have been
16143/// installed by OSPs or open-vm-tools, but a version that does
16144/// not report its install type or an install type that we do
16145/// not recognize.
16146/// - `guestToolsTypeMSI`: MSI is the installation type used for VMware Tools on Windows.
16147/// - `guestToolsTypeTar`: Tools have been installed by the tar installer.
16148/// - `guestToolsTypeOSP`: OSPs are RPM or Debian packages tailored for the OS in the VM.
16149///
16150/// See http://packages.vmware.com
16151/// - `guestToolsTypeOpenVMTools`: open-vm-tools are the open-source version of VMware Tools, may have
16152/// been packaged by the OS vendor.
16153#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
16154pub enum VirtualMachineToolsInstallTypeEnum {
16155 #[serde(rename = "guestToolsTypeUnknown")]
16156 #[strum(serialize = "guestToolsTypeUnknown")]
16157 GuestToolsTypeUnknown,
16158 #[serde(rename = "guestToolsTypeMSI")]
16159 #[strum(serialize = "guestToolsTypeMSI")]
16160 GuestToolsTypeMsi,
16161 #[serde(rename = "guestToolsTypeTar")]
16162 #[strum(serialize = "guestToolsTypeTar")]
16163 GuestToolsTypeTar,
16164 #[serde(rename = "guestToolsTypeOSP")]
16165 #[strum(serialize = "guestToolsTypeOSP")]
16166 GuestToolsTypeOsp,
16167 #[serde(rename = "guestToolsTypeOpenVMTools")]
16168 #[strum(serialize = "guestToolsTypeOpenVMTools")]
16169 GuestToolsTypeOpenVmTools,
16170 /// This variant handles values not known at compile time.
16171 #[serde(untagged)]
16172 #[strum(serialize = "__OTHER__")]
16173 Other_(String),
16174}
16175/// Current running status of VMware Tools running in the guest
16176/// operating system.
16177///
16178/// Possible values:
16179/// - `guestToolsNotRunning`: VMware Tools is not running.
16180/// - `guestToolsRunning`: VMware Tools is running.
16181/// - `guestToolsExecutingScripts`: VMware Tools is starting.
16182#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
16183pub enum VirtualMachineToolsRunningStatusEnum {
16184 #[serde(rename = "guestToolsNotRunning")]
16185 #[strum(serialize = "guestToolsNotRunning")]
16186 GuestToolsNotRunning,
16187 #[serde(rename = "guestToolsRunning")]
16188 #[strum(serialize = "guestToolsRunning")]
16189 GuestToolsRunning,
16190 #[serde(rename = "guestToolsExecutingScripts")]
16191 #[strum(serialize = "guestToolsExecutingScripts")]
16192 GuestToolsExecutingScripts,
16193 /// This variant handles values not known at compile time.
16194 #[serde(untagged)]
16195 #[strum(serialize = "__OTHER__")]
16196 Other_(String),
16197}
16198/// Deprecated as of vSphere API 4.0 use *VirtualMachineToolsVersionStatus_enum*
16199/// and *VirtualMachineToolsRunningStatus_enum*.
16200///
16201/// Current status of VMware Tools running in the guest operating system.
16202///
16203/// Possible values:
16204/// - `toolsNotInstalled`: VMware Tools has never been installed
16205/// or has not run in the virtual machine.
16206/// - `toolsNotRunning`: VMware Tools is not running.
16207/// - `toolsOld`: VMware Tools is running, but the version is not current.
16208/// - `toolsOk`: VMware Tools is running and the version is current.
16209#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
16210pub enum VirtualMachineToolsStatusEnum {
16211 #[serde(rename = "toolsNotInstalled")]
16212 #[strum(serialize = "toolsNotInstalled")]
16213 ToolsNotInstalled,
16214 #[serde(rename = "toolsNotRunning")]
16215 #[strum(serialize = "toolsNotRunning")]
16216 ToolsNotRunning,
16217 #[serde(rename = "toolsOld")]
16218 #[strum(serialize = "toolsOld")]
16219 ToolsOld,
16220 #[serde(rename = "toolsOk")]
16221 #[strum(serialize = "toolsOk")]
16222 ToolsOk,
16223 /// This variant handles values not known at compile time.
16224 #[serde(untagged)]
16225 #[strum(serialize = "__OTHER__")]
16226 Other_(String),
16227}
16228/// Current version status of VMware Tools installed in the guest operating
16229/// system.
16230///
16231/// Possible values:
16232/// - `guestToolsNotInstalled`: VMware Tools has never been installed.
16233/// - `guestToolsNeedUpgrade`:
16234///
16235/// Deprecated as of vSphere API 5.1 value is not reported by
16236/// toolsVersionStatus2, instead more detailed status is reported.
16237///
16238/// VMware Tools is installed, but the version is not current.
16239/// - `guestToolsCurrent`: VMware Tools is installed, and the version is current.
16240/// - `guestToolsUnmanaged`: VMware Tools is installed, but it is not managed by VMWare.
16241/// - `guestToolsTooOld`: VMware Tools is installed, but the version is too old.
16242/// - `guestToolsSupportedOld`: VMware Tools is installed, supported, but a newer version is available.
16243/// - `guestToolsSupportedNew`: VMware Tools is installed, supported, and newer
16244/// than the version available on the host.
16245/// - `guestToolsTooNew`: VMware Tools is installed, and the version is known to be
16246/// too new to work correctly with this virtual machine.
16247/// - `guestToolsBlacklisted`: VMware Tools is installed, but the installed version is
16248/// known to have a grave bug and should be immediately upgraded.
16249#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
16250pub enum VirtualMachineToolsVersionStatusEnum {
16251 #[serde(rename = "guestToolsNotInstalled")]
16252 #[strum(serialize = "guestToolsNotInstalled")]
16253 GuestToolsNotInstalled,
16254 #[serde(rename = "guestToolsNeedUpgrade")]
16255 #[strum(serialize = "guestToolsNeedUpgrade")]
16256 GuestToolsNeedUpgrade,
16257 #[serde(rename = "guestToolsCurrent")]
16258 #[strum(serialize = "guestToolsCurrent")]
16259 GuestToolsCurrent,
16260 #[serde(rename = "guestToolsUnmanaged")]
16261 #[strum(serialize = "guestToolsUnmanaged")]
16262 GuestToolsUnmanaged,
16263 #[serde(rename = "guestToolsTooOld")]
16264 #[strum(serialize = "guestToolsTooOld")]
16265 GuestToolsTooOld,
16266 #[serde(rename = "guestToolsSupportedOld")]
16267 #[strum(serialize = "guestToolsSupportedOld")]
16268 GuestToolsSupportedOld,
16269 #[serde(rename = "guestToolsSupportedNew")]
16270 #[strum(serialize = "guestToolsSupportedNew")]
16271 GuestToolsSupportedNew,
16272 #[serde(rename = "guestToolsTooNew")]
16273 #[strum(serialize = "guestToolsTooNew")]
16274 GuestToolsTooNew,
16275 #[serde(rename = "guestToolsBlacklisted")]
16276 #[strum(serialize = "guestToolsBlacklisted")]
16277 GuestToolsBlacklisted,
16278 /// This variant handles values not known at compile time.
16279 #[serde(untagged)]
16280 #[strum(serialize = "__OTHER__")]
16281 Other_(String),
16282}
16283/// Firmware types
16284///
16285/// Possible values:
16286/// - `bios`: BIOS firmware
16287/// - `efi`: Extensible Firmware Interface
16288#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
16289pub enum GuestOsDescriptorFirmwareTypeEnum {
16290 #[serde(rename = "bios")]
16291 #[strum(serialize = "bios")]
16292 Bios,
16293 #[serde(rename = "efi")]
16294 #[strum(serialize = "efi")]
16295 Efi,
16296 /// This variant handles values not known at compile time.
16297 #[serde(untagged)]
16298 #[strum(serialize = "__OTHER__")]
16299 Other_(String),
16300}
16301/// Guest operating system family constants.
16302///
16303/// Possible values:
16304/// - `windowsGuest`: Windows operating system
16305/// - `linuxGuest`: Linux operating system
16306/// - `netwareGuest`: Novell Netware
16307/// - `solarisGuest`: Solaris operating system
16308/// - `darwinGuestFamily`: Mac OS operating system
16309/// - `otherGuestFamily`: Other operating systems
16310#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
16311pub enum VirtualMachineGuestOsFamilyEnum {
16312 #[serde(rename = "windowsGuest")]
16313 #[strum(serialize = "windowsGuest")]
16314 WindowsGuest,
16315 #[serde(rename = "linuxGuest")]
16316 #[strum(serialize = "linuxGuest")]
16317 LinuxGuest,
16318 #[serde(rename = "netwareGuest")]
16319 #[strum(serialize = "netwareGuest")]
16320 NetwareGuest,
16321 #[serde(rename = "solarisGuest")]
16322 #[strum(serialize = "solarisGuest")]
16323 SolarisGuest,
16324 #[serde(rename = "darwinGuestFamily")]
16325 #[strum(serialize = "darwinGuestFamily")]
16326 DarwinGuestFamily,
16327 #[serde(rename = "otherGuestFamily")]
16328 #[strum(serialize = "otherGuestFamily")]
16329 OtherGuestFamily,
16330 /// This variant handles values not known at compile time.
16331 #[serde(untagged)]
16332 #[strum(serialize = "__OTHER__")]
16333 Other_(String),
16334}
16335/// Guest operating system identifier.
16336///
16337/// Possible values:
16338/// - `dosGuest`: MS-DOS.
16339/// - `win31Guest`: Windows 3.1
16340/// - `win95Guest`: Windows 95
16341/// - `win98Guest`: Windows 98
16342/// - `winMeGuest`: Windows Millennium Edition
16343/// - `winNTGuest`: Windows NT 4
16344/// - `win2000ProGuest`: Windows 2000 Professional
16345/// - `win2000ServGuest`: Windows 2000 Server
16346/// - `win2000AdvServGuest`: Windows 2000 Advanced Server
16347/// - `winXPHomeGuest`: Windows XP Home Edition
16348/// - `winXPProGuest`: Windows XP Professional
16349/// - `winXPPro64Guest`: Windows XP Professional Edition (64 bit)
16350/// - `winNetWebGuest`: Windows Server 2003, Web Edition
16351/// - `winNetStandardGuest`: Windows Server 2003, Standard Edition
16352/// - `winNetEnterpriseGuest`: Windows Server 2003, Enterprise Edition
16353/// - `winNetDatacenterGuest`: Windows Server 2003, Datacenter Edition
16354/// - `winNetBusinessGuest`: Windows Small Business Server 2003
16355/// - `winNetStandard64Guest`: Windows Server 2003, Standard Edition (64 bit)
16356/// - `winNetEnterprise64Guest`: Windows Server 2003, Enterprise Edition (64 bit)
16357/// - `winLonghornGuest`: Windows Longhorn
16358/// - `winLonghorn64Guest`: Windows Longhorn (64 bit)
16359/// - `winNetDatacenter64Guest`: Windows Server 2003, Datacenter Edition (64 bit)
16360/// - `winVistaGuest`: Windows Vista
16361/// - `winVista64Guest`: Windows Vista (64 bit)
16362/// - `windows7Guest`: Windows 7
16363/// - `windows7_64Guest`: Windows 7 (64 bit)
16364/// - `windows7Server64Guest`: Windows Server 2008 R2 (64 bit)
16365/// - `windows8Guest`: Windows 8
16366/// - `windows8_64Guest`: Windows 8 (64 bit)
16367/// - `windows8Server64Guest`: Windows 8 Server (64 bit)
16368/// - `windows9Guest`: Windows 10
16369/// - `windows9_64Guest`: Windows 10 (64 bit)
16370/// - `windows9Server64Guest`: Windows 10 Server (64 bit)
16371/// - `windows11_64Guest`: Windows 11
16372///
16373/// ***Since:*** vSphere API Release 8.0.0.1
16374/// - `windows12_64Guest`: Windows 12
16375///
16376/// ***Since:*** vSphere API Release 8.0.0.1
16377/// - `windowsHyperVGuest`: Windows Hyper-V
16378/// - `windows2019srv_64Guest`: Windows Server 2019
16379/// - `windows2019srvNext_64Guest`: Windows Server 2022
16380///
16381/// ***Since:*** vSphere API Release 7.0.1.0
16382/// - `windows2022srvNext_64Guest`: Windows Server 2025
16383///
16384/// ***Since:*** vSphere API Release 8.0.0.1
16385/// - `freebsdGuest`: FreeBSD
16386/// - `freebsd64Guest`: FreeBSD x64
16387/// - `freebsd11Guest`: FreeBSD 11
16388/// - `freebsd11_64Guest`: FreeBSD 11 x64
16389/// - `freebsd12Guest`: FreeBSD 12
16390/// - `freebsd12_64Guest`: FreeBSD 12 x64
16391/// - `freebsd13Guest`: FreeBSD 13
16392///
16393/// ***Since:*** vSphere API Release 7.0.1.0
16394/// - `freebsd13_64Guest`: FreeBSD 13 x64
16395///
16396/// ***Since:*** vSphere API Release 7.0.1.0
16397/// - `freebsd14Guest`: FreeBSD 14
16398///
16399/// ***Since:*** vSphere API Release 8.0.0.1
16400/// - `freebsd14_64Guest`: FreeBSD 14 x64
16401///
16402/// ***Since:*** vSphere API Release 8.0.0.1
16403/// - `freebsd15Guest`: FreeBSD 15
16404///
16405/// ***Since:*** vSphere API Release 9.0.0.0
16406/// - `freebsd15_64Guest`: FreeBSD 15 x64
16407///
16408/// ***Since:*** vSphere API Release 9.0.0.0
16409/// - `redhatGuest`: Red Hat Linux 2.1
16410/// - `rhel2Guest`: Red Hat Enterprise Linux 2
16411/// - `rhel3Guest`: Red Hat Enterprise Linux 3
16412/// - `rhel3_64Guest`: Red Hat Enterprise Linux 3 (64 bit)
16413/// - `rhel4Guest`: Red Hat Enterprise Linux 4
16414/// - `rhel4_64Guest`: Red Hat Enterprise Linux 4 (64 bit)
16415/// - `rhel5Guest`: Red Hat Enterprise Linux 5
16416/// - `rhel5_64Guest`: Red Hat Enterprise Linux 5 (64 bit)
16417/// - `rhel6Guest`: Red Hat Enterprise Linux 6
16418/// - `rhel6_64Guest`: Red Hat Enterprise Linux 6 (64 bit)
16419/// - `rhel7Guest`: Red Hat Enterprise Linux 7
16420/// - `rhel7_64Guest`: Red Hat Enterprise Linux 7 (64 bit)
16421/// - `rhel8_64Guest`: Red Hat Enterprise Linux 8 (64 bit)
16422/// - `rhel9_64Guest`: Red Hat Enterprise Linux 9 (64 bit)
16423///
16424/// ***Since:*** vSphere API Release 7.0.1.0
16425/// - `rhel10_64Guest`: Red Hat Enterprise Linux 10 (64 bit)
16426///
16427/// ***Since:*** vSphere API Release 9.0.0.0
16428/// - `centosGuest`: CentOS 4/5
16429/// - `centos64Guest`: CentOS 4/5 (64-bit)
16430/// - `centos6Guest`: CentOS 6
16431/// - `centos6_64Guest`: CentOS 6 (64-bit)
16432/// - `centos7Guest`: CentOS 7
16433/// - `centos7_64Guest`: CentOS 7 (64-bit)
16434/// - `centos8_64Guest`: CentOS 8 (64-bit)
16435/// - `centos9_64Guest`: CentOS 9 (64-bit)
16436///
16437/// ***Since:*** vSphere API Release 7.0.1.0
16438/// - `oracleLinuxGuest`: Oracle Linux 4/5
16439/// - `oracleLinux64Guest`: Oracle Linux 4/5 (64-bit)
16440/// - `oracleLinux6Guest`: Oracle 6
16441/// - `oracleLinux6_64Guest`: Oracle 6 (64-bit)
16442/// - `oracleLinux7Guest`: Oracle 7
16443/// - `oracleLinux7_64Guest`: Oracle 7 (64-bit)
16444/// - `oracleLinux8_64Guest`: Oracle 8 (64-bit)
16445/// - `oracleLinux9_64Guest`: Oracle 9 (64-bit)
16446///
16447/// ***Since:*** vSphere API Release 7.0.1.0
16448/// - `oracleLinux10_64Guest`: Oracle 10 (64-bit)
16449///
16450/// ***Since:*** vSphere API Release 9.0.0.0
16451/// - `suseGuest`: Suse Linux
16452/// - `suse64Guest`: Suse Linux (64 bit)
16453/// - `slesGuest`: Suse Linux Enterprise Server 9
16454/// - `sles64Guest`: Suse Linux Enterprise Server 9 (64 bit)
16455/// - `sles10Guest`: Suse linux Enterprise Server 10
16456/// - `sles10_64Guest`: Suse Linux Enterprise Server 10 (64 bit)
16457/// - `sles11Guest`: Suse linux Enterprise Server 11
16458/// - `sles11_64Guest`: Suse Linux Enterprise Server 11 (64 bit)
16459/// - `sles12Guest`: Suse linux Enterprise Server 12
16460/// - `sles12_64Guest`: Suse Linux Enterprise Server 12 (64 bit)
16461/// - `sles15_64Guest`: Suse Linux Enterprise Server 15 (64 bit)
16462/// - `sles16_64Guest`: Suse Linux Enterprise Server 16 (64 bit)
16463///
16464/// ***Since:*** vSphere API Release 7.0.1.0
16465/// - `nld9Guest`: Novell Linux Desktop 9
16466/// - `oesGuest`: Open Enterprise Server
16467/// - `sjdsGuest`: Sun Java Desktop System
16468/// - `mandrakeGuest`: Mandrake Linux
16469/// - `mandrivaGuest`: Mandriva Linux
16470/// - `mandriva64Guest`: Mandriva Linux (64 bit)
16471/// - `turboLinuxGuest`: Turbolinux
16472/// - `turboLinux64Guest`: Turbolinux (64 bit)
16473/// - `ubuntuGuest`: Ubuntu Linux
16474/// - `ubuntu64Guest`: Ubuntu Linux (64 bit)
16475/// - `debian4Guest`: Debian GNU/Linux 4
16476/// - `debian4_64Guest`: Debian GNU/Linux 4 (64 bit)
16477/// - `debian5Guest`: Debian GNU/Linux 5
16478/// - `debian5_64Guest`: Debian GNU/Linux 5 (64 bit)
16479/// - `debian6Guest`: Debian GNU/Linux 6
16480/// - `debian6_64Guest`: Debian GNU/Linux 6 (64 bit)
16481/// - `debian7Guest`: Debian GNU/Linux 7
16482/// - `debian7_64Guest`: Debian GNU/Linux 7 (64 bit)
16483/// - `debian8Guest`: Debian GNU/Linux 8
16484/// - `debian8_64Guest`: Debian GNU/Linux 8 (64 bit)
16485/// - `debian9Guest`: Debian GNU/Linux 9
16486/// - `debian9_64Guest`: Debian GNU/Linux 9 (64 bit)
16487/// - `debian10Guest`: Debian GNU/Linux 10
16488/// - `debian10_64Guest`: Debian GNU/Linux 10 (64 bit)
16489/// - `debian11Guest`: Debian GNU/Linux 11
16490/// - `debian11_64Guest`: Debian GNU/Linux 11 (64 bit)
16491/// - `debian12Guest`: Debian GNU/Linux 12
16492///
16493/// ***Since:*** vSphere API Release 8.0.0.1
16494/// - `debian12_64Guest`: Debian GNU/Linux 12 (64 bit)
16495///
16496/// ***Since:*** vSphere API Release 8.0.0.1
16497/// - `debian13Guest`: Debian GNU/Linux 13
16498///
16499/// ***Since:*** vSphere API Release 9.0.0.0
16500/// - `debian13_64Guest`: Debian GNU/Linux 13 (64 bit)
16501///
16502/// ***Since:*** vSphere API Release 9.0.0.0
16503/// - `asianux3Guest`: Asianux Server 3
16504/// - `asianux3_64Guest`: Asianux Server 3 (64 bit)
16505/// - `asianux4Guest`: Asianux Server 4
16506/// - `asianux4_64Guest`: Asianux Server 4 (64 bit)
16507/// - `asianux5_64Guest`: Asianux Server 5 (64 bit)
16508/// - `asianux7_64Guest`: Asianux Server 7 (64 bit)
16509/// - `asianux8_64Guest`: Asianux Server 8 (64 bit)
16510/// - `asianux9_64Guest`: Asianux Server 9 (64 bit)
16511///
16512/// ***Since:*** vSphere API Release 7.0.1.0
16513/// - `miraclelinux_64Guest`: MIRACLE LINUX (64-bit)
16514///
16515/// ***Since:*** vSphere API Release 9.0.0.0
16516/// - `pardus_64Guest`: Pardus (64-bit)
16517///
16518/// ***Since:*** vSphere API Release 9.0.0.0
16519/// - `opensuseGuest`: OpenSUSE Linux
16520/// - `opensuse64Guest`: OpenSUSE Linux (64 bit)
16521/// - `fedoraGuest`: Fedora Linux
16522/// - `fedora64Guest`: Fedora Linux (64 bit)
16523/// - `coreos64Guest`: CoreOS Linux (64 bit)
16524/// - `vmwarePhoton64Guest`: VMware Photon (64 bit)
16525/// - `other24xLinuxGuest`: Linux 2.4x Kernel
16526/// - `other26xLinuxGuest`: Linux 2.6x Kernel
16527/// - `otherLinuxGuest`: Linux 2.2x Kernel
16528/// - `other3xLinuxGuest`: Linux 3.x Kernel
16529/// - `other4xLinuxGuest`: Linux 4.x Kernel
16530/// - `other5xLinuxGuest`: Linux 5.x Kernel
16531///
16532/// ***Since:*** vSphere API Release 7.0.1.0
16533/// - `other6xLinuxGuest`: Linux 6.x Kernel
16534///
16535/// ***Since:*** vSphere API Release 8.0.0.1
16536/// - `other7xLinuxGuest`: Linux 7.x Kernel
16537///
16538/// ***Since:*** vSphere API Release 9.0.0.0
16539/// - `genericLinuxGuest`: Other Linux
16540/// - `other24xLinux64Guest`: Linux 2.4.x Kernel (64 bit)
16541/// - `other26xLinux64Guest`: Linux 2.6.x Kernel (64 bit)
16542/// - `other3xLinux64Guest`: Linux 3.x Kernel (64 bit)
16543/// - `other4xLinux64Guest`: Linux 4.x Kernel (64 bit)
16544/// - `other5xLinux64Guest`: Linux 5.x Kernel (64 bit)
16545///
16546/// ***Since:*** vSphere API Release 7.0.1.0
16547/// - `other6xLinux64Guest`: Linux 6.x Kernel (64 bit)
16548///
16549/// ***Since:*** vSphere API Release 8.0.0.1
16550/// - `other7xLinux64Guest`: Linux 7.x Kernel (64 bit)
16551///
16552/// ***Since:*** vSphere API Release 9.0.0.0
16553/// - `otherLinux64Guest`: Linux (64 bit)
16554/// - `solaris6Guest`: Solaris 6
16555/// - `solaris7Guest`: Solaris 7
16556/// - `solaris8Guest`: Solaris 8
16557/// - `solaris9Guest`: Solaris 9
16558/// - `solaris10Guest`: Solaris 10 (32 bit)
16559/// - `solaris10_64Guest`: Solaris 10 (64 bit)
16560/// - `solaris11_64Guest`: Solaris 11 (64 bit)
16561/// - `fusionos_64Guest`: FusionOS (64 bit)
16562///
16563/// ***Since:*** vSphere API Release 9.0.0.0
16564/// - `prolinux_64Guest`: ProLinux (64 bit)
16565///
16566/// ***Since:*** vSphere API Release 9.0.0.0
16567/// - `kylinlinux_64Guest`: Kylinlinux (64 bit)
16568///
16569/// ***Since:*** vSphere API Release 9.0.0.0
16570/// - `os2Guest`: OS/2
16571/// - `eComStationGuest`: eComStation 1.x
16572/// - `eComStation2Guest`: eComStation 2.0
16573/// - `netware4Guest`: Novell NetWare 4
16574/// - `netware5Guest`: Novell NetWare 5.1
16575/// - `netware6Guest`: Novell NetWare 6.x
16576/// - `openServer5Guest`: SCO OpenServer 5
16577/// - `openServer6Guest`: SCO OpenServer 6
16578/// - `unixWare7Guest`: SCO UnixWare 7
16579/// - `darwinGuest`: Mac OS 10.5
16580/// - `darwin64Guest`: Mac OS 10.5 (64 bit)
16581/// - `darwin10Guest`: Mac OS 10.6
16582/// - `darwin10_64Guest`: Mac OS 10.6 (64 bit)
16583/// - `darwin11Guest`: Mac OS 10.7
16584/// - `darwin11_64Guest`: Mac OS 10.7 (64 bit)
16585/// - `darwin12_64Guest`: Mac OS 10.8 (64 bit)
16586/// - `darwin13_64Guest`: Mac OS 10.9 (64 bit)
16587/// - `darwin14_64Guest`: Mac OS 10.10 (64 bit)
16588/// - `darwin15_64Guest`: Mac OS 10.11 (64 bit)
16589/// - `darwin16_64Guest`: Mac OS 10.12 (64 bit)
16590/// - `darwin17_64Guest`: macOS 10.13 (64 bit)
16591/// - `darwin18_64Guest`: macOS 10.14 (64 bit)
16592/// - `darwin19_64Guest`: macOS 10.15 (64 bit)
16593/// - `darwin20_64Guest`: macOS 11 (64 bit)
16594///
16595/// ***Since:*** vSphere API Release 7.0.1.0
16596/// - `darwin21_64Guest`: macOS 12 (64 bit)
16597///
16598/// ***Since:*** vSphere API Release 7.0.1.0
16599/// - `darwin22_64Guest`: macOS 13 (64 bit)
16600///
16601/// ***Since:*** vSphere API Release 8.0.0.1
16602/// - `darwin23_64Guest`: macOS 14 (64 bit)
16603///
16604/// ***Since:*** vSphere API Release 8.0.0.1
16605/// - `vmkernelGuest`: VMware ESX 4
16606/// - `vmkernel5Guest`: VMware ESX 5
16607/// - `vmkernel6Guest`: VMware ESX 6
16608/// - `vmkernel65Guest`: VMware ESXi 6.5 AND ESXi 6.7.
16609/// - `vmkernel7Guest`: VMware ESX 7
16610/// - `vmkernel8Guest`: VMware ESX 8
16611///
16612/// ***Since:*** vSphere API Release 8.0.0.1
16613/// - `vmkernel9Guest`: VMware ESX 9
16614///
16615/// ***Since:*** vSphere API Release 9.0.0.0
16616/// - `amazonlinux2_64Guest`: Amazon Linux 2 (64 bit)
16617/// - `amazonlinux3_64Guest`: Amazon Linux 3 (64 bit)
16618///
16619/// ***Since:*** vSphere API Release 7.0.1.0
16620/// - `crxPod1Guest`: CRX Pod 1
16621/// - `crxSys1Guest`: CRX Sys 1
16622///
16623/// ***Since:*** vSphere API Release 8.0.3.0
16624/// - `rockylinux_64Guest`: Rocky Linux (64-bit)
16625///
16626/// ***Since:*** vSphere API Release 8.0.0.1
16627/// - `almalinux_64Guest`: AlmaLinux (64-bit)
16628///
16629/// ***Since:*** vSphere API Release 8.0.0.1
16630/// - `otherGuest`: Other Operating System
16631/// - `otherGuest64`: Other Operating System (64 bit)
16632#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
16633pub enum VirtualMachineGuestOsIdentifierEnum {
16634 #[serde(rename = "dosGuest")]
16635 #[strum(serialize = "dosGuest")]
16636 DosGuest,
16637 #[serde(rename = "win31Guest")]
16638 #[strum(serialize = "win31Guest")]
16639 Win31Guest,
16640 #[serde(rename = "win95Guest")]
16641 #[strum(serialize = "win95Guest")]
16642 Win95Guest,
16643 #[serde(rename = "win98Guest")]
16644 #[strum(serialize = "win98Guest")]
16645 Win98Guest,
16646 #[serde(rename = "winMeGuest")]
16647 #[strum(serialize = "winMeGuest")]
16648 WinMeGuest,
16649 #[serde(rename = "winNTGuest")]
16650 #[strum(serialize = "winNTGuest")]
16651 WinNtGuest,
16652 #[serde(rename = "win2000ProGuest")]
16653 #[strum(serialize = "win2000ProGuest")]
16654 Win2000ProGuest,
16655 #[serde(rename = "win2000ServGuest")]
16656 #[strum(serialize = "win2000ServGuest")]
16657 Win2000ServGuest,
16658 #[serde(rename = "win2000AdvServGuest")]
16659 #[strum(serialize = "win2000AdvServGuest")]
16660 Win2000AdvServGuest,
16661 #[serde(rename = "winXPHomeGuest")]
16662 #[strum(serialize = "winXPHomeGuest")]
16663 WinXpHomeGuest,
16664 #[serde(rename = "winXPProGuest")]
16665 #[strum(serialize = "winXPProGuest")]
16666 WinXpProGuest,
16667 #[serde(rename = "winXPPro64Guest")]
16668 #[strum(serialize = "winXPPro64Guest")]
16669 WinXpPro64Guest,
16670 #[serde(rename = "winNetWebGuest")]
16671 #[strum(serialize = "winNetWebGuest")]
16672 WinNetWebGuest,
16673 #[serde(rename = "winNetStandardGuest")]
16674 #[strum(serialize = "winNetStandardGuest")]
16675 WinNetStandardGuest,
16676 #[serde(rename = "winNetEnterpriseGuest")]
16677 #[strum(serialize = "winNetEnterpriseGuest")]
16678 WinNetEnterpriseGuest,
16679 #[serde(rename = "winNetDatacenterGuest")]
16680 #[strum(serialize = "winNetDatacenterGuest")]
16681 WinNetDatacenterGuest,
16682 #[serde(rename = "winNetBusinessGuest")]
16683 #[strum(serialize = "winNetBusinessGuest")]
16684 WinNetBusinessGuest,
16685 #[serde(rename = "winNetStandard64Guest")]
16686 #[strum(serialize = "winNetStandard64Guest")]
16687 WinNetStandard64Guest,
16688 #[serde(rename = "winNetEnterprise64Guest")]
16689 #[strum(serialize = "winNetEnterprise64Guest")]
16690 WinNetEnterprise64Guest,
16691 #[serde(rename = "winLonghornGuest")]
16692 #[strum(serialize = "winLonghornGuest")]
16693 WinLonghornGuest,
16694 #[serde(rename = "winLonghorn64Guest")]
16695 #[strum(serialize = "winLonghorn64Guest")]
16696 WinLonghorn64Guest,
16697 #[serde(rename = "winNetDatacenter64Guest")]
16698 #[strum(serialize = "winNetDatacenter64Guest")]
16699 WinNetDatacenter64Guest,
16700 #[serde(rename = "winVistaGuest")]
16701 #[strum(serialize = "winVistaGuest")]
16702 WinVistaGuest,
16703 #[serde(rename = "winVista64Guest")]
16704 #[strum(serialize = "winVista64Guest")]
16705 WinVista64Guest,
16706 #[serde(rename = "windows7Guest")]
16707 #[strum(serialize = "windows7Guest")]
16708 Windows7Guest,
16709 #[serde(rename = "windows7_64Guest")]
16710 #[strum(serialize = "windows7_64Guest")]
16711 Windows764Guest,
16712 #[serde(rename = "windows7Server64Guest")]
16713 #[strum(serialize = "windows7Server64Guest")]
16714 Windows7Server64Guest,
16715 #[serde(rename = "windows8Guest")]
16716 #[strum(serialize = "windows8Guest")]
16717 Windows8Guest,
16718 #[serde(rename = "windows8_64Guest")]
16719 #[strum(serialize = "windows8_64Guest")]
16720 Windows864Guest,
16721 #[serde(rename = "windows8Server64Guest")]
16722 #[strum(serialize = "windows8Server64Guest")]
16723 Windows8Server64Guest,
16724 #[serde(rename = "windows9Guest")]
16725 #[strum(serialize = "windows9Guest")]
16726 Windows9Guest,
16727 #[serde(rename = "windows9_64Guest")]
16728 #[strum(serialize = "windows9_64Guest")]
16729 Windows964Guest,
16730 #[serde(rename = "windows9Server64Guest")]
16731 #[strum(serialize = "windows9Server64Guest")]
16732 Windows9Server64Guest,
16733 #[serde(rename = "windows11_64Guest")]
16734 #[strum(serialize = "windows11_64Guest")]
16735 Windows1164Guest,
16736 #[serde(rename = "windows12_64Guest")]
16737 #[strum(serialize = "windows12_64Guest")]
16738 Windows1264Guest,
16739 #[serde(rename = "windowsHyperVGuest")]
16740 #[strum(serialize = "windowsHyperVGuest")]
16741 WindowsHyperVGuest,
16742 #[serde(rename = "windows2019srv_64Guest")]
16743 #[strum(serialize = "windows2019srv_64Guest")]
16744 Windows2019Srv64Guest,
16745 #[serde(rename = "windows2019srvNext_64Guest")]
16746 #[strum(serialize = "windows2019srvNext_64Guest")]
16747 Windows2019SrvNext64Guest,
16748 #[serde(rename = "windows2022srvNext_64Guest")]
16749 #[strum(serialize = "windows2022srvNext_64Guest")]
16750 Windows2022SrvNext64Guest,
16751 #[serde(rename = "freebsdGuest")]
16752 #[strum(serialize = "freebsdGuest")]
16753 FreebsdGuest,
16754 #[serde(rename = "freebsd64Guest")]
16755 #[strum(serialize = "freebsd64Guest")]
16756 Freebsd64Guest,
16757 #[serde(rename = "freebsd11Guest")]
16758 #[strum(serialize = "freebsd11Guest")]
16759 Freebsd11Guest,
16760 #[serde(rename = "freebsd11_64Guest")]
16761 #[strum(serialize = "freebsd11_64Guest")]
16762 Freebsd1164Guest,
16763 #[serde(rename = "freebsd12Guest")]
16764 #[strum(serialize = "freebsd12Guest")]
16765 Freebsd12Guest,
16766 #[serde(rename = "freebsd12_64Guest")]
16767 #[strum(serialize = "freebsd12_64Guest")]
16768 Freebsd1264Guest,
16769 #[serde(rename = "freebsd13Guest")]
16770 #[strum(serialize = "freebsd13Guest")]
16771 Freebsd13Guest,
16772 #[serde(rename = "freebsd13_64Guest")]
16773 #[strum(serialize = "freebsd13_64Guest")]
16774 Freebsd1364Guest,
16775 #[serde(rename = "freebsd14Guest")]
16776 #[strum(serialize = "freebsd14Guest")]
16777 Freebsd14Guest,
16778 #[serde(rename = "freebsd14_64Guest")]
16779 #[strum(serialize = "freebsd14_64Guest")]
16780 Freebsd1464Guest,
16781 #[serde(rename = "freebsd15Guest")]
16782 #[strum(serialize = "freebsd15Guest")]
16783 Freebsd15Guest,
16784 #[serde(rename = "freebsd15_64Guest")]
16785 #[strum(serialize = "freebsd15_64Guest")]
16786 Freebsd1564Guest,
16787 #[serde(rename = "redhatGuest")]
16788 #[strum(serialize = "redhatGuest")]
16789 RedhatGuest,
16790 #[serde(rename = "rhel2Guest")]
16791 #[strum(serialize = "rhel2Guest")]
16792 Rhel2Guest,
16793 #[serde(rename = "rhel3Guest")]
16794 #[strum(serialize = "rhel3Guest")]
16795 Rhel3Guest,
16796 #[serde(rename = "rhel3_64Guest")]
16797 #[strum(serialize = "rhel3_64Guest")]
16798 Rhel364Guest,
16799 #[serde(rename = "rhel4Guest")]
16800 #[strum(serialize = "rhel4Guest")]
16801 Rhel4Guest,
16802 #[serde(rename = "rhel4_64Guest")]
16803 #[strum(serialize = "rhel4_64Guest")]
16804 Rhel464Guest,
16805 #[serde(rename = "rhel5Guest")]
16806 #[strum(serialize = "rhel5Guest")]
16807 Rhel5Guest,
16808 #[serde(rename = "rhel5_64Guest")]
16809 #[strum(serialize = "rhel5_64Guest")]
16810 Rhel564Guest,
16811 #[serde(rename = "rhel6Guest")]
16812 #[strum(serialize = "rhel6Guest")]
16813 Rhel6Guest,
16814 #[serde(rename = "rhel6_64Guest")]
16815 #[strum(serialize = "rhel6_64Guest")]
16816 Rhel664Guest,
16817 #[serde(rename = "rhel7Guest")]
16818 #[strum(serialize = "rhel7Guest")]
16819 Rhel7Guest,
16820 #[serde(rename = "rhel7_64Guest")]
16821 #[strum(serialize = "rhel7_64Guest")]
16822 Rhel764Guest,
16823 #[serde(rename = "rhel8_64Guest")]
16824 #[strum(serialize = "rhel8_64Guest")]
16825 Rhel864Guest,
16826 #[serde(rename = "rhel9_64Guest")]
16827 #[strum(serialize = "rhel9_64Guest")]
16828 Rhel964Guest,
16829 #[serde(rename = "rhel10_64Guest")]
16830 #[strum(serialize = "rhel10_64Guest")]
16831 Rhel1064Guest,
16832 #[serde(rename = "centosGuest")]
16833 #[strum(serialize = "centosGuest")]
16834 CentosGuest,
16835 #[serde(rename = "centos64Guest")]
16836 #[strum(serialize = "centos64Guest")]
16837 Centos64Guest,
16838 #[serde(rename = "centos6Guest")]
16839 #[strum(serialize = "centos6Guest")]
16840 Centos6Guest,
16841 #[serde(rename = "centos6_64Guest")]
16842 #[strum(serialize = "centos6_64Guest")]
16843 Centos664Guest,
16844 #[serde(rename = "centos7Guest")]
16845 #[strum(serialize = "centos7Guest")]
16846 Centos7Guest,
16847 #[serde(rename = "centos7_64Guest")]
16848 #[strum(serialize = "centos7_64Guest")]
16849 Centos764Guest,
16850 #[serde(rename = "centos8_64Guest")]
16851 #[strum(serialize = "centos8_64Guest")]
16852 Centos864Guest,
16853 #[serde(rename = "centos9_64Guest")]
16854 #[strum(serialize = "centos9_64Guest")]
16855 Centos964Guest,
16856 #[serde(rename = "oracleLinuxGuest")]
16857 #[strum(serialize = "oracleLinuxGuest")]
16858 OracleLinuxGuest,
16859 #[serde(rename = "oracleLinux64Guest")]
16860 #[strum(serialize = "oracleLinux64Guest")]
16861 OracleLinux64Guest,
16862 #[serde(rename = "oracleLinux6Guest")]
16863 #[strum(serialize = "oracleLinux6Guest")]
16864 OracleLinux6Guest,
16865 #[serde(rename = "oracleLinux6_64Guest")]
16866 #[strum(serialize = "oracleLinux6_64Guest")]
16867 OracleLinux664Guest,
16868 #[serde(rename = "oracleLinux7Guest")]
16869 #[strum(serialize = "oracleLinux7Guest")]
16870 OracleLinux7Guest,
16871 #[serde(rename = "oracleLinux7_64Guest")]
16872 #[strum(serialize = "oracleLinux7_64Guest")]
16873 OracleLinux764Guest,
16874 #[serde(rename = "oracleLinux8_64Guest")]
16875 #[strum(serialize = "oracleLinux8_64Guest")]
16876 OracleLinux864Guest,
16877 #[serde(rename = "oracleLinux9_64Guest")]
16878 #[strum(serialize = "oracleLinux9_64Guest")]
16879 OracleLinux964Guest,
16880 #[serde(rename = "oracleLinux10_64Guest")]
16881 #[strum(serialize = "oracleLinux10_64Guest")]
16882 OracleLinux1064Guest,
16883 #[serde(rename = "suseGuest")]
16884 #[strum(serialize = "suseGuest")]
16885 SuseGuest,
16886 #[serde(rename = "suse64Guest")]
16887 #[strum(serialize = "suse64Guest")]
16888 Suse64Guest,
16889 #[serde(rename = "slesGuest")]
16890 #[strum(serialize = "slesGuest")]
16891 SlesGuest,
16892 #[serde(rename = "sles64Guest")]
16893 #[strum(serialize = "sles64Guest")]
16894 Sles64Guest,
16895 #[serde(rename = "sles10Guest")]
16896 #[strum(serialize = "sles10Guest")]
16897 Sles10Guest,
16898 #[serde(rename = "sles10_64Guest")]
16899 #[strum(serialize = "sles10_64Guest")]
16900 Sles1064Guest,
16901 #[serde(rename = "sles11Guest")]
16902 #[strum(serialize = "sles11Guest")]
16903 Sles11Guest,
16904 #[serde(rename = "sles11_64Guest")]
16905 #[strum(serialize = "sles11_64Guest")]
16906 Sles1164Guest,
16907 #[serde(rename = "sles12Guest")]
16908 #[strum(serialize = "sles12Guest")]
16909 Sles12Guest,
16910 #[serde(rename = "sles12_64Guest")]
16911 #[strum(serialize = "sles12_64Guest")]
16912 Sles1264Guest,
16913 #[serde(rename = "sles15_64Guest")]
16914 #[strum(serialize = "sles15_64Guest")]
16915 Sles1564Guest,
16916 #[serde(rename = "sles16_64Guest")]
16917 #[strum(serialize = "sles16_64Guest")]
16918 Sles1664Guest,
16919 #[serde(rename = "nld9Guest")]
16920 #[strum(serialize = "nld9Guest")]
16921 Nld9Guest,
16922 #[serde(rename = "oesGuest")]
16923 #[strum(serialize = "oesGuest")]
16924 OesGuest,
16925 #[serde(rename = "sjdsGuest")]
16926 #[strum(serialize = "sjdsGuest")]
16927 SjdsGuest,
16928 #[serde(rename = "mandrakeGuest")]
16929 #[strum(serialize = "mandrakeGuest")]
16930 MandrakeGuest,
16931 #[serde(rename = "mandrivaGuest")]
16932 #[strum(serialize = "mandrivaGuest")]
16933 MandrivaGuest,
16934 #[serde(rename = "mandriva64Guest")]
16935 #[strum(serialize = "mandriva64Guest")]
16936 Mandriva64Guest,
16937 #[serde(rename = "turboLinuxGuest")]
16938 #[strum(serialize = "turboLinuxGuest")]
16939 TurboLinuxGuest,
16940 #[serde(rename = "turboLinux64Guest")]
16941 #[strum(serialize = "turboLinux64Guest")]
16942 TurboLinux64Guest,
16943 #[serde(rename = "ubuntuGuest")]
16944 #[strum(serialize = "ubuntuGuest")]
16945 UbuntuGuest,
16946 #[serde(rename = "ubuntu64Guest")]
16947 #[strum(serialize = "ubuntu64Guest")]
16948 Ubuntu64Guest,
16949 #[serde(rename = "debian4Guest")]
16950 #[strum(serialize = "debian4Guest")]
16951 Debian4Guest,
16952 #[serde(rename = "debian4_64Guest")]
16953 #[strum(serialize = "debian4_64Guest")]
16954 Debian464Guest,
16955 #[serde(rename = "debian5Guest")]
16956 #[strum(serialize = "debian5Guest")]
16957 Debian5Guest,
16958 #[serde(rename = "debian5_64Guest")]
16959 #[strum(serialize = "debian5_64Guest")]
16960 Debian564Guest,
16961 #[serde(rename = "debian6Guest")]
16962 #[strum(serialize = "debian6Guest")]
16963 Debian6Guest,
16964 #[serde(rename = "debian6_64Guest")]
16965 #[strum(serialize = "debian6_64Guest")]
16966 Debian664Guest,
16967 #[serde(rename = "debian7Guest")]
16968 #[strum(serialize = "debian7Guest")]
16969 Debian7Guest,
16970 #[serde(rename = "debian7_64Guest")]
16971 #[strum(serialize = "debian7_64Guest")]
16972 Debian764Guest,
16973 #[serde(rename = "debian8Guest")]
16974 #[strum(serialize = "debian8Guest")]
16975 Debian8Guest,
16976 #[serde(rename = "debian8_64Guest")]
16977 #[strum(serialize = "debian8_64Guest")]
16978 Debian864Guest,
16979 #[serde(rename = "debian9Guest")]
16980 #[strum(serialize = "debian9Guest")]
16981 Debian9Guest,
16982 #[serde(rename = "debian9_64Guest")]
16983 #[strum(serialize = "debian9_64Guest")]
16984 Debian964Guest,
16985 #[serde(rename = "debian10Guest")]
16986 #[strum(serialize = "debian10Guest")]
16987 Debian10Guest,
16988 #[serde(rename = "debian10_64Guest")]
16989 #[strum(serialize = "debian10_64Guest")]
16990 Debian1064Guest,
16991 #[serde(rename = "debian11Guest")]
16992 #[strum(serialize = "debian11Guest")]
16993 Debian11Guest,
16994 #[serde(rename = "debian11_64Guest")]
16995 #[strum(serialize = "debian11_64Guest")]
16996 Debian1164Guest,
16997 #[serde(rename = "debian12Guest")]
16998 #[strum(serialize = "debian12Guest")]
16999 Debian12Guest,
17000 #[serde(rename = "debian12_64Guest")]
17001 #[strum(serialize = "debian12_64Guest")]
17002 Debian1264Guest,
17003 #[serde(rename = "debian13Guest")]
17004 #[strum(serialize = "debian13Guest")]
17005 Debian13Guest,
17006 #[serde(rename = "debian13_64Guest")]
17007 #[strum(serialize = "debian13_64Guest")]
17008 Debian1364Guest,
17009 #[serde(rename = "asianux3Guest")]
17010 #[strum(serialize = "asianux3Guest")]
17011 Asianux3Guest,
17012 #[serde(rename = "asianux3_64Guest")]
17013 #[strum(serialize = "asianux3_64Guest")]
17014 Asianux364Guest,
17015 #[serde(rename = "asianux4Guest")]
17016 #[strum(serialize = "asianux4Guest")]
17017 Asianux4Guest,
17018 #[serde(rename = "asianux4_64Guest")]
17019 #[strum(serialize = "asianux4_64Guest")]
17020 Asianux464Guest,
17021 #[serde(rename = "asianux5_64Guest")]
17022 #[strum(serialize = "asianux5_64Guest")]
17023 Asianux564Guest,
17024 #[serde(rename = "asianux7_64Guest")]
17025 #[strum(serialize = "asianux7_64Guest")]
17026 Asianux764Guest,
17027 #[serde(rename = "asianux8_64Guest")]
17028 #[strum(serialize = "asianux8_64Guest")]
17029 Asianux864Guest,
17030 #[serde(rename = "asianux9_64Guest")]
17031 #[strum(serialize = "asianux9_64Guest")]
17032 Asianux964Guest,
17033 #[serde(rename = "miraclelinux_64Guest")]
17034 #[strum(serialize = "miraclelinux_64Guest")]
17035 Miraclelinux64Guest,
17036 #[serde(rename = "pardus_64Guest")]
17037 #[strum(serialize = "pardus_64Guest")]
17038 Pardus64Guest,
17039 #[serde(rename = "opensuseGuest")]
17040 #[strum(serialize = "opensuseGuest")]
17041 OpensuseGuest,
17042 #[serde(rename = "opensuse64Guest")]
17043 #[strum(serialize = "opensuse64Guest")]
17044 Opensuse64Guest,
17045 #[serde(rename = "fedoraGuest")]
17046 #[strum(serialize = "fedoraGuest")]
17047 FedoraGuest,
17048 #[serde(rename = "fedora64Guest")]
17049 #[strum(serialize = "fedora64Guest")]
17050 Fedora64Guest,
17051 #[serde(rename = "coreos64Guest")]
17052 #[strum(serialize = "coreos64Guest")]
17053 Coreos64Guest,
17054 #[serde(rename = "vmwarePhoton64Guest")]
17055 #[strum(serialize = "vmwarePhoton64Guest")]
17056 VmwarePhoton64Guest,
17057 #[serde(rename = "other24xLinuxGuest")]
17058 #[strum(serialize = "other24xLinuxGuest")]
17059 Other24XLinuxGuest,
17060 #[serde(rename = "other26xLinuxGuest")]
17061 #[strum(serialize = "other26xLinuxGuest")]
17062 Other26XLinuxGuest,
17063 #[serde(rename = "otherLinuxGuest")]
17064 #[strum(serialize = "otherLinuxGuest")]
17065 OtherLinuxGuest,
17066 #[serde(rename = "other3xLinuxGuest")]
17067 #[strum(serialize = "other3xLinuxGuest")]
17068 Other3XLinuxGuest,
17069 #[serde(rename = "other4xLinuxGuest")]
17070 #[strum(serialize = "other4xLinuxGuest")]
17071 Other4XLinuxGuest,
17072 #[serde(rename = "other5xLinuxGuest")]
17073 #[strum(serialize = "other5xLinuxGuest")]
17074 Other5XLinuxGuest,
17075 #[serde(rename = "other6xLinuxGuest")]
17076 #[strum(serialize = "other6xLinuxGuest")]
17077 Other6XLinuxGuest,
17078 #[serde(rename = "other7xLinuxGuest")]
17079 #[strum(serialize = "other7xLinuxGuest")]
17080 Other7XLinuxGuest,
17081 #[serde(rename = "genericLinuxGuest")]
17082 #[strum(serialize = "genericLinuxGuest")]
17083 GenericLinuxGuest,
17084 #[serde(rename = "other24xLinux64Guest")]
17085 #[strum(serialize = "other24xLinux64Guest")]
17086 Other24XLinux64Guest,
17087 #[serde(rename = "other26xLinux64Guest")]
17088 #[strum(serialize = "other26xLinux64Guest")]
17089 Other26XLinux64Guest,
17090 #[serde(rename = "other3xLinux64Guest")]
17091 #[strum(serialize = "other3xLinux64Guest")]
17092 Other3XLinux64Guest,
17093 #[serde(rename = "other4xLinux64Guest")]
17094 #[strum(serialize = "other4xLinux64Guest")]
17095 Other4XLinux64Guest,
17096 #[serde(rename = "other5xLinux64Guest")]
17097 #[strum(serialize = "other5xLinux64Guest")]
17098 Other5XLinux64Guest,
17099 #[serde(rename = "other6xLinux64Guest")]
17100 #[strum(serialize = "other6xLinux64Guest")]
17101 Other6XLinux64Guest,
17102 #[serde(rename = "other7xLinux64Guest")]
17103 #[strum(serialize = "other7xLinux64Guest")]
17104 Other7XLinux64Guest,
17105 #[serde(rename = "otherLinux64Guest")]
17106 #[strum(serialize = "otherLinux64Guest")]
17107 OtherLinux64Guest,
17108 #[serde(rename = "solaris6Guest")]
17109 #[strum(serialize = "solaris6Guest")]
17110 Solaris6Guest,
17111 #[serde(rename = "solaris7Guest")]
17112 #[strum(serialize = "solaris7Guest")]
17113 Solaris7Guest,
17114 #[serde(rename = "solaris8Guest")]
17115 #[strum(serialize = "solaris8Guest")]
17116 Solaris8Guest,
17117 #[serde(rename = "solaris9Guest")]
17118 #[strum(serialize = "solaris9Guest")]
17119 Solaris9Guest,
17120 #[serde(rename = "solaris10Guest")]
17121 #[strum(serialize = "solaris10Guest")]
17122 Solaris10Guest,
17123 #[serde(rename = "solaris10_64Guest")]
17124 #[strum(serialize = "solaris10_64Guest")]
17125 Solaris1064Guest,
17126 #[serde(rename = "solaris11_64Guest")]
17127 #[strum(serialize = "solaris11_64Guest")]
17128 Solaris1164Guest,
17129 #[serde(rename = "fusionos_64Guest")]
17130 #[strum(serialize = "fusionos_64Guest")]
17131 Fusionos64Guest,
17132 #[serde(rename = "prolinux_64Guest")]
17133 #[strum(serialize = "prolinux_64Guest")]
17134 Prolinux64Guest,
17135 #[serde(rename = "kylinlinux_64Guest")]
17136 #[strum(serialize = "kylinlinux_64Guest")]
17137 Kylinlinux64Guest,
17138 #[serde(rename = "os2Guest")]
17139 #[strum(serialize = "os2Guest")]
17140 Os2Guest,
17141 #[serde(rename = "eComStationGuest")]
17142 #[strum(serialize = "eComStationGuest")]
17143 EComStationGuest,
17144 #[serde(rename = "eComStation2Guest")]
17145 #[strum(serialize = "eComStation2Guest")]
17146 EComStation2Guest,
17147 #[serde(rename = "netware4Guest")]
17148 #[strum(serialize = "netware4Guest")]
17149 Netware4Guest,
17150 #[serde(rename = "netware5Guest")]
17151 #[strum(serialize = "netware5Guest")]
17152 Netware5Guest,
17153 #[serde(rename = "netware6Guest")]
17154 #[strum(serialize = "netware6Guest")]
17155 Netware6Guest,
17156 #[serde(rename = "openServer5Guest")]
17157 #[strum(serialize = "openServer5Guest")]
17158 OpenServer5Guest,
17159 #[serde(rename = "openServer6Guest")]
17160 #[strum(serialize = "openServer6Guest")]
17161 OpenServer6Guest,
17162 #[serde(rename = "unixWare7Guest")]
17163 #[strum(serialize = "unixWare7Guest")]
17164 UnixWare7Guest,
17165 #[serde(rename = "darwinGuest")]
17166 #[strum(serialize = "darwinGuest")]
17167 DarwinGuest,
17168 #[serde(rename = "darwin64Guest")]
17169 #[strum(serialize = "darwin64Guest")]
17170 Darwin64Guest,
17171 #[serde(rename = "darwin10Guest")]
17172 #[strum(serialize = "darwin10Guest")]
17173 Darwin10Guest,
17174 #[serde(rename = "darwin10_64Guest")]
17175 #[strum(serialize = "darwin10_64Guest")]
17176 Darwin1064Guest,
17177 #[serde(rename = "darwin11Guest")]
17178 #[strum(serialize = "darwin11Guest")]
17179 Darwin11Guest,
17180 #[serde(rename = "darwin11_64Guest")]
17181 #[strum(serialize = "darwin11_64Guest")]
17182 Darwin1164Guest,
17183 #[serde(rename = "darwin12_64Guest")]
17184 #[strum(serialize = "darwin12_64Guest")]
17185 Darwin1264Guest,
17186 #[serde(rename = "darwin13_64Guest")]
17187 #[strum(serialize = "darwin13_64Guest")]
17188 Darwin1364Guest,
17189 #[serde(rename = "darwin14_64Guest")]
17190 #[strum(serialize = "darwin14_64Guest")]
17191 Darwin1464Guest,
17192 #[serde(rename = "darwin15_64Guest")]
17193 #[strum(serialize = "darwin15_64Guest")]
17194 Darwin1564Guest,
17195 #[serde(rename = "darwin16_64Guest")]
17196 #[strum(serialize = "darwin16_64Guest")]
17197 Darwin1664Guest,
17198 #[serde(rename = "darwin17_64Guest")]
17199 #[strum(serialize = "darwin17_64Guest")]
17200 Darwin1764Guest,
17201 #[serde(rename = "darwin18_64Guest")]
17202 #[strum(serialize = "darwin18_64Guest")]
17203 Darwin1864Guest,
17204 #[serde(rename = "darwin19_64Guest")]
17205 #[strum(serialize = "darwin19_64Guest")]
17206 Darwin1964Guest,
17207 #[serde(rename = "darwin20_64Guest")]
17208 #[strum(serialize = "darwin20_64Guest")]
17209 Darwin2064Guest,
17210 #[serde(rename = "darwin21_64Guest")]
17211 #[strum(serialize = "darwin21_64Guest")]
17212 Darwin2164Guest,
17213 #[serde(rename = "darwin22_64Guest")]
17214 #[strum(serialize = "darwin22_64Guest")]
17215 Darwin2264Guest,
17216 #[serde(rename = "darwin23_64Guest")]
17217 #[strum(serialize = "darwin23_64Guest")]
17218 Darwin2364Guest,
17219 #[serde(rename = "vmkernelGuest")]
17220 #[strum(serialize = "vmkernelGuest")]
17221 VmkernelGuest,
17222 #[serde(rename = "vmkernel5Guest")]
17223 #[strum(serialize = "vmkernel5Guest")]
17224 Vmkernel5Guest,
17225 #[serde(rename = "vmkernel6Guest")]
17226 #[strum(serialize = "vmkernel6Guest")]
17227 Vmkernel6Guest,
17228 #[serde(rename = "vmkernel65Guest")]
17229 #[strum(serialize = "vmkernel65Guest")]
17230 Vmkernel65Guest,
17231 #[serde(rename = "vmkernel7Guest")]
17232 #[strum(serialize = "vmkernel7Guest")]
17233 Vmkernel7Guest,
17234 #[serde(rename = "vmkernel8Guest")]
17235 #[strum(serialize = "vmkernel8Guest")]
17236 Vmkernel8Guest,
17237 #[serde(rename = "vmkernel9Guest")]
17238 #[strum(serialize = "vmkernel9Guest")]
17239 Vmkernel9Guest,
17240 #[serde(rename = "amazonlinux2_64Guest")]
17241 #[strum(serialize = "amazonlinux2_64Guest")]
17242 Amazonlinux264Guest,
17243 #[serde(rename = "amazonlinux3_64Guest")]
17244 #[strum(serialize = "amazonlinux3_64Guest")]
17245 Amazonlinux364Guest,
17246 #[serde(rename = "crxPod1Guest")]
17247 #[strum(serialize = "crxPod1Guest")]
17248 CrxPod1Guest,
17249 #[serde(rename = "crxSys1Guest")]
17250 #[strum(serialize = "crxSys1Guest")]
17251 CrxSys1Guest,
17252 #[serde(rename = "rockylinux_64Guest")]
17253 #[strum(serialize = "rockylinux_64Guest")]
17254 Rockylinux64Guest,
17255 #[serde(rename = "almalinux_64Guest")]
17256 #[strum(serialize = "almalinux_64Guest")]
17257 Almalinux64Guest,
17258 #[serde(rename = "otherGuest")]
17259 #[strum(serialize = "otherGuest")]
17260 OtherGuest,
17261 #[serde(rename = "otherGuest64")]
17262 #[strum(serialize = "otherGuest64")]
17263 OtherGuest64,
17264 /// This variant handles values not known at compile time.
17265 #[serde(untagged)]
17266 #[strum(serialize = "__OTHER__")]
17267 Other_(String),
17268}
17269/// Guest OS support level
17270///
17271/// Possible values:
17272/// - `experimental`: This operating system is not supported,
17273/// but may be supported in the future.
17274/// - `legacy`: This operating system is not fully supported,
17275/// but may have been supported in the past.
17276/// - `terminated`: No longer supported.
17277/// - `supported`: Fully supported.
17278/// - `unsupported`: This operating system is not supported.
17279/// - `deprecated`: Support for this operating system will be terminated in the future.
17280///
17281/// Please migrate to using a different operating system.
17282/// - `techPreview`: This operating system may not be supported yet,
17283/// please check VMware compatibility guide.
17284#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
17285pub enum GuestOsDescriptorSupportLevelEnum {
17286 #[serde(rename = "experimental")]
17287 #[strum(serialize = "experimental")]
17288 Experimental,
17289 #[serde(rename = "legacy")]
17290 #[strum(serialize = "legacy")]
17291 Legacy,
17292 #[serde(rename = "terminated")]
17293 #[strum(serialize = "terminated")]
17294 Terminated,
17295 #[serde(rename = "supported")]
17296 #[strum(serialize = "supported")]
17297 Supported,
17298 #[serde(rename = "unsupported")]
17299 #[strum(serialize = "unsupported")]
17300 Unsupported,
17301 #[serde(rename = "deprecated")]
17302 #[strum(serialize = "deprecated")]
17303 Deprecated,
17304 #[serde(rename = "techPreview")]
17305 #[strum(serialize = "techPreview")]
17306 TechPreview,
17307 /// This variant handles values not known at compile time.
17308 #[serde(untagged)]
17309 #[strum(serialize = "__OTHER__")]
17310 Other_(String),
17311}
17312/// End guest quiesce phase error types.
17313///
17314/// Possible values:
17315/// - `failure`: Fail the end phase of guest quiesce creation.
17316#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
17317pub enum GuestQuiesceEndGuestQuiesceErrorEnum {
17318 #[serde(rename = "failure")]
17319 #[strum(serialize = "failure")]
17320 Failure,
17321 /// This variant handles values not known at compile time.
17322 #[serde(untagged)]
17323 #[strum(serialize = "__OTHER__")]
17324 Other_(String),
17325}
17326/// This enum represents the set of legal operations
17327///
17328/// Possible values:
17329/// - `Update`: Create or update the Metadata for the specified VM
17330/// - `Remove`: Remove the Metadata for the specified VM
17331#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
17332pub enum VirtualMachineMetadataManagerVmMetadataOpEnum {
17333 Update,
17334 Remove,
17335 /// This variant handles values not known at compile time.
17336 #[serde(untagged)]
17337 #[strum(serialize = "__OTHER__")]
17338 Other_(String),
17339}
17340/// This enum contains a list of valid owner values for
17341/// the name field
17342///
17343/// Possible values:
17344/// - `ComVmwareVsphereHA`
17345#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
17346pub enum VirtualMachineMetadataManagerVmMetadataOwnerOwnerEnum {
17347 #[serde(rename = "ComVmwareVsphereHA")]
17348 #[strum(serialize = "ComVmwareVsphereHA")]
17349 ComVmwareVsphereHa,
17350 /// This variant handles values not known at compile time.
17351 #[serde(untagged)]
17352 #[strum(serialize = "__OTHER__")]
17353 Other_(String),
17354}
17355/// Specifies how a virtual disk is moved or copied to a
17356/// datastore.
17357///
17358/// In all cases after the move or copy the virtual machine's current running point
17359/// will be placed on the target datastore. The current running point is defined
17360/// as the disk backing which the virtual machine is currently
17361/// writing to. This end state can be achieved in multiple
17362/// ways, and the supported options are described in this
17363/// enumeration.
17364///
17365/// These options are only relevant when the backing of the
17366/// specified disk is a *file backing*.
17367///
17368/// Since disk backings may become shared as the result of
17369/// either a *clone operation* or
17370/// a *relocate operation*,
17371/// *VirtualMachine.PromoteDisks_Task* has been provided as
17372/// a way to unshare such disk backings.
17373///
17374/// See also *VirtualDiskSparseVer1BackingInfo.parent*, *VirtualDiskSparseVer2BackingInfo.parent*, *VirtualDiskFlatVer1BackingInfo.parent*, *VirtualDiskFlatVer2BackingInfo.parent*, *VirtualDiskRawDiskMappingVer1BackingInfo.parent*, *VirtualMachineRelocateSpec.diskMoveType*, *VirtualMachineRelocateSpecDiskLocator.diskMoveType*.
17375///
17376/// Possible values:
17377/// - `moveAllDiskBackingsAndAllowSharing`: All of the virtual disk's backings should be moved to the new datastore.
17378///
17379/// If a disk backing is not the child-most backing of this virtual machine,
17380/// and there exists a read-only disk backing with the same content ID
17381/// on the target datastore, then this disk backing may not be copied. Instead
17382/// it is acceptable to attach to the read-only disk backing at the target
17383/// datastore. A read-only disk backing is defined as a virtual disk
17384/// backing which no virtual machine is currently writing to.
17385///
17386/// See also *VirtualDiskSparseVer1BackingInfo.contentId*, *VirtualDiskSparseVer2BackingInfo.contentId*, *VirtualDiskFlatVer1BackingInfo.contentId*, *VirtualDiskFlatVer2BackingInfo.contentId*, *VirtualDiskRawDiskMappingVer1BackingInfo.contentId*.
17387/// - `moveAllDiskBackingsAndDisallowSharing`: All of the virtual disk's backings should be moved to the new datastore.
17388///
17389/// It is not acceptable to attach to a disk backing with the same content ID
17390/// on the destination datastore. During a *clone operation* any delta disk backings will be consolidated.
17391/// - `moveChildMostDiskBacking`: Move only the child-most disk backing.
17392///
17393/// Any parent disk backings should
17394/// be left in their current locations.
17395///
17396/// This option only differs from *moveAllDiskBackingsAndAllowSharing* and
17397/// *moveAllDiskBackingsAndDisallowSharing* when the virtual
17398/// disk has a parent backing.
17399///
17400/// Note that in the case of a *clone operation*,
17401/// this means that the parent disks will now be shared. This is safe as any
17402/// parent disks are always read-only.
17403/// Note that in the case of a *VirtualMachine.RelocateVM_Task* operation,
17404/// only the virtual disks in the current virtual machine configuration are moved.
17405/// - `createNewChildDiskBacking`: Create a new child disk backing on the destination datastore.
17406///
17407/// None of the
17408/// virtual disk's existing files should be moved from their current locations.
17409///
17410/// Note that in the case of a *clone operation*,
17411/// this means that the original virtual machine's disks are now all being shared.
17412/// This is only safe if the clone was taken from a snapshot point, because
17413/// snapshot points are always read-only. Thus for a clone this
17414/// option is only valid *when cloning from a snapshot*.
17415/// createNewChildDiskBacking is not a supported operation for
17416/// *VirtualMachine.RelocateVM_Task* operations unless all disks are moving.
17417/// - `moveAllDiskBackingsAndConsolidate`: All of the virtual disk's backings should be moved to the new datastore.
17418///
17419/// During a *clone operation* or a
17420/// *VirtualMachine.MigrateVM_Task*, any delta disk backings will be
17421/// consolidated.
17422#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
17423pub enum VirtualMachineRelocateDiskMoveOptionsEnum {
17424 #[serde(rename = "moveAllDiskBackingsAndAllowSharing")]
17425 #[strum(serialize = "moveAllDiskBackingsAndAllowSharing")]
17426 MoveAllDiskBackingsAndAllowSharing,
17427 #[serde(rename = "moveAllDiskBackingsAndDisallowSharing")]
17428 #[strum(serialize = "moveAllDiskBackingsAndDisallowSharing")]
17429 MoveAllDiskBackingsAndDisallowSharing,
17430 #[serde(rename = "moveChildMostDiskBacking")]
17431 #[strum(serialize = "moveChildMostDiskBacking")]
17432 MoveChildMostDiskBacking,
17433 #[serde(rename = "createNewChildDiskBacking")]
17434 #[strum(serialize = "createNewChildDiskBacking")]
17435 CreateNewChildDiskBacking,
17436 #[serde(rename = "moveAllDiskBackingsAndConsolidate")]
17437 #[strum(serialize = "moveAllDiskBackingsAndConsolidate")]
17438 MoveAllDiskBackingsAndConsolidate,
17439 /// This variant handles values not known at compile time.
17440 #[serde(untagged)]
17441 #[strum(serialize = "__OTHER__")]
17442 Other_(String),
17443}
17444/// Deprecated as of vSphere API 5.0.
17445///
17446/// The set of tranformations that can be performed on the virtual disks
17447/// as part of the copy.
17448///
17449/// Possible values:
17450/// - `flat`
17451/// - `sparse`
17452#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
17453pub enum VirtualMachineRelocateTransformationEnum {
17454 #[serde(rename = "flat")]
17455 #[strum(serialize = "flat")]
17456 Flat,
17457 #[serde(rename = "sparse")]
17458 #[strum(serialize = "sparse")]
17459 Sparse,
17460 /// This variant handles values not known at compile time.
17461 #[serde(untagged)]
17462 #[strum(serialize = "__OTHER__")]
17463 Other_(String),
17464}
17465/// The policy setting used to determine when to perform scheduled
17466/// upgrades for a virtual machine.
17467///
17468/// Possible values:
17469/// - `never`: No scheduled upgrades.
17470/// - `onSoftPowerOff`: Run scheduled upgrades only on normal guest OS shutdown.
17471/// - `always`: Always run scheduled upgrades.
17472#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
17473pub enum ScheduledHardwareUpgradeInfoHardwareUpgradePolicyEnum {
17474 #[serde(rename = "never")]
17475 #[strum(serialize = "never")]
17476 Never,
17477 #[serde(rename = "onSoftPowerOff")]
17478 #[strum(serialize = "onSoftPowerOff")]
17479 OnSoftPowerOff,
17480 #[serde(rename = "always")]
17481 #[strum(serialize = "always")]
17482 Always,
17483 /// This variant handles values not known at compile time.
17484 #[serde(untagged)]
17485 #[strum(serialize = "__OTHER__")]
17486 Other_(String),
17487}
17488/// Status for last attempt to run scheduled hardware upgrade.
17489///
17490/// Possible values:
17491/// - `none`: No scheduled upgrade ever happened.
17492/// - `pending`: Upgrade is scheduled, but was not run yet.
17493/// - `success`: Upgrade succeeded.
17494/// - `failed`: Upgrade failed.
17495///
17496/// For more information about the failure
17497///
17498/// See also *ScheduledHardwareUpgradeInfo.fault*.
17499#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
17500pub enum ScheduledHardwareUpgradeInfoHardwareUpgradeStatusEnum {
17501 #[serde(rename = "none")]
17502 #[strum(serialize = "none")]
17503 None,
17504 #[serde(rename = "pending")]
17505 #[strum(serialize = "pending")]
17506 Pending,
17507 #[serde(rename = "success")]
17508 #[strum(serialize = "success")]
17509 Success,
17510 #[serde(rename = "failed")]
17511 #[strum(serialize = "failed")]
17512 Failed,
17513 /// This variant handles values not known at compile time.
17514 #[serde(untagged)]
17515 #[strum(serialize = "__OTHER__")]
17516 Other_(String),
17517}
17518/// Possible SCSI classes.
17519///
17520/// Possible values:
17521/// - `disk`
17522/// - `tape`
17523/// - `printer`
17524/// - `processor`
17525/// - `worm`
17526/// - `cdrom`
17527/// - `scanner`
17528/// - `optical`
17529/// - `media`
17530/// - `com`
17531/// - `raid`
17532/// - `unknown`
17533#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
17534pub enum VirtualMachineScsiPassthroughTypeEnum {
17535 #[serde(rename = "disk")]
17536 #[strum(serialize = "disk")]
17537 Disk,
17538 #[serde(rename = "tape")]
17539 #[strum(serialize = "tape")]
17540 Tape,
17541 #[serde(rename = "printer")]
17542 #[strum(serialize = "printer")]
17543 Printer,
17544 #[serde(rename = "processor")]
17545 #[strum(serialize = "processor")]
17546 Processor,
17547 #[serde(rename = "worm")]
17548 #[strum(serialize = "worm")]
17549 Worm,
17550 #[serde(rename = "cdrom")]
17551 #[strum(serialize = "cdrom")]
17552 Cdrom,
17553 #[serde(rename = "scanner")]
17554 #[strum(serialize = "scanner")]
17555 Scanner,
17556 #[serde(rename = "optical")]
17557 #[strum(serialize = "optical")]
17558 Optical,
17559 #[serde(rename = "media")]
17560 #[strum(serialize = "media")]
17561 Media,
17562 #[serde(rename = "com")]
17563 #[strum(serialize = "com")]
17564 Com,
17565 #[serde(rename = "raid")]
17566 #[strum(serialize = "raid")]
17567 Raid,
17568 #[serde(rename = "unknown")]
17569 #[strum(serialize = "unknown")]
17570 Unknown,
17571 /// This variant handles values not known at compile time.
17572 #[serde(untagged)]
17573 #[strum(serialize = "__OTHER__")]
17574 Other_(String),
17575}
17576/// Flexible Launch Enclave (FLC) modes.
17577///
17578/// Possible values:
17579/// - `locked`: FLC is available in the guest.
17580///
17581/// The "launch Enclave MSRs" are locked and
17582/// initialized with the provided public key hash.
17583/// - `unlocked`: FLC is available in the guest.
17584///
17585/// The "launch enclave MSRs" are writeable
17586/// and initialized with Intel's public key hash.
17587#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
17588pub enum VirtualMachineSgxInfoFlcModesEnum {
17589 #[serde(rename = "locked")]
17590 #[strum(serialize = "locked")]
17591 Locked,
17592 #[serde(rename = "unlocked")]
17593 #[strum(serialize = "unlocked")]
17594 Unlocked,
17595 /// This variant handles values not known at compile time.
17596 #[serde(untagged)]
17597 #[strum(serialize = "__OTHER__")]
17598 Other_(String),
17599}
17600/// Describes how widely the endpoint is available in a cluster.
17601///
17602/// Note that these fields are not necessarily mutual-exclusive.
17603///
17604/// Possible values:
17605/// - `compliant`: Indicates that this device is part of the cluster compliant
17606/// specification.
17607/// - `clusterWide`: Indicates that this is available for all hosts in the cluster.
17608#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
17609pub enum VirtualMachineTargetInfoConfigurationTagEnum {
17610 #[serde(rename = "compliant")]
17611 #[strum(serialize = "compliant")]
17612 Compliant,
17613 #[serde(rename = "clusterWide")]
17614 #[strum(serialize = "clusterWide")]
17615 ClusterWide,
17616 /// This variant handles values not known at compile time.
17617 #[serde(untagged)]
17618 #[strum(serialize = "__OTHER__")]
17619 Other_(String),
17620}
17621/// The policy setting used to determine when tools are auto-upgraded for
17622/// a virtual machine
17623///
17624/// Possible values:
17625/// - `manual`: No auto-upgrades for tools will be performed for this
17626/// virtual machine.
17627///
17628/// Users must manually invoke the UpgradeTools
17629/// operation to update the tools.
17630/// - `upgradeAtPowerCycle`: When the virtual machine is power-cycled, the system checks
17631/// for a newer version of tools when the VM comes back up.
17632///
17633/// If it
17634/// is available, a tools upgrade is automatically performed on the
17635/// virtual machine and it is rebooted if necessary.
17636#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
17637pub enum UpgradePolicyEnum {
17638 #[serde(rename = "manual")]
17639 #[strum(serialize = "manual")]
17640 Manual,
17641 #[serde(rename = "upgradeAtPowerCycle")]
17642 #[strum(serialize = "upgradeAtPowerCycle")]
17643 UpgradeAtPowerCycle,
17644 /// This variant handles values not known at compile time.
17645 #[serde(untagged)]
17646 #[strum(serialize = "__OTHER__")]
17647 Other_(String),
17648}
17649/// Device class family.
17650///
17651/// Possible values:
17652/// - `audio`: Audio capable device.
17653/// - `hid`: Human interface device.
17654/// - `hid_bootable`: Bootable human interface device, this is a subset of HID devices.
17655/// - `physical`: Physical interface device.
17656/// - `communication`: Communication device.
17657/// - `imaging`: Still imaging device.
17658/// - `printer`: Printer device.
17659/// - `storage`: Mass storage device.
17660/// - `hub`: USB hubs.
17661/// - `smart_card`: Smart card device.
17662/// - `security`: Content security device.
17663/// - `video`: Video device.
17664/// - `wireless`: Wireless controller.
17665/// - `bluetooth`: Standard bluetooth adapter that uses HCI protocol,
17666/// this is a subset of wireless controllers.
17667/// - `wusb`: Wireless device related to the Wireless USB standard,
17668/// this is a subset of wireless controllers,
17669/// - `pda`: Palm PDA, and Micorsoft ActiveSync PDA.
17670/// - `vendor_specific`: Device that has an interface using a vendor-specific protocol.
17671/// - `other`: Other miscellaneous device.
17672/// - `unknownFamily`: There was an error in determining this device's classes
17673/// accurately.
17674#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
17675pub enum VirtualMachineUsbInfoFamilyEnum {
17676 #[serde(rename = "audio")]
17677 #[strum(serialize = "audio")]
17678 Audio,
17679 #[serde(rename = "hid")]
17680 #[strum(serialize = "hid")]
17681 Hid,
17682 #[serde(rename = "hid_bootable")]
17683 #[strum(serialize = "hid_bootable")]
17684 HidBootable,
17685 #[serde(rename = "physical")]
17686 #[strum(serialize = "physical")]
17687 Physical,
17688 #[serde(rename = "communication")]
17689 #[strum(serialize = "communication")]
17690 Communication,
17691 #[serde(rename = "imaging")]
17692 #[strum(serialize = "imaging")]
17693 Imaging,
17694 #[serde(rename = "printer")]
17695 #[strum(serialize = "printer")]
17696 Printer,
17697 #[serde(rename = "storage")]
17698 #[strum(serialize = "storage")]
17699 Storage,
17700 #[serde(rename = "hub")]
17701 #[strum(serialize = "hub")]
17702 Hub,
17703 #[serde(rename = "smart_card")]
17704 #[strum(serialize = "smart_card")]
17705 SmartCard,
17706 #[serde(rename = "security")]
17707 #[strum(serialize = "security")]
17708 Security,
17709 #[serde(rename = "video")]
17710 #[strum(serialize = "video")]
17711 Video,
17712 #[serde(rename = "wireless")]
17713 #[strum(serialize = "wireless")]
17714 Wireless,
17715 #[serde(rename = "bluetooth")]
17716 #[strum(serialize = "bluetooth")]
17717 Bluetooth,
17718 #[serde(rename = "wusb")]
17719 #[strum(serialize = "wusb")]
17720 Wusb,
17721 #[serde(rename = "pda")]
17722 #[strum(serialize = "pda")]
17723 Pda,
17724 #[serde(rename = "vendor_specific")]
17725 #[strum(serialize = "vendor_specific")]
17726 VendorSpecific,
17727 #[serde(rename = "other")]
17728 #[strum(serialize = "other")]
17729 Other,
17730 #[serde(rename = "unknownFamily")]
17731 #[strum(serialize = "unknownFamily")]
17732 UnknownFamily,
17733 /// This variant handles values not known at compile time.
17734 #[serde(untagged)]
17735 #[strum(serialize = "__OTHER__")]
17736 Other_(String),
17737}
17738/// Device speed.
17739///
17740/// Possible values:
17741/// - `low`: This device operates at low speed (1.5Mb/s).
17742/// - `full`: This device operates at full speed (12Mb/s).
17743/// - `high`: This device can operate at high speed (480Mb/s)
17744/// - `superSpeed`: This device can operate at super speed (4.8Gb/s)
17745/// - `superSpeedPlus`: This device can operate at super speed plus (10Gb/s)
17746/// - `superSpeed20Gbps`: This device can operate at super speed gen 2x2 (20Gb/s)
17747///
17748/// ***Since:*** vSphere API Release 7.0.3.2
17749/// - `unknownSpeed`: This device's speed is unknown.
17750#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
17751pub enum VirtualMachineUsbInfoSpeedEnum {
17752 #[serde(rename = "low")]
17753 #[strum(serialize = "low")]
17754 Low,
17755 #[serde(rename = "full")]
17756 #[strum(serialize = "full")]
17757 Full,
17758 #[serde(rename = "high")]
17759 #[strum(serialize = "high")]
17760 High,
17761 #[serde(rename = "superSpeed")]
17762 #[strum(serialize = "superSpeed")]
17763 SuperSpeed,
17764 #[serde(rename = "superSpeedPlus")]
17765 #[strum(serialize = "superSpeedPlus")]
17766 SuperSpeedPlus,
17767 #[serde(rename = "superSpeed20Gbps")]
17768 #[strum(serialize = "superSpeed20Gbps")]
17769 SuperSpeed20Gbps,
17770 #[serde(rename = "unknownSpeed")]
17771 #[strum(serialize = "unknownSpeed")]
17772 UnknownSpeed,
17773 /// This variant handles values not known at compile time.
17774 #[serde(untagged)]
17775 #[strum(serialize = "__OTHER__")]
17776 Other_(String),
17777}
17778/// Type of component device.
17779///
17780/// Possible values:
17781/// - `pciPassthru`
17782/// - `nvidiaVgpu`
17783/// - `sriovNic`
17784/// - `dvx`
17785///
17786/// ***Since:*** vSphere API Release 8.0.0.1
17787#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
17788pub enum VirtualMachineVendorDeviceGroupInfoComponentDeviceInfoComponentTypeEnum {
17789 #[serde(rename = "pciPassthru")]
17790 #[strum(serialize = "pciPassthru")]
17791 PciPassthru,
17792 #[serde(rename = "nvidiaVgpu")]
17793 #[strum(serialize = "nvidiaVgpu")]
17794 NvidiaVgpu,
17795 #[serde(rename = "sriovNic")]
17796 #[strum(serialize = "sriovNic")]
17797 SriovNic,
17798 #[serde(rename = "dvx")]
17799 #[strum(serialize = "dvx")]
17800 Dvx,
17801 /// This variant handles values not known at compile time.
17802 #[serde(untagged)]
17803 #[strum(serialize = "__OTHER__")]
17804 Other_(String),
17805}
17806/// Possible values for profile class.
17807///
17808/// Possible values:
17809/// - `compute`
17810/// - `quadro`
17811///
17812/// ***Since:*** vSphere API Release 7.0.3.0
17813#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
17814pub enum VirtualMachineVgpuProfileInfoProfileClassEnum {
17815 #[serde(rename = "compute")]
17816 #[strum(serialize = "compute")]
17817 Compute,
17818 #[serde(rename = "quadro")]
17819 #[strum(serialize = "quadro")]
17820 Quadro,
17821 /// This variant handles values not known at compile time.
17822 #[serde(untagged)]
17823 #[strum(serialize = "__OTHER__")]
17824 Other_(String),
17825}
17826/// Possible values for profile sharing.
17827///
17828/// Possible values:
17829/// - `timeSliced`: Time-sliced
17830/// - `mig`: Multi-instance GPU partitioning
17831///
17832/// ***Since:*** vSphere API Release 7.0.3.0
17833#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
17834pub enum VirtualMachineVgpuProfileInfoProfileSharingEnum {
17835 #[serde(rename = "timeSliced")]
17836 #[strum(serialize = "timeSliced")]
17837 TimeSliced,
17838 #[serde(rename = "mig")]
17839 #[strum(serialize = "mig")]
17840 Mig,
17841 /// This variant handles values not known at compile time.
17842 #[serde(untagged)]
17843 #[strum(serialize = "__OTHER__")]
17844 Other_(String),
17845}
17846/// Possible values:
17847/// - `none`: No operation active.
17848/// - `scheduled`: Device swap will be performed on next restart.
17849/// - `inprogress`: Device swap is in progress.
17850/// - `failed`: Device swap failed.
17851/// - `completed`: Device swap successfully completed.
17852///
17853/// ***Since:*** vSphere API Release 8.0.0.1
17854#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
17855pub enum VirtualMachineVirtualDeviceSwapDeviceSwapStatusEnum {
17856 #[serde(rename = "none")]
17857 #[strum(serialize = "none")]
17858 None,
17859 #[serde(rename = "scheduled")]
17860 #[strum(serialize = "scheduled")]
17861 Scheduled,
17862 #[serde(rename = "inprogress")]
17863 #[strum(serialize = "inprogress")]
17864 Inprogress,
17865 #[serde(rename = "failed")]
17866 #[strum(serialize = "failed")]
17867 Failed,
17868 #[serde(rename = "completed")]
17869 #[strum(serialize = "completed")]
17870 Completed,
17871 /// This variant handles values not known at compile time.
17872 #[serde(untagged)]
17873 #[strum(serialize = "__OTHER__")]
17874 Other_(String),
17875}
17876/// Motherboard layout of the VM.
17877///
17878/// Possible values:
17879/// - `i440bxHostBridge`: Single i440BX host bridge.
17880/// - `acpiHostBridges`: Multiple ACPI host bridges.
17881///
17882/// ***Since:*** vSphere API Release 8.0.0.1
17883#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
17884pub enum VirtualHardwareMotherboardLayoutEnum {
17885 #[serde(rename = "i440bxHostBridge")]
17886 #[strum(serialize = "i440bxHostBridge")]
17887 I440BxHostBridge,
17888 #[serde(rename = "acpiHostBridges")]
17889 #[strum(serialize = "acpiHostBridges")]
17890 AcpiHostBridges,
17891 /// This variant handles values not known at compile time.
17892 #[serde(untagged)]
17893 #[strum(serialize = "__OTHER__")]
17894 Other_(String),
17895}
17896/// The set of supported snapshot modes for VMs configured with NVDIMMs.
17897///
17898/// Possible values:
17899/// - `independent_persistent`: The data on virtual NVDIMMs are not affected by snapshot reverts.
17900///
17901/// Writes to virtual NVDIMMs after a snapshot is taken cannot be
17902/// reverted to the snapshotted state.
17903/// - `independent_eraseonrevert`: Virtual NVDIMMs are erased and recreated upon snapshot reverts.
17904///
17905/// ***Since:*** vSphere API Release 7.0.3.0
17906#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
17907pub enum VirtualMachineVirtualPMemSnapshotModeEnum {
17908 #[serde(rename = "independent_persistent")]
17909 #[strum(serialize = "independent_persistent")]
17910 IndependentPersistent,
17911 #[serde(rename = "independent_eraseonrevert")]
17912 #[strum(serialize = "independent_eraseonrevert")]
17913 IndependentEraseonrevert,
17914 /// This variant handles values not known at compile time.
17915 #[serde(untagged)]
17916 #[strum(serialize = "__OTHER__")]
17917 Other_(String),
17918}
17919/// The VSS Snapshot Context
17920/// VSS\_SNAPSHOT\_CONTEXT values not listed below are not implemented.
17921///
17922/// Possible values:
17923/// - `ctx_auto`: The context value indicates auto selection of VSS snapshot context.
17924///
17925/// The ctx\_backup may make Windows VSS-aware applications quiescing during
17926/// backup. The ctx\_auto makes VMTools select ctx\_file\_share\_backup context
17927/// if ctx\_backup is not available.
17928/// - `ctx_backup`: Indicate VSS\_CTX\_BACKUP.
17929/// - `ctx_file_share_backup`: Indicate VSS\_CTX\_FILE\_SHARE\_BACKUP.
17930#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
17931pub enum VirtualMachineWindowsQuiesceSpecVssBackupContextEnum {
17932 #[serde(rename = "ctx_auto")]
17933 #[strum(serialize = "ctx_auto")]
17934 CtxAuto,
17935 #[serde(rename = "ctx_backup")]
17936 #[strum(serialize = "ctx_backup")]
17937 CtxBackup,
17938 #[serde(rename = "ctx_file_share_backup")]
17939 #[strum(serialize = "ctx_file_share_backup")]
17940 CtxFileShareBackup,
17941 /// This variant handles values not known at compile time.
17942 #[serde(untagged)]
17943 #[strum(serialize = "__OTHER__")]
17944 Other_(String),
17945}
17946/// The types of tests which can requested by any of the methods in either
17947/// *VirtualMachineCompatibilityChecker* or *VirtualMachineProvisioningChecker*.
17948///
17949/// Possible values:
17950/// - `sourceTests`: Tests that examine only the configuration
17951/// of the virtual machine and its current host; the destination
17952/// resource pool and host or cluster are irrelevant.
17953/// - `hostTests`: Tests that examine both the virtual
17954/// machine and the destination host or cluster; the destination
17955/// resource pool is irrelevant.
17956///
17957/// This set excludes tests that fall
17958/// into the datastoreTests group.
17959/// - `resourcePoolTests`: Tests that check that the destination resource
17960/// pool can support the virtual machine if it is powered on.
17961///
17962/// The
17963/// destination host or cluster is relevant because it will affect the
17964/// amount of overhead memory required to run the virtual machine.
17965/// - `datastoreTests`: Tests that check that the
17966/// destination host or cluster can see the datastores where the virtual
17967/// machine's virtual disks are going to be located.
17968///
17969/// The destination
17970/// resource pool is irrelevant.
17971/// - `networkTests`: Tests that check that the
17972/// destination host or cluster can see the networks that the virtual
17973/// machine's virtual nic devices are going to be connected.
17974#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
17975pub enum CheckTestTypeEnum {
17976 #[serde(rename = "sourceTests")]
17977 #[strum(serialize = "sourceTests")]
17978 SourceTests,
17979 #[serde(rename = "hostTests")]
17980 #[strum(serialize = "hostTests")]
17981 HostTests,
17982 #[serde(rename = "resourcePoolTests")]
17983 #[strum(serialize = "resourcePoolTests")]
17984 ResourcePoolTests,
17985 #[serde(rename = "datastoreTests")]
17986 #[strum(serialize = "datastoreTests")]
17987 DatastoreTests,
17988 #[serde(rename = "networkTests")]
17989 #[strum(serialize = "networkTests")]
17990 NetworkTests,
17991 /// This variant handles values not known at compile time.
17992 #[serde(untagged)]
17993 #[strum(serialize = "__OTHER__")]
17994 Other_(String),
17995}
17996/// NetBIOS setting for Windows.
17997///
17998/// Possible values:
17999/// - `enableNetBIOSViaDhcp`: DHCP server decides whether or not to use NetBIOS.
18000/// - `enableNetBIOS`: Always use NetBIOS.
18001/// - `disableNetBIOS`: Never use NetBIOS.
18002#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18003pub enum CustomizationNetBiosModeEnum {
18004 #[serde(rename = "enableNetBIOSViaDhcp")]
18005 #[strum(serialize = "enableNetBIOSViaDhcp")]
18006 EnableNetBiosViaDhcp,
18007 #[serde(rename = "enableNetBIOS")]
18008 #[strum(serialize = "enableNetBIOS")]
18009 EnableNetBios,
18010 #[serde(rename = "disableNetBIOS")]
18011 #[strum(serialize = "disableNetBIOS")]
18012 DisableNetBios,
18013 /// This variant handles values not known at compile time.
18014 #[serde(untagged)]
18015 #[strum(serialize = "__OTHER__")]
18016 Other_(String),
18017}
18018/// Enumeration of AutoMode values.
18019///
18020/// Possible values:
18021/// - `perServer`: Indicates that client access licenses have been purchased for the server,
18022/// allowing a certain number of concurrent connections to the VirtualCenter
18023/// server.
18024/// - `perSeat`: Indicates that a client access license has been purchased for each computer
18025/// that accesses the VirtualCenter server.
18026#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18027pub enum CustomizationLicenseDataModeEnum {
18028 #[serde(rename = "perServer")]
18029 #[strum(serialize = "perServer")]
18030 PerServer,
18031 #[serde(rename = "perSeat")]
18032 #[strum(serialize = "perSeat")]
18033 PerSeat,
18034 /// This variant handles values not known at compile time.
18035 #[serde(untagged)]
18036 #[strum(serialize = "__OTHER__")]
18037 Other_(String),
18038}
18039/// A enum constant specifying what should be done to the guest vm after running
18040/// sysprep.
18041///
18042/// Possible values:
18043/// - `reboot`: Reboot the machine after running sysprep.
18044///
18045/// This will cause values
18046/// specified in the sysprep.xml to be applied immediately.
18047/// - `noreboot`: Take no action.
18048///
18049/// Leave the guest os running after running sysprep. This
18050/// option can be used to look at values for debugging purposes after
18051/// running sysprep.
18052/// - `shutdown`: Shutdown the machine after running sysprep.
18053///
18054/// This puts the vm in a
18055/// sealed state.
18056#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18057pub enum CustomizationSysprepRebootOptionEnum {
18058 #[serde(rename = "reboot")]
18059 #[strum(serialize = "reboot")]
18060 Reboot,
18061 #[serde(rename = "noreboot")]
18062 #[strum(serialize = "noreboot")]
18063 Noreboot,
18064 #[serde(rename = "shutdown")]
18065 #[strum(serialize = "shutdown")]
18066 Shutdown,
18067 /// This variant handles values not known at compile time.
18068 #[serde(untagged)]
18069 #[strum(serialize = "__OTHER__")]
18070 Other_(String),
18071}
18072/// Contains information about connectable virtual devices when
18073/// the virtual machine restores from a migration.
18074///
18075/// Possible values:
18076/// - `connect`: Attempt to connect the virtual device when the virtual machine
18077/// restores from a migration.
18078///
18079/// This property has no effect if it
18080/// is set on a device that is already connected.
18081/// - `disconnect`: Attempt to disconnect the virtual device when the virtual machine
18082/// restores from a migration.
18083///
18084/// This property has no effect if it
18085/// is set on a device that is already disconnected.
18086/// - `unset`: Unset the property, which resets the device to its default state.
18087///
18088/// Under most circumstances, a device will return to the same
18089/// connection state before the migration was initiated.
18090#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18091pub enum VirtualDeviceConnectInfoMigrateConnectOpEnum {
18092 #[serde(rename = "connect")]
18093 #[strum(serialize = "connect")]
18094 Connect,
18095 #[serde(rename = "disconnect")]
18096 #[strum(serialize = "disconnect")]
18097 Disconnect,
18098 #[serde(rename = "unset")]
18099 #[strum(serialize = "unset")]
18100 Unset,
18101 /// This variant handles values not known at compile time.
18102 #[serde(untagged)]
18103 #[strum(serialize = "__OTHER__")]
18104 Other_(String),
18105}
18106/// Specifies the connectable virtual device status.
18107///
18108/// Possible values:
18109/// - `ok`: The device is working correctly.
18110/// - `recoverableError`: The device has reported a recoverable error.
18111///
18112/// For example,
18113/// attempting to connect to floppy device that is being used by
18114/// another virtual machine or some other program would result in
18115/// this status.
18116/// - `unrecoverableError`: The device cannot be used.
18117///
18118/// For example, attempting to connect to
18119/// a floppy device that does not exist would result in this status.
18120/// - `untried`: The device status is unknown, or it has not been requested to
18121/// connect when the VM is powered on.
18122#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18123pub enum VirtualDeviceConnectInfoStatusEnum {
18124 #[serde(rename = "ok")]
18125 #[strum(serialize = "ok")]
18126 Ok,
18127 #[serde(rename = "recoverableError")]
18128 #[strum(serialize = "recoverableError")]
18129 RecoverableError,
18130 #[serde(rename = "unrecoverableError")]
18131 #[strum(serialize = "unrecoverableError")]
18132 UnrecoverableError,
18133 #[serde(rename = "untried")]
18134 #[strum(serialize = "untried")]
18135 Untried,
18136 /// This variant handles values not known at compile time.
18137 #[serde(untagged)]
18138 #[strum(serialize = "__OTHER__")]
18139 Other_(String),
18140}
18141/// All known file extensions.
18142///
18143/// Valid ones are:
18144///
18145/// Possible values:
18146/// - `iso`: CD ISO Image backings
18147/// - `flp`: Floppy File Backings
18148/// - `vmdk`: virtual disks
18149/// - `dsk`: legacy virtual disks
18150/// - `rdm`: pre 3.0 virtual disks using Raw Disk Maps
18151#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18152pub enum VirtualDeviceFileExtensionEnum {
18153 #[serde(rename = "iso")]
18154 #[strum(serialize = "iso")]
18155 Iso,
18156 #[serde(rename = "flp")]
18157 #[strum(serialize = "flp")]
18158 Flp,
18159 #[serde(rename = "vmdk")]
18160 #[strum(serialize = "vmdk")]
18161 Vmdk,
18162 #[serde(rename = "dsk")]
18163 #[strum(serialize = "dsk")]
18164 Dsk,
18165 #[serde(rename = "rdm")]
18166 #[strum(serialize = "rdm")]
18167 Rdm,
18168 /// This variant handles values not known at compile time.
18169 #[serde(untagged)]
18170 #[strum(serialize = "__OTHER__")]
18171 Other_(String),
18172}
18173/// The <code>VirtualDeviceURIBackingOptionDirection</code> enum type
18174/// provides values for the direction of a network connection.
18175///
18176/// Possible values:
18177/// - `server`: Indicates that the virtual machine can listen for a connection
18178/// on the specified *VirtualDeviceURIBackingInfo.serviceURI*.
18179/// - `client`: Indicates that the virtual machine can initiate a connection
18180/// with a system on the network using the specified
18181/// *VirtualDeviceURIBackingInfo.serviceURI*.
18182#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18183pub enum VirtualDeviceUriBackingOptionDirectionEnum {
18184 #[serde(rename = "server")]
18185 #[strum(serialize = "server")]
18186 Server,
18187 #[serde(rename = "client")]
18188 #[strum(serialize = "client")]
18189 Client,
18190 /// This variant handles values not known at compile time.
18191 #[serde(untagged)]
18192 #[strum(serialize = "__OTHER__")]
18193 Other_(String),
18194}
18195/// Describes the change mode of the device.
18196///
18197/// Applies only to virtual disks during VirtualDeviceSpec.Operation "add"
18198/// that have no VirtualDeviceSpec.FileOperation set.
18199///
18200/// Possible values:
18201/// - `fail`
18202/// - `skip`
18203///
18204/// ***Since:*** vSphere API Release 8.0.0.1
18205#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18206pub enum VirtualDeviceConfigSpecChangeModeEnum {
18207 #[serde(rename = "fail")]
18208 #[strum(serialize = "fail")]
18209 Fail,
18210 #[serde(rename = "skip")]
18211 #[strum(serialize = "skip")]
18212 Skip,
18213 /// This variant handles values not known at compile time.
18214 #[serde(untagged)]
18215 #[strum(serialize = "__OTHER__")]
18216 Other_(String),
18217}
18218/// The type of operation being performed on the backing of a virtual device.
18219///
18220/// Valid values are:
18221///
18222/// Possible values:
18223/// - `create`: Specifies the creation of the device backing; for example,
18224/// the creation of a virtual disk or floppy image file.
18225/// - `destroy`: Specifies the destruction of a device backing.
18226/// - `replace`: Specifies the deletion of the existing backing for a virtual device
18227/// and the creation of a new backing.
18228#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18229pub enum VirtualDeviceConfigSpecFileOperationEnum {
18230 #[serde(rename = "create")]
18231 #[strum(serialize = "create")]
18232 Create,
18233 #[serde(rename = "destroy")]
18234 #[strum(serialize = "destroy")]
18235 Destroy,
18236 #[serde(rename = "replace")]
18237 #[strum(serialize = "replace")]
18238 Replace,
18239 /// This variant handles values not known at compile time.
18240 #[serde(untagged)]
18241 #[strum(serialize = "__OTHER__")]
18242 Other_(String),
18243}
18244/// The type of operation being performed on the specified virtual device.
18245///
18246/// Valid values are:
18247///
18248/// Possible values:
18249/// - `add`: Specifies the addition of a virtual device to the configuration.
18250/// - `remove`: Specifies the removal of a virtual device.
18251/// - `edit`: Specifies changes to the virtual device specification.
18252#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18253pub enum VirtualDeviceConfigSpecOperationEnum {
18254 #[serde(rename = "add")]
18255 #[strum(serialize = "add")]
18256 Add,
18257 #[serde(rename = "remove")]
18258 #[strum(serialize = "remove")]
18259 Remove,
18260 #[serde(rename = "edit")]
18261 #[strum(serialize = "edit")]
18262 Edit,
18263 /// This variant handles values not known at compile time.
18264 #[serde(untagged)]
18265 #[strum(serialize = "__OTHER__")]
18266 Other_(String),
18267}
18268/// The delta disk format constants
18269///
18270/// Possible values:
18271/// - `redoLogFormat`: redo-log based format
18272/// - `nativeFormat`: native snapshot format
18273/// - `seSparseFormat`: Flex-SE redo-log based format
18274#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18275pub enum VirtualDiskDeltaDiskFormatEnum {
18276 #[serde(rename = "redoLogFormat")]
18277 #[strum(serialize = "redoLogFormat")]
18278 RedoLogFormat,
18279 #[serde(rename = "nativeFormat")]
18280 #[strum(serialize = "nativeFormat")]
18281 NativeFormat,
18282 #[serde(rename = "seSparseFormat")]
18283 #[strum(serialize = "seSparseFormat")]
18284 SeSparseFormat,
18285 /// This variant handles values not known at compile time.
18286 #[serde(untagged)]
18287 #[strum(serialize = "__OTHER__")]
18288 Other_(String),
18289}
18290/// The delta disk format variant constants
18291///
18292/// Possible values:
18293/// - `vmfsSparseVariant`: vmfsSparse based redo-log format
18294/// - `vsanSparseVariant`: vsanSparse based redo-log format
18295#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18296pub enum VirtualDiskDeltaDiskFormatVariantEnum {
18297 #[serde(rename = "vmfsSparseVariant")]
18298 #[strum(serialize = "vmfsSparseVariant")]
18299 VmfsSparseVariant,
18300 #[serde(rename = "vsanSparseVariant")]
18301 #[strum(serialize = "vsanSparseVariant")]
18302 VsanSparseVariant,
18303 /// This variant handles values not known at compile time.
18304 #[serde(untagged)]
18305 #[strum(serialize = "__OTHER__")]
18306 Other_(String),
18307}
18308/// The sharing mode of the virtual disk.
18309///
18310/// Setting the value to sharingMultiWriter means that multiple virtual
18311/// machines can write to the virtual disk. This sharing mode is allowed
18312/// only for eagerly zeroed thick virtual disks.
18313///
18314/// Possible values:
18315/// - `sharingNone`: The virtual disk is not shared.
18316/// - `sharingMultiWriter`: The virtual disk is shared between multiple virtual machines.
18317#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18318pub enum VirtualDiskSharingEnum {
18319 #[serde(rename = "sharingNone")]
18320 #[strum(serialize = "sharingNone")]
18321 SharingNone,
18322 #[serde(rename = "sharingMultiWriter")]
18323 #[strum(serialize = "sharingMultiWriter")]
18324 SharingMultiWriter,
18325 /// This variant handles values not known at compile time.
18326 #[serde(untagged)]
18327 #[strum(serialize = "__OTHER__")]
18328 Other_(String),
18329}
18330/// Pre-defined constants for cache consistency types
18331///
18332/// Possible values:
18333/// - `strong`: With strong consistency, it ensures that
18334/// a crash will leave the cache data consistent.
18335/// - `weak`: Cache data consistency is not guaranteed after a crash.
18336#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18337pub enum VirtualDiskVFlashCacheConfigInfoCacheConsistencyTypeEnum {
18338 #[serde(rename = "strong")]
18339 #[strum(serialize = "strong")]
18340 Strong,
18341 #[serde(rename = "weak")]
18342 #[strum(serialize = "weak")]
18343 Weak,
18344 /// This variant handles values not known at compile time.
18345 #[serde(untagged)]
18346 #[strum(serialize = "__OTHER__")]
18347 Other_(String),
18348}
18349/// Pre-defined constants for cache modes.
18350///
18351/// Possible values:
18352/// - `write_thru`: In write-through cache mode, writes to the cache cause writes
18353/// to the underlying storage.
18354///
18355/// The cache acts as a facade to the underlying
18356/// storage.
18357/// - `write_back`: In write-back mode, writes to the cache do not go to the underlying storage
18358/// right away.
18359///
18360/// Cache holds data temporarily till it can be permanently saved or
18361/// otherwise modified.
18362#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18363pub enum VirtualDiskVFlashCacheConfigInfoCacheModeEnum {
18364 #[serde(rename = "write_thru")]
18365 #[strum(serialize = "write_thru")]
18366 WriteThru,
18367 #[serde(rename = "write_back")]
18368 #[strum(serialize = "write_back")]
18369 WriteBack,
18370 /// This variant handles values not known at compile time.
18371 #[serde(untagged)]
18372 #[strum(serialize = "__OTHER__")]
18373 Other_(String),
18374}
18375/// All known compatibility modes for raw disk mappings.
18376///
18377/// Valid compatibility
18378/// modes are:
18379/// - virtualMode
18380/// - physicalMode
18381///
18382/// Possible values:
18383/// - `virtualMode`: A disk device backed by a virtual compatibility mode raw disk mapping can
18384/// use disk modes.
18385///
18386/// See also *VirtualDiskMode_enum*.
18387/// - `physicalMode`: A disk device backed by a physical compatibility mode raw disk mapping cannot
18388/// use disk modes, and commands are passed straight through to the LUN
18389/// indicated by the raw disk mapping.
18390#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18391pub enum VirtualDiskCompatibilityModeEnum {
18392 #[serde(rename = "virtualMode")]
18393 #[strum(serialize = "virtualMode")]
18394 VirtualMode,
18395 #[serde(rename = "physicalMode")]
18396 #[strum(serialize = "physicalMode")]
18397 PhysicalMode,
18398 /// This variant handles values not known at compile time.
18399 #[serde(untagged)]
18400 #[strum(serialize = "__OTHER__")]
18401 Other_(String),
18402}
18403/// The list of known disk modes.
18404///
18405/// The list of supported disk modes varies by the backing type. The "persistent"
18406/// mode is supported by every backing type.
18407///
18408/// Possible values:
18409/// - `persistent`: Changes are immediately and permanently written to the virtual disk.
18410/// - `nonpersistent`: Changes to virtual disk are made to a redo log and discarded at power off.
18411/// - `undoable`: Changes are made to a redo log, but you are given the option to commit or undo.
18412/// - `independent_persistent`: Same as persistent, but not affected by snapshots.
18413/// - `independent_nonpersistent`: Same as nonpersistent, but not affected by snapshots.
18414/// - `append`: Changes are appended to the redo log; you revoke changes by removing the undo log.
18415#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18416pub enum VirtualDiskModeEnum {
18417 #[serde(rename = "persistent")]
18418 #[strum(serialize = "persistent")]
18419 Persistent,
18420 #[serde(rename = "nonpersistent")]
18421 #[strum(serialize = "nonpersistent")]
18422 Nonpersistent,
18423 #[serde(rename = "undoable")]
18424 #[strum(serialize = "undoable")]
18425 Undoable,
18426 #[serde(rename = "independent_persistent")]
18427 #[strum(serialize = "independent_persistent")]
18428 IndependentPersistent,
18429 #[serde(rename = "independent_nonpersistent")]
18430 #[strum(serialize = "independent_nonpersistent")]
18431 IndependentNonpersistent,
18432 #[serde(rename = "append")]
18433 #[strum(serialize = "append")]
18434 Append,
18435 /// This variant handles values not known at compile time.
18436 #[serde(untagged)]
18437 #[strum(serialize = "__OTHER__")]
18438 Other_(String),
18439}
18440/// Possible device names for legacy network backing option are listed below.
18441///
18442/// Note: This is not an exhaustive list. It is possible to specify
18443/// a specific device as well.
18444/// For example, on ESX hosts, the device name could be specified as "vmnic\[0-9\]"
18445/// or vmnet\_\[0-9\].
18446/// For VMware Server Windows hosts, the device name could be specified as "vmnet\[0-9\]"
18447/// and for VMware Server Linux hosts, the device name could be specified as "/dev/vmnet\[0-9\]"
18448/// depending on what devices are available on that particular host.
18449///
18450/// Possible values:
18451/// - `bridged`
18452/// - `nat`
18453/// - `hostonly`
18454#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18455pub enum VirtualEthernetCardLegacyNetworkDeviceNameEnum {
18456 #[serde(rename = "bridged")]
18457 #[strum(serialize = "bridged")]
18458 Bridged,
18459 #[serde(rename = "nat")]
18460 #[strum(serialize = "nat")]
18461 Nat,
18462 #[serde(rename = "hostonly")]
18463 #[strum(serialize = "hostonly")]
18464 Hostonly,
18465 /// This variant handles values not known at compile time.
18466 #[serde(untagged)]
18467 #[strum(serialize = "__OTHER__")]
18468 Other_(String),
18469}
18470/// The enumeration of all known valid MAC address types.
18471///
18472/// Possible values:
18473/// - `manual`: A statistically assigned MAC address.
18474/// - `generated`: An automatically generated MAC address.
18475/// - `assigned`: A MAC address assigned by VirtualCenter.
18476#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18477pub enum VirtualEthernetCardMacTypeEnum {
18478 #[serde(rename = "manual")]
18479 #[strum(serialize = "manual")]
18480 Manual,
18481 #[serde(rename = "generated")]
18482 #[strum(serialize = "generated")]
18483 Generated,
18484 #[serde(rename = "assigned")]
18485 #[strum(serialize = "assigned")]
18486 Assigned,
18487 /// This variant handles values not known at compile time.
18488 #[serde(untagged)]
18489 #[strum(serialize = "__OTHER__")]
18490 Other_(String),
18491}
18492/// Possible values:
18493/// - `noSharing`
18494/// - `physicalSharing`
18495///
18496/// ***Since:*** vSphere API Release 8.0.2.0
18497#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18498pub enum VirtualNvmeControllerSharingEnum {
18499 #[serde(rename = "noSharing")]
18500 #[strum(serialize = "noSharing")]
18501 NoSharing,
18502 #[serde(rename = "physicalSharing")]
18503 #[strum(serialize = "physicalSharing")]
18504 PhysicalSharing,
18505 /// This variant handles values not known at compile time.
18506 #[serde(untagged)]
18507 #[strum(serialize = "__OTHER__")]
18508 Other_(String),
18509}
18510/// The valid choices for host pointing devices are:
18511///
18512/// Possible values:
18513/// - `autodetect`: Automatically detects the host mouse type.
18514/// - `intellimouseExplorer`: The Microsoft IntelliMouse Explorer.
18515/// - `intellimousePs2`: The Microsoft Intellimouse with a PS2 connection.
18516/// - `logitechMouseman`: The Logitech MouseMan.
18517/// - `microsoft_serial`: The Microsoft Serial Mouse.
18518/// - `mouseSystems`: The Mouse Systems Mouse.
18519/// - `mousemanSerial`: The Logitech MouseMan Serial Bus Mouse.
18520/// - `ps2`: A generic mouse with a PS2 connection.
18521#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18522pub enum VirtualPointingDeviceHostChoiceEnum {
18523 #[serde(rename = "autodetect")]
18524 #[strum(serialize = "autodetect")]
18525 Autodetect,
18526 #[serde(rename = "intellimouseExplorer")]
18527 #[strum(serialize = "intellimouseExplorer")]
18528 IntellimouseExplorer,
18529 #[serde(rename = "intellimousePs2")]
18530 #[strum(serialize = "intellimousePs2")]
18531 IntellimousePs2,
18532 #[serde(rename = "logitechMouseman")]
18533 #[strum(serialize = "logitechMouseman")]
18534 LogitechMouseman,
18535 #[serde(rename = "microsoft_serial")]
18536 #[strum(serialize = "microsoft_serial")]
18537 MicrosoftSerial,
18538 #[serde(rename = "mouseSystems")]
18539 #[strum(serialize = "mouseSystems")]
18540 MouseSystems,
18541 #[serde(rename = "mousemanSerial")]
18542 #[strum(serialize = "mousemanSerial")]
18543 MousemanSerial,
18544 #[serde(rename = "ps2")]
18545 #[strum(serialize = "ps2")]
18546 Ps2,
18547 /// This variant handles values not known at compile time.
18548 #[serde(untagged)]
18549 #[strum(serialize = "__OTHER__")]
18550 Other_(String),
18551}
18552/// Sharing describes three possible ways of sharing the SCSI bus:
18553/// One of these values is assigned to the sharedBus object to determine
18554/// if or how the SCSI bus is shared.
18555///
18556/// Possible values:
18557/// - `noSharing`: The virtual SCSI bus is not shared.
18558/// - `virtualSharing`: The virtual SCSI bus is shared between two or more virtual machines.
18559///
18560/// In this case, no physical machine is involved.
18561/// - `physicalSharing`: The virtual SCSI bus is shared between two or more virtual machines
18562/// residing on different physical hosts.
18563#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18564pub enum VirtualScsiSharingEnum {
18565 #[serde(rename = "noSharing")]
18566 #[strum(serialize = "noSharing")]
18567 NoSharing,
18568 #[serde(rename = "virtualSharing")]
18569 #[strum(serialize = "virtualSharing")]
18570 VirtualSharing,
18571 #[serde(rename = "physicalSharing")]
18572 #[strum(serialize = "physicalSharing")]
18573 PhysicalSharing,
18574 /// This variant handles values not known at compile time.
18575 #[serde(untagged)]
18576 #[strum(serialize = "__OTHER__")]
18577 Other_(String),
18578}
18579/// The <code>*VirtualSerialPortEndPoint_enum* enum defines
18580/// endpoint values for virtual serial port pipe backing.
18581///
18582/// When you use serial port pipe backing to connect a virtual machine
18583/// to another process, you must define the endpoints.
18584/// See the <code>*VirtualSerialPortPipeBackingInfo.endpoint*</code>
18585/// property for the virtual serial port pipe backing information data object.
18586///
18587/// The possible endpoint values are:
18588/// - client
18589/// - server
18590///
18591/// For the supported choices, see the
18592/// <code>*VirtualSerialPortPipeBackingOption.endpoint*</code>
18593/// property for the virtual serial port pipe backing option data object.
18594///
18595/// Possible values:
18596/// - `client`
18597/// - `server`
18598#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18599pub enum VirtualSerialPortEndPointEnum {
18600 #[serde(rename = "client")]
18601 #[strum(serialize = "client")]
18602 Client,
18603 #[serde(rename = "server")]
18604 #[strum(serialize = "server")]
18605 Server,
18606 /// This variant handles values not known at compile time.
18607 #[serde(untagged)]
18608 #[strum(serialize = "__OTHER__")]
18609 Other_(String),
18610}
18611/// Set of possible values for action field in FilterSpec.
18612///
18613/// Determines whether traffic is allowed or denied.
18614///
18615/// Possible values:
18616/// - `allow`: Allow communication.
18617/// - `deny`: Deny communication.
18618#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18619pub enum VirtualMachineVmciDeviceActionEnum {
18620 #[serde(rename = "allow")]
18621 #[strum(serialize = "allow")]
18622 Allow,
18623 #[serde(rename = "deny")]
18624 #[strum(serialize = "deny")]
18625 Deny,
18626 /// This variant handles values not known at compile time.
18627 #[serde(untagged)]
18628 #[strum(serialize = "__OTHER__")]
18629 Other_(String),
18630}
18631/// Set of possible values for direction field in FilterSpec.
18632///
18633/// Possible values:
18634/// - `guest`: from host to guest
18635/// - `host`: from guest to host
18636/// - `anyDirection`: all of the above
18637#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18638pub enum VirtualMachineVmciDeviceDirectionEnum {
18639 #[serde(rename = "guest")]
18640 #[strum(serialize = "guest")]
18641 Guest,
18642 #[serde(rename = "host")]
18643 #[strum(serialize = "host")]
18644 Host,
18645 #[serde(rename = "anyDirection")]
18646 #[strum(serialize = "anyDirection")]
18647 AnyDirection,
18648 /// This variant handles values not known at compile time.
18649 #[serde(untagged)]
18650 #[strum(serialize = "__OTHER__")]
18651 Other_(String),
18652}
18653/// Set of possible values for protocol field in FilterSpec.
18654///
18655/// Possible values:
18656/// - `hypervisor`: VMCI hypervisor datagram send op.
18657///
18658/// Direction code is not applicable to this one.
18659/// - `doorbell`: VMCI doorbell notification
18660/// - `queuepair`: VMCI queue pair alloc operation.
18661///
18662/// Direction code not applicable to this one.
18663/// - `datagram`: VMCI and VMCI Socket datagram send op.
18664///
18665/// Since VMCI Socket datagrams map ports directly to resources,
18666/// there is no need to distinguish between the two.
18667/// - `stream`: VMCI Stream Socket connect op.
18668/// - `anyProtocol`: All of the above.
18669#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18670pub enum VirtualMachineVmciDeviceProtocolEnum {
18671 #[serde(rename = "hypervisor")]
18672 #[strum(serialize = "hypervisor")]
18673 Hypervisor,
18674 #[serde(rename = "doorbell")]
18675 #[strum(serialize = "doorbell")]
18676 Doorbell,
18677 #[serde(rename = "queuepair")]
18678 #[strum(serialize = "queuepair")]
18679 Queuepair,
18680 #[serde(rename = "datagram")]
18681 #[strum(serialize = "datagram")]
18682 Datagram,
18683 #[serde(rename = "stream")]
18684 #[strum(serialize = "stream")]
18685 Stream,
18686 #[serde(rename = "anyProtocol")]
18687 #[strum(serialize = "anyProtocol")]
18688 AnyProtocol,
18689 /// This variant handles values not known at compile time.
18690 #[serde(untagged)]
18691 #[strum(serialize = "__OTHER__")]
18692 Other_(String),
18693}
18694/// Set of possible values for *VirtualMachineVideoCard.use3dRenderer*.
18695///
18696/// Possible values:
18697/// - `automatic`: Determine automatically whether to render 3D with software or hardware.
18698/// - `software`: Render 3D with software.
18699/// - `hardware`: Render 3D with graphics hardware.
18700#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18701pub enum VirtualMachineVideoCardUse3DRendererEnum {
18702 #[serde(rename = "automatic")]
18703 #[strum(serialize = "automatic")]
18704 Automatic,
18705 #[serde(rename = "software")]
18706 #[strum(serialize = "software")]
18707 Software,
18708 #[serde(rename = "hardware")]
18709 #[strum(serialize = "hardware")]
18710 Hardware,
18711 /// This variant handles values not known at compile time.
18712 #[serde(untagged)]
18713 #[strum(serialize = "__OTHER__")]
18714 Other_(String),
18715}
18716/// TSO (TCP Segmentation Offload) and LRO (Large Receive Offload)
18717/// are both offloading techniques that improve network performance
18718/// by reducing CPU overhead associated with packet segmentation
18719/// and aggregation, respectively.
18720///
18721/// They are commonly used in modern
18722/// networking environments to optimize data transmission and
18723/// reception processes. This is the type of disable offload on a
18724/// network adapter.
18725///
18726/// Possible values:
18727/// - `NONE`: Do not disable.
18728/// - `TSO`: Disable TCP Segmentation Offload (TSO).
18729/// - `LRO`: Disable Large Receive Offload (LRO).
18730/// - `TSO_LRO`: Disable both TSO and LRO.
18731#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18732pub enum VirtualVmxnet3StrictLatencyConfigDisableOffloadEnum {
18733 #[serde(rename = "NONE")]
18734 #[strum(serialize = "NONE")]
18735 None,
18736 #[serde(rename = "TSO")]
18737 #[strum(serialize = "TSO")]
18738 Tso,
18739 #[serde(rename = "LRO")]
18740 #[strum(serialize = "LRO")]
18741 Lro,
18742 #[serde(rename = "TSO_LRO")]
18743 #[strum(serialize = "TSO_LRO")]
18744 TsoLro,
18745 /// This variant handles values not known at compile time.
18746 #[serde(untagged)]
18747 #[strum(serialize = "__OTHER__")]
18748 Other_(String),
18749}
18750/// The enumeration of all known valid VRDMA device protocols.
18751///
18752/// Possible values:
18753/// - `rocev1`: A RoCEv1 device.
18754/// - `rocev2`: A RoCEv2 device.
18755#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18756pub enum VirtualVmxnet3VrdmaOptionDeviceProtocolsEnum {
18757 #[serde(rename = "rocev1")]
18758 #[strum(serialize = "rocev1")]
18759 Rocev1,
18760 #[serde(rename = "rocev2")]
18761 #[strum(serialize = "rocev2")]
18762 Rocev2,
18763 /// This variant handles values not known at compile time.
18764 #[serde(untagged)]
18765 #[strum(serialize = "__OTHER__")]
18766 Other_(String),
18767}
18768/// Possible values:
18769/// - `file`: Regular files, and on Posix filesystems, unix domain sockets
18770/// and devices.
18771/// - `directory`: directory
18772/// - `symlink`: symbolic link
18773#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18774pub enum GuestFileTypeEnum {
18775 #[serde(rename = "file")]
18776 #[strum(serialize = "file")]
18777 File,
18778 #[serde(rename = "directory")]
18779 #[strum(serialize = "directory")]
18780 Directory,
18781 #[serde(rename = "symlink")]
18782 #[strum(serialize = "symlink")]
18783 Symlink,
18784 /// This variant handles values not known at compile time.
18785 #[serde(untagged)]
18786 #[strum(serialize = "__OTHER__")]
18787 Other_(String),
18788}
18789/// This describes the bitness (32-bit or 64-bit) of a registry view in a
18790/// Windows OS that supports WOW64.
18791///
18792/// WOW64 (short for Windows 32-bit on Windows 64-bit) is the x86 emulator
18793/// that allows 32-bit Windows-based applications to run seamlessly on
18794/// 64-bit Windows. Please refer to these MSDN sites for more details:
18795/// http://msdn.microsoft.com/en-us/library/aa384249(v=vs.85).aspx and
18796/// http://msdn.microsoft.com/en-us/library/aa384253(v=vs.85).aspx
18797///
18798/// Possible values:
18799/// - `WOWNative`: Access the key from the native view of the
18800/// Registry (32-bit on 32-bit versions of Windows,
18801/// 64-bit on 64-bit versions of Windows).
18802/// - `WOW32`: Access the key from the 32-bit view of the Registry.
18803/// - `WOW64`: Access the key from the 64-bit view of the Registry.
18804#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18805pub enum GuestRegKeyWowSpecEnum {
18806 #[serde(rename = "WOWNative")]
18807 #[strum(serialize = "WOWNative")]
18808 WowNative,
18809 #[serde(rename = "WOW32")]
18810 #[strum(serialize = "WOW32")]
18811 Wow32,
18812 #[serde(rename = "WOW64")]
18813 #[strum(serialize = "WOW64")]
18814 Wow64,
18815 /// This variant handles values not known at compile time.
18816 #[serde(untagged)]
18817 #[strum(serialize = "__OTHER__")]
18818 Other_(String),
18819}
18820/// Capacity reservation state.
18821///
18822/// Possible values:
18823/// - `State_Unknown`: Represent the value when the lower version client cannot recognize the enum value.
18824/// - `Enforced`: Capacity reservation threshold is reported and enforced.
18825/// - `Reported`: Capacity reservation threshold is reported but is not enforced.
18826/// - `Disabled`: Capacity reservation threshold is not reported and is not enforced.
18827/// - `Unsupported`: Capacity reservation is not supported.
18828#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18829pub enum VsanCapacityReservationStateEnum {
18830 #[serde(rename = "State_Unknown")]
18831 #[strum(serialize = "State_Unknown")]
18832 StateUnknown,
18833 Enforced,
18834 Reported,
18835 Disabled,
18836 Unsupported,
18837 /// This variant handles values not known at compile time.
18838 #[serde(untagged)]
18839 #[strum(serialize = "__OTHER__")]
18840 Other_(String),
18841}
18842/// Enumeration of the allowed access type.
18843///
18844/// Possible values:
18845/// - `CleanAffinityLocation`: clean site affinity if the cluster is converted from a stretched cluster to a standard cluster.
18846/// - `FileServiceConfigOpType_Unknown`: indicates the value cannot be recognized.
18847#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18848pub enum VsanFileServiceConfigOpTypeEnum {
18849 CleanAffinityLocation,
18850 #[serde(rename = "FileServiceConfigOpType_Unknown")]
18851 #[strum(serialize = "FileServiceConfigOpType_Unknown")]
18852 FileServiceConfigOpTypeUnknown,
18853 /// This variant handles values not known at compile time.
18854 #[serde(untagged)]
18855 #[strum(serialize = "__OTHER__")]
18856 Other_(String),
18857}
18858/// Enumeration of preflight check scope.
18859///
18860/// Possible values:
18861/// - `basic`: Scope indicates preflight check covers:
18862/// - Network partition check
18863/// - vSAN datastore presence to each host
18864/// - The versions of the ESXi hosts match in this cluster
18865/// - NTP configuration check in ESXi hosts if vSAN file service version is 8.0 or newer
18866/// - Domain configuration format check
18867/// - Running OVF information check
18868/// - If a DVS portgroup is passed as network, it checks if DVS version is older than 6.6
18869/// - `advanced`: Scope indicates preflight check covers:
18870/// - Checks covered in 'basic' scope
18871/// - File server domain configuration validation in live environment when vSAN file service has been enabled
18872/// - `FileServicePreflightCheckScope_Unknown`: represents the value when the lower version client cannot recognize the enum value.
18873#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18874pub enum VsanFileServicePreflightCheckScopeEnum {
18875 #[serde(rename = "basic")]
18876 #[strum(serialize = "basic")]
18877 Basic,
18878 #[serde(rename = "advanced")]
18879 #[strum(serialize = "advanced")]
18880 Advanced,
18881 #[serde(rename = "FileServicePreflightCheckScope_Unknown")]
18882 #[strum(serialize = "FileServicePreflightCheckScope_Unknown")]
18883 FileServicePreflightCheckScopeUnknown,
18884 /// This variant handles values not known at compile time.
18885 #[serde(untagged)]
18886 #[strum(serialize = "__OTHER__")]
18887 Other_(String),
18888}
18889/// Enumeration of the allowed access type.
18890///
18891/// Possible values:
18892/// - `running`: File service VM is up and running
18893/// - `upgrading`: File service VM is in process of upgrading
18894/// - `FileServiceVMStatus_Unknown`: represent the value when the lower version client cannot recognize the enum value.
18895#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18896pub enum VsanFileServiceVmStatusEnum {
18897 #[serde(rename = "running")]
18898 #[strum(serialize = "running")]
18899 Running,
18900 #[serde(rename = "upgrading")]
18901 #[strum(serialize = "upgrading")]
18902 Upgrading,
18903 #[serde(rename = "FileServiceVMStatus_Unknown")]
18904 #[strum(serialize = "FileServiceVMStatus_Unknown")]
18905 FileServiceVmStatusUnknown,
18906 /// This variant handles values not known at compile time.
18907 #[serde(untagged)]
18908 #[strum(serialize = "__OTHER__")]
18909 Other_(String),
18910}
18911/// Enumeration of the allowed access type.
18912///
18913/// Possible values:
18914/// - `READ_ONLY`: Allows only read operations.
18915/// - `READ_WRITE`: Allows both read and write operations.
18916/// - `NO_ACCESS`: Does not allow any operations
18917/// - `FileShareAccessType_Unknown`
18918#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18919pub enum VsanFileShareAccessTypeEnum {
18920 #[serde(rename = "READ_ONLY")]
18921 #[strum(serialize = "READ_ONLY")]
18922 ReadOnly,
18923 #[serde(rename = "READ_WRITE")]
18924 #[strum(serialize = "READ_WRITE")]
18925 ReadWrite,
18926 #[serde(rename = "NO_ACCESS")]
18927 #[strum(serialize = "NO_ACCESS")]
18928 NoAccess,
18929 #[serde(rename = "FileShareAccessType_Unknown")]
18930 #[strum(serialize = "FileShareAccessType_Unknown")]
18931 FileShareAccessTypeUnknown,
18932 /// This variant handles values not known at compile time.
18933 #[serde(untagged)]
18934 #[strum(serialize = "__OTHER__")]
18935 Other_(String),
18936}
18937/// Enumeration of the file share owner type.
18938///
18939/// Possible values:
18940/// - `cns`
18941/// - `user`
18942/// - `FileShareManagingEntity_Unknown`
18943#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18944pub enum VsanFileShareManagingEntityEnum {
18945 #[serde(rename = "cns")]
18946 #[strum(serialize = "cns")]
18947 Cns,
18948 #[serde(rename = "user")]
18949 #[strum(serialize = "user")]
18950 User,
18951 #[serde(rename = "FileShareManagingEntity_Unknown")]
18952 #[strum(serialize = "FileShareManagingEntity_Unknown")]
18953 FileShareManagingEntityUnknown,
18954 /// This variant handles values not known at compile time.
18955 #[serde(untagged)]
18956 #[strum(serialize = "__OTHER__")]
18957 Other_(String),
18958}
18959/// Enumeration of the allowed NFS share security type.
18960///
18961/// This field is not applicable for SMB file share.
18962/// Kerberos security types is based on following RFC:
18963/// https://tools.ietf.org/html/rfc2203.
18964///
18965/// Possible values:
18966/// - `SYS`: AUTH\_SYS or unmanaged authentication from server.
18967///
18968/// Where server trust the uid/gid sent from clients and make no attemp to validate the same.
18969/// - `KRB5`: RPCSEC\_GSS None (Only Authentication)
18970/// - `KRB5I`: RPCSEC\_GSS Integrity (With checksum)
18971/// - `KRB5P`: RPCSEC\_GSS Privacy (With Encryption)
18972/// - `FileShareNfsSecType_Unknown`: represent the value when the lower version client cannot recognize the enum value
18973#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
18974pub enum VsanFileShareNfsSecTypeEnum {
18975 #[serde(rename = "SYS")]
18976 #[strum(serialize = "SYS")]
18977 Sys,
18978 #[serde(rename = "KRB5")]
18979 #[strum(serialize = "KRB5")]
18980 Krb5,
18981 #[serde(rename = "KRB5I")]
18982 #[strum(serialize = "KRB5I")]
18983 Krb5I,
18984 #[serde(rename = "KRB5P")]
18985 #[strum(serialize = "KRB5P")]
18986 Krb5P,
18987 #[serde(rename = "FileShareNfsSecType_Unknown")]
18988 #[strum(serialize = "FileShareNfsSecType_Unknown")]
18989 FileShareNfsSecTypeUnknown,
18990 /// This variant handles values not known at compile time.
18991 #[serde(untagged)]
18992 #[strum(serialize = "__OTHER__")]
18993 Other_(String),
18994}
18995/// Enumeration of the allowed file share protocol.
18996///
18997/// Possible values:
18998/// - `NFSv3`: NFSv3 protocol
18999/// - `NFSv4`: NFSv4.0 and NFSv4.1 protocol
19000/// - `SMB`: SMB2/SMB3 protocol.
19001/// - `FileShareProtocol_Unknown`: represent the value when the lower version client cannot recognize the enum value
19002#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
19003pub enum VsanFileProtocolEnum {
19004 #[serde(rename = "NFSv3")]
19005 #[strum(serialize = "NFSv3")]
19006 NfSv3,
19007 #[serde(rename = "NFSv4")]
19008 #[strum(serialize = "NFSv4")]
19009 NfSv4,
19010 #[serde(rename = "SMB")]
19011 #[strum(serialize = "SMB")]
19012 Smb,
19013 #[serde(rename = "FileShareProtocol_Unknown")]
19014 #[strum(serialize = "FileShareProtocol_Unknown")]
19015 FileShareProtocolUnknown,
19016 /// This variant handles values not known at compile time.
19017 #[serde(untagged)]
19018 #[strum(serialize = "__OTHER__")]
19019 Other_(String),
19020}
19021/// Enumeration of the SMB file share encryption type.
19022///
19023/// Possible values:
19024/// - `disabled`: Disable the encryption for a share
19025/// - `mandatory`: Traffic to a share must be encrypted.
19026///
19027/// Clients that do not support encryption will be denied on accessing the share
19028/// - `FileShareSmbEncryptionType_Unknown`: represent the value when the lower version client cannot recognize the enum value
19029#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
19030pub enum VsanFileShareSmbEncryptionTypeEnum {
19031 #[serde(rename = "disabled")]
19032 #[strum(serialize = "disabled")]
19033 Disabled,
19034 #[serde(rename = "mandatory")]
19035 #[strum(serialize = "mandatory")]
19036 Mandatory,
19037 #[serde(rename = "FileShareSmbEncryptionType_Unknown")]
19038 #[strum(serialize = "FileShareSmbEncryptionType_Unknown")]
19039 FileShareSmbEncryptionTypeUnknown,
19040 /// This variant handles values not known at compile time.
19041 #[serde(untagged)]
19042 #[strum(serialize = "__OTHER__")]
19043 Other_(String),
19044}
19045/// The operation type to update Hci Mesh client info.
19046///
19047/// Possible values:
19048/// - `dryrunDs`: Dry run for precheck Datastore Source for a remote vCenter.
19049/// - `updateDs`: Create or update Datastore Source for a remote vCenter.
19050/// - `destroyDs`: Destroy Datastore Source for a remote vCenter.
19051/// - `dryrun`: Dry run.
19052/// - `mount`: Mount clients to server cluster.
19053/// - `update`: Update clients to server cluster.
19054/// - `unmount`: Unmount clients from server cluster.
19055/// - `HciMeshClientOperation_unknown`: Unknown operation type.
19056#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
19057pub enum HciMeshClientOperationEnum {
19058 #[serde(rename = "dryrunDs")]
19059 #[strum(serialize = "dryrunDs")]
19060 DryrunDs,
19061 #[serde(rename = "updateDs")]
19062 #[strum(serialize = "updateDs")]
19063 UpdateDs,
19064 #[serde(rename = "destroyDs")]
19065 #[strum(serialize = "destroyDs")]
19066 DestroyDs,
19067 #[serde(rename = "dryrun")]
19068 #[strum(serialize = "dryrun")]
19069 Dryrun,
19070 #[serde(rename = "mount")]
19071 #[strum(serialize = "mount")]
19072 Mount,
19073 #[serde(rename = "update")]
19074 #[strum(serialize = "update")]
19075 Update,
19076 #[serde(rename = "unmount")]
19077 #[strum(serialize = "unmount")]
19078 Unmount,
19079 #[serde(rename = "HciMeshClientOperation_unknown")]
19080 #[strum(serialize = "HciMeshClientOperation_unknown")]
19081 HciMeshClientOperationUnknown,
19082 /// This variant handles values not known at compile time.
19083 #[serde(untagged)]
19084 #[strum(serialize = "__OTHER__")]
19085 Other_(String),
19086}
19087/// This list defines the types of vSAN IO diagnostics failed checks
19088/// in 8.x and previous releases.
19089///
19090/// Possible values:
19091/// - `perfsvcdisabled`: means the vSAN performance service is not enabled.
19092/// - `vsandisabled`: means vSAN is not enabled.
19093/// - `runninginstance`: means that there is already a running instance.
19094/// - `stretchedcluster`: means the vSAN stretched cluster is not supported.
19095/// - `nestedfaultdomain`: means the vSAN nested fault domain is not supported.
19096/// - `computeonlycluster`: means the vSAN HCI mesh compute-only cluster is not supported.
19097/// - `networkpartition`
19098/// - `vmnotpoweredon`: means the target virtual machine is not powered on.
19099/// - `vsanobjectinremotedatastore`: means the target virtual machine is in the remote datastore.
19100/// - `invalidtarget`: means the target is not valid.
19101/// - `invalidobjuuid`: means the object UUID is not valid.
19102/// - `invalidduration`: means the duration is not valid.
19103/// - `runninginstanceontarget`: ***Since:*** 8.0.0.4
19104/// - `toomanytargets`: ***Since:*** 8.0.0.4
19105/// - `toomanyobjects`: ***Since:*** 8.0.0.4
19106/// - `VsanIODiagnosticsFailedCheckType_Unknown`: represents the value when the lower version client cannot recognize the enum value.
19107#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
19108pub enum VsanIoDiagnosticsFailedCheckTypeEnum {
19109 #[serde(rename = "perfsvcdisabled")]
19110 #[strum(serialize = "perfsvcdisabled")]
19111 Perfsvcdisabled,
19112 #[serde(rename = "vsandisabled")]
19113 #[strum(serialize = "vsandisabled")]
19114 Vsandisabled,
19115 #[serde(rename = "runninginstance")]
19116 #[strum(serialize = "runninginstance")]
19117 Runninginstance,
19118 #[serde(rename = "stretchedcluster")]
19119 #[strum(serialize = "stretchedcluster")]
19120 Stretchedcluster,
19121 #[serde(rename = "nestedfaultdomain")]
19122 #[strum(serialize = "nestedfaultdomain")]
19123 Nestedfaultdomain,
19124 #[serde(rename = "computeonlycluster")]
19125 #[strum(serialize = "computeonlycluster")]
19126 Computeonlycluster,
19127 #[serde(rename = "networkpartition")]
19128 #[strum(serialize = "networkpartition")]
19129 Networkpartition,
19130 #[serde(rename = "vmnotpoweredon")]
19131 #[strum(serialize = "vmnotpoweredon")]
19132 Vmnotpoweredon,
19133 #[serde(rename = "vsanobjectinremotedatastore")]
19134 #[strum(serialize = "vsanobjectinremotedatastore")]
19135 Vsanobjectinremotedatastore,
19136 #[serde(rename = "invalidtarget")]
19137 #[strum(serialize = "invalidtarget")]
19138 Invalidtarget,
19139 #[serde(rename = "invalidobjuuid")]
19140 #[strum(serialize = "invalidobjuuid")]
19141 Invalidobjuuid,
19142 #[serde(rename = "invalidduration")]
19143 #[strum(serialize = "invalidduration")]
19144 Invalidduration,
19145 #[serde(rename = "runninginstanceontarget")]
19146 #[strum(serialize = "runninginstanceontarget")]
19147 Runninginstanceontarget,
19148 #[serde(rename = "toomanytargets")]
19149 #[strum(serialize = "toomanytargets")]
19150 Toomanytargets,
19151 #[serde(rename = "toomanyobjects")]
19152 #[strum(serialize = "toomanyobjects")]
19153 Toomanyobjects,
19154 #[serde(rename = "VsanIODiagnosticsFailedCheckType_Unknown")]
19155 #[strum(serialize = "VsanIODiagnosticsFailedCheckType_Unknown")]
19156 VsanIoDiagnosticsFailedCheckTypeUnknown,
19157 /// This variant handles values not known at compile time.
19158 #[serde(untagged)]
19159 #[strum(serialize = "__OTHER__")]
19160 Other_(String),
19161}
19162/// This list defines the type of event which happens in the vSAN IO
19163/// diagnostics instance for 8.x and previous releases.
19164///
19165/// Possible values:
19166/// - `objectOwnerTransfer`: represents the object Owner transfer event.
19167/// - `primaryHostTransfer`: represents the primary host transfer event.
19168/// - `vsanmgmtdRestart`: represents the vsanmgmt daemon restart event.
19169/// - `objectComponentsLayoutChange`: represents the components layout change event.
19170/// - `objectProxyOwnerTransfer`
19171/// - `objectRemoval`: ***Since:*** 8.0.0.4
19172/// - `VsanIODiagnosticsInstanceEventType_Unknown`: represents the value when the lower version client cannot recognize the enum value.
19173#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
19174pub enum VsanIoDiagnosticsInstanceEventTypeEnum {
19175 #[serde(rename = "objectOwnerTransfer")]
19176 #[strum(serialize = "objectOwnerTransfer")]
19177 ObjectOwnerTransfer,
19178 #[serde(rename = "primaryHostTransfer")]
19179 #[strum(serialize = "primaryHostTransfer")]
19180 PrimaryHostTransfer,
19181 #[serde(rename = "vsanmgmtdRestart")]
19182 #[strum(serialize = "vsanmgmtdRestart")]
19183 VsanmgmtdRestart,
19184 #[serde(rename = "objectComponentsLayoutChange")]
19185 #[strum(serialize = "objectComponentsLayoutChange")]
19186 ObjectComponentsLayoutChange,
19187 #[serde(rename = "objectProxyOwnerTransfer")]
19188 #[strum(serialize = "objectProxyOwnerTransfer")]
19189 ObjectProxyOwnerTransfer,
19190 #[serde(rename = "objectRemoval")]
19191 #[strum(serialize = "objectRemoval")]
19192 ObjectRemoval,
19193 #[serde(rename = "VsanIODiagnosticsInstanceEventType_Unknown")]
19194 #[strum(serialize = "VsanIODiagnosticsInstanceEventType_Unknown")]
19195 VsanIoDiagnosticsInstanceEventTypeUnknown,
19196 /// This variant handles values not known at compile time.
19197 #[serde(untagged)]
19198 #[strum(serialize = "__OTHER__")]
19199 Other_(String),
19200}
19201/// This data object defines the state of vSAN IO diagnostics instance.
19202///
19203/// Valid types are:
19204///
19205/// Possible values:
19206/// - `VsanIODiagnosticsInstanceCompleted`: represents the completed instance.
19207/// - `VsanIODiagnosticsInstanceRunning`: represents the running instance.
19208/// - `VsanIODiagnosticsInstanceState_Unknown`: represents the value when the lower version client cannot recognize the enum value.
19209#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
19210pub enum VsanIoDiagnosticsInstanceStateEnum {
19211 #[serde(rename = "VsanIODiagnosticsInstanceCompleted")]
19212 #[strum(serialize = "VsanIODiagnosticsInstanceCompleted")]
19213 VsanIoDiagnosticsInstanceCompleted,
19214 #[serde(rename = "VsanIODiagnosticsInstanceRunning")]
19215 #[strum(serialize = "VsanIODiagnosticsInstanceRunning")]
19216 VsanIoDiagnosticsInstanceRunning,
19217 #[serde(rename = "VsanIODiagnosticsInstanceState_Unknown")]
19218 #[strum(serialize = "VsanIODiagnosticsInstanceState_Unknown")]
19219 VsanIoDiagnosticsInstanceStateUnknown,
19220 /// This variant handles values not known at compile time.
19221 #[serde(untagged)]
19222 #[strum(serialize = "__OTHER__")]
19223 Other_(String),
19224}
19225/// This data object defines the types that support vSAN IO diagnostics.
19226///
19227/// Valid types are:
19228///
19229/// Possible values:
19230/// - `VirtualMachine`: with this type IO diagnostics task will be run against the vmdks associated with the virtual machine.
19231/// - `VsanIODiagnosticsTargetType_Unknown`: represents the value when the lower version client cannot recognize the enum value.
19232#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
19233pub enum VsanIoDiagnosticsTargetTypeEnum {
19234 VirtualMachine,
19235 #[serde(rename = "VsanIODiagnosticsTargetType_Unknown")]
19236 #[strum(serialize = "VsanIODiagnosticsTargetType_Unknown")]
19237 VsanIoDiagnosticsTargetTypeUnknown,
19238 /// This variant handles values not known at compile time.
19239 #[serde(untagged)]
19240 #[strum(serialize = "__OTHER__")]
19241 Other_(String),
19242}
19243/// This data object defines the type of the vSAN IO latency in the whole vSAN IO
19244/// stack from DOM owner to the DOM component manager and LSOM.
19245///
19246/// Possible values:
19247/// - `DomOwnerLatency`: Defines the latency spent at DOM owner layer.
19248/// - `NetworkLatency`: Defines the latency spent over the network.
19249/// - `LsomLatency`: Defines the latency spent at LSOM layer.
19250/// - `VsanIOLatencyType_Unknown`: The fallback version for an unknown vSAN IO latency type.
19251/// - `ZdomLatency`
19252/// - `PerfDomOwnerLatency`
19253/// - `CapacityDomOwnerLatency`
19254/// - `PerfNetworkLatency`
19255/// - `CapacityNetworkLatency`
19256/// - `PerfLsomLatency`
19257/// - `CapacityLsomLatency`
19258/// - `CrossSiteNetworkLatency`
19259#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
19260pub enum VsanIoLatencyTypeEnum {
19261 DomOwnerLatency,
19262 NetworkLatency,
19263 LsomLatency,
19264 #[serde(rename = "VsanIOLatencyType_Unknown")]
19265 #[strum(serialize = "VsanIOLatencyType_Unknown")]
19266 VsanIoLatencyTypeUnknown,
19267 ZdomLatency,
19268 PerfDomOwnerLatency,
19269 CapacityDomOwnerLatency,
19270 PerfNetworkLatency,
19271 CapacityNetworkLatency,
19272 PerfLsomLatency,
19273 CapacityLsomLatency,
19274 CrossSiteNetworkLatency,
19275 /// This variant handles values not known at compile time.
19276 #[serde(untagged)]
19277 #[strum(serialize = "__OTHER__")]
19278 Other_(String),
19279}
19280/// The lifecycle operation types required by lifecycle manager/vLCM.
19281///
19282/// Possible values:
19283/// - `noChecks`: No checks, only return configuration details.
19284/// - `LifecycleCheckOperation_unknown`
19285#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
19286pub enum VimVsanLifecycleCheckOperationEnum {
19287 #[serde(rename = "noChecks")]
19288 #[strum(serialize = "noChecks")]
19289 NoChecks,
19290 #[serde(rename = "LifecycleCheckOperation_unknown")]
19291 #[strum(serialize = "LifecycleCheckOperation_unknown")]
19292 LifecycleCheckOperationUnknown,
19293 /// This variant handles values not known at compile time.
19294 #[serde(untagged)]
19295 #[strum(serialize = "__OTHER__")]
19296 Other_(String),
19297}
19298/// The lifecycle cluster types required by lifecycle manager/vLCM.
19299///
19300/// Possible values:
19301/// - `single`: Single site cluster.
19302/// - `stretched`: Stretched cluster.
19303/// - `metadata`: Metadata mode cluster.
19304/// - `LifecycleClusterType_unknown`: Unknown cluster type.
19305#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
19306pub enum VimVsanLifecycleClusterTypeEnum {
19307 #[serde(rename = "single")]
19308 #[strum(serialize = "single")]
19309 Single,
19310 #[serde(rename = "stretched")]
19311 #[strum(serialize = "stretched")]
19312 Stretched,
19313 #[serde(rename = "metadata")]
19314 #[strum(serialize = "metadata")]
19315 Metadata,
19316 #[serde(rename = "LifecycleClusterType_unknown")]
19317 #[strum(serialize = "LifecycleClusterType_unknown")]
19318 LifecycleClusterTypeUnknown,
19319 /// This variant handles values not known at compile time.
19320 #[serde(untagged)]
19321 #[strum(serialize = "__OTHER__")]
19322 Other_(String),
19323}
19324/// The lifecycle check types required by lifecycle manager/vLCM.
19325///
19326/// Possible values:
19327/// - `supportedWitnessVersion`: Check to cover that the witness host software version is 7.0 or higher.
19328/// - `virtualWitnessHost`: Check to cover that the witness host is a virtual host and not a physical host.
19329/// - `sharedWitnessHost`: Check to cover that the witness host is not shared.
19330/// - `PreCheckType_unknown`: Unknown precheck type.
19331#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
19332pub enum VimVsanLifecyclePreCheckTypeEnum {
19333 #[serde(rename = "supportedWitnessVersion")]
19334 #[strum(serialize = "supportedWitnessVersion")]
19335 SupportedWitnessVersion,
19336 #[serde(rename = "virtualWitnessHost")]
19337 #[strum(serialize = "virtualWitnessHost")]
19338 VirtualWitnessHost,
19339 #[serde(rename = "sharedWitnessHost")]
19340 #[strum(serialize = "sharedWitnessHost")]
19341 SharedWitnessHost,
19342 #[serde(rename = "PreCheckType_unknown")]
19343 #[strum(serialize = "PreCheckType_unknown")]
19344 PreCheckTypeUnknown,
19345 /// This variant handles values not known at compile time.
19346 #[serde(untagged)]
19347 #[strum(serialize = "__OTHER__")]
19348 Other_(String),
19349}
19350/// Mode for the vSAN cluster.
19351///
19352/// If mode is not specified, then vSAN is running
19353/// in default vSAN mode.
19354///
19355/// Possible values:
19356/// - `Mode_None`: Represents the value for vSAN mode not being set.
19357///
19358/// Any mode can be disabled by setting this value.
19359/// - `Mode_Compute`: Compute mode for vSAN.
19360///
19361/// 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
19362/// - `Mode_Storage`
19363/// - `Mode_Unknown`: Represents the value when the lower version client cannot recognize the enum value
19364#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
19365pub enum VsanModeEnum {
19366 #[serde(rename = "Mode_None")]
19367 #[strum(serialize = "Mode_None")]
19368 ModeNone,
19369 #[serde(rename = "Mode_Compute")]
19370 #[strum(serialize = "Mode_Compute")]
19371 ModeCompute,
19372 #[serde(rename = "Mode_Storage")]
19373 #[strum(serialize = "Mode_Storage")]
19374 ModeStorage,
19375 #[serde(rename = "Mode_Unknown")]
19376 #[strum(serialize = "Mode_Unknown")]
19377 ModeUnknown,
19378 /// This variant handles values not known at compile time.
19379 #[serde(untagged)]
19380 #[strum(serialize = "__OTHER__")]
19381 Other_(String),
19382}
19383/// This indicates the precheck type when mounting a remote vSAN datastore
19384/// (for 8.x and previous releases).
19385///
19386/// Possible values:
19387/// - `supportedConfiguration`: General checks to cover following items, 1.
19388///
19389/// 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.
19390/// - `localVsanDatastore`: Check if given datastore is local vSAN datastore.
19391/// - `datastoreType`: Check if remote datastore is a vSAN datastore.
19392/// - `datacenter`: Check if given datastore and cluster are from different datacenters.
19393/// - `vsanFormatVersion`: Check vSAN format version can support mounting remote vSAN datastore.
19394/// - `serverClusterHealth`: Check if the cluster which owns given vSAN datastore is healthy.
19395/// - `datastorePolicy`: Check if given datastore can provision objects using default datastore policy.
19396/// - `remoteDatastoreLimit`: Check number of remote vSAN datastores which are mounted by a client cluster doesn't exceed limit.
19397/// - `clientClusterLimit`: Check number of client clusters which mount to a server cluster doesn't exceed limit.
19398/// - `serverClusterLimit`: Check number of server clusters which a client cluster mounts to doesn't exceed limit.
19399/// - `connectivity`: Check network connectivity between client hosts and server hosts.
19400/// - `networkLatency`: Check network latency between client hosts and server hosts.
19401/// - `license`: Check if all client hosts and server hosts have remote datastore license.
19402/// - `precheck_unknown`: Unknown precheck type.
19403/// - `serverVersionForComputeMode`
19404/// - `remoteVcConnection`
19405/// - `datastoreExists`
19406/// - `serverVcenterLimit`
19407/// - `clientVcenterLimit`
19408/// - `vcApiVersion`
19409/// - `vcenterIdValid`
19410/// - `checkServerVcenter`
19411#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
19412pub enum VimVsanMountPrecheckTypeEnum {
19413 #[serde(rename = "supportedConfiguration")]
19414 #[strum(serialize = "supportedConfiguration")]
19415 SupportedConfiguration,
19416 #[serde(rename = "localVsanDatastore")]
19417 #[strum(serialize = "localVsanDatastore")]
19418 LocalVsanDatastore,
19419 #[serde(rename = "datastoreType")]
19420 #[strum(serialize = "datastoreType")]
19421 DatastoreType,
19422 #[serde(rename = "datacenter")]
19423 #[strum(serialize = "datacenter")]
19424 Datacenter,
19425 #[serde(rename = "vsanFormatVersion")]
19426 #[strum(serialize = "vsanFormatVersion")]
19427 VsanFormatVersion,
19428 #[serde(rename = "serverClusterHealth")]
19429 #[strum(serialize = "serverClusterHealth")]
19430 ServerClusterHealth,
19431 #[serde(rename = "datastorePolicy")]
19432 #[strum(serialize = "datastorePolicy")]
19433 DatastorePolicy,
19434 #[serde(rename = "remoteDatastoreLimit")]
19435 #[strum(serialize = "remoteDatastoreLimit")]
19436 RemoteDatastoreLimit,
19437 #[serde(rename = "clientClusterLimit")]
19438 #[strum(serialize = "clientClusterLimit")]
19439 ClientClusterLimit,
19440 #[serde(rename = "serverClusterLimit")]
19441 #[strum(serialize = "serverClusterLimit")]
19442 ServerClusterLimit,
19443 #[serde(rename = "connectivity")]
19444 #[strum(serialize = "connectivity")]
19445 Connectivity,
19446 #[serde(rename = "networkLatency")]
19447 #[strum(serialize = "networkLatency")]
19448 NetworkLatency,
19449 #[serde(rename = "license")]
19450 #[strum(serialize = "license")]
19451 License,
19452 #[serde(rename = "precheck_unknown")]
19453 #[strum(serialize = "precheck_unknown")]
19454 PrecheckUnknown,
19455 #[serde(rename = "serverVersionForComputeMode")]
19456 #[strum(serialize = "serverVersionForComputeMode")]
19457 ServerVersionForComputeMode,
19458 #[serde(rename = "remoteVcConnection")]
19459 #[strum(serialize = "remoteVcConnection")]
19460 RemoteVcConnection,
19461 #[serde(rename = "datastoreExists")]
19462 #[strum(serialize = "datastoreExists")]
19463 DatastoreExists,
19464 #[serde(rename = "serverVcenterLimit")]
19465 #[strum(serialize = "serverVcenterLimit")]
19466 ServerVcenterLimit,
19467 #[serde(rename = "clientVcenterLimit")]
19468 #[strum(serialize = "clientVcenterLimit")]
19469 ClientVcenterLimit,
19470 #[serde(rename = "vcApiVersion")]
19471 #[strum(serialize = "vcApiVersion")]
19472 VcApiVersion,
19473 #[serde(rename = "vcenterIdValid")]
19474 #[strum(serialize = "vcenterIdValid")]
19475 VcenterIdValid,
19476 #[serde(rename = "checkServerVcenter")]
19477 #[strum(serialize = "checkServerVcenter")]
19478 CheckServerVcenter,
19479 /// This variant handles values not known at compile time.
19480 #[serde(untagged)]
19481 #[strum(serialize = "__OTHER__")]
19482 Other_(String),
19483}
19484/// Remediate action type.
19485///
19486/// When vSAN cluster remediate, vSAN will check the performance service configuration and
19487/// performance service status. If the vSAN performance service configuration is enable but
19488/// the vSAN performance service is not running, it will return "enable" to remediate vSAN
19489/// performance service. If the vSAN performance service configuration is disable but the
19490/// vSAN performance service is not running, it will return "disable" to remediate vSAN
19491/// performance service. If the vSAN performance service configuration is enable, the vSAN
19492/// performance service is running, but the profile of performance service is not match
19493/// the configuration, it will return "update\_profile" to remediate vSAN performance service.
19494/// Others will return "no\_action" which means no need to remediate vSAN performance service.
19495/// Valid types are:
19496///
19497/// Possible values:
19498/// - `enable`: remediate action is create stats object.
19499/// - `disable`: remediate action is delete stats object.
19500/// - `update_profile`: remediate action is update stats object policy.
19501/// - `no_action`: remediate action will do no action.
19502/// - `PerfsvcRemediateAction_Unknown`
19503#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
19504pub enum VsanPerfsvcRemediateActionEnum {
19505 #[serde(rename = "enable")]
19506 #[strum(serialize = "enable")]
19507 Enable,
19508 #[serde(rename = "disable")]
19509 #[strum(serialize = "disable")]
19510 Disable,
19511 #[serde(rename = "update_profile")]
19512 #[strum(serialize = "update_profile")]
19513 UpdateProfile,
19514 #[serde(rename = "no_action")]
19515 #[strum(serialize = "no_action")]
19516 NoAction,
19517 #[serde(rename = "PerfsvcRemediateAction_Unknown")]
19518 #[strum(serialize = "PerfsvcRemediateAction_Unknown")]
19519 PerfsvcRemediateActionUnknown,
19520 /// This variant handles values not known at compile time.
19521 #[serde(untagged)]
19522 #[strum(serialize = "__OTHER__")]
19523 Other_(String),
19524}
19525/// Related operations for PrecheckDatastoreSource.
19526///
19527/// Possible values:
19528/// - `checkCreateDs`: Run precheck for creating Datastore Source.
19529/// - `checkUpdateDs`: Run precheck for updating Datastore Source.
19530/// - `checkDestroyDs`: Run precheck for destroying Datastore Source.
19531/// - `PrecheckDatastoreSourceOperation_unknown`: Unknown operation type.
19532#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
19533pub enum PrecheckDatastoreSourceOperationEnum {
19534 #[serde(rename = "checkCreateDs")]
19535 #[strum(serialize = "checkCreateDs")]
19536 CheckCreateDs,
19537 #[serde(rename = "checkUpdateDs")]
19538 #[strum(serialize = "checkUpdateDs")]
19539 CheckUpdateDs,
19540 #[serde(rename = "checkDestroyDs")]
19541 #[strum(serialize = "checkDestroyDs")]
19542 CheckDestroyDs,
19543 #[serde(rename = "PrecheckDatastoreSourceOperation_unknown")]
19544 #[strum(serialize = "PrecheckDatastoreSourceOperation_unknown")]
19545 PrecheckDatastoreSourceOperationUnknown,
19546 /// This variant handles values not known at compile time.
19547 #[serde(untagged)]
19548 #[strum(serialize = "__OTHER__")]
19549 Other_(String),
19550}
19551/// The link type of a remote vCenter.
19552///
19553/// Possible values:
19554/// - `standalone`: Remote vCenter is standalone.
19555/// - `VsanRemoteVcLinkType_unknown`: Unsupported link type.
19556#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
19557pub enum VsanRemoteVcLinkTypeEnum {
19558 #[serde(rename = "standalone")]
19559 #[strum(serialize = "standalone")]
19560 Standalone,
19561 #[serde(rename = "VsanRemoteVcLinkType_unknown")]
19562 #[strum(serialize = "VsanRemoteVcLinkType_unknown")]
19563 VsanRemoteVcLinkTypeUnknown,
19564 /// This variant handles values not known at compile time.
19565 #[serde(untagged)]
19566 #[strum(serialize = "__OTHER__")]
19567 Other_(String),
19568}
19569/// Network topology between the client and server cluster in a HCI Mesh
19570/// configuration.
19571///
19572/// Possible values:
19573/// - `Topology_Unknown`: Represent the value when the lower version client cannot recognize the enum value.
19574/// - `Symmetric`: Hosts in client and server clusters have homogenous network connectivity with similar network properties like bandwidth and latency.
19575/// - `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.
19576#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
19577pub enum RemoteVsanNetworkTopologyEnum {
19578 #[serde(rename = "Topology_Unknown")]
19579 #[strum(serialize = "Topology_Unknown")]
19580 TopologyUnknown,
19581 Symmetric,
19582 Asymmetric,
19583 /// This variant handles values not known at compile time.
19584 #[serde(untagged)]
19585 #[strum(serialize = "__OTHER__")]
19586 Other_(String),
19587}
19588/// Enumeration of the types for resource check component result.
19589///
19590/// Possible values:
19591/// - `vSAN`: The resource check result for regular vSAN.
19592/// - `DataPersistence`: The resource check result for vSphere data persistence platform.
19593/// - `ResourceCheckComponentType_Unknown`: represent the value when the lower version client cannot recognize the enum value.
19594#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
19595pub enum VsanResourceCheckComponentTypeEnum {
19596 #[serde(rename = "vSAN")]
19597 #[strum(serialize = "vSAN")]
19598 VSan,
19599 DataPersistence,
19600 #[serde(rename = "ResourceCheckComponentType_Unknown")]
19601 #[strum(serialize = "ResourceCheckComponentType_Unknown")]
19602 ResourceCheckComponentTypeUnknown,
19603 /// This variant handles values not known at compile time.
19604 #[serde(untagged)]
19605 #[strum(serialize = "__OTHER__")]
19606 Other_(String),
19607}
19608/// \* The dedup store health category enumeration used in resource check.
19609///
19610/// Possible values:
19611/// - `Inaccessible`: The dedup store is inaccessible which means the dedup store
19612/// has inaccessible sub objects.
19613/// - `Noncompliant`: The dedup store is noncompliant which means the dedup store
19614/// has no inaccessible sub objects but has noncompliant sub objects.
19615#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
19616pub enum ResourceCheckDedupStoreHealthStateEnum {
19617 Inaccessible,
19618 Noncompliant,
19619 /// This variant handles values not known at compile time.
19620 #[serde(untagged)]
19621 #[strum(serialize = "__OTHER__")]
19622 Other_(String),
19623}
19624/// Enumeration of the types for resource check status.
19625///
19626/// Possible values:
19627/// - `resourceCheckUninitialized`: The resource check has never run yet, or it just starts but the task has not been launched yet (i.e.
19628///
19629/// still in initialization stage).
19630/// - `resourceCheckRunning`: The resource check is currently running.
19631/// - `resourceCheckFailed`: The resource check has failed.
19632/// - `resourceCheckCancelled`: The resource check has been cancelled by user.
19633/// - `resourceCheckCompleted`: The resource check has completed successfully.
19634/// - `resourceCheckNoRecentValue`: The last resource check completed successfully but then it has not run again for a while (e.g.
19635///
19636/// 60 min) and the result of the last check becomes stale.
19637/// - `resourceCheckNotSupported`: The resource check is not supported by one or more host in cluster.
19638/// - `ResourceCheckStatusType_Unknown`
19639#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
19640pub enum VsanResourceCheckStatusTypeEnum {
19641 #[serde(rename = "resourceCheckUninitialized")]
19642 #[strum(serialize = "resourceCheckUninitialized")]
19643 ResourceCheckUninitialized,
19644 #[serde(rename = "resourceCheckRunning")]
19645 #[strum(serialize = "resourceCheckRunning")]
19646 ResourceCheckRunning,
19647 #[serde(rename = "resourceCheckFailed")]
19648 #[strum(serialize = "resourceCheckFailed")]
19649 ResourceCheckFailed,
19650 #[serde(rename = "resourceCheckCancelled")]
19651 #[strum(serialize = "resourceCheckCancelled")]
19652 ResourceCheckCancelled,
19653 #[serde(rename = "resourceCheckCompleted")]
19654 #[strum(serialize = "resourceCheckCompleted")]
19655 ResourceCheckCompleted,
19656 #[serde(rename = "resourceCheckNoRecentValue")]
19657 #[strum(serialize = "resourceCheckNoRecentValue")]
19658 ResourceCheckNoRecentValue,
19659 #[serde(rename = "resourceCheckNotSupported")]
19660 #[strum(serialize = "resourceCheckNotSupported")]
19661 ResourceCheckNotSupported,
19662 #[serde(rename = "ResourceCheckStatusType_Unknown")]
19663 #[strum(serialize = "ResourceCheckStatusType_Unknown")]
19664 ResourceCheckStatusTypeUnknown,
19665 /// This variant handles values not known at compile time.
19666 #[serde(untagged)]
19667 #[strum(serialize = "__OTHER__")]
19668 Other_(String),
19669}
19670/// The creator of snapshot.
19671///
19672/// Possible values:
19673/// - `SnapService`: Snapshot is created by Snapshot Service.
19674/// - `SnapshotCreator_Unknown`: Represent the value when the lower version client cannot recognize the enum value.
19675///
19676/// ***Since:*** 8.0.0.4
19677#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
19678pub enum VsanSnapshotCreatorEnum {
19679 SnapService,
19680 #[serde(rename = "SnapshotCreator_Unknown")]
19681 #[strum(serialize = "SnapshotCreator_Unknown")]
19682 SnapshotCreatorUnknown,
19683 /// This variant handles values not known at compile time.
19684 #[serde(untagged)]
19685 #[strum(serialize = "__OTHER__")]
19686 Other_(String),
19687}
19688/// The type of snapshot.
19689///
19690/// Possible values:
19691/// - `Managed`: Snapshot is a managed snapshot.
19692/// - `Unmanaged`: Snapshot is an unmanaged snapshot.
19693/// - `SnapshotType_Unknown`: Represent the value when the lower version client cannot recognize the enum value.
19694///
19695/// ***Since:*** 8.0.0.4
19696#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
19697pub enum VsanSnapshotTypeEnum {
19698 Managed,
19699 Unmanaged,
19700 #[serde(rename = "SnapshotType_Unknown")]
19701 #[strum(serialize = "SnapshotType_Unknown")]
19702 SnapshotTypeUnknown,
19703 /// This variant handles values not known at compile time.
19704 #[serde(untagged)]
19705 #[strum(serialize = "__OTHER__")]
19706 Other_(String),
19707}
19708/// Enumeration type for associating event with managed object
19709///
19710/// This is a list of supported locations to associate an event.
19711///
19712/// The event
19713/// could be related to disk, hosts or cluster.
19714///
19715/// Possible values:
19716/// - `CLUSTER`
19717/// - `HOST`
19718/// - `DISK`
19719/// - `EVENT_LOCATION_UNKNOWN`
19720#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
19721pub enum VsanAnalyticsEventLocationTypeEnum {
19722 #[serde(rename = "CLUSTER")]
19723 #[strum(serialize = "CLUSTER")]
19724 Cluster,
19725 #[serde(rename = "HOST")]
19726 #[strum(serialize = "HOST")]
19727 Host,
19728 #[serde(rename = "DISK")]
19729 #[strum(serialize = "DISK")]
19730 Disk,
19731 #[serde(rename = "EVENT_LOCATION_UNKNOWN")]
19732 #[strum(serialize = "EVENT_LOCATION_UNKNOWN")]
19733 EventLocationUnknown,
19734 /// This variant handles values not known at compile time.
19735 #[serde(untagged)]
19736 #[strum(serialize = "__OTHER__")]
19737 Other_(String),
19738}
19739/// Enumeration type for snapshot types
19740///
19741/// This is a list of supported snapshot types.
19742///
19743/// Possible values:
19744/// - `OBJECT_SNAPSHOT`
19745/// - `HOST_SNAPSHOT`
19746/// - `DISK_SNAPSHOT`
19747/// - `POLICY_SNAPSHOT`
19748/// - `SNAPSHOT_TYPE_UNKNOWN`
19749#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
19750pub enum VsanAnalyticsEventSnapshotTypeEnum {
19751 #[serde(rename = "OBJECT_SNAPSHOT")]
19752 #[strum(serialize = "OBJECT_SNAPSHOT")]
19753 ObjectSnapshot,
19754 #[serde(rename = "HOST_SNAPSHOT")]
19755 #[strum(serialize = "HOST_SNAPSHOT")]
19756 HostSnapshot,
19757 #[serde(rename = "DISK_SNAPSHOT")]
19758 #[strum(serialize = "DISK_SNAPSHOT")]
19759 DiskSnapshot,
19760 #[serde(rename = "POLICY_SNAPSHOT")]
19761 #[strum(serialize = "POLICY_SNAPSHOT")]
19762 PolicySnapshot,
19763 #[serde(rename = "SNAPSHOT_TYPE_UNKNOWN")]
19764 #[strum(serialize = "SNAPSHOT_TYPE_UNKNOWN")]
19765 SnapshotTypeUnknown,
19766 /// This variant handles values not known at compile time.
19767 #[serde(untagged)]
19768 #[strum(serialize = "__OTHER__")]
19769 Other_(String),
19770}
19771/// Enumeration type for events currently subscribed.
19772///
19773///
19774/// This is a list of supported supported events vSAN analytics will collect.
19775///
19776/// Possible values:
19777/// - `STORAGE_OBJECT_UNAVAILABLE`
19778/// - `STORAGE_OBJECT_AVAILABLE`
19779/// - `STORAGE_OBJECT_REPL_CHANGE`
19780/// - `STORAGE_OBJECT_LOST`
19781/// - `STORAGE_OBJECT_CREATED`
19782/// - `STORAGE_OBJECT_DELETED`
19783/// - `STORAGE_DOM_OBJECT_CHANGE`
19784/// - `REPAIR_START`
19785/// - `REPAIR_END`
19786/// - `REBUILD_START`
19787/// - `REBUILD_END`
19788/// - `RESYNC_IN_PROGRESS`
19789/// - `RESYNC_END`
19790/// - `PATCH_START`
19791/// - `PATCH_END`
19792/// - `DG_DECOM_START`
19793/// - `DG_DECOM_END`
19794/// - `HOST_DECOM_START`
19795/// - `HOST_DECOM_FAIL`
19796/// - `HOST_DECOM_END`
19797/// - `CLUSTER_CREATED`
19798/// - `CLUSTER_DELETED`
19799/// - `SDDC_CREATED`
19800/// - `SDDC_DELETED`
19801/// - `HOST_CREATED`
19802/// - `HOST_DELETED`
19803/// - `CLUSTER_MEMBERSHIP_CHANGED`
19804/// - `DEVICE_FAILURE`
19805/// - `DEVICE_NORMAL`
19806/// - `DEVICE_OFFLINE`
19807/// - `DEVICE_ERROR`
19808/// - `HOST_FAILURE`
19809/// - `HOST_NORMAL`
19810/// - `EVENT_TYPE_UNKNOWN`
19811#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
19812pub enum VsanAnalyticsEventTypeEnum {
19813 #[serde(rename = "STORAGE_OBJECT_UNAVAILABLE")]
19814 #[strum(serialize = "STORAGE_OBJECT_UNAVAILABLE")]
19815 StorageObjectUnavailable,
19816 #[serde(rename = "STORAGE_OBJECT_AVAILABLE")]
19817 #[strum(serialize = "STORAGE_OBJECT_AVAILABLE")]
19818 StorageObjectAvailable,
19819 #[serde(rename = "STORAGE_OBJECT_REPL_CHANGE")]
19820 #[strum(serialize = "STORAGE_OBJECT_REPL_CHANGE")]
19821 StorageObjectReplChange,
19822 #[serde(rename = "STORAGE_OBJECT_LOST")]
19823 #[strum(serialize = "STORAGE_OBJECT_LOST")]
19824 StorageObjectLost,
19825 #[serde(rename = "STORAGE_OBJECT_CREATED")]
19826 #[strum(serialize = "STORAGE_OBJECT_CREATED")]
19827 StorageObjectCreated,
19828 #[serde(rename = "STORAGE_OBJECT_DELETED")]
19829 #[strum(serialize = "STORAGE_OBJECT_DELETED")]
19830 StorageObjectDeleted,
19831 #[serde(rename = "STORAGE_DOM_OBJECT_CHANGE")]
19832 #[strum(serialize = "STORAGE_DOM_OBJECT_CHANGE")]
19833 StorageDomObjectChange,
19834 #[serde(rename = "REPAIR_START")]
19835 #[strum(serialize = "REPAIR_START")]
19836 RepairStart,
19837 #[serde(rename = "REPAIR_END")]
19838 #[strum(serialize = "REPAIR_END")]
19839 RepairEnd,
19840 #[serde(rename = "REBUILD_START")]
19841 #[strum(serialize = "REBUILD_START")]
19842 RebuildStart,
19843 #[serde(rename = "REBUILD_END")]
19844 #[strum(serialize = "REBUILD_END")]
19845 RebuildEnd,
19846 #[serde(rename = "RESYNC_IN_PROGRESS")]
19847 #[strum(serialize = "RESYNC_IN_PROGRESS")]
19848 ResyncInProgress,
19849 #[serde(rename = "RESYNC_END")]
19850 #[strum(serialize = "RESYNC_END")]
19851 ResyncEnd,
19852 #[serde(rename = "PATCH_START")]
19853 #[strum(serialize = "PATCH_START")]
19854 PatchStart,
19855 #[serde(rename = "PATCH_END")]
19856 #[strum(serialize = "PATCH_END")]
19857 PatchEnd,
19858 #[serde(rename = "DG_DECOM_START")]
19859 #[strum(serialize = "DG_DECOM_START")]
19860 DgDecomStart,
19861 #[serde(rename = "DG_DECOM_END")]
19862 #[strum(serialize = "DG_DECOM_END")]
19863 DgDecomEnd,
19864 #[serde(rename = "HOST_DECOM_START")]
19865 #[strum(serialize = "HOST_DECOM_START")]
19866 HostDecomStart,
19867 #[serde(rename = "HOST_DECOM_FAIL")]
19868 #[strum(serialize = "HOST_DECOM_FAIL")]
19869 HostDecomFail,
19870 #[serde(rename = "HOST_DECOM_END")]
19871 #[strum(serialize = "HOST_DECOM_END")]
19872 HostDecomEnd,
19873 #[serde(rename = "CLUSTER_CREATED")]
19874 #[strum(serialize = "CLUSTER_CREATED")]
19875 ClusterCreated,
19876 #[serde(rename = "CLUSTER_DELETED")]
19877 #[strum(serialize = "CLUSTER_DELETED")]
19878 ClusterDeleted,
19879 #[serde(rename = "SDDC_CREATED")]
19880 #[strum(serialize = "SDDC_CREATED")]
19881 SddcCreated,
19882 #[serde(rename = "SDDC_DELETED")]
19883 #[strum(serialize = "SDDC_DELETED")]
19884 SddcDeleted,
19885 #[serde(rename = "HOST_CREATED")]
19886 #[strum(serialize = "HOST_CREATED")]
19887 HostCreated,
19888 #[serde(rename = "HOST_DELETED")]
19889 #[strum(serialize = "HOST_DELETED")]
19890 HostDeleted,
19891 #[serde(rename = "CLUSTER_MEMBERSHIP_CHANGED")]
19892 #[strum(serialize = "CLUSTER_MEMBERSHIP_CHANGED")]
19893 ClusterMembershipChanged,
19894 #[serde(rename = "DEVICE_FAILURE")]
19895 #[strum(serialize = "DEVICE_FAILURE")]
19896 DeviceFailure,
19897 #[serde(rename = "DEVICE_NORMAL")]
19898 #[strum(serialize = "DEVICE_NORMAL")]
19899 DeviceNormal,
19900 #[serde(rename = "DEVICE_OFFLINE")]
19901 #[strum(serialize = "DEVICE_OFFLINE")]
19902 DeviceOffline,
19903 #[serde(rename = "DEVICE_ERROR")]
19904 #[strum(serialize = "DEVICE_ERROR")]
19905 DeviceError,
19906 #[serde(rename = "HOST_FAILURE")]
19907 #[strum(serialize = "HOST_FAILURE")]
19908 HostFailure,
19909 #[serde(rename = "HOST_NORMAL")]
19910 #[strum(serialize = "HOST_NORMAL")]
19911 HostNormal,
19912 #[serde(rename = "EVENT_TYPE_UNKNOWN")]
19913 #[strum(serialize = "EVENT_TYPE_UNKNOWN")]
19914 EventTypeUnknown,
19915 /// This variant handles values not known at compile time.
19916 #[serde(untagged)]
19917 #[strum(serialize = "__OTHER__")]
19918 Other_(String),
19919}
19920/// It's used to declare the vSAN configuration types that the hardware
19921/// components like CPU, memory, disk and physical NIC is compatible with.
19922///
19923/// Possible values:
19924/// - `vsan`: represent the regular vSAN.
19925/// - `vsanEsa`: represent vSAN ESA.
19926/// - `VsanConfigType_Unknown`: represent the value when the lower version client cannot recognize the enum value.
19927#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
19928pub enum VsanConfigTypeEnum {
19929 #[serde(rename = "vsan")]
19930 #[strum(serialize = "vsan")]
19931 Vsan,
19932 #[serde(rename = "vsanEsa")]
19933 #[strum(serialize = "vsanEsa")]
19934 VsanEsa,
19935 #[serde(rename = "VsanConfigType_Unknown")]
19936 #[strum(serialize = "VsanConfigType_Unknown")]
19937 VsanConfigTypeUnknown,
19938 /// This variant handles values not known at compile time.
19939 #[serde(untagged)]
19940 #[strum(serialize = "__OTHER__")]
19941 Other_(String),
19942}
19943/// Values indicate the vSAN storage types that the disk is compatible with.
19944///
19945/// Possible values:
19946/// - `diskGroup`: represent disk group for regular vSAN.
19947/// - `singleTier`: represent vSAN ESA storage pool.
19948/// - `VsanDiskCompatibilityType_Unknown`: represent the value when the lower version client cannot recognize the enum value.
19949#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
19950pub enum VsanDiskCompatibilityTypeEnum {
19951 #[serde(rename = "diskGroup")]
19952 #[strum(serialize = "diskGroup")]
19953 DiskGroup,
19954 #[serde(rename = "singleTier")]
19955 #[strum(serialize = "singleTier")]
19956 SingleTier,
19957 #[serde(rename = "VsanDiskCompatibilityType_Unknown")]
19958 #[strum(serialize = "VsanDiskCompatibilityType_Unknown")]
19959 VsanDiskCompatibilityTypeUnknown,
19960 /// This variant handles values not known at compile time.
19961 #[serde(untagged)]
19962 #[strum(serialize = "__OTHER__")]
19963 Other_(String),
19964}
19965/// The total amount of health checks is split into multiple different
19966/// perspectives.
19967///
19968/// This list defines sets labels for sets of health checks
19969/// in 8.x and previous releases.
19970///
19971/// Possible values:
19972/// - `defaultView`: The default set, core "health checks".
19973/// - `deployAssist`: Health checks to aid the user in configuring all aspects of vSphere required for production vSAN clusters, including vDS, DRS, HA, etc.
19974///
19975/// The checks represent best practices, and so ignoring failures is generally acceptable.
19976/// - `CreateExtendClusterView`: Health checks during creating/extending vSAN cluster which only include HCL check.
19977/// - `beforeConfigureHost`: Health checks before configuring host which includes the advanced config option consistent check, software version compatibility check, HCL check, etc.
19978/// - `upgradePreCheck`: Health checks before upgrade which includes some tests from HCL, network and physical disks checks.
19979/// - `vsanUpgradePreCheck`: Health checks before vsan upgrade which includes some tests from HCL, network and physical disks checks.
19980/// - `upgradeBeforeExitMM`: Health checks before exiting maintenance mode during upgrading which includes HCL, network and physical disk checks.
19981/// - `upgradeAfterExitMM`: Health checks after exiting maintenance mode during upgrading which includes HCL, network and physical disk checks.
19982/// - `vsanUpgradeBeforeExitMM`: Health checks before exiting maintenance mode during performing vSAN recommended upgrade which includes some tests in HCL, network and physical disk checks.
19983/// - `vsanUpgradeAfterExitMM`: Health checks after exiting maintenance mode during performing vSAN recommended upgrade which includes some tests in HCL, network and physical disk checks.
19984/// - `vmcUpgradePreChecks`: Health checks during POD upgrade
19985/// - `upgradePreCheckPman`
19986/// - `upgradeBeforeExitMMPman`
19987/// - `upgradeAfterExitMMPman`
19988/// - `inPlaceUpgradeServiceMode`
19989/// - `upgradePreCheckPmanForVMC`
19990/// - `upgradeBeforeExitMMPmanForVMC`
19991/// - `upgradeAfterExitMMPmanForVMC`
19992/// - `clusterPowerOffPrecheck`
19993/// - `VsanEsaPreChecks`
19994/// - `vcsaInstallerForVsanEsa`
19995/// - `upgradePreCheckForVCF`
19996/// - `VsanHealthPerspective_Unknown`
19997#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
19998pub enum VsanHealthPerspectiveEnum {
19999 #[serde(rename = "defaultView")]
20000 #[strum(serialize = "defaultView")]
20001 DefaultView,
20002 #[serde(rename = "deployAssist")]
20003 #[strum(serialize = "deployAssist")]
20004 DeployAssist,
20005 CreateExtendClusterView,
20006 #[serde(rename = "beforeConfigureHost")]
20007 #[strum(serialize = "beforeConfigureHost")]
20008 BeforeConfigureHost,
20009 #[serde(rename = "upgradePreCheck")]
20010 #[strum(serialize = "upgradePreCheck")]
20011 UpgradePreCheck,
20012 #[serde(rename = "vsanUpgradePreCheck")]
20013 #[strum(serialize = "vsanUpgradePreCheck")]
20014 VsanUpgradePreCheck,
20015 #[serde(rename = "upgradeBeforeExitMM")]
20016 #[strum(serialize = "upgradeBeforeExitMM")]
20017 UpgradeBeforeExitMm,
20018 #[serde(rename = "upgradeAfterExitMM")]
20019 #[strum(serialize = "upgradeAfterExitMM")]
20020 UpgradeAfterExitMm,
20021 #[serde(rename = "vsanUpgradeBeforeExitMM")]
20022 #[strum(serialize = "vsanUpgradeBeforeExitMM")]
20023 VsanUpgradeBeforeExitMm,
20024 #[serde(rename = "vsanUpgradeAfterExitMM")]
20025 #[strum(serialize = "vsanUpgradeAfterExitMM")]
20026 VsanUpgradeAfterExitMm,
20027 #[serde(rename = "vmcUpgradePreChecks")]
20028 #[strum(serialize = "vmcUpgradePreChecks")]
20029 VmcUpgradePreChecks,
20030 #[serde(rename = "upgradePreCheckPman")]
20031 #[strum(serialize = "upgradePreCheckPman")]
20032 UpgradePreCheckPman,
20033 #[serde(rename = "upgradeBeforeExitMMPman")]
20034 #[strum(serialize = "upgradeBeforeExitMMPman")]
20035 UpgradeBeforeExitMmPman,
20036 #[serde(rename = "upgradeAfterExitMMPman")]
20037 #[strum(serialize = "upgradeAfterExitMMPman")]
20038 UpgradeAfterExitMmPman,
20039 #[serde(rename = "inPlaceUpgradeServiceMode")]
20040 #[strum(serialize = "inPlaceUpgradeServiceMode")]
20041 InPlaceUpgradeServiceMode,
20042 #[serde(rename = "upgradePreCheckPmanForVMC")]
20043 #[strum(serialize = "upgradePreCheckPmanForVMC")]
20044 UpgradePreCheckPmanForVmc,
20045 #[serde(rename = "upgradeBeforeExitMMPmanForVMC")]
20046 #[strum(serialize = "upgradeBeforeExitMMPmanForVMC")]
20047 UpgradeBeforeExitMmPmanForVmc,
20048 #[serde(rename = "upgradeAfterExitMMPmanForVMC")]
20049 #[strum(serialize = "upgradeAfterExitMMPmanForVMC")]
20050 UpgradeAfterExitMmPmanForVmc,
20051 #[serde(rename = "clusterPowerOffPrecheck")]
20052 #[strum(serialize = "clusterPowerOffPrecheck")]
20053 ClusterPowerOffPrecheck,
20054 VsanEsaPreChecks,
20055 #[serde(rename = "vcsaInstallerForVsanEsa")]
20056 #[strum(serialize = "vcsaInstallerForVsanEsa")]
20057 VcsaInstallerForVsanEsa,
20058 #[serde(rename = "upgradePreCheckForVCF")]
20059 #[strum(serialize = "upgradePreCheckForVCF")]
20060 UpgradePreCheckForVcf,
20061 #[serde(rename = "VsanHealthPerspective_Unknown")]
20062 #[strum(serialize = "VsanHealthPerspective_Unknown")]
20063 VsanHealthPerspectiveUnknown,
20064 /// This variant handles values not known at compile time.
20065 #[serde(untagged)]
20066 #[strum(serialize = "__OTHER__")]
20067 Other_(String),
20068}
20069/// This list defines sets labels of multiple different perspectives
20070/// for sets of health checks in 9.0 release.
20071///
20072/// Possible values:
20073/// - `siteEnterMaintenance`
20074#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20075pub enum VsanHealthPerspective90Enum {
20076 #[serde(rename = "siteEnterMaintenance")]
20077 #[strum(serialize = "siteEnterMaintenance")]
20078 SiteEnterMaintenance,
20079 /// This variant handles values not known at compile time.
20080 #[serde(untagged)]
20081 #[strum(serialize = "__OTHER__")]
20082 Other_(String),
20083}
20084/// Defines health status states applicable to various vSAN system entities.
20085///
20086/// An entity in vSAN health system can have one of the following state.
20087/// Each state represent the health status of entity in terms of vSAN health
20088/// perspective.
20089/// Each system can define its notion of each health status. For example, status
20090/// 'red' for capacity means cluster is running very close to datastore full but
20091/// status 'red' for for an object mean it is already 'inaccessible'.
20092///
20093/// Possible values:
20094/// - `unknown`: Health status in not known for the entity.
20095///
20096/// This might imply that : 1. Underlying entity do not support the mechanism to calculate the health status. 2. Status is not yet calculated.
20097/// - `yellow`: Shows a warning status for the entity.
20098///
20099/// 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.
20100/// - `red`: Shows an alert for the system.
20101///
20102/// This might imply that: 1. Entity is currently running in error state. 2. Potentially harm the cluster status is not fixed soon.
20103/// - `green`: Shows entity is in healthy state and no issues found.
20104#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20105pub enum VsanHealthStatusTypeEnum {
20106 #[serde(rename = "unknown")]
20107 #[strum(serialize = "unknown")]
20108 Unknown,
20109 #[serde(rename = "yellow")]
20110 #[strum(serialize = "yellow")]
20111 Yellow,
20112 #[serde(rename = "red")]
20113 #[strum(serialize = "red")]
20114 Red,
20115 #[serde(rename = "green")]
20116 #[strum(serialize = "green")]
20117 Green,
20118 /// This variant handles values not known at compile time.
20119 #[serde(untagged)]
20120 #[strum(serialize = "__OTHER__")]
20121 Other_(String),
20122}
20123/// The vSAN threshold target type.
20124///
20125/// it is used in
20126/// *VsanHealthThreshold*, to indicate the thresholds are applied
20127/// on which target. A target could be a part of one health check, or just one
20128/// entire health check.
20129/// For below targets, a valid threshold should be a percentage, e.g., an
20130/// integer value which is in range \[0, 100\].
20131///
20132/// Possible values:
20133/// - `diskspace_vsan_datastore`: The vSAN datastore part of "Disk space"
20134/// - `diskspace_vsan_direct`: The vSAN direct part of "Disk space"
20135/// - `diskspace_vsan_pmem`
20136/// - `VsanHealthThresholdTarget_Unknown`
20137#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20138pub enum VsanHealthThresholdTargetEnum {
20139 #[serde(rename = "diskspace_vsan_datastore")]
20140 #[strum(serialize = "diskspace_vsan_datastore")]
20141 DiskspaceVsanDatastore,
20142 #[serde(rename = "diskspace_vsan_direct")]
20143 #[strum(serialize = "diskspace_vsan_direct")]
20144 DiskspaceVsanDirect,
20145 #[serde(rename = "diskspace_vsan_pmem")]
20146 #[strum(serialize = "diskspace_vsan_pmem")]
20147 DiskspaceVsanPmem,
20148 #[serde(rename = "VsanHealthThresholdTarget_Unknown")]
20149 #[strum(serialize = "VsanHealthThresholdTarget_Unknown")]
20150 VsanHealthThresholdTargetUnknown,
20151 /// This variant handles values not known at compile time.
20152 #[serde(untagged)]
20153 #[strum(serialize = "__OTHER__")]
20154 Other_(String),
20155}
20156/// The vSAN IO trip analyzer scheduler recurrence status type.
20157///
20158/// Possible values:
20159/// - `recurrenceEnabled`: The scheduler recurrence is enabled.
20160///
20161/// Tasks will be triggered based on the settings.
20162/// - `recurrenceDisabled`: The scheduler recurrence is disabled.
20163///
20164/// No task will be triggered.
20165/// - `VsanIOTripAnalyzerRecurrenceStatus_Unknown`
20166#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20167pub enum VsanIoTripAnalyzerRecurrenceStatusEnum {
20168 #[serde(rename = "recurrenceEnabled")]
20169 #[strum(serialize = "recurrenceEnabled")]
20170 RecurrenceEnabled,
20171 #[serde(rename = "recurrenceDisabled")]
20172 #[strum(serialize = "recurrenceDisabled")]
20173 RecurrenceDisabled,
20174 #[serde(rename = "VsanIOTripAnalyzerRecurrenceStatus_Unknown")]
20175 #[strum(serialize = "VsanIOTripAnalyzerRecurrenceStatus_Unknown")]
20176 VsanIoTripAnalyzerRecurrenceStatusUnknown,
20177 /// This variant handles values not known at compile time.
20178 #[serde(untagged)]
20179 #[strum(serialize = "__OTHER__")]
20180 Other_(String),
20181}
20182/// vSAN policy regulation check operators.
20183///
20184/// Possible values:
20185/// - `equal`: Equals to.
20186/// - `greater`: Greater than.
20187/// - `nogreater`: No greater than.
20188/// - `less`: Less than.
20189/// - `noless`: No less than.
20190#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20191pub enum VsanPolicyRegulationCheckOpEnumEnum {
20192 #[serde(rename = "equal")]
20193 #[strum(serialize = "equal")]
20194 Equal,
20195 #[serde(rename = "greater")]
20196 #[strum(serialize = "greater")]
20197 Greater,
20198 #[serde(rename = "nogreater")]
20199 #[strum(serialize = "nogreater")]
20200 Nogreater,
20201 #[serde(rename = "less")]
20202 #[strum(serialize = "less")]
20203 Less,
20204 #[serde(rename = "noless")]
20205 #[strum(serialize = "noless")]
20206 Noless,
20207 /// This variant handles values not known at compile time.
20208 #[serde(untagged)]
20209 #[strum(serialize = "__OTHER__")]
20210 Other_(String),
20211}
20212/// The Issue Type:
20213/// BROKEN\_CHAIN - The object is part of a snapshot chain that can't be
20214/// opened
20215/// LEAKED\_OBJECT - The object has no descriptor file
20216/// UNKNOWN - An unknown issue was detected trying to identify this object
20217///
20218/// Possible values:
20219/// - `BROKEN_CHAIN`
20220/// - `LEAKED_OBJECT`
20221/// - `UNKNOWN`
20222#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20223pub enum VimVsanVsanScanObjectsIssueTypeEnum {
20224 #[serde(rename = "BROKEN_CHAIN")]
20225 #[strum(serialize = "BROKEN_CHAIN")]
20226 BrokenChain,
20227 #[serde(rename = "LEAKED_OBJECT")]
20228 #[strum(serialize = "LEAKED_OBJECT")]
20229 LeakedObject,
20230 #[serde(rename = "UNKNOWN")]
20231 #[strum(serialize = "UNKNOWN")]
20232 Unknown,
20233 /// This variant handles values not known at compile time.
20234 #[serde(untagged)]
20235 #[strum(serialize = "__OTHER__")]
20236 Other_(String),
20237}
20238/// Defines the status of vSAN service.
20239///
20240/// Possible values:
20241/// - `started`: Stands for vSAN service is started.
20242/// - `stopped`: Stands for vSAN service is stopped.
20243/// - `VsanServiceStatus_Unknown`
20244#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20245pub enum VsanServiceStatusEnum {
20246 #[serde(rename = "started")]
20247 #[strum(serialize = "started")]
20248 Started,
20249 #[serde(rename = "stopped")]
20250 #[strum(serialize = "stopped")]
20251 Stopped,
20252 #[serde(rename = "VsanServiceStatus_Unknown")]
20253 #[strum(serialize = "VsanServiceStatus_Unknown")]
20254 VsanServiceStatusUnknown,
20255 /// This variant handles values not known at compile time.
20256 #[serde(untagged)]
20257 #[strum(serialize = "__OTHER__")]
20258 Other_(String),
20259}
20260/// Defines vSAN site location type.
20261///
20262/// Possible values:
20263/// - `None`: No specific site location in stretched cluster.
20264/// - `Preferred`: Identify the preferred site in stretched cluster.
20265/// - `NonPreferred`: Identify the non-preferred site of stretched cluster.
20266/// - `VsanSiteLocationType_Unknown`: represent the value when the lower version client cannot recognize the enum value
20267#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20268pub enum VsanSiteLocationTypeEnum {
20269 None,
20270 Preferred,
20271 NonPreferred,
20272 #[serde(rename = "VsanSiteLocationType_Unknown")]
20273 #[strum(serialize = "VsanSiteLocationType_Unknown")]
20274 VsanSiteLocationTypeUnknown,
20275 /// This variant handles values not known at compile time.
20276 #[serde(untagged)]
20277 #[strum(serialize = "__OTHER__")]
20278 Other_(String),
20279}
20280/// It's used to declare the health types of the received stats from the
20281/// vSAN SnapService Appliance.
20282///
20283/// Possible values:
20284/// - `applianceHealth`: represent the health stats of the data protection appliance.
20285/// - `pgSnapshotsHealth`: represent the snapshot health stats of the protection groups.
20286/// - `vmSnapshotsHealth`: represent the snapshot health stats of the virtual machines.
20287/// - `vmMembershipChanges`: represent the stats of VM membership changes.
20288/// - `VsanSnapHealthType_Unknown`: represent the value when the lower version client cannot recognize the enum value.
20289#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20290pub enum VsanSnapHealthTypeEnum {
20291 #[serde(rename = "applianceHealth")]
20292 #[strum(serialize = "applianceHealth")]
20293 ApplianceHealth,
20294 #[serde(rename = "pgSnapshotsHealth")]
20295 #[strum(serialize = "pgSnapshotsHealth")]
20296 PgSnapshotsHealth,
20297 #[serde(rename = "vmSnapshotsHealth")]
20298 #[strum(serialize = "vmSnapshotsHealth")]
20299 VmSnapshotsHealth,
20300 #[serde(rename = "vmMembershipChanges")]
20301 #[strum(serialize = "vmMembershipChanges")]
20302 VmMembershipChanges,
20303 #[serde(rename = "VsanSnapHealthType_Unknown")]
20304 #[strum(serialize = "VsanSnapHealthType_Unknown")]
20305 VsanSnapHealthTypeUnknown,
20306 /// This variant handles values not known at compile time.
20307 #[serde(untagged)]
20308 #[strum(serialize = "__OTHER__")]
20309 Other_(String),
20310}
20311/// It's used to declare the expiration types of the received stats from the
20312/// vSAN SnapService Appliance.
20313///
20314/// Possible values:
20315/// - `afterSet`: represent the stats will expire once the new value has been set.
20316/// - `afterGet`: represent the stats will expire once it has been queried.
20317/// - `afterTtl`: represent the stats will expire after a specific TTL.
20318/// - `never`: represent the stats will never expire.
20319/// - `VsanSnapStatsExpirationType_Unknown`: represent the value when the lower version client cannot recognize the enum value.
20320#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20321pub enum VsanSnapStatsExpirationTypeEnum {
20322 #[serde(rename = "afterSet")]
20323 #[strum(serialize = "afterSet")]
20324 AfterSet,
20325 #[serde(rename = "afterGet")]
20326 #[strum(serialize = "afterGet")]
20327 AfterGet,
20328 #[serde(rename = "afterTtl")]
20329 #[strum(serialize = "afterTtl")]
20330 AfterTtl,
20331 #[serde(rename = "never")]
20332 #[strum(serialize = "never")]
20333 Never,
20334 #[serde(rename = "VsanSnapStatsExpirationType_Unknown")]
20335 #[strum(serialize = "VsanSnapStatsExpirationType_Unknown")]
20336 VsanSnapStatsExpirationTypeUnknown,
20337 /// This variant handles values not known at compile time.
20338 #[serde(untagged)]
20339 #[strum(serialize = "__OTHER__")]
20340 Other_(String),
20341}
20342/// It's used to declare the virtual machine membership change status.
20343///
20344/// Possible values:
20345/// - `added`: represent the virtual machine is newly added to the protection group.
20346/// - `removed`: represent the virtual machine has been removed from the protection group.
20347/// - `VsanSnapVmMembershipChangeStatus_Unknown`: represent the value when the lower version client cannot recognize the enum value.
20348#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20349pub enum VsanSnapVmMembershipChangeStatusEnum {
20350 #[serde(rename = "added")]
20351 #[strum(serialize = "added")]
20352 Added,
20353 #[serde(rename = "removed")]
20354 #[strum(serialize = "removed")]
20355 Removed,
20356 #[serde(rename = "VsanSnapVmMembershipChangeStatus_Unknown")]
20357 #[strum(serialize = "VsanSnapVmMembershipChangeStatus_Unknown")]
20358 VsanSnapVmMembershipChangeStatusUnknown,
20359 /// This variant handles values not known at compile time.
20360 #[serde(untagged)]
20361 #[strum(serialize = "__OTHER__")]
20362 Other_(String),
20363}
20364/// The reasons why a vSAN component went into syncing state.
20365///
20366/// Possible values:
20367/// - `repair`: The component is created and resyncing to repair a bad component.
20368/// - `evacuate`: The component is created and resyncing after evacuate disk group or host to ensure accessibility and full data evacuation.
20369/// - `rebalance`: The component is created and resyncing for rebalancing.
20370/// - `reconfigure`: The component is created and resyncing after vSAN object was resized or its policy was changed.
20371/// - `dying_evacuate`: The component is being moved out when a disk is going to die.
20372/// - `stale`: The component is syncing because it was stale.
20373/// - `merge_concat`: The component is created and resyncing to merge concatenations.
20374/// - `object_format_change`
20375/// - `VsanSyncReason_Unknown`
20376#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20377pub enum VsanSyncReasonEnum {
20378 #[serde(rename = "repair")]
20379 #[strum(serialize = "repair")]
20380 Repair,
20381 #[serde(rename = "evacuate")]
20382 #[strum(serialize = "evacuate")]
20383 Evacuate,
20384 #[serde(rename = "rebalance")]
20385 #[strum(serialize = "rebalance")]
20386 Rebalance,
20387 #[serde(rename = "reconfigure")]
20388 #[strum(serialize = "reconfigure")]
20389 Reconfigure,
20390 #[serde(rename = "dying_evacuate")]
20391 #[strum(serialize = "dying_evacuate")]
20392 DyingEvacuate,
20393 #[serde(rename = "stale")]
20394 #[strum(serialize = "stale")]
20395 Stale,
20396 #[serde(rename = "merge_concat")]
20397 #[strum(serialize = "merge_concat")]
20398 MergeConcat,
20399 #[serde(rename = "object_format_change")]
20400 #[strum(serialize = "object_format_change")]
20401 ObjectFormatChange,
20402 #[serde(rename = "VsanSyncReason_Unknown")]
20403 #[strum(serialize = "VsanSyncReason_Unknown")]
20404 VsanSyncReasonUnknown,
20405 /// This variant handles values not known at compile time.
20406 #[serde(untagged)]
20407 #[strum(serialize = "__OTHER__")]
20408 Other_(String),
20409}
20410/// The status of syncing vSAN component.
20411///
20412/// Components which need recovery
20413/// can be in one of the three status.
20414///
20415/// Possible values:
20416/// - `active`: The component which is actively syncing.
20417/// - `queued`: The component which is in queue for sync to start.
20418///
20419/// Status change from queue to active could be due to reasons like availability of space in the cluster.
20420/// - `suspended`: The component which is in suspended state.
20421///
20422/// 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.
20423/// - `VsanSyncStatus_Unknown`
20424#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20425pub enum VsanSyncStatusEnum {
20426 #[serde(rename = "active")]
20427 #[strum(serialize = "active")]
20428 Active,
20429 #[serde(rename = "queued")]
20430 #[strum(serialize = "queued")]
20431 Queued,
20432 #[serde(rename = "suspended")]
20433 #[strum(serialize = "suspended")]
20434 Suspended,
20435 #[serde(rename = "VsanSyncStatus_Unknown")]
20436 #[strum(serialize = "VsanSyncStatus_Unknown")]
20437 VsanSyncStatusUnknown,
20438 /// This variant handles values not known at compile time.
20439 #[serde(untagged)]
20440 #[strum(serialize = "__OTHER__")]
20441 Other_(String),
20442}
20443/// Lists the impact on the node after applying update item.
20444///
20445/// Possible values:
20446/// - `reboot`: Host needs a reboot for this updateItem which also implies that it will enter maintenance mode before a reboot.
20447/// - `VsanUpdateItemImpactType_Unknown`
20448#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20449pub enum VsanUpdateItemImpactTypeEnum {
20450 #[serde(rename = "reboot")]
20451 #[strum(serialize = "reboot")]
20452 Reboot,
20453 #[serde(rename = "VsanUpdateItemImpactType_Unknown")]
20454 #[strum(serialize = "VsanUpdateItemImpactType_Unknown")]
20455 VsanUpdateItemImpactTypeUnknown,
20456 /// This variant handles values not known at compile time.
20457 #[serde(untagged)]
20458 #[strum(serialize = "__OTHER__")]
20459 Other_(String),
20460}
20461/// Type of VsanUpdateItem.
20462///
20463/// Possible values:
20464/// - `vib`: A ESX VIB.
20465/// - `offlinebundle`: A ESX Offline Bundle containing ESXi VIB(s).
20466/// - `vmhbaFirmware`: Firmware of a SCSI/RAID controller.
20467/// - `fullStackFirmware`: (Deprecated since vSphere 8.0) Firmware of various components on host.
20468/// - `VsanUpdateItemType_Unknown`
20469#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20470pub enum VsanUpdateItemTypeEnum {
20471 #[serde(rename = "vib")]
20472 #[strum(serialize = "vib")]
20473 Vib,
20474 #[serde(rename = "offlinebundle")]
20475 #[strum(serialize = "offlinebundle")]
20476 Offlinebundle,
20477 #[serde(rename = "vmhbaFirmware")]
20478 #[strum(serialize = "vmhbaFirmware")]
20479 VmhbaFirmware,
20480 #[serde(rename = "fullStackFirmware")]
20481 #[strum(serialize = "fullStackFirmware")]
20482 FullStackFirmware,
20483 #[serde(rename = "VsanUpdateItemType_Unknown")]
20484 #[strum(serialize = "VsanUpdateItemType_Unknown")]
20485 VsanUpdateItemTypeUnknown,
20486 /// This variant handles values not known at compile time.
20487 #[serde(untagged)]
20488 #[strum(serialize = "__OTHER__")]
20489 Other_(String),
20490}
20491/// Phase of deployment.
20492///
20493/// Possible values:
20494/// - `initializing`: Deployment just started.
20495/// - `validation`: Deployment spec is being validated.
20496/// - `vsanbootstrap`: 1-Node vSAN cluster is being created.
20497/// - `ovaunpack`: VCSA OVA is being verified and unpacked.
20498/// - `vcsadeploy`: VCSA is being deployed (booted and configured).
20499/// - `vcconfig`: Post-install configuration of vCenter, like creation of datacenter, cluster objects and configuration of DRS, HA, vSAN and other features.
20500/// - `done`: deployment completed successfully.
20501/// - `failed`: Deployment failed.
20502/// - `VsanVcsaDeploymentPhase_Unknown`
20503#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20504pub enum VimVsanVsanVcsaDeploymentPhaseEnum {
20505 #[serde(rename = "initializing")]
20506 #[strum(serialize = "initializing")]
20507 Initializing,
20508 #[serde(rename = "validation")]
20509 #[strum(serialize = "validation")]
20510 Validation,
20511 #[serde(rename = "vsanbootstrap")]
20512 #[strum(serialize = "vsanbootstrap")]
20513 Vsanbootstrap,
20514 #[serde(rename = "ovaunpack")]
20515 #[strum(serialize = "ovaunpack")]
20516 Ovaunpack,
20517 #[serde(rename = "vcsadeploy")]
20518 #[strum(serialize = "vcsadeploy")]
20519 Vcsadeploy,
20520 #[serde(rename = "vcconfig")]
20521 #[strum(serialize = "vcconfig")]
20522 Vcconfig,
20523 #[serde(rename = "done")]
20524 #[strum(serialize = "done")]
20525 Done,
20526 #[serde(rename = "failed")]
20527 #[strum(serialize = "failed")]
20528 Failed,
20529 #[serde(rename = "VsanVcsaDeploymentPhase_Unknown")]
20530 #[strum(serialize = "VsanVcsaDeploymentPhase_Unknown")]
20531 VsanVcsaDeploymentPhaseUnknown,
20532 /// This variant handles values not known at compile time.
20533 #[serde(untagged)]
20534 #[strum(serialize = "__OTHER__")]
20535 Other_(String),
20536}
20537/// Type of VsanVibSpec.
20538///
20539/// Possible values:
20540/// - `tool`: A management tool.
20541/// - `driver`: A management driver.
20542/// - `VsanVibType_Unknown`
20543#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20544pub enum VsanVibTypeEnum {
20545 #[serde(rename = "tool")]
20546 #[strum(serialize = "tool")]
20547 Tool,
20548 #[serde(rename = "driver")]
20549 #[strum(serialize = "driver")]
20550 Driver,
20551 #[serde(rename = "VsanVibType_Unknown")]
20552 #[strum(serialize = "VsanVibType_Unknown")]
20553 VsanVibTypeUnknown,
20554 /// This variant handles values not known at compile time.
20555 #[serde(untagged)]
20556 #[strum(serialize = "__OTHER__")]
20557 Other_(String),
20558}
20559/// Defines the possible operators to use when comparing the values of
20560/// individual property.
20561///
20562/// Possible values:
20563/// - `Equal`: Equality operator.
20564/// - `NotEqual`: Inequality operator.
20565/// - `Greater`: Greater than operator.
20566/// - `GreaterOrEqual`: Greater than or equal to operator.
20567/// - `Less`: Less than operator.
20568/// - `LessOrEqual`: Less than or equal to operator.
20569/// - `In`: Checks for equality with at least one of a list of values.
20570/// - `NotIn`: Checks for inequality with all values in a list.
20571/// - `Like`: Pattern matching operator applicable to string properties.
20572/// - `NotLike`: Opposite of operator Like.
20573/// - `Unset`: Used in conjunction with comparableValue to see if a property is set or not.
20574/// - `VsanXvcQueryCriteriaOperator_unknown`: Unknown operation type.
20575#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20576pub enum VsanXvcQueryCriteriaOperatorEnum {
20577 Equal,
20578 NotEqual,
20579 Greater,
20580 GreaterOrEqual,
20581 Less,
20582 LessOrEqual,
20583 In,
20584 NotIn,
20585 Like,
20586 NotLike,
20587 Unset,
20588 #[serde(rename = "VsanXvcQueryCriteriaOperator_unknown")]
20589 #[strum(serialize = "VsanXvcQueryCriteriaOperator_unknown")]
20590 VsanXvcQueryCriteriaOperatorUnknown,
20591 /// This variant handles values not known at compile time.
20592 #[serde(untagged)]
20593 #[strum(serialize = "__OTHER__")]
20594 Other_(String),
20595}
20596/// Defines operator types for query filter.
20597///
20598/// Possible values:
20599/// - `And`: The operator is evaluated to true only if all its operands are true.
20600/// - `Or`: The operator is evaluated to true if at least one of its operands is true.
20601/// - `Op_unknown`: Unknown operator.
20602#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20603pub enum VsanXvcQueryFilterOperatorEnum {
20604 And,
20605 Or,
20606 #[serde(rename = "Op_unknown")]
20607 #[strum(serialize = "Op_unknown")]
20608 OpUnknown,
20609 /// This variant handles values not known at compile time.
20610 #[serde(untagged)]
20611 #[strum(serialize = "__OTHER__")]
20612 Other_(String),
20613}
20614/// Defines the type of status for the Compliance Resource Check Query.
20615///
20616/// The status is one of the four inProgress/aborted/completed/uninitialized.
20617///
20618/// Possible values:
20619/// - `inProgress`: The Compliance Resource Check Query task is in progress.
20620/// - `aborted`: The Compliance Resource Check Query task is aborted due to some error etc.
20621/// - `completed`: The Compliance Resource Check Query is completed and data can be fetchd.
20622/// - `uninitialized`: The Compliance Resource Check Query is never called and the result cannot be get.
20623/// - `ComplianceResourceCheckStatusType_Unknown`
20624#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20625pub enum VimVsanClusterComplianceResourceCheckStatusTypeEnum {
20626 #[serde(rename = "inProgress")]
20627 #[strum(serialize = "inProgress")]
20628 InProgress,
20629 #[serde(rename = "aborted")]
20630 #[strum(serialize = "aborted")]
20631 Aborted,
20632 #[serde(rename = "completed")]
20633 #[strum(serialize = "completed")]
20634 Completed,
20635 #[serde(rename = "uninitialized")]
20636 #[strum(serialize = "uninitialized")]
20637 Uninitialized,
20638 #[serde(rename = "ComplianceResourceCheckStatusType_Unknown")]
20639 #[strum(serialize = "ComplianceResourceCheckStatusType_Unknown")]
20640 ComplianceResourceCheckStatusTypeUnknown,
20641 /// This variant handles values not known at compile time.
20642 #[serde(untagged)]
20643 #[strum(serialize = "__OTHER__")]
20644 Other_(String),
20645}
20646/// vSAN managed storage types.
20647///
20648/// Possible values:
20649/// - `vsandirect`: Represents vSAN direct datastore managed by vSAN
20650/// - `pmem`:
20651///
20652/// Deprecated as of vSphere 9.0 APIs with no replacement.
20653///
20654/// Represents PMem datastore managed by vSAN.
20655/// - `VsanManagedStorageType_Unknown`
20656#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20657pub enum VimVsanClusterVsanManagedStorageTypeEnum {
20658 #[serde(rename = "vsandirect")]
20659 #[strum(serialize = "vsandirect")]
20660 Vsandirect,
20661 #[serde(rename = "pmem")]
20662 #[strum(serialize = "pmem")]
20663 Pmem,
20664 #[serde(rename = "VsanManagedStorageType_Unknown")]
20665 #[strum(serialize = "VsanManagedStorageType_Unknown")]
20666 VsanManagedStorageTypeUnknown,
20667 /// This variant handles values not known at compile time.
20668 #[serde(untagged)]
20669 #[strum(serialize = "__OTHER__")]
20670 Other_(String),
20671}
20672/// Defines the high level cluster power state..
20673///
20674/// Possible values:
20675/// - `poweredOn`: indicates the cluster is powered on.
20676/// - `poweredOff`: indicates the cluster is powered off.
20677/// - `poweringOn`: indicates the cluster is in the progress of powering on.
20678/// - `poweringOff`: indicates the cluster is in the progress of powering off.
20679/// - `ClusterPowerState_Unknown`: represent the value when the lower version client cannot recognize the enum value.
20680#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20681pub enum ClusterPowerStateEnum {
20682 #[serde(rename = "poweredOn")]
20683 #[strum(serialize = "poweredOn")]
20684 PoweredOn,
20685 #[serde(rename = "poweredOff")]
20686 #[strum(serialize = "poweredOff")]
20687 PoweredOff,
20688 #[serde(rename = "poweringOn")]
20689 #[strum(serialize = "poweringOn")]
20690 PoweringOn,
20691 #[serde(rename = "poweringOff")]
20692 #[strum(serialize = "poweringOff")]
20693 PoweringOff,
20694 #[serde(rename = "ClusterPowerState_Unknown")]
20695 #[strum(serialize = "ClusterPowerState_Unknown")]
20696 ClusterPowerStateUnknown,
20697 /// This variant handles values not known at compile time.
20698 #[serde(untagged)]
20699 #[strum(serialize = "__OTHER__")]
20700 Other_(String),
20701}
20702/// Defines the set of status values for compliance operations.
20703///
20704/// Possible values:
20705/// - `compliant`: Entity is compliant.
20706/// - `nonCompliant`: Entity is not compliant.
20707/// - `unknown`: Compliance status of the entity is unknown.
20708/// - `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.
20709/// - `outOfDate`: Compliance status of the entity is out of date when the policy associated with the entity is edited and not applied.
20710///
20711/// The compliance status will remain in out-of-date status until the latest policy is applied to the entity.
20712/// - `ComplianceStatus_Unknown`: Represent the value when the lower version client cannot recognize the enum value.
20713#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20714pub enum VsanComplianceStatusEnum {
20715 #[serde(rename = "compliant")]
20716 #[strum(serialize = "compliant")]
20717 Compliant,
20718 #[serde(rename = "nonCompliant")]
20719 #[strum(serialize = "nonCompliant")]
20720 NonCompliant,
20721 #[serde(rename = "unknown")]
20722 #[strum(serialize = "unknown")]
20723 Unknown,
20724 #[serde(rename = "notApplicable")]
20725 #[strum(serialize = "notApplicable")]
20726 NotApplicable,
20727 #[serde(rename = "outOfDate")]
20728 #[strum(serialize = "outOfDate")]
20729 OutOfDate,
20730 #[serde(rename = "ComplianceStatus_Unknown")]
20731 #[strum(serialize = "ComplianceStatus_Unknown")]
20732 ComplianceStatusUnknown,
20733 /// This variant handles values not known at compile time.
20734 #[serde(untagged)]
20735 #[strum(serialize = "__OTHER__")]
20736 Other_(String),
20737}
20738/// The action to take with regard to storage objects upon decommissioning
20739/// a host from use with the VSAN service.
20740///
20741/// Possible values:
20742/// - `noAction`: No special action should take place regarding VSAN data.
20743/// - `ensureObjectAccessibility`: VSAN data reconfiguration should be performed to ensure storage
20744/// object accessibility.
20745/// - `evacuateAllData`: VSAN data evacuation should be performed such that all storage
20746/// object data is removed from the host.
20747#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20748pub enum VsanHostDecommissionModeObjectActionEnum {
20749 #[serde(rename = "noAction")]
20750 #[strum(serialize = "noAction")]
20751 NoAction,
20752 #[serde(rename = "ensureObjectAccessibility")]
20753 #[strum(serialize = "ensureObjectAccessibility")]
20754 EnsureObjectAccessibility,
20755 #[serde(rename = "evacuateAllData")]
20756 #[strum(serialize = "evacuateAllData")]
20757 EvacuateAllData,
20758 /// This variant handles values not known at compile time.
20759 #[serde(untagged)]
20760 #[strum(serialize = "__OTHER__")]
20761 Other_(String),
20762}
20763/// Disk group types to create.
20764///
20765/// Possible values:
20766/// - `hybrid`: Consumes SSD as cache tier, and HDD as capacity tier.
20767/// - `allFlash`: Uses SSD for both cache tier and capacity tier.
20768///
20769/// vSAN optimizes the on-disk format on all flash disk group, to support more features, such as deduplication and compression, etc.
20770/// - `vsandirect`
20771/// - `pmem`:
20772///
20773/// Deprecated as of vSphere 9.0 APIs with no replacement.
20774///
20775/// Do not use.
20776/// - `DiskMappingCreationType_Unknown`
20777#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20778pub enum VimVsanHostDiskMappingCreationTypeEnum {
20779 #[serde(rename = "hybrid")]
20780 #[strum(serialize = "hybrid")]
20781 Hybrid,
20782 #[serde(rename = "allFlash")]
20783 #[strum(serialize = "allFlash")]
20784 AllFlash,
20785 #[serde(rename = "vsandirect")]
20786 #[strum(serialize = "vsandirect")]
20787 Vsandirect,
20788 #[serde(rename = "pmem")]
20789 #[strum(serialize = "pmem")]
20790 Pmem,
20791 #[serde(rename = "DiskMappingCreationType_Unknown")]
20792 #[strum(serialize = "DiskMappingCreationType_Unknown")]
20793 DiskMappingCreationTypeUnknown,
20794 /// This variant handles values not known at compile time.
20795 #[serde(untagged)]
20796 #[strum(serialize = "__OTHER__")]
20797 Other_(String),
20798}
20799/// Values used for indicating a disk's status for use by the VSAN service.
20800///
20801/// See also *VsanHostDiskResult.state*.
20802///
20803/// Possible values:
20804/// - `inUse`: Disk is currently in use by the VSAN service.
20805///
20806/// A disk may be considered in use by the VSAN service regardless of
20807/// whether the VSAN service is enabled. As long as a disk is in use
20808/// by VSAN, it is reserved exclusively for VSAN and may not be used
20809/// for other purposes.
20810///
20811/// See also *VsanHostDiskResult.error*.
20812/// - `eligible`: Disk is considered eligible for use by the VSAN service,
20813/// but is not currently in use.
20814/// - `ineligible`: Disk is considered ineligible for use by the VSAN service,
20815/// and is not currently in use.
20816///
20817/// See also *VsanHostDiskResult.error*.
20818#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20819pub enum VsanHostDiskResultStateEnum {
20820 #[serde(rename = "inUse")]
20821 #[strum(serialize = "inUse")]
20822 InUse,
20823 #[serde(rename = "eligible")]
20824 #[strum(serialize = "eligible")]
20825 Eligible,
20826 #[serde(rename = "ineligible")]
20827 #[strum(serialize = "ineligible")]
20828 Ineligible,
20829 /// This variant handles values not known at compile time.
20830 #[serde(untagged)]
20831 #[strum(serialize = "__OTHER__")]
20832 Other_(String),
20833}
20834/// The rekey operation type of vSAN2 encryption.
20835///
20836/// Possible values:
20837/// - `enablement`: Enable encryption.
20838/// - `shallowRekey`: Only replace KEK and keep DEK not changed.
20839/// - `deepRekey`: Replace both KEK and DEK.
20840/// - `disablement`
20841/// - `EncryptionOperation_Unknown`: Represent the value when the lower version client cannot recognize the enum value.
20842#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20843pub enum VsanEncryptionOperationEnum {
20844 #[serde(rename = "enablement")]
20845 #[strum(serialize = "enablement")]
20846 Enablement,
20847 #[serde(rename = "shallowRekey")]
20848 #[strum(serialize = "shallowRekey")]
20849 ShallowRekey,
20850 #[serde(rename = "deepRekey")]
20851 #[strum(serialize = "deepRekey")]
20852 DeepRekey,
20853 #[serde(rename = "disablement")]
20854 #[strum(serialize = "disablement")]
20855 Disablement,
20856 #[serde(rename = "EncryptionOperation_Unknown")]
20857 #[strum(serialize = "EncryptionOperation_Unknown")]
20858 EncryptionOperationUnknown,
20859 /// This variant handles values not known at compile time.
20860 #[serde(untagged)]
20861 #[strum(serialize = "__OTHER__")]
20862 Other_(String),
20863}
20864/// The state of host during data-in-transit encryption configuration
20865/// change for a vSAN cluster.
20866///
20867/// The final configuration whether to
20868/// turn on or turn off encryption for the cluster is defined in
20869/// *VsanHostConfigInfoEx.dataInTransitEncryptionInfo*.
20870///
20871/// Possible values:
20872/// - `settled`: Stable state.
20873///
20874/// Host enforces all sessions to be encrypted or non-encrypted according to the encryption configuration.
20875/// - `preparing`: Host accepts both encrypted and non-encrypted messages.
20876///
20877/// For enable process, host transfers non-encrypted messages; for disable process, host transfers encrypted messages.
20878/// - `prepared`: Host accepts both encrypted and non-encrypted messages.
20879///
20880/// For enable process, host transfers encrypted messages; for disable process, host transfers non-encrypted messages.
20881/// - `EncryptionTransitionState_Unknown`: Represent the value when the lower version client cannot recognize the enum value.
20882#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20883pub enum VsanEncryptionTransitionStateEnum {
20884 #[serde(rename = "settled")]
20885 #[strum(serialize = "settled")]
20886 Settled,
20887 #[serde(rename = "preparing")]
20888 #[strum(serialize = "preparing")]
20889 Preparing,
20890 #[serde(rename = "prepared")]
20891 #[strum(serialize = "prepared")]
20892 Prepared,
20893 #[serde(rename = "EncryptionTransitionState_Unknown")]
20894 #[strum(serialize = "EncryptionTransitionState_Unknown")]
20895 EncryptionTransitionStateUnknown,
20896 /// This variant handles values not known at compile time.
20897 #[serde(untagged)]
20898 #[strum(serialize = "__OTHER__")]
20899 Other_(String),
20900}
20901/// A *VsanHostHealthState_enum* represents the state of a participating
20902/// host in the VSAN service.
20903///
20904/// See also *VsanHostClusterStatus*.
20905///
20906/// Possible values:
20907/// - `unknown`: Node health is unknown.
20908/// - `healthy`: Node is considered healthy.
20909/// - `unhealthy`: Node is considered unhealthy.
20910#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20911pub enum VsanHostHealthStateEnum {
20912 #[serde(rename = "unknown")]
20913 #[strum(serialize = "unknown")]
20914 Unknown,
20915 #[serde(rename = "healthy")]
20916 #[strum(serialize = "healthy")]
20917 Healthy,
20918 #[serde(rename = "unhealthy")]
20919 #[strum(serialize = "unhealthy")]
20920 Unhealthy,
20921 /// This variant handles values not known at compile time.
20922 #[serde(untagged)]
20923 #[strum(serialize = "__OTHER__")]
20924 Other_(String),
20925}
20926/// A *VsanHostNodeState_enum* represents the state of participation of a host
20927/// in the VSAN service.
20928///
20929/// See also *VsanHostClusterStatus*, *VsanHostClusterStatusState*.
20930///
20931/// Possible values:
20932/// - `error`: The node is enabled for the VSAN service but has some configuration
20933/// error which prevents participation.
20934/// - `disabled`: The node is disabled for the VSAN service.
20935/// - `agent`: The node is enabled for the VSAN service and is serving as an agent.
20936/// - `master`: The node is enabled for the VSAN service and is serving as the master.
20937/// - `backup`: The node is enabled for the VSAN service and is serving as the backup.
20938/// - `starting`: The node is starting the VSAN service; this state is considered
20939/// transitory.
20940/// - `stopping`: The node is stopping the VSAN service; this state is considered
20941/// transitory.
20942/// - `enteringMaintenanceMode`: The node is entering maintenance mode; this state is considered
20943/// transitory.
20944///
20945/// See also *HostSystem.EnterMaintenanceMode_Task*.
20946/// - `exitingMaintenanceMode`: The node is exiting maintenance mode; this state is considered
20947/// transitory.
20948///
20949/// See also *HostSystem.ExitMaintenanceMode_Task*.
20950/// - `decommissioning`: The node is being decommissioned from the VSAN service; this state is
20951/// considered transitory.
20952#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
20953pub enum VsanHostNodeStateEnum {
20954 #[serde(rename = "error")]
20955 #[strum(serialize = "error")]
20956 Error,
20957 #[serde(rename = "disabled")]
20958 #[strum(serialize = "disabled")]
20959 Disabled,
20960 #[serde(rename = "agent")]
20961 #[strum(serialize = "agent")]
20962 Agent,
20963 #[serde(rename = "master")]
20964 #[strum(serialize = "master")]
20965 Master,
20966 #[serde(rename = "backup")]
20967 #[strum(serialize = "backup")]
20968 Backup,
20969 #[serde(rename = "starting")]
20970 #[strum(serialize = "starting")]
20971 Starting,
20972 #[serde(rename = "stopping")]
20973 #[strum(serialize = "stopping")]
20974 Stopping,
20975 #[serde(rename = "enteringMaintenanceMode")]
20976 #[strum(serialize = "enteringMaintenanceMode")]
20977 EnteringMaintenanceMode,
20978 #[serde(rename = "exitingMaintenanceMode")]
20979 #[strum(serialize = "exitingMaintenanceMode")]
20980 ExitingMaintenanceMode,
20981 #[serde(rename = "decommissioning")]
20982 #[strum(serialize = "decommissioning")]
20983 Decommissioning,
20984 /// This variant handles values not known at compile time.
20985 #[serde(untagged)]
20986 #[strum(serialize = "__OTHER__")]
20987 Other_(String),
20988}
20989/// Network transmission type of vSAN traffic through
20990/// a virtual network adapter for 8.x and previous releases.
20991///
20992/// Possible values:
20993/// - `vsan`: This vmknic is used for general vSAN data transmission.
20994///
20995/// If no vSAN vmknic configured with 'witness' traffic type, witness data transmission will be handled by vmknic with 'vsan' traffic type.
20996/// - `witness`: This vmknic is dedicated for vSAN witness data transmission.
20997///
20998/// For vSAN stretched cluster, this traffic type is recommended for vSAN vmknics to be used for witness transmission.
20999/// - `TrafficType_Unknown`
21000#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
21001pub enum VimVsanHostTrafficTypeEnum {
21002 #[serde(rename = "vsan")]
21003 #[strum(serialize = "vsan")]
21004 Vsan,
21005 #[serde(rename = "witness")]
21006 #[strum(serialize = "witness")]
21007 Witness,
21008 #[serde(rename = "TrafficType_Unknown")]
21009 #[strum(serialize = "TrafficType_Unknown")]
21010 TrafficTypeUnknown,
21011 /// This variant handles values not known at compile time.
21012 #[serde(untagged)]
21013 #[strum(serialize = "__OTHER__")]
21014 Other_(String),
21015}
21016/// Network transmission type of vSAN traffic through
21017/// a virtual network adapter for 9.0 release
21018///
21019/// Possible values:
21020/// - `vsanExternal`
21021#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
21022pub enum VimVsanHostTrafficType90Enum {
21023 #[serde(rename = "vsanExternal")]
21024 #[strum(serialize = "vsanExternal")]
21025 VsanExternal,
21026 /// This variant handles values not known at compile time.
21027 #[serde(untagged)]
21028 #[strum(serialize = "__OTHER__")]
21029 Other_(String),
21030}
21031/// Remote server node type
21032///
21033/// Possible values:
21034/// - `NodeType_Unknown`: Represent the value when the lower version client cannot recognize the enum value.
21035/// - `REMOTE_NODE`: remote server is a normal data node
21036/// - `REMOTE_WITNESS_NODE`: remote server is a witness node
21037/// - `REMOTE_METADATA_NODE`: remote server is a metadata node
21038#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
21039pub enum ServerNodeTypeEnum {
21040 #[serde(rename = "NodeType_Unknown")]
21041 #[strum(serialize = "NodeType_Unknown")]
21042 NodeTypeUnknown,
21043 #[serde(rename = "REMOTE_NODE")]
21044 #[strum(serialize = "REMOTE_NODE")]
21045 RemoteNode,
21046 #[serde(rename = "REMOTE_WITNESS_NODE")]
21047 #[strum(serialize = "REMOTE_WITNESS_NODE")]
21048 RemoteWitnessNode,
21049 #[serde(rename = "REMOTE_METADATA_NODE")]
21050 #[strum(serialize = "REMOTE_METADATA_NODE")]
21051 RemoteMetadataNode,
21052 /// This variant handles values not known at compile time.
21053 #[serde(untagged)]
21054 #[strum(serialize = "__OTHER__")]
21055 Other_(String),
21056}
21057/// Declaration of all supported vSAN runtime stats types.
21058///
21059/// It is used
21060/// to retrieve vSAN runtime stats through
21061/// *VsanSystemEx.VsanHostGetRuntimeStats*
21062///
21063/// Possible values:
21064/// - `resyncIopsInfo`
21065/// - `configGeneration`
21066/// - `supportedClusterSize`
21067/// - `repairTimerInfo`
21068/// - `componentLimitPerCluster`
21069/// - `maxWitnessClusters`
21070/// - `StatsType_Unknown`
21071#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
21072pub enum VsanHostStatsTypeEnum {
21073 #[serde(rename = "resyncIopsInfo")]
21074 #[strum(serialize = "resyncIopsInfo")]
21075 ResyncIopsInfo,
21076 #[serde(rename = "configGeneration")]
21077 #[strum(serialize = "configGeneration")]
21078 ConfigGeneration,
21079 #[serde(rename = "supportedClusterSize")]
21080 #[strum(serialize = "supportedClusterSize")]
21081 SupportedClusterSize,
21082 #[serde(rename = "repairTimerInfo")]
21083 #[strum(serialize = "repairTimerInfo")]
21084 RepairTimerInfo,
21085 #[serde(rename = "componentLimitPerCluster")]
21086 #[strum(serialize = "componentLimitPerCluster")]
21087 ComponentLimitPerCluster,
21088 #[serde(rename = "maxWitnessClusters")]
21089 #[strum(serialize = "maxWitnessClusters")]
21090 MaxWitnessClusters,
21091 #[serde(rename = "StatsType_Unknown")]
21092 #[strum(serialize = "StatsType_Unknown")]
21093 StatsTypeUnknown,
21094 /// This variant handles values not known at compile time.
21095 #[serde(untagged)]
21096 #[strum(serialize = "__OTHER__")]
21097 Other_(String),
21098}
21099/// Represents type of disk in storage pool.
21100///
21101/// Possible values:
21102/// - `singleTier`: Represents devices belonging to single tier storage pool.
21103/// - `StoragePoolDiskType_Unknown`: Represents the value when lower version client cannot recognize the enum value.
21104#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
21105pub enum StoragePoolDiskTypeEnum {
21106 #[serde(rename = "singleTier")]
21107 #[strum(serialize = "singleTier")]
21108 SingleTier,
21109 #[serde(rename = "StoragePoolDiskType_Unknown")]
21110 #[strum(serialize = "StoragePoolDiskType_Unknown")]
21111 StoragePoolDiskTypeUnknown,
21112 /// This variant handles values not known at compile time.
21113 #[serde(untagged)]
21114 #[strum(serialize = "__OTHER__")]
21115 Other_(String),
21116}
21117/// This class represents a disk type in trimming.
21118///
21119/// Possible values:
21120/// - `cacheDisk`: means the disk is performed as a cache disk.
21121/// - `capacityDisk`: means the disk is performed as a capacity disk.
21122/// - `TrimDiskType_Unknown`
21123#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
21124pub enum TrimDiskTypeEnum {
21125 #[serde(rename = "cacheDisk")]
21126 #[strum(serialize = "cacheDisk")]
21127 CacheDisk,
21128 #[serde(rename = "capacityDisk")]
21129 #[strum(serialize = "capacityDisk")]
21130 CapacityDisk,
21131 #[serde(rename = "TrimDiskType_Unknown")]
21132 #[strum(serialize = "TrimDiskType_Unknown")]
21133 TrimDiskTypeUnknown,
21134 /// This variant handles values not known at compile time.
21135 #[serde(untagged)]
21136 #[strum(serialize = "__OTHER__")]
21137 Other_(String),
21138}
21139/// Disk evacuation reason
21140///
21141/// Possible values:
21142/// - `User`: Evacuated by user
21143/// - `Ure`: Unrecoverable error
21144/// - `SmartDiskFailures`: Smart disk failures
21145/// - `Latency`: I/O Latency
21146/// - `Congestion`: I/O congestion
21147/// - `TransientDeviceError`: Disk transient device error
21148/// - `VsanDiskEvacReason_Unknow`: represents the value when the lower version client cannot recognize the enum value.
21149#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
21150pub enum VsanDiskEvacReasonEnum {
21151 User,
21152 Ure,
21153 SmartDiskFailures,
21154 Latency,
21155 Congestion,
21156 TransientDeviceError,
21157 #[serde(rename = "VsanDiskEvacReason_Unknow")]
21158 #[strum(serialize = "VsanDiskEvacReason_Unknow")]
21159 VsanDiskEvacReasonUnknow,
21160 /// This variant handles values not known at compile time.
21161 #[serde(untagged)]
21162 #[strum(serialize = "__OTHER__")]
21163 Other_(String),
21164}
21165/// This class represents a list of supported vSAN disk trim options.
21166///
21167/// Possible values:
21168/// - `metaDataOnly`: means only the metadata area on disk will be trimmed.
21169/// - `fullDisk`: means the full disk will be trimmed.
21170/// - `VsanDiskTrimOption_Unknown`
21171#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
21172pub enum VsanDiskTrimOptionEnum {
21173 #[serde(rename = "metaDataOnly")]
21174 #[strum(serialize = "metaDataOnly")]
21175 MetaDataOnly,
21176 #[serde(rename = "fullDisk")]
21177 #[strum(serialize = "fullDisk")]
21178 FullDisk,
21179 #[serde(rename = "VsanDiskTrimOption_Unknown")]
21180 #[strum(serialize = "VsanDiskTrimOption_Unknown")]
21181 VsanDiskTrimOptionUnknown,
21182 /// This variant handles values not known at compile time.
21183 #[serde(untagged)]
21184 #[strum(serialize = "__OTHER__")]
21185 Other_(String),
21186}
21187/// vSAN disk types.
21188///
21189/// Possible values:
21190/// - `diskGroup`: Represents disk belonging to disk group model.
21191/// - `storagePool`: Represents disk belonging to storage pool model.
21192/// - `directDisk`: Represents disk belonging to vSAN direct disks.
21193/// - `VsanDiskType_Unknown`: Represents the value when lower version client cannot recognize the enum value.
21194#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
21195pub enum VsanDiskTypeEnum {
21196 #[serde(rename = "diskGroup")]
21197 #[strum(serialize = "diskGroup")]
21198 DiskGroup,
21199 #[serde(rename = "storagePool")]
21200 #[strum(serialize = "storagePool")]
21201 StoragePool,
21202 #[serde(rename = "directDisk")]
21203 #[strum(serialize = "directDisk")]
21204 DirectDisk,
21205 #[serde(rename = "VsanDiskType_Unknown")]
21206 #[strum(serialize = "VsanDiskType_Unknown")]
21207 VsanDiskTypeUnknown,
21208 /// This variant handles values not known at compile time.
21209 #[serde(untagged)]
21210 #[strum(serialize = "__OTHER__")]
21211 Other_(String),
21212}
21213/// This class represents a list of supported vSAN diskgroup capability types.
21214///
21215/// Possible values:
21216/// - `supportLargerThan16TB`: Stands for diskgroups supporting large capacity drives, i.e., any capacity disk will be formatted to support larger than 16TB logical space.
21217/// - `VsanDiskgroupCapability_Unknown`
21218#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
21219pub enum VsanDiskgroupCapabilityEnum {
21220 #[serde(rename = "supportLargerThan16TB")]
21221 #[strum(serialize = "supportLargerThan16TB")]
21222 SupportLargerThan16Tb,
21223 #[serde(rename = "VsanDiskgroupCapability_Unknown")]
21224 #[strum(serialize = "VsanDiskgroupCapability_Unknown")]
21225 VsanDiskgroupCapabilityUnknown,
21226 /// This variant handles values not known at compile time.
21227 #[serde(untagged)]
21228 #[strum(serialize = "__OTHER__")]
21229 Other_(String),
21230}
21231/// The list of disk issues.
21232///
21233/// Possible values:
21234/// - `nonExist`
21235/// - `stampMismatch`
21236/// - `unknown`
21237#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
21238pub enum VsanDiskIssueTypeEnum {
21239 #[serde(rename = "nonExist")]
21240 #[strum(serialize = "nonExist")]
21241 NonExist,
21242 #[serde(rename = "stampMismatch")]
21243 #[strum(serialize = "stampMismatch")]
21244 StampMismatch,
21245 #[serde(rename = "unknown")]
21246 #[strum(serialize = "unknown")]
21247 Unknown,
21248 /// This variant handles values not known at compile time.
21249 #[serde(untagged)]
21250 #[strum(serialize = "__OTHER__")]
21251 Other_(String),
21252}
21253/// Wipe disk eligible.
21254///
21255/// Possible values:
21256/// - `WipeDiskEligible_Unknown`: Represent the value when the lower version client cannot recognize the enum value.
21257/// - `Yes`: This disk is eligible for wipe.
21258/// - `No`: This disk is ineligible for wipe.
21259/// - `Unknown`: Whether the disk is eligible for wipe is unknown.
21260///
21261/// Because whether the disk support wipe or not is unknown.
21262#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
21263pub enum VsanHostWipeDiskEligibleEnum {
21264 #[serde(rename = "WipeDiskEligible_Unknown")]
21265 #[strum(serialize = "WipeDiskEligible_Unknown")]
21266 WipeDiskEligibleUnknown,
21267 Yes,
21268 No,
21269 Unknown,
21270 /// This variant handles values not known at compile time.
21271 #[serde(untagged)]
21272 #[strum(serialize = "__OTHER__")]
21273 Other_(String),
21274}
21275/// Wipe disk state.
21276///
21277/// Possible values:
21278/// - `WipeDiskState_Unknown`: Represent the value when the lower version client cannot recognize the enum value.
21279/// - `Wiping`: This disk is being wiped.
21280/// - `Success`: This disk has been wiped successfully.
21281/// - `Failure`: This disk has failed to wipe.
21282#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
21283pub enum VsanHostWipeDiskStateEnum {
21284 #[serde(rename = "WipeDiskState_Unknown")]
21285 #[strum(serialize = "WipeDiskState_Unknown")]
21286 WipeDiskStateUnknown,
21287 Wiping,
21288 Success,
21289 Failure,
21290 /// This variant handles values not known at compile time.
21291 #[serde(untagged)]
21292 #[strum(serialize = "__OTHER__")]
21293 Other_(String),
21294}
21295/// Provisioning type constants.
21296///
21297/// Possible values:
21298/// - `thin`: Space required for thin-provisioned virtual disk is allocated
21299/// and zeroed on demand as the space is used.
21300/// - `eagerZeroedThick`: An eager zeroed thick virtual disk has all space allocated and
21301/// wiped clean of any previous contents on the physical media at
21302/// creation time.
21303///
21304/// Such virtual disk may take longer time
21305/// during creation compared to other provisioning formats.
21306/// - `lazyZeroedThick`: A thick virtual disk has all space allocated at creation time.
21307///
21308/// This space may contain stale data on the physical media.
21309#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
21310pub enum BaseConfigInfoDiskFileBackingInfoProvisioningTypeEnum {
21311 #[serde(rename = "thin")]
21312 #[strum(serialize = "thin")]
21313 Thin,
21314 #[serde(rename = "eagerZeroedThick")]
21315 #[strum(serialize = "eagerZeroedThick")]
21316 EagerZeroedThick,
21317 #[serde(rename = "lazyZeroedThick")]
21318 #[strum(serialize = "lazyZeroedThick")]
21319 LazyZeroedThick,
21320 /// This variant handles values not known at compile time.
21321 #[serde(untagged)]
21322 #[strum(serialize = "__OTHER__")]
21323 Other_(String),
21324}
21325/// Flags representing the different information of a disk.
21326///
21327/// Possible values:
21328/// - `id`: ID of virtual storage object.
21329/// - `descriptorVersion`: The disk descriptor version of the virtual storage object.
21330///
21331/// ***Since:*** vSphere API Release 8.0.1.0
21332/// - `backingObjectId`: ID of object backing the virtual storage object.
21333/// - `path`: File path of virtual storage object.
21334/// - `parentPath`: Parent file path of virtual storage object file.
21335/// - `name`: Name of virtual storage object.
21336/// - `deviceName`: Canonical name of the LUN used for virtual storage object.
21337/// - `capacity`: Logical size of virtual storage object.
21338/// - `allocated`: Size allocated by the file system for the virtual storage object
21339/// file/chain/link/extent only.
21340/// - `type`: Provisioning type of virtual storage object.
21341/// - `consumers`: IDs of the consumers of virtual storage object.
21342/// - `tentativeState`: If virtual storage object is in tentative state.
21343/// - `createTime`: Date and time of creation of virtual storage object.
21344/// - `ioFilter`: IOFilter associated with virtual storage object.
21345/// - `controlFlags`: Control flags of virtual storage object.
21346/// - `keepAfterVmDelete`: Deletion behaviour of virtual storage object after VM deletion.
21347/// - `relocationDisabled`: If relocation is disabled for virtual storage object.
21348/// - `keyId`: Key ID used to encrypt the virtual storage object.
21349/// - `keyProviderId`: Crypto key provider ID used to encrypt the virtual storage object.
21350/// - `nativeSnapshotSupported`: If virtual storage object supports native snapshot.
21351/// - `cbtEnabled`: If virtual storage object has changed block tracking enabled.
21352/// - `virtualDiskFormat`: The type of VirtualDisk for 4k native disk/array support.
21353///
21354/// ***Since:*** vSphere API Release 9.0.0.0
21355///
21356/// ***Since:*** vSphere API Release 8.0.0.1
21357#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
21358pub enum VslmDiskInfoFlagEnum {
21359 #[serde(rename = "id")]
21360 #[strum(serialize = "id")]
21361 Id,
21362 #[serde(rename = "descriptorVersion")]
21363 #[strum(serialize = "descriptorVersion")]
21364 DescriptorVersion,
21365 #[serde(rename = "backingObjectId")]
21366 #[strum(serialize = "backingObjectId")]
21367 BackingObjectId,
21368 #[serde(rename = "path")]
21369 #[strum(serialize = "path")]
21370 Path,
21371 #[serde(rename = "parentPath")]
21372 #[strum(serialize = "parentPath")]
21373 ParentPath,
21374 #[serde(rename = "name")]
21375 #[strum(serialize = "name")]
21376 Name,
21377 #[serde(rename = "deviceName")]
21378 #[strum(serialize = "deviceName")]
21379 DeviceName,
21380 #[serde(rename = "capacity")]
21381 #[strum(serialize = "capacity")]
21382 Capacity,
21383 #[serde(rename = "allocated")]
21384 #[strum(serialize = "allocated")]
21385 Allocated,
21386 #[serde(rename = "type")]
21387 #[strum(serialize = "type")]
21388 Type,
21389 #[serde(rename = "consumers")]
21390 #[strum(serialize = "consumers")]
21391 Consumers,
21392 #[serde(rename = "tentativeState")]
21393 #[strum(serialize = "tentativeState")]
21394 TentativeState,
21395 #[serde(rename = "createTime")]
21396 #[strum(serialize = "createTime")]
21397 CreateTime,
21398 #[serde(rename = "ioFilter")]
21399 #[strum(serialize = "ioFilter")]
21400 IoFilter,
21401 #[serde(rename = "controlFlags")]
21402 #[strum(serialize = "controlFlags")]
21403 ControlFlags,
21404 #[serde(rename = "keepAfterVmDelete")]
21405 #[strum(serialize = "keepAfterVmDelete")]
21406 KeepAfterVmDelete,
21407 #[serde(rename = "relocationDisabled")]
21408 #[strum(serialize = "relocationDisabled")]
21409 RelocationDisabled,
21410 #[serde(rename = "keyId")]
21411 #[strum(serialize = "keyId")]
21412 KeyId,
21413 #[serde(rename = "keyProviderId")]
21414 #[strum(serialize = "keyProviderId")]
21415 KeyProviderId,
21416 #[serde(rename = "nativeSnapshotSupported")]
21417 #[strum(serialize = "nativeSnapshotSupported")]
21418 NativeSnapshotSupported,
21419 #[serde(rename = "cbtEnabled")]
21420 #[strum(serialize = "cbtEnabled")]
21421 CbtEnabled,
21422 #[serde(rename = "virtualDiskFormat")]
21423 #[strum(serialize = "virtualDiskFormat")]
21424 VirtualDiskFormat,
21425 /// This variant handles values not known at compile time.
21426 #[serde(untagged)]
21427 #[strum(serialize = "__OTHER__")]
21428 Other_(String),
21429}
21430/// Consumption type constants.
21431///
21432/// Consumption type describes how the virtual storage object is connected and
21433/// consumed for data by the clients.
21434///
21435/// Possible values:
21436/// - `disk`: Disk type.
21437#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
21438pub enum VStorageObjectConsumptionTypeEnum {
21439 #[serde(rename = "disk")]
21440 #[strum(serialize = "disk")]
21441 Disk,
21442 /// This variant handles values not known at compile time.
21443 #[serde(untagged)]
21444 #[strum(serialize = "__OTHER__")]
21445 Other_(String),
21446}
21447/// Possible values:
21448/// - `keepAfterDeleteVm`: Choice of the deletion behavior of this virtual storage object.
21449///
21450/// If not set, the default value is false.
21451/// - `disableRelocation`: Is virtual storage object relocation disabled.
21452///
21453/// If not set, the default value is false.
21454/// - `enableChangedBlockTracking`: Is Virtual storage object has changed blocked tracking enabled.
21455///
21456/// If not set, default value is false.
21457#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
21458pub enum VslmVStorageObjectControlFlagEnum {
21459 #[serde(rename = "keepAfterDeleteVm")]
21460 #[strum(serialize = "keepAfterDeleteVm")]
21461 KeepAfterDeleteVm,
21462 #[serde(rename = "disableRelocation")]
21463 #[strum(serialize = "disableRelocation")]
21464 DisableRelocation,
21465 #[serde(rename = "enableChangedBlockTracking")]
21466 #[strum(serialize = "enableChangedBlockTracking")]
21467 EnableChangedBlockTracking,
21468 /// This variant handles values not known at compile time.
21469 #[serde(untagged)]
21470 #[strum(serialize = "__OTHER__")]
21471 Other_(String),
21472}
21473/// Enumeration of possible changes to a property.
21474///
21475/// Possible values:
21476/// - `add`
21477/// - `remove`
21478/// - `assign`
21479/// - `indirectRemove`
21480#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
21481pub enum PropertyChangeOpEnum {
21482 #[serde(rename = "add")]
21483 #[strum(serialize = "add")]
21484 Add,
21485 #[serde(rename = "remove")]
21486 #[strum(serialize = "remove")]
21487 Remove,
21488 #[serde(rename = "assign")]
21489 #[strum(serialize = "assign")]
21490 Assign,
21491 #[serde(rename = "indirectRemove")]
21492 #[strum(serialize = "indirectRemove")]
21493 IndirectRemove,
21494 /// This variant handles values not known at compile time.
21495 #[serde(untagged)]
21496 #[strum(serialize = "__OTHER__")]
21497 Other_(String),
21498}
21499/// Enumeration of different kinds of updates.
21500///
21501/// Possible values:
21502/// - `modify`: A property of the managed object changed its value.
21503/// - `enter`: A managed object became visible to a filter for the first time.
21504///
21505/// For instance, this can happen if a virtual machine is added to a
21506/// folder.
21507/// - `leave`: A managed object left the set of objects visible to a filter.
21508///
21509/// For
21510/// instance, this can happen when a virtual machine is destroyed.
21511#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
21512pub enum ObjectUpdateKindEnum {
21513 #[serde(rename = "modify")]
21514 #[strum(serialize = "modify")]
21515 Modify,
21516 #[serde(rename = "enter")]
21517 #[strum(serialize = "enter")]
21518 Enter,
21519 #[serde(rename = "leave")]
21520 #[strum(serialize = "leave")]
21521 Leave,
21522 /// This variant handles values not known at compile time.
21523 #[serde(untagged)]
21524 #[strum(serialize = "__OTHER__")]
21525 Other_(String),
21526}
21527/// List of possible states of a task.
21528///
21529/// Possible values:
21530/// - `queued`: When there are too many tasks for threads to handle.
21531/// - `running`: When the busy thread is freed from its current task by
21532/// finishing the task, it picks a queued task to run.
21533///
21534/// Then the queued tasks are marked as running.
21535/// - `success`: When a running task has completed.
21536/// - `error`: When a running task has encountered an error.
21537#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
21538pub enum VslmTaskInfoStateEnum {
21539 #[serde(rename = "queued")]
21540 #[strum(serialize = "queued")]
21541 Queued,
21542 #[serde(rename = "running")]
21543 #[strum(serialize = "running")]
21544 Running,
21545 #[serde(rename = "success")]
21546 #[strum(serialize = "success")]
21547 Success,
21548 #[serde(rename = "error")]
21549 #[strum(serialize = "error")]
21550 Error,
21551 /// This variant handles values not known at compile time.
21552 #[serde(untagged)]
21553 #[strum(serialize = "__OTHER__")]
21554 Other_(String),
21555}
21556/// Possible values:
21557/// - `preFcdMigrateEvent`: Event type used to notify that FCD is going to be relocated.
21558/// - `postFcdMigrateEvent`: Event type used to notify FCD has been relocated.
21559#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
21560pub enum VslmEventTypeEnum {
21561 #[serde(rename = "preFcdMigrateEvent")]
21562 #[strum(serialize = "preFcdMigrateEvent")]
21563 PreFcdMigrateEvent,
21564 #[serde(rename = "postFcdMigrateEvent")]
21565 #[strum(serialize = "postFcdMigrateEvent")]
21566 PostFcdMigrateEvent,
21567 /// This variant handles values not known at compile time.
21568 #[serde(untagged)]
21569 #[strum(serialize = "__OTHER__")]
21570 Other_(String),
21571}
21572/// The possible states of the vlsm event processing.
21573///
21574/// Possible values:
21575/// - `success`: When the event has been successfully processed.
21576/// - `error`: When there is error while processing the event.
21577#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
21578pub enum VslmEventVslmEventInfoStateEnum {
21579 #[serde(rename = "success")]
21580 #[strum(serialize = "success")]
21581 Success,
21582 #[serde(rename = "error")]
21583 #[strum(serialize = "error")]
21584 Error,
21585 /// This variant handles values not known at compile time.
21586 #[serde(untagged)]
21587 #[strum(serialize = "__OTHER__")]
21588 Other_(String),
21589}
21590/// The *VslmVsoVStorageObjectQuerySpecQueryFieldEnum_enum* enumerated
21591/// type defines the searchable fields.
21592///
21593/// Possible values:
21594/// - `id`: Indicates *BaseConfigInfo.id* as the searchable field.
21595/// - `name`: Indicates *BaseConfigInfo.name* as the searchable
21596/// field.
21597/// - `capacity`: Indicates *VStorageObjectConfigInfo.capacityInMB* as the
21598/// searchable field.
21599/// - `createTime`: Indicates *BaseConfigInfo.createTime* as the searchable
21600/// field.
21601/// - `backingObjectId`: Indicates
21602/// *BaseConfigInfoFileBackingInfo.backingObjectId* as the
21603/// searchable field.
21604/// - `datastoreMoId`: Indicates *BaseConfigInfoBackingInfo.datastore* as the
21605/// searchable field.
21606/// - `metadataKey`: Indicates it as the searchable field.
21607/// - `metadataValue`: Indicates it as the searchable field.
21608#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
21609pub enum VslmVsoVStorageObjectQuerySpecQueryFieldEnumEnum {
21610 #[serde(rename = "id")]
21611 #[strum(serialize = "id")]
21612 Id,
21613 #[serde(rename = "name")]
21614 #[strum(serialize = "name")]
21615 Name,
21616 #[serde(rename = "capacity")]
21617 #[strum(serialize = "capacity")]
21618 Capacity,
21619 #[serde(rename = "createTime")]
21620 #[strum(serialize = "createTime")]
21621 CreateTime,
21622 #[serde(rename = "backingObjectId")]
21623 #[strum(serialize = "backingObjectId")]
21624 BackingObjectId,
21625 #[serde(rename = "datastoreMoId")]
21626 #[strum(serialize = "datastoreMoId")]
21627 DatastoreMoId,
21628 #[serde(rename = "metadataKey")]
21629 #[strum(serialize = "metadataKey")]
21630 MetadataKey,
21631 #[serde(rename = "metadataValue")]
21632 #[strum(serialize = "metadataValue")]
21633 MetadataValue,
21634 /// This variant handles values not known at compile time.
21635 #[serde(untagged)]
21636 #[strum(serialize = "__OTHER__")]
21637 Other_(String),
21638}
21639/// The *VslmVsoVStorageObjectQuerySpecQueryOperatorEnum_enum* enumerated
21640/// type defines the operators to use for constructing the query criteria.
21641///
21642/// Possible values:
21643/// - `equals`
21644/// - `notEquals`
21645/// - `lessThan`
21646/// - `greaterThan`
21647/// - `lessThanOrEqual`
21648/// - `greaterThanOrEqual`
21649/// - `contains`
21650/// - `startsWith`
21651/// - `endsWith`
21652#[derive(Clone, Debug, serde::Deserialize, serde::Serialize, strum_macros::IntoStaticStr)]
21653pub enum VslmVsoVStorageObjectQuerySpecQueryOperatorEnumEnum {
21654 #[serde(rename = "equals")]
21655 #[strum(serialize = "equals")]
21656 Equals,
21657 #[serde(rename = "notEquals")]
21658 #[strum(serialize = "notEquals")]
21659 NotEquals,
21660 #[serde(rename = "lessThan")]
21661 #[strum(serialize = "lessThan")]
21662 LessThan,
21663 #[serde(rename = "greaterThan")]
21664 #[strum(serialize = "greaterThan")]
21665 GreaterThan,
21666 #[serde(rename = "lessThanOrEqual")]
21667 #[strum(serialize = "lessThanOrEqual")]
21668 LessThanOrEqual,
21669 #[serde(rename = "greaterThanOrEqual")]
21670 #[strum(serialize = "greaterThanOrEqual")]
21671 GreaterThanOrEqual,
21672 #[serde(rename = "contains")]
21673 #[strum(serialize = "contains")]
21674 Contains,
21675 #[serde(rename = "startsWith")]
21676 #[strum(serialize = "startsWith")]
21677 StartsWith,
21678 #[serde(rename = "endsWith")]
21679 #[strum(serialize = "endsWith")]
21680 EndsWith,
21681 /// This variant handles values not known at compile time.
21682 #[serde(untagged)]
21683 #[strum(serialize = "__OTHER__")]
21684 Other_(String),
21685}