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