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