if.go

/*
Copyright (c) 2014-2018 VMware, Inc. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package types

import "reflect"

func (b *Action) GetAction() *Action { return b }

type BaseAction interface {
	GetAction() *Action
}

func init() {
	t["BaseAction"] = reflect.TypeOf((*Action)(nil)).Elem()
}

func (b *ActiveDirectoryFault) GetActiveDirectoryFault() *ActiveDirectoryFault { return b }

type BaseActiveDirectoryFault interface {
	GetActiveDirectoryFault() *ActiveDirectoryFault
}

func init() {
	t["BaseActiveDirectoryFault"] = reflect.TypeOf((*ActiveDirectoryFault)(nil)).Elem()
}

func (b *AlarmAction) GetAlarmAction() *AlarmAction { return b }

type BaseAlarmAction interface {
	GetAlarmAction() *AlarmAction
}

func init() {
	t["BaseAlarmAction"] = reflect.TypeOf((*AlarmAction)(nil)).Elem()
}

func (b *AlarmEvent) GetAlarmEvent() *AlarmEvent { return b }

type BaseAlarmEvent interface {
	GetAlarmEvent() *AlarmEvent
}

func init() {
	t["BaseAlarmEvent"] = reflect.TypeOf((*AlarmEvent)(nil)).Elem()
}

func (b *AlarmExpression) GetAlarmExpression() *AlarmExpression { return b }

type BaseAlarmExpression interface {
	GetAlarmExpression() *AlarmExpression
}

func init() {
	t["BaseAlarmExpression"] = reflect.TypeOf((*AlarmExpression)(nil)).Elem()
}

func (b *AlarmSpec) GetAlarmSpec() *AlarmSpec { return b }

type BaseAlarmSpec interface {
	GetAlarmSpec() *AlarmSpec
}

func init() {
	t["BaseAlarmSpec"] = reflect.TypeOf((*AlarmSpec)(nil)).Elem()
}

func (b *AnswerFileCreateSpec) GetAnswerFileCreateSpec() *AnswerFileCreateSpec { return b }

type BaseAnswerFileCreateSpec interface {
	GetAnswerFileCreateSpec() *AnswerFileCreateSpec
}

func init() {
	t["BaseAnswerFileCreateSpec"] = reflect.TypeOf((*AnswerFileCreateSpec)(nil)).Elem()
}

func (b *ApplyProfile) GetApplyProfile() *ApplyProfile { return b }

type BaseApplyProfile interface {
	GetApplyProfile() *ApplyProfile
}

func init() {
	t["BaseApplyProfile"] = reflect.TypeOf((*ApplyProfile)(nil)).Elem()
}

func (b *ArrayUpdateSpec) GetArrayUpdateSpec() *ArrayUpdateSpec { return b }

type BaseArrayUpdateSpec interface {
	GetArrayUpdateSpec() *ArrayUpdateSpec
}

func init() {
	t["BaseArrayUpdateSpec"] = reflect.TypeOf((*ArrayUpdateSpec)(nil)).Elem()
}

func (b *AuthorizationEvent) GetAuthorizationEvent() *AuthorizationEvent { return b }

type BaseAuthorizationEvent interface {
	GetAuthorizationEvent() *AuthorizationEvent
}

func init() {
	t["BaseAuthorizationEvent"] = reflect.TypeOf((*AuthorizationEvent)(nil)).Elem()
}

func (b *BaseConfigInfo) GetBaseConfigInfo() *BaseConfigInfo { return b }

type BaseBaseConfigInfo interface {
	GetBaseConfigInfo() *BaseConfigInfo
}

func init() {
	t["BaseBaseConfigInfo"] = reflect.TypeOf((*BaseConfigInfo)(nil)).Elem()
}

func (b *BaseConfigInfoBackingInfo) GetBaseConfigInfoBackingInfo() *BaseConfigInfoBackingInfo {
	return b
}

type BaseBaseConfigInfoBackingInfo interface {
	GetBaseConfigInfoBackingInfo() *BaseConfigInfoBackingInfo
}

func init() {
	t["BaseBaseConfigInfoBackingInfo"] = reflect.TypeOf((*BaseConfigInfoBackingInfo)(nil)).Elem()
}

func (b *BaseConfigInfoFileBackingInfo) GetBaseConfigInfoFileBackingInfo() *BaseConfigInfoFileBackingInfo {
	return b
}

type BaseBaseConfigInfoFileBackingInfo interface {
	GetBaseConfigInfoFileBackingInfo() *BaseConfigInfoFileBackingInfo
}

func init() {
	t["BaseBaseConfigInfoFileBackingInfo"] = reflect.TypeOf((*BaseConfigInfoFileBackingInfo)(nil)).Elem()
}

func (b *CannotAccessNetwork) GetCannotAccessNetwork() *CannotAccessNetwork { return b }

type BaseCannotAccessNetwork interface {
	GetCannotAccessNetwork() *CannotAccessNetwork
}

func init() {
	t["BaseCannotAccessNetwork"] = reflect.TypeOf((*CannotAccessNetwork)(nil)).Elem()
}

func (b *CannotAccessVmComponent) GetCannotAccessVmComponent() *CannotAccessVmComponent { return b }

type BaseCannotAccessVmComponent interface {
	GetCannotAccessVmComponent() *CannotAccessVmComponent
}

func init() {
	t["BaseCannotAccessVmComponent"] = reflect.TypeOf((*CannotAccessVmComponent)(nil)).Elem()
}

func (b *CannotAccessVmDevice) GetCannotAccessVmDevice() *CannotAccessVmDevice { return b }

type BaseCannotAccessVmDevice interface {
	GetCannotAccessVmDevice() *CannotAccessVmDevice
}

func init() {
	t["BaseCannotAccessVmDevice"] = reflect.TypeOf((*CannotAccessVmDevice)(nil)).Elem()
}

func (b *CannotAccessVmDisk) GetCannotAccessVmDisk() *CannotAccessVmDisk { return b }

type BaseCannotAccessVmDisk interface {
	GetCannotAccessVmDisk() *CannotAccessVmDisk
}

func init() {
	t["BaseCannotAccessVmDisk"] = reflect.TypeOf((*CannotAccessVmDisk)(nil)).Elem()
}

func (b *CannotMoveVsanEnabledHost) GetCannotMoveVsanEnabledHost() *CannotMoveVsanEnabledHost {
	return b
}

type BaseCannotMoveVsanEnabledHost interface {
	GetCannotMoveVsanEnabledHost() *CannotMoveVsanEnabledHost
}

func init() {
	t["BaseCannotMoveVsanEnabledHost"] = reflect.TypeOf((*CannotMoveVsanEnabledHost)(nil)).Elem()
}

func (b *ClusterAction) GetClusterAction() *ClusterAction { return b }

type BaseClusterAction interface {
	GetClusterAction() *ClusterAction
}

func init() {
	t["BaseClusterAction"] = reflect.TypeOf((*ClusterAction)(nil)).Elem()
}

func (b *ClusterComputeResourceValidationResultBase) GetClusterComputeResourceValidationResultBase() *ClusterComputeResourceValidationResultBase {
	return b
}

type BaseClusterComputeResourceValidationResultBase interface {
	GetClusterComputeResourceValidationResultBase() *ClusterComputeResourceValidationResultBase
}

func init() {
	t["BaseClusterComputeResourceValidationResultBase"] = reflect.TypeOf((*ClusterComputeResourceValidationResultBase)(nil)).Elem()
}

func (b *ClusterDasAdmissionControlInfo) GetClusterDasAdmissionControlInfo() *ClusterDasAdmissionControlInfo {
	return b
}

type BaseClusterDasAdmissionControlInfo interface {
	GetClusterDasAdmissionControlInfo() *ClusterDasAdmissionControlInfo
}

func init() {
	t["BaseClusterDasAdmissionControlInfo"] = reflect.TypeOf((*ClusterDasAdmissionControlInfo)(nil)).Elem()
}

func (b *ClusterDasAdmissionControlPolicy) GetClusterDasAdmissionControlPolicy() *ClusterDasAdmissionControlPolicy {
	return b
}

type BaseClusterDasAdmissionControlPolicy interface {
	GetClusterDasAdmissionControlPolicy() *ClusterDasAdmissionControlPolicy
}

func init() {
	t["BaseClusterDasAdmissionControlPolicy"] = reflect.TypeOf((*ClusterDasAdmissionControlPolicy)(nil)).Elem()
}

func (b *ClusterDasAdvancedRuntimeInfo) GetClusterDasAdvancedRuntimeInfo() *ClusterDasAdvancedRuntimeInfo {
	return b
}

type BaseClusterDasAdvancedRuntimeInfo interface {
	GetClusterDasAdvancedRuntimeInfo() *ClusterDasAdvancedRuntimeInfo
}

func init() {
	t["BaseClusterDasAdvancedRuntimeInfo"] = reflect.TypeOf((*ClusterDasAdvancedRuntimeInfo)(nil)).Elem()
}

func (b *ClusterDasData) GetClusterDasData() *ClusterDasData { return b }

type BaseClusterDasData interface {
	GetClusterDasData() *ClusterDasData
}

func init() {
	t["BaseClusterDasData"] = reflect.TypeOf((*ClusterDasData)(nil)).Elem()
}

func (b *ClusterDasHostInfo) GetClusterDasHostInfo() *ClusterDasHostInfo { return b }

type BaseClusterDasHostInfo interface {
	GetClusterDasHostInfo() *ClusterDasHostInfo
}

func init() {
	t["BaseClusterDasHostInfo"] = reflect.TypeOf((*ClusterDasHostInfo)(nil)).Elem()
}

func (b *ClusterDrsFaultsFaultsByVm) GetClusterDrsFaultsFaultsByVm() *ClusterDrsFaultsFaultsByVm {
	return b
}

type BaseClusterDrsFaultsFaultsByVm interface {
	GetClusterDrsFaultsFaultsByVm() *ClusterDrsFaultsFaultsByVm
}

func init() {
	t["BaseClusterDrsFaultsFaultsByVm"] = reflect.TypeOf((*ClusterDrsFaultsFaultsByVm)(nil)).Elem()
}

func (b *ClusterEvent) GetClusterEvent() *ClusterEvent { return b }

type BaseClusterEvent interface {
	GetClusterEvent() *ClusterEvent
}

func init() {
	t["BaseClusterEvent"] = reflect.TypeOf((*ClusterEvent)(nil)).Elem()
}

func (b *ClusterGroupInfo) GetClusterGroupInfo() *ClusterGroupInfo { return b }

type BaseClusterGroupInfo interface {
	GetClusterGroupInfo() *ClusterGroupInfo
}

func init() {
	t["BaseClusterGroupInfo"] = reflect.TypeOf((*ClusterGroupInfo)(nil)).Elem()
}

func (b *ClusterOvercommittedEvent) GetClusterOvercommittedEvent() *ClusterOvercommittedEvent {
	return b
}

type BaseClusterOvercommittedEvent interface {
	GetClusterOvercommittedEvent() *ClusterOvercommittedEvent
}

func init() {
	t["BaseClusterOvercommittedEvent"] = reflect.TypeOf((*ClusterOvercommittedEvent)(nil)).Elem()
}

func (b *ClusterProfileConfigSpec) GetClusterProfileConfigSpec() *ClusterProfileConfigSpec { return b }

type BaseClusterProfileConfigSpec interface {
	GetClusterProfileConfigSpec() *ClusterProfileConfigSpec
}

func init() {
	t["BaseClusterProfileConfigSpec"] = reflect.TypeOf((*ClusterProfileConfigSpec)(nil)).Elem()
}

func (b *ClusterProfileCreateSpec) GetClusterProfileCreateSpec() *ClusterProfileCreateSpec { return b }

type BaseClusterProfileCreateSpec interface {
	GetClusterProfileCreateSpec() *ClusterProfileCreateSpec
}

func init() {
	t["BaseClusterProfileCreateSpec"] = reflect.TypeOf((*ClusterProfileCreateSpec)(nil)).Elem()
}

func (b *ClusterRuleInfo) GetClusterRuleInfo() *ClusterRuleInfo { return b }

type BaseClusterRuleInfo interface {
	GetClusterRuleInfo() *ClusterRuleInfo
}

func init() {
	t["BaseClusterRuleInfo"] = reflect.TypeOf((*ClusterRuleInfo)(nil)).Elem()
}

func (b *ClusterSlotPolicy) GetClusterSlotPolicy() *ClusterSlotPolicy { return b }

type BaseClusterSlotPolicy interface {
	GetClusterSlotPolicy() *ClusterSlotPolicy
}

func init() {
	t["BaseClusterSlotPolicy"] = reflect.TypeOf((*ClusterSlotPolicy)(nil)).Elem()
}

func (b *ClusterStatusChangedEvent) GetClusterStatusChangedEvent() *ClusterStatusChangedEvent {
	return b
}

type BaseClusterStatusChangedEvent interface {
	GetClusterStatusChangedEvent() *ClusterStatusChangedEvent
}

func init() {
	t["BaseClusterStatusChangedEvent"] = reflect.TypeOf((*ClusterStatusChangedEvent)(nil)).Elem()
}

func (b *ComputeResourceConfigInfo) GetComputeResourceConfigInfo() *ComputeResourceConfigInfo {
	return b
}

type BaseComputeResourceConfigInfo interface {
	GetComputeResourceConfigInfo() *ComputeResourceConfigInfo
}

func init() {
	t["BaseComputeResourceConfigInfo"] = reflect.TypeOf((*ComputeResourceConfigInfo)(nil)).Elem()
}

func (b *ComputeResourceConfigSpec) GetComputeResourceConfigSpec() *ComputeResourceConfigSpec {
	return b
}

type BaseComputeResourceConfigSpec interface {
	GetComputeResourceConfigSpec() *ComputeResourceConfigSpec
}

func init() {
	t["BaseComputeResourceConfigSpec"] = reflect.TypeOf((*ComputeResourceConfigSpec)(nil)).Elem()
}

func (b *ComputeResourceSummary) GetComputeResourceSummary() *ComputeResourceSummary { return b }

type BaseComputeResourceSummary interface {
	GetComputeResourceSummary() *ComputeResourceSummary
}

func init() {
	t["BaseComputeResourceSummary"] = reflect.TypeOf((*ComputeResourceSummary)(nil)).Elem()
}

func (b *CpuIncompatible) GetCpuIncompatible() *CpuIncompatible { return b }

type BaseCpuIncompatible interface {
	GetCpuIncompatible() *CpuIncompatible
}

func init() {
	t["BaseCpuIncompatible"] = reflect.TypeOf((*CpuIncompatible)(nil)).Elem()
}

func (b *CryptoSpec) GetCryptoSpec() *CryptoSpec { return b }

type BaseCryptoSpec interface {
	GetCryptoSpec() *CryptoSpec
}

func init() {
	t["BaseCryptoSpec"] = reflect.TypeOf((*CryptoSpec)(nil)).Elem()
}

func (b *CryptoSpecNoOp) GetCryptoSpecNoOp() *CryptoSpecNoOp { return b }

type BaseCryptoSpecNoOp interface {
	GetCryptoSpecNoOp() *CryptoSpecNoOp
}

func init() {
	t["BaseCryptoSpecNoOp"] = reflect.TypeOf((*CryptoSpecNoOp)(nil)).Elem()
}

func (b *CustomFieldDefEvent) GetCustomFieldDefEvent() *CustomFieldDefEvent { return b }

type BaseCustomFieldDefEvent interface {
	GetCustomFieldDefEvent() *CustomFieldDefEvent
}

func init() {
	t["BaseCustomFieldDefEvent"] = reflect.TypeOf((*CustomFieldDefEvent)(nil)).Elem()
}

func (b *CustomFieldEvent) GetCustomFieldEvent() *CustomFieldEvent { return b }

type BaseCustomFieldEvent interface {
	GetCustomFieldEvent() *CustomFieldEvent
}

func init() {
	t["BaseCustomFieldEvent"] = reflect.TypeOf((*CustomFieldEvent)(nil)).Elem()
}

func (b *CustomFieldValue) GetCustomFieldValue() *CustomFieldValue { return b }

type BaseCustomFieldValue interface {
	GetCustomFieldValue() *CustomFieldValue
}

func init() {
	t["BaseCustomFieldValue"] = reflect.TypeOf((*CustomFieldValue)(nil)).Elem()
}

func (b *CustomizationEvent) GetCustomizationEvent() *CustomizationEvent { return b }

type BaseCustomizationEvent interface {
	GetCustomizationEvent() *CustomizationEvent
}

func init() {
	t["BaseCustomizationEvent"] = reflect.TypeOf((*CustomizationEvent)(nil)).Elem()
}

func (b *CustomizationFailed) GetCustomizationFailed() *CustomizationFailed { return b }

type BaseCustomizationFailed interface {
	GetCustomizationFailed() *CustomizationFailed
}

func init() {
	t["BaseCustomizationFailed"] = reflect.TypeOf((*CustomizationFailed)(nil)).Elem()
}

func (b *CustomizationFault) GetCustomizationFault() *CustomizationFault { return b }

type BaseCustomizationFault interface {
	GetCustomizationFault() *CustomizationFault
}

func init() {
	t["BaseCustomizationFault"] = reflect.TypeOf((*CustomizationFault)(nil)).Elem()
}

func (b *CustomizationIdentitySettings) GetCustomizationIdentitySettings() *CustomizationIdentitySettings {
	return b
}

type BaseCustomizationIdentitySettings interface {
	GetCustomizationIdentitySettings() *CustomizationIdentitySettings
}

func init() {
	t["BaseCustomizationIdentitySettings"] = reflect.TypeOf((*CustomizationIdentitySettings)(nil)).Elem()
}

func (b *CustomizationIpGenerator) GetCustomizationIpGenerator() *CustomizationIpGenerator { return b }

type BaseCustomizationIpGenerator interface {
	GetCustomizationIpGenerator() *CustomizationIpGenerator
}

func init() {
	t["BaseCustomizationIpGenerator"] = reflect.TypeOf((*CustomizationIpGenerator)(nil)).Elem()
}

func (b *CustomizationIpV6Generator) GetCustomizationIpV6Generator() *CustomizationIpV6Generator {
	return b
}

type BaseCustomizationIpV6Generator interface {
	GetCustomizationIpV6Generator() *CustomizationIpV6Generator
}

func init() {
	t["BaseCustomizationIpV6Generator"] = reflect.TypeOf((*CustomizationIpV6Generator)(nil)).Elem()
}

func (b *CustomizationName) GetCustomizationName() *CustomizationName { return b }

type BaseCustomizationName interface {
	GetCustomizationName() *CustomizationName
}

func init() {
	t["BaseCustomizationName"] = reflect.TypeOf((*CustomizationName)(nil)).Elem()
}

func (b *CustomizationOptions) GetCustomizationOptions() *CustomizationOptions { return b }

type BaseCustomizationOptions interface {
	GetCustomizationOptions() *CustomizationOptions
}

func init() {
	t["BaseCustomizationOptions"] = reflect.TypeOf((*CustomizationOptions)(nil)).Elem()
}

func (b *DVPortSetting) GetDVPortSetting() *DVPortSetting { return b }

type BaseDVPortSetting interface {
	GetDVPortSetting() *DVPortSetting
}

func init() {
	t["BaseDVPortSetting"] = reflect.TypeOf((*DVPortSetting)(nil)).Elem()
}

func (b *DVPortgroupEvent) GetDVPortgroupEvent() *DVPortgroupEvent { return b }

type BaseDVPortgroupEvent interface {
	GetDVPortgroupEvent() *DVPortgroupEvent
}

func init() {
	t["BaseDVPortgroupEvent"] = reflect.TypeOf((*DVPortgroupEvent)(nil)).Elem()
}

func (b *DVPortgroupPolicy) GetDVPortgroupPolicy() *DVPortgroupPolicy { return b }

type BaseDVPortgroupPolicy interface {
	GetDVPortgroupPolicy() *DVPortgroupPolicy
}

func init() {
	t["BaseDVPortgroupPolicy"] = reflect.TypeOf((*DVPortgroupPolicy)(nil)).Elem()
}

func (b *DVSConfigInfo) GetDVSConfigInfo() *DVSConfigInfo { return b }

type BaseDVSConfigInfo interface {
	GetDVSConfigInfo() *DVSConfigInfo
}

func init() {
	t["BaseDVSConfigInfo"] = reflect.TypeOf((*DVSConfigInfo)(nil)).Elem()
}

func (b *DVSConfigSpec) GetDVSConfigSpec() *DVSConfigSpec { return b }

type BaseDVSConfigSpec interface {
	GetDVSConfigSpec() *DVSConfigSpec
}

func init() {
	t["BaseDVSConfigSpec"] = reflect.TypeOf((*DVSConfigSpec)(nil)).Elem()
}

func (b *DVSFeatureCapability) GetDVSFeatureCapability() *DVSFeatureCapability { return b }

type BaseDVSFeatureCapability interface {
	GetDVSFeatureCapability() *DVSFeatureCapability
}

func init() {
	t["BaseDVSFeatureCapability"] = reflect.TypeOf((*DVSFeatureCapability)(nil)).Elem()
}

func (b *DVSHealthCheckCapability) GetDVSHealthCheckCapability() *DVSHealthCheckCapability { return b }

type BaseDVSHealthCheckCapability interface {
	GetDVSHealthCheckCapability() *DVSHealthCheckCapability
}

func init() {
	t["BaseDVSHealthCheckCapability"] = reflect.TypeOf((*DVSHealthCheckCapability)(nil)).Elem()
}

func (b *DVSHealthCheckConfig) GetDVSHealthCheckConfig() *DVSHealthCheckConfig { return b }

type BaseDVSHealthCheckConfig interface {
	GetDVSHealthCheckConfig() *DVSHealthCheckConfig
}

func init() {
	t["BaseDVSHealthCheckConfig"] = reflect.TypeOf((*DVSHealthCheckConfig)(nil)).Elem()
}

func (b *DVSUplinkPortPolicy) GetDVSUplinkPortPolicy() *DVSUplinkPortPolicy { return b }

type BaseDVSUplinkPortPolicy interface {
	GetDVSUplinkPortPolicy() *DVSUplinkPortPolicy
}

func init() {
	t["BaseDVSUplinkPortPolicy"] = reflect.TypeOf((*DVSUplinkPortPolicy)(nil)).Elem()
}

func (b *DailyTaskScheduler) GetDailyTaskScheduler() *DailyTaskScheduler { return b }

type BaseDailyTaskScheduler interface {
	GetDailyTaskScheduler() *DailyTaskScheduler
}

func init() {
	t["BaseDailyTaskScheduler"] = reflect.TypeOf((*DailyTaskScheduler)(nil)).Elem()
}

func (b *DatacenterEvent) GetDatacenterEvent() *DatacenterEvent { return b }

type BaseDatacenterEvent interface {
	GetDatacenterEvent() *DatacenterEvent
}

func init() {
	t["BaseDatacenterEvent"] = reflect.TypeOf((*DatacenterEvent)(nil)).Elem()
}

func (b *DatastoreEvent) GetDatastoreEvent() *DatastoreEvent { return b }

type BaseDatastoreEvent interface {
	GetDatastoreEvent() *DatastoreEvent
}

func init() {
	t["BaseDatastoreEvent"] = reflect.TypeOf((*DatastoreEvent)(nil)).Elem()
}

func (b *DatastoreFileEvent) GetDatastoreFileEvent() *DatastoreFileEvent { return b }

type BaseDatastoreFileEvent interface {
	GetDatastoreFileEvent() *DatastoreFileEvent
}

func init() {
	t["BaseDatastoreFileEvent"] = reflect.TypeOf((*DatastoreFileEvent)(nil)).Elem()
}

func (b *DatastoreInfo) GetDatastoreInfo() *DatastoreInfo { return b }

type BaseDatastoreInfo interface {
	GetDatastoreInfo() *DatastoreInfo
}

func init() {
	t["BaseDatastoreInfo"] = reflect.TypeOf((*DatastoreInfo)(nil)).Elem()
}

func (b *DatastoreNotWritableOnHost) GetDatastoreNotWritableOnHost() *DatastoreNotWritableOnHost {
	return b
}

type BaseDatastoreNotWritableOnHost interface {
	GetDatastoreNotWritableOnHost() *DatastoreNotWritableOnHost
}

func init() {
	t["BaseDatastoreNotWritableOnHost"] = reflect.TypeOf((*DatastoreNotWritableOnHost)(nil)).Elem()
}

func (b *Description) GetDescription() *Description { return b }

type BaseDescription interface {
	GetDescription() *Description
}

func init() {
	t["BaseDescription"] = reflect.TypeOf((*Description)(nil)).Elem()
}

func (b *DeviceBackingNotSupported) GetDeviceBackingNotSupported() *DeviceBackingNotSupported {
	return b
}

type BaseDeviceBackingNotSupported interface {
	GetDeviceBackingNotSupported() *DeviceBackingNotSupported
}

func init() {
	t["BaseDeviceBackingNotSupported"] = reflect.TypeOf((*DeviceBackingNotSupported)(nil)).Elem()
}

func (b *DeviceNotSupported) GetDeviceNotSupported() *DeviceNotSupported { return b }

type BaseDeviceNotSupported interface {
	GetDeviceNotSupported() *DeviceNotSupported
}

func init() {
	t["BaseDeviceNotSupported"] = reflect.TypeOf((*DeviceNotSupported)(nil)).Elem()
}

func (b *DiskNotSupported) GetDiskNotSupported() *DiskNotSupported { return b }

type BaseDiskNotSupported interface {
	GetDiskNotSupported() *DiskNotSupported
}

func init() {
	t["BaseDiskNotSupported"] = reflect.TypeOf((*DiskNotSupported)(nil)).Elem()
}

func (b *DistributedVirtualSwitchHostMemberBacking) GetDistributedVirtualSwitchHostMemberBacking() *DistributedVirtualSwitchHostMemberBacking {
	return b
}

type BaseDistributedVirtualSwitchHostMemberBacking interface {
	GetDistributedVirtualSwitchHostMemberBacking() *DistributedVirtualSwitchHostMemberBacking
}

func init() {
	t["BaseDistributedVirtualSwitchHostMemberBacking"] = reflect.TypeOf((*DistributedVirtualSwitchHostMemberBacking)(nil)).Elem()
}

func (b *DistributedVirtualSwitchManagerHostDvsFilterSpec) GetDistributedVirtualSwitchManagerHostDvsFilterSpec() *DistributedVirtualSwitchManagerHostDvsFilterSpec {
	return b
}

type BaseDistributedVirtualSwitchManagerHostDvsFilterSpec interface {
	GetDistributedVirtualSwitchManagerHostDvsFilterSpec() *DistributedVirtualSwitchManagerHostDvsFilterSpec
}

func init() {
	t["BaseDistributedVirtualSwitchManagerHostDvsFilterSpec"] = reflect.TypeOf((*DistributedVirtualSwitchManagerHostDvsFilterSpec)(nil)).Elem()
}

func (b *DvsEvent) GetDvsEvent() *DvsEvent { return b }

type BaseDvsEvent interface {
	GetDvsEvent() *DvsEvent
}

func init() {
	t["BaseDvsEvent"] = reflect.TypeOf((*DvsEvent)(nil)).Elem()
}

func (b *DvsFault) GetDvsFault() *DvsFault { return b }

type BaseDvsFault interface {
	GetDvsFault() *DvsFault
}

func init() {
	t["BaseDvsFault"] = reflect.TypeOf((*DvsFault)(nil)).Elem()
}

func (b *DvsFilterConfig) GetDvsFilterConfig() *DvsFilterConfig { return b }

type BaseDvsFilterConfig interface {
	GetDvsFilterConfig() *DvsFilterConfig
	GetDvsTrafficFilterConfig() *DvsTrafficFilterConfig
}

func init() {
	t["BaseDvsFilterConfig"] = reflect.TypeOf((*DvsFilterConfig)(nil)).Elem()
}

func (b *DvsHealthStatusChangeEvent) GetDvsHealthStatusChangeEvent() *DvsHealthStatusChangeEvent {
	return b
}

type BaseDvsHealthStatusChangeEvent interface {
	GetDvsHealthStatusChangeEvent() *DvsHealthStatusChangeEvent
}

func init() {
	t["BaseDvsHealthStatusChangeEvent"] = reflect.TypeOf((*DvsHealthStatusChangeEvent)(nil)).Elem()
}

func (b *DvsIpPort) GetDvsIpPort() *DvsIpPort { return b }

type BaseDvsIpPort interface {
	GetDvsIpPort() *DvsIpPort
}

func init() {
	t["BaseDvsIpPort"] = reflect.TypeOf((*DvsIpPort)(nil)).Elem()
}

func (b *DvsNetworkRuleAction) GetDvsNetworkRuleAction() *DvsNetworkRuleAction { return b }

type BaseDvsNetworkRuleAction interface {
	GetDvsNetworkRuleAction() *DvsNetworkRuleAction
}

func init() {
	t["BaseDvsNetworkRuleAction"] = reflect.TypeOf((*DvsNetworkRuleAction)(nil)).Elem()
}

func (b *DvsNetworkRuleQualifier) GetDvsNetworkRuleQualifier() *DvsNetworkRuleQualifier { return b }

type BaseDvsNetworkRuleQualifier interface {
	GetDvsNetworkRuleQualifier() *DvsNetworkRuleQualifier
	GetDvsIpNetworkRuleQualifier() *DvsIpNetworkRuleQualifier
}

func init() {
	t["BaseDvsNetworkRuleQualifier"] = reflect.TypeOf((*DvsNetworkRuleQualifier)(nil)).Elem()
}

func (b *DvsIpNetworkRuleQualifier) GetDvsIpNetworkRuleQualifier() *DvsIpNetworkRuleQualifier {
	return b
}

type BaseDvsIpNetworkRuleQualifier interface {
	GetDvsIpNetworkRuleQualifier() *DvsIpNetworkRuleQualifier
}

func (b *DvsTrafficFilterConfig) GetDvsTrafficFilterConfig() *DvsTrafficFilterConfig { return b }

type BaseDvsTrafficFilterConfig interface {
	GetDvsTrafficFilterConfig() *DvsTrafficFilterConfig
}

func init() {
	t["BaseDvsTrafficFilterConfig"] = reflect.TypeOf((*DvsTrafficFilterConfig)(nil)).Elem()
}

func (b *DvsVNicProfile) GetDvsVNicProfile() *DvsVNicProfile { return b }

type BaseDvsVNicProfile interface {
	GetDvsVNicProfile() *DvsVNicProfile
}

func init() {
	t["BaseDvsVNicProfile"] = reflect.TypeOf((*DvsVNicProfile)(nil)).Elem()
}

func (b *DynamicData) GetDynamicData() *DynamicData { return b }

type BaseDynamicData interface {
	GetDynamicData() *DynamicData
}

func init() {
	t["BaseDynamicData"] = reflect.TypeOf((*DynamicData)(nil)).Elem()
}

func (b *EVCAdmissionFailed) GetEVCAdmissionFailed() *EVCAdmissionFailed { return b }

type BaseEVCAdmissionFailed interface {
	GetEVCAdmissionFailed() *EVCAdmissionFailed
}

func init() {
	t["BaseEVCAdmissionFailed"] = reflect.TypeOf((*EVCAdmissionFailed)(nil)).Elem()
}

func (b *EVCConfigFault) GetEVCConfigFault() *EVCConfigFault { return b }

type BaseEVCConfigFault interface {
	GetEVCConfigFault() *EVCConfigFault
}

func init() {
	t["BaseEVCConfigFault"] = reflect.TypeOf((*EVCConfigFault)(nil)).Elem()
}

func (b *ElementDescription) GetElementDescription() *ElementDescription { return b }

type BaseElementDescription interface {
	GetElementDescription() *ElementDescription
}

func init() {
	t["BaseElementDescription"] = reflect.TypeOf((*ElementDescription)(nil)).Elem()
}

func (b *EnteredStandbyModeEvent) GetEnteredStandbyModeEvent() *EnteredStandbyModeEvent { return b }

type BaseEnteredStandbyModeEvent interface {
	GetEnteredStandbyModeEvent() *EnteredStandbyModeEvent
}

func init() {
	t["BaseEnteredStandbyModeEvent"] = reflect.TypeOf((*EnteredStandbyModeEvent)(nil)).Elem()
}

func (b *EnteringStandbyModeEvent) GetEnteringStandbyModeEvent() *EnteringStandbyModeEvent { return b }

type BaseEnteringStandbyModeEvent interface {
	GetEnteringStandbyModeEvent() *EnteringStandbyModeEvent
}

func init() {
	t["BaseEnteringStandbyModeEvent"] = reflect.TypeOf((*EnteringStandbyModeEvent)(nil)).Elem()
}

func (b *EntityEventArgument) GetEntityEventArgument() *EntityEventArgument { return b }

type BaseEntityEventArgument interface {
	GetEntityEventArgument() *EntityEventArgument
}

func init() {
	t["BaseEntityEventArgument"] = reflect.TypeOf((*EntityEventArgument)(nil)).Elem()
}

func (b *Event) GetEvent() *Event { return b }

type BaseEvent interface {
	GetEvent() *Event
}

func init() {
	t["BaseEvent"] = reflect.TypeOf((*Event)(nil)).Elem()
}

func (b *EventArgument) GetEventArgument() *EventArgument { return b }

type BaseEventArgument interface {
	GetEventArgument() *EventArgument
}

func init() {
	t["BaseEventArgument"] = reflect.TypeOf((*EventArgument)(nil)).Elem()
}

func (b *ExitStandbyModeFailedEvent) GetExitStandbyModeFailedEvent() *ExitStandbyModeFailedEvent {
	return b
}

type BaseExitStandbyModeFailedEvent interface {
	GetExitStandbyModeFailedEvent() *ExitStandbyModeFailedEvent
}

func init() {
	t["BaseExitStandbyModeFailedEvent"] = reflect.TypeOf((*ExitStandbyModeFailedEvent)(nil)).Elem()
}

func (b *ExitedStandbyModeEvent) GetExitedStandbyModeEvent() *ExitedStandbyModeEvent { return b }

type BaseExitedStandbyModeEvent interface {
	GetExitedStandbyModeEvent() *ExitedStandbyModeEvent
}

func init() {
	t["BaseExitedStandbyModeEvent"] = reflect.TypeOf((*ExitedStandbyModeEvent)(nil)).Elem()
}

func (b *ExitingStandbyModeEvent) GetExitingStandbyModeEvent() *ExitingStandbyModeEvent { return b }

type BaseExitingStandbyModeEvent interface {
	GetExitingStandbyModeEvent() *ExitingStandbyModeEvent
}

func init() {
	t["BaseExitingStandbyModeEvent"] = reflect.TypeOf((*ExitingStandbyModeEvent)(nil)).Elem()
}

func (b *ExpiredFeatureLicense) GetExpiredFeatureLicense() *ExpiredFeatureLicense { return b }

type BaseExpiredFeatureLicense interface {
	GetExpiredFeatureLicense() *ExpiredFeatureLicense
}

func init() {
	t["BaseExpiredFeatureLicense"] = reflect.TypeOf((*ExpiredFeatureLicense)(nil)).Elem()
}

func (b *FaultToleranceConfigInfo) GetFaultToleranceConfigInfo() *FaultToleranceConfigInfo { return b }

type BaseFaultToleranceConfigInfo interface {
	GetFaultToleranceConfigInfo() *FaultToleranceConfigInfo
}

func init() {
	t["BaseFaultToleranceConfigInfo"] = reflect.TypeOf((*FaultToleranceConfigInfo)(nil)).Elem()
}

func (b *FcoeFault) GetFcoeFault() *FcoeFault { return b }

type BaseFcoeFault interface {
	GetFcoeFault() *FcoeFault
}

func init() {
	t["BaseFcoeFault"] = reflect.TypeOf((*FcoeFault)(nil)).Elem()
}

func (b *FileBackedVirtualDiskSpec) GetFileBackedVirtualDiskSpec() *FileBackedVirtualDiskSpec {
	return b
}

type BaseFileBackedVirtualDiskSpec interface {
	GetFileBackedVirtualDiskSpec() *FileBackedVirtualDiskSpec
}

func init() {
	t["BaseFileBackedVirtualDiskSpec"] = reflect.TypeOf((*FileBackedVirtualDiskSpec)(nil)).Elem()
}

func (b *FileFault) GetFileFault() *FileFault { return b }

type BaseFileFault interface {
	GetFileFault() *FileFault
}

func init() {
	t["BaseFileFault"] = reflect.TypeOf((*FileFault)(nil)).Elem()
}

func (b *FileInfo) GetFileInfo() *FileInfo { return b }

type BaseFileInfo interface {
	GetFileInfo() *FileInfo
}

func init() {
	t["BaseFileInfo"] = reflect.TypeOf((*FileInfo)(nil)).Elem()
}

func (b *FileQuery) GetFileQuery() *FileQuery { return b }

type BaseFileQuery interface {
	GetFileQuery() *FileQuery
}

func init() {
	t["BaseFileQuery"] = reflect.TypeOf((*FileQuery)(nil)).Elem()
}

func (b *GatewayConnectFault) GetGatewayConnectFault() *GatewayConnectFault { return b }

type BaseGatewayConnectFault interface {
	GetGatewayConnectFault() *GatewayConnectFault
}

func init() {
	t["BaseGatewayConnectFault"] = reflect.TypeOf((*GatewayConnectFault)(nil)).Elem()
}

func (b *GatewayToHostConnectFault) GetGatewayToHostConnectFault() *GatewayToHostConnectFault {
	return b
}

type BaseGatewayToHostConnectFault interface {
	GetGatewayToHostConnectFault() *GatewayToHostConnectFault
}

func init() {
	t["BaseGatewayToHostConnectFault"] = reflect.TypeOf((*GatewayToHostConnectFault)(nil)).Elem()
}

func (b *GeneralEvent) GetGeneralEvent() *GeneralEvent { return b }

type BaseGeneralEvent interface {
	GetGeneralEvent() *GeneralEvent
}

func init() {
	t["BaseGeneralEvent"] = reflect.TypeOf((*GeneralEvent)(nil)).Elem()
}

func (b *GuestAuthSubject) GetGuestAuthSubject() *GuestAuthSubject { return b }

type BaseGuestAuthSubject interface {
	GetGuestAuthSubject() *GuestAuthSubject
}

func init() {
	t["BaseGuestAuthSubject"] = reflect.TypeOf((*GuestAuthSubject)(nil)).Elem()
}

func (b *GuestAuthentication) GetGuestAuthentication() *GuestAuthentication { return b }

type BaseGuestAuthentication interface {
	GetGuestAuthentication() *GuestAuthentication
}

func init() {
	t["BaseGuestAuthentication"] = reflect.TypeOf((*GuestAuthentication)(nil)).Elem()
}

func (b *GuestFileAttributes) GetGuestFileAttributes() *GuestFileAttributes { return b }

type BaseGuestFileAttributes interface {
	GetGuestFileAttributes() *GuestFileAttributes
}

func init() {
	t["BaseGuestFileAttributes"] = reflect.TypeOf((*GuestFileAttributes)(nil)).Elem()
}

func (b *GuestOperationsFault) GetGuestOperationsFault() *GuestOperationsFault { return b }

type BaseGuestOperationsFault interface {
	GetGuestOperationsFault() *GuestOperationsFault
}

func init() {
	t["BaseGuestOperationsFault"] = reflect.TypeOf((*GuestOperationsFault)(nil)).Elem()
}

func (b *GuestProgramSpec) GetGuestProgramSpec() *GuestProgramSpec { return b }

type BaseGuestProgramSpec interface {
	GetGuestProgramSpec() *GuestProgramSpec
}

func init() {
	t["BaseGuestProgramSpec"] = reflect.TypeOf((*GuestProgramSpec)(nil)).Elem()
}

func (b *GuestRegValueDataSpec) GetGuestRegValueDataSpec() *GuestRegValueDataSpec { return b }

type BaseGuestRegValueDataSpec interface {
	GetGuestRegValueDataSpec() *GuestRegValueDataSpec
}

func init() {
	t["BaseGuestRegValueDataSpec"] = reflect.TypeOf((*GuestRegValueDataSpec)(nil)).Elem()
}

func (b *GuestRegistryFault) GetGuestRegistryFault() *GuestRegistryFault { return b }

type BaseGuestRegistryFault interface {
	GetGuestRegistryFault() *GuestRegistryFault
}

func init() {
	t["BaseGuestRegistryFault"] = reflect.TypeOf((*GuestRegistryFault)(nil)).Elem()
}

func (b *GuestRegistryKeyFault) GetGuestRegistryKeyFault() *GuestRegistryKeyFault { return b }

type BaseGuestRegistryKeyFault interface {
	GetGuestRegistryKeyFault() *GuestRegistryKeyFault
}

func init() {
	t["BaseGuestRegistryKeyFault"] = reflect.TypeOf((*GuestRegistryKeyFault)(nil)).Elem()
}

func (b *GuestRegistryValueFault) GetGuestRegistryValueFault() *GuestRegistryValueFault { return b }

type BaseGuestRegistryValueFault interface {
	GetGuestRegistryValueFault() *GuestRegistryValueFault
}

func init() {
	t["BaseGuestRegistryValueFault"] = reflect.TypeOf((*GuestRegistryValueFault)(nil)).Elem()
}

func (b *HostAccountSpec) GetHostAccountSpec() *HostAccountSpec { return b }

type BaseHostAccountSpec interface {
	GetHostAccountSpec() *HostAccountSpec
}

func init() {
	t["BaseHostAccountSpec"] = reflect.TypeOf((*HostAccountSpec)(nil)).Elem()
}

func (b *HostAuthenticationStoreInfo) GetHostAuthenticationStoreInfo() *HostAuthenticationStoreInfo {
	return b
}

type BaseHostAuthenticationStoreInfo interface {
	GetHostAuthenticationStoreInfo() *HostAuthenticationStoreInfo
}

func init() {
	t["BaseHostAuthenticationStoreInfo"] = reflect.TypeOf((*HostAuthenticationStoreInfo)(nil)).Elem()
}

func (b *HostCommunication) GetHostCommunication() *HostCommunication { return b }

type BaseHostCommunication interface {
	GetHostCommunication() *HostCommunication
}

func init() {
	t["BaseHostCommunication"] = reflect.TypeOf((*HostCommunication)(nil)).Elem()
}

func (b *HostConfigFault) GetHostConfigFault() *HostConfigFault { return b }

type BaseHostConfigFault interface {
	GetHostConfigFault() *HostConfigFault
}

func init() {
	t["BaseHostConfigFault"] = reflect.TypeOf((*HostConfigFault)(nil)).Elem()
}

func (b *HostConnectFault) GetHostConnectFault() *HostConnectFault { return b }

type BaseHostConnectFault interface {
	GetHostConnectFault() *HostConnectFault
}

func init() {
	t["BaseHostConnectFault"] = reflect.TypeOf((*HostConnectFault)(nil)).Elem()
}

func (b *HostConnectInfoNetworkInfo) GetHostConnectInfoNetworkInfo() *HostConnectInfoNetworkInfo {
	return b
}

type BaseHostConnectInfoNetworkInfo interface {
	GetHostConnectInfoNetworkInfo() *HostConnectInfoNetworkInfo
}

func init() {
	t["BaseHostConnectInfoNetworkInfo"] = reflect.TypeOf((*HostConnectInfoNetworkInfo)(nil)).Elem()
}

func (b *HostDasEvent) GetHostDasEvent() *HostDasEvent { return b }

type BaseHostDasEvent interface {
	GetHostDasEvent() *HostDasEvent
}

func init() {
	t["BaseHostDasEvent"] = reflect.TypeOf((*HostDasEvent)(nil)).Elem()
}

func (b *HostDatastoreConnectInfo) GetHostDatastoreConnectInfo() *HostDatastoreConnectInfo { return b }

type BaseHostDatastoreConnectInfo interface {
	GetHostDatastoreConnectInfo() *HostDatastoreConnectInfo
}

func init() {
	t["BaseHostDatastoreConnectInfo"] = reflect.TypeOf((*HostDatastoreConnectInfo)(nil)).Elem()
}

func (b *HostDevice) GetHostDevice() *HostDevice { return b }

type BaseHostDevice interface {
	GetHostDevice() *HostDevice
}

func init() {
	t["BaseHostDevice"] = reflect.TypeOf((*HostDevice)(nil)).Elem()
}

func (b *HostDigestInfo) GetHostDigestInfo() *HostDigestInfo { return b }

type BaseHostDigestInfo interface {
	GetHostDigestInfo() *HostDigestInfo
}

func init() {
	t["BaseHostDigestInfo"] = reflect.TypeOf((*HostDigestInfo)(nil)).Elem()
}

func (b *HostDirectoryStoreInfo) GetHostDirectoryStoreInfo() *HostDirectoryStoreInfo { return b }

type BaseHostDirectoryStoreInfo interface {
	GetHostDirectoryStoreInfo() *HostDirectoryStoreInfo
}

func init() {
	t["BaseHostDirectoryStoreInfo"] = reflect.TypeOf((*HostDirectoryStoreInfo)(nil)).Elem()
}

func (b *HostDnsConfig) GetHostDnsConfig() *HostDnsConfig { return b }

type BaseHostDnsConfig interface {
	GetHostDnsConfig() *HostDnsConfig
}

func init() {
	t["BaseHostDnsConfig"] = reflect.TypeOf((*HostDnsConfig)(nil)).Elem()
}

func (b *HostEvent) GetHostEvent() *HostEvent { return b }

type BaseHostEvent interface {
	GetHostEvent() *HostEvent
}

func init() {
	t["BaseHostEvent"] = reflect.TypeOf((*HostEvent)(nil)).Elem()
}

func (b *HostFibreChannelHba) GetHostFibreChannelHba() *HostFibreChannelHba { return b }

type BaseHostFibreChannelHba interface {
	GetHostFibreChannelHba() *HostFibreChannelHba
}

func init() {
	t["BaseHostFibreChannelHba"] = reflect.TypeOf((*HostFibreChannelHba)(nil)).Elem()
}

func (b *HostFibreChannelTargetTransport) GetHostFibreChannelTargetTransport() *HostFibreChannelTargetTransport {
	return b
}

type BaseHostFibreChannelTargetTransport interface {
	GetHostFibreChannelTargetTransport() *HostFibreChannelTargetTransport
}

func init() {
	t["BaseHostFibreChannelTargetTransport"] = reflect.TypeOf((*HostFibreChannelTargetTransport)(nil)).Elem()
}

func (b *HostFileSystemVolume) GetHostFileSystemVolume() *HostFileSystemVolume { return b }

type BaseHostFileSystemVolume interface {
	GetHostFileSystemVolume() *HostFileSystemVolume
}

func init() {
	t["BaseHostFileSystemVolume"] = reflect.TypeOf((*HostFileSystemVolume)(nil)).Elem()
}

func (b *HostHardwareElementInfo) GetHostHardwareElementInfo() *HostHardwareElementInfo { return b }

type BaseHostHardwareElementInfo interface {
	GetHostHardwareElementInfo() *HostHardwareElementInfo
}

func init() {
	t["BaseHostHardwareElementInfo"] = reflect.TypeOf((*HostHardwareElementInfo)(nil)).Elem()
}

func (b *HostHostBusAdapter) GetHostHostBusAdapter() *HostHostBusAdapter { return b }

type BaseHostHostBusAdapter interface {
	GetHostHostBusAdapter() *HostHostBusAdapter
}

func init() {
	t["BaseHostHostBusAdapter"] = reflect.TypeOf((*HostHostBusAdapter)(nil)).Elem()
}

func (b *HostIpRouteConfig) GetHostIpRouteConfig() *HostIpRouteConfig { return b }

type BaseHostIpRouteConfig interface {
	GetHostIpRouteConfig() *HostIpRouteConfig
}

func init() {
	t["BaseHostIpRouteConfig"] = reflect.TypeOf((*HostIpRouteConfig)(nil)).Elem()
}

func (b *HostMemberHealthCheckResult) GetHostMemberHealthCheckResult() *HostMemberHealthCheckResult {
	return b
}

type BaseHostMemberHealthCheckResult interface {
	GetHostMemberHealthCheckResult() *HostMemberHealthCheckResult
}

func init() {
	t["BaseHostMemberHealthCheckResult"] = reflect.TypeOf((*HostMemberHealthCheckResult)(nil)).Elem()
}

func (b *HostMemberUplinkHealthCheckResult) GetHostMemberUplinkHealthCheckResult() *HostMemberUplinkHealthCheckResult {
	return b
}

type BaseHostMemberUplinkHealthCheckResult interface {
	GetHostMemberUplinkHealthCheckResult() *HostMemberUplinkHealthCheckResult
}

func init() {
	t["BaseHostMemberUplinkHealthCheckResult"] = reflect.TypeOf((*HostMemberUplinkHealthCheckResult)(nil)).Elem()
}

func (b *HostMultipathInfoLogicalUnitPolicy) GetHostMultipathInfoLogicalUnitPolicy() *HostMultipathInfoLogicalUnitPolicy {
	return b
}

type BaseHostMultipathInfoLogicalUnitPolicy interface {
	GetHostMultipathInfoLogicalUnitPolicy() *HostMultipathInfoLogicalUnitPolicy
}

func init() {
	t["BaseHostMultipathInfoLogicalUnitPolicy"] = reflect.TypeOf((*HostMultipathInfoLogicalUnitPolicy)(nil)).Elem()
}

func (b *HostNvmeSpec) GetHostNvmeSpec() *HostNvmeSpec { return b }

type BaseHostNvmeSpec interface {
	GetHostNvmeSpec() *HostNvmeSpec
}

func init() {
	t["BaseHostNvmeSpec"] = reflect.TypeOf((*HostNvmeSpec)(nil)).Elem()
}

func (b *HostNvmeTransportParameters) GetHostNvmeTransportParameters() *HostNvmeTransportParameters {
	return b
}

type BaseHostNvmeTransportParameters interface {
	GetHostNvmeTransportParameters() *HostNvmeTransportParameters
}

func init() {
	t["BaseHostNvmeTransportParameters"] = reflect.TypeOf((*HostNvmeTransportParameters)(nil)).Elem()
}

func (b *HostPciPassthruConfig) GetHostPciPassthruConfig() *HostPciPassthruConfig { return b }

type BaseHostPciPassthruConfig interface {
	GetHostPciPassthruConfig() *HostPciPassthruConfig
}

func init() {
	t["BaseHostPciPassthruConfig"] = reflect.TypeOf((*HostPciPassthruConfig)(nil)).Elem()
}

func (b *HostPciPassthruInfo) GetHostPciPassthruInfo() *HostPciPassthruInfo { return b }

type BaseHostPciPassthruInfo interface {
	GetHostPciPassthruInfo() *HostPciPassthruInfo
}

func init() {
	t["BaseHostPciPassthruInfo"] = reflect.TypeOf((*HostPciPassthruInfo)(nil)).Elem()
}

func (b *HostPowerOpFailed) GetHostPowerOpFailed() *HostPowerOpFailed { return b }

type BaseHostPowerOpFailed interface {
	GetHostPowerOpFailed() *HostPowerOpFailed
}

func init() {
	t["BaseHostPowerOpFailed"] = reflect.TypeOf((*HostPowerOpFailed)(nil)).Elem()
}

func (b *HostProfileConfigSpec) GetHostProfileConfigSpec() *HostProfileConfigSpec { return b }

type BaseHostProfileConfigSpec interface {
	GetHostProfileConfigSpec() *HostProfileConfigSpec
}

func init() {
	t["BaseHostProfileConfigSpec"] = reflect.TypeOf((*HostProfileConfigSpec)(nil)).Elem()
}

func (b *HostProfilesEntityCustomizations) GetHostProfilesEntityCustomizations() *HostProfilesEntityCustomizations {
	return b
}

type BaseHostProfilesEntityCustomizations interface {
	GetHostProfilesEntityCustomizations() *HostProfilesEntityCustomizations
}

func init() {
	t["BaseHostProfilesEntityCustomizations"] = reflect.TypeOf((*HostProfilesEntityCustomizations)(nil)).Elem()
}

func (b *HostRdmaDeviceBacking) GetHostRdmaDeviceBacking() *HostRdmaDeviceBacking { return b }

type BaseHostRdmaDeviceBacking interface {
	GetHostRdmaDeviceBacking() *HostRdmaDeviceBacking
}

func init() {
	t["BaseHostRdmaDeviceBacking"] = reflect.TypeOf((*HostRdmaDeviceBacking)(nil)).Elem()
}

func (b *HostSriovDevicePoolInfo) GetHostSriovDevicePoolInfo() *HostSriovDevicePoolInfo { return b }

type BaseHostSriovDevicePoolInfo interface {
	GetHostSriovDevicePoolInfo() *HostSriovDevicePoolInfo
}

func init() {
	t["BaseHostSriovDevicePoolInfo"] = reflect.TypeOf((*HostSriovDevicePoolInfo)(nil)).Elem()
}

func (b *HostSystemSwapConfigurationSystemSwapOption) GetHostSystemSwapConfigurationSystemSwapOption() *HostSystemSwapConfigurationSystemSwapOption {
	return b
}

type BaseHostSystemSwapConfigurationSystemSwapOption interface {
	GetHostSystemSwapConfigurationSystemSwapOption() *HostSystemSwapConfigurationSystemSwapOption
}

func init() {
	t["BaseHostSystemSwapConfigurationSystemSwapOption"] = reflect.TypeOf((*HostSystemSwapConfigurationSystemSwapOption)(nil)).Elem()
}

func (b *HostTargetTransport) GetHostTargetTransport() *HostTargetTransport { return b }

type BaseHostTargetTransport interface {
	GetHostTargetTransport() *HostTargetTransport
}

func init() {
	t["BaseHostTargetTransport"] = reflect.TypeOf((*HostTargetTransport)(nil)).Elem()
}

func (b *HostTpmEventDetails) GetHostTpmEventDetails() *HostTpmEventDetails { return b }

type BaseHostTpmEventDetails interface {
	GetHostTpmEventDetails() *HostTpmEventDetails
}

func init() {
	t["BaseHostTpmEventDetails"] = reflect.TypeOf((*HostTpmEventDetails)(nil)).Elem()
}

func (b *HostVirtualSwitchBridge) GetHostVirtualSwitchBridge() *HostVirtualSwitchBridge { return b }

type BaseHostVirtualSwitchBridge interface {
	GetHostVirtualSwitchBridge() *HostVirtualSwitchBridge
}

func init() {
	t["BaseHostVirtualSwitchBridge"] = reflect.TypeOf((*HostVirtualSwitchBridge)(nil)).Elem()
}

func (b *HourlyTaskScheduler) GetHourlyTaskScheduler() *HourlyTaskScheduler { return b }

type BaseHourlyTaskScheduler interface {
	GetHourlyTaskScheduler() *HourlyTaskScheduler
}

func init() {
	t["BaseHourlyTaskScheduler"] = reflect.TypeOf((*HourlyTaskScheduler)(nil)).Elem()
}

func (b *ImportSpec) GetImportSpec() *ImportSpec { return b }

type BaseImportSpec interface {
	GetImportSpec() *ImportSpec
}

func init() {
	t["BaseImportSpec"] = reflect.TypeOf((*ImportSpec)(nil)).Elem()
}

func (b *InaccessibleDatastore) GetInaccessibleDatastore() *InaccessibleDatastore { return b }

type BaseInaccessibleDatastore interface {
	GetInaccessibleDatastore() *InaccessibleDatastore
}

func init() {
	t["BaseInaccessibleDatastore"] = reflect.TypeOf((*InaccessibleDatastore)(nil)).Elem()
}

func (b *InheritablePolicy) GetInheritablePolicy() *InheritablePolicy { return b }

type BaseInheritablePolicy interface {
	GetInheritablePolicy() *InheritablePolicy
}

func init() {
	t["BaseInheritablePolicy"] = reflect.TypeOf((*InheritablePolicy)(nil)).Elem()
}

func (b *InsufficientHostCapacityFault) GetInsufficientHostCapacityFault() *InsufficientHostCapacityFault {
	return b
}

type BaseInsufficientHostCapacityFault interface {
	GetInsufficientHostCapacityFault() *InsufficientHostCapacityFault
}

func init() {
	t["BaseInsufficientHostCapacityFault"] = reflect.TypeOf((*InsufficientHostCapacityFault)(nil)).Elem()
}

func (b *InsufficientResourcesFault) GetInsufficientResourcesFault() *InsufficientResourcesFault {
	return b
}

type BaseInsufficientResourcesFault interface {
	GetInsufficientResourcesFault() *InsufficientResourcesFault
}

func init() {
	t["BaseInsufficientResourcesFault"] = reflect.TypeOf((*InsufficientResourcesFault)(nil)).Elem()
}

func (b *InsufficientStandbyResource) GetInsufficientStandbyResource() *InsufficientStandbyResource {
	return b
}

type BaseInsufficientStandbyResource interface {
	GetInsufficientStandbyResource() *InsufficientStandbyResource
}

func init() {
	t["BaseInsufficientStandbyResource"] = reflect.TypeOf((*InsufficientStandbyResource)(nil)).Elem()
}

func (b *InvalidArgument) GetInvalidArgument() *InvalidArgument { return b }

type BaseInvalidArgument interface {
	GetInvalidArgument() *InvalidArgument
}

func init() {
	t["BaseInvalidArgument"] = reflect.TypeOf((*InvalidArgument)(nil)).Elem()
}

func (b *InvalidCAMServer) GetInvalidCAMServer() *InvalidCAMServer { return b }

type BaseInvalidCAMServer interface {
	GetInvalidCAMServer() *InvalidCAMServer
}

func init() {
	t["BaseInvalidCAMServer"] = reflect.TypeOf((*InvalidCAMServer)(nil)).Elem()
}

func (b *InvalidDatastore) GetInvalidDatastore() *InvalidDatastore { return b }

type BaseInvalidDatastore interface {
	GetInvalidDatastore() *InvalidDatastore
}

func init() {
	t["BaseInvalidDatastore"] = reflect.TypeOf((*InvalidDatastore)(nil)).Elem()
}

func (b *InvalidDeviceSpec) GetInvalidDeviceSpec() *InvalidDeviceSpec { return b }

type BaseInvalidDeviceSpec interface {
	GetInvalidDeviceSpec() *InvalidDeviceSpec
}

func init() {
	t["BaseInvalidDeviceSpec"] = reflect.TypeOf((*InvalidDeviceSpec)(nil)).Elem()
}

func (b *InvalidFolder) GetInvalidFolder() *InvalidFolder { return b }

type BaseInvalidFolder interface {
	GetInvalidFolder() *InvalidFolder
}

func init() {
	t["BaseInvalidFolder"] = reflect.TypeOf((*InvalidFolder)(nil)).Elem()
}

func (b *InvalidFormat) GetInvalidFormat() *InvalidFormat { return b }

type BaseInvalidFormat interface {
	GetInvalidFormat() *InvalidFormat
}

func init() {
	t["BaseInvalidFormat"] = reflect.TypeOf((*InvalidFormat)(nil)).Elem()
}

func (b *InvalidHostState) GetInvalidHostState() *InvalidHostState { return b }

type BaseInvalidHostState interface {
	GetInvalidHostState() *InvalidHostState
}

func init() {
	t["BaseInvalidHostState"] = reflect.TypeOf((*InvalidHostState)(nil)).Elem()
}

func (b *InvalidLogin) GetInvalidLogin() *InvalidLogin { return b }

type BaseInvalidLogin interface {
	GetInvalidLogin() *InvalidLogin
}

func init() {
	t["BaseInvalidLogin"] = reflect.TypeOf((*InvalidLogin)(nil)).Elem()
}

func (b *InvalidPropertyValue) GetInvalidPropertyValue() *InvalidPropertyValue { return b }

type BaseInvalidPropertyValue interface {
	GetInvalidPropertyValue() *InvalidPropertyValue
}

func init() {
	t["BaseInvalidPropertyValue"] = reflect.TypeOf((*InvalidPropertyValue)(nil)).Elem()
}

func (b *InvalidRequest) GetInvalidRequest() *InvalidRequest { return b }

type BaseInvalidRequest interface {
	GetInvalidRequest() *InvalidRequest
}

func init() {
	t["BaseInvalidRequest"] = reflect.TypeOf((*InvalidRequest)(nil)).Elem()
}

func (b *InvalidState) GetInvalidState() *InvalidState { return b }

type BaseInvalidState interface {
	GetInvalidState() *InvalidState
}

func init() {
	t["BaseInvalidState"] = reflect.TypeOf((*InvalidState)(nil)).Elem()
}

func (b *InvalidVmConfig) GetInvalidVmConfig() *InvalidVmConfig { return b }

type BaseInvalidVmConfig interface {
	GetInvalidVmConfig() *InvalidVmConfig
}

func init() {
	t["BaseInvalidVmConfig"] = reflect.TypeOf((*InvalidVmConfig)(nil)).Elem()
}

func (b *IoFilterInfo) GetIoFilterInfo() *IoFilterInfo { return b }

type BaseIoFilterInfo interface {
	GetIoFilterInfo() *IoFilterInfo
}

func init() {
	t["BaseIoFilterInfo"] = reflect.TypeOf((*IoFilterInfo)(nil)).Elem()
}

func (b *IpAddress) GetIpAddress() *IpAddress { return b }

type BaseIpAddress interface {
	GetIpAddress() *IpAddress
}

func init() {
	t["BaseIpAddress"] = reflect.TypeOf((*IpAddress)(nil)).Elem()
}

func (b *IscsiFault) GetIscsiFault() *IscsiFault { return b }

type BaseIscsiFault interface {
	GetIscsiFault() *IscsiFault
}

func init() {
	t["BaseIscsiFault"] = reflect.TypeOf((*IscsiFault)(nil)).Elem()
}

func (b *LicenseEvent) GetLicenseEvent() *LicenseEvent { return b }

type BaseLicenseEvent interface {
	GetLicenseEvent() *LicenseEvent
}

func init() {
	t["BaseLicenseEvent"] = reflect.TypeOf((*LicenseEvent)(nil)).Elem()
}

func (b *LicenseSource) GetLicenseSource() *LicenseSource { return b }

type BaseLicenseSource interface {
	GetLicenseSource() *LicenseSource
}

func init() {
	t["BaseLicenseSource"] = reflect.TypeOf((*LicenseSource)(nil)).Elem()
}

func (b *MacAddress) GetMacAddress() *MacAddress { return b }

type BaseMacAddress interface {
	GetMacAddress() *MacAddress
}

func init() {
	t["BaseMacAddress"] = reflect.TypeOf((*MacAddress)(nil)).Elem()
}

func (b *MethodFault) GetMethodFault() *MethodFault { return b }

type BaseMethodFault interface {
	GetMethodFault() *MethodFault
}

func init() {
	t["BaseMethodFault"] = reflect.TypeOf((*MethodFault)(nil)).Elem()
}

func (b *MigrationEvent) GetMigrationEvent() *MigrationEvent { return b }

type BaseMigrationEvent interface {
	GetMigrationEvent() *MigrationEvent
}

func init() {
	t["BaseMigrationEvent"] = reflect.TypeOf((*MigrationEvent)(nil)).Elem()
}

func (b *MigrationFault) GetMigrationFault() *MigrationFault { return b }

type BaseMigrationFault interface {
	GetMigrationFault() *MigrationFault
}

func init() {
	t["BaseMigrationFault"] = reflect.TypeOf((*MigrationFault)(nil)).Elem()
}

func (b *MigrationFeatureNotSupported) GetMigrationFeatureNotSupported() *MigrationFeatureNotSupported {
	return b
}

type BaseMigrationFeatureNotSupported interface {
	GetMigrationFeatureNotSupported() *MigrationFeatureNotSupported
}

func init() {
	t["BaseMigrationFeatureNotSupported"] = reflect.TypeOf((*MigrationFeatureNotSupported)(nil)).Elem()
}

func (b *MonthlyTaskScheduler) GetMonthlyTaskScheduler() *MonthlyTaskScheduler { return b }

type BaseMonthlyTaskScheduler interface {
	GetMonthlyTaskScheduler() *MonthlyTaskScheduler
}

func init() {
	t["BaseMonthlyTaskScheduler"] = reflect.TypeOf((*MonthlyTaskScheduler)(nil)).Elem()
}

func (b *NasConfigFault) GetNasConfigFault() *NasConfigFault { return b }

type BaseNasConfigFault interface {
	GetNasConfigFault() *NasConfigFault
}

func init() {
	t["BaseNasConfigFault"] = reflect.TypeOf((*NasConfigFault)(nil)).Elem()
}

func (b *NegatableExpression) GetNegatableExpression() *NegatableExpression { return b }

type BaseNegatableExpression interface {
	GetNegatableExpression() *NegatableExpression
}

func init() {
	t["BaseNegatableExpression"] = reflect.TypeOf((*NegatableExpression)(nil)).Elem()
}

func (b *NetBIOSConfigInfo) GetNetBIOSConfigInfo() *NetBIOSConfigInfo { return b }

type BaseNetBIOSConfigInfo interface {
	GetNetBIOSConfigInfo() *NetBIOSConfigInfo
}

func init() {
	t["BaseNetBIOSConfigInfo"] = reflect.TypeOf((*NetBIOSConfigInfo)(nil)).Elem()
}

func (b *NetworkSummary) GetNetworkSummary() *NetworkSummary { return b }

type BaseNetworkSummary interface {
	GetNetworkSummary() *NetworkSummary
}

func init() {
	t["BaseNetworkSummary"] = reflect.TypeOf((*NetworkSummary)(nil)).Elem()
}

func (b *NoCompatibleHost) GetNoCompatibleHost() *NoCompatibleHost { return b }

type BaseNoCompatibleHost interface {
	GetNoCompatibleHost() *NoCompatibleHost
}

func init() {
	t["BaseNoCompatibleHost"] = reflect.TypeOf((*NoCompatibleHost)(nil)).Elem()
}

func (b *NoPermission) GetNoPermission() *NoPermission { return b }

type BaseNoPermission interface {
	GetNoPermission() *NoPermission
}

func init() {
	t["BaseNoPermission"] = reflect.TypeOf((*NoPermission)(nil)).Elem()
}

func (b *NodeDeploymentSpec) GetNodeDeploymentSpec() *NodeDeploymentSpec { return b }

type BaseNodeDeploymentSpec interface {
	GetNodeDeploymentSpec() *NodeDeploymentSpec
}

func init() {
	t["BaseNodeDeploymentSpec"] = reflect.TypeOf((*NodeDeploymentSpec)(nil)).Elem()
}

func (b *NodeNetworkSpec) GetNodeNetworkSpec() *NodeNetworkSpec { return b }

type BaseNodeNetworkSpec interface {
	GetNodeNetworkSpec() *NodeNetworkSpec
}

func init() {
	t["BaseNodeNetworkSpec"] = reflect.TypeOf((*NodeNetworkSpec)(nil)).Elem()
}

func (b *NotEnoughCpus) GetNotEnoughCpus() *NotEnoughCpus { return b }

type BaseNotEnoughCpus interface {
	GetNotEnoughCpus() *NotEnoughCpus
}

func init() {
	t["BaseNotEnoughCpus"] = reflect.TypeOf((*NotEnoughCpus)(nil)).Elem()
}

func (b *NotEnoughLicenses) GetNotEnoughLicenses() *NotEnoughLicenses { return b }

type BaseNotEnoughLicenses interface {
	GetNotEnoughLicenses() *NotEnoughLicenses
}

func init() {
	t["BaseNotEnoughLicenses"] = reflect.TypeOf((*NotEnoughLicenses)(nil)).Elem()
}

func (b *NotSupported) GetNotSupported() *NotSupported { return b }

type BaseNotSupported interface {
	GetNotSupported() *NotSupported
}

func init() {
	t["BaseNotSupported"] = reflect.TypeOf((*NotSupported)(nil)).Elem()
}

func (b *NotSupportedHost) GetNotSupportedHost() *NotSupportedHost { return b }

type BaseNotSupportedHost interface {
	GetNotSupportedHost() *NotSupportedHost
}

func init() {
	t["BaseNotSupportedHost"] = reflect.TypeOf((*NotSupportedHost)(nil)).Elem()
}

func (b *NotSupportedHostInCluster) GetNotSupportedHostInCluster() *NotSupportedHostInCluster {
	return b
}

type BaseNotSupportedHostInCluster interface {
	GetNotSupportedHostInCluster() *NotSupportedHostInCluster
}

func init() {
	t["BaseNotSupportedHostInCluster"] = reflect.TypeOf((*NotSupportedHostInCluster)(nil)).Elem()
}

func (b *OptionType) GetOptionType() *OptionType { return b }

type BaseOptionType interface {
	GetOptionType() *OptionType
}

func init() {
	t["BaseOptionType"] = reflect.TypeOf((*OptionType)(nil)).Elem()
}

func (b *OptionValue) GetOptionValue() *OptionValue { return b }

type BaseOptionValue interface {
	GetOptionValue() *OptionValue
}

func init() {
	t["BaseOptionValue"] = reflect.TypeOf((*OptionValue)(nil)).Elem()
}

func (b *OvfAttribute) GetOvfAttribute() *OvfAttribute { return b }

type BaseOvfAttribute interface {
	GetOvfAttribute() *OvfAttribute
}

func init() {
	t["BaseOvfAttribute"] = reflect.TypeOf((*OvfAttribute)(nil)).Elem()
}

func (b *OvfConnectedDevice) GetOvfConnectedDevice() *OvfConnectedDevice { return b }

type BaseOvfConnectedDevice interface {
	GetOvfConnectedDevice() *OvfConnectedDevice
}

func init() {
	t["BaseOvfConnectedDevice"] = reflect.TypeOf((*OvfConnectedDevice)(nil)).Elem()
}

func (b *OvfConstraint) GetOvfConstraint() *OvfConstraint { return b }

type BaseOvfConstraint interface {
	GetOvfConstraint() *OvfConstraint
}

func init() {
	t["BaseOvfConstraint"] = reflect.TypeOf((*OvfConstraint)(nil)).Elem()
}

func (b *OvfConsumerCallbackFault) GetOvfConsumerCallbackFault() *OvfConsumerCallbackFault { return b }

type BaseOvfConsumerCallbackFault interface {
	GetOvfConsumerCallbackFault() *OvfConsumerCallbackFault
}

func init() {
	t["BaseOvfConsumerCallbackFault"] = reflect.TypeOf((*OvfConsumerCallbackFault)(nil)).Elem()
}

func (b *OvfElement) GetOvfElement() *OvfElement { return b }

type BaseOvfElement interface {
	GetOvfElement() *OvfElement
}

func init() {
	t["BaseOvfElement"] = reflect.TypeOf((*OvfElement)(nil)).Elem()
}

func (b *OvfExport) GetOvfExport() *OvfExport { return b }

type BaseOvfExport interface {
	GetOvfExport() *OvfExport
}

func init() {
	t["BaseOvfExport"] = reflect.TypeOf((*OvfExport)(nil)).Elem()
}

func (b *OvfFault) GetOvfFault() *OvfFault { return b }

type BaseOvfFault interface {
	GetOvfFault() *OvfFault
}

func init() {
	t["BaseOvfFault"] = reflect.TypeOf((*OvfFault)(nil)).Elem()
}

func (b *OvfHardwareExport) GetOvfHardwareExport() *OvfHardwareExport { return b }

type BaseOvfHardwareExport interface {
	GetOvfHardwareExport() *OvfHardwareExport
}

func init() {
	t["BaseOvfHardwareExport"] = reflect.TypeOf((*OvfHardwareExport)(nil)).Elem()
}

func (b *OvfImport) GetOvfImport() *OvfImport { return b }

type BaseOvfImport interface {
	GetOvfImport() *OvfImport
}

func init() {
	t["BaseOvfImport"] = reflect.TypeOf((*OvfImport)(nil)).Elem()
}

func (b *OvfInvalidPackage) GetOvfInvalidPackage() *OvfInvalidPackage { return b }

type BaseOvfInvalidPackage interface {
	GetOvfInvalidPackage() *OvfInvalidPackage
}

func init() {
	t["BaseOvfInvalidPackage"] = reflect.TypeOf((*OvfInvalidPackage)(nil)).Elem()
}

func (b *OvfInvalidValue) GetOvfInvalidValue() *OvfInvalidValue { return b }

type BaseOvfInvalidValue interface {
	GetOvfInvalidValue() *OvfInvalidValue
}

func init() {
	t["BaseOvfInvalidValue"] = reflect.TypeOf((*OvfInvalidValue)(nil)).Elem()
}

func (b *OvfManagerCommonParams) GetOvfManagerCommonParams() *OvfManagerCommonParams { return b }

type BaseOvfManagerCommonParams interface {
	GetOvfManagerCommonParams() *OvfManagerCommonParams
}

func init() {
	t["BaseOvfManagerCommonParams"] = reflect.TypeOf((*OvfManagerCommonParams)(nil)).Elem()
}

func (b *OvfMissingElement) GetOvfMissingElement() *OvfMissingElement { return b }

type BaseOvfMissingElement interface {
	GetOvfMissingElement() *OvfMissingElement
}

func init() {
	t["BaseOvfMissingElement"] = reflect.TypeOf((*OvfMissingElement)(nil)).Elem()
}

func (b *OvfProperty) GetOvfProperty() *OvfProperty { return b }

type BaseOvfProperty interface {
	GetOvfProperty() *OvfProperty
}

func init() {
	t["BaseOvfProperty"] = reflect.TypeOf((*OvfProperty)(nil)).Elem()
}

func (b *OvfSystemFault) GetOvfSystemFault() *OvfSystemFault { return b }

type BaseOvfSystemFault interface {
	GetOvfSystemFault() *OvfSystemFault
}

func init() {
	t["BaseOvfSystemFault"] = reflect.TypeOf((*OvfSystemFault)(nil)).Elem()
}

func (b *OvfUnsupportedAttribute) GetOvfUnsupportedAttribute() *OvfUnsupportedAttribute { return b }

type BaseOvfUnsupportedAttribute interface {
	GetOvfUnsupportedAttribute() *OvfUnsupportedAttribute
}

func init() {
	t["BaseOvfUnsupportedAttribute"] = reflect.TypeOf((*OvfUnsupportedAttribute)(nil)).Elem()
}

func (b *OvfUnsupportedElement) GetOvfUnsupportedElement() *OvfUnsupportedElement { return b }

type BaseOvfUnsupportedElement interface {
	GetOvfUnsupportedElement() *OvfUnsupportedElement
}

func init() {
	t["BaseOvfUnsupportedElement"] = reflect.TypeOf((*OvfUnsupportedElement)(nil)).Elem()
}

func (b *OvfUnsupportedPackage) GetOvfUnsupportedPackage() *OvfUnsupportedPackage { return b }

type BaseOvfUnsupportedPackage interface {
	GetOvfUnsupportedPackage() *OvfUnsupportedPackage
}

func init() {
	t["BaseOvfUnsupportedPackage"] = reflect.TypeOf((*OvfUnsupportedPackage)(nil)).Elem()
}

func (b *PatchMetadataInvalid) GetPatchMetadataInvalid() *PatchMetadataInvalid { return b }

type BasePatchMetadataInvalid interface {
	GetPatchMetadataInvalid() *PatchMetadataInvalid
}

func init() {
	t["BasePatchMetadataInvalid"] = reflect.TypeOf((*PatchMetadataInvalid)(nil)).Elem()
}

func (b *PatchNotApplicable) GetPatchNotApplicable() *PatchNotApplicable { return b }

type BasePatchNotApplicable interface {
	GetPatchNotApplicable() *PatchNotApplicable
}

func init() {
	t["BasePatchNotApplicable"] = reflect.TypeOf((*PatchNotApplicable)(nil)).Elem()
}

func (b *PerfEntityMetricBase) GetPerfEntityMetricBase() *PerfEntityMetricBase { return b }

type BasePerfEntityMetricBase interface {
	GetPerfEntityMetricBase() *PerfEntityMetricBase
}

func init() {
	t["BasePerfEntityMetricBase"] = reflect.TypeOf((*PerfEntityMetricBase)(nil)).Elem()
}

func (b *PerfMetricSeries) GetPerfMetricSeries() *PerfMetricSeries { return b }

type BasePerfMetricSeries interface {
	GetPerfMetricSeries() *PerfMetricSeries
}

func init() {
	t["BasePerfMetricSeries"] = reflect.TypeOf((*PerfMetricSeries)(nil)).Elem()
}

func (b *PermissionEvent) GetPermissionEvent() *PermissionEvent { return b }

type BasePermissionEvent interface {
	GetPermissionEvent() *PermissionEvent
}

func init() {
	t["BasePermissionEvent"] = reflect.TypeOf((*PermissionEvent)(nil)).Elem()
}

func (b *PhysicalNicHint) GetPhysicalNicHint() *PhysicalNicHint { return b }

type BasePhysicalNicHint interface {
	GetPhysicalNicHint() *PhysicalNicHint
}

func init() {
	t["BasePhysicalNicHint"] = reflect.TypeOf((*PhysicalNicHint)(nil)).Elem()
}

func (b *PlatformConfigFault) GetPlatformConfigFault() *PlatformConfigFault { return b }

type BasePlatformConfigFault interface {
	GetPlatformConfigFault() *PlatformConfigFault
}

func init() {
	t["BasePlatformConfigFault"] = reflect.TypeOf((*PlatformConfigFault)(nil)).Elem()
}

func (b *PolicyOption) GetPolicyOption() *PolicyOption { return b }

type BasePolicyOption interface {
	GetPolicyOption() *PolicyOption
}

func init() {
	t["BasePolicyOption"] = reflect.TypeOf((*PolicyOption)(nil)).Elem()
}

func (b *PortGroupProfile) GetPortGroupProfile() *PortGroupProfile { return b }

type BasePortGroupProfile interface {
	GetPortGroupProfile() *PortGroupProfile
}

func init() {
	t["BasePortGroupProfile"] = reflect.TypeOf((*PortGroupProfile)(nil)).Elem()
}

func (b *ProfileConfigInfo) GetProfileConfigInfo() *ProfileConfigInfo { return b }

type BaseProfileConfigInfo interface {
	GetProfileConfigInfo() *ProfileConfigInfo
}

func init() {
	t["BaseProfileConfigInfo"] = reflect.TypeOf((*ProfileConfigInfo)(nil)).Elem()
}

func (b *ProfileCreateSpec) GetProfileCreateSpec() *ProfileCreateSpec { return b }

type BaseProfileCreateSpec interface {
	GetProfileCreateSpec() *ProfileCreateSpec
}

func init() {
	t["BaseProfileCreateSpec"] = reflect.TypeOf((*ProfileCreateSpec)(nil)).Elem()
}

func (b *ProfileEvent) GetProfileEvent() *ProfileEvent { return b }

type BaseProfileEvent interface {
	GetProfileEvent() *ProfileEvent
}

func init() {
	t["BaseProfileEvent"] = reflect.TypeOf((*ProfileEvent)(nil)).Elem()
}

func (b *ProfileExecuteResult) GetProfileExecuteResult() *ProfileExecuteResult { return b }

type BaseProfileExecuteResult interface {
	GetProfileExecuteResult() *ProfileExecuteResult
}

func init() {
	t["BaseProfileExecuteResult"] = reflect.TypeOf((*ProfileExecuteResult)(nil)).Elem()
}

func (b *ProfileExpression) GetProfileExpression() *ProfileExpression { return b }

type BaseProfileExpression interface {
	GetProfileExpression() *ProfileExpression
}

func init() {
	t["BaseProfileExpression"] = reflect.TypeOf((*ProfileExpression)(nil)).Elem()
}

func (b *ProfilePolicyOptionMetadata) GetProfilePolicyOptionMetadata() *ProfilePolicyOptionMetadata {
	return b
}

type BaseProfilePolicyOptionMetadata interface {
	GetProfilePolicyOptionMetadata() *ProfilePolicyOptionMetadata
}

func init() {
	t["BaseProfilePolicyOptionMetadata"] = reflect.TypeOf((*ProfilePolicyOptionMetadata)(nil)).Elem()
}

func (b *ProfileSerializedCreateSpec) GetProfileSerializedCreateSpec() *ProfileSerializedCreateSpec {
	return b
}

type BaseProfileSerializedCreateSpec interface {
	GetProfileSerializedCreateSpec() *ProfileSerializedCreateSpec
}

func init() {
	t["BaseProfileSerializedCreateSpec"] = reflect.TypeOf((*ProfileSerializedCreateSpec)(nil)).Elem()
}

func (b *RDMNotSupported) GetRDMNotSupported() *RDMNotSupported { return b }

type BaseRDMNotSupported interface {
	GetRDMNotSupported() *RDMNotSupported
}

func init() {
	t["BaseRDMNotSupported"] = reflect.TypeOf((*RDMNotSupported)(nil)).Elem()
}

func (b *RecurrentTaskScheduler) GetRecurrentTaskScheduler() *RecurrentTaskScheduler { return b }

type BaseRecurrentTaskScheduler interface {
	GetRecurrentTaskScheduler() *RecurrentTaskScheduler
}

func init() {
	t["BaseRecurrentTaskScheduler"] = reflect.TypeOf((*RecurrentTaskScheduler)(nil)).Elem()
}

func (b *ReplicationConfigFault) GetReplicationConfigFault() *ReplicationConfigFault { return b }

type BaseReplicationConfigFault interface {
	GetReplicationConfigFault() *ReplicationConfigFault
}

func init() {
	t["BaseReplicationConfigFault"] = reflect.TypeOf((*ReplicationConfigFault)(nil)).Elem()
}

func (b *ReplicationFault) GetReplicationFault() *ReplicationFault { return b }

type BaseReplicationFault interface {
	GetReplicationFault() *ReplicationFault
}

func init() {
	t["BaseReplicationFault"] = reflect.TypeOf((*ReplicationFault)(nil)).Elem()
}

func (b *ReplicationVmFault) GetReplicationVmFault() *ReplicationVmFault { return b }

type BaseReplicationVmFault interface {
	GetReplicationVmFault() *ReplicationVmFault
}

func init() {
	t["BaseReplicationVmFault"] = reflect.TypeOf((*ReplicationVmFault)(nil)).Elem()
}

func (b *ResourceInUse) GetResourceInUse() *ResourceInUse { return b }

type BaseResourceInUse interface {
	GetResourceInUse() *ResourceInUse
}

func init() {
	t["BaseResourceInUse"] = reflect.TypeOf((*ResourceInUse)(nil)).Elem()
}

func (b *ResourcePoolEvent) GetResourcePoolEvent() *ResourcePoolEvent { return b }

type BaseResourcePoolEvent interface {
	GetResourcePoolEvent() *ResourcePoolEvent
}

func init() {
	t["BaseResourcePoolEvent"] = reflect.TypeOf((*ResourcePoolEvent)(nil)).Elem()
}

func (b *ResourcePoolSummary) GetResourcePoolSummary() *ResourcePoolSummary { return b }

type BaseResourcePoolSummary interface {
	GetResourcePoolSummary() *ResourcePoolSummary
}

func init() {
	t["BaseResourcePoolSummary"] = reflect.TypeOf((*ResourcePoolSummary)(nil)).Elem()
}

func (b *RoleEvent) GetRoleEvent() *RoleEvent { return b }

type BaseRoleEvent interface {
	GetRoleEvent() *RoleEvent
}

func init() {
	t["BaseRoleEvent"] = reflect.TypeOf((*RoleEvent)(nil)).Elem()
}

func (b *RuntimeFault) GetRuntimeFault() *RuntimeFault { return b }

type BaseRuntimeFault interface {
	GetRuntimeFault() *RuntimeFault
}

func init() {
	t["BaseRuntimeFault"] = reflect.TypeOf((*RuntimeFault)(nil)).Elem()
}

func (b *ScheduledTaskEvent) GetScheduledTaskEvent() *ScheduledTaskEvent { return b }

type BaseScheduledTaskEvent interface {
	GetScheduledTaskEvent() *ScheduledTaskEvent
}

func init() {
	t["BaseScheduledTaskEvent"] = reflect.TypeOf((*ScheduledTaskEvent)(nil)).Elem()
}

func (b *ScheduledTaskSpec) GetScheduledTaskSpec() *ScheduledTaskSpec { return b }

type BaseScheduledTaskSpec interface {
	GetScheduledTaskSpec() *ScheduledTaskSpec
}

func init() {
	t["BaseScheduledTaskSpec"] = reflect.TypeOf((*ScheduledTaskSpec)(nil)).Elem()
}

func (b *ScsiLun) GetScsiLun() *ScsiLun { return b }

type BaseScsiLun interface {
	GetScsiLun() *ScsiLun
}

func init() {
	t["BaseScsiLun"] = reflect.TypeOf((*ScsiLun)(nil)).Elem()
}

func (b *SecurityError) GetSecurityError() *SecurityError { return b }

type BaseSecurityError interface {
	GetSecurityError() *SecurityError
}

func init() {
	t["BaseSecurityError"] = reflect.TypeOf((*SecurityError)(nil)).Elem()
}

func (b *SelectionSet) GetSelectionSet() *SelectionSet { return b }

type BaseSelectionSet interface {
	GetSelectionSet() *SelectionSet
}

func init() {
	t["BaseSelectionSet"] = reflect.TypeOf((*SelectionSet)(nil)).Elem()
}

func (b *SelectionSpec) GetSelectionSpec() *SelectionSpec { return b }

type BaseSelectionSpec interface {
	GetSelectionSpec() *SelectionSpec
}

func init() {
	t["BaseSelectionSpec"] = reflect.TypeOf((*SelectionSpec)(nil)).Elem()
}

func (b *ServiceLocatorCredential) GetServiceLocatorCredential() *ServiceLocatorCredential { return b }

type BaseServiceLocatorCredential interface {
	GetServiceLocatorCredential() *ServiceLocatorCredential
}

func init() {
	t["BaseServiceLocatorCredential"] = reflect.TypeOf((*ServiceLocatorCredential)(nil)).Elem()
}

func (b *SessionEvent) GetSessionEvent() *SessionEvent { return b }

type BaseSessionEvent interface {
	GetSessionEvent() *SessionEvent
}

func init() {
	t["BaseSessionEvent"] = reflect.TypeOf((*SessionEvent)(nil)).Elem()
}

func (b *SessionManagerServiceRequestSpec) GetSessionManagerServiceRequestSpec() *SessionManagerServiceRequestSpec {
	return b
}

type BaseSessionManagerServiceRequestSpec interface {
	GetSessionManagerServiceRequestSpec() *SessionManagerServiceRequestSpec
}

func init() {
	t["BaseSessionManagerServiceRequestSpec"] = reflect.TypeOf((*SessionManagerServiceRequestSpec)(nil)).Elem()
}

func (b *SnapshotCopyNotSupported) GetSnapshotCopyNotSupported() *SnapshotCopyNotSupported { return b }

type BaseSnapshotCopyNotSupported interface {
	GetSnapshotCopyNotSupported() *SnapshotCopyNotSupported
}

func init() {
	t["BaseSnapshotCopyNotSupported"] = reflect.TypeOf((*SnapshotCopyNotSupported)(nil)).Elem()
}

func (b *SnapshotFault) GetSnapshotFault() *SnapshotFault { return b }

type BaseSnapshotFault interface {
	GetSnapshotFault() *SnapshotFault
}

func init() {
	t["BaseSnapshotFault"] = reflect.TypeOf((*SnapshotFault)(nil)).Elem()
}

func (b *TaskEvent) GetTaskEvent() *TaskEvent { return b }

type BaseTaskEvent interface {
	GetTaskEvent() *TaskEvent
}

func init() {
	t["BaseTaskEvent"] = reflect.TypeOf((*TaskEvent)(nil)).Elem()
}

func (b *TaskInProgress) GetTaskInProgress() *TaskInProgress { return b }

type BaseTaskInProgress interface {
	GetTaskInProgress() *TaskInProgress
}

func init() {
	t["BaseTaskInProgress"] = reflect.TypeOf((*TaskInProgress)(nil)).Elem()
}

func (b *TaskReason) GetTaskReason() *TaskReason { return b }

type BaseTaskReason interface {
	GetTaskReason() *TaskReason
}

func init() {
	t["BaseTaskReason"] = reflect.TypeOf((*TaskReason)(nil)).Elem()
}

func (b *TaskScheduler) GetTaskScheduler() *TaskScheduler { return b }

type BaseTaskScheduler interface {
	GetTaskScheduler() *TaskScheduler
}

func init() {
	t["BaseTaskScheduler"] = reflect.TypeOf((*TaskScheduler)(nil)).Elem()
}

func (b *TemplateUpgradeEvent) GetTemplateUpgradeEvent() *TemplateUpgradeEvent { return b }

type BaseTemplateUpgradeEvent interface {
	GetTemplateUpgradeEvent() *TemplateUpgradeEvent
}

func init() {
	t["BaseTemplateUpgradeEvent"] = reflect.TypeOf((*TemplateUpgradeEvent)(nil)).Elem()
}

func (b *Timedout) GetTimedout() *Timedout { return b }

type BaseTimedout interface {
	GetTimedout() *Timedout
}

func init() {
	t["BaseTimedout"] = reflect.TypeOf((*Timedout)(nil)).Elem()
}

func (b *TypeDescription) GetTypeDescription() *TypeDescription { return b }

type BaseTypeDescription interface {
	GetTypeDescription() *TypeDescription
}

func init() {
	t["BaseTypeDescription"] = reflect.TypeOf((*TypeDescription)(nil)).Elem()
}

func (b *UnsupportedDatastore) GetUnsupportedDatastore() *UnsupportedDatastore { return b }

type BaseUnsupportedDatastore interface {
	GetUnsupportedDatastore() *UnsupportedDatastore
}

func init() {
	t["BaseUnsupportedDatastore"] = reflect.TypeOf((*UnsupportedDatastore)(nil)).Elem()
}

func (b *UpgradeEvent) GetUpgradeEvent() *UpgradeEvent { return b }

type BaseUpgradeEvent interface {
	GetUpgradeEvent() *UpgradeEvent
}

func init() {
	t["BaseUpgradeEvent"] = reflect.TypeOf((*UpgradeEvent)(nil)).Elem()
}

func (b *UserSearchResult) GetUserSearchResult() *UserSearchResult { return b }

type BaseUserSearchResult interface {
	GetUserSearchResult() *UserSearchResult
}

func init() {
	t["BaseUserSearchResult"] = reflect.TypeOf((*UserSearchResult)(nil)).Elem()
}

func (b *VAppConfigFault) GetVAppConfigFault() *VAppConfigFault { return b }

type BaseVAppConfigFault interface {
	GetVAppConfigFault() *VAppConfigFault
}

func init() {
	t["BaseVAppConfigFault"] = reflect.TypeOf((*VAppConfigFault)(nil)).Elem()
}

func (b *VAppPropertyFault) GetVAppPropertyFault() *VAppPropertyFault { return b }

type BaseVAppPropertyFault interface {
	GetVAppPropertyFault() *VAppPropertyFault
}

func init() {
	t["BaseVAppPropertyFault"] = reflect.TypeOf((*VAppPropertyFault)(nil)).Elem()
}

func (b *VMotionInterfaceIssue) GetVMotionInterfaceIssue() *VMotionInterfaceIssue { return b }

type BaseVMotionInterfaceIssue interface {
	GetVMotionInterfaceIssue() *VMotionInterfaceIssue
}

func init() {
	t["BaseVMotionInterfaceIssue"] = reflect.TypeOf((*VMotionInterfaceIssue)(nil)).Elem()
}

func (b *VMwareDVSHealthCheckConfig) GetVMwareDVSHealthCheckConfig() *VMwareDVSHealthCheckConfig {
	return b
}

type BaseVMwareDVSHealthCheckConfig interface {
	GetVMwareDVSHealthCheckConfig() *VMwareDVSHealthCheckConfig
}

func init() {
	t["BaseVMwareDVSHealthCheckConfig"] = reflect.TypeOf((*VMwareDVSHealthCheckConfig)(nil)).Elem()
}

func (b *VimFault) GetVimFault() *VimFault { return b }

type BaseVimFault interface {
	GetVimFault() *VimFault
}

func init() {
	t["BaseVimFault"] = reflect.TypeOf((*VimFault)(nil)).Elem()
}

func (b *VirtualController) GetVirtualController() *VirtualController { return b }

type BaseVirtualController interface {
	GetVirtualController() *VirtualController
}

func init() {
	t["BaseVirtualController"] = reflect.TypeOf((*VirtualController)(nil)).Elem()
}

func (b *VirtualControllerOption) GetVirtualControllerOption() *VirtualControllerOption { return b }

type BaseVirtualControllerOption interface {
	GetVirtualControllerOption() *VirtualControllerOption
}

func init() {
	t["BaseVirtualControllerOption"] = reflect.TypeOf((*VirtualControllerOption)(nil)).Elem()
}

func (b *VirtualDevice) GetVirtualDevice() *VirtualDevice { return b }

type BaseVirtualDevice interface {
	GetVirtualDevice() *VirtualDevice
}

func init() {
	t["BaseVirtualDevice"] = reflect.TypeOf((*VirtualDevice)(nil)).Elem()
}

func (b *VirtualDeviceBackingInfo) GetVirtualDeviceBackingInfo() *VirtualDeviceBackingInfo { return b }

type BaseVirtualDeviceBackingInfo interface {
	GetVirtualDeviceBackingInfo() *VirtualDeviceBackingInfo
}

func init() {
	t["BaseVirtualDeviceBackingInfo"] = reflect.TypeOf((*VirtualDeviceBackingInfo)(nil)).Elem()
}

func (b *VirtualDeviceBackingOption) GetVirtualDeviceBackingOption() *VirtualDeviceBackingOption {
	return b
}

type BaseVirtualDeviceBackingOption interface {
	GetVirtualDeviceBackingOption() *VirtualDeviceBackingOption
}

func init() {
	t["BaseVirtualDeviceBackingOption"] = reflect.TypeOf((*VirtualDeviceBackingOption)(nil)).Elem()
}

func (b *VirtualDeviceBusSlotInfo) GetVirtualDeviceBusSlotInfo() *VirtualDeviceBusSlotInfo { return b }

type BaseVirtualDeviceBusSlotInfo interface {
	GetVirtualDeviceBusSlotInfo() *VirtualDeviceBusSlotInfo
}

func init() {
	t["BaseVirtualDeviceBusSlotInfo"] = reflect.TypeOf((*VirtualDeviceBusSlotInfo)(nil)).Elem()
}

func (b *VirtualDeviceConfigSpec) GetVirtualDeviceConfigSpec() *VirtualDeviceConfigSpec { return b }

type BaseVirtualDeviceConfigSpec interface {
	GetVirtualDeviceConfigSpec() *VirtualDeviceConfigSpec
}

func init() {
	t["BaseVirtualDeviceConfigSpec"] = reflect.TypeOf((*VirtualDeviceConfigSpec)(nil)).Elem()
}

func (b *VirtualDeviceDeviceBackingInfo) GetVirtualDeviceDeviceBackingInfo() *VirtualDeviceDeviceBackingInfo {
	return b
}

type BaseVirtualDeviceDeviceBackingInfo interface {
	GetVirtualDeviceDeviceBackingInfo() *VirtualDeviceDeviceBackingInfo
}

func init() {
	t["BaseVirtualDeviceDeviceBackingInfo"] = reflect.TypeOf((*VirtualDeviceDeviceBackingInfo)(nil)).Elem()
}

func (b *VirtualDeviceDeviceBackingOption) GetVirtualDeviceDeviceBackingOption() *VirtualDeviceDeviceBackingOption {
	return b
}

type BaseVirtualDeviceDeviceBackingOption interface {
	GetVirtualDeviceDeviceBackingOption() *VirtualDeviceDeviceBackingOption
}

func init() {
	t["BaseVirtualDeviceDeviceBackingOption"] = reflect.TypeOf((*VirtualDeviceDeviceBackingOption)(nil)).Elem()
}

func (b *VirtualDeviceFileBackingInfo) GetVirtualDeviceFileBackingInfo() *VirtualDeviceFileBackingInfo {
	return b
}

type BaseVirtualDeviceFileBackingInfo interface {
	GetVirtualDeviceFileBackingInfo() *VirtualDeviceFileBackingInfo
}

func init() {
	t["BaseVirtualDeviceFileBackingInfo"] = reflect.TypeOf((*VirtualDeviceFileBackingInfo)(nil)).Elem()
}

func (b *VirtualDeviceFileBackingOption) GetVirtualDeviceFileBackingOption() *VirtualDeviceFileBackingOption {
	return b
}

type BaseVirtualDeviceFileBackingOption interface {
	GetVirtualDeviceFileBackingOption() *VirtualDeviceFileBackingOption
}

func init() {
	t["BaseVirtualDeviceFileBackingOption"] = reflect.TypeOf((*VirtualDeviceFileBackingOption)(nil)).Elem()
}

func (b *VirtualDeviceOption) GetVirtualDeviceOption() *VirtualDeviceOption { return b }

type BaseVirtualDeviceOption interface {
	GetVirtualDeviceOption() *VirtualDeviceOption
}

func init() {
	t["BaseVirtualDeviceOption"] = reflect.TypeOf((*VirtualDeviceOption)(nil)).Elem()
}

func (b *VirtualDevicePciBusSlotInfo) GetVirtualDevicePciBusSlotInfo() *VirtualDevicePciBusSlotInfo {
	return b
}

type BaseVirtualDevicePciBusSlotInfo interface {
	GetVirtualDevicePciBusSlotInfo() *VirtualDevicePciBusSlotInfo
}

func init() {
	t["BaseVirtualDevicePciBusSlotInfo"] = reflect.TypeOf((*VirtualDevicePciBusSlotInfo)(nil)).Elem()
}

func (b *VirtualDevicePipeBackingInfo) GetVirtualDevicePipeBackingInfo() *VirtualDevicePipeBackingInfo {
	return b
}

type BaseVirtualDevicePipeBackingInfo interface {
	GetVirtualDevicePipeBackingInfo() *VirtualDevicePipeBackingInfo
}

func init() {
	t["BaseVirtualDevicePipeBackingInfo"] = reflect.TypeOf((*VirtualDevicePipeBackingInfo)(nil)).Elem()
}

func (b *VirtualDevicePipeBackingOption) GetVirtualDevicePipeBackingOption() *VirtualDevicePipeBackingOption {
	return b
}

type BaseVirtualDevicePipeBackingOption interface {
	GetVirtualDevicePipeBackingOption() *VirtualDevicePipeBackingOption
}

func init() {
	t["BaseVirtualDevicePipeBackingOption"] = reflect.TypeOf((*VirtualDevicePipeBackingOption)(nil)).Elem()
}

func (b *VirtualDeviceRemoteDeviceBackingInfo) GetVirtualDeviceRemoteDeviceBackingInfo() *VirtualDeviceRemoteDeviceBackingInfo {
	return b
}

type BaseVirtualDeviceRemoteDeviceBackingInfo interface {
	GetVirtualDeviceRemoteDeviceBackingInfo() *VirtualDeviceRemoteDeviceBackingInfo
}

func init() {
	t["BaseVirtualDeviceRemoteDeviceBackingInfo"] = reflect.TypeOf((*VirtualDeviceRemoteDeviceBackingInfo)(nil)).Elem()
}

func (b *VirtualDeviceRemoteDeviceBackingOption) GetVirtualDeviceRemoteDeviceBackingOption() *VirtualDeviceRemoteDeviceBackingOption {
	return b
}

type BaseVirtualDeviceRemoteDeviceBackingOption interface {
	GetVirtualDeviceRemoteDeviceBackingOption() *VirtualDeviceRemoteDeviceBackingOption
}

func init() {
	t["BaseVirtualDeviceRemoteDeviceBackingOption"] = reflect.TypeOf((*VirtualDeviceRemoteDeviceBackingOption)(nil)).Elem()
}

func (b *VirtualDeviceURIBackingInfo) GetVirtualDeviceURIBackingInfo() *VirtualDeviceURIBackingInfo {
	return b
}

type BaseVirtualDeviceURIBackingInfo interface {
	GetVirtualDeviceURIBackingInfo() *VirtualDeviceURIBackingInfo
}

func init() {
	t["BaseVirtualDeviceURIBackingInfo"] = reflect.TypeOf((*VirtualDeviceURIBackingInfo)(nil)).Elem()
}

func (b *VirtualDeviceURIBackingOption) GetVirtualDeviceURIBackingOption() *VirtualDeviceURIBackingOption {
	return b
}

type BaseVirtualDeviceURIBackingOption interface {
	GetVirtualDeviceURIBackingOption() *VirtualDeviceURIBackingOption
}

func init() {
	t["BaseVirtualDeviceURIBackingOption"] = reflect.TypeOf((*VirtualDeviceURIBackingOption)(nil)).Elem()
}

func (b *VirtualDiskRawDiskVer2BackingInfo) GetVirtualDiskRawDiskVer2BackingInfo() *VirtualDiskRawDiskVer2BackingInfo {
	return b
}

type BaseVirtualDiskRawDiskVer2BackingInfo interface {
	GetVirtualDiskRawDiskVer2BackingInfo() *VirtualDiskRawDiskVer2BackingInfo
}

func init() {
	t["BaseVirtualDiskRawDiskVer2BackingInfo"] = reflect.TypeOf((*VirtualDiskRawDiskVer2BackingInfo)(nil)).Elem()
}

func (b *VirtualDiskRawDiskVer2BackingOption) GetVirtualDiskRawDiskVer2BackingOption() *VirtualDiskRawDiskVer2BackingOption {
	return b
}

type BaseVirtualDiskRawDiskVer2BackingOption interface {
	GetVirtualDiskRawDiskVer2BackingOption() *VirtualDiskRawDiskVer2BackingOption
}

func init() {
	t["BaseVirtualDiskRawDiskVer2BackingOption"] = reflect.TypeOf((*VirtualDiskRawDiskVer2BackingOption)(nil)).Elem()
}

func (b *VirtualDiskSpec) GetVirtualDiskSpec() *VirtualDiskSpec { return b }

type BaseVirtualDiskSpec interface {
	GetVirtualDiskSpec() *VirtualDiskSpec
}

func init() {
	t["BaseVirtualDiskSpec"] = reflect.TypeOf((*VirtualDiskSpec)(nil)).Elem()
}

func (b *VirtualEthernetCard) GetVirtualEthernetCard() *VirtualEthernetCard { return b }

type BaseVirtualEthernetCard interface {
	GetVirtualEthernetCard() *VirtualEthernetCard
}

func init() {
	t["BaseVirtualEthernetCard"] = reflect.TypeOf((*VirtualEthernetCard)(nil)).Elem()
}

func (b *VirtualEthernetCardOption) GetVirtualEthernetCardOption() *VirtualEthernetCardOption {
	return b
}

type BaseVirtualEthernetCardOption interface {
	GetVirtualEthernetCardOption() *VirtualEthernetCardOption
}

func init() {
	t["BaseVirtualEthernetCardOption"] = reflect.TypeOf((*VirtualEthernetCardOption)(nil)).Elem()
}

func (b *VirtualHardwareCompatibilityIssue) GetVirtualHardwareCompatibilityIssue() *VirtualHardwareCompatibilityIssue {
	return b
}

type BaseVirtualHardwareCompatibilityIssue interface {
	GetVirtualHardwareCompatibilityIssue() *VirtualHardwareCompatibilityIssue
}

func init() {
	t["BaseVirtualHardwareCompatibilityIssue"] = reflect.TypeOf((*VirtualHardwareCompatibilityIssue)(nil)).Elem()
}

func (b *VirtualMachineBootOptionsBootableDevice) GetVirtualMachineBootOptionsBootableDevice() *VirtualMachineBootOptionsBootableDevice {
	return b
}

type BaseVirtualMachineBootOptionsBootableDevice interface {
	GetVirtualMachineBootOptionsBootableDevice() *VirtualMachineBootOptionsBootableDevice
}

func init() {
	t["BaseVirtualMachineBootOptionsBootableDevice"] = reflect.TypeOf((*VirtualMachineBootOptionsBootableDevice)(nil)).Elem()
}

func (b *VirtualMachineDeviceRuntimeInfoDeviceRuntimeState) GetVirtualMachineDeviceRuntimeInfoDeviceRuntimeState() *VirtualMachineDeviceRuntimeInfoDeviceRuntimeState {
	return b
}

type BaseVirtualMachineDeviceRuntimeInfoDeviceRuntimeState interface {
	GetVirtualMachineDeviceRuntimeInfoDeviceRuntimeState() *VirtualMachineDeviceRuntimeInfoDeviceRuntimeState
}

func init() {
	t["BaseVirtualMachineDeviceRuntimeInfoDeviceRuntimeState"] = reflect.TypeOf((*VirtualMachineDeviceRuntimeInfoDeviceRuntimeState)(nil)).Elem()
}

func (b *VirtualMachineDiskDeviceInfo) GetVirtualMachineDiskDeviceInfo() *VirtualMachineDiskDeviceInfo {
	return b
}

type BaseVirtualMachineDiskDeviceInfo interface {
	GetVirtualMachineDiskDeviceInfo() *VirtualMachineDiskDeviceInfo
}

func init() {
	t["BaseVirtualMachineDiskDeviceInfo"] = reflect.TypeOf((*VirtualMachineDiskDeviceInfo)(nil)).Elem()
}

func (b *VirtualMachineGuestQuiesceSpec) GetVirtualMachineGuestQuiesceSpec() *VirtualMachineGuestQuiesceSpec {
	return b
}

type BaseVirtualMachineGuestQuiesceSpec interface {
	GetVirtualMachineGuestQuiesceSpec() *VirtualMachineGuestQuiesceSpec
}

func init() {
	t["BaseVirtualMachineGuestQuiesceSpec"] = reflect.TypeOf((*VirtualMachineGuestQuiesceSpec)(nil)).Elem()
}

func (b *VirtualMachinePciPassthroughInfo) GetVirtualMachinePciPassthroughInfo() *VirtualMachinePciPassthroughInfo {
	return b
}

type BaseVirtualMachinePciPassthroughInfo interface {
	GetVirtualMachinePciPassthroughInfo() *VirtualMachinePciPassthroughInfo
}

func init() {
	t["BaseVirtualMachinePciPassthroughInfo"] = reflect.TypeOf((*VirtualMachinePciPassthroughInfo)(nil)).Elem()
}

func (b *VirtualMachineProfileSpec) GetVirtualMachineProfileSpec() *VirtualMachineProfileSpec {
	return b
}

type BaseVirtualMachineProfileSpec interface {
	GetVirtualMachineProfileSpec() *VirtualMachineProfileSpec
}

func init() {
	t["BaseVirtualMachineProfileSpec"] = reflect.TypeOf((*VirtualMachineProfileSpec)(nil)).Elem()
}

func (b *VirtualMachineSriovDevicePoolInfo) GetVirtualMachineSriovDevicePoolInfo() *VirtualMachineSriovDevicePoolInfo {
	return b
}

type BaseVirtualMachineSriovDevicePoolInfo interface {
	GetVirtualMachineSriovDevicePoolInfo() *VirtualMachineSriovDevicePoolInfo
}

func init() {
	t["BaseVirtualMachineSriovDevicePoolInfo"] = reflect.TypeOf((*VirtualMachineSriovDevicePoolInfo)(nil)).Elem()
}

func (b *VirtualMachineTargetInfo) GetVirtualMachineTargetInfo() *VirtualMachineTargetInfo { return b }

type BaseVirtualMachineTargetInfo interface {
	GetVirtualMachineTargetInfo() *VirtualMachineTargetInfo
}

func init() {
	t["BaseVirtualMachineTargetInfo"] = reflect.TypeOf((*VirtualMachineTargetInfo)(nil)).Elem()
}

func (b *VirtualPCIPassthroughPluginBackingInfo) GetVirtualPCIPassthroughPluginBackingInfo() *VirtualPCIPassthroughPluginBackingInfo {
	return b
}

type BaseVirtualPCIPassthroughPluginBackingInfo interface {
	GetVirtualPCIPassthroughPluginBackingInfo() *VirtualPCIPassthroughPluginBackingInfo
}

func init() {
	t["BaseVirtualPCIPassthroughPluginBackingInfo"] = reflect.TypeOf((*VirtualPCIPassthroughPluginBackingInfo)(nil)).Elem()
}

func (b *VirtualPCIPassthroughPluginBackingOption) GetVirtualPCIPassthroughPluginBackingOption() *VirtualPCIPassthroughPluginBackingOption {
	return b
}

type BaseVirtualPCIPassthroughPluginBackingOption interface {
	GetVirtualPCIPassthroughPluginBackingOption() *VirtualPCIPassthroughPluginBackingOption
}

func init() {
	t["BaseVirtualPCIPassthroughPluginBackingOption"] = reflect.TypeOf((*VirtualPCIPassthroughPluginBackingOption)(nil)).Elem()
}

func (b *VirtualSATAController) GetVirtualSATAController() *VirtualSATAController { return b }

type BaseVirtualSATAController interface {
	GetVirtualSATAController() *VirtualSATAController
}

func init() {
	t["BaseVirtualSATAController"] = reflect.TypeOf((*VirtualSATAController)(nil)).Elem()
}

func (b *VirtualSATAControllerOption) GetVirtualSATAControllerOption() *VirtualSATAControllerOption {
	return b
}

type BaseVirtualSATAControllerOption interface {
	GetVirtualSATAControllerOption() *VirtualSATAControllerOption
}

func init() {
	t["BaseVirtualSATAControllerOption"] = reflect.TypeOf((*VirtualSATAControllerOption)(nil)).Elem()
}

func (b *VirtualSCSIController) GetVirtualSCSIController() *VirtualSCSIController { return b }

type BaseVirtualSCSIController interface {
	GetVirtualSCSIController() *VirtualSCSIController
}

func init() {
	t["BaseVirtualSCSIController"] = reflect.TypeOf((*VirtualSCSIController)(nil)).Elem()
}

func (b *VirtualSCSIControllerOption) GetVirtualSCSIControllerOption() *VirtualSCSIControllerOption {
	return b
}

type BaseVirtualSCSIControllerOption interface {
	GetVirtualSCSIControllerOption() *VirtualSCSIControllerOption
}

func init() {
	t["BaseVirtualSCSIControllerOption"] = reflect.TypeOf((*VirtualSCSIControllerOption)(nil)).Elem()
}

func (b *VirtualSoundCard) GetVirtualSoundCard() *VirtualSoundCard { return b }

type BaseVirtualSoundCard interface {
	GetVirtualSoundCard() *VirtualSoundCard
}

func init() {
	t["BaseVirtualSoundCard"] = reflect.TypeOf((*VirtualSoundCard)(nil)).Elem()
}

func (b *VirtualSoundCardOption) GetVirtualSoundCardOption() *VirtualSoundCardOption { return b }

type BaseVirtualSoundCardOption interface {
	GetVirtualSoundCardOption() *VirtualSoundCardOption
}

func init() {
	t["BaseVirtualSoundCardOption"] = reflect.TypeOf((*VirtualSoundCardOption)(nil)).Elem()
}

func (b *VirtualVmxnet) GetVirtualVmxnet() *VirtualVmxnet { return b }

type BaseVirtualVmxnet interface {
	GetVirtualVmxnet() *VirtualVmxnet
}

func init() {
	t["BaseVirtualVmxnet"] = reflect.TypeOf((*VirtualVmxnet)(nil)).Elem()
}

func (b *VirtualVmxnet3) GetVirtualVmxnet3() *VirtualVmxnet3 { return b }

type BaseVirtualVmxnet3 interface {
	GetVirtualVmxnet3() *VirtualVmxnet3
}

func init() {
	t["BaseVirtualVmxnet3"] = reflect.TypeOf((*VirtualVmxnet3)(nil)).Elem()
}

func (b *VirtualVmxnet3Option) GetVirtualVmxnet3Option() *VirtualVmxnet3Option { return b }

type BaseVirtualVmxnet3Option interface {
	GetVirtualVmxnet3Option() *VirtualVmxnet3Option
}

func init() {
	t["BaseVirtualVmxnet3Option"] = reflect.TypeOf((*VirtualVmxnet3Option)(nil)).Elem()
}

func (b *VirtualVmxnetOption) GetVirtualVmxnetOption() *VirtualVmxnetOption { return b }

type BaseVirtualVmxnetOption interface {
	GetVirtualVmxnetOption() *VirtualVmxnetOption
}

func init() {
	t["BaseVirtualVmxnetOption"] = reflect.TypeOf((*VirtualVmxnetOption)(nil)).Elem()
}

func (b *VmCloneEvent) GetVmCloneEvent() *VmCloneEvent { return b }

type BaseVmCloneEvent interface {
	GetVmCloneEvent() *VmCloneEvent
}

func init() {
	t["BaseVmCloneEvent"] = reflect.TypeOf((*VmCloneEvent)(nil)).Elem()
}

func (b *VmConfigFault) GetVmConfigFault() *VmConfigFault { return b }

type BaseVmConfigFault interface {
	GetVmConfigFault() *VmConfigFault
}

func init() {
	t["BaseVmConfigFault"] = reflect.TypeOf((*VmConfigFault)(nil)).Elem()
}

func (b *VmConfigFileInfo) GetVmConfigFileInfo() *VmConfigFileInfo { return b }

type BaseVmConfigFileInfo interface {
	GetVmConfigFileInfo() *VmConfigFileInfo
}

func init() {
	t["BaseVmConfigFileInfo"] = reflect.TypeOf((*VmConfigFileInfo)(nil)).Elem()
}

func (b *VmConfigFileQuery) GetVmConfigFileQuery() *VmConfigFileQuery { return b }

type BaseVmConfigFileQuery interface {
	GetVmConfigFileQuery() *VmConfigFileQuery
}

func init() {
	t["BaseVmConfigFileQuery"] = reflect.TypeOf((*VmConfigFileQuery)(nil)).Elem()
}

func (b *VmConfigInfo) GetVmConfigInfo() *VmConfigInfo { return b }

type BaseVmConfigInfo interface {
	GetVmConfigInfo() *VmConfigInfo
}

func init() {
	t["BaseVmConfigInfo"] = reflect.TypeOf((*VmConfigInfo)(nil)).Elem()
}

func (b *VmConfigSpec) GetVmConfigSpec() *VmConfigSpec { return b }

type BaseVmConfigSpec interface {
	GetVmConfigSpec() *VmConfigSpec
}

func init() {
	t["BaseVmConfigSpec"] = reflect.TypeOf((*VmConfigSpec)(nil)).Elem()
}

func (b *VmDasBeingResetEvent) GetVmDasBeingResetEvent() *VmDasBeingResetEvent { return b }

type BaseVmDasBeingResetEvent interface {
	GetVmDasBeingResetEvent() *VmDasBeingResetEvent
}

func init() {
	t["BaseVmDasBeingResetEvent"] = reflect.TypeOf((*VmDasBeingResetEvent)(nil)).Elem()
}

func (b *VmEvent) GetVmEvent() *VmEvent { return b }

type BaseVmEvent interface {
	GetVmEvent() *VmEvent
}

func init() {
	t["BaseVmEvent"] = reflect.TypeOf((*VmEvent)(nil)).Elem()
}

func (b *VmFaultToleranceIssue) GetVmFaultToleranceIssue() *VmFaultToleranceIssue { return b }

type BaseVmFaultToleranceIssue interface {
	GetVmFaultToleranceIssue() *VmFaultToleranceIssue
}

func init() {
	t["BaseVmFaultToleranceIssue"] = reflect.TypeOf((*VmFaultToleranceIssue)(nil)).Elem()
}

func (b *VmMigratedEvent) GetVmMigratedEvent() *VmMigratedEvent { return b }

type BaseVmMigratedEvent interface {
	GetVmMigratedEvent() *VmMigratedEvent
}

func init() {
	t["BaseVmMigratedEvent"] = reflect.TypeOf((*VmMigratedEvent)(nil)).Elem()
}

func (b *VmPoweredOffEvent) GetVmPoweredOffEvent() *VmPoweredOffEvent { return b }

type BaseVmPoweredOffEvent interface {
	GetVmPoweredOffEvent() *VmPoweredOffEvent
}

func init() {
	t["BaseVmPoweredOffEvent"] = reflect.TypeOf((*VmPoweredOffEvent)(nil)).Elem()
}

func (b *VmPoweredOnEvent) GetVmPoweredOnEvent() *VmPoweredOnEvent { return b }

type BaseVmPoweredOnEvent interface {
	GetVmPoweredOnEvent() *VmPoweredOnEvent
}

func init() {
	t["BaseVmPoweredOnEvent"] = reflect.TypeOf((*VmPoweredOnEvent)(nil)).Elem()
}

func (b *VmRelocateSpecEvent) GetVmRelocateSpecEvent() *VmRelocateSpecEvent { return b }

type BaseVmRelocateSpecEvent interface {
	GetVmRelocateSpecEvent() *VmRelocateSpecEvent
}

func init() {
	t["BaseVmRelocateSpecEvent"] = reflect.TypeOf((*VmRelocateSpecEvent)(nil)).Elem()
}

func (b *VmStartingEvent) GetVmStartingEvent() *VmStartingEvent { return b }

type BaseVmStartingEvent interface {
	GetVmStartingEvent() *VmStartingEvent
}

func init() {
	t["BaseVmStartingEvent"] = reflect.TypeOf((*VmStartingEvent)(nil)).Elem()
}

func (b *VmToolsUpgradeFault) GetVmToolsUpgradeFault() *VmToolsUpgradeFault { return b }

type BaseVmToolsUpgradeFault interface {
	GetVmToolsUpgradeFault() *VmToolsUpgradeFault
}

func init() {
	t["BaseVmToolsUpgradeFault"] = reflect.TypeOf((*VmToolsUpgradeFault)(nil)).Elem()
}

func (b *VmfsDatastoreBaseOption) GetVmfsDatastoreBaseOption() *VmfsDatastoreBaseOption { return b }

type BaseVmfsDatastoreBaseOption interface {
	GetVmfsDatastoreBaseOption() *VmfsDatastoreBaseOption
}

func init() {
	t["BaseVmfsDatastoreBaseOption"] = reflect.TypeOf((*VmfsDatastoreBaseOption)(nil)).Elem()
}

func (b *VmfsDatastoreSingleExtentOption) GetVmfsDatastoreSingleExtentOption() *VmfsDatastoreSingleExtentOption {
	return b
}

type BaseVmfsDatastoreSingleExtentOption interface {
	GetVmfsDatastoreSingleExtentOption() *VmfsDatastoreSingleExtentOption
}

func init() {
	t["BaseVmfsDatastoreSingleExtentOption"] = reflect.TypeOf((*VmfsDatastoreSingleExtentOption)(nil)).Elem()
}

func (b *VmfsDatastoreSpec) GetVmfsDatastoreSpec() *VmfsDatastoreSpec { return b }

type BaseVmfsDatastoreSpec interface {
	GetVmfsDatastoreSpec() *VmfsDatastoreSpec
}

func init() {
	t["BaseVmfsDatastoreSpec"] = reflect.TypeOf((*VmfsDatastoreSpec)(nil)).Elem()
}

func (b *VmfsMountFault) GetVmfsMountFault() *VmfsMountFault { return b }

type BaseVmfsMountFault interface {
	GetVmfsMountFault() *VmfsMountFault
}

func init() {
	t["BaseVmfsMountFault"] = reflect.TypeOf((*VmfsMountFault)(nil)).Elem()
}

func (b *VmwareDistributedVirtualSwitchVlanSpec) GetVmwareDistributedVirtualSwitchVlanSpec() *VmwareDistributedVirtualSwitchVlanSpec {
	return b
}

type BaseVmwareDistributedVirtualSwitchVlanSpec interface {
	GetVmwareDistributedVirtualSwitchVlanSpec() *VmwareDistributedVirtualSwitchVlanSpec
}

func init() {
	t["BaseVmwareDistributedVirtualSwitchVlanSpec"] = reflect.TypeOf((*VmwareDistributedVirtualSwitchVlanSpec)(nil)).Elem()
}

func (b *VsanDiskFault) GetVsanDiskFault() *VsanDiskFault { return b }

type BaseVsanDiskFault interface {
	GetVsanDiskFault() *VsanDiskFault
}

func init() {
	t["BaseVsanDiskFault"] = reflect.TypeOf((*VsanDiskFault)(nil)).Elem()
}

func (b *VsanFault) GetVsanFault() *VsanFault { return b }

type BaseVsanFault interface {
	GetVsanFault() *VsanFault
}

func init() {
	t["BaseVsanFault"] = reflect.TypeOf((*VsanFault)(nil)).Elem()
}

func (b *VsanUpgradeSystemPreflightCheckIssue) GetVsanUpgradeSystemPreflightCheckIssue() *VsanUpgradeSystemPreflightCheckIssue {
	return b
}

type BaseVsanUpgradeSystemPreflightCheckIssue interface {
	GetVsanUpgradeSystemPreflightCheckIssue() *VsanUpgradeSystemPreflightCheckIssue
}

func init() {
	t["BaseVsanUpgradeSystemPreflightCheckIssue"] = reflect.TypeOf((*VsanUpgradeSystemPreflightCheckIssue)(nil)).Elem()
}

func (b *VsanUpgradeSystemUpgradeHistoryItem) GetVsanUpgradeSystemUpgradeHistoryItem() *VsanUpgradeSystemUpgradeHistoryItem {
	return b
}

type BaseVsanUpgradeSystemUpgradeHistoryItem interface {
	GetVsanUpgradeSystemUpgradeHistoryItem() *VsanUpgradeSystemUpgradeHistoryItem
}

func init() {
	t["BaseVsanUpgradeSystemUpgradeHistoryItem"] = reflect.TypeOf((*VsanUpgradeSystemUpgradeHistoryItem)(nil)).Elem()
}

func (b *VslmCreateSpecBackingSpec) GetVslmCreateSpecBackingSpec() *VslmCreateSpecBackingSpec {
	return b
}

type BaseVslmCreateSpecBackingSpec interface {
	GetVslmCreateSpecBackingSpec() *VslmCreateSpecBackingSpec
}

func init() {
	t["BaseVslmCreateSpecBackingSpec"] = reflect.TypeOf((*VslmCreateSpecBackingSpec)(nil)).Elem()
}

func (b *VslmMigrateSpec) GetVslmMigrateSpec() *VslmMigrateSpec { return b }

type BaseVslmMigrateSpec interface {
	GetVslmMigrateSpec() *VslmMigrateSpec
}

func init() {
	t["BaseVslmMigrateSpec"] = reflect.TypeOf((*VslmMigrateSpec)(nil)).Elem()
}