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