github.com/vmware/govmomi@v0.37.1/vim25/types/if.go (about)

     1  /*
     2  Copyright (c) 2014-2023 VMware, Inc. All Rights Reserved.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package types
    18  
    19  import "reflect"
    20  
    21  func (b *Action) GetAction() *Action { return b }
    22  
    23  type BaseAction interface {
    24  	GetAction() *Action
    25  }
    26  
    27  func init() {
    28  	t["BaseAction"] = reflect.TypeOf((*Action)(nil)).Elem()
    29  }
    30  
    31  func (b *ActiveDirectoryFault) GetActiveDirectoryFault() *ActiveDirectoryFault { return b }
    32  
    33  type BaseActiveDirectoryFault interface {
    34  	GetActiveDirectoryFault() *ActiveDirectoryFault
    35  }
    36  
    37  func init() {
    38  	t["BaseActiveDirectoryFault"] = reflect.TypeOf((*ActiveDirectoryFault)(nil)).Elem()
    39  }
    40  
    41  func (b *AlarmAction) GetAlarmAction() *AlarmAction { return b }
    42  
    43  type BaseAlarmAction interface {
    44  	GetAlarmAction() *AlarmAction
    45  }
    46  
    47  func init() {
    48  	t["BaseAlarmAction"] = reflect.TypeOf((*AlarmAction)(nil)).Elem()
    49  }
    50  
    51  func (b *AlarmEvent) GetAlarmEvent() *AlarmEvent { return b }
    52  
    53  type BaseAlarmEvent interface {
    54  	GetAlarmEvent() *AlarmEvent
    55  }
    56  
    57  func init() {
    58  	t["BaseAlarmEvent"] = reflect.TypeOf((*AlarmEvent)(nil)).Elem()
    59  }
    60  
    61  func (b *AlarmExpression) GetAlarmExpression() *AlarmExpression { return b }
    62  
    63  type BaseAlarmExpression interface {
    64  	GetAlarmExpression() *AlarmExpression
    65  }
    66  
    67  func init() {
    68  	t["BaseAlarmExpression"] = reflect.TypeOf((*AlarmExpression)(nil)).Elem()
    69  }
    70  
    71  func (b *AlarmSpec) GetAlarmSpec() *AlarmSpec { return b }
    72  
    73  type BaseAlarmSpec interface {
    74  	GetAlarmSpec() *AlarmSpec
    75  }
    76  
    77  func init() {
    78  	t["BaseAlarmSpec"] = reflect.TypeOf((*AlarmSpec)(nil)).Elem()
    79  }
    80  
    81  func (b *AnswerFileCreateSpec) GetAnswerFileCreateSpec() *AnswerFileCreateSpec { return b }
    82  
    83  type BaseAnswerFileCreateSpec interface {
    84  	GetAnswerFileCreateSpec() *AnswerFileCreateSpec
    85  }
    86  
    87  func init() {
    88  	t["BaseAnswerFileCreateSpec"] = reflect.TypeOf((*AnswerFileCreateSpec)(nil)).Elem()
    89  }
    90  
    91  func (b *ApplyProfile) GetApplyProfile() *ApplyProfile { return b }
    92  
    93  type BaseApplyProfile interface {
    94  	GetApplyProfile() *ApplyProfile
    95  }
    96  
    97  func init() {
    98  	t["BaseApplyProfile"] = reflect.TypeOf((*ApplyProfile)(nil)).Elem()
    99  }
   100  
   101  func (b *ArrayUpdateSpec) GetArrayUpdateSpec() *ArrayUpdateSpec { return b }
   102  
   103  type BaseArrayUpdateSpec interface {
   104  	GetArrayUpdateSpec() *ArrayUpdateSpec
   105  }
   106  
   107  func init() {
   108  	t["BaseArrayUpdateSpec"] = reflect.TypeOf((*ArrayUpdateSpec)(nil)).Elem()
   109  }
   110  
   111  func (b *AuthorizationEvent) GetAuthorizationEvent() *AuthorizationEvent { return b }
   112  
   113  type BaseAuthorizationEvent interface {
   114  	GetAuthorizationEvent() *AuthorizationEvent
   115  }
   116  
   117  func init() {
   118  	t["BaseAuthorizationEvent"] = reflect.TypeOf((*AuthorizationEvent)(nil)).Elem()
   119  }
   120  
   121  func (b *BaseConfigInfo) GetBaseConfigInfo() *BaseConfigInfo { return b }
   122  
   123  type BaseBaseConfigInfo interface {
   124  	GetBaseConfigInfo() *BaseConfigInfo
   125  }
   126  
   127  func init() {
   128  	t["BaseBaseConfigInfo"] = reflect.TypeOf((*BaseConfigInfo)(nil)).Elem()
   129  }
   130  
   131  func (b *BaseConfigInfoBackingInfo) GetBaseConfigInfoBackingInfo() *BaseConfigInfoBackingInfo {
   132  	return b
   133  }
   134  
   135  type BaseBaseConfigInfoBackingInfo interface {
   136  	GetBaseConfigInfoBackingInfo() *BaseConfigInfoBackingInfo
   137  }
   138  
   139  func init() {
   140  	t["BaseBaseConfigInfoBackingInfo"] = reflect.TypeOf((*BaseConfigInfoBackingInfo)(nil)).Elem()
   141  }
   142  
   143  func (b *BaseConfigInfoFileBackingInfo) GetBaseConfigInfoFileBackingInfo() *BaseConfigInfoFileBackingInfo {
   144  	return b
   145  }
   146  
   147  type BaseBaseConfigInfoFileBackingInfo interface {
   148  	GetBaseConfigInfoFileBackingInfo() *BaseConfigInfoFileBackingInfo
   149  }
   150  
   151  func init() {
   152  	t["BaseBaseConfigInfoFileBackingInfo"] = reflect.TypeOf((*BaseConfigInfoFileBackingInfo)(nil)).Elem()
   153  }
   154  
   155  func (b *CannotAccessNetwork) GetCannotAccessNetwork() *CannotAccessNetwork { return b }
   156  
   157  type BaseCannotAccessNetwork interface {
   158  	GetCannotAccessNetwork() *CannotAccessNetwork
   159  }
   160  
   161  func init() {
   162  	t["BaseCannotAccessNetwork"] = reflect.TypeOf((*CannotAccessNetwork)(nil)).Elem()
   163  }
   164  
   165  func (b *CannotAccessVmComponent) GetCannotAccessVmComponent() *CannotAccessVmComponent { return b }
   166  
   167  type BaseCannotAccessVmComponent interface {
   168  	GetCannotAccessVmComponent() *CannotAccessVmComponent
   169  }
   170  
   171  func init() {
   172  	t["BaseCannotAccessVmComponent"] = reflect.TypeOf((*CannotAccessVmComponent)(nil)).Elem()
   173  }
   174  
   175  func (b *CannotAccessVmDevice) GetCannotAccessVmDevice() *CannotAccessVmDevice { return b }
   176  
   177  type BaseCannotAccessVmDevice interface {
   178  	GetCannotAccessVmDevice() *CannotAccessVmDevice
   179  }
   180  
   181  func init() {
   182  	t["BaseCannotAccessVmDevice"] = reflect.TypeOf((*CannotAccessVmDevice)(nil)).Elem()
   183  }
   184  
   185  func (b *CannotAccessVmDisk) GetCannotAccessVmDisk() *CannotAccessVmDisk { return b }
   186  
   187  type BaseCannotAccessVmDisk interface {
   188  	GetCannotAccessVmDisk() *CannotAccessVmDisk
   189  }
   190  
   191  func init() {
   192  	t["BaseCannotAccessVmDisk"] = reflect.TypeOf((*CannotAccessVmDisk)(nil)).Elem()
   193  }
   194  
   195  func (b *CannotMoveVsanEnabledHost) GetCannotMoveVsanEnabledHost() *CannotMoveVsanEnabledHost {
   196  	return b
   197  }
   198  
   199  type BaseCannotMoveVsanEnabledHost interface {
   200  	GetCannotMoveVsanEnabledHost() *CannotMoveVsanEnabledHost
   201  }
   202  
   203  func init() {
   204  	t["BaseCannotMoveVsanEnabledHost"] = reflect.TypeOf((*CannotMoveVsanEnabledHost)(nil)).Elem()
   205  }
   206  
   207  func (b *ClusterAction) GetClusterAction() *ClusterAction { return b }
   208  
   209  type BaseClusterAction interface {
   210  	GetClusterAction() *ClusterAction
   211  }
   212  
   213  func init() {
   214  	t["BaseClusterAction"] = reflect.TypeOf((*ClusterAction)(nil)).Elem()
   215  }
   216  
   217  func (b *ClusterComputeResourceValidationResultBase) GetClusterComputeResourceValidationResultBase() *ClusterComputeResourceValidationResultBase {
   218  	return b
   219  }
   220  
   221  type BaseClusterComputeResourceValidationResultBase interface {
   222  	GetClusterComputeResourceValidationResultBase() *ClusterComputeResourceValidationResultBase
   223  }
   224  
   225  func init() {
   226  	t["BaseClusterComputeResourceValidationResultBase"] = reflect.TypeOf((*ClusterComputeResourceValidationResultBase)(nil)).Elem()
   227  }
   228  
   229  func (b *ClusterDasAdmissionControlInfo) GetClusterDasAdmissionControlInfo() *ClusterDasAdmissionControlInfo {
   230  	return b
   231  }
   232  
   233  type BaseClusterDasAdmissionControlInfo interface {
   234  	GetClusterDasAdmissionControlInfo() *ClusterDasAdmissionControlInfo
   235  }
   236  
   237  func init() {
   238  	t["BaseClusterDasAdmissionControlInfo"] = reflect.TypeOf((*ClusterDasAdmissionControlInfo)(nil)).Elem()
   239  }
   240  
   241  func (b *ClusterDasAdmissionControlPolicy) GetClusterDasAdmissionControlPolicy() *ClusterDasAdmissionControlPolicy {
   242  	return b
   243  }
   244  
   245  type BaseClusterDasAdmissionControlPolicy interface {
   246  	GetClusterDasAdmissionControlPolicy() *ClusterDasAdmissionControlPolicy
   247  }
   248  
   249  func init() {
   250  	t["BaseClusterDasAdmissionControlPolicy"] = reflect.TypeOf((*ClusterDasAdmissionControlPolicy)(nil)).Elem()
   251  }
   252  
   253  func (b *ClusterDasAdvancedRuntimeInfo) GetClusterDasAdvancedRuntimeInfo() *ClusterDasAdvancedRuntimeInfo {
   254  	return b
   255  }
   256  
   257  type BaseClusterDasAdvancedRuntimeInfo interface {
   258  	GetClusterDasAdvancedRuntimeInfo() *ClusterDasAdvancedRuntimeInfo
   259  }
   260  
   261  func init() {
   262  	t["BaseClusterDasAdvancedRuntimeInfo"] = reflect.TypeOf((*ClusterDasAdvancedRuntimeInfo)(nil)).Elem()
   263  }
   264  
   265  func (b *ClusterDasData) GetClusterDasData() *ClusterDasData { return b }
   266  
   267  type BaseClusterDasData interface {
   268  	GetClusterDasData() *ClusterDasData
   269  }
   270  
   271  func init() {
   272  	t["BaseClusterDasData"] = reflect.TypeOf((*ClusterDasData)(nil)).Elem()
   273  }
   274  
   275  func (b *ClusterDasHostInfo) GetClusterDasHostInfo() *ClusterDasHostInfo { return b }
   276  
   277  type BaseClusterDasHostInfo interface {
   278  	GetClusterDasHostInfo() *ClusterDasHostInfo
   279  }
   280  
   281  func init() {
   282  	t["BaseClusterDasHostInfo"] = reflect.TypeOf((*ClusterDasHostInfo)(nil)).Elem()
   283  }
   284  
   285  func (b *ClusterDrsFaultsFaultsByVm) GetClusterDrsFaultsFaultsByVm() *ClusterDrsFaultsFaultsByVm {
   286  	return b
   287  }
   288  
   289  type BaseClusterDrsFaultsFaultsByVm interface {
   290  	GetClusterDrsFaultsFaultsByVm() *ClusterDrsFaultsFaultsByVm
   291  }
   292  
   293  func init() {
   294  	t["BaseClusterDrsFaultsFaultsByVm"] = reflect.TypeOf((*ClusterDrsFaultsFaultsByVm)(nil)).Elem()
   295  }
   296  
   297  func (b *ClusterEvent) GetClusterEvent() *ClusterEvent { return b }
   298  
   299  type BaseClusterEvent interface {
   300  	GetClusterEvent() *ClusterEvent
   301  }
   302  
   303  func init() {
   304  	t["BaseClusterEvent"] = reflect.TypeOf((*ClusterEvent)(nil)).Elem()
   305  }
   306  
   307  func (b *ClusterGroupInfo) GetClusterGroupInfo() *ClusterGroupInfo { return b }
   308  
   309  type BaseClusterGroupInfo interface {
   310  	GetClusterGroupInfo() *ClusterGroupInfo
   311  }
   312  
   313  func init() {
   314  	t["BaseClusterGroupInfo"] = reflect.TypeOf((*ClusterGroupInfo)(nil)).Elem()
   315  }
   316  
   317  func (b *ClusterOvercommittedEvent) GetClusterOvercommittedEvent() *ClusterOvercommittedEvent {
   318  	return b
   319  }
   320  
   321  type BaseClusterOvercommittedEvent interface {
   322  	GetClusterOvercommittedEvent() *ClusterOvercommittedEvent
   323  }
   324  
   325  func init() {
   326  	t["BaseClusterOvercommittedEvent"] = reflect.TypeOf((*ClusterOvercommittedEvent)(nil)).Elem()
   327  }
   328  
   329  func (b *ClusterProfileConfigSpec) GetClusterProfileConfigSpec() *ClusterProfileConfigSpec { return b }
   330  
   331  type BaseClusterProfileConfigSpec interface {
   332  	GetClusterProfileConfigSpec() *ClusterProfileConfigSpec
   333  }
   334  
   335  func init() {
   336  	t["BaseClusterProfileConfigSpec"] = reflect.TypeOf((*ClusterProfileConfigSpec)(nil)).Elem()
   337  }
   338  
   339  func (b *ClusterProfileCreateSpec) GetClusterProfileCreateSpec() *ClusterProfileCreateSpec { return b }
   340  
   341  type BaseClusterProfileCreateSpec interface {
   342  	GetClusterProfileCreateSpec() *ClusterProfileCreateSpec
   343  }
   344  
   345  func init() {
   346  	t["BaseClusterProfileCreateSpec"] = reflect.TypeOf((*ClusterProfileCreateSpec)(nil)).Elem()
   347  }
   348  
   349  func (b *ClusterRuleInfo) GetClusterRuleInfo() *ClusterRuleInfo { return b }
   350  
   351  type BaseClusterRuleInfo interface {
   352  	GetClusterRuleInfo() *ClusterRuleInfo
   353  }
   354  
   355  func init() {
   356  	t["BaseClusterRuleInfo"] = reflect.TypeOf((*ClusterRuleInfo)(nil)).Elem()
   357  }
   358  
   359  func (b *ClusterSlotPolicy) GetClusterSlotPolicy() *ClusterSlotPolicy { return b }
   360  
   361  type BaseClusterSlotPolicy interface {
   362  	GetClusterSlotPolicy() *ClusterSlotPolicy
   363  }
   364  
   365  func init() {
   366  	t["BaseClusterSlotPolicy"] = reflect.TypeOf((*ClusterSlotPolicy)(nil)).Elem()
   367  }
   368  
   369  func (b *ClusterStatusChangedEvent) GetClusterStatusChangedEvent() *ClusterStatusChangedEvent {
   370  	return b
   371  }
   372  
   373  type BaseClusterStatusChangedEvent interface {
   374  	GetClusterStatusChangedEvent() *ClusterStatusChangedEvent
   375  }
   376  
   377  func init() {
   378  	t["BaseClusterStatusChangedEvent"] = reflect.TypeOf((*ClusterStatusChangedEvent)(nil)).Elem()
   379  }
   380  
   381  func (b *ComputeResourceConfigInfo) GetComputeResourceConfigInfo() *ComputeResourceConfigInfo {
   382  	return b
   383  }
   384  
   385  type BaseComputeResourceConfigInfo interface {
   386  	GetComputeResourceConfigInfo() *ComputeResourceConfigInfo
   387  }
   388  
   389  func init() {
   390  	t["BaseComputeResourceConfigInfo"] = reflect.TypeOf((*ComputeResourceConfigInfo)(nil)).Elem()
   391  }
   392  
   393  func (b *ComputeResourceConfigSpec) GetComputeResourceConfigSpec() *ComputeResourceConfigSpec {
   394  	return b
   395  }
   396  
   397  type BaseComputeResourceConfigSpec interface {
   398  	GetComputeResourceConfigSpec() *ComputeResourceConfigSpec
   399  }
   400  
   401  func init() {
   402  	t["BaseComputeResourceConfigSpec"] = reflect.TypeOf((*ComputeResourceConfigSpec)(nil)).Elem()
   403  }
   404  
   405  func (b *ComputeResourceSummary) GetComputeResourceSummary() *ComputeResourceSummary { return b }
   406  
   407  type BaseComputeResourceSummary interface {
   408  	GetComputeResourceSummary() *ComputeResourceSummary
   409  }
   410  
   411  func init() {
   412  	t["BaseComputeResourceSummary"] = reflect.TypeOf((*ComputeResourceSummary)(nil)).Elem()
   413  }
   414  
   415  func (b *CpuIncompatible) GetCpuIncompatible() *CpuIncompatible { return b }
   416  
   417  type BaseCpuIncompatible interface {
   418  	GetCpuIncompatible() *CpuIncompatible
   419  }
   420  
   421  func init() {
   422  	t["BaseCpuIncompatible"] = reflect.TypeOf((*CpuIncompatible)(nil)).Elem()
   423  }
   424  
   425  func (b *CryptoSpec) GetCryptoSpec() *CryptoSpec { return b }
   426  
   427  type BaseCryptoSpec interface {
   428  	GetCryptoSpec() *CryptoSpec
   429  }
   430  
   431  func init() {
   432  	t["BaseCryptoSpec"] = reflect.TypeOf((*CryptoSpec)(nil)).Elem()
   433  }
   434  
   435  func (b *CryptoSpecNoOp) GetCryptoSpecNoOp() *CryptoSpecNoOp { return b }
   436  
   437  type BaseCryptoSpecNoOp interface {
   438  	GetCryptoSpecNoOp() *CryptoSpecNoOp
   439  }
   440  
   441  func init() {
   442  	t["BaseCryptoSpecNoOp"] = reflect.TypeOf((*CryptoSpecNoOp)(nil)).Elem()
   443  }
   444  
   445  func (b *CustomFieldDefEvent) GetCustomFieldDefEvent() *CustomFieldDefEvent { return b }
   446  
   447  type BaseCustomFieldDefEvent interface {
   448  	GetCustomFieldDefEvent() *CustomFieldDefEvent
   449  }
   450  
   451  func init() {
   452  	t["BaseCustomFieldDefEvent"] = reflect.TypeOf((*CustomFieldDefEvent)(nil)).Elem()
   453  }
   454  
   455  func (b *CustomFieldEvent) GetCustomFieldEvent() *CustomFieldEvent { return b }
   456  
   457  type BaseCustomFieldEvent interface {
   458  	GetCustomFieldEvent() *CustomFieldEvent
   459  }
   460  
   461  func init() {
   462  	t["BaseCustomFieldEvent"] = reflect.TypeOf((*CustomFieldEvent)(nil)).Elem()
   463  }
   464  
   465  func (b *CustomFieldValue) GetCustomFieldValue() *CustomFieldValue { return b }
   466  
   467  type BaseCustomFieldValue interface {
   468  	GetCustomFieldValue() *CustomFieldValue
   469  }
   470  
   471  func init() {
   472  	t["BaseCustomFieldValue"] = reflect.TypeOf((*CustomFieldValue)(nil)).Elem()
   473  }
   474  
   475  func (b *CustomizationEvent) GetCustomizationEvent() *CustomizationEvent { return b }
   476  
   477  type BaseCustomizationEvent interface {
   478  	GetCustomizationEvent() *CustomizationEvent
   479  }
   480  
   481  func init() {
   482  	t["BaseCustomizationEvent"] = reflect.TypeOf((*CustomizationEvent)(nil)).Elem()
   483  }
   484  
   485  func (b *CustomizationFailed) GetCustomizationFailed() *CustomizationFailed { return b }
   486  
   487  type BaseCustomizationFailed interface {
   488  	GetCustomizationFailed() *CustomizationFailed
   489  }
   490  
   491  func init() {
   492  	t["BaseCustomizationFailed"] = reflect.TypeOf((*CustomizationFailed)(nil)).Elem()
   493  }
   494  
   495  func (b *CustomizationFault) GetCustomizationFault() *CustomizationFault { return b }
   496  
   497  type BaseCustomizationFault interface {
   498  	GetCustomizationFault() *CustomizationFault
   499  }
   500  
   501  func init() {
   502  	t["BaseCustomizationFault"] = reflect.TypeOf((*CustomizationFault)(nil)).Elem()
   503  }
   504  
   505  func (b *CustomizationIdentitySettings) GetCustomizationIdentitySettings() *CustomizationIdentitySettings {
   506  	return b
   507  }
   508  
   509  type BaseCustomizationIdentitySettings interface {
   510  	GetCustomizationIdentitySettings() *CustomizationIdentitySettings
   511  }
   512  
   513  func init() {
   514  	t["BaseCustomizationIdentitySettings"] = reflect.TypeOf((*CustomizationIdentitySettings)(nil)).Elem()
   515  }
   516  
   517  func (b *CustomizationIpGenerator) GetCustomizationIpGenerator() *CustomizationIpGenerator { return b }
   518  
   519  type BaseCustomizationIpGenerator interface {
   520  	GetCustomizationIpGenerator() *CustomizationIpGenerator
   521  }
   522  
   523  func init() {
   524  	t["BaseCustomizationIpGenerator"] = reflect.TypeOf((*CustomizationIpGenerator)(nil)).Elem()
   525  }
   526  
   527  func (b *CustomizationIpV6Generator) GetCustomizationIpV6Generator() *CustomizationIpV6Generator {
   528  	return b
   529  }
   530  
   531  type BaseCustomizationIpV6Generator interface {
   532  	GetCustomizationIpV6Generator() *CustomizationIpV6Generator
   533  }
   534  
   535  func init() {
   536  	t["BaseCustomizationIpV6Generator"] = reflect.TypeOf((*CustomizationIpV6Generator)(nil)).Elem()
   537  }
   538  
   539  func (b *CustomizationName) GetCustomizationName() *CustomizationName { return b }
   540  
   541  type BaseCustomizationName interface {
   542  	GetCustomizationName() *CustomizationName
   543  }
   544  
   545  func init() {
   546  	t["BaseCustomizationName"] = reflect.TypeOf((*CustomizationName)(nil)).Elem()
   547  }
   548  
   549  func (b *CustomizationOptions) GetCustomizationOptions() *CustomizationOptions { return b }
   550  
   551  type BaseCustomizationOptions interface {
   552  	GetCustomizationOptions() *CustomizationOptions
   553  }
   554  
   555  func init() {
   556  	t["BaseCustomizationOptions"] = reflect.TypeOf((*CustomizationOptions)(nil)).Elem()
   557  }
   558  
   559  func (b *DVPortSetting) GetDVPortSetting() *DVPortSetting { return b }
   560  
   561  type BaseDVPortSetting interface {
   562  	GetDVPortSetting() *DVPortSetting
   563  }
   564  
   565  func init() {
   566  	t["BaseDVPortSetting"] = reflect.TypeOf((*DVPortSetting)(nil)).Elem()
   567  }
   568  
   569  func (b *DVPortgroupEvent) GetDVPortgroupEvent() *DVPortgroupEvent { return b }
   570  
   571  type BaseDVPortgroupEvent interface {
   572  	GetDVPortgroupEvent() *DVPortgroupEvent
   573  }
   574  
   575  func init() {
   576  	t["BaseDVPortgroupEvent"] = reflect.TypeOf((*DVPortgroupEvent)(nil)).Elem()
   577  }
   578  
   579  func (b *DVPortgroupPolicy) GetDVPortgroupPolicy() *DVPortgroupPolicy { return b }
   580  
   581  type BaseDVPortgroupPolicy interface {
   582  	GetDVPortgroupPolicy() *DVPortgroupPolicy
   583  }
   584  
   585  func init() {
   586  	t["BaseDVPortgroupPolicy"] = reflect.TypeOf((*DVPortgroupPolicy)(nil)).Elem()
   587  }
   588  
   589  func (b *DVSConfigInfo) GetDVSConfigInfo() *DVSConfigInfo { return b }
   590  
   591  type BaseDVSConfigInfo interface {
   592  	GetDVSConfigInfo() *DVSConfigInfo
   593  }
   594  
   595  func init() {
   596  	t["BaseDVSConfigInfo"] = reflect.TypeOf((*DVSConfigInfo)(nil)).Elem()
   597  }
   598  
   599  func (b *DVSConfigSpec) GetDVSConfigSpec() *DVSConfigSpec { return b }
   600  
   601  type BaseDVSConfigSpec interface {
   602  	GetDVSConfigSpec() *DVSConfigSpec
   603  }
   604  
   605  func init() {
   606  	t["BaseDVSConfigSpec"] = reflect.TypeOf((*DVSConfigSpec)(nil)).Elem()
   607  }
   608  
   609  func (b *DVSFeatureCapability) GetDVSFeatureCapability() *DVSFeatureCapability { return b }
   610  
   611  type BaseDVSFeatureCapability interface {
   612  	GetDVSFeatureCapability() *DVSFeatureCapability
   613  }
   614  
   615  func init() {
   616  	t["BaseDVSFeatureCapability"] = reflect.TypeOf((*DVSFeatureCapability)(nil)).Elem()
   617  }
   618  
   619  func (b *DVSHealthCheckCapability) GetDVSHealthCheckCapability() *DVSHealthCheckCapability { return b }
   620  
   621  type BaseDVSHealthCheckCapability interface {
   622  	GetDVSHealthCheckCapability() *DVSHealthCheckCapability
   623  }
   624  
   625  func init() {
   626  	t["BaseDVSHealthCheckCapability"] = reflect.TypeOf((*DVSHealthCheckCapability)(nil)).Elem()
   627  }
   628  
   629  func (b *DVSHealthCheckConfig) GetDVSHealthCheckConfig() *DVSHealthCheckConfig { return b }
   630  
   631  type BaseDVSHealthCheckConfig interface {
   632  	GetDVSHealthCheckConfig() *DVSHealthCheckConfig
   633  }
   634  
   635  func init() {
   636  	t["BaseDVSHealthCheckConfig"] = reflect.TypeOf((*DVSHealthCheckConfig)(nil)).Elem()
   637  }
   638  
   639  func (b *DVSUplinkPortPolicy) GetDVSUplinkPortPolicy() *DVSUplinkPortPolicy { return b }
   640  
   641  type BaseDVSUplinkPortPolicy interface {
   642  	GetDVSUplinkPortPolicy() *DVSUplinkPortPolicy
   643  }
   644  
   645  func init() {
   646  	t["BaseDVSUplinkPortPolicy"] = reflect.TypeOf((*DVSUplinkPortPolicy)(nil)).Elem()
   647  }
   648  
   649  func (b *DailyTaskScheduler) GetDailyTaskScheduler() *DailyTaskScheduler { return b }
   650  
   651  type BaseDailyTaskScheduler interface {
   652  	GetDailyTaskScheduler() *DailyTaskScheduler
   653  }
   654  
   655  func init() {
   656  	t["BaseDailyTaskScheduler"] = reflect.TypeOf((*DailyTaskScheduler)(nil)).Elem()
   657  }
   658  
   659  func (b *DatacenterEvent) GetDatacenterEvent() *DatacenterEvent { return b }
   660  
   661  type BaseDatacenterEvent interface {
   662  	GetDatacenterEvent() *DatacenterEvent
   663  }
   664  
   665  func init() {
   666  	t["BaseDatacenterEvent"] = reflect.TypeOf((*DatacenterEvent)(nil)).Elem()
   667  }
   668  
   669  func (b *DatastoreEvent) GetDatastoreEvent() *DatastoreEvent { return b }
   670  
   671  type BaseDatastoreEvent interface {
   672  	GetDatastoreEvent() *DatastoreEvent
   673  }
   674  
   675  func init() {
   676  	t["BaseDatastoreEvent"] = reflect.TypeOf((*DatastoreEvent)(nil)).Elem()
   677  }
   678  
   679  func (b *DatastoreFileEvent) GetDatastoreFileEvent() *DatastoreFileEvent { return b }
   680  
   681  type BaseDatastoreFileEvent interface {
   682  	GetDatastoreFileEvent() *DatastoreFileEvent
   683  }
   684  
   685  func init() {
   686  	t["BaseDatastoreFileEvent"] = reflect.TypeOf((*DatastoreFileEvent)(nil)).Elem()
   687  }
   688  
   689  func (b *DatastoreInfo) GetDatastoreInfo() *DatastoreInfo { return b }
   690  
   691  type BaseDatastoreInfo interface {
   692  	GetDatastoreInfo() *DatastoreInfo
   693  }
   694  
   695  func init() {
   696  	t["BaseDatastoreInfo"] = reflect.TypeOf((*DatastoreInfo)(nil)).Elem()
   697  }
   698  
   699  func (b *DatastoreNotWritableOnHost) GetDatastoreNotWritableOnHost() *DatastoreNotWritableOnHost {
   700  	return b
   701  }
   702  
   703  type BaseDatastoreNotWritableOnHost interface {
   704  	GetDatastoreNotWritableOnHost() *DatastoreNotWritableOnHost
   705  }
   706  
   707  func init() {
   708  	t["BaseDatastoreNotWritableOnHost"] = reflect.TypeOf((*DatastoreNotWritableOnHost)(nil)).Elem()
   709  }
   710  
   711  func (b *Description) GetDescription() *Description { return b }
   712  
   713  type BaseDescription interface {
   714  	GetDescription() *Description
   715  }
   716  
   717  func init() {
   718  	t["BaseDescription"] = reflect.TypeOf((*Description)(nil)).Elem()
   719  }
   720  
   721  func (b *DeviceBackingNotSupported) GetDeviceBackingNotSupported() *DeviceBackingNotSupported {
   722  	return b
   723  }
   724  
   725  type BaseDeviceBackingNotSupported interface {
   726  	GetDeviceBackingNotSupported() *DeviceBackingNotSupported
   727  }
   728  
   729  func init() {
   730  	t["BaseDeviceBackingNotSupported"] = reflect.TypeOf((*DeviceBackingNotSupported)(nil)).Elem()
   731  }
   732  
   733  func (b *DeviceNotSupported) GetDeviceNotSupported() *DeviceNotSupported { return b }
   734  
   735  type BaseDeviceNotSupported interface {
   736  	GetDeviceNotSupported() *DeviceNotSupported
   737  }
   738  
   739  func init() {
   740  	t["BaseDeviceNotSupported"] = reflect.TypeOf((*DeviceNotSupported)(nil)).Elem()
   741  }
   742  
   743  func (b *DiskNotSupported) GetDiskNotSupported() *DiskNotSupported { return b }
   744  
   745  type BaseDiskNotSupported interface {
   746  	GetDiskNotSupported() *DiskNotSupported
   747  }
   748  
   749  func init() {
   750  	t["BaseDiskNotSupported"] = reflect.TypeOf((*DiskNotSupported)(nil)).Elem()
   751  }
   752  
   753  func (b *DistributedVirtualSwitchHostMemberBacking) GetDistributedVirtualSwitchHostMemberBacking() *DistributedVirtualSwitchHostMemberBacking {
   754  	return b
   755  }
   756  
   757  type BaseDistributedVirtualSwitchHostMemberBacking interface {
   758  	GetDistributedVirtualSwitchHostMemberBacking() *DistributedVirtualSwitchHostMemberBacking
   759  }
   760  
   761  func init() {
   762  	t["BaseDistributedVirtualSwitchHostMemberBacking"] = reflect.TypeOf((*DistributedVirtualSwitchHostMemberBacking)(nil)).Elem()
   763  }
   764  
   765  func (b *DistributedVirtualSwitchManagerHostDvsFilterSpec) GetDistributedVirtualSwitchManagerHostDvsFilterSpec() *DistributedVirtualSwitchManagerHostDvsFilterSpec {
   766  	return b
   767  }
   768  
   769  type BaseDistributedVirtualSwitchManagerHostDvsFilterSpec interface {
   770  	GetDistributedVirtualSwitchManagerHostDvsFilterSpec() *DistributedVirtualSwitchManagerHostDvsFilterSpec
   771  }
   772  
   773  func init() {
   774  	t["BaseDistributedVirtualSwitchManagerHostDvsFilterSpec"] = reflect.TypeOf((*DistributedVirtualSwitchManagerHostDvsFilterSpec)(nil)).Elem()
   775  }
   776  
   777  func (b *DvsEvent) GetDvsEvent() *DvsEvent { return b }
   778  
   779  type BaseDvsEvent interface {
   780  	GetDvsEvent() *DvsEvent
   781  }
   782  
   783  func init() {
   784  	t["BaseDvsEvent"] = reflect.TypeOf((*DvsEvent)(nil)).Elem()
   785  }
   786  
   787  func (b *DvsFault) GetDvsFault() *DvsFault { return b }
   788  
   789  type BaseDvsFault interface {
   790  	GetDvsFault() *DvsFault
   791  }
   792  
   793  func init() {
   794  	t["BaseDvsFault"] = reflect.TypeOf((*DvsFault)(nil)).Elem()
   795  }
   796  
   797  func (b *DvsFilterConfig) GetDvsFilterConfig() *DvsFilterConfig { return b }
   798  
   799  type BaseDvsFilterConfig interface {
   800  	GetDvsFilterConfig() *DvsFilterConfig
   801  }
   802  
   803  func init() {
   804  	t["BaseDvsFilterConfig"] = reflect.TypeOf((*DvsFilterConfig)(nil)).Elem()
   805  }
   806  
   807  func (b *DvsHealthStatusChangeEvent) GetDvsHealthStatusChangeEvent() *DvsHealthStatusChangeEvent {
   808  	return b
   809  }
   810  
   811  type BaseDvsHealthStatusChangeEvent interface {
   812  	GetDvsHealthStatusChangeEvent() *DvsHealthStatusChangeEvent
   813  }
   814  
   815  func init() {
   816  	t["BaseDvsHealthStatusChangeEvent"] = reflect.TypeOf((*DvsHealthStatusChangeEvent)(nil)).Elem()
   817  }
   818  
   819  func (b *DvsIpPort) GetDvsIpPort() *DvsIpPort { return b }
   820  
   821  type BaseDvsIpPort interface {
   822  	GetDvsIpPort() *DvsIpPort
   823  }
   824  
   825  func init() {
   826  	t["BaseDvsIpPort"] = reflect.TypeOf((*DvsIpPort)(nil)).Elem()
   827  }
   828  
   829  func (b *DvsNetworkRuleAction) GetDvsNetworkRuleAction() *DvsNetworkRuleAction { return b }
   830  
   831  type BaseDvsNetworkRuleAction interface {
   832  	GetDvsNetworkRuleAction() *DvsNetworkRuleAction
   833  }
   834  
   835  func init() {
   836  	t["BaseDvsNetworkRuleAction"] = reflect.TypeOf((*DvsNetworkRuleAction)(nil)).Elem()
   837  }
   838  
   839  func (b *DvsNetworkRuleQualifier) GetDvsNetworkRuleQualifier() *DvsNetworkRuleQualifier { return b }
   840  
   841  type BaseDvsNetworkRuleQualifier interface {
   842  	GetDvsNetworkRuleQualifier() *DvsNetworkRuleQualifier
   843  }
   844  
   845  func init() {
   846  	t["BaseDvsNetworkRuleQualifier"] = reflect.TypeOf((*DvsNetworkRuleQualifier)(nil)).Elem()
   847  }
   848  
   849  func (b *DvsTrafficFilterConfig) GetDvsTrafficFilterConfig() *DvsTrafficFilterConfig { return b }
   850  
   851  type BaseDvsTrafficFilterConfig interface {
   852  	GetDvsTrafficFilterConfig() *DvsTrafficFilterConfig
   853  }
   854  
   855  func init() {
   856  	t["BaseDvsTrafficFilterConfig"] = reflect.TypeOf((*DvsTrafficFilterConfig)(nil)).Elem()
   857  }
   858  
   859  func (b *DvsVNicProfile) GetDvsVNicProfile() *DvsVNicProfile { return b }
   860  
   861  type BaseDvsVNicProfile interface {
   862  	GetDvsVNicProfile() *DvsVNicProfile
   863  }
   864  
   865  func init() {
   866  	t["BaseDvsVNicProfile"] = reflect.TypeOf((*DvsVNicProfile)(nil)).Elem()
   867  }
   868  
   869  func (b *DynamicData) GetDynamicData() *DynamicData { return b }
   870  
   871  type BaseDynamicData interface {
   872  	GetDynamicData() *DynamicData
   873  }
   874  
   875  func init() {
   876  	t["BaseDynamicData"] = reflect.TypeOf((*DynamicData)(nil)).Elem()
   877  }
   878  
   879  func (b *EVCAdmissionFailed) GetEVCAdmissionFailed() *EVCAdmissionFailed { return b }
   880  
   881  type BaseEVCAdmissionFailed interface {
   882  	GetEVCAdmissionFailed() *EVCAdmissionFailed
   883  }
   884  
   885  func init() {
   886  	t["BaseEVCAdmissionFailed"] = reflect.TypeOf((*EVCAdmissionFailed)(nil)).Elem()
   887  }
   888  
   889  func (b *EVCConfigFault) GetEVCConfigFault() *EVCConfigFault { return b }
   890  
   891  type BaseEVCConfigFault interface {
   892  	GetEVCConfigFault() *EVCConfigFault
   893  }
   894  
   895  func init() {
   896  	t["BaseEVCConfigFault"] = reflect.TypeOf((*EVCConfigFault)(nil)).Elem()
   897  }
   898  
   899  func (b *ElementDescription) GetElementDescription() *ElementDescription { return b }
   900  
   901  type BaseElementDescription interface {
   902  	GetElementDescription() *ElementDescription
   903  }
   904  
   905  func init() {
   906  	t["BaseElementDescription"] = reflect.TypeOf((*ElementDescription)(nil)).Elem()
   907  }
   908  
   909  func (b *EnteredStandbyModeEvent) GetEnteredStandbyModeEvent() *EnteredStandbyModeEvent { return b }
   910  
   911  type BaseEnteredStandbyModeEvent interface {
   912  	GetEnteredStandbyModeEvent() *EnteredStandbyModeEvent
   913  }
   914  
   915  func init() {
   916  	t["BaseEnteredStandbyModeEvent"] = reflect.TypeOf((*EnteredStandbyModeEvent)(nil)).Elem()
   917  }
   918  
   919  func (b *EnteringStandbyModeEvent) GetEnteringStandbyModeEvent() *EnteringStandbyModeEvent { return b }
   920  
   921  type BaseEnteringStandbyModeEvent interface {
   922  	GetEnteringStandbyModeEvent() *EnteringStandbyModeEvent
   923  }
   924  
   925  func init() {
   926  	t["BaseEnteringStandbyModeEvent"] = reflect.TypeOf((*EnteringStandbyModeEvent)(nil)).Elem()
   927  }
   928  
   929  func (b *EntityEventArgument) GetEntityEventArgument() *EntityEventArgument { return b }
   930  
   931  type BaseEntityEventArgument interface {
   932  	GetEntityEventArgument() *EntityEventArgument
   933  }
   934  
   935  func init() {
   936  	t["BaseEntityEventArgument"] = reflect.TypeOf((*EntityEventArgument)(nil)).Elem()
   937  }
   938  
   939  func (b *Event) GetEvent() *Event { return b }
   940  
   941  type BaseEvent interface {
   942  	GetEvent() *Event
   943  }
   944  
   945  func init() {
   946  	t["BaseEvent"] = reflect.TypeOf((*Event)(nil)).Elem()
   947  }
   948  
   949  func (b *EventArgument) GetEventArgument() *EventArgument { return b }
   950  
   951  type BaseEventArgument interface {
   952  	GetEventArgument() *EventArgument
   953  }
   954  
   955  func init() {
   956  	t["BaseEventArgument"] = reflect.TypeOf((*EventArgument)(nil)).Elem()
   957  }
   958  
   959  func (b *ExitStandbyModeFailedEvent) GetExitStandbyModeFailedEvent() *ExitStandbyModeFailedEvent {
   960  	return b
   961  }
   962  
   963  type BaseExitStandbyModeFailedEvent interface {
   964  	GetExitStandbyModeFailedEvent() *ExitStandbyModeFailedEvent
   965  }
   966  
   967  func init() {
   968  	t["BaseExitStandbyModeFailedEvent"] = reflect.TypeOf((*ExitStandbyModeFailedEvent)(nil)).Elem()
   969  }
   970  
   971  func (b *ExitedStandbyModeEvent) GetExitedStandbyModeEvent() *ExitedStandbyModeEvent { return b }
   972  
   973  type BaseExitedStandbyModeEvent interface {
   974  	GetExitedStandbyModeEvent() *ExitedStandbyModeEvent
   975  }
   976  
   977  func init() {
   978  	t["BaseExitedStandbyModeEvent"] = reflect.TypeOf((*ExitedStandbyModeEvent)(nil)).Elem()
   979  }
   980  
   981  func (b *ExitingStandbyModeEvent) GetExitingStandbyModeEvent() *ExitingStandbyModeEvent { return b }
   982  
   983  type BaseExitingStandbyModeEvent interface {
   984  	GetExitingStandbyModeEvent() *ExitingStandbyModeEvent
   985  }
   986  
   987  func init() {
   988  	t["BaseExitingStandbyModeEvent"] = reflect.TypeOf((*ExitingStandbyModeEvent)(nil)).Elem()
   989  }
   990  
   991  func (b *ExpiredFeatureLicense) GetExpiredFeatureLicense() *ExpiredFeatureLicense { return b }
   992  
   993  type BaseExpiredFeatureLicense interface {
   994  	GetExpiredFeatureLicense() *ExpiredFeatureLicense
   995  }
   996  
   997  func init() {
   998  	t["BaseExpiredFeatureLicense"] = reflect.TypeOf((*ExpiredFeatureLicense)(nil)).Elem()
   999  }
  1000  
  1001  func (b *FaultToleranceConfigInfo) GetFaultToleranceConfigInfo() *FaultToleranceConfigInfo { return b }
  1002  
  1003  type BaseFaultToleranceConfigInfo interface {
  1004  	GetFaultToleranceConfigInfo() *FaultToleranceConfigInfo
  1005  }
  1006  
  1007  func init() {
  1008  	t["BaseFaultToleranceConfigInfo"] = reflect.TypeOf((*FaultToleranceConfigInfo)(nil)).Elem()
  1009  }
  1010  
  1011  func (b *FcoeFault) GetFcoeFault() *FcoeFault { return b }
  1012  
  1013  type BaseFcoeFault interface {
  1014  	GetFcoeFault() *FcoeFault
  1015  }
  1016  
  1017  func init() {
  1018  	t["BaseFcoeFault"] = reflect.TypeOf((*FcoeFault)(nil)).Elem()
  1019  }
  1020  
  1021  func (b *FileBackedVirtualDiskSpec) GetFileBackedVirtualDiskSpec() *FileBackedVirtualDiskSpec {
  1022  	return b
  1023  }
  1024  
  1025  type BaseFileBackedVirtualDiskSpec interface {
  1026  	GetFileBackedVirtualDiskSpec() *FileBackedVirtualDiskSpec
  1027  }
  1028  
  1029  func init() {
  1030  	t["BaseFileBackedVirtualDiskSpec"] = reflect.TypeOf((*FileBackedVirtualDiskSpec)(nil)).Elem()
  1031  }
  1032  
  1033  func (b *FileFault) GetFileFault() *FileFault { return b }
  1034  
  1035  type BaseFileFault interface {
  1036  	GetFileFault() *FileFault
  1037  }
  1038  
  1039  func init() {
  1040  	t["BaseFileFault"] = reflect.TypeOf((*FileFault)(nil)).Elem()
  1041  }
  1042  
  1043  func (b *FileInfo) GetFileInfo() *FileInfo { return b }
  1044  
  1045  type BaseFileInfo interface {
  1046  	GetFileInfo() *FileInfo
  1047  }
  1048  
  1049  func init() {
  1050  	t["BaseFileInfo"] = reflect.TypeOf((*FileInfo)(nil)).Elem()
  1051  }
  1052  
  1053  func (b *FileQuery) GetFileQuery() *FileQuery { return b }
  1054  
  1055  type BaseFileQuery interface {
  1056  	GetFileQuery() *FileQuery
  1057  }
  1058  
  1059  func init() {
  1060  	t["BaseFileQuery"] = reflect.TypeOf((*FileQuery)(nil)).Elem()
  1061  }
  1062  
  1063  func (b *GatewayConnectFault) GetGatewayConnectFault() *GatewayConnectFault { return b }
  1064  
  1065  type BaseGatewayConnectFault interface {
  1066  	GetGatewayConnectFault() *GatewayConnectFault
  1067  }
  1068  
  1069  func init() {
  1070  	t["BaseGatewayConnectFault"] = reflect.TypeOf((*GatewayConnectFault)(nil)).Elem()
  1071  }
  1072  
  1073  func (b *GatewayToHostConnectFault) GetGatewayToHostConnectFault() *GatewayToHostConnectFault {
  1074  	return b
  1075  }
  1076  
  1077  type BaseGatewayToHostConnectFault interface {
  1078  	GetGatewayToHostConnectFault() *GatewayToHostConnectFault
  1079  }
  1080  
  1081  func init() {
  1082  	t["BaseGatewayToHostConnectFault"] = reflect.TypeOf((*GatewayToHostConnectFault)(nil)).Elem()
  1083  }
  1084  
  1085  func (b *GeneralEvent) GetGeneralEvent() *GeneralEvent { return b }
  1086  
  1087  type BaseGeneralEvent interface {
  1088  	GetGeneralEvent() *GeneralEvent
  1089  }
  1090  
  1091  func init() {
  1092  	t["BaseGeneralEvent"] = reflect.TypeOf((*GeneralEvent)(nil)).Elem()
  1093  }
  1094  
  1095  func (b *GuestAuthSubject) GetGuestAuthSubject() *GuestAuthSubject { return b }
  1096  
  1097  type BaseGuestAuthSubject interface {
  1098  	GetGuestAuthSubject() *GuestAuthSubject
  1099  }
  1100  
  1101  func init() {
  1102  	t["BaseGuestAuthSubject"] = reflect.TypeOf((*GuestAuthSubject)(nil)).Elem()
  1103  }
  1104  
  1105  func (b *GuestAuthentication) GetGuestAuthentication() *GuestAuthentication { return b }
  1106  
  1107  type BaseGuestAuthentication interface {
  1108  	GetGuestAuthentication() *GuestAuthentication
  1109  }
  1110  
  1111  func init() {
  1112  	t["BaseGuestAuthentication"] = reflect.TypeOf((*GuestAuthentication)(nil)).Elem()
  1113  }
  1114  
  1115  func (b *GuestFileAttributes) GetGuestFileAttributes() *GuestFileAttributes { return b }
  1116  
  1117  type BaseGuestFileAttributes interface {
  1118  	GetGuestFileAttributes() *GuestFileAttributes
  1119  }
  1120  
  1121  func init() {
  1122  	t["BaseGuestFileAttributes"] = reflect.TypeOf((*GuestFileAttributes)(nil)).Elem()
  1123  }
  1124  
  1125  func (b *GuestOperationsFault) GetGuestOperationsFault() *GuestOperationsFault { return b }
  1126  
  1127  type BaseGuestOperationsFault interface {
  1128  	GetGuestOperationsFault() *GuestOperationsFault
  1129  }
  1130  
  1131  func init() {
  1132  	t["BaseGuestOperationsFault"] = reflect.TypeOf((*GuestOperationsFault)(nil)).Elem()
  1133  }
  1134  
  1135  func (b *GuestProgramSpec) GetGuestProgramSpec() *GuestProgramSpec { return b }
  1136  
  1137  type BaseGuestProgramSpec interface {
  1138  	GetGuestProgramSpec() *GuestProgramSpec
  1139  }
  1140  
  1141  func init() {
  1142  	t["BaseGuestProgramSpec"] = reflect.TypeOf((*GuestProgramSpec)(nil)).Elem()
  1143  }
  1144  
  1145  func (b *GuestRegValueDataSpec) GetGuestRegValueDataSpec() *GuestRegValueDataSpec { return b }
  1146  
  1147  type BaseGuestRegValueDataSpec interface {
  1148  	GetGuestRegValueDataSpec() *GuestRegValueDataSpec
  1149  }
  1150  
  1151  func init() {
  1152  	t["BaseGuestRegValueDataSpec"] = reflect.TypeOf((*GuestRegValueDataSpec)(nil)).Elem()
  1153  }
  1154  
  1155  func (b *GuestRegistryFault) GetGuestRegistryFault() *GuestRegistryFault { return b }
  1156  
  1157  type BaseGuestRegistryFault interface {
  1158  	GetGuestRegistryFault() *GuestRegistryFault
  1159  }
  1160  
  1161  func init() {
  1162  	t["BaseGuestRegistryFault"] = reflect.TypeOf((*GuestRegistryFault)(nil)).Elem()
  1163  }
  1164  
  1165  func (b *GuestRegistryKeyFault) GetGuestRegistryKeyFault() *GuestRegistryKeyFault { return b }
  1166  
  1167  type BaseGuestRegistryKeyFault interface {
  1168  	GetGuestRegistryKeyFault() *GuestRegistryKeyFault
  1169  }
  1170  
  1171  func init() {
  1172  	t["BaseGuestRegistryKeyFault"] = reflect.TypeOf((*GuestRegistryKeyFault)(nil)).Elem()
  1173  }
  1174  
  1175  func (b *GuestRegistryValueFault) GetGuestRegistryValueFault() *GuestRegistryValueFault { return b }
  1176  
  1177  type BaseGuestRegistryValueFault interface {
  1178  	GetGuestRegistryValueFault() *GuestRegistryValueFault
  1179  }
  1180  
  1181  func init() {
  1182  	t["BaseGuestRegistryValueFault"] = reflect.TypeOf((*GuestRegistryValueFault)(nil)).Elem()
  1183  }
  1184  
  1185  func (b *HostAccountSpec) GetHostAccountSpec() *HostAccountSpec { return b }
  1186  
  1187  type BaseHostAccountSpec interface {
  1188  	GetHostAccountSpec() *HostAccountSpec
  1189  }
  1190  
  1191  func init() {
  1192  	t["BaseHostAccountSpec"] = reflect.TypeOf((*HostAccountSpec)(nil)).Elem()
  1193  }
  1194  
  1195  func (b *HostAuthenticationStoreInfo) GetHostAuthenticationStoreInfo() *HostAuthenticationStoreInfo {
  1196  	return b
  1197  }
  1198  
  1199  type BaseHostAuthenticationStoreInfo interface {
  1200  	GetHostAuthenticationStoreInfo() *HostAuthenticationStoreInfo
  1201  }
  1202  
  1203  func init() {
  1204  	t["BaseHostAuthenticationStoreInfo"] = reflect.TypeOf((*HostAuthenticationStoreInfo)(nil)).Elem()
  1205  }
  1206  
  1207  func (b *HostCommunication) GetHostCommunication() *HostCommunication { return b }
  1208  
  1209  type BaseHostCommunication interface {
  1210  	GetHostCommunication() *HostCommunication
  1211  }
  1212  
  1213  func init() {
  1214  	t["BaseHostCommunication"] = reflect.TypeOf((*HostCommunication)(nil)).Elem()
  1215  }
  1216  
  1217  func (b *HostConfigFault) GetHostConfigFault() *HostConfigFault { return b }
  1218  
  1219  type BaseHostConfigFault interface {
  1220  	GetHostConfigFault() *HostConfigFault
  1221  }
  1222  
  1223  func init() {
  1224  	t["BaseHostConfigFault"] = reflect.TypeOf((*HostConfigFault)(nil)).Elem()
  1225  }
  1226  
  1227  func (b *HostConnectFault) GetHostConnectFault() *HostConnectFault { return b }
  1228  
  1229  type BaseHostConnectFault interface {
  1230  	GetHostConnectFault() *HostConnectFault
  1231  }
  1232  
  1233  func init() {
  1234  	t["BaseHostConnectFault"] = reflect.TypeOf((*HostConnectFault)(nil)).Elem()
  1235  }
  1236  
  1237  func (b *HostConnectInfoNetworkInfo) GetHostConnectInfoNetworkInfo() *HostConnectInfoNetworkInfo {
  1238  	return b
  1239  }
  1240  
  1241  type BaseHostConnectInfoNetworkInfo interface {
  1242  	GetHostConnectInfoNetworkInfo() *HostConnectInfoNetworkInfo
  1243  }
  1244  
  1245  func init() {
  1246  	t["BaseHostConnectInfoNetworkInfo"] = reflect.TypeOf((*HostConnectInfoNetworkInfo)(nil)).Elem()
  1247  }
  1248  
  1249  func (b *HostDasEvent) GetHostDasEvent() *HostDasEvent { return b }
  1250  
  1251  type BaseHostDasEvent interface {
  1252  	GetHostDasEvent() *HostDasEvent
  1253  }
  1254  
  1255  func init() {
  1256  	t["BaseHostDasEvent"] = reflect.TypeOf((*HostDasEvent)(nil)).Elem()
  1257  }
  1258  
  1259  func (b *HostDataTransportConnectionInfo) GetHostDataTransportConnectionInfo() *HostDataTransportConnectionInfo {
  1260  	return b
  1261  }
  1262  
  1263  type BaseHostDataTransportConnectionInfo interface {
  1264  	GetHostDataTransportConnectionInfo() *HostDataTransportConnectionInfo
  1265  }
  1266  
  1267  func init() {
  1268  	t["BaseHostDataTransportConnectionInfo"] = reflect.TypeOf((*HostDataTransportConnectionInfo)(nil)).Elem()
  1269  }
  1270  
  1271  func (b *HostDatastoreConnectInfo) GetHostDatastoreConnectInfo() *HostDatastoreConnectInfo { return b }
  1272  
  1273  type BaseHostDatastoreConnectInfo interface {
  1274  	GetHostDatastoreConnectInfo() *HostDatastoreConnectInfo
  1275  }
  1276  
  1277  func init() {
  1278  	t["BaseHostDatastoreConnectInfo"] = reflect.TypeOf((*HostDatastoreConnectInfo)(nil)).Elem()
  1279  }
  1280  
  1281  func (b *HostDevice) GetHostDevice() *HostDevice { return b }
  1282  
  1283  type BaseHostDevice interface {
  1284  	GetHostDevice() *HostDevice
  1285  }
  1286  
  1287  func init() {
  1288  	t["BaseHostDevice"] = reflect.TypeOf((*HostDevice)(nil)).Elem()
  1289  }
  1290  
  1291  func (b *HostDigestInfo) GetHostDigestInfo() *HostDigestInfo { return b }
  1292  
  1293  type BaseHostDigestInfo interface {
  1294  	GetHostDigestInfo() *HostDigestInfo
  1295  }
  1296  
  1297  func init() {
  1298  	t["BaseHostDigestInfo"] = reflect.TypeOf((*HostDigestInfo)(nil)).Elem()
  1299  }
  1300  
  1301  func (b *HostDirectoryStoreInfo) GetHostDirectoryStoreInfo() *HostDirectoryStoreInfo { return b }
  1302  
  1303  type BaseHostDirectoryStoreInfo interface {
  1304  	GetHostDirectoryStoreInfo() *HostDirectoryStoreInfo
  1305  }
  1306  
  1307  func init() {
  1308  	t["BaseHostDirectoryStoreInfo"] = reflect.TypeOf((*HostDirectoryStoreInfo)(nil)).Elem()
  1309  }
  1310  
  1311  func (b *HostDnsConfig) GetHostDnsConfig() *HostDnsConfig { return b }
  1312  
  1313  type BaseHostDnsConfig interface {
  1314  	GetHostDnsConfig() *HostDnsConfig
  1315  }
  1316  
  1317  func init() {
  1318  	t["BaseHostDnsConfig"] = reflect.TypeOf((*HostDnsConfig)(nil)).Elem()
  1319  }
  1320  
  1321  func (b *HostEvent) GetHostEvent() *HostEvent { return b }
  1322  
  1323  type BaseHostEvent interface {
  1324  	GetHostEvent() *HostEvent
  1325  }
  1326  
  1327  func init() {
  1328  	t["BaseHostEvent"] = reflect.TypeOf((*HostEvent)(nil)).Elem()
  1329  }
  1330  
  1331  func (b *HostFibreChannelHba) GetHostFibreChannelHba() *HostFibreChannelHba { return b }
  1332  
  1333  type BaseHostFibreChannelHba interface {
  1334  	GetHostFibreChannelHba() *HostFibreChannelHba
  1335  }
  1336  
  1337  func init() {
  1338  	t["BaseHostFibreChannelHba"] = reflect.TypeOf((*HostFibreChannelHba)(nil)).Elem()
  1339  }
  1340  
  1341  func (b *HostFibreChannelTargetTransport) GetHostFibreChannelTargetTransport() *HostFibreChannelTargetTransport {
  1342  	return b
  1343  }
  1344  
  1345  type BaseHostFibreChannelTargetTransport interface {
  1346  	GetHostFibreChannelTargetTransport() *HostFibreChannelTargetTransport
  1347  }
  1348  
  1349  func init() {
  1350  	t["BaseHostFibreChannelTargetTransport"] = reflect.TypeOf((*HostFibreChannelTargetTransport)(nil)).Elem()
  1351  }
  1352  
  1353  func (b *HostFileSystemVolume) GetHostFileSystemVolume() *HostFileSystemVolume { return b }
  1354  
  1355  type BaseHostFileSystemVolume interface {
  1356  	GetHostFileSystemVolume() *HostFileSystemVolume
  1357  }
  1358  
  1359  func init() {
  1360  	t["BaseHostFileSystemVolume"] = reflect.TypeOf((*HostFileSystemVolume)(nil)).Elem()
  1361  }
  1362  
  1363  func (b *HostHardwareElementInfo) GetHostHardwareElementInfo() *HostHardwareElementInfo { return b }
  1364  
  1365  type BaseHostHardwareElementInfo interface {
  1366  	GetHostHardwareElementInfo() *HostHardwareElementInfo
  1367  }
  1368  
  1369  func init() {
  1370  	t["BaseHostHardwareElementInfo"] = reflect.TypeOf((*HostHardwareElementInfo)(nil)).Elem()
  1371  }
  1372  
  1373  func (b *HostHbaCreateSpec) GetHostHbaCreateSpec() *HostHbaCreateSpec { return b }
  1374  
  1375  type BaseHostHbaCreateSpec interface {
  1376  	GetHostHbaCreateSpec() *HostHbaCreateSpec
  1377  }
  1378  
  1379  func init() {
  1380  	t["BaseHostHbaCreateSpec"] = reflect.TypeOf((*HostHbaCreateSpec)(nil)).Elem()
  1381  }
  1382  
  1383  func (b *HostHostBusAdapter) GetHostHostBusAdapter() *HostHostBusAdapter { return b }
  1384  
  1385  type BaseHostHostBusAdapter interface {
  1386  	GetHostHostBusAdapter() *HostHostBusAdapter
  1387  }
  1388  
  1389  func init() {
  1390  	t["BaseHostHostBusAdapter"] = reflect.TypeOf((*HostHostBusAdapter)(nil)).Elem()
  1391  }
  1392  
  1393  func (b *HostIpRouteConfig) GetHostIpRouteConfig() *HostIpRouteConfig { return b }
  1394  
  1395  type BaseHostIpRouteConfig interface {
  1396  	GetHostIpRouteConfig() *HostIpRouteConfig
  1397  }
  1398  
  1399  func init() {
  1400  	t["BaseHostIpRouteConfig"] = reflect.TypeOf((*HostIpRouteConfig)(nil)).Elem()
  1401  }
  1402  
  1403  func (b *HostMemberHealthCheckResult) GetHostMemberHealthCheckResult() *HostMemberHealthCheckResult {
  1404  	return b
  1405  }
  1406  
  1407  type BaseHostMemberHealthCheckResult interface {
  1408  	GetHostMemberHealthCheckResult() *HostMemberHealthCheckResult
  1409  }
  1410  
  1411  func init() {
  1412  	t["BaseHostMemberHealthCheckResult"] = reflect.TypeOf((*HostMemberHealthCheckResult)(nil)).Elem()
  1413  }
  1414  
  1415  func (b *HostMemberUplinkHealthCheckResult) GetHostMemberUplinkHealthCheckResult() *HostMemberUplinkHealthCheckResult {
  1416  	return b
  1417  }
  1418  
  1419  type BaseHostMemberUplinkHealthCheckResult interface {
  1420  	GetHostMemberUplinkHealthCheckResult() *HostMemberUplinkHealthCheckResult
  1421  }
  1422  
  1423  func init() {
  1424  	t["BaseHostMemberUplinkHealthCheckResult"] = reflect.TypeOf((*HostMemberUplinkHealthCheckResult)(nil)).Elem()
  1425  }
  1426  
  1427  func (b *HostMultipathInfoLogicalUnitPolicy) GetHostMultipathInfoLogicalUnitPolicy() *HostMultipathInfoLogicalUnitPolicy {
  1428  	return b
  1429  }
  1430  
  1431  type BaseHostMultipathInfoLogicalUnitPolicy interface {
  1432  	GetHostMultipathInfoLogicalUnitPolicy() *HostMultipathInfoLogicalUnitPolicy
  1433  }
  1434  
  1435  func init() {
  1436  	t["BaseHostMultipathInfoLogicalUnitPolicy"] = reflect.TypeOf((*HostMultipathInfoLogicalUnitPolicy)(nil)).Elem()
  1437  }
  1438  
  1439  func (b *HostNvmeSpec) GetHostNvmeSpec() *HostNvmeSpec { return b }
  1440  
  1441  type BaseHostNvmeSpec interface {
  1442  	GetHostNvmeSpec() *HostNvmeSpec
  1443  }
  1444  
  1445  func init() {
  1446  	t["BaseHostNvmeSpec"] = reflect.TypeOf((*HostNvmeSpec)(nil)).Elem()
  1447  }
  1448  
  1449  func (b *HostNvmeTransportParameters) GetHostNvmeTransportParameters() *HostNvmeTransportParameters {
  1450  	return b
  1451  }
  1452  
  1453  type BaseHostNvmeTransportParameters interface {
  1454  	GetHostNvmeTransportParameters() *HostNvmeTransportParameters
  1455  }
  1456  
  1457  func init() {
  1458  	t["BaseHostNvmeTransportParameters"] = reflect.TypeOf((*HostNvmeTransportParameters)(nil)).Elem()
  1459  }
  1460  
  1461  func (b *HostPciPassthruConfig) GetHostPciPassthruConfig() *HostPciPassthruConfig { return b }
  1462  
  1463  type BaseHostPciPassthruConfig interface {
  1464  	GetHostPciPassthruConfig() *HostPciPassthruConfig
  1465  }
  1466  
  1467  func init() {
  1468  	t["BaseHostPciPassthruConfig"] = reflect.TypeOf((*HostPciPassthruConfig)(nil)).Elem()
  1469  }
  1470  
  1471  func (b *HostPciPassthruInfo) GetHostPciPassthruInfo() *HostPciPassthruInfo { return b }
  1472  
  1473  type BaseHostPciPassthruInfo interface {
  1474  	GetHostPciPassthruInfo() *HostPciPassthruInfo
  1475  }
  1476  
  1477  func init() {
  1478  	t["BaseHostPciPassthruInfo"] = reflect.TypeOf((*HostPciPassthruInfo)(nil)).Elem()
  1479  }
  1480  
  1481  func (b *HostPowerOpFailed) GetHostPowerOpFailed() *HostPowerOpFailed { return b }
  1482  
  1483  type BaseHostPowerOpFailed interface {
  1484  	GetHostPowerOpFailed() *HostPowerOpFailed
  1485  }
  1486  
  1487  func init() {
  1488  	t["BaseHostPowerOpFailed"] = reflect.TypeOf((*HostPowerOpFailed)(nil)).Elem()
  1489  }
  1490  
  1491  func (b *HostProfileConfigSpec) GetHostProfileConfigSpec() *HostProfileConfigSpec { return b }
  1492  
  1493  type BaseHostProfileConfigSpec interface {
  1494  	GetHostProfileConfigSpec() *HostProfileConfigSpec
  1495  }
  1496  
  1497  func init() {
  1498  	t["BaseHostProfileConfigSpec"] = reflect.TypeOf((*HostProfileConfigSpec)(nil)).Elem()
  1499  }
  1500  
  1501  func (b *HostProfilesEntityCustomizations) GetHostProfilesEntityCustomizations() *HostProfilesEntityCustomizations {
  1502  	return b
  1503  }
  1504  
  1505  type BaseHostProfilesEntityCustomizations interface {
  1506  	GetHostProfilesEntityCustomizations() *HostProfilesEntityCustomizations
  1507  }
  1508  
  1509  func init() {
  1510  	t["BaseHostProfilesEntityCustomizations"] = reflect.TypeOf((*HostProfilesEntityCustomizations)(nil)).Elem()
  1511  }
  1512  
  1513  func (b *HostRdmaDeviceBacking) GetHostRdmaDeviceBacking() *HostRdmaDeviceBacking { return b }
  1514  
  1515  type BaseHostRdmaDeviceBacking interface {
  1516  	GetHostRdmaDeviceBacking() *HostRdmaDeviceBacking
  1517  }
  1518  
  1519  func init() {
  1520  	t["BaseHostRdmaDeviceBacking"] = reflect.TypeOf((*HostRdmaDeviceBacking)(nil)).Elem()
  1521  }
  1522  
  1523  func (b *HostSriovDevicePoolInfo) GetHostSriovDevicePoolInfo() *HostSriovDevicePoolInfo { return b }
  1524  
  1525  type BaseHostSriovDevicePoolInfo interface {
  1526  	GetHostSriovDevicePoolInfo() *HostSriovDevicePoolInfo
  1527  }
  1528  
  1529  func init() {
  1530  	t["BaseHostSriovDevicePoolInfo"] = reflect.TypeOf((*HostSriovDevicePoolInfo)(nil)).Elem()
  1531  }
  1532  
  1533  func (b *HostSystemSwapConfigurationSystemSwapOption) GetHostSystemSwapConfigurationSystemSwapOption() *HostSystemSwapConfigurationSystemSwapOption {
  1534  	return b
  1535  }
  1536  
  1537  type BaseHostSystemSwapConfigurationSystemSwapOption interface {
  1538  	GetHostSystemSwapConfigurationSystemSwapOption() *HostSystemSwapConfigurationSystemSwapOption
  1539  }
  1540  
  1541  func init() {
  1542  	t["BaseHostSystemSwapConfigurationSystemSwapOption"] = reflect.TypeOf((*HostSystemSwapConfigurationSystemSwapOption)(nil)).Elem()
  1543  }
  1544  
  1545  func (b *HostTargetTransport) GetHostTargetTransport() *HostTargetTransport { return b }
  1546  
  1547  type BaseHostTargetTransport interface {
  1548  	GetHostTargetTransport() *HostTargetTransport
  1549  }
  1550  
  1551  func init() {
  1552  	t["BaseHostTargetTransport"] = reflect.TypeOf((*HostTargetTransport)(nil)).Elem()
  1553  }
  1554  
  1555  func (b *HostTpmBootSecurityOptionEventDetails) GetHostTpmBootSecurityOptionEventDetails() *HostTpmBootSecurityOptionEventDetails {
  1556  	return b
  1557  }
  1558  
  1559  type BaseHostTpmBootSecurityOptionEventDetails interface {
  1560  	GetHostTpmBootSecurityOptionEventDetails() *HostTpmBootSecurityOptionEventDetails
  1561  }
  1562  
  1563  func init() {
  1564  	t["BaseHostTpmBootSecurityOptionEventDetails"] = reflect.TypeOf((*HostTpmBootSecurityOptionEventDetails)(nil)).Elem()
  1565  }
  1566  
  1567  func (b *HostTpmEventDetails) GetHostTpmEventDetails() *HostTpmEventDetails { return b }
  1568  
  1569  type BaseHostTpmEventDetails interface {
  1570  	GetHostTpmEventDetails() *HostTpmEventDetails
  1571  }
  1572  
  1573  func init() {
  1574  	t["BaseHostTpmEventDetails"] = reflect.TypeOf((*HostTpmEventDetails)(nil)).Elem()
  1575  }
  1576  
  1577  func (b *HostVirtualSwitchBridge) GetHostVirtualSwitchBridge() *HostVirtualSwitchBridge { return b }
  1578  
  1579  type BaseHostVirtualSwitchBridge interface {
  1580  	GetHostVirtualSwitchBridge() *HostVirtualSwitchBridge
  1581  }
  1582  
  1583  func init() {
  1584  	t["BaseHostVirtualSwitchBridge"] = reflect.TypeOf((*HostVirtualSwitchBridge)(nil)).Elem()
  1585  }
  1586  
  1587  func (b *HourlyTaskScheduler) GetHourlyTaskScheduler() *HourlyTaskScheduler { return b }
  1588  
  1589  type BaseHourlyTaskScheduler interface {
  1590  	GetHourlyTaskScheduler() *HourlyTaskScheduler
  1591  }
  1592  
  1593  func init() {
  1594  	t["BaseHourlyTaskScheduler"] = reflect.TypeOf((*HourlyTaskScheduler)(nil)).Elem()
  1595  }
  1596  
  1597  func (b *ImportSpec) GetImportSpec() *ImportSpec { return b }
  1598  
  1599  type BaseImportSpec interface {
  1600  	GetImportSpec() *ImportSpec
  1601  }
  1602  
  1603  func init() {
  1604  	t["BaseImportSpec"] = reflect.TypeOf((*ImportSpec)(nil)).Elem()
  1605  }
  1606  
  1607  func (b *InaccessibleDatastore) GetInaccessibleDatastore() *InaccessibleDatastore { return b }
  1608  
  1609  type BaseInaccessibleDatastore interface {
  1610  	GetInaccessibleDatastore() *InaccessibleDatastore
  1611  }
  1612  
  1613  func init() {
  1614  	t["BaseInaccessibleDatastore"] = reflect.TypeOf((*InaccessibleDatastore)(nil)).Elem()
  1615  }
  1616  
  1617  func (b *InheritablePolicy) GetInheritablePolicy() *InheritablePolicy { return b }
  1618  
  1619  type BaseInheritablePolicy interface {
  1620  	GetInheritablePolicy() *InheritablePolicy
  1621  }
  1622  
  1623  func init() {
  1624  	t["BaseInheritablePolicy"] = reflect.TypeOf((*InheritablePolicy)(nil)).Elem()
  1625  }
  1626  
  1627  func (b *InsufficientHostCapacityFault) GetInsufficientHostCapacityFault() *InsufficientHostCapacityFault {
  1628  	return b
  1629  }
  1630  
  1631  type BaseInsufficientHostCapacityFault interface {
  1632  	GetInsufficientHostCapacityFault() *InsufficientHostCapacityFault
  1633  }
  1634  
  1635  func init() {
  1636  	t["BaseInsufficientHostCapacityFault"] = reflect.TypeOf((*InsufficientHostCapacityFault)(nil)).Elem()
  1637  }
  1638  
  1639  func (b *InsufficientResourcesFault) GetInsufficientResourcesFault() *InsufficientResourcesFault {
  1640  	return b
  1641  }
  1642  
  1643  type BaseInsufficientResourcesFault interface {
  1644  	GetInsufficientResourcesFault() *InsufficientResourcesFault
  1645  }
  1646  
  1647  func init() {
  1648  	t["BaseInsufficientResourcesFault"] = reflect.TypeOf((*InsufficientResourcesFault)(nil)).Elem()
  1649  }
  1650  
  1651  func (b *InsufficientStandbyResource) GetInsufficientStandbyResource() *InsufficientStandbyResource {
  1652  	return b
  1653  }
  1654  
  1655  type BaseInsufficientStandbyResource interface {
  1656  	GetInsufficientStandbyResource() *InsufficientStandbyResource
  1657  }
  1658  
  1659  func init() {
  1660  	t["BaseInsufficientStandbyResource"] = reflect.TypeOf((*InsufficientStandbyResource)(nil)).Elem()
  1661  }
  1662  
  1663  func (b *InvalidArgument) GetInvalidArgument() *InvalidArgument { return b }
  1664  
  1665  type BaseInvalidArgument interface {
  1666  	GetInvalidArgument() *InvalidArgument
  1667  }
  1668  
  1669  func init() {
  1670  	t["BaseInvalidArgument"] = reflect.TypeOf((*InvalidArgument)(nil)).Elem()
  1671  }
  1672  
  1673  func (b *InvalidCAMServer) GetInvalidCAMServer() *InvalidCAMServer { return b }
  1674  
  1675  type BaseInvalidCAMServer interface {
  1676  	GetInvalidCAMServer() *InvalidCAMServer
  1677  }
  1678  
  1679  func init() {
  1680  	t["BaseInvalidCAMServer"] = reflect.TypeOf((*InvalidCAMServer)(nil)).Elem()
  1681  }
  1682  
  1683  func (b *InvalidDatastore) GetInvalidDatastore() *InvalidDatastore { return b }
  1684  
  1685  type BaseInvalidDatastore interface {
  1686  	GetInvalidDatastore() *InvalidDatastore
  1687  }
  1688  
  1689  func init() {
  1690  	t["BaseInvalidDatastore"] = reflect.TypeOf((*InvalidDatastore)(nil)).Elem()
  1691  }
  1692  
  1693  func (b *InvalidDeviceSpec) GetInvalidDeviceSpec() *InvalidDeviceSpec { return b }
  1694  
  1695  type BaseInvalidDeviceSpec interface {
  1696  	GetInvalidDeviceSpec() *InvalidDeviceSpec
  1697  }
  1698  
  1699  func init() {
  1700  	t["BaseInvalidDeviceSpec"] = reflect.TypeOf((*InvalidDeviceSpec)(nil)).Elem()
  1701  }
  1702  
  1703  func (b *InvalidFolder) GetInvalidFolder() *InvalidFolder { return b }
  1704  
  1705  type BaseInvalidFolder interface {
  1706  	GetInvalidFolder() *InvalidFolder
  1707  }
  1708  
  1709  func init() {
  1710  	t["BaseInvalidFolder"] = reflect.TypeOf((*InvalidFolder)(nil)).Elem()
  1711  }
  1712  
  1713  func (b *InvalidFormat) GetInvalidFormat() *InvalidFormat { return b }
  1714  
  1715  type BaseInvalidFormat interface {
  1716  	GetInvalidFormat() *InvalidFormat
  1717  }
  1718  
  1719  func init() {
  1720  	t["BaseInvalidFormat"] = reflect.TypeOf((*InvalidFormat)(nil)).Elem()
  1721  }
  1722  
  1723  func (b *InvalidHostState) GetInvalidHostState() *InvalidHostState { return b }
  1724  
  1725  type BaseInvalidHostState interface {
  1726  	GetInvalidHostState() *InvalidHostState
  1727  }
  1728  
  1729  func init() {
  1730  	t["BaseInvalidHostState"] = reflect.TypeOf((*InvalidHostState)(nil)).Elem()
  1731  }
  1732  
  1733  func (b *InvalidLogin) GetInvalidLogin() *InvalidLogin { return b }
  1734  
  1735  type BaseInvalidLogin interface {
  1736  	GetInvalidLogin() *InvalidLogin
  1737  }
  1738  
  1739  func init() {
  1740  	t["BaseInvalidLogin"] = reflect.TypeOf((*InvalidLogin)(nil)).Elem()
  1741  }
  1742  
  1743  func (b *InvalidPropertyValue) GetInvalidPropertyValue() *InvalidPropertyValue { return b }
  1744  
  1745  type BaseInvalidPropertyValue interface {
  1746  	GetInvalidPropertyValue() *InvalidPropertyValue
  1747  }
  1748  
  1749  func init() {
  1750  	t["BaseInvalidPropertyValue"] = reflect.TypeOf((*InvalidPropertyValue)(nil)).Elem()
  1751  }
  1752  
  1753  func (b *InvalidRequest) GetInvalidRequest() *InvalidRequest { return b }
  1754  
  1755  type BaseInvalidRequest interface {
  1756  	GetInvalidRequest() *InvalidRequest
  1757  }
  1758  
  1759  func init() {
  1760  	t["BaseInvalidRequest"] = reflect.TypeOf((*InvalidRequest)(nil)).Elem()
  1761  }
  1762  
  1763  func (b *InvalidState) GetInvalidState() *InvalidState { return b }
  1764  
  1765  type BaseInvalidState interface {
  1766  	GetInvalidState() *InvalidState
  1767  }
  1768  
  1769  func init() {
  1770  	t["BaseInvalidState"] = reflect.TypeOf((*InvalidState)(nil)).Elem()
  1771  }
  1772  
  1773  func (b *InvalidVmConfig) GetInvalidVmConfig() *InvalidVmConfig { return b }
  1774  
  1775  type BaseInvalidVmConfig interface {
  1776  	GetInvalidVmConfig() *InvalidVmConfig
  1777  }
  1778  
  1779  func init() {
  1780  	t["BaseInvalidVmConfig"] = reflect.TypeOf((*InvalidVmConfig)(nil)).Elem()
  1781  }
  1782  
  1783  func (b *IoFilterInfo) GetIoFilterInfo() *IoFilterInfo { return b }
  1784  
  1785  type BaseIoFilterInfo interface {
  1786  	GetIoFilterInfo() *IoFilterInfo
  1787  }
  1788  
  1789  func init() {
  1790  	t["BaseIoFilterInfo"] = reflect.TypeOf((*IoFilterInfo)(nil)).Elem()
  1791  }
  1792  
  1793  func (b *IpAddress) GetIpAddress() *IpAddress { return b }
  1794  
  1795  type BaseIpAddress interface {
  1796  	GetIpAddress() *IpAddress
  1797  }
  1798  
  1799  func init() {
  1800  	t["BaseIpAddress"] = reflect.TypeOf((*IpAddress)(nil)).Elem()
  1801  }
  1802  
  1803  func (b *IscsiFault) GetIscsiFault() *IscsiFault { return b }
  1804  
  1805  type BaseIscsiFault interface {
  1806  	GetIscsiFault() *IscsiFault
  1807  }
  1808  
  1809  func init() {
  1810  	t["BaseIscsiFault"] = reflect.TypeOf((*IscsiFault)(nil)).Elem()
  1811  }
  1812  
  1813  func (b *LicenseEvent) GetLicenseEvent() *LicenseEvent { return b }
  1814  
  1815  type BaseLicenseEvent interface {
  1816  	GetLicenseEvent() *LicenseEvent
  1817  }
  1818  
  1819  func init() {
  1820  	t["BaseLicenseEvent"] = reflect.TypeOf((*LicenseEvent)(nil)).Elem()
  1821  }
  1822  
  1823  func (b *LicenseSource) GetLicenseSource() *LicenseSource { return b }
  1824  
  1825  type BaseLicenseSource interface {
  1826  	GetLicenseSource() *LicenseSource
  1827  }
  1828  
  1829  func init() {
  1830  	t["BaseLicenseSource"] = reflect.TypeOf((*LicenseSource)(nil)).Elem()
  1831  }
  1832  
  1833  func (b *MacAddress) GetMacAddress() *MacAddress { return b }
  1834  
  1835  type BaseMacAddress interface {
  1836  	GetMacAddress() *MacAddress
  1837  }
  1838  
  1839  func init() {
  1840  	t["BaseMacAddress"] = reflect.TypeOf((*MacAddress)(nil)).Elem()
  1841  }
  1842  
  1843  func (b *MethodFault) GetMethodFault() *MethodFault { return b }
  1844  
  1845  type BaseMethodFault interface {
  1846  	GetMethodFault() *MethodFault
  1847  }
  1848  
  1849  func init() {
  1850  	t["BaseMethodFault"] = reflect.TypeOf((*MethodFault)(nil)).Elem()
  1851  }
  1852  
  1853  func (b *MigrationEvent) GetMigrationEvent() *MigrationEvent { return b }
  1854  
  1855  type BaseMigrationEvent interface {
  1856  	GetMigrationEvent() *MigrationEvent
  1857  }
  1858  
  1859  func init() {
  1860  	t["BaseMigrationEvent"] = reflect.TypeOf((*MigrationEvent)(nil)).Elem()
  1861  }
  1862  
  1863  func (b *MigrationFault) GetMigrationFault() *MigrationFault { return b }
  1864  
  1865  type BaseMigrationFault interface {
  1866  	GetMigrationFault() *MigrationFault
  1867  }
  1868  
  1869  func init() {
  1870  	t["BaseMigrationFault"] = reflect.TypeOf((*MigrationFault)(nil)).Elem()
  1871  }
  1872  
  1873  func (b *MigrationFeatureNotSupported) GetMigrationFeatureNotSupported() *MigrationFeatureNotSupported {
  1874  	return b
  1875  }
  1876  
  1877  type BaseMigrationFeatureNotSupported interface {
  1878  	GetMigrationFeatureNotSupported() *MigrationFeatureNotSupported
  1879  }
  1880  
  1881  func init() {
  1882  	t["BaseMigrationFeatureNotSupported"] = reflect.TypeOf((*MigrationFeatureNotSupported)(nil)).Elem()
  1883  }
  1884  
  1885  func (b *MonthlyTaskScheduler) GetMonthlyTaskScheduler() *MonthlyTaskScheduler { return b }
  1886  
  1887  type BaseMonthlyTaskScheduler interface {
  1888  	GetMonthlyTaskScheduler() *MonthlyTaskScheduler
  1889  }
  1890  
  1891  func init() {
  1892  	t["BaseMonthlyTaskScheduler"] = reflect.TypeOf((*MonthlyTaskScheduler)(nil)).Elem()
  1893  }
  1894  
  1895  func (b *NasConfigFault) GetNasConfigFault() *NasConfigFault { return b }
  1896  
  1897  type BaseNasConfigFault interface {
  1898  	GetNasConfigFault() *NasConfigFault
  1899  }
  1900  
  1901  func init() {
  1902  	t["BaseNasConfigFault"] = reflect.TypeOf((*NasConfigFault)(nil)).Elem()
  1903  }
  1904  
  1905  func (b *NegatableExpression) GetNegatableExpression() *NegatableExpression { return b }
  1906  
  1907  type BaseNegatableExpression interface {
  1908  	GetNegatableExpression() *NegatableExpression
  1909  }
  1910  
  1911  func init() {
  1912  	t["BaseNegatableExpression"] = reflect.TypeOf((*NegatableExpression)(nil)).Elem()
  1913  }
  1914  
  1915  func (b *NetBIOSConfigInfo) GetNetBIOSConfigInfo() *NetBIOSConfigInfo { return b }
  1916  
  1917  type BaseNetBIOSConfigInfo interface {
  1918  	GetNetBIOSConfigInfo() *NetBIOSConfigInfo
  1919  }
  1920  
  1921  func init() {
  1922  	t["BaseNetBIOSConfigInfo"] = reflect.TypeOf((*NetBIOSConfigInfo)(nil)).Elem()
  1923  }
  1924  
  1925  func (b *NetworkSummary) GetNetworkSummary() *NetworkSummary { return b }
  1926  
  1927  type BaseNetworkSummary interface {
  1928  	GetNetworkSummary() *NetworkSummary
  1929  }
  1930  
  1931  func init() {
  1932  	t["BaseNetworkSummary"] = reflect.TypeOf((*NetworkSummary)(nil)).Elem()
  1933  }
  1934  
  1935  func (b *NoCompatibleHost) GetNoCompatibleHost() *NoCompatibleHost { return b }
  1936  
  1937  type BaseNoCompatibleHost interface {
  1938  	GetNoCompatibleHost() *NoCompatibleHost
  1939  }
  1940  
  1941  func init() {
  1942  	t["BaseNoCompatibleHost"] = reflect.TypeOf((*NoCompatibleHost)(nil)).Elem()
  1943  }
  1944  
  1945  func (b *NoPermission) GetNoPermission() *NoPermission { return b }
  1946  
  1947  type BaseNoPermission interface {
  1948  	GetNoPermission() *NoPermission
  1949  }
  1950  
  1951  func init() {
  1952  	t["BaseNoPermission"] = reflect.TypeOf((*NoPermission)(nil)).Elem()
  1953  }
  1954  
  1955  func (b *NodeDeploymentSpec) GetNodeDeploymentSpec() *NodeDeploymentSpec { return b }
  1956  
  1957  type BaseNodeDeploymentSpec interface {
  1958  	GetNodeDeploymentSpec() *NodeDeploymentSpec
  1959  }
  1960  
  1961  func init() {
  1962  	t["BaseNodeDeploymentSpec"] = reflect.TypeOf((*NodeDeploymentSpec)(nil)).Elem()
  1963  }
  1964  
  1965  func (b *NodeNetworkSpec) GetNodeNetworkSpec() *NodeNetworkSpec { return b }
  1966  
  1967  type BaseNodeNetworkSpec interface {
  1968  	GetNodeNetworkSpec() *NodeNetworkSpec
  1969  }
  1970  
  1971  func init() {
  1972  	t["BaseNodeNetworkSpec"] = reflect.TypeOf((*NodeNetworkSpec)(nil)).Elem()
  1973  }
  1974  
  1975  func (b *NotEnoughCpus) GetNotEnoughCpus() *NotEnoughCpus { return b }
  1976  
  1977  type BaseNotEnoughCpus interface {
  1978  	GetNotEnoughCpus() *NotEnoughCpus
  1979  }
  1980  
  1981  func init() {
  1982  	t["BaseNotEnoughCpus"] = reflect.TypeOf((*NotEnoughCpus)(nil)).Elem()
  1983  }
  1984  
  1985  func (b *NotEnoughLicenses) GetNotEnoughLicenses() *NotEnoughLicenses { return b }
  1986  
  1987  type BaseNotEnoughLicenses interface {
  1988  	GetNotEnoughLicenses() *NotEnoughLicenses
  1989  }
  1990  
  1991  func init() {
  1992  	t["BaseNotEnoughLicenses"] = reflect.TypeOf((*NotEnoughLicenses)(nil)).Elem()
  1993  }
  1994  
  1995  func (b *NotSupported) GetNotSupported() *NotSupported { return b }
  1996  
  1997  type BaseNotSupported interface {
  1998  	GetNotSupported() *NotSupported
  1999  }
  2000  
  2001  func init() {
  2002  	t["BaseNotSupported"] = reflect.TypeOf((*NotSupported)(nil)).Elem()
  2003  }
  2004  
  2005  func (b *NotSupportedHost) GetNotSupportedHost() *NotSupportedHost { return b }
  2006  
  2007  type BaseNotSupportedHost interface {
  2008  	GetNotSupportedHost() *NotSupportedHost
  2009  }
  2010  
  2011  func init() {
  2012  	t["BaseNotSupportedHost"] = reflect.TypeOf((*NotSupportedHost)(nil)).Elem()
  2013  }
  2014  
  2015  func (b *NotSupportedHostInCluster) GetNotSupportedHostInCluster() *NotSupportedHostInCluster {
  2016  	return b
  2017  }
  2018  
  2019  type BaseNotSupportedHostInCluster interface {
  2020  	GetNotSupportedHostInCluster() *NotSupportedHostInCluster
  2021  }
  2022  
  2023  func init() {
  2024  	t["BaseNotSupportedHostInCluster"] = reflect.TypeOf((*NotSupportedHostInCluster)(nil)).Elem()
  2025  }
  2026  
  2027  func (b *OptionType) GetOptionType() *OptionType { return b }
  2028  
  2029  type BaseOptionType interface {
  2030  	GetOptionType() *OptionType
  2031  }
  2032  
  2033  func init() {
  2034  	t["BaseOptionType"] = reflect.TypeOf((*OptionType)(nil)).Elem()
  2035  }
  2036  
  2037  func (b *OptionValue) GetOptionValue() *OptionValue { return b }
  2038  
  2039  type BaseOptionValue interface {
  2040  	GetOptionValue() *OptionValue
  2041  }
  2042  
  2043  func init() {
  2044  	t["BaseOptionValue"] = reflect.TypeOf((*OptionValue)(nil)).Elem()
  2045  }
  2046  
  2047  func (b *OvfAttribute) GetOvfAttribute() *OvfAttribute { return b }
  2048  
  2049  type BaseOvfAttribute interface {
  2050  	GetOvfAttribute() *OvfAttribute
  2051  }
  2052  
  2053  func init() {
  2054  	t["BaseOvfAttribute"] = reflect.TypeOf((*OvfAttribute)(nil)).Elem()
  2055  }
  2056  
  2057  func (b *OvfConnectedDevice) GetOvfConnectedDevice() *OvfConnectedDevice { return b }
  2058  
  2059  type BaseOvfConnectedDevice interface {
  2060  	GetOvfConnectedDevice() *OvfConnectedDevice
  2061  }
  2062  
  2063  func init() {
  2064  	t["BaseOvfConnectedDevice"] = reflect.TypeOf((*OvfConnectedDevice)(nil)).Elem()
  2065  }
  2066  
  2067  func (b *OvfConstraint) GetOvfConstraint() *OvfConstraint { return b }
  2068  
  2069  type BaseOvfConstraint interface {
  2070  	GetOvfConstraint() *OvfConstraint
  2071  }
  2072  
  2073  func init() {
  2074  	t["BaseOvfConstraint"] = reflect.TypeOf((*OvfConstraint)(nil)).Elem()
  2075  }
  2076  
  2077  func (b *OvfConsumerCallbackFault) GetOvfConsumerCallbackFault() *OvfConsumerCallbackFault { return b }
  2078  
  2079  type BaseOvfConsumerCallbackFault interface {
  2080  	GetOvfConsumerCallbackFault() *OvfConsumerCallbackFault
  2081  }
  2082  
  2083  func init() {
  2084  	t["BaseOvfConsumerCallbackFault"] = reflect.TypeOf((*OvfConsumerCallbackFault)(nil)).Elem()
  2085  }
  2086  
  2087  func (b *OvfElement) GetOvfElement() *OvfElement { return b }
  2088  
  2089  type BaseOvfElement interface {
  2090  	GetOvfElement() *OvfElement
  2091  }
  2092  
  2093  func init() {
  2094  	t["BaseOvfElement"] = reflect.TypeOf((*OvfElement)(nil)).Elem()
  2095  }
  2096  
  2097  func (b *OvfExport) GetOvfExport() *OvfExport { return b }
  2098  
  2099  type BaseOvfExport interface {
  2100  	GetOvfExport() *OvfExport
  2101  }
  2102  
  2103  func init() {
  2104  	t["BaseOvfExport"] = reflect.TypeOf((*OvfExport)(nil)).Elem()
  2105  }
  2106  
  2107  func (b *OvfFault) GetOvfFault() *OvfFault { return b }
  2108  
  2109  type BaseOvfFault interface {
  2110  	GetOvfFault() *OvfFault
  2111  }
  2112  
  2113  func init() {
  2114  	t["BaseOvfFault"] = reflect.TypeOf((*OvfFault)(nil)).Elem()
  2115  }
  2116  
  2117  func (b *OvfHardwareExport) GetOvfHardwareExport() *OvfHardwareExport { return b }
  2118  
  2119  type BaseOvfHardwareExport interface {
  2120  	GetOvfHardwareExport() *OvfHardwareExport
  2121  }
  2122  
  2123  func init() {
  2124  	t["BaseOvfHardwareExport"] = reflect.TypeOf((*OvfHardwareExport)(nil)).Elem()
  2125  }
  2126  
  2127  func (b *OvfImport) GetOvfImport() *OvfImport { return b }
  2128  
  2129  type BaseOvfImport interface {
  2130  	GetOvfImport() *OvfImport
  2131  }
  2132  
  2133  func init() {
  2134  	t["BaseOvfImport"] = reflect.TypeOf((*OvfImport)(nil)).Elem()
  2135  }
  2136  
  2137  func (b *OvfInvalidPackage) GetOvfInvalidPackage() *OvfInvalidPackage { return b }
  2138  
  2139  type BaseOvfInvalidPackage interface {
  2140  	GetOvfInvalidPackage() *OvfInvalidPackage
  2141  }
  2142  
  2143  func init() {
  2144  	t["BaseOvfInvalidPackage"] = reflect.TypeOf((*OvfInvalidPackage)(nil)).Elem()
  2145  }
  2146  
  2147  func (b *OvfInvalidValue) GetOvfInvalidValue() *OvfInvalidValue { return b }
  2148  
  2149  type BaseOvfInvalidValue interface {
  2150  	GetOvfInvalidValue() *OvfInvalidValue
  2151  }
  2152  
  2153  func init() {
  2154  	t["BaseOvfInvalidValue"] = reflect.TypeOf((*OvfInvalidValue)(nil)).Elem()
  2155  }
  2156  
  2157  func (b *OvfManagerCommonParams) GetOvfManagerCommonParams() *OvfManagerCommonParams { return b }
  2158  
  2159  type BaseOvfManagerCommonParams interface {
  2160  	GetOvfManagerCommonParams() *OvfManagerCommonParams
  2161  }
  2162  
  2163  func init() {
  2164  	t["BaseOvfManagerCommonParams"] = reflect.TypeOf((*OvfManagerCommonParams)(nil)).Elem()
  2165  }
  2166  
  2167  func (b *OvfMissingElement) GetOvfMissingElement() *OvfMissingElement { return b }
  2168  
  2169  type BaseOvfMissingElement interface {
  2170  	GetOvfMissingElement() *OvfMissingElement
  2171  }
  2172  
  2173  func init() {
  2174  	t["BaseOvfMissingElement"] = reflect.TypeOf((*OvfMissingElement)(nil)).Elem()
  2175  }
  2176  
  2177  func (b *OvfProperty) GetOvfProperty() *OvfProperty { return b }
  2178  
  2179  type BaseOvfProperty interface {
  2180  	GetOvfProperty() *OvfProperty
  2181  }
  2182  
  2183  func init() {
  2184  	t["BaseOvfProperty"] = reflect.TypeOf((*OvfProperty)(nil)).Elem()
  2185  }
  2186  
  2187  func (b *OvfSystemFault) GetOvfSystemFault() *OvfSystemFault { return b }
  2188  
  2189  type BaseOvfSystemFault interface {
  2190  	GetOvfSystemFault() *OvfSystemFault
  2191  }
  2192  
  2193  func init() {
  2194  	t["BaseOvfSystemFault"] = reflect.TypeOf((*OvfSystemFault)(nil)).Elem()
  2195  }
  2196  
  2197  func (b *OvfUnsupportedAttribute) GetOvfUnsupportedAttribute() *OvfUnsupportedAttribute { return b }
  2198  
  2199  type BaseOvfUnsupportedAttribute interface {
  2200  	GetOvfUnsupportedAttribute() *OvfUnsupportedAttribute
  2201  }
  2202  
  2203  func init() {
  2204  	t["BaseOvfUnsupportedAttribute"] = reflect.TypeOf((*OvfUnsupportedAttribute)(nil)).Elem()
  2205  }
  2206  
  2207  func (b *OvfUnsupportedElement) GetOvfUnsupportedElement() *OvfUnsupportedElement { return b }
  2208  
  2209  type BaseOvfUnsupportedElement interface {
  2210  	GetOvfUnsupportedElement() *OvfUnsupportedElement
  2211  }
  2212  
  2213  func init() {
  2214  	t["BaseOvfUnsupportedElement"] = reflect.TypeOf((*OvfUnsupportedElement)(nil)).Elem()
  2215  }
  2216  
  2217  func (b *OvfUnsupportedPackage) GetOvfUnsupportedPackage() *OvfUnsupportedPackage { return b }
  2218  
  2219  type BaseOvfUnsupportedPackage interface {
  2220  	GetOvfUnsupportedPackage() *OvfUnsupportedPackage
  2221  }
  2222  
  2223  func init() {
  2224  	t["BaseOvfUnsupportedPackage"] = reflect.TypeOf((*OvfUnsupportedPackage)(nil)).Elem()
  2225  }
  2226  
  2227  func (b *PatchMetadataInvalid) GetPatchMetadataInvalid() *PatchMetadataInvalid { return b }
  2228  
  2229  type BasePatchMetadataInvalid interface {
  2230  	GetPatchMetadataInvalid() *PatchMetadataInvalid
  2231  }
  2232  
  2233  func init() {
  2234  	t["BasePatchMetadataInvalid"] = reflect.TypeOf((*PatchMetadataInvalid)(nil)).Elem()
  2235  }
  2236  
  2237  func (b *PatchNotApplicable) GetPatchNotApplicable() *PatchNotApplicable { return b }
  2238  
  2239  type BasePatchNotApplicable interface {
  2240  	GetPatchNotApplicable() *PatchNotApplicable
  2241  }
  2242  
  2243  func init() {
  2244  	t["BasePatchNotApplicable"] = reflect.TypeOf((*PatchNotApplicable)(nil)).Elem()
  2245  }
  2246  
  2247  func (b *PerfEntityMetricBase) GetPerfEntityMetricBase() *PerfEntityMetricBase { return b }
  2248  
  2249  type BasePerfEntityMetricBase interface {
  2250  	GetPerfEntityMetricBase() *PerfEntityMetricBase
  2251  }
  2252  
  2253  func init() {
  2254  	t["BasePerfEntityMetricBase"] = reflect.TypeOf((*PerfEntityMetricBase)(nil)).Elem()
  2255  }
  2256  
  2257  func (b *PerfMetricSeries) GetPerfMetricSeries() *PerfMetricSeries { return b }
  2258  
  2259  type BasePerfMetricSeries interface {
  2260  	GetPerfMetricSeries() *PerfMetricSeries
  2261  }
  2262  
  2263  func init() {
  2264  	t["BasePerfMetricSeries"] = reflect.TypeOf((*PerfMetricSeries)(nil)).Elem()
  2265  }
  2266  
  2267  func (b *PermissionEvent) GetPermissionEvent() *PermissionEvent { return b }
  2268  
  2269  type BasePermissionEvent interface {
  2270  	GetPermissionEvent() *PermissionEvent
  2271  }
  2272  
  2273  func init() {
  2274  	t["BasePermissionEvent"] = reflect.TypeOf((*PermissionEvent)(nil)).Elem()
  2275  }
  2276  
  2277  func (b *PhysicalNicHint) GetPhysicalNicHint() *PhysicalNicHint { return b }
  2278  
  2279  type BasePhysicalNicHint interface {
  2280  	GetPhysicalNicHint() *PhysicalNicHint
  2281  }
  2282  
  2283  func init() {
  2284  	t["BasePhysicalNicHint"] = reflect.TypeOf((*PhysicalNicHint)(nil)).Elem()
  2285  }
  2286  
  2287  func (b *PlatformConfigFault) GetPlatformConfigFault() *PlatformConfigFault { return b }
  2288  
  2289  type BasePlatformConfigFault interface {
  2290  	GetPlatformConfigFault() *PlatformConfigFault
  2291  }
  2292  
  2293  func init() {
  2294  	t["BasePlatformConfigFault"] = reflect.TypeOf((*PlatformConfigFault)(nil)).Elem()
  2295  }
  2296  
  2297  func (b *PolicyOption) GetPolicyOption() *PolicyOption { return b }
  2298  
  2299  type BasePolicyOption interface {
  2300  	GetPolicyOption() *PolicyOption
  2301  }
  2302  
  2303  func init() {
  2304  	t["BasePolicyOption"] = reflect.TypeOf((*PolicyOption)(nil)).Elem()
  2305  }
  2306  
  2307  func (b *PortGroupProfile) GetPortGroupProfile() *PortGroupProfile { return b }
  2308  
  2309  type BasePortGroupProfile interface {
  2310  	GetPortGroupProfile() *PortGroupProfile
  2311  }
  2312  
  2313  func init() {
  2314  	t["BasePortGroupProfile"] = reflect.TypeOf((*PortGroupProfile)(nil)).Elem()
  2315  }
  2316  
  2317  func (b *ProfileConfigInfo) GetProfileConfigInfo() *ProfileConfigInfo { return b }
  2318  
  2319  type BaseProfileConfigInfo interface {
  2320  	GetProfileConfigInfo() *ProfileConfigInfo
  2321  }
  2322  
  2323  func init() {
  2324  	t["BaseProfileConfigInfo"] = reflect.TypeOf((*ProfileConfigInfo)(nil)).Elem()
  2325  }
  2326  
  2327  func (b *ProfileCreateSpec) GetProfileCreateSpec() *ProfileCreateSpec { return b }
  2328  
  2329  type BaseProfileCreateSpec interface {
  2330  	GetProfileCreateSpec() *ProfileCreateSpec
  2331  }
  2332  
  2333  func init() {
  2334  	t["BaseProfileCreateSpec"] = reflect.TypeOf((*ProfileCreateSpec)(nil)).Elem()
  2335  }
  2336  
  2337  func (b *ProfileEvent) GetProfileEvent() *ProfileEvent { return b }
  2338  
  2339  type BaseProfileEvent interface {
  2340  	GetProfileEvent() *ProfileEvent
  2341  }
  2342  
  2343  func init() {
  2344  	t["BaseProfileEvent"] = reflect.TypeOf((*ProfileEvent)(nil)).Elem()
  2345  }
  2346  
  2347  func (b *ProfileExecuteResult) GetProfileExecuteResult() *ProfileExecuteResult { return b }
  2348  
  2349  type BaseProfileExecuteResult interface {
  2350  	GetProfileExecuteResult() *ProfileExecuteResult
  2351  }
  2352  
  2353  func init() {
  2354  	t["BaseProfileExecuteResult"] = reflect.TypeOf((*ProfileExecuteResult)(nil)).Elem()
  2355  }
  2356  
  2357  func (b *ProfileExpression) GetProfileExpression() *ProfileExpression { return b }
  2358  
  2359  type BaseProfileExpression interface {
  2360  	GetProfileExpression() *ProfileExpression
  2361  }
  2362  
  2363  func init() {
  2364  	t["BaseProfileExpression"] = reflect.TypeOf((*ProfileExpression)(nil)).Elem()
  2365  }
  2366  
  2367  func (b *ProfilePolicyOptionMetadata) GetProfilePolicyOptionMetadata() *ProfilePolicyOptionMetadata {
  2368  	return b
  2369  }
  2370  
  2371  type BaseProfilePolicyOptionMetadata interface {
  2372  	GetProfilePolicyOptionMetadata() *ProfilePolicyOptionMetadata
  2373  }
  2374  
  2375  func init() {
  2376  	t["BaseProfilePolicyOptionMetadata"] = reflect.TypeOf((*ProfilePolicyOptionMetadata)(nil)).Elem()
  2377  }
  2378  
  2379  func (b *ProfileSerializedCreateSpec) GetProfileSerializedCreateSpec() *ProfileSerializedCreateSpec {
  2380  	return b
  2381  }
  2382  
  2383  type BaseProfileSerializedCreateSpec interface {
  2384  	GetProfileSerializedCreateSpec() *ProfileSerializedCreateSpec
  2385  }
  2386  
  2387  func init() {
  2388  	t["BaseProfileSerializedCreateSpec"] = reflect.TypeOf((*ProfileSerializedCreateSpec)(nil)).Elem()
  2389  }
  2390  
  2391  func (b *RDMNotSupported) GetRDMNotSupported() *RDMNotSupported { return b }
  2392  
  2393  type BaseRDMNotSupported interface {
  2394  	GetRDMNotSupported() *RDMNotSupported
  2395  }
  2396  
  2397  func init() {
  2398  	t["BaseRDMNotSupported"] = reflect.TypeOf((*RDMNotSupported)(nil)).Elem()
  2399  }
  2400  
  2401  func (b *RecurrentTaskScheduler) GetRecurrentTaskScheduler() *RecurrentTaskScheduler { return b }
  2402  
  2403  type BaseRecurrentTaskScheduler interface {
  2404  	GetRecurrentTaskScheduler() *RecurrentTaskScheduler
  2405  }
  2406  
  2407  func init() {
  2408  	t["BaseRecurrentTaskScheduler"] = reflect.TypeOf((*RecurrentTaskScheduler)(nil)).Elem()
  2409  }
  2410  
  2411  func (b *ReplicationConfigFault) GetReplicationConfigFault() *ReplicationConfigFault { return b }
  2412  
  2413  type BaseReplicationConfigFault interface {
  2414  	GetReplicationConfigFault() *ReplicationConfigFault
  2415  }
  2416  
  2417  func init() {
  2418  	t["BaseReplicationConfigFault"] = reflect.TypeOf((*ReplicationConfigFault)(nil)).Elem()
  2419  }
  2420  
  2421  func (b *ReplicationFault) GetReplicationFault() *ReplicationFault { return b }
  2422  
  2423  type BaseReplicationFault interface {
  2424  	GetReplicationFault() *ReplicationFault
  2425  }
  2426  
  2427  func init() {
  2428  	t["BaseReplicationFault"] = reflect.TypeOf((*ReplicationFault)(nil)).Elem()
  2429  }
  2430  
  2431  func (b *ReplicationVmFault) GetReplicationVmFault() *ReplicationVmFault { return b }
  2432  
  2433  type BaseReplicationVmFault interface {
  2434  	GetReplicationVmFault() *ReplicationVmFault
  2435  }
  2436  
  2437  func init() {
  2438  	t["BaseReplicationVmFault"] = reflect.TypeOf((*ReplicationVmFault)(nil)).Elem()
  2439  }
  2440  
  2441  func (b *ResourceInUse) GetResourceInUse() *ResourceInUse { return b }
  2442  
  2443  type BaseResourceInUse interface {
  2444  	GetResourceInUse() *ResourceInUse
  2445  }
  2446  
  2447  func init() {
  2448  	t["BaseResourceInUse"] = reflect.TypeOf((*ResourceInUse)(nil)).Elem()
  2449  }
  2450  
  2451  func (b *ResourcePoolEvent) GetResourcePoolEvent() *ResourcePoolEvent { return b }
  2452  
  2453  type BaseResourcePoolEvent interface {
  2454  	GetResourcePoolEvent() *ResourcePoolEvent
  2455  }
  2456  
  2457  func init() {
  2458  	t["BaseResourcePoolEvent"] = reflect.TypeOf((*ResourcePoolEvent)(nil)).Elem()
  2459  }
  2460  
  2461  func (b *ResourcePoolSummary) GetResourcePoolSummary() *ResourcePoolSummary { return b }
  2462  
  2463  type BaseResourcePoolSummary interface {
  2464  	GetResourcePoolSummary() *ResourcePoolSummary
  2465  }
  2466  
  2467  func init() {
  2468  	t["BaseResourcePoolSummary"] = reflect.TypeOf((*ResourcePoolSummary)(nil)).Elem()
  2469  }
  2470  
  2471  func (b *RoleEvent) GetRoleEvent() *RoleEvent { return b }
  2472  
  2473  type BaseRoleEvent interface {
  2474  	GetRoleEvent() *RoleEvent
  2475  }
  2476  
  2477  func init() {
  2478  	t["BaseRoleEvent"] = reflect.TypeOf((*RoleEvent)(nil)).Elem()
  2479  }
  2480  
  2481  func (b *RuntimeFault) GetRuntimeFault() *RuntimeFault { return b }
  2482  
  2483  type BaseRuntimeFault interface {
  2484  	GetRuntimeFault() *RuntimeFault
  2485  }
  2486  
  2487  func init() {
  2488  	t["BaseRuntimeFault"] = reflect.TypeOf((*RuntimeFault)(nil)).Elem()
  2489  }
  2490  
  2491  func (b *ScheduledTaskEvent) GetScheduledTaskEvent() *ScheduledTaskEvent { return b }
  2492  
  2493  type BaseScheduledTaskEvent interface {
  2494  	GetScheduledTaskEvent() *ScheduledTaskEvent
  2495  }
  2496  
  2497  func init() {
  2498  	t["BaseScheduledTaskEvent"] = reflect.TypeOf((*ScheduledTaskEvent)(nil)).Elem()
  2499  }
  2500  
  2501  func (b *ScheduledTaskSpec) GetScheduledTaskSpec() *ScheduledTaskSpec { return b }
  2502  
  2503  type BaseScheduledTaskSpec interface {
  2504  	GetScheduledTaskSpec() *ScheduledTaskSpec
  2505  }
  2506  
  2507  func init() {
  2508  	t["BaseScheduledTaskSpec"] = reflect.TypeOf((*ScheduledTaskSpec)(nil)).Elem()
  2509  }
  2510  
  2511  func (b *ScsiLun) GetScsiLun() *ScsiLun { return b }
  2512  
  2513  type BaseScsiLun interface {
  2514  	GetScsiLun() *ScsiLun
  2515  }
  2516  
  2517  func init() {
  2518  	t["BaseScsiLun"] = reflect.TypeOf((*ScsiLun)(nil)).Elem()
  2519  }
  2520  
  2521  func (b *SecurityError) GetSecurityError() *SecurityError { return b }
  2522  
  2523  type BaseSecurityError interface {
  2524  	GetSecurityError() *SecurityError
  2525  }
  2526  
  2527  func init() {
  2528  	t["BaseSecurityError"] = reflect.TypeOf((*SecurityError)(nil)).Elem()
  2529  }
  2530  
  2531  func (b *SelectionSet) GetSelectionSet() *SelectionSet { return b }
  2532  
  2533  type BaseSelectionSet interface {
  2534  	GetSelectionSet() *SelectionSet
  2535  }
  2536  
  2537  func init() {
  2538  	t["BaseSelectionSet"] = reflect.TypeOf((*SelectionSet)(nil)).Elem()
  2539  }
  2540  
  2541  func (b *SelectionSpec) GetSelectionSpec() *SelectionSpec { return b }
  2542  
  2543  type BaseSelectionSpec interface {
  2544  	GetSelectionSpec() *SelectionSpec
  2545  }
  2546  
  2547  func init() {
  2548  	t["BaseSelectionSpec"] = reflect.TypeOf((*SelectionSpec)(nil)).Elem()
  2549  }
  2550  
  2551  func (b *ServiceLocatorCredential) GetServiceLocatorCredential() *ServiceLocatorCredential { return b }
  2552  
  2553  type BaseServiceLocatorCredential interface {
  2554  	GetServiceLocatorCredential() *ServiceLocatorCredential
  2555  }
  2556  
  2557  func init() {
  2558  	t["BaseServiceLocatorCredential"] = reflect.TypeOf((*ServiceLocatorCredential)(nil)).Elem()
  2559  }
  2560  
  2561  func (b *SessionEvent) GetSessionEvent() *SessionEvent { return b }
  2562  
  2563  type BaseSessionEvent interface {
  2564  	GetSessionEvent() *SessionEvent
  2565  }
  2566  
  2567  func init() {
  2568  	t["BaseSessionEvent"] = reflect.TypeOf((*SessionEvent)(nil)).Elem()
  2569  }
  2570  
  2571  func (b *SessionManagerServiceRequestSpec) GetSessionManagerServiceRequestSpec() *SessionManagerServiceRequestSpec {
  2572  	return b
  2573  }
  2574  
  2575  type BaseSessionManagerServiceRequestSpec interface {
  2576  	GetSessionManagerServiceRequestSpec() *SessionManagerServiceRequestSpec
  2577  }
  2578  
  2579  func init() {
  2580  	t["BaseSessionManagerServiceRequestSpec"] = reflect.TypeOf((*SessionManagerServiceRequestSpec)(nil)).Elem()
  2581  }
  2582  
  2583  func (b *SnapshotCopyNotSupported) GetSnapshotCopyNotSupported() *SnapshotCopyNotSupported { return b }
  2584  
  2585  type BaseSnapshotCopyNotSupported interface {
  2586  	GetSnapshotCopyNotSupported() *SnapshotCopyNotSupported
  2587  }
  2588  
  2589  func init() {
  2590  	t["BaseSnapshotCopyNotSupported"] = reflect.TypeOf((*SnapshotCopyNotSupported)(nil)).Elem()
  2591  }
  2592  
  2593  func (b *SnapshotFault) GetSnapshotFault() *SnapshotFault { return b }
  2594  
  2595  type BaseSnapshotFault interface {
  2596  	GetSnapshotFault() *SnapshotFault
  2597  }
  2598  
  2599  func init() {
  2600  	t["BaseSnapshotFault"] = reflect.TypeOf((*SnapshotFault)(nil)).Elem()
  2601  }
  2602  
  2603  func (b *TaskEvent) GetTaskEvent() *TaskEvent { return b }
  2604  
  2605  type BaseTaskEvent interface {
  2606  	GetTaskEvent() *TaskEvent
  2607  }
  2608  
  2609  func init() {
  2610  	t["BaseTaskEvent"] = reflect.TypeOf((*TaskEvent)(nil)).Elem()
  2611  }
  2612  
  2613  func (b *TaskInProgress) GetTaskInProgress() *TaskInProgress { return b }
  2614  
  2615  type BaseTaskInProgress interface {
  2616  	GetTaskInProgress() *TaskInProgress
  2617  }
  2618  
  2619  func init() {
  2620  	t["BaseTaskInProgress"] = reflect.TypeOf((*TaskInProgress)(nil)).Elem()
  2621  }
  2622  
  2623  func (b *TaskReason) GetTaskReason() *TaskReason { return b }
  2624  
  2625  type BaseTaskReason interface {
  2626  	GetTaskReason() *TaskReason
  2627  }
  2628  
  2629  func init() {
  2630  	t["BaseTaskReason"] = reflect.TypeOf((*TaskReason)(nil)).Elem()
  2631  }
  2632  
  2633  func (b *TaskScheduler) GetTaskScheduler() *TaskScheduler { return b }
  2634  
  2635  type BaseTaskScheduler interface {
  2636  	GetTaskScheduler() *TaskScheduler
  2637  }
  2638  
  2639  func init() {
  2640  	t["BaseTaskScheduler"] = reflect.TypeOf((*TaskScheduler)(nil)).Elem()
  2641  }
  2642  
  2643  func (b *TemplateUpgradeEvent) GetTemplateUpgradeEvent() *TemplateUpgradeEvent { return b }
  2644  
  2645  type BaseTemplateUpgradeEvent interface {
  2646  	GetTemplateUpgradeEvent() *TemplateUpgradeEvent
  2647  }
  2648  
  2649  func init() {
  2650  	t["BaseTemplateUpgradeEvent"] = reflect.TypeOf((*TemplateUpgradeEvent)(nil)).Elem()
  2651  }
  2652  
  2653  func (b *Timedout) GetTimedout() *Timedout { return b }
  2654  
  2655  type BaseTimedout interface {
  2656  	GetTimedout() *Timedout
  2657  }
  2658  
  2659  func init() {
  2660  	t["BaseTimedout"] = reflect.TypeOf((*Timedout)(nil)).Elem()
  2661  }
  2662  
  2663  func (b *TypeDescription) GetTypeDescription() *TypeDescription { return b }
  2664  
  2665  type BaseTypeDescription interface {
  2666  	GetTypeDescription() *TypeDescription
  2667  }
  2668  
  2669  func init() {
  2670  	t["BaseTypeDescription"] = reflect.TypeOf((*TypeDescription)(nil)).Elem()
  2671  }
  2672  
  2673  func (b *UnsupportedDatastore) GetUnsupportedDatastore() *UnsupportedDatastore { return b }
  2674  
  2675  type BaseUnsupportedDatastore interface {
  2676  	GetUnsupportedDatastore() *UnsupportedDatastore
  2677  }
  2678  
  2679  func init() {
  2680  	t["BaseUnsupportedDatastore"] = reflect.TypeOf((*UnsupportedDatastore)(nil)).Elem()
  2681  }
  2682  
  2683  func (b *UpgradeEvent) GetUpgradeEvent() *UpgradeEvent { return b }
  2684  
  2685  type BaseUpgradeEvent interface {
  2686  	GetUpgradeEvent() *UpgradeEvent
  2687  }
  2688  
  2689  func init() {
  2690  	t["BaseUpgradeEvent"] = reflect.TypeOf((*UpgradeEvent)(nil)).Elem()
  2691  }
  2692  
  2693  func (b *UserSearchResult) GetUserSearchResult() *UserSearchResult { return b }
  2694  
  2695  type BaseUserSearchResult interface {
  2696  	GetUserSearchResult() *UserSearchResult
  2697  }
  2698  
  2699  func init() {
  2700  	t["BaseUserSearchResult"] = reflect.TypeOf((*UserSearchResult)(nil)).Elem()
  2701  }
  2702  
  2703  func (b *VAppConfigFault) GetVAppConfigFault() *VAppConfigFault { return b }
  2704  
  2705  type BaseVAppConfigFault interface {
  2706  	GetVAppConfigFault() *VAppConfigFault
  2707  }
  2708  
  2709  func init() {
  2710  	t["BaseVAppConfigFault"] = reflect.TypeOf((*VAppConfigFault)(nil)).Elem()
  2711  }
  2712  
  2713  func (b *VAppPropertyFault) GetVAppPropertyFault() *VAppPropertyFault { return b }
  2714  
  2715  type BaseVAppPropertyFault interface {
  2716  	GetVAppPropertyFault() *VAppPropertyFault
  2717  }
  2718  
  2719  func init() {
  2720  	t["BaseVAppPropertyFault"] = reflect.TypeOf((*VAppPropertyFault)(nil)).Elem()
  2721  }
  2722  
  2723  func (b *VMotionInterfaceIssue) GetVMotionInterfaceIssue() *VMotionInterfaceIssue { return b }
  2724  
  2725  type BaseVMotionInterfaceIssue interface {
  2726  	GetVMotionInterfaceIssue() *VMotionInterfaceIssue
  2727  }
  2728  
  2729  func init() {
  2730  	t["BaseVMotionInterfaceIssue"] = reflect.TypeOf((*VMotionInterfaceIssue)(nil)).Elem()
  2731  }
  2732  
  2733  func (b *VMwareDVSHealthCheckConfig) GetVMwareDVSHealthCheckConfig() *VMwareDVSHealthCheckConfig {
  2734  	return b
  2735  }
  2736  
  2737  type BaseVMwareDVSHealthCheckConfig interface {
  2738  	GetVMwareDVSHealthCheckConfig() *VMwareDVSHealthCheckConfig
  2739  }
  2740  
  2741  func init() {
  2742  	t["BaseVMwareDVSHealthCheckConfig"] = reflect.TypeOf((*VMwareDVSHealthCheckConfig)(nil)).Elem()
  2743  }
  2744  
  2745  func (b *VimFault) GetVimFault() *VimFault { return b }
  2746  
  2747  type BaseVimFault interface {
  2748  	GetVimFault() *VimFault
  2749  }
  2750  
  2751  func init() {
  2752  	t["BaseVimFault"] = reflect.TypeOf((*VimFault)(nil)).Elem()
  2753  }
  2754  
  2755  func (b *VirtualController) GetVirtualController() *VirtualController { return b }
  2756  
  2757  type BaseVirtualController interface {
  2758  	GetVirtualController() *VirtualController
  2759  }
  2760  
  2761  func init() {
  2762  	t["BaseVirtualController"] = reflect.TypeOf((*VirtualController)(nil)).Elem()
  2763  }
  2764  
  2765  func (b *VirtualControllerOption) GetVirtualControllerOption() *VirtualControllerOption { return b }
  2766  
  2767  type BaseVirtualControllerOption interface {
  2768  	GetVirtualControllerOption() *VirtualControllerOption
  2769  }
  2770  
  2771  func init() {
  2772  	t["BaseVirtualControllerOption"] = reflect.TypeOf((*VirtualControllerOption)(nil)).Elem()
  2773  }
  2774  
  2775  func (b *VirtualDevice) GetVirtualDevice() *VirtualDevice { return b }
  2776  
  2777  type BaseVirtualDevice interface {
  2778  	GetVirtualDevice() *VirtualDevice
  2779  }
  2780  
  2781  func init() {
  2782  	t["BaseVirtualDevice"] = reflect.TypeOf((*VirtualDevice)(nil)).Elem()
  2783  }
  2784  
  2785  func (b *VirtualDeviceBackingInfo) GetVirtualDeviceBackingInfo() *VirtualDeviceBackingInfo { return b }
  2786  
  2787  type BaseVirtualDeviceBackingInfo interface {
  2788  	GetVirtualDeviceBackingInfo() *VirtualDeviceBackingInfo
  2789  }
  2790  
  2791  func init() {
  2792  	t["BaseVirtualDeviceBackingInfo"] = reflect.TypeOf((*VirtualDeviceBackingInfo)(nil)).Elem()
  2793  }
  2794  
  2795  func (b *VirtualDeviceBackingOption) GetVirtualDeviceBackingOption() *VirtualDeviceBackingOption {
  2796  	return b
  2797  }
  2798  
  2799  type BaseVirtualDeviceBackingOption interface {
  2800  	GetVirtualDeviceBackingOption() *VirtualDeviceBackingOption
  2801  }
  2802  
  2803  func init() {
  2804  	t["BaseVirtualDeviceBackingOption"] = reflect.TypeOf((*VirtualDeviceBackingOption)(nil)).Elem()
  2805  }
  2806  
  2807  func (b *VirtualDeviceBusSlotInfo) GetVirtualDeviceBusSlotInfo() *VirtualDeviceBusSlotInfo { return b }
  2808  
  2809  type BaseVirtualDeviceBusSlotInfo interface {
  2810  	GetVirtualDeviceBusSlotInfo() *VirtualDeviceBusSlotInfo
  2811  }
  2812  
  2813  func init() {
  2814  	t["BaseVirtualDeviceBusSlotInfo"] = reflect.TypeOf((*VirtualDeviceBusSlotInfo)(nil)).Elem()
  2815  }
  2816  
  2817  func (b *VirtualDeviceConfigSpec) GetVirtualDeviceConfigSpec() *VirtualDeviceConfigSpec { return b }
  2818  
  2819  type BaseVirtualDeviceConfigSpec interface {
  2820  	GetVirtualDeviceConfigSpec() *VirtualDeviceConfigSpec
  2821  }
  2822  
  2823  func init() {
  2824  	t["BaseVirtualDeviceConfigSpec"] = reflect.TypeOf((*VirtualDeviceConfigSpec)(nil)).Elem()
  2825  }
  2826  
  2827  func (b *VirtualDeviceDeviceBackingInfo) GetVirtualDeviceDeviceBackingInfo() *VirtualDeviceDeviceBackingInfo {
  2828  	return b
  2829  }
  2830  
  2831  type BaseVirtualDeviceDeviceBackingInfo interface {
  2832  	GetVirtualDeviceDeviceBackingInfo() *VirtualDeviceDeviceBackingInfo
  2833  }
  2834  
  2835  func init() {
  2836  	t["BaseVirtualDeviceDeviceBackingInfo"] = reflect.TypeOf((*VirtualDeviceDeviceBackingInfo)(nil)).Elem()
  2837  }
  2838  
  2839  func (b *VirtualDeviceDeviceBackingOption) GetVirtualDeviceDeviceBackingOption() *VirtualDeviceDeviceBackingOption {
  2840  	return b
  2841  }
  2842  
  2843  type BaseVirtualDeviceDeviceBackingOption interface {
  2844  	GetVirtualDeviceDeviceBackingOption() *VirtualDeviceDeviceBackingOption
  2845  }
  2846  
  2847  func init() {
  2848  	t["BaseVirtualDeviceDeviceBackingOption"] = reflect.TypeOf((*VirtualDeviceDeviceBackingOption)(nil)).Elem()
  2849  }
  2850  
  2851  func (b *VirtualDeviceFileBackingInfo) GetVirtualDeviceFileBackingInfo() *VirtualDeviceFileBackingInfo {
  2852  	return b
  2853  }
  2854  
  2855  type BaseVirtualDeviceFileBackingInfo interface {
  2856  	GetVirtualDeviceFileBackingInfo() *VirtualDeviceFileBackingInfo
  2857  }
  2858  
  2859  func init() {
  2860  	t["BaseVirtualDeviceFileBackingInfo"] = reflect.TypeOf((*VirtualDeviceFileBackingInfo)(nil)).Elem()
  2861  }
  2862  
  2863  func (b *VirtualDeviceFileBackingOption) GetVirtualDeviceFileBackingOption() *VirtualDeviceFileBackingOption {
  2864  	return b
  2865  }
  2866  
  2867  type BaseVirtualDeviceFileBackingOption interface {
  2868  	GetVirtualDeviceFileBackingOption() *VirtualDeviceFileBackingOption
  2869  }
  2870  
  2871  func init() {
  2872  	t["BaseVirtualDeviceFileBackingOption"] = reflect.TypeOf((*VirtualDeviceFileBackingOption)(nil)).Elem()
  2873  }
  2874  
  2875  func (b *VirtualDeviceOption) GetVirtualDeviceOption() *VirtualDeviceOption { return b }
  2876  
  2877  type BaseVirtualDeviceOption interface {
  2878  	GetVirtualDeviceOption() *VirtualDeviceOption
  2879  }
  2880  
  2881  func init() {
  2882  	t["BaseVirtualDeviceOption"] = reflect.TypeOf((*VirtualDeviceOption)(nil)).Elem()
  2883  }
  2884  
  2885  func (b *VirtualDevicePciBusSlotInfo) GetVirtualDevicePciBusSlotInfo() *VirtualDevicePciBusSlotInfo {
  2886  	return b
  2887  }
  2888  
  2889  type BaseVirtualDevicePciBusSlotInfo interface {
  2890  	GetVirtualDevicePciBusSlotInfo() *VirtualDevicePciBusSlotInfo
  2891  }
  2892  
  2893  func init() {
  2894  	t["BaseVirtualDevicePciBusSlotInfo"] = reflect.TypeOf((*VirtualDevicePciBusSlotInfo)(nil)).Elem()
  2895  }
  2896  
  2897  func (b *VirtualDevicePipeBackingInfo) GetVirtualDevicePipeBackingInfo() *VirtualDevicePipeBackingInfo {
  2898  	return b
  2899  }
  2900  
  2901  type BaseVirtualDevicePipeBackingInfo interface {
  2902  	GetVirtualDevicePipeBackingInfo() *VirtualDevicePipeBackingInfo
  2903  }
  2904  
  2905  func init() {
  2906  	t["BaseVirtualDevicePipeBackingInfo"] = reflect.TypeOf((*VirtualDevicePipeBackingInfo)(nil)).Elem()
  2907  }
  2908  
  2909  func (b *VirtualDevicePipeBackingOption) GetVirtualDevicePipeBackingOption() *VirtualDevicePipeBackingOption {
  2910  	return b
  2911  }
  2912  
  2913  type BaseVirtualDevicePipeBackingOption interface {
  2914  	GetVirtualDevicePipeBackingOption() *VirtualDevicePipeBackingOption
  2915  }
  2916  
  2917  func init() {
  2918  	t["BaseVirtualDevicePipeBackingOption"] = reflect.TypeOf((*VirtualDevicePipeBackingOption)(nil)).Elem()
  2919  }
  2920  
  2921  func (b *VirtualDeviceRemoteDeviceBackingInfo) GetVirtualDeviceRemoteDeviceBackingInfo() *VirtualDeviceRemoteDeviceBackingInfo {
  2922  	return b
  2923  }
  2924  
  2925  type BaseVirtualDeviceRemoteDeviceBackingInfo interface {
  2926  	GetVirtualDeviceRemoteDeviceBackingInfo() *VirtualDeviceRemoteDeviceBackingInfo
  2927  }
  2928  
  2929  func init() {
  2930  	t["BaseVirtualDeviceRemoteDeviceBackingInfo"] = reflect.TypeOf((*VirtualDeviceRemoteDeviceBackingInfo)(nil)).Elem()
  2931  }
  2932  
  2933  func (b *VirtualDeviceRemoteDeviceBackingOption) GetVirtualDeviceRemoteDeviceBackingOption() *VirtualDeviceRemoteDeviceBackingOption {
  2934  	return b
  2935  }
  2936  
  2937  type BaseVirtualDeviceRemoteDeviceBackingOption interface {
  2938  	GetVirtualDeviceRemoteDeviceBackingOption() *VirtualDeviceRemoteDeviceBackingOption
  2939  }
  2940  
  2941  func init() {
  2942  	t["BaseVirtualDeviceRemoteDeviceBackingOption"] = reflect.TypeOf((*VirtualDeviceRemoteDeviceBackingOption)(nil)).Elem()
  2943  }
  2944  
  2945  func (b *VirtualDeviceURIBackingInfo) GetVirtualDeviceURIBackingInfo() *VirtualDeviceURIBackingInfo {
  2946  	return b
  2947  }
  2948  
  2949  type BaseVirtualDeviceURIBackingInfo interface {
  2950  	GetVirtualDeviceURIBackingInfo() *VirtualDeviceURIBackingInfo
  2951  }
  2952  
  2953  func init() {
  2954  	t["BaseVirtualDeviceURIBackingInfo"] = reflect.TypeOf((*VirtualDeviceURIBackingInfo)(nil)).Elem()
  2955  }
  2956  
  2957  func (b *VirtualDeviceURIBackingOption) GetVirtualDeviceURIBackingOption() *VirtualDeviceURIBackingOption {
  2958  	return b
  2959  }
  2960  
  2961  type BaseVirtualDeviceURIBackingOption interface {
  2962  	GetVirtualDeviceURIBackingOption() *VirtualDeviceURIBackingOption
  2963  }
  2964  
  2965  func init() {
  2966  	t["BaseVirtualDeviceURIBackingOption"] = reflect.TypeOf((*VirtualDeviceURIBackingOption)(nil)).Elem()
  2967  }
  2968  
  2969  func (b *VirtualDiskRawDiskVer2BackingInfo) GetVirtualDiskRawDiskVer2BackingInfo() *VirtualDiskRawDiskVer2BackingInfo {
  2970  	return b
  2971  }
  2972  
  2973  type BaseVirtualDiskRawDiskVer2BackingInfo interface {
  2974  	GetVirtualDiskRawDiskVer2BackingInfo() *VirtualDiskRawDiskVer2BackingInfo
  2975  }
  2976  
  2977  func init() {
  2978  	t["BaseVirtualDiskRawDiskVer2BackingInfo"] = reflect.TypeOf((*VirtualDiskRawDiskVer2BackingInfo)(nil)).Elem()
  2979  }
  2980  
  2981  func (b *VirtualDiskRawDiskVer2BackingOption) GetVirtualDiskRawDiskVer2BackingOption() *VirtualDiskRawDiskVer2BackingOption {
  2982  	return b
  2983  }
  2984  
  2985  type BaseVirtualDiskRawDiskVer2BackingOption interface {
  2986  	GetVirtualDiskRawDiskVer2BackingOption() *VirtualDiskRawDiskVer2BackingOption
  2987  }
  2988  
  2989  func init() {
  2990  	t["BaseVirtualDiskRawDiskVer2BackingOption"] = reflect.TypeOf((*VirtualDiskRawDiskVer2BackingOption)(nil)).Elem()
  2991  }
  2992  
  2993  func (b *VirtualDiskSpec) GetVirtualDiskSpec() *VirtualDiskSpec { return b }
  2994  
  2995  type BaseVirtualDiskSpec interface {
  2996  	GetVirtualDiskSpec() *VirtualDiskSpec
  2997  }
  2998  
  2999  func init() {
  3000  	t["BaseVirtualDiskSpec"] = reflect.TypeOf((*VirtualDiskSpec)(nil)).Elem()
  3001  }
  3002  
  3003  func (b *VirtualEthernetCard) GetVirtualEthernetCard() *VirtualEthernetCard { return b }
  3004  
  3005  type BaseVirtualEthernetCard interface {
  3006  	GetVirtualEthernetCard() *VirtualEthernetCard
  3007  }
  3008  
  3009  func init() {
  3010  	t["BaseVirtualEthernetCard"] = reflect.TypeOf((*VirtualEthernetCard)(nil)).Elem()
  3011  }
  3012  
  3013  func (b *VirtualEthernetCardOption) GetVirtualEthernetCardOption() *VirtualEthernetCardOption {
  3014  	return b
  3015  }
  3016  
  3017  type BaseVirtualEthernetCardOption interface {
  3018  	GetVirtualEthernetCardOption() *VirtualEthernetCardOption
  3019  }
  3020  
  3021  func init() {
  3022  	t["BaseVirtualEthernetCardOption"] = reflect.TypeOf((*VirtualEthernetCardOption)(nil)).Elem()
  3023  }
  3024  
  3025  func (b *VirtualHardwareCompatibilityIssue) GetVirtualHardwareCompatibilityIssue() *VirtualHardwareCompatibilityIssue {
  3026  	return b
  3027  }
  3028  
  3029  type BaseVirtualHardwareCompatibilityIssue interface {
  3030  	GetVirtualHardwareCompatibilityIssue() *VirtualHardwareCompatibilityIssue
  3031  }
  3032  
  3033  func init() {
  3034  	t["BaseVirtualHardwareCompatibilityIssue"] = reflect.TypeOf((*VirtualHardwareCompatibilityIssue)(nil)).Elem()
  3035  }
  3036  
  3037  func (b *VirtualMachineBaseIndependentFilterSpec) GetVirtualMachineBaseIndependentFilterSpec() *VirtualMachineBaseIndependentFilterSpec {
  3038  	return b
  3039  }
  3040  
  3041  type BaseVirtualMachineBaseIndependentFilterSpec interface {
  3042  	GetVirtualMachineBaseIndependentFilterSpec() *VirtualMachineBaseIndependentFilterSpec
  3043  }
  3044  
  3045  func init() {
  3046  	t["BaseVirtualMachineBaseIndependentFilterSpec"] = reflect.TypeOf((*VirtualMachineBaseIndependentFilterSpec)(nil)).Elem()
  3047  }
  3048  
  3049  func (b *VirtualMachineBootOptionsBootableDevice) GetVirtualMachineBootOptionsBootableDevice() *VirtualMachineBootOptionsBootableDevice {
  3050  	return b
  3051  }
  3052  
  3053  type BaseVirtualMachineBootOptionsBootableDevice interface {
  3054  	GetVirtualMachineBootOptionsBootableDevice() *VirtualMachineBootOptionsBootableDevice
  3055  }
  3056  
  3057  func init() {
  3058  	t["BaseVirtualMachineBootOptionsBootableDevice"] = reflect.TypeOf((*VirtualMachineBootOptionsBootableDevice)(nil)).Elem()
  3059  }
  3060  
  3061  func (b *VirtualMachineConnection) GetVirtualMachineConnection() *VirtualMachineConnection { return b }
  3062  
  3063  type BaseVirtualMachineConnection interface {
  3064  	GetVirtualMachineConnection() *VirtualMachineConnection
  3065  }
  3066  
  3067  func init() {
  3068  	t["BaseVirtualMachineConnection"] = reflect.TypeOf((*VirtualMachineConnection)(nil)).Elem()
  3069  }
  3070  
  3071  func (b *VirtualMachineDeviceRuntimeInfoDeviceRuntimeState) GetVirtualMachineDeviceRuntimeInfoDeviceRuntimeState() *VirtualMachineDeviceRuntimeInfoDeviceRuntimeState {
  3072  	return b
  3073  }
  3074  
  3075  type BaseVirtualMachineDeviceRuntimeInfoDeviceRuntimeState interface {
  3076  	GetVirtualMachineDeviceRuntimeInfoDeviceRuntimeState() *VirtualMachineDeviceRuntimeInfoDeviceRuntimeState
  3077  }
  3078  
  3079  func init() {
  3080  	t["BaseVirtualMachineDeviceRuntimeInfoDeviceRuntimeState"] = reflect.TypeOf((*VirtualMachineDeviceRuntimeInfoDeviceRuntimeState)(nil)).Elem()
  3081  }
  3082  
  3083  func (b *VirtualMachineDiskDeviceInfo) GetVirtualMachineDiskDeviceInfo() *VirtualMachineDiskDeviceInfo {
  3084  	return b
  3085  }
  3086  
  3087  type BaseVirtualMachineDiskDeviceInfo interface {
  3088  	GetVirtualMachineDiskDeviceInfo() *VirtualMachineDiskDeviceInfo
  3089  }
  3090  
  3091  func init() {
  3092  	t["BaseVirtualMachineDiskDeviceInfo"] = reflect.TypeOf((*VirtualMachineDiskDeviceInfo)(nil)).Elem()
  3093  }
  3094  
  3095  func (b *VirtualMachineGuestQuiesceSpec) GetVirtualMachineGuestQuiesceSpec() *VirtualMachineGuestQuiesceSpec {
  3096  	return b
  3097  }
  3098  
  3099  type BaseVirtualMachineGuestQuiesceSpec interface {
  3100  	GetVirtualMachineGuestQuiesceSpec() *VirtualMachineGuestQuiesceSpec
  3101  }
  3102  
  3103  func init() {
  3104  	t["BaseVirtualMachineGuestQuiesceSpec"] = reflect.TypeOf((*VirtualMachineGuestQuiesceSpec)(nil)).Elem()
  3105  }
  3106  
  3107  func (b *VirtualMachinePciPassthroughInfo) GetVirtualMachinePciPassthroughInfo() *VirtualMachinePciPassthroughInfo {
  3108  	return b
  3109  }
  3110  
  3111  type BaseVirtualMachinePciPassthroughInfo interface {
  3112  	GetVirtualMachinePciPassthroughInfo() *VirtualMachinePciPassthroughInfo
  3113  }
  3114  
  3115  func init() {
  3116  	t["BaseVirtualMachinePciPassthroughInfo"] = reflect.TypeOf((*VirtualMachinePciPassthroughInfo)(nil)).Elem()
  3117  }
  3118  
  3119  func (b *VirtualMachineProfileSpec) GetVirtualMachineProfileSpec() *VirtualMachineProfileSpec {
  3120  	return b
  3121  }
  3122  
  3123  type BaseVirtualMachineProfileSpec interface {
  3124  	GetVirtualMachineProfileSpec() *VirtualMachineProfileSpec
  3125  }
  3126  
  3127  func init() {
  3128  	t["BaseVirtualMachineProfileSpec"] = reflect.TypeOf((*VirtualMachineProfileSpec)(nil)).Elem()
  3129  }
  3130  
  3131  func (b *VirtualMachineSriovDevicePoolInfo) GetVirtualMachineSriovDevicePoolInfo() *VirtualMachineSriovDevicePoolInfo {
  3132  	return b
  3133  }
  3134  
  3135  type BaseVirtualMachineSriovDevicePoolInfo interface {
  3136  	GetVirtualMachineSriovDevicePoolInfo() *VirtualMachineSriovDevicePoolInfo
  3137  }
  3138  
  3139  func init() {
  3140  	t["BaseVirtualMachineSriovDevicePoolInfo"] = reflect.TypeOf((*VirtualMachineSriovDevicePoolInfo)(nil)).Elem()
  3141  }
  3142  
  3143  func (b *VirtualMachineTargetInfo) GetVirtualMachineTargetInfo() *VirtualMachineTargetInfo { return b }
  3144  
  3145  type BaseVirtualMachineTargetInfo interface {
  3146  	GetVirtualMachineTargetInfo() *VirtualMachineTargetInfo
  3147  }
  3148  
  3149  func init() {
  3150  	t["BaseVirtualMachineTargetInfo"] = reflect.TypeOf((*VirtualMachineTargetInfo)(nil)).Elem()
  3151  }
  3152  
  3153  func (b *VirtualMachineVirtualDeviceGroupsDeviceGroup) GetVirtualMachineVirtualDeviceGroupsDeviceGroup() *VirtualMachineVirtualDeviceGroupsDeviceGroup {
  3154  	return b
  3155  }
  3156  
  3157  type BaseVirtualMachineVirtualDeviceGroupsDeviceGroup interface {
  3158  	GetVirtualMachineVirtualDeviceGroupsDeviceGroup() *VirtualMachineVirtualDeviceGroupsDeviceGroup
  3159  }
  3160  
  3161  func init() {
  3162  	t["BaseVirtualMachineVirtualDeviceGroupsDeviceGroup"] = reflect.TypeOf((*VirtualMachineVirtualDeviceGroupsDeviceGroup)(nil)).Elem()
  3163  }
  3164  
  3165  func (b *VirtualPCIPassthroughPluginBackingInfo) GetVirtualPCIPassthroughPluginBackingInfo() *VirtualPCIPassthroughPluginBackingInfo {
  3166  	return b
  3167  }
  3168  
  3169  type BaseVirtualPCIPassthroughPluginBackingInfo interface {
  3170  	GetVirtualPCIPassthroughPluginBackingInfo() *VirtualPCIPassthroughPluginBackingInfo
  3171  }
  3172  
  3173  func init() {
  3174  	t["BaseVirtualPCIPassthroughPluginBackingInfo"] = reflect.TypeOf((*VirtualPCIPassthroughPluginBackingInfo)(nil)).Elem()
  3175  }
  3176  
  3177  func (b *VirtualPCIPassthroughPluginBackingOption) GetVirtualPCIPassthroughPluginBackingOption() *VirtualPCIPassthroughPluginBackingOption {
  3178  	return b
  3179  }
  3180  
  3181  type BaseVirtualPCIPassthroughPluginBackingOption interface {
  3182  	GetVirtualPCIPassthroughPluginBackingOption() *VirtualPCIPassthroughPluginBackingOption
  3183  }
  3184  
  3185  func init() {
  3186  	t["BaseVirtualPCIPassthroughPluginBackingOption"] = reflect.TypeOf((*VirtualPCIPassthroughPluginBackingOption)(nil)).Elem()
  3187  }
  3188  
  3189  func (b *VirtualSATAController) GetVirtualSATAController() *VirtualSATAController { return b }
  3190  
  3191  type BaseVirtualSATAController interface {
  3192  	GetVirtualSATAController() *VirtualSATAController
  3193  }
  3194  
  3195  func init() {
  3196  	t["BaseVirtualSATAController"] = reflect.TypeOf((*VirtualSATAController)(nil)).Elem()
  3197  }
  3198  
  3199  func (b *VirtualSATAControllerOption) GetVirtualSATAControllerOption() *VirtualSATAControllerOption {
  3200  	return b
  3201  }
  3202  
  3203  type BaseVirtualSATAControllerOption interface {
  3204  	GetVirtualSATAControllerOption() *VirtualSATAControllerOption
  3205  }
  3206  
  3207  func init() {
  3208  	t["BaseVirtualSATAControllerOption"] = reflect.TypeOf((*VirtualSATAControllerOption)(nil)).Elem()
  3209  }
  3210  
  3211  func (b *VirtualSCSIController) GetVirtualSCSIController() *VirtualSCSIController { return b }
  3212  
  3213  type BaseVirtualSCSIController interface {
  3214  	GetVirtualSCSIController() *VirtualSCSIController
  3215  }
  3216  
  3217  func init() {
  3218  	t["BaseVirtualSCSIController"] = reflect.TypeOf((*VirtualSCSIController)(nil)).Elem()
  3219  }
  3220  
  3221  func (b *VirtualSCSIControllerOption) GetVirtualSCSIControllerOption() *VirtualSCSIControllerOption {
  3222  	return b
  3223  }
  3224  
  3225  type BaseVirtualSCSIControllerOption interface {
  3226  	GetVirtualSCSIControllerOption() *VirtualSCSIControllerOption
  3227  }
  3228  
  3229  func init() {
  3230  	t["BaseVirtualSCSIControllerOption"] = reflect.TypeOf((*VirtualSCSIControllerOption)(nil)).Elem()
  3231  }
  3232  
  3233  func (b *VirtualSoundCard) GetVirtualSoundCard() *VirtualSoundCard { return b }
  3234  
  3235  type BaseVirtualSoundCard interface {
  3236  	GetVirtualSoundCard() *VirtualSoundCard
  3237  }
  3238  
  3239  func init() {
  3240  	t["BaseVirtualSoundCard"] = reflect.TypeOf((*VirtualSoundCard)(nil)).Elem()
  3241  }
  3242  
  3243  func (b *VirtualSoundCardOption) GetVirtualSoundCardOption() *VirtualSoundCardOption { return b }
  3244  
  3245  type BaseVirtualSoundCardOption interface {
  3246  	GetVirtualSoundCardOption() *VirtualSoundCardOption
  3247  }
  3248  
  3249  func init() {
  3250  	t["BaseVirtualSoundCardOption"] = reflect.TypeOf((*VirtualSoundCardOption)(nil)).Elem()
  3251  }
  3252  
  3253  func (b *VirtualVmxnet) GetVirtualVmxnet() *VirtualVmxnet { return b }
  3254  
  3255  type BaseVirtualVmxnet interface {
  3256  	GetVirtualVmxnet() *VirtualVmxnet
  3257  }
  3258  
  3259  func init() {
  3260  	t["BaseVirtualVmxnet"] = reflect.TypeOf((*VirtualVmxnet)(nil)).Elem()
  3261  }
  3262  
  3263  func (b *VirtualVmxnet3) GetVirtualVmxnet3() *VirtualVmxnet3 { return b }
  3264  
  3265  type BaseVirtualVmxnet3 interface {
  3266  	GetVirtualVmxnet3() *VirtualVmxnet3
  3267  }
  3268  
  3269  func init() {
  3270  	t["BaseVirtualVmxnet3"] = reflect.TypeOf((*VirtualVmxnet3)(nil)).Elem()
  3271  }
  3272  
  3273  func (b *VirtualVmxnet3Option) GetVirtualVmxnet3Option() *VirtualVmxnet3Option { return b }
  3274  
  3275  type BaseVirtualVmxnet3Option interface {
  3276  	GetVirtualVmxnet3Option() *VirtualVmxnet3Option
  3277  }
  3278  
  3279  func init() {
  3280  	t["BaseVirtualVmxnet3Option"] = reflect.TypeOf((*VirtualVmxnet3Option)(nil)).Elem()
  3281  }
  3282  
  3283  func (b *VirtualVmxnetOption) GetVirtualVmxnetOption() *VirtualVmxnetOption { return b }
  3284  
  3285  type BaseVirtualVmxnetOption interface {
  3286  	GetVirtualVmxnetOption() *VirtualVmxnetOption
  3287  }
  3288  
  3289  func init() {
  3290  	t["BaseVirtualVmxnetOption"] = reflect.TypeOf((*VirtualVmxnetOption)(nil)).Elem()
  3291  }
  3292  
  3293  func (b *VmCloneEvent) GetVmCloneEvent() *VmCloneEvent { return b }
  3294  
  3295  type BaseVmCloneEvent interface {
  3296  	GetVmCloneEvent() *VmCloneEvent
  3297  }
  3298  
  3299  func init() {
  3300  	t["BaseVmCloneEvent"] = reflect.TypeOf((*VmCloneEvent)(nil)).Elem()
  3301  }
  3302  
  3303  func (b *VmConfigFault) GetVmConfigFault() *VmConfigFault { return b }
  3304  
  3305  type BaseVmConfigFault interface {
  3306  	GetVmConfigFault() *VmConfigFault
  3307  }
  3308  
  3309  func init() {
  3310  	t["BaseVmConfigFault"] = reflect.TypeOf((*VmConfigFault)(nil)).Elem()
  3311  }
  3312  
  3313  func (b *VmConfigFileInfo) GetVmConfigFileInfo() *VmConfigFileInfo { return b }
  3314  
  3315  type BaseVmConfigFileInfo interface {
  3316  	GetVmConfigFileInfo() *VmConfigFileInfo
  3317  }
  3318  
  3319  func init() {
  3320  	t["BaseVmConfigFileInfo"] = reflect.TypeOf((*VmConfigFileInfo)(nil)).Elem()
  3321  }
  3322  
  3323  func (b *VmConfigFileQuery) GetVmConfigFileQuery() *VmConfigFileQuery { return b }
  3324  
  3325  type BaseVmConfigFileQuery interface {
  3326  	GetVmConfigFileQuery() *VmConfigFileQuery
  3327  }
  3328  
  3329  func init() {
  3330  	t["BaseVmConfigFileQuery"] = reflect.TypeOf((*VmConfigFileQuery)(nil)).Elem()
  3331  }
  3332  
  3333  func (b *VmConfigInfo) GetVmConfigInfo() *VmConfigInfo { return b }
  3334  
  3335  type BaseVmConfigInfo interface {
  3336  	GetVmConfigInfo() *VmConfigInfo
  3337  }
  3338  
  3339  func init() {
  3340  	t["BaseVmConfigInfo"] = reflect.TypeOf((*VmConfigInfo)(nil)).Elem()
  3341  }
  3342  
  3343  func (b *VmConfigSpec) GetVmConfigSpec() *VmConfigSpec { return b }
  3344  
  3345  type BaseVmConfigSpec interface {
  3346  	GetVmConfigSpec() *VmConfigSpec
  3347  }
  3348  
  3349  func init() {
  3350  	t["BaseVmConfigSpec"] = reflect.TypeOf((*VmConfigSpec)(nil)).Elem()
  3351  }
  3352  
  3353  func (b *VmDasBeingResetEvent) GetVmDasBeingResetEvent() *VmDasBeingResetEvent { return b }
  3354  
  3355  type BaseVmDasBeingResetEvent interface {
  3356  	GetVmDasBeingResetEvent() *VmDasBeingResetEvent
  3357  }
  3358  
  3359  func init() {
  3360  	t["BaseVmDasBeingResetEvent"] = reflect.TypeOf((*VmDasBeingResetEvent)(nil)).Elem()
  3361  }
  3362  
  3363  func (b *VmEvent) GetVmEvent() *VmEvent { return b }
  3364  
  3365  type BaseVmEvent interface {
  3366  	GetVmEvent() *VmEvent
  3367  }
  3368  
  3369  func init() {
  3370  	t["BaseVmEvent"] = reflect.TypeOf((*VmEvent)(nil)).Elem()
  3371  }
  3372  
  3373  func (b *VmFaultToleranceIssue) GetVmFaultToleranceIssue() *VmFaultToleranceIssue { return b }
  3374  
  3375  type BaseVmFaultToleranceIssue interface {
  3376  	GetVmFaultToleranceIssue() *VmFaultToleranceIssue
  3377  }
  3378  
  3379  func init() {
  3380  	t["BaseVmFaultToleranceIssue"] = reflect.TypeOf((*VmFaultToleranceIssue)(nil)).Elem()
  3381  }
  3382  
  3383  func (b *VmMigratedEvent) GetVmMigratedEvent() *VmMigratedEvent { return b }
  3384  
  3385  type BaseVmMigratedEvent interface {
  3386  	GetVmMigratedEvent() *VmMigratedEvent
  3387  }
  3388  
  3389  func init() {
  3390  	t["BaseVmMigratedEvent"] = reflect.TypeOf((*VmMigratedEvent)(nil)).Elem()
  3391  }
  3392  
  3393  func (b *VmPoweredOffEvent) GetVmPoweredOffEvent() *VmPoweredOffEvent { return b }
  3394  
  3395  type BaseVmPoweredOffEvent interface {
  3396  	GetVmPoweredOffEvent() *VmPoweredOffEvent
  3397  }
  3398  
  3399  func init() {
  3400  	t["BaseVmPoweredOffEvent"] = reflect.TypeOf((*VmPoweredOffEvent)(nil)).Elem()
  3401  }
  3402  
  3403  func (b *VmPoweredOnEvent) GetVmPoweredOnEvent() *VmPoweredOnEvent { return b }
  3404  
  3405  type BaseVmPoweredOnEvent interface {
  3406  	GetVmPoweredOnEvent() *VmPoweredOnEvent
  3407  }
  3408  
  3409  func init() {
  3410  	t["BaseVmPoweredOnEvent"] = reflect.TypeOf((*VmPoweredOnEvent)(nil)).Elem()
  3411  }
  3412  
  3413  func (b *VmRelocateSpecEvent) GetVmRelocateSpecEvent() *VmRelocateSpecEvent { return b }
  3414  
  3415  type BaseVmRelocateSpecEvent interface {
  3416  	GetVmRelocateSpecEvent() *VmRelocateSpecEvent
  3417  }
  3418  
  3419  func init() {
  3420  	t["BaseVmRelocateSpecEvent"] = reflect.TypeOf((*VmRelocateSpecEvent)(nil)).Elem()
  3421  }
  3422  
  3423  func (b *VmStartingEvent) GetVmStartingEvent() *VmStartingEvent { return b }
  3424  
  3425  type BaseVmStartingEvent interface {
  3426  	GetVmStartingEvent() *VmStartingEvent
  3427  }
  3428  
  3429  func init() {
  3430  	t["BaseVmStartingEvent"] = reflect.TypeOf((*VmStartingEvent)(nil)).Elem()
  3431  }
  3432  
  3433  func (b *VmToolsUpgradeFault) GetVmToolsUpgradeFault() *VmToolsUpgradeFault { return b }
  3434  
  3435  type BaseVmToolsUpgradeFault interface {
  3436  	GetVmToolsUpgradeFault() *VmToolsUpgradeFault
  3437  }
  3438  
  3439  func init() {
  3440  	t["BaseVmToolsUpgradeFault"] = reflect.TypeOf((*VmToolsUpgradeFault)(nil)).Elem()
  3441  }
  3442  
  3443  func (b *VmfsDatastoreBaseOption) GetVmfsDatastoreBaseOption() *VmfsDatastoreBaseOption { return b }
  3444  
  3445  type BaseVmfsDatastoreBaseOption interface {
  3446  	GetVmfsDatastoreBaseOption() *VmfsDatastoreBaseOption
  3447  }
  3448  
  3449  func init() {
  3450  	t["BaseVmfsDatastoreBaseOption"] = reflect.TypeOf((*VmfsDatastoreBaseOption)(nil)).Elem()
  3451  }
  3452  
  3453  func (b *VmfsDatastoreSingleExtentOption) GetVmfsDatastoreSingleExtentOption() *VmfsDatastoreSingleExtentOption {
  3454  	return b
  3455  }
  3456  
  3457  type BaseVmfsDatastoreSingleExtentOption interface {
  3458  	GetVmfsDatastoreSingleExtentOption() *VmfsDatastoreSingleExtentOption
  3459  }
  3460  
  3461  func init() {
  3462  	t["BaseVmfsDatastoreSingleExtentOption"] = reflect.TypeOf((*VmfsDatastoreSingleExtentOption)(nil)).Elem()
  3463  }
  3464  
  3465  func (b *VmfsDatastoreSpec) GetVmfsDatastoreSpec() *VmfsDatastoreSpec { return b }
  3466  
  3467  type BaseVmfsDatastoreSpec interface {
  3468  	GetVmfsDatastoreSpec() *VmfsDatastoreSpec
  3469  }
  3470  
  3471  func init() {
  3472  	t["BaseVmfsDatastoreSpec"] = reflect.TypeOf((*VmfsDatastoreSpec)(nil)).Elem()
  3473  }
  3474  
  3475  func (b *VmfsMountFault) GetVmfsMountFault() *VmfsMountFault { return b }
  3476  
  3477  type BaseVmfsMountFault interface {
  3478  	GetVmfsMountFault() *VmfsMountFault
  3479  }
  3480  
  3481  func init() {
  3482  	t["BaseVmfsMountFault"] = reflect.TypeOf((*VmfsMountFault)(nil)).Elem()
  3483  }
  3484  
  3485  func (b *VmwareDistributedVirtualSwitchVlanSpec) GetVmwareDistributedVirtualSwitchVlanSpec() *VmwareDistributedVirtualSwitchVlanSpec {
  3486  	return b
  3487  }
  3488  
  3489  type BaseVmwareDistributedVirtualSwitchVlanSpec interface {
  3490  	GetVmwareDistributedVirtualSwitchVlanSpec() *VmwareDistributedVirtualSwitchVlanSpec
  3491  }
  3492  
  3493  func init() {
  3494  	t["BaseVmwareDistributedVirtualSwitchVlanSpec"] = reflect.TypeOf((*VmwareDistributedVirtualSwitchVlanSpec)(nil)).Elem()
  3495  }
  3496  
  3497  func (b *VsanDiskFault) GetVsanDiskFault() *VsanDiskFault { return b }
  3498  
  3499  type BaseVsanDiskFault interface {
  3500  	GetVsanDiskFault() *VsanDiskFault
  3501  }
  3502  
  3503  func init() {
  3504  	t["BaseVsanDiskFault"] = reflect.TypeOf((*VsanDiskFault)(nil)).Elem()
  3505  }
  3506  
  3507  func (b *VsanFault) GetVsanFault() *VsanFault { return b }
  3508  
  3509  type BaseVsanFault interface {
  3510  	GetVsanFault() *VsanFault
  3511  }
  3512  
  3513  func init() {
  3514  	t["BaseVsanFault"] = reflect.TypeOf((*VsanFault)(nil)).Elem()
  3515  }
  3516  
  3517  func (b *VsanUpgradeSystemPreflightCheckIssue) GetVsanUpgradeSystemPreflightCheckIssue() *VsanUpgradeSystemPreflightCheckIssue {
  3518  	return b
  3519  }
  3520  
  3521  type BaseVsanUpgradeSystemPreflightCheckIssue interface {
  3522  	GetVsanUpgradeSystemPreflightCheckIssue() *VsanUpgradeSystemPreflightCheckIssue
  3523  }
  3524  
  3525  func init() {
  3526  	t["BaseVsanUpgradeSystemPreflightCheckIssue"] = reflect.TypeOf((*VsanUpgradeSystemPreflightCheckIssue)(nil)).Elem()
  3527  }
  3528  
  3529  func (b *VsanUpgradeSystemUpgradeHistoryItem) GetVsanUpgradeSystemUpgradeHistoryItem() *VsanUpgradeSystemUpgradeHistoryItem {
  3530  	return b
  3531  }
  3532  
  3533  type BaseVsanUpgradeSystemUpgradeHistoryItem interface {
  3534  	GetVsanUpgradeSystemUpgradeHistoryItem() *VsanUpgradeSystemUpgradeHistoryItem
  3535  }
  3536  
  3537  func init() {
  3538  	t["BaseVsanUpgradeSystemUpgradeHistoryItem"] = reflect.TypeOf((*VsanUpgradeSystemUpgradeHistoryItem)(nil)).Elem()
  3539  }
  3540  
  3541  func (b *VslmCreateSpecBackingSpec) GetVslmCreateSpecBackingSpec() *VslmCreateSpecBackingSpec {
  3542  	return b
  3543  }
  3544  
  3545  type BaseVslmCreateSpecBackingSpec interface {
  3546  	GetVslmCreateSpecBackingSpec() *VslmCreateSpecBackingSpec
  3547  }
  3548  
  3549  func init() {
  3550  	t["BaseVslmCreateSpecBackingSpec"] = reflect.TypeOf((*VslmCreateSpecBackingSpec)(nil)).Elem()
  3551  }
  3552  
  3553  func (b *VslmMigrateSpec) GetVslmMigrateSpec() *VslmMigrateSpec { return b }
  3554  
  3555  type BaseVslmMigrateSpec interface {
  3556  	GetVslmMigrateSpec() *VslmMigrateSpec
  3557  }
  3558  
  3559  func init() {
  3560  	t["BaseVslmMigrateSpec"] = reflect.TypeOf((*VslmMigrateSpec)(nil)).Elem()
  3561  }