1/* 2Copyright (c) 2014-2016 VMware, Inc. All Rights Reserved. 3 4Licensed under the Apache License, Version 2.0 (the "License"); 5you may not use this file except in compliance with the License. 6You may obtain a copy of the License at 7 8 http://www.apache.org/licenses/LICENSE-2.0 9 10Unless required by applicable law or agreed to in writing, software 11distributed under the License is distributed on an "AS IS" BASIS, 12WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13See the License for the specific language governing permissions and 14limitations under the License. 15*/ 16 17package mo 18 19import ( 20 "reflect" 21 "time" 22 23 "github.com/vmware/govmomi/vim25/types" 24) 25 26type Alarm struct { 27 ExtensibleManagedObject 28 29 Info types.AlarmInfo `mo:"info"` 30} 31 32func init() { 33 t["Alarm"] = reflect.TypeOf((*Alarm)(nil)).Elem() 34} 35 36type AlarmManager struct { 37 Self types.ManagedObjectReference 38 39 DefaultExpression []types.BaseAlarmExpression `mo:"defaultExpression"` 40 Description types.AlarmDescription `mo:"description"` 41} 42 43func (m AlarmManager) Reference() types.ManagedObjectReference { 44 return m.Self 45} 46 47func init() { 48 t["AlarmManager"] = reflect.TypeOf((*AlarmManager)(nil)).Elem() 49} 50 51type AuthorizationManager struct { 52 Self types.ManagedObjectReference 53 54 PrivilegeList []types.AuthorizationPrivilege `mo:"privilegeList"` 55 RoleList []types.AuthorizationRole `mo:"roleList"` 56 Description types.AuthorizationDescription `mo:"description"` 57} 58 59func (m AuthorizationManager) Reference() types.ManagedObjectReference { 60 return m.Self 61} 62 63func init() { 64 t["AuthorizationManager"] = reflect.TypeOf((*AuthorizationManager)(nil)).Elem() 65} 66 67type CertificateManager struct { 68 Self types.ManagedObjectReference 69} 70 71func (m CertificateManager) Reference() types.ManagedObjectReference { 72 return m.Self 73} 74 75func init() { 76 t["CertificateManager"] = reflect.TypeOf((*CertificateManager)(nil)).Elem() 77} 78 79type ClusterComputeResource struct { 80 ComputeResource 81 82 Configuration types.ClusterConfigInfo `mo:"configuration"` 83 Recommendation []types.ClusterRecommendation `mo:"recommendation"` 84 DrsRecommendation []types.ClusterDrsRecommendation `mo:"drsRecommendation"` 85 MigrationHistory []types.ClusterDrsMigration `mo:"migrationHistory"` 86 ActionHistory []types.ClusterActionHistory `mo:"actionHistory"` 87 DrsFault []types.ClusterDrsFaults `mo:"drsFault"` 88} 89 90func init() { 91 t["ClusterComputeResource"] = reflect.TypeOf((*ClusterComputeResource)(nil)).Elem() 92} 93 94type ClusterEVCManager struct { 95 ExtensibleManagedObject 96 97 ManagedCluster types.ManagedObjectReference `mo:"managedCluster"` 98 EvcState types.ClusterEVCManagerEVCState `mo:"evcState"` 99} 100 101func init() { 102 t["ClusterEVCManager"] = reflect.TypeOf((*ClusterEVCManager)(nil)).Elem() 103} 104 105type ClusterProfile struct { 106 Profile 107} 108 109func init() { 110 t["ClusterProfile"] = reflect.TypeOf((*ClusterProfile)(nil)).Elem() 111} 112 113type ClusterProfileManager struct { 114 ProfileManager 115} 116 117func init() { 118 t["ClusterProfileManager"] = reflect.TypeOf((*ClusterProfileManager)(nil)).Elem() 119} 120 121type ComputeResource struct { 122 ManagedEntity 123 124 ResourcePool *types.ManagedObjectReference `mo:"resourcePool"` 125 Host []types.ManagedObjectReference `mo:"host"` 126 Datastore []types.ManagedObjectReference `mo:"datastore"` 127 Network []types.ManagedObjectReference `mo:"network"` 128 Summary types.BaseComputeResourceSummary `mo:"summary"` 129 EnvironmentBrowser *types.ManagedObjectReference `mo:"environmentBrowser"` 130 ConfigurationEx types.BaseComputeResourceConfigInfo `mo:"configurationEx"` 131} 132 133func (m *ComputeResource) Entity() *ManagedEntity { 134 return &m.ManagedEntity 135} 136 137func init() { 138 t["ComputeResource"] = reflect.TypeOf((*ComputeResource)(nil)).Elem() 139} 140 141type ContainerView struct { 142 ManagedObjectView 143 144 Container types.ManagedObjectReference `mo:"container"` 145 Type []string `mo:"type"` 146 Recursive bool `mo:"recursive"` 147} 148 149func init() { 150 t["ContainerView"] = reflect.TypeOf((*ContainerView)(nil)).Elem() 151} 152 153type CustomFieldsManager struct { 154 Self types.ManagedObjectReference 155 156 Field []types.CustomFieldDef `mo:"field"` 157} 158 159func (m CustomFieldsManager) Reference() types.ManagedObjectReference { 160 return m.Self 161} 162 163func init() { 164 t["CustomFieldsManager"] = reflect.TypeOf((*CustomFieldsManager)(nil)).Elem() 165} 166 167type CustomizationSpecManager struct { 168 Self types.ManagedObjectReference 169 170 Info []types.CustomizationSpecInfo `mo:"info"` 171 EncryptionKey []byte `mo:"encryptionKey"` 172} 173 174func (m CustomizationSpecManager) Reference() types.ManagedObjectReference { 175 return m.Self 176} 177 178func init() { 179 t["CustomizationSpecManager"] = reflect.TypeOf((*CustomizationSpecManager)(nil)).Elem() 180} 181 182type Datacenter struct { 183 ManagedEntity 184 185 VmFolder types.ManagedObjectReference `mo:"vmFolder"` 186 HostFolder types.ManagedObjectReference `mo:"hostFolder"` 187 DatastoreFolder types.ManagedObjectReference `mo:"datastoreFolder"` 188 NetworkFolder types.ManagedObjectReference `mo:"networkFolder"` 189 Datastore []types.ManagedObjectReference `mo:"datastore"` 190 Network []types.ManagedObjectReference `mo:"network"` 191 Configuration types.DatacenterConfigInfo `mo:"configuration"` 192} 193 194func (m *Datacenter) Entity() *ManagedEntity { 195 return &m.ManagedEntity 196} 197 198func init() { 199 t["Datacenter"] = reflect.TypeOf((*Datacenter)(nil)).Elem() 200} 201 202type Datastore struct { 203 ManagedEntity 204 205 Info types.BaseDatastoreInfo `mo:"info"` 206 Summary types.DatastoreSummary `mo:"summary"` 207 Host []types.DatastoreHostMount `mo:"host"` 208 Vm []types.ManagedObjectReference `mo:"vm"` 209 Browser types.ManagedObjectReference `mo:"browser"` 210 Capability types.DatastoreCapability `mo:"capability"` 211 IormConfiguration *types.StorageIORMInfo `mo:"iormConfiguration"` 212} 213 214func (m *Datastore) Entity() *ManagedEntity { 215 return &m.ManagedEntity 216} 217 218func init() { 219 t["Datastore"] = reflect.TypeOf((*Datastore)(nil)).Elem() 220} 221 222type DatastoreNamespaceManager struct { 223 Self types.ManagedObjectReference 224} 225 226func (m DatastoreNamespaceManager) Reference() types.ManagedObjectReference { 227 return m.Self 228} 229 230func init() { 231 t["DatastoreNamespaceManager"] = reflect.TypeOf((*DatastoreNamespaceManager)(nil)).Elem() 232} 233 234type DiagnosticManager struct { 235 Self types.ManagedObjectReference 236} 237 238func (m DiagnosticManager) Reference() types.ManagedObjectReference { 239 return m.Self 240} 241 242func init() { 243 t["DiagnosticManager"] = reflect.TypeOf((*DiagnosticManager)(nil)).Elem() 244} 245 246type DistributedVirtualPortgroup struct { 247 Network 248 249 Key string `mo:"key"` 250 Config types.DVPortgroupConfigInfo `mo:"config"` 251 PortKeys []string `mo:"portKeys"` 252} 253 254func init() { 255 t["DistributedVirtualPortgroup"] = reflect.TypeOf((*DistributedVirtualPortgroup)(nil)).Elem() 256} 257 258type DistributedVirtualSwitch struct { 259 ManagedEntity 260 261 Uuid string `mo:"uuid"` 262 Capability types.DVSCapability `mo:"capability"` 263 Summary types.DVSSummary `mo:"summary"` 264 Config types.BaseDVSConfigInfo `mo:"config"` 265 NetworkResourcePool []types.DVSNetworkResourcePool `mo:"networkResourcePool"` 266 Portgroup []types.ManagedObjectReference `mo:"portgroup"` 267 Runtime *types.DVSRuntimeInfo `mo:"runtime"` 268} 269 270func (m *DistributedVirtualSwitch) Entity() *ManagedEntity { 271 return &m.ManagedEntity 272} 273 274func init() { 275 t["DistributedVirtualSwitch"] = reflect.TypeOf((*DistributedVirtualSwitch)(nil)).Elem() 276} 277 278type DistributedVirtualSwitchManager struct { 279 Self types.ManagedObjectReference 280} 281 282func (m DistributedVirtualSwitchManager) Reference() types.ManagedObjectReference { 283 return m.Self 284} 285 286func init() { 287 t["DistributedVirtualSwitchManager"] = reflect.TypeOf((*DistributedVirtualSwitchManager)(nil)).Elem() 288} 289 290type EnvironmentBrowser struct { 291 Self types.ManagedObjectReference 292 293 DatastoreBrowser *types.ManagedObjectReference `mo:"datastoreBrowser"` 294} 295 296func (m EnvironmentBrowser) Reference() types.ManagedObjectReference { 297 return m.Self 298} 299 300func init() { 301 t["EnvironmentBrowser"] = reflect.TypeOf((*EnvironmentBrowser)(nil)).Elem() 302} 303 304type EventHistoryCollector struct { 305 HistoryCollector 306 307 LatestPage []types.BaseEvent `mo:"latestPage"` 308} 309 310func init() { 311 t["EventHistoryCollector"] = reflect.TypeOf((*EventHistoryCollector)(nil)).Elem() 312} 313 314type EventManager struct { 315 Self types.ManagedObjectReference 316 317 Description types.EventDescription `mo:"description"` 318 LatestEvent types.BaseEvent `mo:"latestEvent"` 319 MaxCollector int32 `mo:"maxCollector"` 320} 321 322func (m EventManager) Reference() types.ManagedObjectReference { 323 return m.Self 324} 325 326func init() { 327 t["EventManager"] = reflect.TypeOf((*EventManager)(nil)).Elem() 328} 329 330type ExtensibleManagedObject struct { 331 Self types.ManagedObjectReference 332 333 Value []types.BaseCustomFieldValue `mo:"value"` 334 AvailableField []types.CustomFieldDef `mo:"availableField"` 335} 336 337func (m ExtensibleManagedObject) Reference() types.ManagedObjectReference { 338 return m.Self 339} 340 341func init() { 342 t["ExtensibleManagedObject"] = reflect.TypeOf((*ExtensibleManagedObject)(nil)).Elem() 343} 344 345type ExtensionManager struct { 346 Self types.ManagedObjectReference 347 348 ExtensionList []types.Extension `mo:"extensionList"` 349} 350 351func (m ExtensionManager) Reference() types.ManagedObjectReference { 352 return m.Self 353} 354 355func init() { 356 t["ExtensionManager"] = reflect.TypeOf((*ExtensionManager)(nil)).Elem() 357} 358 359type FileManager struct { 360 Self types.ManagedObjectReference 361} 362 363func (m FileManager) Reference() types.ManagedObjectReference { 364 return m.Self 365} 366 367func init() { 368 t["FileManager"] = reflect.TypeOf((*FileManager)(nil)).Elem() 369} 370 371type Folder struct { 372 ManagedEntity 373 374 ChildType []string `mo:"childType"` 375 ChildEntity []types.ManagedObjectReference `mo:"childEntity"` 376} 377 378func (m *Folder) Entity() *ManagedEntity { 379 return &m.ManagedEntity 380} 381 382func init() { 383 t["Folder"] = reflect.TypeOf((*Folder)(nil)).Elem() 384} 385 386type GuestAliasManager struct { 387 Self types.ManagedObjectReference 388} 389 390func (m GuestAliasManager) Reference() types.ManagedObjectReference { 391 return m.Self 392} 393 394func init() { 395 t["GuestAliasManager"] = reflect.TypeOf((*GuestAliasManager)(nil)).Elem() 396} 397 398type GuestAuthManager struct { 399 Self types.ManagedObjectReference 400} 401 402func (m GuestAuthManager) Reference() types.ManagedObjectReference { 403 return m.Self 404} 405 406func init() { 407 t["GuestAuthManager"] = reflect.TypeOf((*GuestAuthManager)(nil)).Elem() 408} 409 410type GuestFileManager struct { 411 Self types.ManagedObjectReference 412} 413 414func (m GuestFileManager) Reference() types.ManagedObjectReference { 415 return m.Self 416} 417 418func init() { 419 t["GuestFileManager"] = reflect.TypeOf((*GuestFileManager)(nil)).Elem() 420} 421 422type GuestOperationsManager struct { 423 Self types.ManagedObjectReference 424 425 AuthManager *types.ManagedObjectReference `mo:"authManager"` 426 FileManager *types.ManagedObjectReference `mo:"fileManager"` 427 ProcessManager *types.ManagedObjectReference `mo:"processManager"` 428 GuestWindowsRegistryManager *types.ManagedObjectReference `mo:"guestWindowsRegistryManager"` 429 AliasManager *types.ManagedObjectReference `mo:"aliasManager"` 430} 431 432func (m GuestOperationsManager) Reference() types.ManagedObjectReference { 433 return m.Self 434} 435 436func init() { 437 t["GuestOperationsManager"] = reflect.TypeOf((*GuestOperationsManager)(nil)).Elem() 438} 439 440type GuestProcessManager struct { 441 Self types.ManagedObjectReference 442} 443 444func (m GuestProcessManager) Reference() types.ManagedObjectReference { 445 return m.Self 446} 447 448func init() { 449 t["GuestProcessManager"] = reflect.TypeOf((*GuestProcessManager)(nil)).Elem() 450} 451 452type GuestWindowsRegistryManager struct { 453 Self types.ManagedObjectReference 454} 455 456func (m GuestWindowsRegistryManager) Reference() types.ManagedObjectReference { 457 return m.Self 458} 459 460func init() { 461 t["GuestWindowsRegistryManager"] = reflect.TypeOf((*GuestWindowsRegistryManager)(nil)).Elem() 462} 463 464type HistoryCollector struct { 465 Self types.ManagedObjectReference 466 467 Filter types.AnyType `mo:"filter"` 468} 469 470func (m HistoryCollector) Reference() types.ManagedObjectReference { 471 return m.Self 472} 473 474func init() { 475 t["HistoryCollector"] = reflect.TypeOf((*HistoryCollector)(nil)).Elem() 476} 477 478type HostAccessManager struct { 479 Self types.ManagedObjectReference 480 481 LockdownMode types.HostLockdownMode `mo:"lockdownMode"` 482} 483 484func (m HostAccessManager) Reference() types.ManagedObjectReference { 485 return m.Self 486} 487 488func init() { 489 t["HostAccessManager"] = reflect.TypeOf((*HostAccessManager)(nil)).Elem() 490} 491 492type HostActiveDirectoryAuthentication struct { 493 HostDirectoryStore 494} 495 496func init() { 497 t["HostActiveDirectoryAuthentication"] = reflect.TypeOf((*HostActiveDirectoryAuthentication)(nil)).Elem() 498} 499 500type HostAuthenticationManager struct { 501 Self types.ManagedObjectReference 502 503 Info types.HostAuthenticationManagerInfo `mo:"info"` 504 SupportedStore []types.ManagedObjectReference `mo:"supportedStore"` 505} 506 507func (m HostAuthenticationManager) Reference() types.ManagedObjectReference { 508 return m.Self 509} 510 511func init() { 512 t["HostAuthenticationManager"] = reflect.TypeOf((*HostAuthenticationManager)(nil)).Elem() 513} 514 515type HostAuthenticationStore struct { 516 Self types.ManagedObjectReference 517 518 Info types.BaseHostAuthenticationStoreInfo `mo:"info"` 519} 520 521func (m HostAuthenticationStore) Reference() types.ManagedObjectReference { 522 return m.Self 523} 524 525func init() { 526 t["HostAuthenticationStore"] = reflect.TypeOf((*HostAuthenticationStore)(nil)).Elem() 527} 528 529type HostAutoStartManager struct { 530 Self types.ManagedObjectReference 531 532 Config types.HostAutoStartManagerConfig `mo:"config"` 533} 534 535func (m HostAutoStartManager) Reference() types.ManagedObjectReference { 536 return m.Self 537} 538 539func init() { 540 t["HostAutoStartManager"] = reflect.TypeOf((*HostAutoStartManager)(nil)).Elem() 541} 542 543type HostBootDeviceSystem struct { 544 Self types.ManagedObjectReference 545} 546 547func (m HostBootDeviceSystem) Reference() types.ManagedObjectReference { 548 return m.Self 549} 550 551func init() { 552 t["HostBootDeviceSystem"] = reflect.TypeOf((*HostBootDeviceSystem)(nil)).Elem() 553} 554 555type HostCacheConfigurationManager struct { 556 Self types.ManagedObjectReference 557 558 CacheConfigurationInfo []types.HostCacheConfigurationInfo `mo:"cacheConfigurationInfo"` 559} 560 561func (m HostCacheConfigurationManager) Reference() types.ManagedObjectReference { 562 return m.Self 563} 564 565func init() { 566 t["HostCacheConfigurationManager"] = reflect.TypeOf((*HostCacheConfigurationManager)(nil)).Elem() 567} 568 569type HostCertificateManager struct { 570 Self types.ManagedObjectReference 571 572 CertificateInfo types.HostCertificateManagerCertificateInfo `mo:"certificateInfo"` 573} 574 575func (m HostCertificateManager) Reference() types.ManagedObjectReference { 576 return m.Self 577} 578 579func init() { 580 t["HostCertificateManager"] = reflect.TypeOf((*HostCertificateManager)(nil)).Elem() 581} 582 583type HostCpuSchedulerSystem struct { 584 ExtensibleManagedObject 585 586 HyperthreadInfo *types.HostHyperThreadScheduleInfo `mo:"hyperthreadInfo"` 587} 588 589func init() { 590 t["HostCpuSchedulerSystem"] = reflect.TypeOf((*HostCpuSchedulerSystem)(nil)).Elem() 591} 592 593type HostDatastoreBrowser struct { 594 Self types.ManagedObjectReference 595 596 Datastore []types.ManagedObjectReference `mo:"datastore"` 597 SupportedType []types.BaseFileQuery `mo:"supportedType"` 598} 599 600func (m HostDatastoreBrowser) Reference() types.ManagedObjectReference { 601 return m.Self 602} 603 604func init() { 605 t["HostDatastoreBrowser"] = reflect.TypeOf((*HostDatastoreBrowser)(nil)).Elem() 606} 607 608type HostDatastoreSystem struct { 609 Self types.ManagedObjectReference 610 611 Datastore []types.ManagedObjectReference `mo:"datastore"` 612 Capabilities types.HostDatastoreSystemCapabilities `mo:"capabilities"` 613} 614 615func (m HostDatastoreSystem) Reference() types.ManagedObjectReference { 616 return m.Self 617} 618 619func init() { 620 t["HostDatastoreSystem"] = reflect.TypeOf((*HostDatastoreSystem)(nil)).Elem() 621} 622 623type HostDateTimeSystem struct { 624 Self types.ManagedObjectReference 625 626 DateTimeInfo types.HostDateTimeInfo `mo:"dateTimeInfo"` 627} 628 629func (m HostDateTimeSystem) Reference() types.ManagedObjectReference { 630 return m.Self 631} 632 633func init() { 634 t["HostDateTimeSystem"] = reflect.TypeOf((*HostDateTimeSystem)(nil)).Elem() 635} 636 637type HostDiagnosticSystem struct { 638 Self types.ManagedObjectReference 639 640 ActivePartition *types.HostDiagnosticPartition `mo:"activePartition"` 641} 642 643func (m HostDiagnosticSystem) Reference() types.ManagedObjectReference { 644 return m.Self 645} 646 647func init() { 648 t["HostDiagnosticSystem"] = reflect.TypeOf((*HostDiagnosticSystem)(nil)).Elem() 649} 650 651type HostDirectoryStore struct { 652 HostAuthenticationStore 653} 654 655func init() { 656 t["HostDirectoryStore"] = reflect.TypeOf((*HostDirectoryStore)(nil)).Elem() 657} 658 659type HostEsxAgentHostManager struct { 660 Self types.ManagedObjectReference 661 662 ConfigInfo types.HostEsxAgentHostManagerConfigInfo `mo:"configInfo"` 663} 664 665func (m HostEsxAgentHostManager) Reference() types.ManagedObjectReference { 666 return m.Self 667} 668 669func init() { 670 t["HostEsxAgentHostManager"] = reflect.TypeOf((*HostEsxAgentHostManager)(nil)).Elem() 671} 672 673type HostFirewallSystem struct { 674 ExtensibleManagedObject 675 676 FirewallInfo *types.HostFirewallInfo `mo:"firewallInfo"` 677} 678 679func init() { 680 t["HostFirewallSystem"] = reflect.TypeOf((*HostFirewallSystem)(nil)).Elem() 681} 682 683type HostFirmwareSystem struct { 684 Self types.ManagedObjectReference 685} 686 687func (m HostFirmwareSystem) Reference() types.ManagedObjectReference { 688 return m.Self 689} 690 691func init() { 692 t["HostFirmwareSystem"] = reflect.TypeOf((*HostFirmwareSystem)(nil)).Elem() 693} 694 695type HostGraphicsManager struct { 696 ExtensibleManagedObject 697 698 GraphicsInfo []types.HostGraphicsInfo `mo:"graphicsInfo"` 699 SharedPassthruGpuTypes []string `mo:"sharedPassthruGpuTypes"` 700} 701 702func init() { 703 t["HostGraphicsManager"] = reflect.TypeOf((*HostGraphicsManager)(nil)).Elem() 704} 705 706type HostHealthStatusSystem struct { 707 Self types.ManagedObjectReference 708 709 Runtime types.HealthSystemRuntime `mo:"runtime"` 710} 711 712func (m HostHealthStatusSystem) Reference() types.ManagedObjectReference { 713 return m.Self 714} 715 716func init() { 717 t["HostHealthStatusSystem"] = reflect.TypeOf((*HostHealthStatusSystem)(nil)).Elem() 718} 719 720type HostImageConfigManager struct { 721 Self types.ManagedObjectReference 722} 723 724func (m HostImageConfigManager) Reference() types.ManagedObjectReference { 725 return m.Self 726} 727 728func init() { 729 t["HostImageConfigManager"] = reflect.TypeOf((*HostImageConfigManager)(nil)).Elem() 730} 731 732type HostKernelModuleSystem struct { 733 Self types.ManagedObjectReference 734} 735 736func (m HostKernelModuleSystem) Reference() types.ManagedObjectReference { 737 return m.Self 738} 739 740func init() { 741 t["HostKernelModuleSystem"] = reflect.TypeOf((*HostKernelModuleSystem)(nil)).Elem() 742} 743 744type HostLocalAccountManager struct { 745 Self types.ManagedObjectReference 746} 747 748func (m HostLocalAccountManager) Reference() types.ManagedObjectReference { 749 return m.Self 750} 751 752func init() { 753 t["HostLocalAccountManager"] = reflect.TypeOf((*HostLocalAccountManager)(nil)).Elem() 754} 755 756type HostLocalAuthentication struct { 757 HostAuthenticationStore 758} 759 760func init() { 761 t["HostLocalAuthentication"] = reflect.TypeOf((*HostLocalAuthentication)(nil)).Elem() 762} 763 764type HostMemorySystem struct { 765 ExtensibleManagedObject 766 767 ConsoleReservationInfo *types.ServiceConsoleReservationInfo `mo:"consoleReservationInfo"` 768 VirtualMachineReservationInfo *types.VirtualMachineMemoryReservationInfo `mo:"virtualMachineReservationInfo"` 769} 770 771func init() { 772 t["HostMemorySystem"] = reflect.TypeOf((*HostMemorySystem)(nil)).Elem() 773} 774 775type HostNetworkSystem struct { 776 ExtensibleManagedObject 777 778 Capabilities *types.HostNetCapabilities `mo:"capabilities"` 779 NetworkInfo *types.HostNetworkInfo `mo:"networkInfo"` 780 OffloadCapabilities *types.HostNetOffloadCapabilities `mo:"offloadCapabilities"` 781 NetworkConfig *types.HostNetworkConfig `mo:"networkConfig"` 782 DnsConfig types.BaseHostDnsConfig `mo:"dnsConfig"` 783 IpRouteConfig types.BaseHostIpRouteConfig `mo:"ipRouteConfig"` 784 ConsoleIpRouteConfig types.BaseHostIpRouteConfig `mo:"consoleIpRouteConfig"` 785} 786 787func init() { 788 t["HostNetworkSystem"] = reflect.TypeOf((*HostNetworkSystem)(nil)).Elem() 789} 790 791type HostPatchManager struct { 792 Self types.ManagedObjectReference 793} 794 795func (m HostPatchManager) Reference() types.ManagedObjectReference { 796 return m.Self 797} 798 799func init() { 800 t["HostPatchManager"] = reflect.TypeOf((*HostPatchManager)(nil)).Elem() 801} 802 803type HostPciPassthruSystem struct { 804 ExtensibleManagedObject 805 806 PciPassthruInfo []types.BaseHostPciPassthruInfo `mo:"pciPassthruInfo"` 807} 808 809func init() { 810 t["HostPciPassthruSystem"] = reflect.TypeOf((*HostPciPassthruSystem)(nil)).Elem() 811} 812 813type HostPowerSystem struct { 814 Self types.ManagedObjectReference 815 816 Capability types.PowerSystemCapability `mo:"capability"` 817 Info types.PowerSystemInfo `mo:"info"` 818} 819 820func (m HostPowerSystem) Reference() types.ManagedObjectReference { 821 return m.Self 822} 823 824func init() { 825 t["HostPowerSystem"] = reflect.TypeOf((*HostPowerSystem)(nil)).Elem() 826} 827 828type HostProfile struct { 829 Profile 830 831 ReferenceHost *types.ManagedObjectReference `mo:"referenceHost"` 832} 833 834func init() { 835 t["HostProfile"] = reflect.TypeOf((*HostProfile)(nil)).Elem() 836} 837 838type HostProfileManager struct { 839 ProfileManager 840} 841 842func init() { 843 t["HostProfileManager"] = reflect.TypeOf((*HostProfileManager)(nil)).Elem() 844} 845 846type HostServiceSystem struct { 847 ExtensibleManagedObject 848 849 ServiceInfo types.HostServiceInfo `mo:"serviceInfo"` 850} 851 852func init() { 853 t["HostServiceSystem"] = reflect.TypeOf((*HostServiceSystem)(nil)).Elem() 854} 855 856type HostSnmpSystem struct { 857 Self types.ManagedObjectReference 858 859 Configuration types.HostSnmpConfigSpec `mo:"configuration"` 860 Limits types.HostSnmpSystemAgentLimits `mo:"limits"` 861} 862 863func (m HostSnmpSystem) Reference() types.ManagedObjectReference { 864 return m.Self 865} 866 867func init() { 868 t["HostSnmpSystem"] = reflect.TypeOf((*HostSnmpSystem)(nil)).Elem() 869} 870 871type HostStorageSystem struct { 872 ExtensibleManagedObject 873 874 StorageDeviceInfo *types.HostStorageDeviceInfo `mo:"storageDeviceInfo"` 875 FileSystemVolumeInfo types.HostFileSystemVolumeInfo `mo:"fileSystemVolumeInfo"` 876 SystemFile []string `mo:"systemFile"` 877 MultipathStateInfo *types.HostMultipathStateInfo `mo:"multipathStateInfo"` 878} 879 880func init() { 881 t["HostStorageSystem"] = reflect.TypeOf((*HostStorageSystem)(nil)).Elem() 882} 883 884type HostSystem struct { 885 ManagedEntity 886 887 Runtime types.HostRuntimeInfo `mo:"runtime"` 888 Summary types.HostListSummary `mo:"summary"` 889 Hardware *types.HostHardwareInfo `mo:"hardware"` 890 Capability *types.HostCapability `mo:"capability"` 891 LicensableResource types.HostLicensableResourceInfo `mo:"licensableResource"` 892 ConfigManager types.HostConfigManager `mo:"configManager"` 893 Config *types.HostConfigInfo `mo:"config"` 894 Vm []types.ManagedObjectReference `mo:"vm"` 895 Datastore []types.ManagedObjectReference `mo:"datastore"` 896 Network []types.ManagedObjectReference `mo:"network"` 897 DatastoreBrowser types.ManagedObjectReference `mo:"datastoreBrowser"` 898 SystemResources *types.HostSystemResourceInfo `mo:"systemResources"` 899} 900 901func (m *HostSystem) Entity() *ManagedEntity { 902 return &m.ManagedEntity 903} 904 905func init() { 906 t["HostSystem"] = reflect.TypeOf((*HostSystem)(nil)).Elem() 907} 908 909type HostVFlashManager struct { 910 Self types.ManagedObjectReference 911 912 VFlashConfigInfo *types.HostVFlashManagerVFlashConfigInfo `mo:"vFlashConfigInfo"` 913} 914 915func (m HostVFlashManager) Reference() types.ManagedObjectReference { 916 return m.Self 917} 918 919func init() { 920 t["HostVFlashManager"] = reflect.TypeOf((*HostVFlashManager)(nil)).Elem() 921} 922 923type HostVMotionSystem struct { 924 ExtensibleManagedObject 925 926 NetConfig *types.HostVMotionNetConfig `mo:"netConfig"` 927 IpConfig *types.HostIpConfig `mo:"ipConfig"` 928} 929 930func init() { 931 t["HostVMotionSystem"] = reflect.TypeOf((*HostVMotionSystem)(nil)).Elem() 932} 933 934type HostVirtualNicManager struct { 935 ExtensibleManagedObject 936 937 Info types.HostVirtualNicManagerInfo `mo:"info"` 938} 939 940func init() { 941 t["HostVirtualNicManager"] = reflect.TypeOf((*HostVirtualNicManager)(nil)).Elem() 942} 943 944type HostVsanInternalSystem struct { 945 Self types.ManagedObjectReference 946} 947 948func (m HostVsanInternalSystem) Reference() types.ManagedObjectReference { 949 return m.Self 950} 951 952func init() { 953 t["HostVsanInternalSystem"] = reflect.TypeOf((*HostVsanInternalSystem)(nil)).Elem() 954} 955 956type HostVsanSystem struct { 957 Self types.ManagedObjectReference 958 959 Config types.VsanHostConfigInfo `mo:"config"` 960} 961 962func (m HostVsanSystem) Reference() types.ManagedObjectReference { 963 return m.Self 964} 965 966func init() { 967 t["HostVsanSystem"] = reflect.TypeOf((*HostVsanSystem)(nil)).Elem() 968} 969 970type HttpNfcLease struct { 971 Self types.ManagedObjectReference 972 973 InitializeProgress int32 `mo:"initializeProgress"` 974 Info *types.HttpNfcLeaseInfo `mo:"info"` 975 State types.HttpNfcLeaseState `mo:"state"` 976 Error *types.LocalizedMethodFault `mo:"error"` 977} 978 979func (m HttpNfcLease) Reference() types.ManagedObjectReference { 980 return m.Self 981} 982 983func init() { 984 t["HttpNfcLease"] = reflect.TypeOf((*HttpNfcLease)(nil)).Elem() 985} 986 987type InventoryView struct { 988 ManagedObjectView 989} 990 991func init() { 992 t["InventoryView"] = reflect.TypeOf((*InventoryView)(nil)).Elem() 993} 994 995type IoFilterManager struct { 996 Self types.ManagedObjectReference 997} 998 999func (m IoFilterManager) Reference() types.ManagedObjectReference { 1000 return m.Self 1001} 1002 1003func init() { 1004 t["IoFilterManager"] = reflect.TypeOf((*IoFilterManager)(nil)).Elem() 1005} 1006 1007type IpPoolManager struct { 1008 Self types.ManagedObjectReference 1009} 1010 1011func (m IpPoolManager) Reference() types.ManagedObjectReference { 1012 return m.Self 1013} 1014 1015func init() { 1016 t["IpPoolManager"] = reflect.TypeOf((*IpPoolManager)(nil)).Elem() 1017} 1018 1019type IscsiManager struct { 1020 Self types.ManagedObjectReference 1021} 1022 1023func (m IscsiManager) Reference() types.ManagedObjectReference { 1024 return m.Self 1025} 1026 1027func init() { 1028 t["IscsiManager"] = reflect.TypeOf((*IscsiManager)(nil)).Elem() 1029} 1030 1031type LicenseAssignmentManager struct { 1032 Self types.ManagedObjectReference 1033} 1034 1035func (m LicenseAssignmentManager) Reference() types.ManagedObjectReference { 1036 return m.Self 1037} 1038 1039func init() { 1040 t["LicenseAssignmentManager"] = reflect.TypeOf((*LicenseAssignmentManager)(nil)).Elem() 1041} 1042 1043type LicenseManager struct { 1044 Self types.ManagedObjectReference 1045 1046 Source types.BaseLicenseSource `mo:"source"` 1047 SourceAvailable bool `mo:"sourceAvailable"` 1048 Diagnostics *types.LicenseDiagnostics `mo:"diagnostics"` 1049 FeatureInfo []types.LicenseFeatureInfo `mo:"featureInfo"` 1050 LicensedEdition string `mo:"licensedEdition"` 1051 Licenses []types.LicenseManagerLicenseInfo `mo:"licenses"` 1052 LicenseAssignmentManager *types.ManagedObjectReference `mo:"licenseAssignmentManager"` 1053 Evaluation types.LicenseManagerEvaluationInfo `mo:"evaluation"` 1054} 1055 1056func (m LicenseManager) Reference() types.ManagedObjectReference { 1057 return m.Self 1058} 1059 1060func init() { 1061 t["LicenseManager"] = reflect.TypeOf((*LicenseManager)(nil)).Elem() 1062} 1063 1064type ListView struct { 1065 ManagedObjectView 1066} 1067 1068func init() { 1069 t["ListView"] = reflect.TypeOf((*ListView)(nil)).Elem() 1070} 1071 1072type LocalizationManager struct { 1073 Self types.ManagedObjectReference 1074 1075 Catalog []types.LocalizationManagerMessageCatalog `mo:"catalog"` 1076} 1077 1078func (m LocalizationManager) Reference() types.ManagedObjectReference { 1079 return m.Self 1080} 1081 1082func init() { 1083 t["LocalizationManager"] = reflect.TypeOf((*LocalizationManager)(nil)).Elem() 1084} 1085 1086type ManagedEntity struct { 1087 ExtensibleManagedObject 1088 1089 Parent *types.ManagedObjectReference `mo:"parent"` 1090 CustomValue []types.BaseCustomFieldValue `mo:"customValue"` 1091 OverallStatus types.ManagedEntityStatus `mo:"overallStatus"` 1092 ConfigStatus types.ManagedEntityStatus `mo:"configStatus"` 1093 ConfigIssue []types.BaseEvent `mo:"configIssue"` 1094 EffectiveRole []int32 `mo:"effectiveRole"` 1095 Permission []types.Permission `mo:"permission"` 1096 Name string `mo:"name"` 1097 DisabledMethod []string `mo:"disabledMethod"` 1098 RecentTask []types.ManagedObjectReference `mo:"recentTask"` 1099 DeclaredAlarmState []types.AlarmState `mo:"declaredAlarmState"` 1100 TriggeredAlarmState []types.AlarmState `mo:"triggeredAlarmState"` 1101 AlarmActionsEnabled *bool `mo:"alarmActionsEnabled"` 1102 Tag []types.Tag `mo:"tag"` 1103} 1104 1105func init() { 1106 t["ManagedEntity"] = reflect.TypeOf((*ManagedEntity)(nil)).Elem() 1107} 1108 1109type ManagedObjectView struct { 1110 Self types.ManagedObjectReference 1111 1112 View []types.ManagedObjectReference `mo:"view"` 1113} 1114 1115func (m ManagedObjectView) Reference() types.ManagedObjectReference { 1116 return m.Self 1117} 1118 1119func init() { 1120 t["ManagedObjectView"] = reflect.TypeOf((*ManagedObjectView)(nil)).Elem() 1121} 1122 1123type MessageBusProxy struct { 1124 Self types.ManagedObjectReference 1125} 1126 1127func (m MessageBusProxy) Reference() types.ManagedObjectReference { 1128 return m.Self 1129} 1130 1131func init() { 1132 t["MessageBusProxy"] = reflect.TypeOf((*MessageBusProxy)(nil)).Elem() 1133} 1134 1135type Network struct { 1136 ManagedEntity 1137 1138 Name string `mo:"name"` 1139 Summary types.BaseNetworkSummary `mo:"summary"` 1140 Host []types.ManagedObjectReference `mo:"host"` 1141 Vm []types.ManagedObjectReference `mo:"vm"` 1142} 1143 1144func (m *Network) Entity() *ManagedEntity { 1145 return &m.ManagedEntity 1146} 1147 1148func init() { 1149 t["Network"] = reflect.TypeOf((*Network)(nil)).Elem() 1150} 1151 1152type OpaqueNetwork struct { 1153 Network 1154} 1155 1156func init() { 1157 t["OpaqueNetwork"] = reflect.TypeOf((*OpaqueNetwork)(nil)).Elem() 1158} 1159 1160type OptionManager struct { 1161 Self types.ManagedObjectReference 1162 1163 SupportedOption []types.OptionDef `mo:"supportedOption"` 1164 Setting []types.BaseOptionValue `mo:"setting"` 1165} 1166 1167func (m OptionManager) Reference() types.ManagedObjectReference { 1168 return m.Self 1169} 1170 1171func init() { 1172 t["OptionManager"] = reflect.TypeOf((*OptionManager)(nil)).Elem() 1173} 1174 1175type OverheadMemoryManager struct { 1176 Self types.ManagedObjectReference 1177} 1178 1179func (m OverheadMemoryManager) Reference() types.ManagedObjectReference { 1180 return m.Self 1181} 1182 1183func init() { 1184 t["OverheadMemoryManager"] = reflect.TypeOf((*OverheadMemoryManager)(nil)).Elem() 1185} 1186 1187type OvfManager struct { 1188 Self types.ManagedObjectReference 1189 1190 OvfImportOption []types.OvfOptionInfo `mo:"ovfImportOption"` 1191 OvfExportOption []types.OvfOptionInfo `mo:"ovfExportOption"` 1192} 1193 1194func (m OvfManager) Reference() types.ManagedObjectReference { 1195 return m.Self 1196} 1197 1198func init() { 1199 t["OvfManager"] = reflect.TypeOf((*OvfManager)(nil)).Elem() 1200} 1201 1202type PerformanceManager struct { 1203 Self types.ManagedObjectReference 1204 1205 Description types.PerformanceDescription `mo:"description"` 1206 HistoricalInterval []types.PerfInterval `mo:"historicalInterval"` 1207 PerfCounter []types.PerfCounterInfo `mo:"perfCounter"` 1208} 1209 1210func (m PerformanceManager) Reference() types.ManagedObjectReference { 1211 return m.Self 1212} 1213 1214func init() { 1215 t["PerformanceManager"] = reflect.TypeOf((*PerformanceManager)(nil)).Elem() 1216} 1217 1218type Profile struct { 1219 Self types.ManagedObjectReference 1220 1221 Config types.BaseProfileConfigInfo `mo:"config"` 1222 Description *types.ProfileDescription `mo:"description"` 1223 Name string `mo:"name"` 1224 CreatedTime time.Time `mo:"createdTime"` 1225 ModifiedTime time.Time `mo:"modifiedTime"` 1226 Entity []types.ManagedObjectReference `mo:"entity"` 1227 ComplianceStatus string `mo:"complianceStatus"` 1228} 1229 1230func (m Profile) Reference() types.ManagedObjectReference { 1231 return m.Self 1232} 1233 1234func init() { 1235 t["Profile"] = reflect.TypeOf((*Profile)(nil)).Elem() 1236} 1237 1238type ProfileComplianceManager struct { 1239 Self types.ManagedObjectReference 1240} 1241 1242func (m ProfileComplianceManager) Reference() types.ManagedObjectReference { 1243 return m.Self 1244} 1245 1246func init() { 1247 t["ProfileComplianceManager"] = reflect.TypeOf((*ProfileComplianceManager)(nil)).Elem() 1248} 1249 1250type ProfileManager struct { 1251 Self types.ManagedObjectReference 1252 1253 Profile []types.ManagedObjectReference `mo:"profile"` 1254} 1255 1256func (m ProfileManager) Reference() types.ManagedObjectReference { 1257 return m.Self 1258} 1259 1260func init() { 1261 t["ProfileManager"] = reflect.TypeOf((*ProfileManager)(nil)).Elem() 1262} 1263 1264type PropertyCollector struct { 1265 Self types.ManagedObjectReference 1266 1267 Filter []types.ManagedObjectReference `mo:"filter"` 1268} 1269 1270func (m PropertyCollector) Reference() types.ManagedObjectReference { 1271 return m.Self 1272} 1273 1274func init() { 1275 t["PropertyCollector"] = reflect.TypeOf((*PropertyCollector)(nil)).Elem() 1276} 1277 1278type PropertyFilter struct { 1279 Self types.ManagedObjectReference 1280 1281 Spec types.PropertyFilterSpec `mo:"spec"` 1282 PartialUpdates bool `mo:"partialUpdates"` 1283} 1284 1285func (m PropertyFilter) Reference() types.ManagedObjectReference { 1286 return m.Self 1287} 1288 1289func init() { 1290 t["PropertyFilter"] = reflect.TypeOf((*PropertyFilter)(nil)).Elem() 1291} 1292 1293type ResourcePlanningManager struct { 1294 Self types.ManagedObjectReference 1295} 1296 1297func (m ResourcePlanningManager) Reference() types.ManagedObjectReference { 1298 return m.Self 1299} 1300 1301func init() { 1302 t["ResourcePlanningManager"] = reflect.TypeOf((*ResourcePlanningManager)(nil)).Elem() 1303} 1304 1305type ResourcePool struct { 1306 ManagedEntity 1307 1308 Summary types.BaseResourcePoolSummary `mo:"summary"` 1309 Runtime types.ResourcePoolRuntimeInfo `mo:"runtime"` 1310 Owner types.ManagedObjectReference `mo:"owner"` 1311 ResourcePool []types.ManagedObjectReference `mo:"resourcePool"` 1312 Vm []types.ManagedObjectReference `mo:"vm"` 1313 Config types.ResourceConfigSpec `mo:"config"` 1314 ChildConfiguration []types.ResourceConfigSpec `mo:"childConfiguration"` 1315} 1316 1317func (m *ResourcePool) Entity() *ManagedEntity { 1318 return &m.ManagedEntity 1319} 1320 1321func init() { 1322 t["ResourcePool"] = reflect.TypeOf((*ResourcePool)(nil)).Elem() 1323} 1324 1325type ScheduledTask struct { 1326 ExtensibleManagedObject 1327 1328 Info types.ScheduledTaskInfo `mo:"info"` 1329} 1330 1331func init() { 1332 t["ScheduledTask"] = reflect.TypeOf((*ScheduledTask)(nil)).Elem() 1333} 1334 1335type ScheduledTaskManager struct { 1336 Self types.ManagedObjectReference 1337 1338 ScheduledTask []types.ManagedObjectReference `mo:"scheduledTask"` 1339 Description types.ScheduledTaskDescription `mo:"description"` 1340} 1341 1342func (m ScheduledTaskManager) Reference() types.ManagedObjectReference { 1343 return m.Self 1344} 1345 1346func init() { 1347 t["ScheduledTaskManager"] = reflect.TypeOf((*ScheduledTaskManager)(nil)).Elem() 1348} 1349 1350type SearchIndex struct { 1351 Self types.ManagedObjectReference 1352} 1353 1354func (m SearchIndex) Reference() types.ManagedObjectReference { 1355 return m.Self 1356} 1357 1358func init() { 1359 t["SearchIndex"] = reflect.TypeOf((*SearchIndex)(nil)).Elem() 1360} 1361 1362type ServiceInstance struct { 1363 Self types.ManagedObjectReference 1364 1365 ServerClock time.Time `mo:"serverClock"` 1366 Capability types.Capability `mo:"capability"` 1367 Content types.ServiceContent `mo:"content"` 1368} 1369 1370func (m ServiceInstance) Reference() types.ManagedObjectReference { 1371 return m.Self 1372} 1373 1374func init() { 1375 t["ServiceInstance"] = reflect.TypeOf((*ServiceInstance)(nil)).Elem() 1376} 1377 1378type ServiceManager struct { 1379 Self types.ManagedObjectReference 1380 1381 Service []types.ServiceManagerServiceInfo `mo:"service"` 1382} 1383 1384func (m ServiceManager) Reference() types.ManagedObjectReference { 1385 return m.Self 1386} 1387 1388func init() { 1389 t["ServiceManager"] = reflect.TypeOf((*ServiceManager)(nil)).Elem() 1390} 1391 1392type SessionManager struct { 1393 Self types.ManagedObjectReference 1394 1395 SessionList []types.UserSession `mo:"sessionList"` 1396 CurrentSession *types.UserSession `mo:"currentSession"` 1397 Message *string `mo:"message"` 1398 MessageLocaleList []string `mo:"messageLocaleList"` 1399 SupportedLocaleList []string `mo:"supportedLocaleList"` 1400 DefaultLocale string `mo:"defaultLocale"` 1401} 1402 1403func (m SessionManager) Reference() types.ManagedObjectReference { 1404 return m.Self 1405} 1406 1407func init() { 1408 t["SessionManager"] = reflect.TypeOf((*SessionManager)(nil)).Elem() 1409} 1410 1411type SimpleCommand struct { 1412 Self types.ManagedObjectReference 1413 1414 EncodingType types.SimpleCommandEncoding `mo:"encodingType"` 1415 Entity types.ServiceManagerServiceInfo `mo:"entity"` 1416} 1417 1418func (m SimpleCommand) Reference() types.ManagedObjectReference { 1419 return m.Self 1420} 1421 1422func init() { 1423 t["SimpleCommand"] = reflect.TypeOf((*SimpleCommand)(nil)).Elem() 1424} 1425 1426type StoragePod struct { 1427 Folder 1428 1429 Summary *types.StoragePodSummary `mo:"summary"` 1430 PodStorageDrsEntry *types.PodStorageDrsEntry `mo:"podStorageDrsEntry"` 1431} 1432 1433func init() { 1434 t["StoragePod"] = reflect.TypeOf((*StoragePod)(nil)).Elem() 1435} 1436 1437type StorageResourceManager struct { 1438 Self types.ManagedObjectReference 1439} 1440 1441func (m StorageResourceManager) Reference() types.ManagedObjectReference { 1442 return m.Self 1443} 1444 1445func init() { 1446 t["StorageResourceManager"] = reflect.TypeOf((*StorageResourceManager)(nil)).Elem() 1447} 1448 1449type Task struct { 1450 ExtensibleManagedObject 1451 1452 Info types.TaskInfo `mo:"info"` 1453} 1454 1455func init() { 1456 t["Task"] = reflect.TypeOf((*Task)(nil)).Elem() 1457} 1458 1459type TaskHistoryCollector struct { 1460 HistoryCollector 1461 1462 LatestPage []types.TaskInfo `mo:"latestPage"` 1463} 1464 1465func init() { 1466 t["TaskHistoryCollector"] = reflect.TypeOf((*TaskHistoryCollector)(nil)).Elem() 1467} 1468 1469type TaskManager struct { 1470 Self types.ManagedObjectReference 1471 1472 RecentTask []types.ManagedObjectReference `mo:"recentTask"` 1473 Description types.TaskDescription `mo:"description"` 1474 MaxCollector int32 `mo:"maxCollector"` 1475} 1476 1477func (m TaskManager) Reference() types.ManagedObjectReference { 1478 return m.Self 1479} 1480 1481func init() { 1482 t["TaskManager"] = reflect.TypeOf((*TaskManager)(nil)).Elem() 1483} 1484 1485type UserDirectory struct { 1486 Self types.ManagedObjectReference 1487 1488 DomainList []string `mo:"domainList"` 1489} 1490 1491func (m UserDirectory) Reference() types.ManagedObjectReference { 1492 return m.Self 1493} 1494 1495func init() { 1496 t["UserDirectory"] = reflect.TypeOf((*UserDirectory)(nil)).Elem() 1497} 1498 1499type VRPResourceManager struct { 1500 Self types.ManagedObjectReference 1501} 1502 1503func (m VRPResourceManager) Reference() types.ManagedObjectReference { 1504 return m.Self 1505} 1506 1507func init() { 1508 t["VRPResourceManager"] = reflect.TypeOf((*VRPResourceManager)(nil)).Elem() 1509} 1510 1511type View struct { 1512 Self types.ManagedObjectReference 1513} 1514 1515func (m View) Reference() types.ManagedObjectReference { 1516 return m.Self 1517} 1518 1519func init() { 1520 t["View"] = reflect.TypeOf((*View)(nil)).Elem() 1521} 1522 1523type ViewManager struct { 1524 Self types.ManagedObjectReference 1525 1526 ViewList []types.ManagedObjectReference `mo:"viewList"` 1527} 1528 1529func (m ViewManager) Reference() types.ManagedObjectReference { 1530 return m.Self 1531} 1532 1533func init() { 1534 t["ViewManager"] = reflect.TypeOf((*ViewManager)(nil)).Elem() 1535} 1536 1537type VirtualApp struct { 1538 ResourcePool 1539 1540 ParentFolder *types.ManagedObjectReference `mo:"parentFolder"` 1541 Datastore []types.ManagedObjectReference `mo:"datastore"` 1542 Network []types.ManagedObjectReference `mo:"network"` 1543 VAppConfig *types.VAppConfigInfo `mo:"vAppConfig"` 1544 ParentVApp *types.ManagedObjectReference `mo:"parentVApp"` 1545 ChildLink []types.VirtualAppLinkInfo `mo:"childLink"` 1546} 1547 1548func init() { 1549 t["VirtualApp"] = reflect.TypeOf((*VirtualApp)(nil)).Elem() 1550} 1551 1552type VirtualDiskManager struct { 1553 Self types.ManagedObjectReference 1554} 1555 1556func (m VirtualDiskManager) Reference() types.ManagedObjectReference { 1557 return m.Self 1558} 1559 1560func init() { 1561 t["VirtualDiskManager"] = reflect.TypeOf((*VirtualDiskManager)(nil)).Elem() 1562} 1563 1564type VirtualMachine struct { 1565 ManagedEntity 1566 1567 Capability types.VirtualMachineCapability `mo:"capability"` 1568 Config *types.VirtualMachineConfigInfo `mo:"config"` 1569 Layout *types.VirtualMachineFileLayout `mo:"layout"` 1570 LayoutEx *types.VirtualMachineFileLayoutEx `mo:"layoutEx"` 1571 Storage *types.VirtualMachineStorageInfo `mo:"storage"` 1572 EnvironmentBrowser types.ManagedObjectReference `mo:"environmentBrowser"` 1573 ResourcePool *types.ManagedObjectReference `mo:"resourcePool"` 1574 ParentVApp *types.ManagedObjectReference `mo:"parentVApp"` 1575 ResourceConfig *types.ResourceConfigSpec `mo:"resourceConfig"` 1576 Runtime types.VirtualMachineRuntimeInfo `mo:"runtime"` 1577 Guest *types.GuestInfo `mo:"guest"` 1578 Summary types.VirtualMachineSummary `mo:"summary"` 1579 Datastore []types.ManagedObjectReference `mo:"datastore"` 1580 Network []types.ManagedObjectReference `mo:"network"` 1581 Snapshot *types.VirtualMachineSnapshotInfo `mo:"snapshot"` 1582 RootSnapshot []types.ManagedObjectReference `mo:"rootSnapshot"` 1583 GuestHeartbeatStatus types.ManagedEntityStatus `mo:"guestHeartbeatStatus"` 1584} 1585 1586func (m *VirtualMachine) Entity() *ManagedEntity { 1587 return &m.ManagedEntity 1588} 1589 1590func init() { 1591 t["VirtualMachine"] = reflect.TypeOf((*VirtualMachine)(nil)).Elem() 1592} 1593 1594type VirtualMachineCompatibilityChecker struct { 1595 Self types.ManagedObjectReference 1596} 1597 1598func (m VirtualMachineCompatibilityChecker) Reference() types.ManagedObjectReference { 1599 return m.Self 1600} 1601 1602func init() { 1603 t["VirtualMachineCompatibilityChecker"] = reflect.TypeOf((*VirtualMachineCompatibilityChecker)(nil)).Elem() 1604} 1605 1606type VirtualMachineProvisioningChecker struct { 1607 Self types.ManagedObjectReference 1608} 1609 1610func (m VirtualMachineProvisioningChecker) Reference() types.ManagedObjectReference { 1611 return m.Self 1612} 1613 1614func init() { 1615 t["VirtualMachineProvisioningChecker"] = reflect.TypeOf((*VirtualMachineProvisioningChecker)(nil)).Elem() 1616} 1617 1618type VirtualMachineSnapshot struct { 1619 ExtensibleManagedObject 1620 1621 Config types.VirtualMachineConfigInfo `mo:"config"` 1622 ChildSnapshot []types.ManagedObjectReference `mo:"childSnapshot"` 1623 Vm types.ManagedObjectReference `mo:"vm"` 1624} 1625 1626func init() { 1627 t["VirtualMachineSnapshot"] = reflect.TypeOf((*VirtualMachineSnapshot)(nil)).Elem() 1628} 1629 1630type VirtualizationManager struct { 1631 Self types.ManagedObjectReference 1632} 1633 1634func (m VirtualizationManager) Reference() types.ManagedObjectReference { 1635 return m.Self 1636} 1637 1638func init() { 1639 t["VirtualizationManager"] = reflect.TypeOf((*VirtualizationManager)(nil)).Elem() 1640} 1641 1642type VmwareDistributedVirtualSwitch struct { 1643 DistributedVirtualSwitch 1644} 1645 1646func init() { 1647 t["VmwareDistributedVirtualSwitch"] = reflect.TypeOf((*VmwareDistributedVirtualSwitch)(nil)).Elem() 1648} 1649 1650type VsanUpgradeSystem struct { 1651 Self types.ManagedObjectReference 1652} 1653 1654func (m VsanUpgradeSystem) Reference() types.ManagedObjectReference { 1655 return m.Self 1656} 1657 1658func init() { 1659 t["VsanUpgradeSystem"] = reflect.TypeOf((*VsanUpgradeSystem)(nil)).Elem() 1660} 1661