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