1/* 2Copyright (c) 2014-2018 VMware, Inc. All Rights Reserved. 3 4Licensed under the Apache License, Version 2.0 (the "License"); 5you may not use this file except in compliance with the License. 6You may obtain a copy of the License at 7 8 http://www.apache.org/licenses/LICENSE-2.0 9 10Unless required by applicable law or agreed to in writing, software 11distributed under the License is distributed on an "AS IS" BASIS, 12WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13See the License for the specific language governing permissions and 14limitations under the License. 15*/ 16 17package methods 18 19import ( 20 "context" 21 22 "github.com/vmware/govmomi/vim25/soap" 23 "github.com/vmware/govmomi/vim25/types" 24) 25 26type AbdicateDomOwnershipBody struct { 27 Req *types.AbdicateDomOwnership `xml:"urn:vim25 AbdicateDomOwnership,omitempty"` 28 Res *types.AbdicateDomOwnershipResponse `xml:"urn:vim25 AbdicateDomOwnershipResponse,omitempty"` 29 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 30} 31 32func (b *AbdicateDomOwnershipBody) Fault() *soap.Fault { return b.Fault_ } 33 34func AbdicateDomOwnership(ctx context.Context, r soap.RoundTripper, req *types.AbdicateDomOwnership) (*types.AbdicateDomOwnershipResponse, error) { 35 var reqBody, resBody AbdicateDomOwnershipBody 36 37 reqBody.Req = req 38 39 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 40 return nil, err 41 } 42 43 return resBody.Res, nil 44} 45 46type AcknowledgeAlarmBody struct { 47 Req *types.AcknowledgeAlarm `xml:"urn:vim25 AcknowledgeAlarm,omitempty"` 48 Res *types.AcknowledgeAlarmResponse `xml:"urn:vim25 AcknowledgeAlarmResponse,omitempty"` 49 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 50} 51 52func (b *AcknowledgeAlarmBody) Fault() *soap.Fault { return b.Fault_ } 53 54func AcknowledgeAlarm(ctx context.Context, r soap.RoundTripper, req *types.AcknowledgeAlarm) (*types.AcknowledgeAlarmResponse, error) { 55 var reqBody, resBody AcknowledgeAlarmBody 56 57 reqBody.Req = req 58 59 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 60 return nil, err 61 } 62 63 return resBody.Res, nil 64} 65 66type AcquireCimServicesTicketBody struct { 67 Req *types.AcquireCimServicesTicket `xml:"urn:vim25 AcquireCimServicesTicket,omitempty"` 68 Res *types.AcquireCimServicesTicketResponse `xml:"urn:vim25 AcquireCimServicesTicketResponse,omitempty"` 69 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 70} 71 72func (b *AcquireCimServicesTicketBody) Fault() *soap.Fault { return b.Fault_ } 73 74func AcquireCimServicesTicket(ctx context.Context, r soap.RoundTripper, req *types.AcquireCimServicesTicket) (*types.AcquireCimServicesTicketResponse, error) { 75 var reqBody, resBody AcquireCimServicesTicketBody 76 77 reqBody.Req = req 78 79 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 80 return nil, err 81 } 82 83 return resBody.Res, nil 84} 85 86type AcquireCloneTicketBody struct { 87 Req *types.AcquireCloneTicket `xml:"urn:vim25 AcquireCloneTicket,omitempty"` 88 Res *types.AcquireCloneTicketResponse `xml:"urn:vim25 AcquireCloneTicketResponse,omitempty"` 89 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 90} 91 92func (b *AcquireCloneTicketBody) Fault() *soap.Fault { return b.Fault_ } 93 94func AcquireCloneTicket(ctx context.Context, r soap.RoundTripper, req *types.AcquireCloneTicket) (*types.AcquireCloneTicketResponse, error) { 95 var reqBody, resBody AcquireCloneTicketBody 96 97 reqBody.Req = req 98 99 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 100 return nil, err 101 } 102 103 return resBody.Res, nil 104} 105 106type AcquireCredentialsInGuestBody struct { 107 Req *types.AcquireCredentialsInGuest `xml:"urn:vim25 AcquireCredentialsInGuest,omitempty"` 108 Res *types.AcquireCredentialsInGuestResponse `xml:"urn:vim25 AcquireCredentialsInGuestResponse,omitempty"` 109 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 110} 111 112func (b *AcquireCredentialsInGuestBody) Fault() *soap.Fault { return b.Fault_ } 113 114func AcquireCredentialsInGuest(ctx context.Context, r soap.RoundTripper, req *types.AcquireCredentialsInGuest) (*types.AcquireCredentialsInGuestResponse, error) { 115 var reqBody, resBody AcquireCredentialsInGuestBody 116 117 reqBody.Req = req 118 119 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 120 return nil, err 121 } 122 123 return resBody.Res, nil 124} 125 126type AcquireGenericServiceTicketBody struct { 127 Req *types.AcquireGenericServiceTicket `xml:"urn:vim25 AcquireGenericServiceTicket,omitempty"` 128 Res *types.AcquireGenericServiceTicketResponse `xml:"urn:vim25 AcquireGenericServiceTicketResponse,omitempty"` 129 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 130} 131 132func (b *AcquireGenericServiceTicketBody) Fault() *soap.Fault { return b.Fault_ } 133 134func AcquireGenericServiceTicket(ctx context.Context, r soap.RoundTripper, req *types.AcquireGenericServiceTicket) (*types.AcquireGenericServiceTicketResponse, error) { 135 var reqBody, resBody AcquireGenericServiceTicketBody 136 137 reqBody.Req = req 138 139 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 140 return nil, err 141 } 142 143 return resBody.Res, nil 144} 145 146type AcquireLocalTicketBody struct { 147 Req *types.AcquireLocalTicket `xml:"urn:vim25 AcquireLocalTicket,omitempty"` 148 Res *types.AcquireLocalTicketResponse `xml:"urn:vim25 AcquireLocalTicketResponse,omitempty"` 149 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 150} 151 152func (b *AcquireLocalTicketBody) Fault() *soap.Fault { return b.Fault_ } 153 154func AcquireLocalTicket(ctx context.Context, r soap.RoundTripper, req *types.AcquireLocalTicket) (*types.AcquireLocalTicketResponse, error) { 155 var reqBody, resBody AcquireLocalTicketBody 156 157 reqBody.Req = req 158 159 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 160 return nil, err 161 } 162 163 return resBody.Res, nil 164} 165 166type AcquireMksTicketBody struct { 167 Req *types.AcquireMksTicket `xml:"urn:vim25 AcquireMksTicket,omitempty"` 168 Res *types.AcquireMksTicketResponse `xml:"urn:vim25 AcquireMksTicketResponse,omitempty"` 169 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 170} 171 172func (b *AcquireMksTicketBody) Fault() *soap.Fault { return b.Fault_ } 173 174func AcquireMksTicket(ctx context.Context, r soap.RoundTripper, req *types.AcquireMksTicket) (*types.AcquireMksTicketResponse, error) { 175 var reqBody, resBody AcquireMksTicketBody 176 177 reqBody.Req = req 178 179 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 180 return nil, err 181 } 182 183 return resBody.Res, nil 184} 185 186type AcquireTicketBody struct { 187 Req *types.AcquireTicket `xml:"urn:vim25 AcquireTicket,omitempty"` 188 Res *types.AcquireTicketResponse `xml:"urn:vim25 AcquireTicketResponse,omitempty"` 189 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 190} 191 192func (b *AcquireTicketBody) Fault() *soap.Fault { return b.Fault_ } 193 194func AcquireTicket(ctx context.Context, r soap.RoundTripper, req *types.AcquireTicket) (*types.AcquireTicketResponse, error) { 195 var reqBody, resBody AcquireTicketBody 196 197 reqBody.Req = req 198 199 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 200 return nil, err 201 } 202 203 return resBody.Res, nil 204} 205 206type AddAuthorizationRoleBody struct { 207 Req *types.AddAuthorizationRole `xml:"urn:vim25 AddAuthorizationRole,omitempty"` 208 Res *types.AddAuthorizationRoleResponse `xml:"urn:vim25 AddAuthorizationRoleResponse,omitempty"` 209 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 210} 211 212func (b *AddAuthorizationRoleBody) Fault() *soap.Fault { return b.Fault_ } 213 214func AddAuthorizationRole(ctx context.Context, r soap.RoundTripper, req *types.AddAuthorizationRole) (*types.AddAuthorizationRoleResponse, error) { 215 var reqBody, resBody AddAuthorizationRoleBody 216 217 reqBody.Req = req 218 219 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 220 return nil, err 221 } 222 223 return resBody.Res, nil 224} 225 226type AddCustomFieldDefBody struct { 227 Req *types.AddCustomFieldDef `xml:"urn:vim25 AddCustomFieldDef,omitempty"` 228 Res *types.AddCustomFieldDefResponse `xml:"urn:vim25 AddCustomFieldDefResponse,omitempty"` 229 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 230} 231 232func (b *AddCustomFieldDefBody) Fault() *soap.Fault { return b.Fault_ } 233 234func AddCustomFieldDef(ctx context.Context, r soap.RoundTripper, req *types.AddCustomFieldDef) (*types.AddCustomFieldDefResponse, error) { 235 var reqBody, resBody AddCustomFieldDefBody 236 237 reqBody.Req = req 238 239 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 240 return nil, err 241 } 242 243 return resBody.Res, nil 244} 245 246type AddDVPortgroup_TaskBody struct { 247 Req *types.AddDVPortgroup_Task `xml:"urn:vim25 AddDVPortgroup_Task,omitempty"` 248 Res *types.AddDVPortgroup_TaskResponse `xml:"urn:vim25 AddDVPortgroup_TaskResponse,omitempty"` 249 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 250} 251 252func (b *AddDVPortgroup_TaskBody) Fault() *soap.Fault { return b.Fault_ } 253 254func AddDVPortgroup_Task(ctx context.Context, r soap.RoundTripper, req *types.AddDVPortgroup_Task) (*types.AddDVPortgroup_TaskResponse, error) { 255 var reqBody, resBody AddDVPortgroup_TaskBody 256 257 reqBody.Req = req 258 259 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 260 return nil, err 261 } 262 263 return resBody.Res, nil 264} 265 266type AddDisks_TaskBody struct { 267 Req *types.AddDisks_Task `xml:"urn:vim25 AddDisks_Task,omitempty"` 268 Res *types.AddDisks_TaskResponse `xml:"urn:vim25 AddDisks_TaskResponse,omitempty"` 269 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 270} 271 272func (b *AddDisks_TaskBody) Fault() *soap.Fault { return b.Fault_ } 273 274func AddDisks_Task(ctx context.Context, r soap.RoundTripper, req *types.AddDisks_Task) (*types.AddDisks_TaskResponse, error) { 275 var reqBody, resBody AddDisks_TaskBody 276 277 reqBody.Req = req 278 279 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 280 return nil, err 281 } 282 283 return resBody.Res, nil 284} 285 286type AddFilterBody struct { 287 Req *types.AddFilter `xml:"urn:vim25 AddFilter,omitempty"` 288 Res *types.AddFilterResponse `xml:"urn:vim25 AddFilterResponse,omitempty"` 289 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 290} 291 292func (b *AddFilterBody) Fault() *soap.Fault { return b.Fault_ } 293 294func AddFilter(ctx context.Context, r soap.RoundTripper, req *types.AddFilter) (*types.AddFilterResponse, error) { 295 var reqBody, resBody AddFilterBody 296 297 reqBody.Req = req 298 299 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 300 return nil, err 301 } 302 303 return resBody.Res, nil 304} 305 306type AddFilterEntitiesBody struct { 307 Req *types.AddFilterEntities `xml:"urn:vim25 AddFilterEntities,omitempty"` 308 Res *types.AddFilterEntitiesResponse `xml:"urn:vim25 AddFilterEntitiesResponse,omitempty"` 309 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 310} 311 312func (b *AddFilterEntitiesBody) Fault() *soap.Fault { return b.Fault_ } 313 314func AddFilterEntities(ctx context.Context, r soap.RoundTripper, req *types.AddFilterEntities) (*types.AddFilterEntitiesResponse, error) { 315 var reqBody, resBody AddFilterEntitiesBody 316 317 reqBody.Req = req 318 319 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 320 return nil, err 321 } 322 323 return resBody.Res, nil 324} 325 326type AddGuestAliasBody struct { 327 Req *types.AddGuestAlias `xml:"urn:vim25 AddGuestAlias,omitempty"` 328 Res *types.AddGuestAliasResponse `xml:"urn:vim25 AddGuestAliasResponse,omitempty"` 329 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 330} 331 332func (b *AddGuestAliasBody) Fault() *soap.Fault { return b.Fault_ } 333 334func AddGuestAlias(ctx context.Context, r soap.RoundTripper, req *types.AddGuestAlias) (*types.AddGuestAliasResponse, error) { 335 var reqBody, resBody AddGuestAliasBody 336 337 reqBody.Req = req 338 339 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 340 return nil, err 341 } 342 343 return resBody.Res, nil 344} 345 346type AddHost_TaskBody struct { 347 Req *types.AddHost_Task `xml:"urn:vim25 AddHost_Task,omitempty"` 348 Res *types.AddHost_TaskResponse `xml:"urn:vim25 AddHost_TaskResponse,omitempty"` 349 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 350} 351 352func (b *AddHost_TaskBody) Fault() *soap.Fault { return b.Fault_ } 353 354func AddHost_Task(ctx context.Context, r soap.RoundTripper, req *types.AddHost_Task) (*types.AddHost_TaskResponse, error) { 355 var reqBody, resBody AddHost_TaskBody 356 357 reqBody.Req = req 358 359 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 360 return nil, err 361 } 362 363 return resBody.Res, nil 364} 365 366type AddInternetScsiSendTargetsBody struct { 367 Req *types.AddInternetScsiSendTargets `xml:"urn:vim25 AddInternetScsiSendTargets,omitempty"` 368 Res *types.AddInternetScsiSendTargetsResponse `xml:"urn:vim25 AddInternetScsiSendTargetsResponse,omitempty"` 369 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 370} 371 372func (b *AddInternetScsiSendTargetsBody) Fault() *soap.Fault { return b.Fault_ } 373 374func AddInternetScsiSendTargets(ctx context.Context, r soap.RoundTripper, req *types.AddInternetScsiSendTargets) (*types.AddInternetScsiSendTargetsResponse, error) { 375 var reqBody, resBody AddInternetScsiSendTargetsBody 376 377 reqBody.Req = req 378 379 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 380 return nil, err 381 } 382 383 return resBody.Res, nil 384} 385 386type AddInternetScsiStaticTargetsBody struct { 387 Req *types.AddInternetScsiStaticTargets `xml:"urn:vim25 AddInternetScsiStaticTargets,omitempty"` 388 Res *types.AddInternetScsiStaticTargetsResponse `xml:"urn:vim25 AddInternetScsiStaticTargetsResponse,omitempty"` 389 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 390} 391 392func (b *AddInternetScsiStaticTargetsBody) Fault() *soap.Fault { return b.Fault_ } 393 394func AddInternetScsiStaticTargets(ctx context.Context, r soap.RoundTripper, req *types.AddInternetScsiStaticTargets) (*types.AddInternetScsiStaticTargetsResponse, error) { 395 var reqBody, resBody AddInternetScsiStaticTargetsBody 396 397 reqBody.Req = req 398 399 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 400 return nil, err 401 } 402 403 return resBody.Res, nil 404} 405 406type AddKeyBody struct { 407 Req *types.AddKey `xml:"urn:vim25 AddKey,omitempty"` 408 Res *types.AddKeyResponse `xml:"urn:vim25 AddKeyResponse,omitempty"` 409 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 410} 411 412func (b *AddKeyBody) Fault() *soap.Fault { return b.Fault_ } 413 414func AddKey(ctx context.Context, r soap.RoundTripper, req *types.AddKey) (*types.AddKeyResponse, error) { 415 var reqBody, resBody AddKeyBody 416 417 reqBody.Req = req 418 419 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 420 return nil, err 421 } 422 423 return resBody.Res, nil 424} 425 426type AddKeysBody struct { 427 Req *types.AddKeys `xml:"urn:vim25 AddKeys,omitempty"` 428 Res *types.AddKeysResponse `xml:"urn:vim25 AddKeysResponse,omitempty"` 429 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 430} 431 432func (b *AddKeysBody) Fault() *soap.Fault { return b.Fault_ } 433 434func AddKeys(ctx context.Context, r soap.RoundTripper, req *types.AddKeys) (*types.AddKeysResponse, error) { 435 var reqBody, resBody AddKeysBody 436 437 reqBody.Req = req 438 439 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 440 return nil, err 441 } 442 443 return resBody.Res, nil 444} 445 446type AddLicenseBody struct { 447 Req *types.AddLicense `xml:"urn:vim25 AddLicense,omitempty"` 448 Res *types.AddLicenseResponse `xml:"urn:vim25 AddLicenseResponse,omitempty"` 449 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 450} 451 452func (b *AddLicenseBody) Fault() *soap.Fault { return b.Fault_ } 453 454func AddLicense(ctx context.Context, r soap.RoundTripper, req *types.AddLicense) (*types.AddLicenseResponse, error) { 455 var reqBody, resBody AddLicenseBody 456 457 reqBody.Req = req 458 459 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 460 return nil, err 461 } 462 463 return resBody.Res, nil 464} 465 466type AddMonitoredEntitiesBody struct { 467 Req *types.AddMonitoredEntities `xml:"urn:vim25 AddMonitoredEntities,omitempty"` 468 Res *types.AddMonitoredEntitiesResponse `xml:"urn:vim25 AddMonitoredEntitiesResponse,omitempty"` 469 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 470} 471 472func (b *AddMonitoredEntitiesBody) Fault() *soap.Fault { return b.Fault_ } 473 474func AddMonitoredEntities(ctx context.Context, r soap.RoundTripper, req *types.AddMonitoredEntities) (*types.AddMonitoredEntitiesResponse, error) { 475 var reqBody, resBody AddMonitoredEntitiesBody 476 477 reqBody.Req = req 478 479 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 480 return nil, err 481 } 482 483 return resBody.Res, nil 484} 485 486type AddNetworkResourcePoolBody struct { 487 Req *types.AddNetworkResourcePool `xml:"urn:vim25 AddNetworkResourcePool,omitempty"` 488 Res *types.AddNetworkResourcePoolResponse `xml:"urn:vim25 AddNetworkResourcePoolResponse,omitempty"` 489 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 490} 491 492func (b *AddNetworkResourcePoolBody) Fault() *soap.Fault { return b.Fault_ } 493 494func AddNetworkResourcePool(ctx context.Context, r soap.RoundTripper, req *types.AddNetworkResourcePool) (*types.AddNetworkResourcePoolResponse, error) { 495 var reqBody, resBody AddNetworkResourcePoolBody 496 497 reqBody.Req = req 498 499 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 500 return nil, err 501 } 502 503 return resBody.Res, nil 504} 505 506type AddPortGroupBody struct { 507 Req *types.AddPortGroup `xml:"urn:vim25 AddPortGroup,omitempty"` 508 Res *types.AddPortGroupResponse `xml:"urn:vim25 AddPortGroupResponse,omitempty"` 509 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 510} 511 512func (b *AddPortGroupBody) Fault() *soap.Fault { return b.Fault_ } 513 514func AddPortGroup(ctx context.Context, r soap.RoundTripper, req *types.AddPortGroup) (*types.AddPortGroupResponse, error) { 515 var reqBody, resBody AddPortGroupBody 516 517 reqBody.Req = req 518 519 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 520 return nil, err 521 } 522 523 return resBody.Res, nil 524} 525 526type AddServiceConsoleVirtualNicBody struct { 527 Req *types.AddServiceConsoleVirtualNic `xml:"urn:vim25 AddServiceConsoleVirtualNic,omitempty"` 528 Res *types.AddServiceConsoleVirtualNicResponse `xml:"urn:vim25 AddServiceConsoleVirtualNicResponse,omitempty"` 529 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 530} 531 532func (b *AddServiceConsoleVirtualNicBody) Fault() *soap.Fault { return b.Fault_ } 533 534func AddServiceConsoleVirtualNic(ctx context.Context, r soap.RoundTripper, req *types.AddServiceConsoleVirtualNic) (*types.AddServiceConsoleVirtualNicResponse, error) { 535 var reqBody, resBody AddServiceConsoleVirtualNicBody 536 537 reqBody.Req = req 538 539 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 540 return nil, err 541 } 542 543 return resBody.Res, nil 544} 545 546type AddStandaloneHost_TaskBody struct { 547 Req *types.AddStandaloneHost_Task `xml:"urn:vim25 AddStandaloneHost_Task,omitempty"` 548 Res *types.AddStandaloneHost_TaskResponse `xml:"urn:vim25 AddStandaloneHost_TaskResponse,omitempty"` 549 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 550} 551 552func (b *AddStandaloneHost_TaskBody) Fault() *soap.Fault { return b.Fault_ } 553 554func AddStandaloneHost_Task(ctx context.Context, r soap.RoundTripper, req *types.AddStandaloneHost_Task) (*types.AddStandaloneHost_TaskResponse, error) { 555 var reqBody, resBody AddStandaloneHost_TaskBody 556 557 reqBody.Req = req 558 559 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 560 return nil, err 561 } 562 563 return resBody.Res, nil 564} 565 566type AddVirtualNicBody struct { 567 Req *types.AddVirtualNic `xml:"urn:vim25 AddVirtualNic,omitempty"` 568 Res *types.AddVirtualNicResponse `xml:"urn:vim25 AddVirtualNicResponse,omitempty"` 569 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 570} 571 572func (b *AddVirtualNicBody) Fault() *soap.Fault { return b.Fault_ } 573 574func AddVirtualNic(ctx context.Context, r soap.RoundTripper, req *types.AddVirtualNic) (*types.AddVirtualNicResponse, error) { 575 var reqBody, resBody AddVirtualNicBody 576 577 reqBody.Req = req 578 579 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 580 return nil, err 581 } 582 583 return resBody.Res, nil 584} 585 586type AddVirtualSwitchBody struct { 587 Req *types.AddVirtualSwitch `xml:"urn:vim25 AddVirtualSwitch,omitempty"` 588 Res *types.AddVirtualSwitchResponse `xml:"urn:vim25 AddVirtualSwitchResponse,omitempty"` 589 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 590} 591 592func (b *AddVirtualSwitchBody) Fault() *soap.Fault { return b.Fault_ } 593 594func AddVirtualSwitch(ctx context.Context, r soap.RoundTripper, req *types.AddVirtualSwitch) (*types.AddVirtualSwitchResponse, error) { 595 var reqBody, resBody AddVirtualSwitchBody 596 597 reqBody.Req = req 598 599 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 600 return nil, err 601 } 602 603 return resBody.Res, nil 604} 605 606type AllocateIpv4AddressBody struct { 607 Req *types.AllocateIpv4Address `xml:"urn:vim25 AllocateIpv4Address,omitempty"` 608 Res *types.AllocateIpv4AddressResponse `xml:"urn:vim25 AllocateIpv4AddressResponse,omitempty"` 609 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 610} 611 612func (b *AllocateIpv4AddressBody) Fault() *soap.Fault { return b.Fault_ } 613 614func AllocateIpv4Address(ctx context.Context, r soap.RoundTripper, req *types.AllocateIpv4Address) (*types.AllocateIpv4AddressResponse, error) { 615 var reqBody, resBody AllocateIpv4AddressBody 616 617 reqBody.Req = req 618 619 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 620 return nil, err 621 } 622 623 return resBody.Res, nil 624} 625 626type AllocateIpv6AddressBody struct { 627 Req *types.AllocateIpv6Address `xml:"urn:vim25 AllocateIpv6Address,omitempty"` 628 Res *types.AllocateIpv6AddressResponse `xml:"urn:vim25 AllocateIpv6AddressResponse,omitempty"` 629 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 630} 631 632func (b *AllocateIpv6AddressBody) Fault() *soap.Fault { return b.Fault_ } 633 634func AllocateIpv6Address(ctx context.Context, r soap.RoundTripper, req *types.AllocateIpv6Address) (*types.AllocateIpv6AddressResponse, error) { 635 var reqBody, resBody AllocateIpv6AddressBody 636 637 reqBody.Req = req 638 639 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 640 return nil, err 641 } 642 643 return resBody.Res, nil 644} 645 646type AnswerVMBody struct { 647 Req *types.AnswerVM `xml:"urn:vim25 AnswerVM,omitempty"` 648 Res *types.AnswerVMResponse `xml:"urn:vim25 AnswerVMResponse,omitempty"` 649 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 650} 651 652func (b *AnswerVMBody) Fault() *soap.Fault { return b.Fault_ } 653 654func AnswerVM(ctx context.Context, r soap.RoundTripper, req *types.AnswerVM) (*types.AnswerVMResponse, error) { 655 var reqBody, resBody AnswerVMBody 656 657 reqBody.Req = req 658 659 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 660 return nil, err 661 } 662 663 return resBody.Res, nil 664} 665 666type ApplyEntitiesConfig_TaskBody struct { 667 Req *types.ApplyEntitiesConfig_Task `xml:"urn:vim25 ApplyEntitiesConfig_Task,omitempty"` 668 Res *types.ApplyEntitiesConfig_TaskResponse `xml:"urn:vim25 ApplyEntitiesConfig_TaskResponse,omitempty"` 669 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 670} 671 672func (b *ApplyEntitiesConfig_TaskBody) Fault() *soap.Fault { return b.Fault_ } 673 674func ApplyEntitiesConfig_Task(ctx context.Context, r soap.RoundTripper, req *types.ApplyEntitiesConfig_Task) (*types.ApplyEntitiesConfig_TaskResponse, error) { 675 var reqBody, resBody ApplyEntitiesConfig_TaskBody 676 677 reqBody.Req = req 678 679 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 680 return nil, err 681 } 682 683 return resBody.Res, nil 684} 685 686type ApplyEvcModeVM_TaskBody struct { 687 Req *types.ApplyEvcModeVM_Task `xml:"urn:vim25 ApplyEvcModeVM_Task,omitempty"` 688 Res *types.ApplyEvcModeVM_TaskResponse `xml:"urn:vim25 ApplyEvcModeVM_TaskResponse,omitempty"` 689 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 690} 691 692func (b *ApplyEvcModeVM_TaskBody) Fault() *soap.Fault { return b.Fault_ } 693 694func ApplyEvcModeVM_Task(ctx context.Context, r soap.RoundTripper, req *types.ApplyEvcModeVM_Task) (*types.ApplyEvcModeVM_TaskResponse, error) { 695 var reqBody, resBody ApplyEvcModeVM_TaskBody 696 697 reqBody.Req = req 698 699 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 700 return nil, err 701 } 702 703 return resBody.Res, nil 704} 705 706type ApplyHostConfig_TaskBody struct { 707 Req *types.ApplyHostConfig_Task `xml:"urn:vim25 ApplyHostConfig_Task,omitempty"` 708 Res *types.ApplyHostConfig_TaskResponse `xml:"urn:vim25 ApplyHostConfig_TaskResponse,omitempty"` 709 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 710} 711 712func (b *ApplyHostConfig_TaskBody) Fault() *soap.Fault { return b.Fault_ } 713 714func ApplyHostConfig_Task(ctx context.Context, r soap.RoundTripper, req *types.ApplyHostConfig_Task) (*types.ApplyHostConfig_TaskResponse, error) { 715 var reqBody, resBody ApplyHostConfig_TaskBody 716 717 reqBody.Req = req 718 719 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 720 return nil, err 721 } 722 723 return resBody.Res, nil 724} 725 726type ApplyRecommendationBody struct { 727 Req *types.ApplyRecommendation `xml:"urn:vim25 ApplyRecommendation,omitempty"` 728 Res *types.ApplyRecommendationResponse `xml:"urn:vim25 ApplyRecommendationResponse,omitempty"` 729 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 730} 731 732func (b *ApplyRecommendationBody) Fault() *soap.Fault { return b.Fault_ } 733 734func ApplyRecommendation(ctx context.Context, r soap.RoundTripper, req *types.ApplyRecommendation) (*types.ApplyRecommendationResponse, error) { 735 var reqBody, resBody ApplyRecommendationBody 736 737 reqBody.Req = req 738 739 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 740 return nil, err 741 } 742 743 return resBody.Res, nil 744} 745 746type ApplyStorageDrsRecommendationToPod_TaskBody struct { 747 Req *types.ApplyStorageDrsRecommendationToPod_Task `xml:"urn:vim25 ApplyStorageDrsRecommendationToPod_Task,omitempty"` 748 Res *types.ApplyStorageDrsRecommendationToPod_TaskResponse `xml:"urn:vim25 ApplyStorageDrsRecommendationToPod_TaskResponse,omitempty"` 749 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 750} 751 752func (b *ApplyStorageDrsRecommendationToPod_TaskBody) Fault() *soap.Fault { return b.Fault_ } 753 754func ApplyStorageDrsRecommendationToPod_Task(ctx context.Context, r soap.RoundTripper, req *types.ApplyStorageDrsRecommendationToPod_Task) (*types.ApplyStorageDrsRecommendationToPod_TaskResponse, error) { 755 var reqBody, resBody ApplyStorageDrsRecommendationToPod_TaskBody 756 757 reqBody.Req = req 758 759 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 760 return nil, err 761 } 762 763 return resBody.Res, nil 764} 765 766type ApplyStorageDrsRecommendation_TaskBody struct { 767 Req *types.ApplyStorageDrsRecommendation_Task `xml:"urn:vim25 ApplyStorageDrsRecommendation_Task,omitempty"` 768 Res *types.ApplyStorageDrsRecommendation_TaskResponse `xml:"urn:vim25 ApplyStorageDrsRecommendation_TaskResponse,omitempty"` 769 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 770} 771 772func (b *ApplyStorageDrsRecommendation_TaskBody) Fault() *soap.Fault { return b.Fault_ } 773 774func ApplyStorageDrsRecommendation_Task(ctx context.Context, r soap.RoundTripper, req *types.ApplyStorageDrsRecommendation_Task) (*types.ApplyStorageDrsRecommendation_TaskResponse, error) { 775 var reqBody, resBody ApplyStorageDrsRecommendation_TaskBody 776 777 reqBody.Req = req 778 779 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 780 return nil, err 781 } 782 783 return resBody.Res, nil 784} 785 786type AreAlarmActionsEnabledBody struct { 787 Req *types.AreAlarmActionsEnabled `xml:"urn:vim25 AreAlarmActionsEnabled,omitempty"` 788 Res *types.AreAlarmActionsEnabledResponse `xml:"urn:vim25 AreAlarmActionsEnabledResponse,omitempty"` 789 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 790} 791 792func (b *AreAlarmActionsEnabledBody) Fault() *soap.Fault { return b.Fault_ } 793 794func AreAlarmActionsEnabled(ctx context.Context, r soap.RoundTripper, req *types.AreAlarmActionsEnabled) (*types.AreAlarmActionsEnabledResponse, error) { 795 var reqBody, resBody AreAlarmActionsEnabledBody 796 797 reqBody.Req = req 798 799 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 800 return nil, err 801 } 802 803 return resBody.Res, nil 804} 805 806type AssignUserToGroupBody struct { 807 Req *types.AssignUserToGroup `xml:"urn:vim25 AssignUserToGroup,omitempty"` 808 Res *types.AssignUserToGroupResponse `xml:"urn:vim25 AssignUserToGroupResponse,omitempty"` 809 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 810} 811 812func (b *AssignUserToGroupBody) Fault() *soap.Fault { return b.Fault_ } 813 814func AssignUserToGroup(ctx context.Context, r soap.RoundTripper, req *types.AssignUserToGroup) (*types.AssignUserToGroupResponse, error) { 815 var reqBody, resBody AssignUserToGroupBody 816 817 reqBody.Req = req 818 819 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 820 return nil, err 821 } 822 823 return resBody.Res, nil 824} 825 826type AssociateProfileBody struct { 827 Req *types.AssociateProfile `xml:"urn:vim25 AssociateProfile,omitempty"` 828 Res *types.AssociateProfileResponse `xml:"urn:vim25 AssociateProfileResponse,omitempty"` 829 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 830} 831 832func (b *AssociateProfileBody) Fault() *soap.Fault { return b.Fault_ } 833 834func AssociateProfile(ctx context.Context, r soap.RoundTripper, req *types.AssociateProfile) (*types.AssociateProfileResponse, error) { 835 var reqBody, resBody AssociateProfileBody 836 837 reqBody.Req = req 838 839 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 840 return nil, err 841 } 842 843 return resBody.Res, nil 844} 845 846type AttachDisk_TaskBody struct { 847 Req *types.AttachDisk_Task `xml:"urn:vim25 AttachDisk_Task,omitempty"` 848 Res *types.AttachDisk_TaskResponse `xml:"urn:vim25 AttachDisk_TaskResponse,omitempty"` 849 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 850} 851 852func (b *AttachDisk_TaskBody) Fault() *soap.Fault { return b.Fault_ } 853 854func AttachDisk_Task(ctx context.Context, r soap.RoundTripper, req *types.AttachDisk_Task) (*types.AttachDisk_TaskResponse, error) { 855 var reqBody, resBody AttachDisk_TaskBody 856 857 reqBody.Req = req 858 859 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 860 return nil, err 861 } 862 863 return resBody.Res, nil 864} 865 866type AttachScsiLunBody struct { 867 Req *types.AttachScsiLun `xml:"urn:vim25 AttachScsiLun,omitempty"` 868 Res *types.AttachScsiLunResponse `xml:"urn:vim25 AttachScsiLunResponse,omitempty"` 869 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 870} 871 872func (b *AttachScsiLunBody) Fault() *soap.Fault { return b.Fault_ } 873 874func AttachScsiLun(ctx context.Context, r soap.RoundTripper, req *types.AttachScsiLun) (*types.AttachScsiLunResponse, error) { 875 var reqBody, resBody AttachScsiLunBody 876 877 reqBody.Req = req 878 879 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 880 return nil, err 881 } 882 883 return resBody.Res, nil 884} 885 886type AttachScsiLunEx_TaskBody struct { 887 Req *types.AttachScsiLunEx_Task `xml:"urn:vim25 AttachScsiLunEx_Task,omitempty"` 888 Res *types.AttachScsiLunEx_TaskResponse `xml:"urn:vim25 AttachScsiLunEx_TaskResponse,omitempty"` 889 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 890} 891 892func (b *AttachScsiLunEx_TaskBody) Fault() *soap.Fault { return b.Fault_ } 893 894func AttachScsiLunEx_Task(ctx context.Context, r soap.RoundTripper, req *types.AttachScsiLunEx_Task) (*types.AttachScsiLunEx_TaskResponse, error) { 895 var reqBody, resBody AttachScsiLunEx_TaskBody 896 897 reqBody.Req = req 898 899 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 900 return nil, err 901 } 902 903 return resBody.Res, nil 904} 905 906type AttachTagToVStorageObjectBody struct { 907 Req *types.AttachTagToVStorageObject `xml:"urn:vim25 AttachTagToVStorageObject,omitempty"` 908 Res *types.AttachTagToVStorageObjectResponse `xml:"urn:vim25 AttachTagToVStorageObjectResponse,omitempty"` 909 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 910} 911 912func (b *AttachTagToVStorageObjectBody) Fault() *soap.Fault { return b.Fault_ } 913 914func AttachTagToVStorageObject(ctx context.Context, r soap.RoundTripper, req *types.AttachTagToVStorageObject) (*types.AttachTagToVStorageObjectResponse, error) { 915 var reqBody, resBody AttachTagToVStorageObjectBody 916 917 reqBody.Req = req 918 919 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 920 return nil, err 921 } 922 923 return resBody.Res, nil 924} 925 926type AttachVmfsExtentBody struct { 927 Req *types.AttachVmfsExtent `xml:"urn:vim25 AttachVmfsExtent,omitempty"` 928 Res *types.AttachVmfsExtentResponse `xml:"urn:vim25 AttachVmfsExtentResponse,omitempty"` 929 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 930} 931 932func (b *AttachVmfsExtentBody) Fault() *soap.Fault { return b.Fault_ } 933 934func AttachVmfsExtent(ctx context.Context, r soap.RoundTripper, req *types.AttachVmfsExtent) (*types.AttachVmfsExtentResponse, error) { 935 var reqBody, resBody AttachVmfsExtentBody 936 937 reqBody.Req = req 938 939 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 940 return nil, err 941 } 942 943 return resBody.Res, nil 944} 945 946type AutoStartPowerOffBody struct { 947 Req *types.AutoStartPowerOff `xml:"urn:vim25 AutoStartPowerOff,omitempty"` 948 Res *types.AutoStartPowerOffResponse `xml:"urn:vim25 AutoStartPowerOffResponse,omitempty"` 949 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 950} 951 952func (b *AutoStartPowerOffBody) Fault() *soap.Fault { return b.Fault_ } 953 954func AutoStartPowerOff(ctx context.Context, r soap.RoundTripper, req *types.AutoStartPowerOff) (*types.AutoStartPowerOffResponse, error) { 955 var reqBody, resBody AutoStartPowerOffBody 956 957 reqBody.Req = req 958 959 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 960 return nil, err 961 } 962 963 return resBody.Res, nil 964} 965 966type AutoStartPowerOnBody struct { 967 Req *types.AutoStartPowerOn `xml:"urn:vim25 AutoStartPowerOn,omitempty"` 968 Res *types.AutoStartPowerOnResponse `xml:"urn:vim25 AutoStartPowerOnResponse,omitempty"` 969 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 970} 971 972func (b *AutoStartPowerOnBody) Fault() *soap.Fault { return b.Fault_ } 973 974func AutoStartPowerOn(ctx context.Context, r soap.RoundTripper, req *types.AutoStartPowerOn) (*types.AutoStartPowerOnResponse, error) { 975 var reqBody, resBody AutoStartPowerOnBody 976 977 reqBody.Req = req 978 979 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 980 return nil, err 981 } 982 983 return resBody.Res, nil 984} 985 986type BackupFirmwareConfigurationBody struct { 987 Req *types.BackupFirmwareConfiguration `xml:"urn:vim25 BackupFirmwareConfiguration,omitempty"` 988 Res *types.BackupFirmwareConfigurationResponse `xml:"urn:vim25 BackupFirmwareConfigurationResponse,omitempty"` 989 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 990} 991 992func (b *BackupFirmwareConfigurationBody) Fault() *soap.Fault { return b.Fault_ } 993 994func BackupFirmwareConfiguration(ctx context.Context, r soap.RoundTripper, req *types.BackupFirmwareConfiguration) (*types.BackupFirmwareConfigurationResponse, error) { 995 var reqBody, resBody BackupFirmwareConfigurationBody 996 997 reqBody.Req = req 998 999 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1000 return nil, err 1001 } 1002 1003 return resBody.Res, nil 1004} 1005 1006type BindVnicBody struct { 1007 Req *types.BindVnic `xml:"urn:vim25 BindVnic,omitempty"` 1008 Res *types.BindVnicResponse `xml:"urn:vim25 BindVnicResponse,omitempty"` 1009 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1010} 1011 1012func (b *BindVnicBody) Fault() *soap.Fault { return b.Fault_ } 1013 1014func BindVnic(ctx context.Context, r soap.RoundTripper, req *types.BindVnic) (*types.BindVnicResponse, error) { 1015 var reqBody, resBody BindVnicBody 1016 1017 reqBody.Req = req 1018 1019 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1020 return nil, err 1021 } 1022 1023 return resBody.Res, nil 1024} 1025 1026type BrowseDiagnosticLogBody struct { 1027 Req *types.BrowseDiagnosticLog `xml:"urn:vim25 BrowseDiagnosticLog,omitempty"` 1028 Res *types.BrowseDiagnosticLogResponse `xml:"urn:vim25 BrowseDiagnosticLogResponse,omitempty"` 1029 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1030} 1031 1032func (b *BrowseDiagnosticLogBody) Fault() *soap.Fault { return b.Fault_ } 1033 1034func BrowseDiagnosticLog(ctx context.Context, r soap.RoundTripper, req *types.BrowseDiagnosticLog) (*types.BrowseDiagnosticLogResponse, error) { 1035 var reqBody, resBody BrowseDiagnosticLogBody 1036 1037 reqBody.Req = req 1038 1039 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1040 return nil, err 1041 } 1042 1043 return resBody.Res, nil 1044} 1045 1046type CanProvisionObjectsBody struct { 1047 Req *types.CanProvisionObjects `xml:"urn:vim25 CanProvisionObjects,omitempty"` 1048 Res *types.CanProvisionObjectsResponse `xml:"urn:vim25 CanProvisionObjectsResponse,omitempty"` 1049 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1050} 1051 1052func (b *CanProvisionObjectsBody) Fault() *soap.Fault { return b.Fault_ } 1053 1054func CanProvisionObjects(ctx context.Context, r soap.RoundTripper, req *types.CanProvisionObjects) (*types.CanProvisionObjectsResponse, error) { 1055 var reqBody, resBody CanProvisionObjectsBody 1056 1057 reqBody.Req = req 1058 1059 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1060 return nil, err 1061 } 1062 1063 return resBody.Res, nil 1064} 1065 1066type CancelRecommendationBody struct { 1067 Req *types.CancelRecommendation `xml:"urn:vim25 CancelRecommendation,omitempty"` 1068 Res *types.CancelRecommendationResponse `xml:"urn:vim25 CancelRecommendationResponse,omitempty"` 1069 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1070} 1071 1072func (b *CancelRecommendationBody) Fault() *soap.Fault { return b.Fault_ } 1073 1074func CancelRecommendation(ctx context.Context, r soap.RoundTripper, req *types.CancelRecommendation) (*types.CancelRecommendationResponse, error) { 1075 var reqBody, resBody CancelRecommendationBody 1076 1077 reqBody.Req = req 1078 1079 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1080 return nil, err 1081 } 1082 1083 return resBody.Res, nil 1084} 1085 1086type CancelRetrievePropertiesExBody struct { 1087 Req *types.CancelRetrievePropertiesEx `xml:"urn:vim25 CancelRetrievePropertiesEx,omitempty"` 1088 Res *types.CancelRetrievePropertiesExResponse `xml:"urn:vim25 CancelRetrievePropertiesExResponse,omitempty"` 1089 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1090} 1091 1092func (b *CancelRetrievePropertiesExBody) Fault() *soap.Fault { return b.Fault_ } 1093 1094func CancelRetrievePropertiesEx(ctx context.Context, r soap.RoundTripper, req *types.CancelRetrievePropertiesEx) (*types.CancelRetrievePropertiesExResponse, error) { 1095 var reqBody, resBody CancelRetrievePropertiesExBody 1096 1097 reqBody.Req = req 1098 1099 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1100 return nil, err 1101 } 1102 1103 return resBody.Res, nil 1104} 1105 1106type CancelStorageDrsRecommendationBody struct { 1107 Req *types.CancelStorageDrsRecommendation `xml:"urn:vim25 CancelStorageDrsRecommendation,omitempty"` 1108 Res *types.CancelStorageDrsRecommendationResponse `xml:"urn:vim25 CancelStorageDrsRecommendationResponse,omitempty"` 1109 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1110} 1111 1112func (b *CancelStorageDrsRecommendationBody) Fault() *soap.Fault { return b.Fault_ } 1113 1114func CancelStorageDrsRecommendation(ctx context.Context, r soap.RoundTripper, req *types.CancelStorageDrsRecommendation) (*types.CancelStorageDrsRecommendationResponse, error) { 1115 var reqBody, resBody CancelStorageDrsRecommendationBody 1116 1117 reqBody.Req = req 1118 1119 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1120 return nil, err 1121 } 1122 1123 return resBody.Res, nil 1124} 1125 1126type CancelTaskBody struct { 1127 Req *types.CancelTask `xml:"urn:vim25 CancelTask,omitempty"` 1128 Res *types.CancelTaskResponse `xml:"urn:vim25 CancelTaskResponse,omitempty"` 1129 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1130} 1131 1132func (b *CancelTaskBody) Fault() *soap.Fault { return b.Fault_ } 1133 1134func CancelTask(ctx context.Context, r soap.RoundTripper, req *types.CancelTask) (*types.CancelTaskResponse, error) { 1135 var reqBody, resBody CancelTaskBody 1136 1137 reqBody.Req = req 1138 1139 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1140 return nil, err 1141 } 1142 1143 return resBody.Res, nil 1144} 1145 1146type CancelWaitForUpdatesBody struct { 1147 Req *types.CancelWaitForUpdates `xml:"urn:vim25 CancelWaitForUpdates,omitempty"` 1148 Res *types.CancelWaitForUpdatesResponse `xml:"urn:vim25 CancelWaitForUpdatesResponse,omitempty"` 1149 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1150} 1151 1152func (b *CancelWaitForUpdatesBody) Fault() *soap.Fault { return b.Fault_ } 1153 1154func CancelWaitForUpdates(ctx context.Context, r soap.RoundTripper, req *types.CancelWaitForUpdates) (*types.CancelWaitForUpdatesResponse, error) { 1155 var reqBody, resBody CancelWaitForUpdatesBody 1156 1157 reqBody.Req = req 1158 1159 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1160 return nil, err 1161 } 1162 1163 return resBody.Res, nil 1164} 1165 1166type CertMgrRefreshCACertificatesAndCRLs_TaskBody struct { 1167 Req *types.CertMgrRefreshCACertificatesAndCRLs_Task `xml:"urn:vim25 CertMgrRefreshCACertificatesAndCRLs_Task,omitempty"` 1168 Res *types.CertMgrRefreshCACertificatesAndCRLs_TaskResponse `xml:"urn:vim25 CertMgrRefreshCACertificatesAndCRLs_TaskResponse,omitempty"` 1169 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1170} 1171 1172func (b *CertMgrRefreshCACertificatesAndCRLs_TaskBody) Fault() *soap.Fault { return b.Fault_ } 1173 1174func CertMgrRefreshCACertificatesAndCRLs_Task(ctx context.Context, r soap.RoundTripper, req *types.CertMgrRefreshCACertificatesAndCRLs_Task) (*types.CertMgrRefreshCACertificatesAndCRLs_TaskResponse, error) { 1175 var reqBody, resBody CertMgrRefreshCACertificatesAndCRLs_TaskBody 1176 1177 reqBody.Req = req 1178 1179 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1180 return nil, err 1181 } 1182 1183 return resBody.Res, nil 1184} 1185 1186type CertMgrRefreshCertificates_TaskBody struct { 1187 Req *types.CertMgrRefreshCertificates_Task `xml:"urn:vim25 CertMgrRefreshCertificates_Task,omitempty"` 1188 Res *types.CertMgrRefreshCertificates_TaskResponse `xml:"urn:vim25 CertMgrRefreshCertificates_TaskResponse,omitempty"` 1189 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1190} 1191 1192func (b *CertMgrRefreshCertificates_TaskBody) Fault() *soap.Fault { return b.Fault_ } 1193 1194func CertMgrRefreshCertificates_Task(ctx context.Context, r soap.RoundTripper, req *types.CertMgrRefreshCertificates_Task) (*types.CertMgrRefreshCertificates_TaskResponse, error) { 1195 var reqBody, resBody CertMgrRefreshCertificates_TaskBody 1196 1197 reqBody.Req = req 1198 1199 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1200 return nil, err 1201 } 1202 1203 return resBody.Res, nil 1204} 1205 1206type CertMgrRevokeCertificates_TaskBody struct { 1207 Req *types.CertMgrRevokeCertificates_Task `xml:"urn:vim25 CertMgrRevokeCertificates_Task,omitempty"` 1208 Res *types.CertMgrRevokeCertificates_TaskResponse `xml:"urn:vim25 CertMgrRevokeCertificates_TaskResponse,omitempty"` 1209 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1210} 1211 1212func (b *CertMgrRevokeCertificates_TaskBody) Fault() *soap.Fault { return b.Fault_ } 1213 1214func CertMgrRevokeCertificates_Task(ctx context.Context, r soap.RoundTripper, req *types.CertMgrRevokeCertificates_Task) (*types.CertMgrRevokeCertificates_TaskResponse, error) { 1215 var reqBody, resBody CertMgrRevokeCertificates_TaskBody 1216 1217 reqBody.Req = req 1218 1219 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1220 return nil, err 1221 } 1222 1223 return resBody.Res, nil 1224} 1225 1226type ChangeAccessModeBody struct { 1227 Req *types.ChangeAccessMode `xml:"urn:vim25 ChangeAccessMode,omitempty"` 1228 Res *types.ChangeAccessModeResponse `xml:"urn:vim25 ChangeAccessModeResponse,omitempty"` 1229 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1230} 1231 1232func (b *ChangeAccessModeBody) Fault() *soap.Fault { return b.Fault_ } 1233 1234func ChangeAccessMode(ctx context.Context, r soap.RoundTripper, req *types.ChangeAccessMode) (*types.ChangeAccessModeResponse, error) { 1235 var reqBody, resBody ChangeAccessModeBody 1236 1237 reqBody.Req = req 1238 1239 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1240 return nil, err 1241 } 1242 1243 return resBody.Res, nil 1244} 1245 1246type ChangeFileAttributesInGuestBody struct { 1247 Req *types.ChangeFileAttributesInGuest `xml:"urn:vim25 ChangeFileAttributesInGuest,omitempty"` 1248 Res *types.ChangeFileAttributesInGuestResponse `xml:"urn:vim25 ChangeFileAttributesInGuestResponse,omitempty"` 1249 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1250} 1251 1252func (b *ChangeFileAttributesInGuestBody) Fault() *soap.Fault { return b.Fault_ } 1253 1254func ChangeFileAttributesInGuest(ctx context.Context, r soap.RoundTripper, req *types.ChangeFileAttributesInGuest) (*types.ChangeFileAttributesInGuestResponse, error) { 1255 var reqBody, resBody ChangeFileAttributesInGuestBody 1256 1257 reqBody.Req = req 1258 1259 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1260 return nil, err 1261 } 1262 1263 return resBody.Res, nil 1264} 1265 1266type ChangeKey_TaskBody struct { 1267 Req *types.ChangeKey_Task `xml:"urn:vim25 ChangeKey_Task,omitempty"` 1268 Res *types.ChangeKey_TaskResponse `xml:"urn:vim25 ChangeKey_TaskResponse,omitempty"` 1269 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1270} 1271 1272func (b *ChangeKey_TaskBody) Fault() *soap.Fault { return b.Fault_ } 1273 1274func ChangeKey_Task(ctx context.Context, r soap.RoundTripper, req *types.ChangeKey_Task) (*types.ChangeKey_TaskResponse, error) { 1275 var reqBody, resBody ChangeKey_TaskBody 1276 1277 reqBody.Req = req 1278 1279 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1280 return nil, err 1281 } 1282 1283 return resBody.Res, nil 1284} 1285 1286type ChangeLockdownModeBody struct { 1287 Req *types.ChangeLockdownMode `xml:"urn:vim25 ChangeLockdownMode,omitempty"` 1288 Res *types.ChangeLockdownModeResponse `xml:"urn:vim25 ChangeLockdownModeResponse,omitempty"` 1289 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1290} 1291 1292func (b *ChangeLockdownModeBody) Fault() *soap.Fault { return b.Fault_ } 1293 1294func ChangeLockdownMode(ctx context.Context, r soap.RoundTripper, req *types.ChangeLockdownMode) (*types.ChangeLockdownModeResponse, error) { 1295 var reqBody, resBody ChangeLockdownModeBody 1296 1297 reqBody.Req = req 1298 1299 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1300 return nil, err 1301 } 1302 1303 return resBody.Res, nil 1304} 1305 1306type ChangeNFSUserPasswordBody struct { 1307 Req *types.ChangeNFSUserPassword `xml:"urn:vim25 ChangeNFSUserPassword,omitempty"` 1308 Res *types.ChangeNFSUserPasswordResponse `xml:"urn:vim25 ChangeNFSUserPasswordResponse,omitempty"` 1309 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1310} 1311 1312func (b *ChangeNFSUserPasswordBody) Fault() *soap.Fault { return b.Fault_ } 1313 1314func ChangeNFSUserPassword(ctx context.Context, r soap.RoundTripper, req *types.ChangeNFSUserPassword) (*types.ChangeNFSUserPasswordResponse, error) { 1315 var reqBody, resBody ChangeNFSUserPasswordBody 1316 1317 reqBody.Req = req 1318 1319 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1320 return nil, err 1321 } 1322 1323 return resBody.Res, nil 1324} 1325 1326type ChangeOwnerBody struct { 1327 Req *types.ChangeOwner `xml:"urn:vim25 ChangeOwner,omitempty"` 1328 Res *types.ChangeOwnerResponse `xml:"urn:vim25 ChangeOwnerResponse,omitempty"` 1329 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1330} 1331 1332func (b *ChangeOwnerBody) Fault() *soap.Fault { return b.Fault_ } 1333 1334func ChangeOwner(ctx context.Context, r soap.RoundTripper, req *types.ChangeOwner) (*types.ChangeOwnerResponse, error) { 1335 var reqBody, resBody ChangeOwnerBody 1336 1337 reqBody.Req = req 1338 1339 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1340 return nil, err 1341 } 1342 1343 return resBody.Res, nil 1344} 1345 1346type CheckAddHostEvc_TaskBody struct { 1347 Req *types.CheckAddHostEvc_Task `xml:"urn:vim25 CheckAddHostEvc_Task,omitempty"` 1348 Res *types.CheckAddHostEvc_TaskResponse `xml:"urn:vim25 CheckAddHostEvc_TaskResponse,omitempty"` 1349 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1350} 1351 1352func (b *CheckAddHostEvc_TaskBody) Fault() *soap.Fault { return b.Fault_ } 1353 1354func CheckAddHostEvc_Task(ctx context.Context, r soap.RoundTripper, req *types.CheckAddHostEvc_Task) (*types.CheckAddHostEvc_TaskResponse, error) { 1355 var reqBody, resBody CheckAddHostEvc_TaskBody 1356 1357 reqBody.Req = req 1358 1359 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1360 return nil, err 1361 } 1362 1363 return resBody.Res, nil 1364} 1365 1366type CheckAnswerFileStatus_TaskBody struct { 1367 Req *types.CheckAnswerFileStatus_Task `xml:"urn:vim25 CheckAnswerFileStatus_Task,omitempty"` 1368 Res *types.CheckAnswerFileStatus_TaskResponse `xml:"urn:vim25 CheckAnswerFileStatus_TaskResponse,omitempty"` 1369 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1370} 1371 1372func (b *CheckAnswerFileStatus_TaskBody) Fault() *soap.Fault { return b.Fault_ } 1373 1374func CheckAnswerFileStatus_Task(ctx context.Context, r soap.RoundTripper, req *types.CheckAnswerFileStatus_Task) (*types.CheckAnswerFileStatus_TaskResponse, error) { 1375 var reqBody, resBody CheckAnswerFileStatus_TaskBody 1376 1377 reqBody.Req = req 1378 1379 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1380 return nil, err 1381 } 1382 1383 return resBody.Res, nil 1384} 1385 1386type CheckClone_TaskBody struct { 1387 Req *types.CheckClone_Task `xml:"urn:vim25 CheckClone_Task,omitempty"` 1388 Res *types.CheckClone_TaskResponse `xml:"urn:vim25 CheckClone_TaskResponse,omitempty"` 1389 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1390} 1391 1392func (b *CheckClone_TaskBody) Fault() *soap.Fault { return b.Fault_ } 1393 1394func CheckClone_Task(ctx context.Context, r soap.RoundTripper, req *types.CheckClone_Task) (*types.CheckClone_TaskResponse, error) { 1395 var reqBody, resBody CheckClone_TaskBody 1396 1397 reqBody.Req = req 1398 1399 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1400 return nil, err 1401 } 1402 1403 return resBody.Res, nil 1404} 1405 1406type CheckCompatibility_TaskBody struct { 1407 Req *types.CheckCompatibility_Task `xml:"urn:vim25 CheckCompatibility_Task,omitempty"` 1408 Res *types.CheckCompatibility_TaskResponse `xml:"urn:vim25 CheckCompatibility_TaskResponse,omitempty"` 1409 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1410} 1411 1412func (b *CheckCompatibility_TaskBody) Fault() *soap.Fault { return b.Fault_ } 1413 1414func CheckCompatibility_Task(ctx context.Context, r soap.RoundTripper, req *types.CheckCompatibility_Task) (*types.CheckCompatibility_TaskResponse, error) { 1415 var reqBody, resBody CheckCompatibility_TaskBody 1416 1417 reqBody.Req = req 1418 1419 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1420 return nil, err 1421 } 1422 1423 return resBody.Res, nil 1424} 1425 1426type CheckCompliance_TaskBody struct { 1427 Req *types.CheckCompliance_Task `xml:"urn:vim25 CheckCompliance_Task,omitempty"` 1428 Res *types.CheckCompliance_TaskResponse `xml:"urn:vim25 CheckCompliance_TaskResponse,omitempty"` 1429 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1430} 1431 1432func (b *CheckCompliance_TaskBody) Fault() *soap.Fault { return b.Fault_ } 1433 1434func CheckCompliance_Task(ctx context.Context, r soap.RoundTripper, req *types.CheckCompliance_Task) (*types.CheckCompliance_TaskResponse, error) { 1435 var reqBody, resBody CheckCompliance_TaskBody 1436 1437 reqBody.Req = req 1438 1439 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1440 return nil, err 1441 } 1442 1443 return resBody.Res, nil 1444} 1445 1446type CheckConfigureEvcMode_TaskBody struct { 1447 Req *types.CheckConfigureEvcMode_Task `xml:"urn:vim25 CheckConfigureEvcMode_Task,omitempty"` 1448 Res *types.CheckConfigureEvcMode_TaskResponse `xml:"urn:vim25 CheckConfigureEvcMode_TaskResponse,omitempty"` 1449 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1450} 1451 1452func (b *CheckConfigureEvcMode_TaskBody) Fault() *soap.Fault { return b.Fault_ } 1453 1454func CheckConfigureEvcMode_Task(ctx context.Context, r soap.RoundTripper, req *types.CheckConfigureEvcMode_Task) (*types.CheckConfigureEvcMode_TaskResponse, error) { 1455 var reqBody, resBody CheckConfigureEvcMode_TaskBody 1456 1457 reqBody.Req = req 1458 1459 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1460 return nil, err 1461 } 1462 1463 return resBody.Res, nil 1464} 1465 1466type CheckCustomizationResourcesBody struct { 1467 Req *types.CheckCustomizationResources `xml:"urn:vim25 CheckCustomizationResources,omitempty"` 1468 Res *types.CheckCustomizationResourcesResponse `xml:"urn:vim25 CheckCustomizationResourcesResponse,omitempty"` 1469 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1470} 1471 1472func (b *CheckCustomizationResourcesBody) Fault() *soap.Fault { return b.Fault_ } 1473 1474func CheckCustomizationResources(ctx context.Context, r soap.RoundTripper, req *types.CheckCustomizationResources) (*types.CheckCustomizationResourcesResponse, error) { 1475 var reqBody, resBody CheckCustomizationResourcesBody 1476 1477 reqBody.Req = req 1478 1479 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1480 return nil, err 1481 } 1482 1483 return resBody.Res, nil 1484} 1485 1486type CheckCustomizationSpecBody struct { 1487 Req *types.CheckCustomizationSpec `xml:"urn:vim25 CheckCustomizationSpec,omitempty"` 1488 Res *types.CheckCustomizationSpecResponse `xml:"urn:vim25 CheckCustomizationSpecResponse,omitempty"` 1489 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1490} 1491 1492func (b *CheckCustomizationSpecBody) Fault() *soap.Fault { return b.Fault_ } 1493 1494func CheckCustomizationSpec(ctx context.Context, r soap.RoundTripper, req *types.CheckCustomizationSpec) (*types.CheckCustomizationSpecResponse, error) { 1495 var reqBody, resBody CheckCustomizationSpecBody 1496 1497 reqBody.Req = req 1498 1499 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1500 return nil, err 1501 } 1502 1503 return resBody.Res, nil 1504} 1505 1506type CheckForUpdatesBody struct { 1507 Req *types.CheckForUpdates `xml:"urn:vim25 CheckForUpdates,omitempty"` 1508 Res *types.CheckForUpdatesResponse `xml:"urn:vim25 CheckForUpdatesResponse,omitempty"` 1509 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1510} 1511 1512func (b *CheckForUpdatesBody) Fault() *soap.Fault { return b.Fault_ } 1513 1514func CheckForUpdates(ctx context.Context, r soap.RoundTripper, req *types.CheckForUpdates) (*types.CheckForUpdatesResponse, error) { 1515 var reqBody, resBody CheckForUpdatesBody 1516 1517 reqBody.Req = req 1518 1519 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1520 return nil, err 1521 } 1522 1523 return resBody.Res, nil 1524} 1525 1526type CheckHostPatch_TaskBody struct { 1527 Req *types.CheckHostPatch_Task `xml:"urn:vim25 CheckHostPatch_Task,omitempty"` 1528 Res *types.CheckHostPatch_TaskResponse `xml:"urn:vim25 CheckHostPatch_TaskResponse,omitempty"` 1529 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1530} 1531 1532func (b *CheckHostPatch_TaskBody) Fault() *soap.Fault { return b.Fault_ } 1533 1534func CheckHostPatch_Task(ctx context.Context, r soap.RoundTripper, req *types.CheckHostPatch_Task) (*types.CheckHostPatch_TaskResponse, error) { 1535 var reqBody, resBody CheckHostPatch_TaskBody 1536 1537 reqBody.Req = req 1538 1539 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1540 return nil, err 1541 } 1542 1543 return resBody.Res, nil 1544} 1545 1546type CheckInstantClone_TaskBody struct { 1547 Req *types.CheckInstantClone_Task `xml:"urn:vim25 CheckInstantClone_Task,omitempty"` 1548 Res *types.CheckInstantClone_TaskResponse `xml:"urn:vim25 CheckInstantClone_TaskResponse,omitempty"` 1549 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1550} 1551 1552func (b *CheckInstantClone_TaskBody) Fault() *soap.Fault { return b.Fault_ } 1553 1554func CheckInstantClone_Task(ctx context.Context, r soap.RoundTripper, req *types.CheckInstantClone_Task) (*types.CheckInstantClone_TaskResponse, error) { 1555 var reqBody, resBody CheckInstantClone_TaskBody 1556 1557 reqBody.Req = req 1558 1559 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1560 return nil, err 1561 } 1562 1563 return resBody.Res, nil 1564} 1565 1566type CheckLicenseFeatureBody struct { 1567 Req *types.CheckLicenseFeature `xml:"urn:vim25 CheckLicenseFeature,omitempty"` 1568 Res *types.CheckLicenseFeatureResponse `xml:"urn:vim25 CheckLicenseFeatureResponse,omitempty"` 1569 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1570} 1571 1572func (b *CheckLicenseFeatureBody) Fault() *soap.Fault { return b.Fault_ } 1573 1574func CheckLicenseFeature(ctx context.Context, r soap.RoundTripper, req *types.CheckLicenseFeature) (*types.CheckLicenseFeatureResponse, error) { 1575 var reqBody, resBody CheckLicenseFeatureBody 1576 1577 reqBody.Req = req 1578 1579 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1580 return nil, err 1581 } 1582 1583 return resBody.Res, nil 1584} 1585 1586type CheckMigrate_TaskBody struct { 1587 Req *types.CheckMigrate_Task `xml:"urn:vim25 CheckMigrate_Task,omitempty"` 1588 Res *types.CheckMigrate_TaskResponse `xml:"urn:vim25 CheckMigrate_TaskResponse,omitempty"` 1589 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1590} 1591 1592func (b *CheckMigrate_TaskBody) Fault() *soap.Fault { return b.Fault_ } 1593 1594func CheckMigrate_Task(ctx context.Context, r soap.RoundTripper, req *types.CheckMigrate_Task) (*types.CheckMigrate_TaskResponse, error) { 1595 var reqBody, resBody CheckMigrate_TaskBody 1596 1597 reqBody.Req = req 1598 1599 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1600 return nil, err 1601 } 1602 1603 return resBody.Res, nil 1604} 1605 1606type CheckPowerOn_TaskBody struct { 1607 Req *types.CheckPowerOn_Task `xml:"urn:vim25 CheckPowerOn_Task,omitempty"` 1608 Res *types.CheckPowerOn_TaskResponse `xml:"urn:vim25 CheckPowerOn_TaskResponse,omitempty"` 1609 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1610} 1611 1612func (b *CheckPowerOn_TaskBody) Fault() *soap.Fault { return b.Fault_ } 1613 1614func CheckPowerOn_Task(ctx context.Context, r soap.RoundTripper, req *types.CheckPowerOn_Task) (*types.CheckPowerOn_TaskResponse, error) { 1615 var reqBody, resBody CheckPowerOn_TaskBody 1616 1617 reqBody.Req = req 1618 1619 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1620 return nil, err 1621 } 1622 1623 return resBody.Res, nil 1624} 1625 1626type CheckProfileCompliance_TaskBody struct { 1627 Req *types.CheckProfileCompliance_Task `xml:"urn:vim25 CheckProfileCompliance_Task,omitempty"` 1628 Res *types.CheckProfileCompliance_TaskResponse `xml:"urn:vim25 CheckProfileCompliance_TaskResponse,omitempty"` 1629 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1630} 1631 1632func (b *CheckProfileCompliance_TaskBody) Fault() *soap.Fault { return b.Fault_ } 1633 1634func CheckProfileCompliance_Task(ctx context.Context, r soap.RoundTripper, req *types.CheckProfileCompliance_Task) (*types.CheckProfileCompliance_TaskResponse, error) { 1635 var reqBody, resBody CheckProfileCompliance_TaskBody 1636 1637 reqBody.Req = req 1638 1639 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1640 return nil, err 1641 } 1642 1643 return resBody.Res, nil 1644} 1645 1646type CheckRelocate_TaskBody struct { 1647 Req *types.CheckRelocate_Task `xml:"urn:vim25 CheckRelocate_Task,omitempty"` 1648 Res *types.CheckRelocate_TaskResponse `xml:"urn:vim25 CheckRelocate_TaskResponse,omitempty"` 1649 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1650} 1651 1652func (b *CheckRelocate_TaskBody) Fault() *soap.Fault { return b.Fault_ } 1653 1654func CheckRelocate_Task(ctx context.Context, r soap.RoundTripper, req *types.CheckRelocate_Task) (*types.CheckRelocate_TaskResponse, error) { 1655 var reqBody, resBody CheckRelocate_TaskBody 1656 1657 reqBody.Req = req 1658 1659 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1660 return nil, err 1661 } 1662 1663 return resBody.Res, nil 1664} 1665 1666type CheckVmConfig_TaskBody struct { 1667 Req *types.CheckVmConfig_Task `xml:"urn:vim25 CheckVmConfig_Task,omitempty"` 1668 Res *types.CheckVmConfig_TaskResponse `xml:"urn:vim25 CheckVmConfig_TaskResponse,omitempty"` 1669 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1670} 1671 1672func (b *CheckVmConfig_TaskBody) Fault() *soap.Fault { return b.Fault_ } 1673 1674func CheckVmConfig_Task(ctx context.Context, r soap.RoundTripper, req *types.CheckVmConfig_Task) (*types.CheckVmConfig_TaskResponse, error) { 1675 var reqBody, resBody CheckVmConfig_TaskBody 1676 1677 reqBody.Req = req 1678 1679 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1680 return nil, err 1681 } 1682 1683 return resBody.Res, nil 1684} 1685 1686type ClearComplianceStatusBody struct { 1687 Req *types.ClearComplianceStatus `xml:"urn:vim25 ClearComplianceStatus,omitempty"` 1688 Res *types.ClearComplianceStatusResponse `xml:"urn:vim25 ClearComplianceStatusResponse,omitempty"` 1689 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1690} 1691 1692func (b *ClearComplianceStatusBody) Fault() *soap.Fault { return b.Fault_ } 1693 1694func ClearComplianceStatus(ctx context.Context, r soap.RoundTripper, req *types.ClearComplianceStatus) (*types.ClearComplianceStatusResponse, error) { 1695 var reqBody, resBody ClearComplianceStatusBody 1696 1697 reqBody.Req = req 1698 1699 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1700 return nil, err 1701 } 1702 1703 return resBody.Res, nil 1704} 1705 1706type ClearNFSUserBody struct { 1707 Req *types.ClearNFSUser `xml:"urn:vim25 ClearNFSUser,omitempty"` 1708 Res *types.ClearNFSUserResponse `xml:"urn:vim25 ClearNFSUserResponse,omitempty"` 1709 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1710} 1711 1712func (b *ClearNFSUserBody) Fault() *soap.Fault { return b.Fault_ } 1713 1714func ClearNFSUser(ctx context.Context, r soap.RoundTripper, req *types.ClearNFSUser) (*types.ClearNFSUserResponse, error) { 1715 var reqBody, resBody ClearNFSUserBody 1716 1717 reqBody.Req = req 1718 1719 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1720 return nil, err 1721 } 1722 1723 return resBody.Res, nil 1724} 1725 1726type ClearSystemEventLogBody struct { 1727 Req *types.ClearSystemEventLog `xml:"urn:vim25 ClearSystemEventLog,omitempty"` 1728 Res *types.ClearSystemEventLogResponse `xml:"urn:vim25 ClearSystemEventLogResponse,omitempty"` 1729 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1730} 1731 1732func (b *ClearSystemEventLogBody) Fault() *soap.Fault { return b.Fault_ } 1733 1734func ClearSystemEventLog(ctx context.Context, r soap.RoundTripper, req *types.ClearSystemEventLog) (*types.ClearSystemEventLogResponse, error) { 1735 var reqBody, resBody ClearSystemEventLogBody 1736 1737 reqBody.Req = req 1738 1739 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1740 return nil, err 1741 } 1742 1743 return resBody.Res, nil 1744} 1745 1746type ClearTriggeredAlarmsBody struct { 1747 Req *types.ClearTriggeredAlarms `xml:"urn:vim25 ClearTriggeredAlarms,omitempty"` 1748 Res *types.ClearTriggeredAlarmsResponse `xml:"urn:vim25 ClearTriggeredAlarmsResponse,omitempty"` 1749 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1750} 1751 1752func (b *ClearTriggeredAlarmsBody) Fault() *soap.Fault { return b.Fault_ } 1753 1754func ClearTriggeredAlarms(ctx context.Context, r soap.RoundTripper, req *types.ClearTriggeredAlarms) (*types.ClearTriggeredAlarmsResponse, error) { 1755 var reqBody, resBody ClearTriggeredAlarmsBody 1756 1757 reqBody.Req = req 1758 1759 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1760 return nil, err 1761 } 1762 1763 return resBody.Res, nil 1764} 1765 1766type ClearVStorageObjectControlFlagsBody struct { 1767 Req *types.ClearVStorageObjectControlFlags `xml:"urn:vim25 ClearVStorageObjectControlFlags,omitempty"` 1768 Res *types.ClearVStorageObjectControlFlagsResponse `xml:"urn:vim25 ClearVStorageObjectControlFlagsResponse,omitempty"` 1769 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1770} 1771 1772func (b *ClearVStorageObjectControlFlagsBody) Fault() *soap.Fault { return b.Fault_ } 1773 1774func ClearVStorageObjectControlFlags(ctx context.Context, r soap.RoundTripper, req *types.ClearVStorageObjectControlFlags) (*types.ClearVStorageObjectControlFlagsResponse, error) { 1775 var reqBody, resBody ClearVStorageObjectControlFlagsBody 1776 1777 reqBody.Req = req 1778 1779 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1780 return nil, err 1781 } 1782 1783 return resBody.Res, nil 1784} 1785 1786type CloneSessionBody struct { 1787 Req *types.CloneSession `xml:"urn:vim25 CloneSession,omitempty"` 1788 Res *types.CloneSessionResponse `xml:"urn:vim25 CloneSessionResponse,omitempty"` 1789 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1790} 1791 1792func (b *CloneSessionBody) Fault() *soap.Fault { return b.Fault_ } 1793 1794func CloneSession(ctx context.Context, r soap.RoundTripper, req *types.CloneSession) (*types.CloneSessionResponse, error) { 1795 var reqBody, resBody CloneSessionBody 1796 1797 reqBody.Req = req 1798 1799 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1800 return nil, err 1801 } 1802 1803 return resBody.Res, nil 1804} 1805 1806type CloneVApp_TaskBody struct { 1807 Req *types.CloneVApp_Task `xml:"urn:vim25 CloneVApp_Task,omitempty"` 1808 Res *types.CloneVApp_TaskResponse `xml:"urn:vim25 CloneVApp_TaskResponse,omitempty"` 1809 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1810} 1811 1812func (b *CloneVApp_TaskBody) Fault() *soap.Fault { return b.Fault_ } 1813 1814func CloneVApp_Task(ctx context.Context, r soap.RoundTripper, req *types.CloneVApp_Task) (*types.CloneVApp_TaskResponse, error) { 1815 var reqBody, resBody CloneVApp_TaskBody 1816 1817 reqBody.Req = req 1818 1819 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1820 return nil, err 1821 } 1822 1823 return resBody.Res, nil 1824} 1825 1826type CloneVM_TaskBody struct { 1827 Req *types.CloneVM_Task `xml:"urn:vim25 CloneVM_Task,omitempty"` 1828 Res *types.CloneVM_TaskResponse `xml:"urn:vim25 CloneVM_TaskResponse,omitempty"` 1829 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1830} 1831 1832func (b *CloneVM_TaskBody) Fault() *soap.Fault { return b.Fault_ } 1833 1834func CloneVM_Task(ctx context.Context, r soap.RoundTripper, req *types.CloneVM_Task) (*types.CloneVM_TaskResponse, error) { 1835 var reqBody, resBody CloneVM_TaskBody 1836 1837 reqBody.Req = req 1838 1839 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1840 return nil, err 1841 } 1842 1843 return resBody.Res, nil 1844} 1845 1846type CloneVStorageObject_TaskBody struct { 1847 Req *types.CloneVStorageObject_Task `xml:"urn:vim25 CloneVStorageObject_Task,omitempty"` 1848 Res *types.CloneVStorageObject_TaskResponse `xml:"urn:vim25 CloneVStorageObject_TaskResponse,omitempty"` 1849 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1850} 1851 1852func (b *CloneVStorageObject_TaskBody) Fault() *soap.Fault { return b.Fault_ } 1853 1854func CloneVStorageObject_Task(ctx context.Context, r soap.RoundTripper, req *types.CloneVStorageObject_Task) (*types.CloneVStorageObject_TaskResponse, error) { 1855 var reqBody, resBody CloneVStorageObject_TaskBody 1856 1857 reqBody.Req = req 1858 1859 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1860 return nil, err 1861 } 1862 1863 return resBody.Res, nil 1864} 1865 1866type CloseInventoryViewFolderBody struct { 1867 Req *types.CloseInventoryViewFolder `xml:"urn:vim25 CloseInventoryViewFolder,omitempty"` 1868 Res *types.CloseInventoryViewFolderResponse `xml:"urn:vim25 CloseInventoryViewFolderResponse,omitempty"` 1869 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1870} 1871 1872func (b *CloseInventoryViewFolderBody) Fault() *soap.Fault { return b.Fault_ } 1873 1874func CloseInventoryViewFolder(ctx context.Context, r soap.RoundTripper, req *types.CloseInventoryViewFolder) (*types.CloseInventoryViewFolderResponse, error) { 1875 var reqBody, resBody CloseInventoryViewFolderBody 1876 1877 reqBody.Req = req 1878 1879 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1880 return nil, err 1881 } 1882 1883 return resBody.Res, nil 1884} 1885 1886type ClusterEnterMaintenanceModeBody struct { 1887 Req *types.ClusterEnterMaintenanceMode `xml:"urn:vim25 ClusterEnterMaintenanceMode,omitempty"` 1888 Res *types.ClusterEnterMaintenanceModeResponse `xml:"urn:vim25 ClusterEnterMaintenanceModeResponse,omitempty"` 1889 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1890} 1891 1892func (b *ClusterEnterMaintenanceModeBody) Fault() *soap.Fault { return b.Fault_ } 1893 1894func ClusterEnterMaintenanceMode(ctx context.Context, r soap.RoundTripper, req *types.ClusterEnterMaintenanceMode) (*types.ClusterEnterMaintenanceModeResponse, error) { 1895 var reqBody, resBody ClusterEnterMaintenanceModeBody 1896 1897 reqBody.Req = req 1898 1899 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1900 return nil, err 1901 } 1902 1903 return resBody.Res, nil 1904} 1905 1906type CompositeHostProfile_TaskBody struct { 1907 Req *types.CompositeHostProfile_Task `xml:"urn:vim25 CompositeHostProfile_Task,omitempty"` 1908 Res *types.CompositeHostProfile_TaskResponse `xml:"urn:vim25 CompositeHostProfile_TaskResponse,omitempty"` 1909 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1910} 1911 1912func (b *CompositeHostProfile_TaskBody) Fault() *soap.Fault { return b.Fault_ } 1913 1914func CompositeHostProfile_Task(ctx context.Context, r soap.RoundTripper, req *types.CompositeHostProfile_Task) (*types.CompositeHostProfile_TaskResponse, error) { 1915 var reqBody, resBody CompositeHostProfile_TaskBody 1916 1917 reqBody.Req = req 1918 1919 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1920 return nil, err 1921 } 1922 1923 return resBody.Res, nil 1924} 1925 1926type ComputeDiskPartitionInfoBody struct { 1927 Req *types.ComputeDiskPartitionInfo `xml:"urn:vim25 ComputeDiskPartitionInfo,omitempty"` 1928 Res *types.ComputeDiskPartitionInfoResponse `xml:"urn:vim25 ComputeDiskPartitionInfoResponse,omitempty"` 1929 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1930} 1931 1932func (b *ComputeDiskPartitionInfoBody) Fault() *soap.Fault { return b.Fault_ } 1933 1934func ComputeDiskPartitionInfo(ctx context.Context, r soap.RoundTripper, req *types.ComputeDiskPartitionInfo) (*types.ComputeDiskPartitionInfoResponse, error) { 1935 var reqBody, resBody ComputeDiskPartitionInfoBody 1936 1937 reqBody.Req = req 1938 1939 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1940 return nil, err 1941 } 1942 1943 return resBody.Res, nil 1944} 1945 1946type ComputeDiskPartitionInfoForResizeBody struct { 1947 Req *types.ComputeDiskPartitionInfoForResize `xml:"urn:vim25 ComputeDiskPartitionInfoForResize,omitempty"` 1948 Res *types.ComputeDiskPartitionInfoForResizeResponse `xml:"urn:vim25 ComputeDiskPartitionInfoForResizeResponse,omitempty"` 1949 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1950} 1951 1952func (b *ComputeDiskPartitionInfoForResizeBody) Fault() *soap.Fault { return b.Fault_ } 1953 1954func ComputeDiskPartitionInfoForResize(ctx context.Context, r soap.RoundTripper, req *types.ComputeDiskPartitionInfoForResize) (*types.ComputeDiskPartitionInfoForResizeResponse, error) { 1955 var reqBody, resBody ComputeDiskPartitionInfoForResizeBody 1956 1957 reqBody.Req = req 1958 1959 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1960 return nil, err 1961 } 1962 1963 return resBody.Res, nil 1964} 1965 1966type ConfigureCryptoKeyBody struct { 1967 Req *types.ConfigureCryptoKey `xml:"urn:vim25 ConfigureCryptoKey,omitempty"` 1968 Res *types.ConfigureCryptoKeyResponse `xml:"urn:vim25 ConfigureCryptoKeyResponse,omitempty"` 1969 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1970} 1971 1972func (b *ConfigureCryptoKeyBody) Fault() *soap.Fault { return b.Fault_ } 1973 1974func ConfigureCryptoKey(ctx context.Context, r soap.RoundTripper, req *types.ConfigureCryptoKey) (*types.ConfigureCryptoKeyResponse, error) { 1975 var reqBody, resBody ConfigureCryptoKeyBody 1976 1977 reqBody.Req = req 1978 1979 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 1980 return nil, err 1981 } 1982 1983 return resBody.Res, nil 1984} 1985 1986type ConfigureDatastoreIORM_TaskBody struct { 1987 Req *types.ConfigureDatastoreIORM_Task `xml:"urn:vim25 ConfigureDatastoreIORM_Task,omitempty"` 1988 Res *types.ConfigureDatastoreIORM_TaskResponse `xml:"urn:vim25 ConfigureDatastoreIORM_TaskResponse,omitempty"` 1989 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 1990} 1991 1992func (b *ConfigureDatastoreIORM_TaskBody) Fault() *soap.Fault { return b.Fault_ } 1993 1994func ConfigureDatastoreIORM_Task(ctx context.Context, r soap.RoundTripper, req *types.ConfigureDatastoreIORM_Task) (*types.ConfigureDatastoreIORM_TaskResponse, error) { 1995 var reqBody, resBody ConfigureDatastoreIORM_TaskBody 1996 1997 reqBody.Req = req 1998 1999 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2000 return nil, err 2001 } 2002 2003 return resBody.Res, nil 2004} 2005 2006type ConfigureDatastorePrincipalBody struct { 2007 Req *types.ConfigureDatastorePrincipal `xml:"urn:vim25 ConfigureDatastorePrincipal,omitempty"` 2008 Res *types.ConfigureDatastorePrincipalResponse `xml:"urn:vim25 ConfigureDatastorePrincipalResponse,omitempty"` 2009 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2010} 2011 2012func (b *ConfigureDatastorePrincipalBody) Fault() *soap.Fault { return b.Fault_ } 2013 2014func ConfigureDatastorePrincipal(ctx context.Context, r soap.RoundTripper, req *types.ConfigureDatastorePrincipal) (*types.ConfigureDatastorePrincipalResponse, error) { 2015 var reqBody, resBody ConfigureDatastorePrincipalBody 2016 2017 reqBody.Req = req 2018 2019 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2020 return nil, err 2021 } 2022 2023 return resBody.Res, nil 2024} 2025 2026type ConfigureEvcMode_TaskBody struct { 2027 Req *types.ConfigureEvcMode_Task `xml:"urn:vim25 ConfigureEvcMode_Task,omitempty"` 2028 Res *types.ConfigureEvcMode_TaskResponse `xml:"urn:vim25 ConfigureEvcMode_TaskResponse,omitempty"` 2029 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2030} 2031 2032func (b *ConfigureEvcMode_TaskBody) Fault() *soap.Fault { return b.Fault_ } 2033 2034func ConfigureEvcMode_Task(ctx context.Context, r soap.RoundTripper, req *types.ConfigureEvcMode_Task) (*types.ConfigureEvcMode_TaskResponse, error) { 2035 var reqBody, resBody ConfigureEvcMode_TaskBody 2036 2037 reqBody.Req = req 2038 2039 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2040 return nil, err 2041 } 2042 2043 return resBody.Res, nil 2044} 2045 2046type ConfigureHostCache_TaskBody struct { 2047 Req *types.ConfigureHostCache_Task `xml:"urn:vim25 ConfigureHostCache_Task,omitempty"` 2048 Res *types.ConfigureHostCache_TaskResponse `xml:"urn:vim25 ConfigureHostCache_TaskResponse,omitempty"` 2049 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2050} 2051 2052func (b *ConfigureHostCache_TaskBody) Fault() *soap.Fault { return b.Fault_ } 2053 2054func ConfigureHostCache_Task(ctx context.Context, r soap.RoundTripper, req *types.ConfigureHostCache_Task) (*types.ConfigureHostCache_TaskResponse, error) { 2055 var reqBody, resBody ConfigureHostCache_TaskBody 2056 2057 reqBody.Req = req 2058 2059 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2060 return nil, err 2061 } 2062 2063 return resBody.Res, nil 2064} 2065 2066type ConfigureLicenseSourceBody struct { 2067 Req *types.ConfigureLicenseSource `xml:"urn:vim25 ConfigureLicenseSource,omitempty"` 2068 Res *types.ConfigureLicenseSourceResponse `xml:"urn:vim25 ConfigureLicenseSourceResponse,omitempty"` 2069 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2070} 2071 2072func (b *ConfigureLicenseSourceBody) Fault() *soap.Fault { return b.Fault_ } 2073 2074func ConfigureLicenseSource(ctx context.Context, r soap.RoundTripper, req *types.ConfigureLicenseSource) (*types.ConfigureLicenseSourceResponse, error) { 2075 var reqBody, resBody ConfigureLicenseSourceBody 2076 2077 reqBody.Req = req 2078 2079 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2080 return nil, err 2081 } 2082 2083 return resBody.Res, nil 2084} 2085 2086type ConfigurePowerPolicyBody struct { 2087 Req *types.ConfigurePowerPolicy `xml:"urn:vim25 ConfigurePowerPolicy,omitempty"` 2088 Res *types.ConfigurePowerPolicyResponse `xml:"urn:vim25 ConfigurePowerPolicyResponse,omitempty"` 2089 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2090} 2091 2092func (b *ConfigurePowerPolicyBody) Fault() *soap.Fault { return b.Fault_ } 2093 2094func ConfigurePowerPolicy(ctx context.Context, r soap.RoundTripper, req *types.ConfigurePowerPolicy) (*types.ConfigurePowerPolicyResponse, error) { 2095 var reqBody, resBody ConfigurePowerPolicyBody 2096 2097 reqBody.Req = req 2098 2099 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2100 return nil, err 2101 } 2102 2103 return resBody.Res, nil 2104} 2105 2106type ConfigureStorageDrsForPod_TaskBody struct { 2107 Req *types.ConfigureStorageDrsForPod_Task `xml:"urn:vim25 ConfigureStorageDrsForPod_Task,omitempty"` 2108 Res *types.ConfigureStorageDrsForPod_TaskResponse `xml:"urn:vim25 ConfigureStorageDrsForPod_TaskResponse,omitempty"` 2109 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2110} 2111 2112func (b *ConfigureStorageDrsForPod_TaskBody) Fault() *soap.Fault { return b.Fault_ } 2113 2114func ConfigureStorageDrsForPod_Task(ctx context.Context, r soap.RoundTripper, req *types.ConfigureStorageDrsForPod_Task) (*types.ConfigureStorageDrsForPod_TaskResponse, error) { 2115 var reqBody, resBody ConfigureStorageDrsForPod_TaskBody 2116 2117 reqBody.Req = req 2118 2119 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2120 return nil, err 2121 } 2122 2123 return resBody.Res, nil 2124} 2125 2126type ConfigureVFlashResourceEx_TaskBody struct { 2127 Req *types.ConfigureVFlashResourceEx_Task `xml:"urn:vim25 ConfigureVFlashResourceEx_Task,omitempty"` 2128 Res *types.ConfigureVFlashResourceEx_TaskResponse `xml:"urn:vim25 ConfigureVFlashResourceEx_TaskResponse,omitempty"` 2129 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2130} 2131 2132func (b *ConfigureVFlashResourceEx_TaskBody) Fault() *soap.Fault { return b.Fault_ } 2133 2134func ConfigureVFlashResourceEx_Task(ctx context.Context, r soap.RoundTripper, req *types.ConfigureVFlashResourceEx_Task) (*types.ConfigureVFlashResourceEx_TaskResponse, error) { 2135 var reqBody, resBody ConfigureVFlashResourceEx_TaskBody 2136 2137 reqBody.Req = req 2138 2139 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2140 return nil, err 2141 } 2142 2143 return resBody.Res, nil 2144} 2145 2146type ConsolidateVMDisks_TaskBody struct { 2147 Req *types.ConsolidateVMDisks_Task `xml:"urn:vim25 ConsolidateVMDisks_Task,omitempty"` 2148 Res *types.ConsolidateVMDisks_TaskResponse `xml:"urn:vim25 ConsolidateVMDisks_TaskResponse,omitempty"` 2149 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2150} 2151 2152func (b *ConsolidateVMDisks_TaskBody) Fault() *soap.Fault { return b.Fault_ } 2153 2154func ConsolidateVMDisks_Task(ctx context.Context, r soap.RoundTripper, req *types.ConsolidateVMDisks_Task) (*types.ConsolidateVMDisks_TaskResponse, error) { 2155 var reqBody, resBody ConsolidateVMDisks_TaskBody 2156 2157 reqBody.Req = req 2158 2159 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2160 return nil, err 2161 } 2162 2163 return resBody.Res, nil 2164} 2165 2166type ContinueRetrievePropertiesExBody struct { 2167 Req *types.ContinueRetrievePropertiesEx `xml:"urn:vim25 ContinueRetrievePropertiesEx,omitempty"` 2168 Res *types.ContinueRetrievePropertiesExResponse `xml:"urn:vim25 ContinueRetrievePropertiesExResponse,omitempty"` 2169 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2170} 2171 2172func (b *ContinueRetrievePropertiesExBody) Fault() *soap.Fault { return b.Fault_ } 2173 2174func ContinueRetrievePropertiesEx(ctx context.Context, r soap.RoundTripper, req *types.ContinueRetrievePropertiesEx) (*types.ContinueRetrievePropertiesExResponse, error) { 2175 var reqBody, resBody ContinueRetrievePropertiesExBody 2176 2177 reqBody.Req = req 2178 2179 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2180 return nil, err 2181 } 2182 2183 return resBody.Res, nil 2184} 2185 2186type ConvertNamespacePathToUuidPathBody struct { 2187 Req *types.ConvertNamespacePathToUuidPath `xml:"urn:vim25 ConvertNamespacePathToUuidPath,omitempty"` 2188 Res *types.ConvertNamespacePathToUuidPathResponse `xml:"urn:vim25 ConvertNamespacePathToUuidPathResponse,omitempty"` 2189 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2190} 2191 2192func (b *ConvertNamespacePathToUuidPathBody) Fault() *soap.Fault { return b.Fault_ } 2193 2194func ConvertNamespacePathToUuidPath(ctx context.Context, r soap.RoundTripper, req *types.ConvertNamespacePathToUuidPath) (*types.ConvertNamespacePathToUuidPathResponse, error) { 2195 var reqBody, resBody ConvertNamespacePathToUuidPathBody 2196 2197 reqBody.Req = req 2198 2199 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2200 return nil, err 2201 } 2202 2203 return resBody.Res, nil 2204} 2205 2206type CopyDatastoreFile_TaskBody struct { 2207 Req *types.CopyDatastoreFile_Task `xml:"urn:vim25 CopyDatastoreFile_Task,omitempty"` 2208 Res *types.CopyDatastoreFile_TaskResponse `xml:"urn:vim25 CopyDatastoreFile_TaskResponse,omitempty"` 2209 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2210} 2211 2212func (b *CopyDatastoreFile_TaskBody) Fault() *soap.Fault { return b.Fault_ } 2213 2214func CopyDatastoreFile_Task(ctx context.Context, r soap.RoundTripper, req *types.CopyDatastoreFile_Task) (*types.CopyDatastoreFile_TaskResponse, error) { 2215 var reqBody, resBody CopyDatastoreFile_TaskBody 2216 2217 reqBody.Req = req 2218 2219 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2220 return nil, err 2221 } 2222 2223 return resBody.Res, nil 2224} 2225 2226type CopyVirtualDisk_TaskBody struct { 2227 Req *types.CopyVirtualDisk_Task `xml:"urn:vim25 CopyVirtualDisk_Task,omitempty"` 2228 Res *types.CopyVirtualDisk_TaskResponse `xml:"urn:vim25 CopyVirtualDisk_TaskResponse,omitempty"` 2229 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2230} 2231 2232func (b *CopyVirtualDisk_TaskBody) Fault() *soap.Fault { return b.Fault_ } 2233 2234func CopyVirtualDisk_Task(ctx context.Context, r soap.RoundTripper, req *types.CopyVirtualDisk_Task) (*types.CopyVirtualDisk_TaskResponse, error) { 2235 var reqBody, resBody CopyVirtualDisk_TaskBody 2236 2237 reqBody.Req = req 2238 2239 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2240 return nil, err 2241 } 2242 2243 return resBody.Res, nil 2244} 2245 2246type CreateAlarmBody struct { 2247 Req *types.CreateAlarm `xml:"urn:vim25 CreateAlarm,omitempty"` 2248 Res *types.CreateAlarmResponse `xml:"urn:vim25 CreateAlarmResponse,omitempty"` 2249 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2250} 2251 2252func (b *CreateAlarmBody) Fault() *soap.Fault { return b.Fault_ } 2253 2254func CreateAlarm(ctx context.Context, r soap.RoundTripper, req *types.CreateAlarm) (*types.CreateAlarmResponse, error) { 2255 var reqBody, resBody CreateAlarmBody 2256 2257 reqBody.Req = req 2258 2259 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2260 return nil, err 2261 } 2262 2263 return resBody.Res, nil 2264} 2265 2266type CreateChildVM_TaskBody struct { 2267 Req *types.CreateChildVM_Task `xml:"urn:vim25 CreateChildVM_Task,omitempty"` 2268 Res *types.CreateChildVM_TaskResponse `xml:"urn:vim25 CreateChildVM_TaskResponse,omitempty"` 2269 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2270} 2271 2272func (b *CreateChildVM_TaskBody) Fault() *soap.Fault { return b.Fault_ } 2273 2274func CreateChildVM_Task(ctx context.Context, r soap.RoundTripper, req *types.CreateChildVM_Task) (*types.CreateChildVM_TaskResponse, error) { 2275 var reqBody, resBody CreateChildVM_TaskBody 2276 2277 reqBody.Req = req 2278 2279 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2280 return nil, err 2281 } 2282 2283 return resBody.Res, nil 2284} 2285 2286type CreateClusterBody struct { 2287 Req *types.CreateCluster `xml:"urn:vim25 CreateCluster,omitempty"` 2288 Res *types.CreateClusterResponse `xml:"urn:vim25 CreateClusterResponse,omitempty"` 2289 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2290} 2291 2292func (b *CreateClusterBody) Fault() *soap.Fault { return b.Fault_ } 2293 2294func CreateCluster(ctx context.Context, r soap.RoundTripper, req *types.CreateCluster) (*types.CreateClusterResponse, error) { 2295 var reqBody, resBody CreateClusterBody 2296 2297 reqBody.Req = req 2298 2299 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2300 return nil, err 2301 } 2302 2303 return resBody.Res, nil 2304} 2305 2306type CreateClusterExBody struct { 2307 Req *types.CreateClusterEx `xml:"urn:vim25 CreateClusterEx,omitempty"` 2308 Res *types.CreateClusterExResponse `xml:"urn:vim25 CreateClusterExResponse,omitempty"` 2309 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2310} 2311 2312func (b *CreateClusterExBody) Fault() *soap.Fault { return b.Fault_ } 2313 2314func CreateClusterEx(ctx context.Context, r soap.RoundTripper, req *types.CreateClusterEx) (*types.CreateClusterExResponse, error) { 2315 var reqBody, resBody CreateClusterExBody 2316 2317 reqBody.Req = req 2318 2319 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2320 return nil, err 2321 } 2322 2323 return resBody.Res, nil 2324} 2325 2326type CreateCollectorForEventsBody struct { 2327 Req *types.CreateCollectorForEvents `xml:"urn:vim25 CreateCollectorForEvents,omitempty"` 2328 Res *types.CreateCollectorForEventsResponse `xml:"urn:vim25 CreateCollectorForEventsResponse,omitempty"` 2329 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2330} 2331 2332func (b *CreateCollectorForEventsBody) Fault() *soap.Fault { return b.Fault_ } 2333 2334func CreateCollectorForEvents(ctx context.Context, r soap.RoundTripper, req *types.CreateCollectorForEvents) (*types.CreateCollectorForEventsResponse, error) { 2335 var reqBody, resBody CreateCollectorForEventsBody 2336 2337 reqBody.Req = req 2338 2339 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2340 return nil, err 2341 } 2342 2343 return resBody.Res, nil 2344} 2345 2346type CreateCollectorForTasksBody struct { 2347 Req *types.CreateCollectorForTasks `xml:"urn:vim25 CreateCollectorForTasks,omitempty"` 2348 Res *types.CreateCollectorForTasksResponse `xml:"urn:vim25 CreateCollectorForTasksResponse,omitempty"` 2349 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2350} 2351 2352func (b *CreateCollectorForTasksBody) Fault() *soap.Fault { return b.Fault_ } 2353 2354func CreateCollectorForTasks(ctx context.Context, r soap.RoundTripper, req *types.CreateCollectorForTasks) (*types.CreateCollectorForTasksResponse, error) { 2355 var reqBody, resBody CreateCollectorForTasksBody 2356 2357 reqBody.Req = req 2358 2359 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2360 return nil, err 2361 } 2362 2363 return resBody.Res, nil 2364} 2365 2366type CreateContainerViewBody struct { 2367 Req *types.CreateContainerView `xml:"urn:vim25 CreateContainerView,omitempty"` 2368 Res *types.CreateContainerViewResponse `xml:"urn:vim25 CreateContainerViewResponse,omitempty"` 2369 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2370} 2371 2372func (b *CreateContainerViewBody) Fault() *soap.Fault { return b.Fault_ } 2373 2374func CreateContainerView(ctx context.Context, r soap.RoundTripper, req *types.CreateContainerView) (*types.CreateContainerViewResponse, error) { 2375 var reqBody, resBody CreateContainerViewBody 2376 2377 reqBody.Req = req 2378 2379 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2380 return nil, err 2381 } 2382 2383 return resBody.Res, nil 2384} 2385 2386type CreateCustomizationSpecBody struct { 2387 Req *types.CreateCustomizationSpec `xml:"urn:vim25 CreateCustomizationSpec,omitempty"` 2388 Res *types.CreateCustomizationSpecResponse `xml:"urn:vim25 CreateCustomizationSpecResponse,omitempty"` 2389 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2390} 2391 2392func (b *CreateCustomizationSpecBody) Fault() *soap.Fault { return b.Fault_ } 2393 2394func CreateCustomizationSpec(ctx context.Context, r soap.RoundTripper, req *types.CreateCustomizationSpec) (*types.CreateCustomizationSpecResponse, error) { 2395 var reqBody, resBody CreateCustomizationSpecBody 2396 2397 reqBody.Req = req 2398 2399 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2400 return nil, err 2401 } 2402 2403 return resBody.Res, nil 2404} 2405 2406type CreateDVPortgroup_TaskBody struct { 2407 Req *types.CreateDVPortgroup_Task `xml:"urn:vim25 CreateDVPortgroup_Task,omitempty"` 2408 Res *types.CreateDVPortgroup_TaskResponse `xml:"urn:vim25 CreateDVPortgroup_TaskResponse,omitempty"` 2409 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2410} 2411 2412func (b *CreateDVPortgroup_TaskBody) Fault() *soap.Fault { return b.Fault_ } 2413 2414func CreateDVPortgroup_Task(ctx context.Context, r soap.RoundTripper, req *types.CreateDVPortgroup_Task) (*types.CreateDVPortgroup_TaskResponse, error) { 2415 var reqBody, resBody CreateDVPortgroup_TaskBody 2416 2417 reqBody.Req = req 2418 2419 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2420 return nil, err 2421 } 2422 2423 return resBody.Res, nil 2424} 2425 2426type CreateDVS_TaskBody struct { 2427 Req *types.CreateDVS_Task `xml:"urn:vim25 CreateDVS_Task,omitempty"` 2428 Res *types.CreateDVS_TaskResponse `xml:"urn:vim25 CreateDVS_TaskResponse,omitempty"` 2429 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2430} 2431 2432func (b *CreateDVS_TaskBody) Fault() *soap.Fault { return b.Fault_ } 2433 2434func CreateDVS_Task(ctx context.Context, r soap.RoundTripper, req *types.CreateDVS_Task) (*types.CreateDVS_TaskResponse, error) { 2435 var reqBody, resBody CreateDVS_TaskBody 2436 2437 reqBody.Req = req 2438 2439 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2440 return nil, err 2441 } 2442 2443 return resBody.Res, nil 2444} 2445 2446type CreateDatacenterBody struct { 2447 Req *types.CreateDatacenter `xml:"urn:vim25 CreateDatacenter,omitempty"` 2448 Res *types.CreateDatacenterResponse `xml:"urn:vim25 CreateDatacenterResponse,omitempty"` 2449 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2450} 2451 2452func (b *CreateDatacenterBody) Fault() *soap.Fault { return b.Fault_ } 2453 2454func CreateDatacenter(ctx context.Context, r soap.RoundTripper, req *types.CreateDatacenter) (*types.CreateDatacenterResponse, error) { 2455 var reqBody, resBody CreateDatacenterBody 2456 2457 reqBody.Req = req 2458 2459 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2460 return nil, err 2461 } 2462 2463 return resBody.Res, nil 2464} 2465 2466type CreateDefaultProfileBody struct { 2467 Req *types.CreateDefaultProfile `xml:"urn:vim25 CreateDefaultProfile,omitempty"` 2468 Res *types.CreateDefaultProfileResponse `xml:"urn:vim25 CreateDefaultProfileResponse,omitempty"` 2469 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2470} 2471 2472func (b *CreateDefaultProfileBody) Fault() *soap.Fault { return b.Fault_ } 2473 2474func CreateDefaultProfile(ctx context.Context, r soap.RoundTripper, req *types.CreateDefaultProfile) (*types.CreateDefaultProfileResponse, error) { 2475 var reqBody, resBody CreateDefaultProfileBody 2476 2477 reqBody.Req = req 2478 2479 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2480 return nil, err 2481 } 2482 2483 return resBody.Res, nil 2484} 2485 2486type CreateDescriptorBody struct { 2487 Req *types.CreateDescriptor `xml:"urn:vim25 CreateDescriptor,omitempty"` 2488 Res *types.CreateDescriptorResponse `xml:"urn:vim25 CreateDescriptorResponse,omitempty"` 2489 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2490} 2491 2492func (b *CreateDescriptorBody) Fault() *soap.Fault { return b.Fault_ } 2493 2494func CreateDescriptor(ctx context.Context, r soap.RoundTripper, req *types.CreateDescriptor) (*types.CreateDescriptorResponse, error) { 2495 var reqBody, resBody CreateDescriptorBody 2496 2497 reqBody.Req = req 2498 2499 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2500 return nil, err 2501 } 2502 2503 return resBody.Res, nil 2504} 2505 2506type CreateDiagnosticPartitionBody struct { 2507 Req *types.CreateDiagnosticPartition `xml:"urn:vim25 CreateDiagnosticPartition,omitempty"` 2508 Res *types.CreateDiagnosticPartitionResponse `xml:"urn:vim25 CreateDiagnosticPartitionResponse,omitempty"` 2509 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2510} 2511 2512func (b *CreateDiagnosticPartitionBody) Fault() *soap.Fault { return b.Fault_ } 2513 2514func CreateDiagnosticPartition(ctx context.Context, r soap.RoundTripper, req *types.CreateDiagnosticPartition) (*types.CreateDiagnosticPartitionResponse, error) { 2515 var reqBody, resBody CreateDiagnosticPartitionBody 2516 2517 reqBody.Req = req 2518 2519 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2520 return nil, err 2521 } 2522 2523 return resBody.Res, nil 2524} 2525 2526type CreateDirectoryBody struct { 2527 Req *types.CreateDirectory `xml:"urn:vim25 CreateDirectory,omitempty"` 2528 Res *types.CreateDirectoryResponse `xml:"urn:vim25 CreateDirectoryResponse,omitempty"` 2529 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2530} 2531 2532func (b *CreateDirectoryBody) Fault() *soap.Fault { return b.Fault_ } 2533 2534func CreateDirectory(ctx context.Context, r soap.RoundTripper, req *types.CreateDirectory) (*types.CreateDirectoryResponse, error) { 2535 var reqBody, resBody CreateDirectoryBody 2536 2537 reqBody.Req = req 2538 2539 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2540 return nil, err 2541 } 2542 2543 return resBody.Res, nil 2544} 2545 2546type CreateDiskFromSnapshot_TaskBody struct { 2547 Req *types.CreateDiskFromSnapshot_Task `xml:"urn:vim25 CreateDiskFromSnapshot_Task,omitempty"` 2548 Res *types.CreateDiskFromSnapshot_TaskResponse `xml:"urn:vim25 CreateDiskFromSnapshot_TaskResponse,omitempty"` 2549 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2550} 2551 2552func (b *CreateDiskFromSnapshot_TaskBody) Fault() *soap.Fault { return b.Fault_ } 2553 2554func CreateDiskFromSnapshot_Task(ctx context.Context, r soap.RoundTripper, req *types.CreateDiskFromSnapshot_Task) (*types.CreateDiskFromSnapshot_TaskResponse, error) { 2555 var reqBody, resBody CreateDiskFromSnapshot_TaskBody 2556 2557 reqBody.Req = req 2558 2559 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2560 return nil, err 2561 } 2562 2563 return resBody.Res, nil 2564} 2565 2566type CreateDisk_TaskBody struct { 2567 Req *types.CreateDisk_Task `xml:"urn:vim25 CreateDisk_Task,omitempty"` 2568 Res *types.CreateDisk_TaskResponse `xml:"urn:vim25 CreateDisk_TaskResponse,omitempty"` 2569 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2570} 2571 2572func (b *CreateDisk_TaskBody) Fault() *soap.Fault { return b.Fault_ } 2573 2574func CreateDisk_Task(ctx context.Context, r soap.RoundTripper, req *types.CreateDisk_Task) (*types.CreateDisk_TaskResponse, error) { 2575 var reqBody, resBody CreateDisk_TaskBody 2576 2577 reqBody.Req = req 2578 2579 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2580 return nil, err 2581 } 2582 2583 return resBody.Res, nil 2584} 2585 2586type CreateFilterBody struct { 2587 Req *types.CreateFilter `xml:"urn:vim25 CreateFilter,omitempty"` 2588 Res *types.CreateFilterResponse `xml:"urn:vim25 CreateFilterResponse,omitempty"` 2589 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2590} 2591 2592func (b *CreateFilterBody) Fault() *soap.Fault { return b.Fault_ } 2593 2594func CreateFilter(ctx context.Context, r soap.RoundTripper, req *types.CreateFilter) (*types.CreateFilterResponse, error) { 2595 var reqBody, resBody CreateFilterBody 2596 2597 reqBody.Req = req 2598 2599 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2600 return nil, err 2601 } 2602 2603 return resBody.Res, nil 2604} 2605 2606type CreateFolderBody struct { 2607 Req *types.CreateFolder `xml:"urn:vim25 CreateFolder,omitempty"` 2608 Res *types.CreateFolderResponse `xml:"urn:vim25 CreateFolderResponse,omitempty"` 2609 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2610} 2611 2612func (b *CreateFolderBody) Fault() *soap.Fault { return b.Fault_ } 2613 2614func CreateFolder(ctx context.Context, r soap.RoundTripper, req *types.CreateFolder) (*types.CreateFolderResponse, error) { 2615 var reqBody, resBody CreateFolderBody 2616 2617 reqBody.Req = req 2618 2619 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2620 return nil, err 2621 } 2622 2623 return resBody.Res, nil 2624} 2625 2626type CreateGroupBody struct { 2627 Req *types.CreateGroup `xml:"urn:vim25 CreateGroup,omitempty"` 2628 Res *types.CreateGroupResponse `xml:"urn:vim25 CreateGroupResponse,omitempty"` 2629 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2630} 2631 2632func (b *CreateGroupBody) Fault() *soap.Fault { return b.Fault_ } 2633 2634func CreateGroup(ctx context.Context, r soap.RoundTripper, req *types.CreateGroup) (*types.CreateGroupResponse, error) { 2635 var reqBody, resBody CreateGroupBody 2636 2637 reqBody.Req = req 2638 2639 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2640 return nil, err 2641 } 2642 2643 return resBody.Res, nil 2644} 2645 2646type CreateImportSpecBody struct { 2647 Req *types.CreateImportSpec `xml:"urn:vim25 CreateImportSpec,omitempty"` 2648 Res *types.CreateImportSpecResponse `xml:"urn:vim25 CreateImportSpecResponse,omitempty"` 2649 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2650} 2651 2652func (b *CreateImportSpecBody) Fault() *soap.Fault { return b.Fault_ } 2653 2654func CreateImportSpec(ctx context.Context, r soap.RoundTripper, req *types.CreateImportSpec) (*types.CreateImportSpecResponse, error) { 2655 var reqBody, resBody CreateImportSpecBody 2656 2657 reqBody.Req = req 2658 2659 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2660 return nil, err 2661 } 2662 2663 return resBody.Res, nil 2664} 2665 2666type CreateInventoryViewBody struct { 2667 Req *types.CreateInventoryView `xml:"urn:vim25 CreateInventoryView,omitempty"` 2668 Res *types.CreateInventoryViewResponse `xml:"urn:vim25 CreateInventoryViewResponse,omitempty"` 2669 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2670} 2671 2672func (b *CreateInventoryViewBody) Fault() *soap.Fault { return b.Fault_ } 2673 2674func CreateInventoryView(ctx context.Context, r soap.RoundTripper, req *types.CreateInventoryView) (*types.CreateInventoryViewResponse, error) { 2675 var reqBody, resBody CreateInventoryViewBody 2676 2677 reqBody.Req = req 2678 2679 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2680 return nil, err 2681 } 2682 2683 return resBody.Res, nil 2684} 2685 2686type CreateIpPoolBody struct { 2687 Req *types.CreateIpPool `xml:"urn:vim25 CreateIpPool,omitempty"` 2688 Res *types.CreateIpPoolResponse `xml:"urn:vim25 CreateIpPoolResponse,omitempty"` 2689 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2690} 2691 2692func (b *CreateIpPoolBody) Fault() *soap.Fault { return b.Fault_ } 2693 2694func CreateIpPool(ctx context.Context, r soap.RoundTripper, req *types.CreateIpPool) (*types.CreateIpPoolResponse, error) { 2695 var reqBody, resBody CreateIpPoolBody 2696 2697 reqBody.Req = req 2698 2699 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2700 return nil, err 2701 } 2702 2703 return resBody.Res, nil 2704} 2705 2706type CreateListViewBody struct { 2707 Req *types.CreateListView `xml:"urn:vim25 CreateListView,omitempty"` 2708 Res *types.CreateListViewResponse `xml:"urn:vim25 CreateListViewResponse,omitempty"` 2709 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2710} 2711 2712func (b *CreateListViewBody) Fault() *soap.Fault { return b.Fault_ } 2713 2714func CreateListView(ctx context.Context, r soap.RoundTripper, req *types.CreateListView) (*types.CreateListViewResponse, error) { 2715 var reqBody, resBody CreateListViewBody 2716 2717 reqBody.Req = req 2718 2719 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2720 return nil, err 2721 } 2722 2723 return resBody.Res, nil 2724} 2725 2726type CreateListViewFromViewBody struct { 2727 Req *types.CreateListViewFromView `xml:"urn:vim25 CreateListViewFromView,omitempty"` 2728 Res *types.CreateListViewFromViewResponse `xml:"urn:vim25 CreateListViewFromViewResponse,omitempty"` 2729 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2730} 2731 2732func (b *CreateListViewFromViewBody) Fault() *soap.Fault { return b.Fault_ } 2733 2734func CreateListViewFromView(ctx context.Context, r soap.RoundTripper, req *types.CreateListViewFromView) (*types.CreateListViewFromViewResponse, error) { 2735 var reqBody, resBody CreateListViewFromViewBody 2736 2737 reqBody.Req = req 2738 2739 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2740 return nil, err 2741 } 2742 2743 return resBody.Res, nil 2744} 2745 2746type CreateLocalDatastoreBody struct { 2747 Req *types.CreateLocalDatastore `xml:"urn:vim25 CreateLocalDatastore,omitempty"` 2748 Res *types.CreateLocalDatastoreResponse `xml:"urn:vim25 CreateLocalDatastoreResponse,omitempty"` 2749 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2750} 2751 2752func (b *CreateLocalDatastoreBody) Fault() *soap.Fault { return b.Fault_ } 2753 2754func CreateLocalDatastore(ctx context.Context, r soap.RoundTripper, req *types.CreateLocalDatastore) (*types.CreateLocalDatastoreResponse, error) { 2755 var reqBody, resBody CreateLocalDatastoreBody 2756 2757 reqBody.Req = req 2758 2759 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2760 return nil, err 2761 } 2762 2763 return resBody.Res, nil 2764} 2765 2766type CreateNasDatastoreBody struct { 2767 Req *types.CreateNasDatastore `xml:"urn:vim25 CreateNasDatastore,omitempty"` 2768 Res *types.CreateNasDatastoreResponse `xml:"urn:vim25 CreateNasDatastoreResponse,omitempty"` 2769 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2770} 2771 2772func (b *CreateNasDatastoreBody) Fault() *soap.Fault { return b.Fault_ } 2773 2774func CreateNasDatastore(ctx context.Context, r soap.RoundTripper, req *types.CreateNasDatastore) (*types.CreateNasDatastoreResponse, error) { 2775 var reqBody, resBody CreateNasDatastoreBody 2776 2777 reqBody.Req = req 2778 2779 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2780 return nil, err 2781 } 2782 2783 return resBody.Res, nil 2784} 2785 2786type CreateNvdimmNamespace_TaskBody struct { 2787 Req *types.CreateNvdimmNamespace_Task `xml:"urn:vim25 CreateNvdimmNamespace_Task,omitempty"` 2788 Res *types.CreateNvdimmNamespace_TaskResponse `xml:"urn:vim25 CreateNvdimmNamespace_TaskResponse,omitempty"` 2789 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2790} 2791 2792func (b *CreateNvdimmNamespace_TaskBody) Fault() *soap.Fault { return b.Fault_ } 2793 2794func CreateNvdimmNamespace_Task(ctx context.Context, r soap.RoundTripper, req *types.CreateNvdimmNamespace_Task) (*types.CreateNvdimmNamespace_TaskResponse, error) { 2795 var reqBody, resBody CreateNvdimmNamespace_TaskBody 2796 2797 reqBody.Req = req 2798 2799 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2800 return nil, err 2801 } 2802 2803 return resBody.Res, nil 2804} 2805 2806type CreateObjectScheduledTaskBody struct { 2807 Req *types.CreateObjectScheduledTask `xml:"urn:vim25 CreateObjectScheduledTask,omitempty"` 2808 Res *types.CreateObjectScheduledTaskResponse `xml:"urn:vim25 CreateObjectScheduledTaskResponse,omitempty"` 2809 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2810} 2811 2812func (b *CreateObjectScheduledTaskBody) Fault() *soap.Fault { return b.Fault_ } 2813 2814func CreateObjectScheduledTask(ctx context.Context, r soap.RoundTripper, req *types.CreateObjectScheduledTask) (*types.CreateObjectScheduledTaskResponse, error) { 2815 var reqBody, resBody CreateObjectScheduledTaskBody 2816 2817 reqBody.Req = req 2818 2819 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2820 return nil, err 2821 } 2822 2823 return resBody.Res, nil 2824} 2825 2826type CreatePerfIntervalBody struct { 2827 Req *types.CreatePerfInterval `xml:"urn:vim25 CreatePerfInterval,omitempty"` 2828 Res *types.CreatePerfIntervalResponse `xml:"urn:vim25 CreatePerfIntervalResponse,omitempty"` 2829 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2830} 2831 2832func (b *CreatePerfIntervalBody) Fault() *soap.Fault { return b.Fault_ } 2833 2834func CreatePerfInterval(ctx context.Context, r soap.RoundTripper, req *types.CreatePerfInterval) (*types.CreatePerfIntervalResponse, error) { 2835 var reqBody, resBody CreatePerfIntervalBody 2836 2837 reqBody.Req = req 2838 2839 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2840 return nil, err 2841 } 2842 2843 return resBody.Res, nil 2844} 2845 2846type CreateProfileBody struct { 2847 Req *types.CreateProfile `xml:"urn:vim25 CreateProfile,omitempty"` 2848 Res *types.CreateProfileResponse `xml:"urn:vim25 CreateProfileResponse,omitempty"` 2849 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2850} 2851 2852func (b *CreateProfileBody) Fault() *soap.Fault { return b.Fault_ } 2853 2854func CreateProfile(ctx context.Context, r soap.RoundTripper, req *types.CreateProfile) (*types.CreateProfileResponse, error) { 2855 var reqBody, resBody CreateProfileBody 2856 2857 reqBody.Req = req 2858 2859 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2860 return nil, err 2861 } 2862 2863 return resBody.Res, nil 2864} 2865 2866type CreatePropertyCollectorBody struct { 2867 Req *types.CreatePropertyCollector `xml:"urn:vim25 CreatePropertyCollector,omitempty"` 2868 Res *types.CreatePropertyCollectorResponse `xml:"urn:vim25 CreatePropertyCollectorResponse,omitempty"` 2869 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2870} 2871 2872func (b *CreatePropertyCollectorBody) Fault() *soap.Fault { return b.Fault_ } 2873 2874func CreatePropertyCollector(ctx context.Context, r soap.RoundTripper, req *types.CreatePropertyCollector) (*types.CreatePropertyCollectorResponse, error) { 2875 var reqBody, resBody CreatePropertyCollectorBody 2876 2877 reqBody.Req = req 2878 2879 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2880 return nil, err 2881 } 2882 2883 return resBody.Res, nil 2884} 2885 2886type CreateRegistryKeyInGuestBody struct { 2887 Req *types.CreateRegistryKeyInGuest `xml:"urn:vim25 CreateRegistryKeyInGuest,omitempty"` 2888 Res *types.CreateRegistryKeyInGuestResponse `xml:"urn:vim25 CreateRegistryKeyInGuestResponse,omitempty"` 2889 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2890} 2891 2892func (b *CreateRegistryKeyInGuestBody) Fault() *soap.Fault { return b.Fault_ } 2893 2894func CreateRegistryKeyInGuest(ctx context.Context, r soap.RoundTripper, req *types.CreateRegistryKeyInGuest) (*types.CreateRegistryKeyInGuestResponse, error) { 2895 var reqBody, resBody CreateRegistryKeyInGuestBody 2896 2897 reqBody.Req = req 2898 2899 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2900 return nil, err 2901 } 2902 2903 return resBody.Res, nil 2904} 2905 2906type CreateResourcePoolBody struct { 2907 Req *types.CreateResourcePool `xml:"urn:vim25 CreateResourcePool,omitempty"` 2908 Res *types.CreateResourcePoolResponse `xml:"urn:vim25 CreateResourcePoolResponse,omitempty"` 2909 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2910} 2911 2912func (b *CreateResourcePoolBody) Fault() *soap.Fault { return b.Fault_ } 2913 2914func CreateResourcePool(ctx context.Context, r soap.RoundTripper, req *types.CreateResourcePool) (*types.CreateResourcePoolResponse, error) { 2915 var reqBody, resBody CreateResourcePoolBody 2916 2917 reqBody.Req = req 2918 2919 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2920 return nil, err 2921 } 2922 2923 return resBody.Res, nil 2924} 2925 2926type CreateScheduledTaskBody struct { 2927 Req *types.CreateScheduledTask `xml:"urn:vim25 CreateScheduledTask,omitempty"` 2928 Res *types.CreateScheduledTaskResponse `xml:"urn:vim25 CreateScheduledTaskResponse,omitempty"` 2929 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2930} 2931 2932func (b *CreateScheduledTaskBody) Fault() *soap.Fault { return b.Fault_ } 2933 2934func CreateScheduledTask(ctx context.Context, r soap.RoundTripper, req *types.CreateScheduledTask) (*types.CreateScheduledTaskResponse, error) { 2935 var reqBody, resBody CreateScheduledTaskBody 2936 2937 reqBody.Req = req 2938 2939 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2940 return nil, err 2941 } 2942 2943 return resBody.Res, nil 2944} 2945 2946type CreateScreenshot_TaskBody struct { 2947 Req *types.CreateScreenshot_Task `xml:"urn:vim25 CreateScreenshot_Task,omitempty"` 2948 Res *types.CreateScreenshot_TaskResponse `xml:"urn:vim25 CreateScreenshot_TaskResponse,omitempty"` 2949 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2950} 2951 2952func (b *CreateScreenshot_TaskBody) Fault() *soap.Fault { return b.Fault_ } 2953 2954func CreateScreenshot_Task(ctx context.Context, r soap.RoundTripper, req *types.CreateScreenshot_Task) (*types.CreateScreenshot_TaskResponse, error) { 2955 var reqBody, resBody CreateScreenshot_TaskBody 2956 2957 reqBody.Req = req 2958 2959 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2960 return nil, err 2961 } 2962 2963 return resBody.Res, nil 2964} 2965 2966type CreateSecondaryVMEx_TaskBody struct { 2967 Req *types.CreateSecondaryVMEx_Task `xml:"urn:vim25 CreateSecondaryVMEx_Task,omitempty"` 2968 Res *types.CreateSecondaryVMEx_TaskResponse `xml:"urn:vim25 CreateSecondaryVMEx_TaskResponse,omitempty"` 2969 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2970} 2971 2972func (b *CreateSecondaryVMEx_TaskBody) Fault() *soap.Fault { return b.Fault_ } 2973 2974func CreateSecondaryVMEx_Task(ctx context.Context, r soap.RoundTripper, req *types.CreateSecondaryVMEx_Task) (*types.CreateSecondaryVMEx_TaskResponse, error) { 2975 var reqBody, resBody CreateSecondaryVMEx_TaskBody 2976 2977 reqBody.Req = req 2978 2979 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 2980 return nil, err 2981 } 2982 2983 return resBody.Res, nil 2984} 2985 2986type CreateSecondaryVM_TaskBody struct { 2987 Req *types.CreateSecondaryVM_Task `xml:"urn:vim25 CreateSecondaryVM_Task,omitempty"` 2988 Res *types.CreateSecondaryVM_TaskResponse `xml:"urn:vim25 CreateSecondaryVM_TaskResponse,omitempty"` 2989 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 2990} 2991 2992func (b *CreateSecondaryVM_TaskBody) Fault() *soap.Fault { return b.Fault_ } 2993 2994func CreateSecondaryVM_Task(ctx context.Context, r soap.RoundTripper, req *types.CreateSecondaryVM_Task) (*types.CreateSecondaryVM_TaskResponse, error) { 2995 var reqBody, resBody CreateSecondaryVM_TaskBody 2996 2997 reqBody.Req = req 2998 2999 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3000 return nil, err 3001 } 3002 3003 return resBody.Res, nil 3004} 3005 3006type CreateSnapshotEx_TaskBody struct { 3007 Req *types.CreateSnapshotEx_Task `xml:"urn:vim25 CreateSnapshotEx_Task,omitempty"` 3008 Res *types.CreateSnapshotEx_TaskResponse `xml:"urn:vim25 CreateSnapshotEx_TaskResponse,omitempty"` 3009 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3010} 3011 3012func (b *CreateSnapshotEx_TaskBody) Fault() *soap.Fault { return b.Fault_ } 3013 3014func CreateSnapshotEx_Task(ctx context.Context, r soap.RoundTripper, req *types.CreateSnapshotEx_Task) (*types.CreateSnapshotEx_TaskResponse, error) { 3015 var reqBody, resBody CreateSnapshotEx_TaskBody 3016 3017 reqBody.Req = req 3018 3019 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3020 return nil, err 3021 } 3022 3023 return resBody.Res, nil 3024} 3025 3026type CreateSnapshot_TaskBody struct { 3027 Req *types.CreateSnapshot_Task `xml:"urn:vim25 CreateSnapshot_Task,omitempty"` 3028 Res *types.CreateSnapshot_TaskResponse `xml:"urn:vim25 CreateSnapshot_TaskResponse,omitempty"` 3029 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3030} 3031 3032func (b *CreateSnapshot_TaskBody) Fault() *soap.Fault { return b.Fault_ } 3033 3034func CreateSnapshot_Task(ctx context.Context, r soap.RoundTripper, req *types.CreateSnapshot_Task) (*types.CreateSnapshot_TaskResponse, error) { 3035 var reqBody, resBody CreateSnapshot_TaskBody 3036 3037 reqBody.Req = req 3038 3039 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3040 return nil, err 3041 } 3042 3043 return resBody.Res, nil 3044} 3045 3046type CreateStoragePodBody struct { 3047 Req *types.CreateStoragePod `xml:"urn:vim25 CreateStoragePod,omitempty"` 3048 Res *types.CreateStoragePodResponse `xml:"urn:vim25 CreateStoragePodResponse,omitempty"` 3049 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3050} 3051 3052func (b *CreateStoragePodBody) Fault() *soap.Fault { return b.Fault_ } 3053 3054func CreateStoragePod(ctx context.Context, r soap.RoundTripper, req *types.CreateStoragePod) (*types.CreateStoragePodResponse, error) { 3055 var reqBody, resBody CreateStoragePodBody 3056 3057 reqBody.Req = req 3058 3059 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3060 return nil, err 3061 } 3062 3063 return resBody.Res, nil 3064} 3065 3066type CreateTaskBody struct { 3067 Req *types.CreateTask `xml:"urn:vim25 CreateTask,omitempty"` 3068 Res *types.CreateTaskResponse `xml:"urn:vim25 CreateTaskResponse,omitempty"` 3069 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3070} 3071 3072func (b *CreateTaskBody) Fault() *soap.Fault { return b.Fault_ } 3073 3074func CreateTask(ctx context.Context, r soap.RoundTripper, req *types.CreateTask) (*types.CreateTaskResponse, error) { 3075 var reqBody, resBody CreateTaskBody 3076 3077 reqBody.Req = req 3078 3079 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3080 return nil, err 3081 } 3082 3083 return resBody.Res, nil 3084} 3085 3086type CreateTemporaryDirectoryInGuestBody struct { 3087 Req *types.CreateTemporaryDirectoryInGuest `xml:"urn:vim25 CreateTemporaryDirectoryInGuest,omitempty"` 3088 Res *types.CreateTemporaryDirectoryInGuestResponse `xml:"urn:vim25 CreateTemporaryDirectoryInGuestResponse,omitempty"` 3089 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3090} 3091 3092func (b *CreateTemporaryDirectoryInGuestBody) Fault() *soap.Fault { return b.Fault_ } 3093 3094func CreateTemporaryDirectoryInGuest(ctx context.Context, r soap.RoundTripper, req *types.CreateTemporaryDirectoryInGuest) (*types.CreateTemporaryDirectoryInGuestResponse, error) { 3095 var reqBody, resBody CreateTemporaryDirectoryInGuestBody 3096 3097 reqBody.Req = req 3098 3099 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3100 return nil, err 3101 } 3102 3103 return resBody.Res, nil 3104} 3105 3106type CreateTemporaryFileInGuestBody struct { 3107 Req *types.CreateTemporaryFileInGuest `xml:"urn:vim25 CreateTemporaryFileInGuest,omitempty"` 3108 Res *types.CreateTemporaryFileInGuestResponse `xml:"urn:vim25 CreateTemporaryFileInGuestResponse,omitempty"` 3109 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3110} 3111 3112func (b *CreateTemporaryFileInGuestBody) Fault() *soap.Fault { return b.Fault_ } 3113 3114func CreateTemporaryFileInGuest(ctx context.Context, r soap.RoundTripper, req *types.CreateTemporaryFileInGuest) (*types.CreateTemporaryFileInGuestResponse, error) { 3115 var reqBody, resBody CreateTemporaryFileInGuestBody 3116 3117 reqBody.Req = req 3118 3119 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3120 return nil, err 3121 } 3122 3123 return resBody.Res, nil 3124} 3125 3126type CreateUserBody struct { 3127 Req *types.CreateUser `xml:"urn:vim25 CreateUser,omitempty"` 3128 Res *types.CreateUserResponse `xml:"urn:vim25 CreateUserResponse,omitempty"` 3129 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3130} 3131 3132func (b *CreateUserBody) Fault() *soap.Fault { return b.Fault_ } 3133 3134func CreateUser(ctx context.Context, r soap.RoundTripper, req *types.CreateUser) (*types.CreateUserResponse, error) { 3135 var reqBody, resBody CreateUserBody 3136 3137 reqBody.Req = req 3138 3139 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3140 return nil, err 3141 } 3142 3143 return resBody.Res, nil 3144} 3145 3146type CreateVAppBody struct { 3147 Req *types.CreateVApp `xml:"urn:vim25 CreateVApp,omitempty"` 3148 Res *types.CreateVAppResponse `xml:"urn:vim25 CreateVAppResponse,omitempty"` 3149 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3150} 3151 3152func (b *CreateVAppBody) Fault() *soap.Fault { return b.Fault_ } 3153 3154func CreateVApp(ctx context.Context, r soap.RoundTripper, req *types.CreateVApp) (*types.CreateVAppResponse, error) { 3155 var reqBody, resBody CreateVAppBody 3156 3157 reqBody.Req = req 3158 3159 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3160 return nil, err 3161 } 3162 3163 return resBody.Res, nil 3164} 3165 3166type CreateVM_TaskBody struct { 3167 Req *types.CreateVM_Task `xml:"urn:vim25 CreateVM_Task,omitempty"` 3168 Res *types.CreateVM_TaskResponse `xml:"urn:vim25 CreateVM_TaskResponse,omitempty"` 3169 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3170} 3171 3172func (b *CreateVM_TaskBody) Fault() *soap.Fault { return b.Fault_ } 3173 3174func CreateVM_Task(ctx context.Context, r soap.RoundTripper, req *types.CreateVM_Task) (*types.CreateVM_TaskResponse, error) { 3175 var reqBody, resBody CreateVM_TaskBody 3176 3177 reqBody.Req = req 3178 3179 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3180 return nil, err 3181 } 3182 3183 return resBody.Res, nil 3184} 3185 3186type CreateVirtualDisk_TaskBody struct { 3187 Req *types.CreateVirtualDisk_Task `xml:"urn:vim25 CreateVirtualDisk_Task,omitempty"` 3188 Res *types.CreateVirtualDisk_TaskResponse `xml:"urn:vim25 CreateVirtualDisk_TaskResponse,omitempty"` 3189 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3190} 3191 3192func (b *CreateVirtualDisk_TaskBody) Fault() *soap.Fault { return b.Fault_ } 3193 3194func CreateVirtualDisk_Task(ctx context.Context, r soap.RoundTripper, req *types.CreateVirtualDisk_Task) (*types.CreateVirtualDisk_TaskResponse, error) { 3195 var reqBody, resBody CreateVirtualDisk_TaskBody 3196 3197 reqBody.Req = req 3198 3199 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3200 return nil, err 3201 } 3202 3203 return resBody.Res, nil 3204} 3205 3206type CreateVmfsDatastoreBody struct { 3207 Req *types.CreateVmfsDatastore `xml:"urn:vim25 CreateVmfsDatastore,omitempty"` 3208 Res *types.CreateVmfsDatastoreResponse `xml:"urn:vim25 CreateVmfsDatastoreResponse,omitempty"` 3209 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3210} 3211 3212func (b *CreateVmfsDatastoreBody) Fault() *soap.Fault { return b.Fault_ } 3213 3214func CreateVmfsDatastore(ctx context.Context, r soap.RoundTripper, req *types.CreateVmfsDatastore) (*types.CreateVmfsDatastoreResponse, error) { 3215 var reqBody, resBody CreateVmfsDatastoreBody 3216 3217 reqBody.Req = req 3218 3219 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3220 return nil, err 3221 } 3222 3223 return resBody.Res, nil 3224} 3225 3226type CreateVvolDatastoreBody struct { 3227 Req *types.CreateVvolDatastore `xml:"urn:vim25 CreateVvolDatastore,omitempty"` 3228 Res *types.CreateVvolDatastoreResponse `xml:"urn:vim25 CreateVvolDatastoreResponse,omitempty"` 3229 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3230} 3231 3232func (b *CreateVvolDatastoreBody) Fault() *soap.Fault { return b.Fault_ } 3233 3234func CreateVvolDatastore(ctx context.Context, r soap.RoundTripper, req *types.CreateVvolDatastore) (*types.CreateVvolDatastoreResponse, error) { 3235 var reqBody, resBody CreateVvolDatastoreBody 3236 3237 reqBody.Req = req 3238 3239 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3240 return nil, err 3241 } 3242 3243 return resBody.Res, nil 3244} 3245 3246type CryptoManagerHostEnableBody struct { 3247 Req *types.CryptoManagerHostEnable `xml:"urn:vim25 CryptoManagerHostEnable,omitempty"` 3248 Res *types.CryptoManagerHostEnableResponse `xml:"urn:vim25 CryptoManagerHostEnableResponse,omitempty"` 3249 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3250} 3251 3252func (b *CryptoManagerHostEnableBody) Fault() *soap.Fault { return b.Fault_ } 3253 3254func CryptoManagerHostEnable(ctx context.Context, r soap.RoundTripper, req *types.CryptoManagerHostEnable) (*types.CryptoManagerHostEnableResponse, error) { 3255 var reqBody, resBody CryptoManagerHostEnableBody 3256 3257 reqBody.Req = req 3258 3259 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3260 return nil, err 3261 } 3262 3263 return resBody.Res, nil 3264} 3265 3266type CryptoManagerHostPrepareBody struct { 3267 Req *types.CryptoManagerHostPrepare `xml:"urn:vim25 CryptoManagerHostPrepare,omitempty"` 3268 Res *types.CryptoManagerHostPrepareResponse `xml:"urn:vim25 CryptoManagerHostPrepareResponse,omitempty"` 3269 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3270} 3271 3272func (b *CryptoManagerHostPrepareBody) Fault() *soap.Fault { return b.Fault_ } 3273 3274func CryptoManagerHostPrepare(ctx context.Context, r soap.RoundTripper, req *types.CryptoManagerHostPrepare) (*types.CryptoManagerHostPrepareResponse, error) { 3275 var reqBody, resBody CryptoManagerHostPrepareBody 3276 3277 reqBody.Req = req 3278 3279 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3280 return nil, err 3281 } 3282 3283 return resBody.Res, nil 3284} 3285 3286type CryptoUnlock_TaskBody struct { 3287 Req *types.CryptoUnlock_Task `xml:"urn:vim25 CryptoUnlock_Task,omitempty"` 3288 Res *types.CryptoUnlock_TaskResponse `xml:"urn:vim25 CryptoUnlock_TaskResponse,omitempty"` 3289 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3290} 3291 3292func (b *CryptoUnlock_TaskBody) Fault() *soap.Fault { return b.Fault_ } 3293 3294func CryptoUnlock_Task(ctx context.Context, r soap.RoundTripper, req *types.CryptoUnlock_Task) (*types.CryptoUnlock_TaskResponse, error) { 3295 var reqBody, resBody CryptoUnlock_TaskBody 3296 3297 reqBody.Req = req 3298 3299 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3300 return nil, err 3301 } 3302 3303 return resBody.Res, nil 3304} 3305 3306type CurrentTimeBody struct { 3307 Req *types.CurrentTime `xml:"urn:vim25 CurrentTime,omitempty"` 3308 Res *types.CurrentTimeResponse `xml:"urn:vim25 CurrentTimeResponse,omitempty"` 3309 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3310} 3311 3312func (b *CurrentTimeBody) Fault() *soap.Fault { return b.Fault_ } 3313 3314func CurrentTime(ctx context.Context, r soap.RoundTripper, req *types.CurrentTime) (*types.CurrentTimeResponse, error) { 3315 var reqBody, resBody CurrentTimeBody 3316 3317 reqBody.Req = req 3318 3319 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3320 return nil, err 3321 } 3322 3323 return resBody.Res, nil 3324} 3325 3326type CustomizationSpecItemToXmlBody struct { 3327 Req *types.CustomizationSpecItemToXml `xml:"urn:vim25 CustomizationSpecItemToXml,omitempty"` 3328 Res *types.CustomizationSpecItemToXmlResponse `xml:"urn:vim25 CustomizationSpecItemToXmlResponse,omitempty"` 3329 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3330} 3331 3332func (b *CustomizationSpecItemToXmlBody) Fault() *soap.Fault { return b.Fault_ } 3333 3334func CustomizationSpecItemToXml(ctx context.Context, r soap.RoundTripper, req *types.CustomizationSpecItemToXml) (*types.CustomizationSpecItemToXmlResponse, error) { 3335 var reqBody, resBody CustomizationSpecItemToXmlBody 3336 3337 reqBody.Req = req 3338 3339 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3340 return nil, err 3341 } 3342 3343 return resBody.Res, nil 3344} 3345 3346type CustomizeVM_TaskBody struct { 3347 Req *types.CustomizeVM_Task `xml:"urn:vim25 CustomizeVM_Task,omitempty"` 3348 Res *types.CustomizeVM_TaskResponse `xml:"urn:vim25 CustomizeVM_TaskResponse,omitempty"` 3349 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3350} 3351 3352func (b *CustomizeVM_TaskBody) Fault() *soap.Fault { return b.Fault_ } 3353 3354func CustomizeVM_Task(ctx context.Context, r soap.RoundTripper, req *types.CustomizeVM_Task) (*types.CustomizeVM_TaskResponse, error) { 3355 var reqBody, resBody CustomizeVM_TaskBody 3356 3357 reqBody.Req = req 3358 3359 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3360 return nil, err 3361 } 3362 3363 return resBody.Res, nil 3364} 3365 3366type DVPortgroupRollback_TaskBody struct { 3367 Req *types.DVPortgroupRollback_Task `xml:"urn:vim25 DVPortgroupRollback_Task,omitempty"` 3368 Res *types.DVPortgroupRollback_TaskResponse `xml:"urn:vim25 DVPortgroupRollback_TaskResponse,omitempty"` 3369 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3370} 3371 3372func (b *DVPortgroupRollback_TaskBody) Fault() *soap.Fault { return b.Fault_ } 3373 3374func DVPortgroupRollback_Task(ctx context.Context, r soap.RoundTripper, req *types.DVPortgroupRollback_Task) (*types.DVPortgroupRollback_TaskResponse, error) { 3375 var reqBody, resBody DVPortgroupRollback_TaskBody 3376 3377 reqBody.Req = req 3378 3379 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3380 return nil, err 3381 } 3382 3383 return resBody.Res, nil 3384} 3385 3386type DVSManagerExportEntity_TaskBody struct { 3387 Req *types.DVSManagerExportEntity_Task `xml:"urn:vim25 DVSManagerExportEntity_Task,omitempty"` 3388 Res *types.DVSManagerExportEntity_TaskResponse `xml:"urn:vim25 DVSManagerExportEntity_TaskResponse,omitempty"` 3389 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3390} 3391 3392func (b *DVSManagerExportEntity_TaskBody) Fault() *soap.Fault { return b.Fault_ } 3393 3394func DVSManagerExportEntity_Task(ctx context.Context, r soap.RoundTripper, req *types.DVSManagerExportEntity_Task) (*types.DVSManagerExportEntity_TaskResponse, error) { 3395 var reqBody, resBody DVSManagerExportEntity_TaskBody 3396 3397 reqBody.Req = req 3398 3399 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3400 return nil, err 3401 } 3402 3403 return resBody.Res, nil 3404} 3405 3406type DVSManagerImportEntity_TaskBody struct { 3407 Req *types.DVSManagerImportEntity_Task `xml:"urn:vim25 DVSManagerImportEntity_Task,omitempty"` 3408 Res *types.DVSManagerImportEntity_TaskResponse `xml:"urn:vim25 DVSManagerImportEntity_TaskResponse,omitempty"` 3409 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3410} 3411 3412func (b *DVSManagerImportEntity_TaskBody) Fault() *soap.Fault { return b.Fault_ } 3413 3414func DVSManagerImportEntity_Task(ctx context.Context, r soap.RoundTripper, req *types.DVSManagerImportEntity_Task) (*types.DVSManagerImportEntity_TaskResponse, error) { 3415 var reqBody, resBody DVSManagerImportEntity_TaskBody 3416 3417 reqBody.Req = req 3418 3419 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3420 return nil, err 3421 } 3422 3423 return resBody.Res, nil 3424} 3425 3426type DVSManagerLookupDvPortGroupBody struct { 3427 Req *types.DVSManagerLookupDvPortGroup `xml:"urn:vim25 DVSManagerLookupDvPortGroup,omitempty"` 3428 Res *types.DVSManagerLookupDvPortGroupResponse `xml:"urn:vim25 DVSManagerLookupDvPortGroupResponse,omitempty"` 3429 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3430} 3431 3432func (b *DVSManagerLookupDvPortGroupBody) Fault() *soap.Fault { return b.Fault_ } 3433 3434func DVSManagerLookupDvPortGroup(ctx context.Context, r soap.RoundTripper, req *types.DVSManagerLookupDvPortGroup) (*types.DVSManagerLookupDvPortGroupResponse, error) { 3435 var reqBody, resBody DVSManagerLookupDvPortGroupBody 3436 3437 reqBody.Req = req 3438 3439 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3440 return nil, err 3441 } 3442 3443 return resBody.Res, nil 3444} 3445 3446type DVSRollback_TaskBody struct { 3447 Req *types.DVSRollback_Task `xml:"urn:vim25 DVSRollback_Task,omitempty"` 3448 Res *types.DVSRollback_TaskResponse `xml:"urn:vim25 DVSRollback_TaskResponse,omitempty"` 3449 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3450} 3451 3452func (b *DVSRollback_TaskBody) Fault() *soap.Fault { return b.Fault_ } 3453 3454func DVSRollback_Task(ctx context.Context, r soap.RoundTripper, req *types.DVSRollback_Task) (*types.DVSRollback_TaskResponse, error) { 3455 var reqBody, resBody DVSRollback_TaskBody 3456 3457 reqBody.Req = req 3458 3459 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3460 return nil, err 3461 } 3462 3463 return resBody.Res, nil 3464} 3465 3466type DatastoreEnterMaintenanceModeBody struct { 3467 Req *types.DatastoreEnterMaintenanceMode `xml:"urn:vim25 DatastoreEnterMaintenanceMode,omitempty"` 3468 Res *types.DatastoreEnterMaintenanceModeResponse `xml:"urn:vim25 DatastoreEnterMaintenanceModeResponse,omitempty"` 3469 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3470} 3471 3472func (b *DatastoreEnterMaintenanceModeBody) Fault() *soap.Fault { return b.Fault_ } 3473 3474func DatastoreEnterMaintenanceMode(ctx context.Context, r soap.RoundTripper, req *types.DatastoreEnterMaintenanceMode) (*types.DatastoreEnterMaintenanceModeResponse, error) { 3475 var reqBody, resBody DatastoreEnterMaintenanceModeBody 3476 3477 reqBody.Req = req 3478 3479 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3480 return nil, err 3481 } 3482 3483 return resBody.Res, nil 3484} 3485 3486type DatastoreExitMaintenanceMode_TaskBody struct { 3487 Req *types.DatastoreExitMaintenanceMode_Task `xml:"urn:vim25 DatastoreExitMaintenanceMode_Task,omitempty"` 3488 Res *types.DatastoreExitMaintenanceMode_TaskResponse `xml:"urn:vim25 DatastoreExitMaintenanceMode_TaskResponse,omitempty"` 3489 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3490} 3491 3492func (b *DatastoreExitMaintenanceMode_TaskBody) Fault() *soap.Fault { return b.Fault_ } 3493 3494func DatastoreExitMaintenanceMode_Task(ctx context.Context, r soap.RoundTripper, req *types.DatastoreExitMaintenanceMode_Task) (*types.DatastoreExitMaintenanceMode_TaskResponse, error) { 3495 var reqBody, resBody DatastoreExitMaintenanceMode_TaskBody 3496 3497 reqBody.Req = req 3498 3499 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3500 return nil, err 3501 } 3502 3503 return resBody.Res, nil 3504} 3505 3506type DecodeLicenseBody struct { 3507 Req *types.DecodeLicense `xml:"urn:vim25 DecodeLicense,omitempty"` 3508 Res *types.DecodeLicenseResponse `xml:"urn:vim25 DecodeLicenseResponse,omitempty"` 3509 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3510} 3511 3512func (b *DecodeLicenseBody) Fault() *soap.Fault { return b.Fault_ } 3513 3514func DecodeLicense(ctx context.Context, r soap.RoundTripper, req *types.DecodeLicense) (*types.DecodeLicenseResponse, error) { 3515 var reqBody, resBody DecodeLicenseBody 3516 3517 reqBody.Req = req 3518 3519 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3520 return nil, err 3521 } 3522 3523 return resBody.Res, nil 3524} 3525 3526type DefragmentAllDisksBody struct { 3527 Req *types.DefragmentAllDisks `xml:"urn:vim25 DefragmentAllDisks,omitempty"` 3528 Res *types.DefragmentAllDisksResponse `xml:"urn:vim25 DefragmentAllDisksResponse,omitempty"` 3529 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3530} 3531 3532func (b *DefragmentAllDisksBody) Fault() *soap.Fault { return b.Fault_ } 3533 3534func DefragmentAllDisks(ctx context.Context, r soap.RoundTripper, req *types.DefragmentAllDisks) (*types.DefragmentAllDisksResponse, error) { 3535 var reqBody, resBody DefragmentAllDisksBody 3536 3537 reqBody.Req = req 3538 3539 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3540 return nil, err 3541 } 3542 3543 return resBody.Res, nil 3544} 3545 3546type DefragmentVirtualDisk_TaskBody struct { 3547 Req *types.DefragmentVirtualDisk_Task `xml:"urn:vim25 DefragmentVirtualDisk_Task,omitempty"` 3548 Res *types.DefragmentVirtualDisk_TaskResponse `xml:"urn:vim25 DefragmentVirtualDisk_TaskResponse,omitempty"` 3549 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3550} 3551 3552func (b *DefragmentVirtualDisk_TaskBody) Fault() *soap.Fault { return b.Fault_ } 3553 3554func DefragmentVirtualDisk_Task(ctx context.Context, r soap.RoundTripper, req *types.DefragmentVirtualDisk_Task) (*types.DefragmentVirtualDisk_TaskResponse, error) { 3555 var reqBody, resBody DefragmentVirtualDisk_TaskBody 3556 3557 reqBody.Req = req 3558 3559 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3560 return nil, err 3561 } 3562 3563 return resBody.Res, nil 3564} 3565 3566type DeleteCustomizationSpecBody struct { 3567 Req *types.DeleteCustomizationSpec `xml:"urn:vim25 DeleteCustomizationSpec,omitempty"` 3568 Res *types.DeleteCustomizationSpecResponse `xml:"urn:vim25 DeleteCustomizationSpecResponse,omitempty"` 3569 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3570} 3571 3572func (b *DeleteCustomizationSpecBody) Fault() *soap.Fault { return b.Fault_ } 3573 3574func DeleteCustomizationSpec(ctx context.Context, r soap.RoundTripper, req *types.DeleteCustomizationSpec) (*types.DeleteCustomizationSpecResponse, error) { 3575 var reqBody, resBody DeleteCustomizationSpecBody 3576 3577 reqBody.Req = req 3578 3579 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3580 return nil, err 3581 } 3582 3583 return resBody.Res, nil 3584} 3585 3586type DeleteDatastoreFile_TaskBody struct { 3587 Req *types.DeleteDatastoreFile_Task `xml:"urn:vim25 DeleteDatastoreFile_Task,omitempty"` 3588 Res *types.DeleteDatastoreFile_TaskResponse `xml:"urn:vim25 DeleteDatastoreFile_TaskResponse,omitempty"` 3589 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3590} 3591 3592func (b *DeleteDatastoreFile_TaskBody) Fault() *soap.Fault { return b.Fault_ } 3593 3594func DeleteDatastoreFile_Task(ctx context.Context, r soap.RoundTripper, req *types.DeleteDatastoreFile_Task) (*types.DeleteDatastoreFile_TaskResponse, error) { 3595 var reqBody, resBody DeleteDatastoreFile_TaskBody 3596 3597 reqBody.Req = req 3598 3599 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3600 return nil, err 3601 } 3602 3603 return resBody.Res, nil 3604} 3605 3606type DeleteDirectoryBody struct { 3607 Req *types.DeleteDirectory `xml:"urn:vim25 DeleteDirectory,omitempty"` 3608 Res *types.DeleteDirectoryResponse `xml:"urn:vim25 DeleteDirectoryResponse,omitempty"` 3609 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3610} 3611 3612func (b *DeleteDirectoryBody) Fault() *soap.Fault { return b.Fault_ } 3613 3614func DeleteDirectory(ctx context.Context, r soap.RoundTripper, req *types.DeleteDirectory) (*types.DeleteDirectoryResponse, error) { 3615 var reqBody, resBody DeleteDirectoryBody 3616 3617 reqBody.Req = req 3618 3619 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3620 return nil, err 3621 } 3622 3623 return resBody.Res, nil 3624} 3625 3626type DeleteDirectoryInGuestBody struct { 3627 Req *types.DeleteDirectoryInGuest `xml:"urn:vim25 DeleteDirectoryInGuest,omitempty"` 3628 Res *types.DeleteDirectoryInGuestResponse `xml:"urn:vim25 DeleteDirectoryInGuestResponse,omitempty"` 3629 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3630} 3631 3632func (b *DeleteDirectoryInGuestBody) Fault() *soap.Fault { return b.Fault_ } 3633 3634func DeleteDirectoryInGuest(ctx context.Context, r soap.RoundTripper, req *types.DeleteDirectoryInGuest) (*types.DeleteDirectoryInGuestResponse, error) { 3635 var reqBody, resBody DeleteDirectoryInGuestBody 3636 3637 reqBody.Req = req 3638 3639 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3640 return nil, err 3641 } 3642 3643 return resBody.Res, nil 3644} 3645 3646type DeleteFileBody struct { 3647 Req *types.DeleteFile `xml:"urn:vim25 DeleteFile,omitempty"` 3648 Res *types.DeleteFileResponse `xml:"urn:vim25 DeleteFileResponse,omitempty"` 3649 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3650} 3651 3652func (b *DeleteFileBody) Fault() *soap.Fault { return b.Fault_ } 3653 3654func DeleteFile(ctx context.Context, r soap.RoundTripper, req *types.DeleteFile) (*types.DeleteFileResponse, error) { 3655 var reqBody, resBody DeleteFileBody 3656 3657 reqBody.Req = req 3658 3659 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3660 return nil, err 3661 } 3662 3663 return resBody.Res, nil 3664} 3665 3666type DeleteFileInGuestBody struct { 3667 Req *types.DeleteFileInGuest `xml:"urn:vim25 DeleteFileInGuest,omitempty"` 3668 Res *types.DeleteFileInGuestResponse `xml:"urn:vim25 DeleteFileInGuestResponse,omitempty"` 3669 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3670} 3671 3672func (b *DeleteFileInGuestBody) Fault() *soap.Fault { return b.Fault_ } 3673 3674func DeleteFileInGuest(ctx context.Context, r soap.RoundTripper, req *types.DeleteFileInGuest) (*types.DeleteFileInGuestResponse, error) { 3675 var reqBody, resBody DeleteFileInGuestBody 3676 3677 reqBody.Req = req 3678 3679 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3680 return nil, err 3681 } 3682 3683 return resBody.Res, nil 3684} 3685 3686type DeleteHostSpecificationBody struct { 3687 Req *types.DeleteHostSpecification `xml:"urn:vim25 DeleteHostSpecification,omitempty"` 3688 Res *types.DeleteHostSpecificationResponse `xml:"urn:vim25 DeleteHostSpecificationResponse,omitempty"` 3689 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3690} 3691 3692func (b *DeleteHostSpecificationBody) Fault() *soap.Fault { return b.Fault_ } 3693 3694func DeleteHostSpecification(ctx context.Context, r soap.RoundTripper, req *types.DeleteHostSpecification) (*types.DeleteHostSpecificationResponse, error) { 3695 var reqBody, resBody DeleteHostSpecificationBody 3696 3697 reqBody.Req = req 3698 3699 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3700 return nil, err 3701 } 3702 3703 return resBody.Res, nil 3704} 3705 3706type DeleteHostSubSpecificationBody struct { 3707 Req *types.DeleteHostSubSpecification `xml:"urn:vim25 DeleteHostSubSpecification,omitempty"` 3708 Res *types.DeleteHostSubSpecificationResponse `xml:"urn:vim25 DeleteHostSubSpecificationResponse,omitempty"` 3709 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3710} 3711 3712func (b *DeleteHostSubSpecificationBody) Fault() *soap.Fault { return b.Fault_ } 3713 3714func DeleteHostSubSpecification(ctx context.Context, r soap.RoundTripper, req *types.DeleteHostSubSpecification) (*types.DeleteHostSubSpecificationResponse, error) { 3715 var reqBody, resBody DeleteHostSubSpecificationBody 3716 3717 reqBody.Req = req 3718 3719 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3720 return nil, err 3721 } 3722 3723 return resBody.Res, nil 3724} 3725 3726type DeleteNvdimmBlockNamespaces_TaskBody struct { 3727 Req *types.DeleteNvdimmBlockNamespaces_Task `xml:"urn:vim25 DeleteNvdimmBlockNamespaces_Task,omitempty"` 3728 Res *types.DeleteNvdimmBlockNamespaces_TaskResponse `xml:"urn:vim25 DeleteNvdimmBlockNamespaces_TaskResponse,omitempty"` 3729 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3730} 3731 3732func (b *DeleteNvdimmBlockNamespaces_TaskBody) Fault() *soap.Fault { return b.Fault_ } 3733 3734func DeleteNvdimmBlockNamespaces_Task(ctx context.Context, r soap.RoundTripper, req *types.DeleteNvdimmBlockNamespaces_Task) (*types.DeleteNvdimmBlockNamespaces_TaskResponse, error) { 3735 var reqBody, resBody DeleteNvdimmBlockNamespaces_TaskBody 3736 3737 reqBody.Req = req 3738 3739 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3740 return nil, err 3741 } 3742 3743 return resBody.Res, nil 3744} 3745 3746type DeleteNvdimmNamespace_TaskBody struct { 3747 Req *types.DeleteNvdimmNamespace_Task `xml:"urn:vim25 DeleteNvdimmNamespace_Task,omitempty"` 3748 Res *types.DeleteNvdimmNamespace_TaskResponse `xml:"urn:vim25 DeleteNvdimmNamespace_TaskResponse,omitempty"` 3749 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3750} 3751 3752func (b *DeleteNvdimmNamespace_TaskBody) Fault() *soap.Fault { return b.Fault_ } 3753 3754func DeleteNvdimmNamespace_Task(ctx context.Context, r soap.RoundTripper, req *types.DeleteNvdimmNamespace_Task) (*types.DeleteNvdimmNamespace_TaskResponse, error) { 3755 var reqBody, resBody DeleteNvdimmNamespace_TaskBody 3756 3757 reqBody.Req = req 3758 3759 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3760 return nil, err 3761 } 3762 3763 return resBody.Res, nil 3764} 3765 3766type DeleteRegistryKeyInGuestBody struct { 3767 Req *types.DeleteRegistryKeyInGuest `xml:"urn:vim25 DeleteRegistryKeyInGuest,omitempty"` 3768 Res *types.DeleteRegistryKeyInGuestResponse `xml:"urn:vim25 DeleteRegistryKeyInGuestResponse,omitempty"` 3769 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3770} 3771 3772func (b *DeleteRegistryKeyInGuestBody) Fault() *soap.Fault { return b.Fault_ } 3773 3774func DeleteRegistryKeyInGuest(ctx context.Context, r soap.RoundTripper, req *types.DeleteRegistryKeyInGuest) (*types.DeleteRegistryKeyInGuestResponse, error) { 3775 var reqBody, resBody DeleteRegistryKeyInGuestBody 3776 3777 reqBody.Req = req 3778 3779 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3780 return nil, err 3781 } 3782 3783 return resBody.Res, nil 3784} 3785 3786type DeleteRegistryValueInGuestBody struct { 3787 Req *types.DeleteRegistryValueInGuest `xml:"urn:vim25 DeleteRegistryValueInGuest,omitempty"` 3788 Res *types.DeleteRegistryValueInGuestResponse `xml:"urn:vim25 DeleteRegistryValueInGuestResponse,omitempty"` 3789 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3790} 3791 3792func (b *DeleteRegistryValueInGuestBody) Fault() *soap.Fault { return b.Fault_ } 3793 3794func DeleteRegistryValueInGuest(ctx context.Context, r soap.RoundTripper, req *types.DeleteRegistryValueInGuest) (*types.DeleteRegistryValueInGuestResponse, error) { 3795 var reqBody, resBody DeleteRegistryValueInGuestBody 3796 3797 reqBody.Req = req 3798 3799 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3800 return nil, err 3801 } 3802 3803 return resBody.Res, nil 3804} 3805 3806type DeleteScsiLunStateBody struct { 3807 Req *types.DeleteScsiLunState `xml:"urn:vim25 DeleteScsiLunState,omitempty"` 3808 Res *types.DeleteScsiLunStateResponse `xml:"urn:vim25 DeleteScsiLunStateResponse,omitempty"` 3809 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3810} 3811 3812func (b *DeleteScsiLunStateBody) Fault() *soap.Fault { return b.Fault_ } 3813 3814func DeleteScsiLunState(ctx context.Context, r soap.RoundTripper, req *types.DeleteScsiLunState) (*types.DeleteScsiLunStateResponse, error) { 3815 var reqBody, resBody DeleteScsiLunStateBody 3816 3817 reqBody.Req = req 3818 3819 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3820 return nil, err 3821 } 3822 3823 return resBody.Res, nil 3824} 3825 3826type DeleteSnapshot_TaskBody struct { 3827 Req *types.DeleteSnapshot_Task `xml:"urn:vim25 DeleteSnapshot_Task,omitempty"` 3828 Res *types.DeleteSnapshot_TaskResponse `xml:"urn:vim25 DeleteSnapshot_TaskResponse,omitempty"` 3829 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3830} 3831 3832func (b *DeleteSnapshot_TaskBody) Fault() *soap.Fault { return b.Fault_ } 3833 3834func DeleteSnapshot_Task(ctx context.Context, r soap.RoundTripper, req *types.DeleteSnapshot_Task) (*types.DeleteSnapshot_TaskResponse, error) { 3835 var reqBody, resBody DeleteSnapshot_TaskBody 3836 3837 reqBody.Req = req 3838 3839 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3840 return nil, err 3841 } 3842 3843 return resBody.Res, nil 3844} 3845 3846type DeleteVStorageObject_TaskBody struct { 3847 Req *types.DeleteVStorageObject_Task `xml:"urn:vim25 DeleteVStorageObject_Task,omitempty"` 3848 Res *types.DeleteVStorageObject_TaskResponse `xml:"urn:vim25 DeleteVStorageObject_TaskResponse,omitempty"` 3849 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3850} 3851 3852func (b *DeleteVStorageObject_TaskBody) Fault() *soap.Fault { return b.Fault_ } 3853 3854func DeleteVStorageObject_Task(ctx context.Context, r soap.RoundTripper, req *types.DeleteVStorageObject_Task) (*types.DeleteVStorageObject_TaskResponse, error) { 3855 var reqBody, resBody DeleteVStorageObject_TaskBody 3856 3857 reqBody.Req = req 3858 3859 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3860 return nil, err 3861 } 3862 3863 return resBody.Res, nil 3864} 3865 3866type DeleteVffsVolumeStateBody struct { 3867 Req *types.DeleteVffsVolumeState `xml:"urn:vim25 DeleteVffsVolumeState,omitempty"` 3868 Res *types.DeleteVffsVolumeStateResponse `xml:"urn:vim25 DeleteVffsVolumeStateResponse,omitempty"` 3869 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3870} 3871 3872func (b *DeleteVffsVolumeStateBody) Fault() *soap.Fault { return b.Fault_ } 3873 3874func DeleteVffsVolumeState(ctx context.Context, r soap.RoundTripper, req *types.DeleteVffsVolumeState) (*types.DeleteVffsVolumeStateResponse, error) { 3875 var reqBody, resBody DeleteVffsVolumeStateBody 3876 3877 reqBody.Req = req 3878 3879 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3880 return nil, err 3881 } 3882 3883 return resBody.Res, nil 3884} 3885 3886type DeleteVirtualDisk_TaskBody struct { 3887 Req *types.DeleteVirtualDisk_Task `xml:"urn:vim25 DeleteVirtualDisk_Task,omitempty"` 3888 Res *types.DeleteVirtualDisk_TaskResponse `xml:"urn:vim25 DeleteVirtualDisk_TaskResponse,omitempty"` 3889 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3890} 3891 3892func (b *DeleteVirtualDisk_TaskBody) Fault() *soap.Fault { return b.Fault_ } 3893 3894func DeleteVirtualDisk_Task(ctx context.Context, r soap.RoundTripper, req *types.DeleteVirtualDisk_Task) (*types.DeleteVirtualDisk_TaskResponse, error) { 3895 var reqBody, resBody DeleteVirtualDisk_TaskBody 3896 3897 reqBody.Req = req 3898 3899 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3900 return nil, err 3901 } 3902 3903 return resBody.Res, nil 3904} 3905 3906type DeleteVmfsVolumeStateBody struct { 3907 Req *types.DeleteVmfsVolumeState `xml:"urn:vim25 DeleteVmfsVolumeState,omitempty"` 3908 Res *types.DeleteVmfsVolumeStateResponse `xml:"urn:vim25 DeleteVmfsVolumeStateResponse,omitempty"` 3909 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3910} 3911 3912func (b *DeleteVmfsVolumeStateBody) Fault() *soap.Fault { return b.Fault_ } 3913 3914func DeleteVmfsVolumeState(ctx context.Context, r soap.RoundTripper, req *types.DeleteVmfsVolumeState) (*types.DeleteVmfsVolumeStateResponse, error) { 3915 var reqBody, resBody DeleteVmfsVolumeStateBody 3916 3917 reqBody.Req = req 3918 3919 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3920 return nil, err 3921 } 3922 3923 return resBody.Res, nil 3924} 3925 3926type DeleteVsanObjectsBody struct { 3927 Req *types.DeleteVsanObjects `xml:"urn:vim25 DeleteVsanObjects,omitempty"` 3928 Res *types.DeleteVsanObjectsResponse `xml:"urn:vim25 DeleteVsanObjectsResponse,omitempty"` 3929 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3930} 3931 3932func (b *DeleteVsanObjectsBody) Fault() *soap.Fault { return b.Fault_ } 3933 3934func DeleteVsanObjects(ctx context.Context, r soap.RoundTripper, req *types.DeleteVsanObjects) (*types.DeleteVsanObjectsResponse, error) { 3935 var reqBody, resBody DeleteVsanObjectsBody 3936 3937 reqBody.Req = req 3938 3939 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3940 return nil, err 3941 } 3942 3943 return resBody.Res, nil 3944} 3945 3946type DeselectVnicBody struct { 3947 Req *types.DeselectVnic `xml:"urn:vim25 DeselectVnic,omitempty"` 3948 Res *types.DeselectVnicResponse `xml:"urn:vim25 DeselectVnicResponse,omitempty"` 3949 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3950} 3951 3952func (b *DeselectVnicBody) Fault() *soap.Fault { return b.Fault_ } 3953 3954func DeselectVnic(ctx context.Context, r soap.RoundTripper, req *types.DeselectVnic) (*types.DeselectVnicResponse, error) { 3955 var reqBody, resBody DeselectVnicBody 3956 3957 reqBody.Req = req 3958 3959 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3960 return nil, err 3961 } 3962 3963 return resBody.Res, nil 3964} 3965 3966type DeselectVnicForNicTypeBody struct { 3967 Req *types.DeselectVnicForNicType `xml:"urn:vim25 DeselectVnicForNicType,omitempty"` 3968 Res *types.DeselectVnicForNicTypeResponse `xml:"urn:vim25 DeselectVnicForNicTypeResponse,omitempty"` 3969 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3970} 3971 3972func (b *DeselectVnicForNicTypeBody) Fault() *soap.Fault { return b.Fault_ } 3973 3974func DeselectVnicForNicType(ctx context.Context, r soap.RoundTripper, req *types.DeselectVnicForNicType) (*types.DeselectVnicForNicTypeResponse, error) { 3975 var reqBody, resBody DeselectVnicForNicTypeBody 3976 3977 reqBody.Req = req 3978 3979 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 3980 return nil, err 3981 } 3982 3983 return resBody.Res, nil 3984} 3985 3986type DestroyChildrenBody struct { 3987 Req *types.DestroyChildren `xml:"urn:vim25 DestroyChildren,omitempty"` 3988 Res *types.DestroyChildrenResponse `xml:"urn:vim25 DestroyChildrenResponse,omitempty"` 3989 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 3990} 3991 3992func (b *DestroyChildrenBody) Fault() *soap.Fault { return b.Fault_ } 3993 3994func DestroyChildren(ctx context.Context, r soap.RoundTripper, req *types.DestroyChildren) (*types.DestroyChildrenResponse, error) { 3995 var reqBody, resBody DestroyChildrenBody 3996 3997 reqBody.Req = req 3998 3999 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4000 return nil, err 4001 } 4002 4003 return resBody.Res, nil 4004} 4005 4006type DestroyCollectorBody struct { 4007 Req *types.DestroyCollector `xml:"urn:vim25 DestroyCollector,omitempty"` 4008 Res *types.DestroyCollectorResponse `xml:"urn:vim25 DestroyCollectorResponse,omitempty"` 4009 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4010} 4011 4012func (b *DestroyCollectorBody) Fault() *soap.Fault { return b.Fault_ } 4013 4014func DestroyCollector(ctx context.Context, r soap.RoundTripper, req *types.DestroyCollector) (*types.DestroyCollectorResponse, error) { 4015 var reqBody, resBody DestroyCollectorBody 4016 4017 reqBody.Req = req 4018 4019 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4020 return nil, err 4021 } 4022 4023 return resBody.Res, nil 4024} 4025 4026type DestroyDatastoreBody struct { 4027 Req *types.DestroyDatastore `xml:"urn:vim25 DestroyDatastore,omitempty"` 4028 Res *types.DestroyDatastoreResponse `xml:"urn:vim25 DestroyDatastoreResponse,omitempty"` 4029 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4030} 4031 4032func (b *DestroyDatastoreBody) Fault() *soap.Fault { return b.Fault_ } 4033 4034func DestroyDatastore(ctx context.Context, r soap.RoundTripper, req *types.DestroyDatastore) (*types.DestroyDatastoreResponse, error) { 4035 var reqBody, resBody DestroyDatastoreBody 4036 4037 reqBody.Req = req 4038 4039 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4040 return nil, err 4041 } 4042 4043 return resBody.Res, nil 4044} 4045 4046type DestroyIpPoolBody struct { 4047 Req *types.DestroyIpPool `xml:"urn:vim25 DestroyIpPool,omitempty"` 4048 Res *types.DestroyIpPoolResponse `xml:"urn:vim25 DestroyIpPoolResponse,omitempty"` 4049 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4050} 4051 4052func (b *DestroyIpPoolBody) Fault() *soap.Fault { return b.Fault_ } 4053 4054func DestroyIpPool(ctx context.Context, r soap.RoundTripper, req *types.DestroyIpPool) (*types.DestroyIpPoolResponse, error) { 4055 var reqBody, resBody DestroyIpPoolBody 4056 4057 reqBody.Req = req 4058 4059 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4060 return nil, err 4061 } 4062 4063 return resBody.Res, nil 4064} 4065 4066type DestroyNetworkBody struct { 4067 Req *types.DestroyNetwork `xml:"urn:vim25 DestroyNetwork,omitempty"` 4068 Res *types.DestroyNetworkResponse `xml:"urn:vim25 DestroyNetworkResponse,omitempty"` 4069 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4070} 4071 4072func (b *DestroyNetworkBody) Fault() *soap.Fault { return b.Fault_ } 4073 4074func DestroyNetwork(ctx context.Context, r soap.RoundTripper, req *types.DestroyNetwork) (*types.DestroyNetworkResponse, error) { 4075 var reqBody, resBody DestroyNetworkBody 4076 4077 reqBody.Req = req 4078 4079 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4080 return nil, err 4081 } 4082 4083 return resBody.Res, nil 4084} 4085 4086type DestroyProfileBody struct { 4087 Req *types.DestroyProfile `xml:"urn:vim25 DestroyProfile,omitempty"` 4088 Res *types.DestroyProfileResponse `xml:"urn:vim25 DestroyProfileResponse,omitempty"` 4089 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4090} 4091 4092func (b *DestroyProfileBody) Fault() *soap.Fault { return b.Fault_ } 4093 4094func DestroyProfile(ctx context.Context, r soap.RoundTripper, req *types.DestroyProfile) (*types.DestroyProfileResponse, error) { 4095 var reqBody, resBody DestroyProfileBody 4096 4097 reqBody.Req = req 4098 4099 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4100 return nil, err 4101 } 4102 4103 return resBody.Res, nil 4104} 4105 4106type DestroyPropertyCollectorBody struct { 4107 Req *types.DestroyPropertyCollector `xml:"urn:vim25 DestroyPropertyCollector,omitempty"` 4108 Res *types.DestroyPropertyCollectorResponse `xml:"urn:vim25 DestroyPropertyCollectorResponse,omitempty"` 4109 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4110} 4111 4112func (b *DestroyPropertyCollectorBody) Fault() *soap.Fault { return b.Fault_ } 4113 4114func DestroyPropertyCollector(ctx context.Context, r soap.RoundTripper, req *types.DestroyPropertyCollector) (*types.DestroyPropertyCollectorResponse, error) { 4115 var reqBody, resBody DestroyPropertyCollectorBody 4116 4117 reqBody.Req = req 4118 4119 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4120 return nil, err 4121 } 4122 4123 return resBody.Res, nil 4124} 4125 4126type DestroyPropertyFilterBody struct { 4127 Req *types.DestroyPropertyFilter `xml:"urn:vim25 DestroyPropertyFilter,omitempty"` 4128 Res *types.DestroyPropertyFilterResponse `xml:"urn:vim25 DestroyPropertyFilterResponse,omitempty"` 4129 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4130} 4131 4132func (b *DestroyPropertyFilterBody) Fault() *soap.Fault { return b.Fault_ } 4133 4134func DestroyPropertyFilter(ctx context.Context, r soap.RoundTripper, req *types.DestroyPropertyFilter) (*types.DestroyPropertyFilterResponse, error) { 4135 var reqBody, resBody DestroyPropertyFilterBody 4136 4137 reqBody.Req = req 4138 4139 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4140 return nil, err 4141 } 4142 4143 return resBody.Res, nil 4144} 4145 4146type DestroyVffsBody struct { 4147 Req *types.DestroyVffs `xml:"urn:vim25 DestroyVffs,omitempty"` 4148 Res *types.DestroyVffsResponse `xml:"urn:vim25 DestroyVffsResponse,omitempty"` 4149 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4150} 4151 4152func (b *DestroyVffsBody) Fault() *soap.Fault { return b.Fault_ } 4153 4154func DestroyVffs(ctx context.Context, r soap.RoundTripper, req *types.DestroyVffs) (*types.DestroyVffsResponse, error) { 4155 var reqBody, resBody DestroyVffsBody 4156 4157 reqBody.Req = req 4158 4159 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4160 return nil, err 4161 } 4162 4163 return resBody.Res, nil 4164} 4165 4166type DestroyViewBody struct { 4167 Req *types.DestroyView `xml:"urn:vim25 DestroyView,omitempty"` 4168 Res *types.DestroyViewResponse `xml:"urn:vim25 DestroyViewResponse,omitempty"` 4169 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4170} 4171 4172func (b *DestroyViewBody) Fault() *soap.Fault { return b.Fault_ } 4173 4174func DestroyView(ctx context.Context, r soap.RoundTripper, req *types.DestroyView) (*types.DestroyViewResponse, error) { 4175 var reqBody, resBody DestroyViewBody 4176 4177 reqBody.Req = req 4178 4179 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4180 return nil, err 4181 } 4182 4183 return resBody.Res, nil 4184} 4185 4186type Destroy_TaskBody struct { 4187 Req *types.Destroy_Task `xml:"urn:vim25 Destroy_Task,omitempty"` 4188 Res *types.Destroy_TaskResponse `xml:"urn:vim25 Destroy_TaskResponse,omitempty"` 4189 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4190} 4191 4192func (b *Destroy_TaskBody) Fault() *soap.Fault { return b.Fault_ } 4193 4194func Destroy_Task(ctx context.Context, r soap.RoundTripper, req *types.Destroy_Task) (*types.Destroy_TaskResponse, error) { 4195 var reqBody, resBody Destroy_TaskBody 4196 4197 reqBody.Req = req 4198 4199 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4200 return nil, err 4201 } 4202 4203 return resBody.Res, nil 4204} 4205 4206type DetachDisk_TaskBody struct { 4207 Req *types.DetachDisk_Task `xml:"urn:vim25 DetachDisk_Task,omitempty"` 4208 Res *types.DetachDisk_TaskResponse `xml:"urn:vim25 DetachDisk_TaskResponse,omitempty"` 4209 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4210} 4211 4212func (b *DetachDisk_TaskBody) Fault() *soap.Fault { return b.Fault_ } 4213 4214func DetachDisk_Task(ctx context.Context, r soap.RoundTripper, req *types.DetachDisk_Task) (*types.DetachDisk_TaskResponse, error) { 4215 var reqBody, resBody DetachDisk_TaskBody 4216 4217 reqBody.Req = req 4218 4219 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4220 return nil, err 4221 } 4222 4223 return resBody.Res, nil 4224} 4225 4226type DetachScsiLunBody struct { 4227 Req *types.DetachScsiLun `xml:"urn:vim25 DetachScsiLun,omitempty"` 4228 Res *types.DetachScsiLunResponse `xml:"urn:vim25 DetachScsiLunResponse,omitempty"` 4229 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4230} 4231 4232func (b *DetachScsiLunBody) Fault() *soap.Fault { return b.Fault_ } 4233 4234func DetachScsiLun(ctx context.Context, r soap.RoundTripper, req *types.DetachScsiLun) (*types.DetachScsiLunResponse, error) { 4235 var reqBody, resBody DetachScsiLunBody 4236 4237 reqBody.Req = req 4238 4239 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4240 return nil, err 4241 } 4242 4243 return resBody.Res, nil 4244} 4245 4246type DetachScsiLunEx_TaskBody struct { 4247 Req *types.DetachScsiLunEx_Task `xml:"urn:vim25 DetachScsiLunEx_Task,omitempty"` 4248 Res *types.DetachScsiLunEx_TaskResponse `xml:"urn:vim25 DetachScsiLunEx_TaskResponse,omitempty"` 4249 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4250} 4251 4252func (b *DetachScsiLunEx_TaskBody) Fault() *soap.Fault { return b.Fault_ } 4253 4254func DetachScsiLunEx_Task(ctx context.Context, r soap.RoundTripper, req *types.DetachScsiLunEx_Task) (*types.DetachScsiLunEx_TaskResponse, error) { 4255 var reqBody, resBody DetachScsiLunEx_TaskBody 4256 4257 reqBody.Req = req 4258 4259 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4260 return nil, err 4261 } 4262 4263 return resBody.Res, nil 4264} 4265 4266type DetachTagFromVStorageObjectBody struct { 4267 Req *types.DetachTagFromVStorageObject `xml:"urn:vim25 DetachTagFromVStorageObject,omitempty"` 4268 Res *types.DetachTagFromVStorageObjectResponse `xml:"urn:vim25 DetachTagFromVStorageObjectResponse,omitempty"` 4269 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4270} 4271 4272func (b *DetachTagFromVStorageObjectBody) Fault() *soap.Fault { return b.Fault_ } 4273 4274func DetachTagFromVStorageObject(ctx context.Context, r soap.RoundTripper, req *types.DetachTagFromVStorageObject) (*types.DetachTagFromVStorageObjectResponse, error) { 4275 var reqBody, resBody DetachTagFromVStorageObjectBody 4276 4277 reqBody.Req = req 4278 4279 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4280 return nil, err 4281 } 4282 4283 return resBody.Res, nil 4284} 4285 4286type DisableEvcMode_TaskBody struct { 4287 Req *types.DisableEvcMode_Task `xml:"urn:vim25 DisableEvcMode_Task,omitempty"` 4288 Res *types.DisableEvcMode_TaskResponse `xml:"urn:vim25 DisableEvcMode_TaskResponse,omitempty"` 4289 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4290} 4291 4292func (b *DisableEvcMode_TaskBody) Fault() *soap.Fault { return b.Fault_ } 4293 4294func DisableEvcMode_Task(ctx context.Context, r soap.RoundTripper, req *types.DisableEvcMode_Task) (*types.DisableEvcMode_TaskResponse, error) { 4295 var reqBody, resBody DisableEvcMode_TaskBody 4296 4297 reqBody.Req = req 4298 4299 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4300 return nil, err 4301 } 4302 4303 return resBody.Res, nil 4304} 4305 4306type DisableFeatureBody struct { 4307 Req *types.DisableFeature `xml:"urn:vim25 DisableFeature,omitempty"` 4308 Res *types.DisableFeatureResponse `xml:"urn:vim25 DisableFeatureResponse,omitempty"` 4309 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4310} 4311 4312func (b *DisableFeatureBody) Fault() *soap.Fault { return b.Fault_ } 4313 4314func DisableFeature(ctx context.Context, r soap.RoundTripper, req *types.DisableFeature) (*types.DisableFeatureResponse, error) { 4315 var reqBody, resBody DisableFeatureBody 4316 4317 reqBody.Req = req 4318 4319 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4320 return nil, err 4321 } 4322 4323 return resBody.Res, nil 4324} 4325 4326type DisableHyperThreadingBody struct { 4327 Req *types.DisableHyperThreading `xml:"urn:vim25 DisableHyperThreading,omitempty"` 4328 Res *types.DisableHyperThreadingResponse `xml:"urn:vim25 DisableHyperThreadingResponse,omitempty"` 4329 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4330} 4331 4332func (b *DisableHyperThreadingBody) Fault() *soap.Fault { return b.Fault_ } 4333 4334func DisableHyperThreading(ctx context.Context, r soap.RoundTripper, req *types.DisableHyperThreading) (*types.DisableHyperThreadingResponse, error) { 4335 var reqBody, resBody DisableHyperThreadingBody 4336 4337 reqBody.Req = req 4338 4339 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4340 return nil, err 4341 } 4342 4343 return resBody.Res, nil 4344} 4345 4346type DisableMultipathPathBody struct { 4347 Req *types.DisableMultipathPath `xml:"urn:vim25 DisableMultipathPath,omitempty"` 4348 Res *types.DisableMultipathPathResponse `xml:"urn:vim25 DisableMultipathPathResponse,omitempty"` 4349 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4350} 4351 4352func (b *DisableMultipathPathBody) Fault() *soap.Fault { return b.Fault_ } 4353 4354func DisableMultipathPath(ctx context.Context, r soap.RoundTripper, req *types.DisableMultipathPath) (*types.DisableMultipathPathResponse, error) { 4355 var reqBody, resBody DisableMultipathPathBody 4356 4357 reqBody.Req = req 4358 4359 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4360 return nil, err 4361 } 4362 4363 return resBody.Res, nil 4364} 4365 4366type DisableRulesetBody struct { 4367 Req *types.DisableRuleset `xml:"urn:vim25 DisableRuleset,omitempty"` 4368 Res *types.DisableRulesetResponse `xml:"urn:vim25 DisableRulesetResponse,omitempty"` 4369 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4370} 4371 4372func (b *DisableRulesetBody) Fault() *soap.Fault { return b.Fault_ } 4373 4374func DisableRuleset(ctx context.Context, r soap.RoundTripper, req *types.DisableRuleset) (*types.DisableRulesetResponse, error) { 4375 var reqBody, resBody DisableRulesetBody 4376 4377 reqBody.Req = req 4378 4379 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4380 return nil, err 4381 } 4382 4383 return resBody.Res, nil 4384} 4385 4386type DisableSecondaryVM_TaskBody struct { 4387 Req *types.DisableSecondaryVM_Task `xml:"urn:vim25 DisableSecondaryVM_Task,omitempty"` 4388 Res *types.DisableSecondaryVM_TaskResponse `xml:"urn:vim25 DisableSecondaryVM_TaskResponse,omitempty"` 4389 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4390} 4391 4392func (b *DisableSecondaryVM_TaskBody) Fault() *soap.Fault { return b.Fault_ } 4393 4394func DisableSecondaryVM_Task(ctx context.Context, r soap.RoundTripper, req *types.DisableSecondaryVM_Task) (*types.DisableSecondaryVM_TaskResponse, error) { 4395 var reqBody, resBody DisableSecondaryVM_TaskBody 4396 4397 reqBody.Req = req 4398 4399 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4400 return nil, err 4401 } 4402 4403 return resBody.Res, nil 4404} 4405 4406type DisableSmartCardAuthenticationBody struct { 4407 Req *types.DisableSmartCardAuthentication `xml:"urn:vim25 DisableSmartCardAuthentication,omitempty"` 4408 Res *types.DisableSmartCardAuthenticationResponse `xml:"urn:vim25 DisableSmartCardAuthenticationResponse,omitempty"` 4409 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4410} 4411 4412func (b *DisableSmartCardAuthenticationBody) Fault() *soap.Fault { return b.Fault_ } 4413 4414func DisableSmartCardAuthentication(ctx context.Context, r soap.RoundTripper, req *types.DisableSmartCardAuthentication) (*types.DisableSmartCardAuthenticationResponse, error) { 4415 var reqBody, resBody DisableSmartCardAuthenticationBody 4416 4417 reqBody.Req = req 4418 4419 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4420 return nil, err 4421 } 4422 4423 return resBody.Res, nil 4424} 4425 4426type DisconnectHost_TaskBody struct { 4427 Req *types.DisconnectHost_Task `xml:"urn:vim25 DisconnectHost_Task,omitempty"` 4428 Res *types.DisconnectHost_TaskResponse `xml:"urn:vim25 DisconnectHost_TaskResponse,omitempty"` 4429 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4430} 4431 4432func (b *DisconnectHost_TaskBody) Fault() *soap.Fault { return b.Fault_ } 4433 4434func DisconnectHost_Task(ctx context.Context, r soap.RoundTripper, req *types.DisconnectHost_Task) (*types.DisconnectHost_TaskResponse, error) { 4435 var reqBody, resBody DisconnectHost_TaskBody 4436 4437 reqBody.Req = req 4438 4439 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4440 return nil, err 4441 } 4442 4443 return resBody.Res, nil 4444} 4445 4446type DiscoverFcoeHbasBody struct { 4447 Req *types.DiscoverFcoeHbas `xml:"urn:vim25 DiscoverFcoeHbas,omitempty"` 4448 Res *types.DiscoverFcoeHbasResponse `xml:"urn:vim25 DiscoverFcoeHbasResponse,omitempty"` 4449 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4450} 4451 4452func (b *DiscoverFcoeHbasBody) Fault() *soap.Fault { return b.Fault_ } 4453 4454func DiscoverFcoeHbas(ctx context.Context, r soap.RoundTripper, req *types.DiscoverFcoeHbas) (*types.DiscoverFcoeHbasResponse, error) { 4455 var reqBody, resBody DiscoverFcoeHbasBody 4456 4457 reqBody.Req = req 4458 4459 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4460 return nil, err 4461 } 4462 4463 return resBody.Res, nil 4464} 4465 4466type DissociateProfileBody struct { 4467 Req *types.DissociateProfile `xml:"urn:vim25 DissociateProfile,omitempty"` 4468 Res *types.DissociateProfileResponse `xml:"urn:vim25 DissociateProfileResponse,omitempty"` 4469 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4470} 4471 4472func (b *DissociateProfileBody) Fault() *soap.Fault { return b.Fault_ } 4473 4474func DissociateProfile(ctx context.Context, r soap.RoundTripper, req *types.DissociateProfile) (*types.DissociateProfileResponse, error) { 4475 var reqBody, resBody DissociateProfileBody 4476 4477 reqBody.Req = req 4478 4479 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4480 return nil, err 4481 } 4482 4483 return resBody.Res, nil 4484} 4485 4486type DoesCustomizationSpecExistBody struct { 4487 Req *types.DoesCustomizationSpecExist `xml:"urn:vim25 DoesCustomizationSpecExist,omitempty"` 4488 Res *types.DoesCustomizationSpecExistResponse `xml:"urn:vim25 DoesCustomizationSpecExistResponse,omitempty"` 4489 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4490} 4491 4492func (b *DoesCustomizationSpecExistBody) Fault() *soap.Fault { return b.Fault_ } 4493 4494func DoesCustomizationSpecExist(ctx context.Context, r soap.RoundTripper, req *types.DoesCustomizationSpecExist) (*types.DoesCustomizationSpecExistResponse, error) { 4495 var reqBody, resBody DoesCustomizationSpecExistBody 4496 4497 reqBody.Req = req 4498 4499 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4500 return nil, err 4501 } 4502 4503 return resBody.Res, nil 4504} 4505 4506type DuplicateCustomizationSpecBody struct { 4507 Req *types.DuplicateCustomizationSpec `xml:"urn:vim25 DuplicateCustomizationSpec,omitempty"` 4508 Res *types.DuplicateCustomizationSpecResponse `xml:"urn:vim25 DuplicateCustomizationSpecResponse,omitempty"` 4509 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4510} 4511 4512func (b *DuplicateCustomizationSpecBody) Fault() *soap.Fault { return b.Fault_ } 4513 4514func DuplicateCustomizationSpec(ctx context.Context, r soap.RoundTripper, req *types.DuplicateCustomizationSpec) (*types.DuplicateCustomizationSpecResponse, error) { 4515 var reqBody, resBody DuplicateCustomizationSpecBody 4516 4517 reqBody.Req = req 4518 4519 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4520 return nil, err 4521 } 4522 4523 return resBody.Res, nil 4524} 4525 4526type DvsReconfigureVmVnicNetworkResourcePool_TaskBody struct { 4527 Req *types.DvsReconfigureVmVnicNetworkResourcePool_Task `xml:"urn:vim25 DvsReconfigureVmVnicNetworkResourcePool_Task,omitempty"` 4528 Res *types.DvsReconfigureVmVnicNetworkResourcePool_TaskResponse `xml:"urn:vim25 DvsReconfigureVmVnicNetworkResourcePool_TaskResponse,omitempty"` 4529 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4530} 4531 4532func (b *DvsReconfigureVmVnicNetworkResourcePool_TaskBody) Fault() *soap.Fault { return b.Fault_ } 4533 4534func DvsReconfigureVmVnicNetworkResourcePool_Task(ctx context.Context, r soap.RoundTripper, req *types.DvsReconfigureVmVnicNetworkResourcePool_Task) (*types.DvsReconfigureVmVnicNetworkResourcePool_TaskResponse, error) { 4535 var reqBody, resBody DvsReconfigureVmVnicNetworkResourcePool_TaskBody 4536 4537 reqBody.Req = req 4538 4539 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4540 return nil, err 4541 } 4542 4543 return resBody.Res, nil 4544} 4545 4546type EagerZeroVirtualDisk_TaskBody struct { 4547 Req *types.EagerZeroVirtualDisk_Task `xml:"urn:vim25 EagerZeroVirtualDisk_Task,omitempty"` 4548 Res *types.EagerZeroVirtualDisk_TaskResponse `xml:"urn:vim25 EagerZeroVirtualDisk_TaskResponse,omitempty"` 4549 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4550} 4551 4552func (b *EagerZeroVirtualDisk_TaskBody) Fault() *soap.Fault { return b.Fault_ } 4553 4554func EagerZeroVirtualDisk_Task(ctx context.Context, r soap.RoundTripper, req *types.EagerZeroVirtualDisk_Task) (*types.EagerZeroVirtualDisk_TaskResponse, error) { 4555 var reqBody, resBody EagerZeroVirtualDisk_TaskBody 4556 4557 reqBody.Req = req 4558 4559 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4560 return nil, err 4561 } 4562 4563 return resBody.Res, nil 4564} 4565 4566type EnableAlarmActionsBody struct { 4567 Req *types.EnableAlarmActions `xml:"urn:vim25 EnableAlarmActions,omitempty"` 4568 Res *types.EnableAlarmActionsResponse `xml:"urn:vim25 EnableAlarmActionsResponse,omitempty"` 4569 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4570} 4571 4572func (b *EnableAlarmActionsBody) Fault() *soap.Fault { return b.Fault_ } 4573 4574func EnableAlarmActions(ctx context.Context, r soap.RoundTripper, req *types.EnableAlarmActions) (*types.EnableAlarmActionsResponse, error) { 4575 var reqBody, resBody EnableAlarmActionsBody 4576 4577 reqBody.Req = req 4578 4579 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4580 return nil, err 4581 } 4582 4583 return resBody.Res, nil 4584} 4585 4586type EnableCryptoBody struct { 4587 Req *types.EnableCrypto `xml:"urn:vim25 EnableCrypto,omitempty"` 4588 Res *types.EnableCryptoResponse `xml:"urn:vim25 EnableCryptoResponse,omitempty"` 4589 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4590} 4591 4592func (b *EnableCryptoBody) Fault() *soap.Fault { return b.Fault_ } 4593 4594func EnableCrypto(ctx context.Context, r soap.RoundTripper, req *types.EnableCrypto) (*types.EnableCryptoResponse, error) { 4595 var reqBody, resBody EnableCryptoBody 4596 4597 reqBody.Req = req 4598 4599 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4600 return nil, err 4601 } 4602 4603 return resBody.Res, nil 4604} 4605 4606type EnableFeatureBody struct { 4607 Req *types.EnableFeature `xml:"urn:vim25 EnableFeature,omitempty"` 4608 Res *types.EnableFeatureResponse `xml:"urn:vim25 EnableFeatureResponse,omitempty"` 4609 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4610} 4611 4612func (b *EnableFeatureBody) Fault() *soap.Fault { return b.Fault_ } 4613 4614func EnableFeature(ctx context.Context, r soap.RoundTripper, req *types.EnableFeature) (*types.EnableFeatureResponse, error) { 4615 var reqBody, resBody EnableFeatureBody 4616 4617 reqBody.Req = req 4618 4619 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4620 return nil, err 4621 } 4622 4623 return resBody.Res, nil 4624} 4625 4626type EnableHyperThreadingBody struct { 4627 Req *types.EnableHyperThreading `xml:"urn:vim25 EnableHyperThreading,omitempty"` 4628 Res *types.EnableHyperThreadingResponse `xml:"urn:vim25 EnableHyperThreadingResponse,omitempty"` 4629 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4630} 4631 4632func (b *EnableHyperThreadingBody) Fault() *soap.Fault { return b.Fault_ } 4633 4634func EnableHyperThreading(ctx context.Context, r soap.RoundTripper, req *types.EnableHyperThreading) (*types.EnableHyperThreadingResponse, error) { 4635 var reqBody, resBody EnableHyperThreadingBody 4636 4637 reqBody.Req = req 4638 4639 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4640 return nil, err 4641 } 4642 4643 return resBody.Res, nil 4644} 4645 4646type EnableMultipathPathBody struct { 4647 Req *types.EnableMultipathPath `xml:"urn:vim25 EnableMultipathPath,omitempty"` 4648 Res *types.EnableMultipathPathResponse `xml:"urn:vim25 EnableMultipathPathResponse,omitempty"` 4649 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4650} 4651 4652func (b *EnableMultipathPathBody) Fault() *soap.Fault { return b.Fault_ } 4653 4654func EnableMultipathPath(ctx context.Context, r soap.RoundTripper, req *types.EnableMultipathPath) (*types.EnableMultipathPathResponse, error) { 4655 var reqBody, resBody EnableMultipathPathBody 4656 4657 reqBody.Req = req 4658 4659 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4660 return nil, err 4661 } 4662 4663 return resBody.Res, nil 4664} 4665 4666type EnableNetworkResourceManagementBody struct { 4667 Req *types.EnableNetworkResourceManagement `xml:"urn:vim25 EnableNetworkResourceManagement,omitempty"` 4668 Res *types.EnableNetworkResourceManagementResponse `xml:"urn:vim25 EnableNetworkResourceManagementResponse,omitempty"` 4669 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4670} 4671 4672func (b *EnableNetworkResourceManagementBody) Fault() *soap.Fault { return b.Fault_ } 4673 4674func EnableNetworkResourceManagement(ctx context.Context, r soap.RoundTripper, req *types.EnableNetworkResourceManagement) (*types.EnableNetworkResourceManagementResponse, error) { 4675 var reqBody, resBody EnableNetworkResourceManagementBody 4676 4677 reqBody.Req = req 4678 4679 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4680 return nil, err 4681 } 4682 4683 return resBody.Res, nil 4684} 4685 4686type EnableRulesetBody struct { 4687 Req *types.EnableRuleset `xml:"urn:vim25 EnableRuleset,omitempty"` 4688 Res *types.EnableRulesetResponse `xml:"urn:vim25 EnableRulesetResponse,omitempty"` 4689 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4690} 4691 4692func (b *EnableRulesetBody) Fault() *soap.Fault { return b.Fault_ } 4693 4694func EnableRuleset(ctx context.Context, r soap.RoundTripper, req *types.EnableRuleset) (*types.EnableRulesetResponse, error) { 4695 var reqBody, resBody EnableRulesetBody 4696 4697 reqBody.Req = req 4698 4699 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4700 return nil, err 4701 } 4702 4703 return resBody.Res, nil 4704} 4705 4706type EnableSecondaryVM_TaskBody struct { 4707 Req *types.EnableSecondaryVM_Task `xml:"urn:vim25 EnableSecondaryVM_Task,omitempty"` 4708 Res *types.EnableSecondaryVM_TaskResponse `xml:"urn:vim25 EnableSecondaryVM_TaskResponse,omitempty"` 4709 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4710} 4711 4712func (b *EnableSecondaryVM_TaskBody) Fault() *soap.Fault { return b.Fault_ } 4713 4714func EnableSecondaryVM_Task(ctx context.Context, r soap.RoundTripper, req *types.EnableSecondaryVM_Task) (*types.EnableSecondaryVM_TaskResponse, error) { 4715 var reqBody, resBody EnableSecondaryVM_TaskBody 4716 4717 reqBody.Req = req 4718 4719 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4720 return nil, err 4721 } 4722 4723 return resBody.Res, nil 4724} 4725 4726type EnableSmartCardAuthenticationBody struct { 4727 Req *types.EnableSmartCardAuthentication `xml:"urn:vim25 EnableSmartCardAuthentication,omitempty"` 4728 Res *types.EnableSmartCardAuthenticationResponse `xml:"urn:vim25 EnableSmartCardAuthenticationResponse,omitempty"` 4729 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4730} 4731 4732func (b *EnableSmartCardAuthenticationBody) Fault() *soap.Fault { return b.Fault_ } 4733 4734func EnableSmartCardAuthentication(ctx context.Context, r soap.RoundTripper, req *types.EnableSmartCardAuthentication) (*types.EnableSmartCardAuthenticationResponse, error) { 4735 var reqBody, resBody EnableSmartCardAuthenticationBody 4736 4737 reqBody.Req = req 4738 4739 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4740 return nil, err 4741 } 4742 4743 return resBody.Res, nil 4744} 4745 4746type EnterLockdownModeBody struct { 4747 Req *types.EnterLockdownMode `xml:"urn:vim25 EnterLockdownMode,omitempty"` 4748 Res *types.EnterLockdownModeResponse `xml:"urn:vim25 EnterLockdownModeResponse,omitempty"` 4749 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4750} 4751 4752func (b *EnterLockdownModeBody) Fault() *soap.Fault { return b.Fault_ } 4753 4754func EnterLockdownMode(ctx context.Context, r soap.RoundTripper, req *types.EnterLockdownMode) (*types.EnterLockdownModeResponse, error) { 4755 var reqBody, resBody EnterLockdownModeBody 4756 4757 reqBody.Req = req 4758 4759 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4760 return nil, err 4761 } 4762 4763 return resBody.Res, nil 4764} 4765 4766type EnterMaintenanceMode_TaskBody struct { 4767 Req *types.EnterMaintenanceMode_Task `xml:"urn:vim25 EnterMaintenanceMode_Task,omitempty"` 4768 Res *types.EnterMaintenanceMode_TaskResponse `xml:"urn:vim25 EnterMaintenanceMode_TaskResponse,omitempty"` 4769 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4770} 4771 4772func (b *EnterMaintenanceMode_TaskBody) Fault() *soap.Fault { return b.Fault_ } 4773 4774func EnterMaintenanceMode_Task(ctx context.Context, r soap.RoundTripper, req *types.EnterMaintenanceMode_Task) (*types.EnterMaintenanceMode_TaskResponse, error) { 4775 var reqBody, resBody EnterMaintenanceMode_TaskBody 4776 4777 reqBody.Req = req 4778 4779 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4780 return nil, err 4781 } 4782 4783 return resBody.Res, nil 4784} 4785 4786type EstimateDatabaseSizeBody struct { 4787 Req *types.EstimateDatabaseSize `xml:"urn:vim25 EstimateDatabaseSize,omitempty"` 4788 Res *types.EstimateDatabaseSizeResponse `xml:"urn:vim25 EstimateDatabaseSizeResponse,omitempty"` 4789 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4790} 4791 4792func (b *EstimateDatabaseSizeBody) Fault() *soap.Fault { return b.Fault_ } 4793 4794func EstimateDatabaseSize(ctx context.Context, r soap.RoundTripper, req *types.EstimateDatabaseSize) (*types.EstimateDatabaseSizeResponse, error) { 4795 var reqBody, resBody EstimateDatabaseSizeBody 4796 4797 reqBody.Req = req 4798 4799 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4800 return nil, err 4801 } 4802 4803 return resBody.Res, nil 4804} 4805 4806type EstimateStorageForConsolidateSnapshots_TaskBody struct { 4807 Req *types.EstimateStorageForConsolidateSnapshots_Task `xml:"urn:vim25 EstimateStorageForConsolidateSnapshots_Task,omitempty"` 4808 Res *types.EstimateStorageForConsolidateSnapshots_TaskResponse `xml:"urn:vim25 EstimateStorageForConsolidateSnapshots_TaskResponse,omitempty"` 4809 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4810} 4811 4812func (b *EstimateStorageForConsolidateSnapshots_TaskBody) Fault() *soap.Fault { return b.Fault_ } 4813 4814func EstimateStorageForConsolidateSnapshots_Task(ctx context.Context, r soap.RoundTripper, req *types.EstimateStorageForConsolidateSnapshots_Task) (*types.EstimateStorageForConsolidateSnapshots_TaskResponse, error) { 4815 var reqBody, resBody EstimateStorageForConsolidateSnapshots_TaskBody 4816 4817 reqBody.Req = req 4818 4819 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4820 return nil, err 4821 } 4822 4823 return resBody.Res, nil 4824} 4825 4826type EsxAgentHostManagerUpdateConfigBody struct { 4827 Req *types.EsxAgentHostManagerUpdateConfig `xml:"urn:vim25 EsxAgentHostManagerUpdateConfig,omitempty"` 4828 Res *types.EsxAgentHostManagerUpdateConfigResponse `xml:"urn:vim25 EsxAgentHostManagerUpdateConfigResponse,omitempty"` 4829 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4830} 4831 4832func (b *EsxAgentHostManagerUpdateConfigBody) Fault() *soap.Fault { return b.Fault_ } 4833 4834func EsxAgentHostManagerUpdateConfig(ctx context.Context, r soap.RoundTripper, req *types.EsxAgentHostManagerUpdateConfig) (*types.EsxAgentHostManagerUpdateConfigResponse, error) { 4835 var reqBody, resBody EsxAgentHostManagerUpdateConfigBody 4836 4837 reqBody.Req = req 4838 4839 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4840 return nil, err 4841 } 4842 4843 return resBody.Res, nil 4844} 4845 4846type EvacuateVsanNode_TaskBody struct { 4847 Req *types.EvacuateVsanNode_Task `xml:"urn:vim25 EvacuateVsanNode_Task,omitempty"` 4848 Res *types.EvacuateVsanNode_TaskResponse `xml:"urn:vim25 EvacuateVsanNode_TaskResponse,omitempty"` 4849 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4850} 4851 4852func (b *EvacuateVsanNode_TaskBody) Fault() *soap.Fault { return b.Fault_ } 4853 4854func EvacuateVsanNode_Task(ctx context.Context, r soap.RoundTripper, req *types.EvacuateVsanNode_Task) (*types.EvacuateVsanNode_TaskResponse, error) { 4855 var reqBody, resBody EvacuateVsanNode_TaskBody 4856 4857 reqBody.Req = req 4858 4859 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4860 return nil, err 4861 } 4862 4863 return resBody.Res, nil 4864} 4865 4866type EvcManagerBody struct { 4867 Req *types.EvcManager `xml:"urn:vim25 EvcManager,omitempty"` 4868 Res *types.EvcManagerResponse `xml:"urn:vim25 EvcManagerResponse,omitempty"` 4869 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4870} 4871 4872func (b *EvcManagerBody) Fault() *soap.Fault { return b.Fault_ } 4873 4874func EvcManager(ctx context.Context, r soap.RoundTripper, req *types.EvcManager) (*types.EvcManagerResponse, error) { 4875 var reqBody, resBody EvcManagerBody 4876 4877 reqBody.Req = req 4878 4879 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4880 return nil, err 4881 } 4882 4883 return resBody.Res, nil 4884} 4885 4886type ExecuteHostProfileBody struct { 4887 Req *types.ExecuteHostProfile `xml:"urn:vim25 ExecuteHostProfile,omitempty"` 4888 Res *types.ExecuteHostProfileResponse `xml:"urn:vim25 ExecuteHostProfileResponse,omitempty"` 4889 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4890} 4891 4892func (b *ExecuteHostProfileBody) Fault() *soap.Fault { return b.Fault_ } 4893 4894func ExecuteHostProfile(ctx context.Context, r soap.RoundTripper, req *types.ExecuteHostProfile) (*types.ExecuteHostProfileResponse, error) { 4895 var reqBody, resBody ExecuteHostProfileBody 4896 4897 reqBody.Req = req 4898 4899 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4900 return nil, err 4901 } 4902 4903 return resBody.Res, nil 4904} 4905 4906type ExecuteSimpleCommandBody struct { 4907 Req *types.ExecuteSimpleCommand `xml:"urn:vim25 ExecuteSimpleCommand,omitempty"` 4908 Res *types.ExecuteSimpleCommandResponse `xml:"urn:vim25 ExecuteSimpleCommandResponse,omitempty"` 4909 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4910} 4911 4912func (b *ExecuteSimpleCommandBody) Fault() *soap.Fault { return b.Fault_ } 4913 4914func ExecuteSimpleCommand(ctx context.Context, r soap.RoundTripper, req *types.ExecuteSimpleCommand) (*types.ExecuteSimpleCommandResponse, error) { 4915 var reqBody, resBody ExecuteSimpleCommandBody 4916 4917 reqBody.Req = req 4918 4919 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4920 return nil, err 4921 } 4922 4923 return resBody.Res, nil 4924} 4925 4926type ExitLockdownModeBody struct { 4927 Req *types.ExitLockdownMode `xml:"urn:vim25 ExitLockdownMode,omitempty"` 4928 Res *types.ExitLockdownModeResponse `xml:"urn:vim25 ExitLockdownModeResponse,omitempty"` 4929 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4930} 4931 4932func (b *ExitLockdownModeBody) Fault() *soap.Fault { return b.Fault_ } 4933 4934func ExitLockdownMode(ctx context.Context, r soap.RoundTripper, req *types.ExitLockdownMode) (*types.ExitLockdownModeResponse, error) { 4935 var reqBody, resBody ExitLockdownModeBody 4936 4937 reqBody.Req = req 4938 4939 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4940 return nil, err 4941 } 4942 4943 return resBody.Res, nil 4944} 4945 4946type ExitMaintenanceMode_TaskBody struct { 4947 Req *types.ExitMaintenanceMode_Task `xml:"urn:vim25 ExitMaintenanceMode_Task,omitempty"` 4948 Res *types.ExitMaintenanceMode_TaskResponse `xml:"urn:vim25 ExitMaintenanceMode_TaskResponse,omitempty"` 4949 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4950} 4951 4952func (b *ExitMaintenanceMode_TaskBody) Fault() *soap.Fault { return b.Fault_ } 4953 4954func ExitMaintenanceMode_Task(ctx context.Context, r soap.RoundTripper, req *types.ExitMaintenanceMode_Task) (*types.ExitMaintenanceMode_TaskResponse, error) { 4955 var reqBody, resBody ExitMaintenanceMode_TaskBody 4956 4957 reqBody.Req = req 4958 4959 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4960 return nil, err 4961 } 4962 4963 return resBody.Res, nil 4964} 4965 4966type ExpandVmfsDatastoreBody struct { 4967 Req *types.ExpandVmfsDatastore `xml:"urn:vim25 ExpandVmfsDatastore,omitempty"` 4968 Res *types.ExpandVmfsDatastoreResponse `xml:"urn:vim25 ExpandVmfsDatastoreResponse,omitempty"` 4969 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4970} 4971 4972func (b *ExpandVmfsDatastoreBody) Fault() *soap.Fault { return b.Fault_ } 4973 4974func ExpandVmfsDatastore(ctx context.Context, r soap.RoundTripper, req *types.ExpandVmfsDatastore) (*types.ExpandVmfsDatastoreResponse, error) { 4975 var reqBody, resBody ExpandVmfsDatastoreBody 4976 4977 reqBody.Req = req 4978 4979 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 4980 return nil, err 4981 } 4982 4983 return resBody.Res, nil 4984} 4985 4986type ExpandVmfsExtentBody struct { 4987 Req *types.ExpandVmfsExtent `xml:"urn:vim25 ExpandVmfsExtent,omitempty"` 4988 Res *types.ExpandVmfsExtentResponse `xml:"urn:vim25 ExpandVmfsExtentResponse,omitempty"` 4989 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 4990} 4991 4992func (b *ExpandVmfsExtentBody) Fault() *soap.Fault { return b.Fault_ } 4993 4994func ExpandVmfsExtent(ctx context.Context, r soap.RoundTripper, req *types.ExpandVmfsExtent) (*types.ExpandVmfsExtentResponse, error) { 4995 var reqBody, resBody ExpandVmfsExtentBody 4996 4997 reqBody.Req = req 4998 4999 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5000 return nil, err 5001 } 5002 5003 return resBody.Res, nil 5004} 5005 5006type ExportAnswerFile_TaskBody struct { 5007 Req *types.ExportAnswerFile_Task `xml:"urn:vim25 ExportAnswerFile_Task,omitempty"` 5008 Res *types.ExportAnswerFile_TaskResponse `xml:"urn:vim25 ExportAnswerFile_TaskResponse,omitempty"` 5009 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5010} 5011 5012func (b *ExportAnswerFile_TaskBody) Fault() *soap.Fault { return b.Fault_ } 5013 5014func ExportAnswerFile_Task(ctx context.Context, r soap.RoundTripper, req *types.ExportAnswerFile_Task) (*types.ExportAnswerFile_TaskResponse, error) { 5015 var reqBody, resBody ExportAnswerFile_TaskBody 5016 5017 reqBody.Req = req 5018 5019 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5020 return nil, err 5021 } 5022 5023 return resBody.Res, nil 5024} 5025 5026type ExportProfileBody struct { 5027 Req *types.ExportProfile `xml:"urn:vim25 ExportProfile,omitempty"` 5028 Res *types.ExportProfileResponse `xml:"urn:vim25 ExportProfileResponse,omitempty"` 5029 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5030} 5031 5032func (b *ExportProfileBody) Fault() *soap.Fault { return b.Fault_ } 5033 5034func ExportProfile(ctx context.Context, r soap.RoundTripper, req *types.ExportProfile) (*types.ExportProfileResponse, error) { 5035 var reqBody, resBody ExportProfileBody 5036 5037 reqBody.Req = req 5038 5039 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5040 return nil, err 5041 } 5042 5043 return resBody.Res, nil 5044} 5045 5046type ExportSnapshotBody struct { 5047 Req *types.ExportSnapshot `xml:"urn:vim25 ExportSnapshot,omitempty"` 5048 Res *types.ExportSnapshotResponse `xml:"urn:vim25 ExportSnapshotResponse,omitempty"` 5049 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5050} 5051 5052func (b *ExportSnapshotBody) Fault() *soap.Fault { return b.Fault_ } 5053 5054func ExportSnapshot(ctx context.Context, r soap.RoundTripper, req *types.ExportSnapshot) (*types.ExportSnapshotResponse, error) { 5055 var reqBody, resBody ExportSnapshotBody 5056 5057 reqBody.Req = req 5058 5059 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5060 return nil, err 5061 } 5062 5063 return resBody.Res, nil 5064} 5065 5066type ExportVAppBody struct { 5067 Req *types.ExportVApp `xml:"urn:vim25 ExportVApp,omitempty"` 5068 Res *types.ExportVAppResponse `xml:"urn:vim25 ExportVAppResponse,omitempty"` 5069 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5070} 5071 5072func (b *ExportVAppBody) Fault() *soap.Fault { return b.Fault_ } 5073 5074func ExportVApp(ctx context.Context, r soap.RoundTripper, req *types.ExportVApp) (*types.ExportVAppResponse, error) { 5075 var reqBody, resBody ExportVAppBody 5076 5077 reqBody.Req = req 5078 5079 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5080 return nil, err 5081 } 5082 5083 return resBody.Res, nil 5084} 5085 5086type ExportVmBody struct { 5087 Req *types.ExportVm `xml:"urn:vim25 ExportVm,omitempty"` 5088 Res *types.ExportVmResponse `xml:"urn:vim25 ExportVmResponse,omitempty"` 5089 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5090} 5091 5092func (b *ExportVmBody) Fault() *soap.Fault { return b.Fault_ } 5093 5094func ExportVm(ctx context.Context, r soap.RoundTripper, req *types.ExportVm) (*types.ExportVmResponse, error) { 5095 var reqBody, resBody ExportVmBody 5096 5097 reqBody.Req = req 5098 5099 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5100 return nil, err 5101 } 5102 5103 return resBody.Res, nil 5104} 5105 5106type ExtendDisk_TaskBody struct { 5107 Req *types.ExtendDisk_Task `xml:"urn:vim25 ExtendDisk_Task,omitempty"` 5108 Res *types.ExtendDisk_TaskResponse `xml:"urn:vim25 ExtendDisk_TaskResponse,omitempty"` 5109 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5110} 5111 5112func (b *ExtendDisk_TaskBody) Fault() *soap.Fault { return b.Fault_ } 5113 5114func ExtendDisk_Task(ctx context.Context, r soap.RoundTripper, req *types.ExtendDisk_Task) (*types.ExtendDisk_TaskResponse, error) { 5115 var reqBody, resBody ExtendDisk_TaskBody 5116 5117 reqBody.Req = req 5118 5119 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5120 return nil, err 5121 } 5122 5123 return resBody.Res, nil 5124} 5125 5126type ExtendVffsBody struct { 5127 Req *types.ExtendVffs `xml:"urn:vim25 ExtendVffs,omitempty"` 5128 Res *types.ExtendVffsResponse `xml:"urn:vim25 ExtendVffsResponse,omitempty"` 5129 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5130} 5131 5132func (b *ExtendVffsBody) Fault() *soap.Fault { return b.Fault_ } 5133 5134func ExtendVffs(ctx context.Context, r soap.RoundTripper, req *types.ExtendVffs) (*types.ExtendVffsResponse, error) { 5135 var reqBody, resBody ExtendVffsBody 5136 5137 reqBody.Req = req 5138 5139 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5140 return nil, err 5141 } 5142 5143 return resBody.Res, nil 5144} 5145 5146type ExtendVirtualDisk_TaskBody struct { 5147 Req *types.ExtendVirtualDisk_Task `xml:"urn:vim25 ExtendVirtualDisk_Task,omitempty"` 5148 Res *types.ExtendVirtualDisk_TaskResponse `xml:"urn:vim25 ExtendVirtualDisk_TaskResponse,omitempty"` 5149 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5150} 5151 5152func (b *ExtendVirtualDisk_TaskBody) Fault() *soap.Fault { return b.Fault_ } 5153 5154func ExtendVirtualDisk_Task(ctx context.Context, r soap.RoundTripper, req *types.ExtendVirtualDisk_Task) (*types.ExtendVirtualDisk_TaskResponse, error) { 5155 var reqBody, resBody ExtendVirtualDisk_TaskBody 5156 5157 reqBody.Req = req 5158 5159 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5160 return nil, err 5161 } 5162 5163 return resBody.Res, nil 5164} 5165 5166type ExtendVmfsDatastoreBody struct { 5167 Req *types.ExtendVmfsDatastore `xml:"urn:vim25 ExtendVmfsDatastore,omitempty"` 5168 Res *types.ExtendVmfsDatastoreResponse `xml:"urn:vim25 ExtendVmfsDatastoreResponse,omitempty"` 5169 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5170} 5171 5172func (b *ExtendVmfsDatastoreBody) Fault() *soap.Fault { return b.Fault_ } 5173 5174func ExtendVmfsDatastore(ctx context.Context, r soap.RoundTripper, req *types.ExtendVmfsDatastore) (*types.ExtendVmfsDatastoreResponse, error) { 5175 var reqBody, resBody ExtendVmfsDatastoreBody 5176 5177 reqBody.Req = req 5178 5179 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5180 return nil, err 5181 } 5182 5183 return resBody.Res, nil 5184} 5185 5186type ExtractOvfEnvironmentBody struct { 5187 Req *types.ExtractOvfEnvironment `xml:"urn:vim25 ExtractOvfEnvironment,omitempty"` 5188 Res *types.ExtractOvfEnvironmentResponse `xml:"urn:vim25 ExtractOvfEnvironmentResponse,omitempty"` 5189 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5190} 5191 5192func (b *ExtractOvfEnvironmentBody) Fault() *soap.Fault { return b.Fault_ } 5193 5194func ExtractOvfEnvironment(ctx context.Context, r soap.RoundTripper, req *types.ExtractOvfEnvironment) (*types.ExtractOvfEnvironmentResponse, error) { 5195 var reqBody, resBody ExtractOvfEnvironmentBody 5196 5197 reqBody.Req = req 5198 5199 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5200 return nil, err 5201 } 5202 5203 return resBody.Res, nil 5204} 5205 5206type FetchDVPortKeysBody struct { 5207 Req *types.FetchDVPortKeys `xml:"urn:vim25 FetchDVPortKeys,omitempty"` 5208 Res *types.FetchDVPortKeysResponse `xml:"urn:vim25 FetchDVPortKeysResponse,omitempty"` 5209 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5210} 5211 5212func (b *FetchDVPortKeysBody) Fault() *soap.Fault { return b.Fault_ } 5213 5214func FetchDVPortKeys(ctx context.Context, r soap.RoundTripper, req *types.FetchDVPortKeys) (*types.FetchDVPortKeysResponse, error) { 5215 var reqBody, resBody FetchDVPortKeysBody 5216 5217 reqBody.Req = req 5218 5219 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5220 return nil, err 5221 } 5222 5223 return resBody.Res, nil 5224} 5225 5226type FetchDVPortsBody struct { 5227 Req *types.FetchDVPorts `xml:"urn:vim25 FetchDVPorts,omitempty"` 5228 Res *types.FetchDVPortsResponse `xml:"urn:vim25 FetchDVPortsResponse,omitempty"` 5229 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5230} 5231 5232func (b *FetchDVPortsBody) Fault() *soap.Fault { return b.Fault_ } 5233 5234func FetchDVPorts(ctx context.Context, r soap.RoundTripper, req *types.FetchDVPorts) (*types.FetchDVPortsResponse, error) { 5235 var reqBody, resBody FetchDVPortsBody 5236 5237 reqBody.Req = req 5238 5239 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5240 return nil, err 5241 } 5242 5243 return resBody.Res, nil 5244} 5245 5246type FetchSystemEventLogBody struct { 5247 Req *types.FetchSystemEventLog `xml:"urn:vim25 FetchSystemEventLog,omitempty"` 5248 Res *types.FetchSystemEventLogResponse `xml:"urn:vim25 FetchSystemEventLogResponse,omitempty"` 5249 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5250} 5251 5252func (b *FetchSystemEventLogBody) Fault() *soap.Fault { return b.Fault_ } 5253 5254func FetchSystemEventLog(ctx context.Context, r soap.RoundTripper, req *types.FetchSystemEventLog) (*types.FetchSystemEventLogResponse, error) { 5255 var reqBody, resBody FetchSystemEventLogBody 5256 5257 reqBody.Req = req 5258 5259 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5260 return nil, err 5261 } 5262 5263 return resBody.Res, nil 5264} 5265 5266type FetchUserPrivilegeOnEntitiesBody struct { 5267 Req *types.FetchUserPrivilegeOnEntities `xml:"urn:vim25 FetchUserPrivilegeOnEntities,omitempty"` 5268 Res *types.FetchUserPrivilegeOnEntitiesResponse `xml:"urn:vim25 FetchUserPrivilegeOnEntitiesResponse,omitempty"` 5269 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5270} 5271 5272func (b *FetchUserPrivilegeOnEntitiesBody) Fault() *soap.Fault { return b.Fault_ } 5273 5274func FetchUserPrivilegeOnEntities(ctx context.Context, r soap.RoundTripper, req *types.FetchUserPrivilegeOnEntities) (*types.FetchUserPrivilegeOnEntitiesResponse, error) { 5275 var reqBody, resBody FetchUserPrivilegeOnEntitiesBody 5276 5277 reqBody.Req = req 5278 5279 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5280 return nil, err 5281 } 5282 5283 return resBody.Res, nil 5284} 5285 5286type FindAllByDnsNameBody struct { 5287 Req *types.FindAllByDnsName `xml:"urn:vim25 FindAllByDnsName,omitempty"` 5288 Res *types.FindAllByDnsNameResponse `xml:"urn:vim25 FindAllByDnsNameResponse,omitempty"` 5289 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5290} 5291 5292func (b *FindAllByDnsNameBody) Fault() *soap.Fault { return b.Fault_ } 5293 5294func FindAllByDnsName(ctx context.Context, r soap.RoundTripper, req *types.FindAllByDnsName) (*types.FindAllByDnsNameResponse, error) { 5295 var reqBody, resBody FindAllByDnsNameBody 5296 5297 reqBody.Req = req 5298 5299 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5300 return nil, err 5301 } 5302 5303 return resBody.Res, nil 5304} 5305 5306type FindAllByIpBody struct { 5307 Req *types.FindAllByIp `xml:"urn:vim25 FindAllByIp,omitempty"` 5308 Res *types.FindAllByIpResponse `xml:"urn:vim25 FindAllByIpResponse,omitempty"` 5309 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5310} 5311 5312func (b *FindAllByIpBody) Fault() *soap.Fault { return b.Fault_ } 5313 5314func FindAllByIp(ctx context.Context, r soap.RoundTripper, req *types.FindAllByIp) (*types.FindAllByIpResponse, error) { 5315 var reqBody, resBody FindAllByIpBody 5316 5317 reqBody.Req = req 5318 5319 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5320 return nil, err 5321 } 5322 5323 return resBody.Res, nil 5324} 5325 5326type FindAllByUuidBody struct { 5327 Req *types.FindAllByUuid `xml:"urn:vim25 FindAllByUuid,omitempty"` 5328 Res *types.FindAllByUuidResponse `xml:"urn:vim25 FindAllByUuidResponse,omitempty"` 5329 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5330} 5331 5332func (b *FindAllByUuidBody) Fault() *soap.Fault { return b.Fault_ } 5333 5334func FindAllByUuid(ctx context.Context, r soap.RoundTripper, req *types.FindAllByUuid) (*types.FindAllByUuidResponse, error) { 5335 var reqBody, resBody FindAllByUuidBody 5336 5337 reqBody.Req = req 5338 5339 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5340 return nil, err 5341 } 5342 5343 return resBody.Res, nil 5344} 5345 5346type FindAssociatedProfileBody struct { 5347 Req *types.FindAssociatedProfile `xml:"urn:vim25 FindAssociatedProfile,omitempty"` 5348 Res *types.FindAssociatedProfileResponse `xml:"urn:vim25 FindAssociatedProfileResponse,omitempty"` 5349 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5350} 5351 5352func (b *FindAssociatedProfileBody) Fault() *soap.Fault { return b.Fault_ } 5353 5354func FindAssociatedProfile(ctx context.Context, r soap.RoundTripper, req *types.FindAssociatedProfile) (*types.FindAssociatedProfileResponse, error) { 5355 var reqBody, resBody FindAssociatedProfileBody 5356 5357 reqBody.Req = req 5358 5359 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5360 return nil, err 5361 } 5362 5363 return resBody.Res, nil 5364} 5365 5366type FindByDatastorePathBody struct { 5367 Req *types.FindByDatastorePath `xml:"urn:vim25 FindByDatastorePath,omitempty"` 5368 Res *types.FindByDatastorePathResponse `xml:"urn:vim25 FindByDatastorePathResponse,omitempty"` 5369 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5370} 5371 5372func (b *FindByDatastorePathBody) Fault() *soap.Fault { return b.Fault_ } 5373 5374func FindByDatastorePath(ctx context.Context, r soap.RoundTripper, req *types.FindByDatastorePath) (*types.FindByDatastorePathResponse, error) { 5375 var reqBody, resBody FindByDatastorePathBody 5376 5377 reqBody.Req = req 5378 5379 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5380 return nil, err 5381 } 5382 5383 return resBody.Res, nil 5384} 5385 5386type FindByDnsNameBody struct { 5387 Req *types.FindByDnsName `xml:"urn:vim25 FindByDnsName,omitempty"` 5388 Res *types.FindByDnsNameResponse `xml:"urn:vim25 FindByDnsNameResponse,omitempty"` 5389 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5390} 5391 5392func (b *FindByDnsNameBody) Fault() *soap.Fault { return b.Fault_ } 5393 5394func FindByDnsName(ctx context.Context, r soap.RoundTripper, req *types.FindByDnsName) (*types.FindByDnsNameResponse, error) { 5395 var reqBody, resBody FindByDnsNameBody 5396 5397 reqBody.Req = req 5398 5399 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5400 return nil, err 5401 } 5402 5403 return resBody.Res, nil 5404} 5405 5406type FindByInventoryPathBody struct { 5407 Req *types.FindByInventoryPath `xml:"urn:vim25 FindByInventoryPath,omitempty"` 5408 Res *types.FindByInventoryPathResponse `xml:"urn:vim25 FindByInventoryPathResponse,omitempty"` 5409 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5410} 5411 5412func (b *FindByInventoryPathBody) Fault() *soap.Fault { return b.Fault_ } 5413 5414func FindByInventoryPath(ctx context.Context, r soap.RoundTripper, req *types.FindByInventoryPath) (*types.FindByInventoryPathResponse, error) { 5415 var reqBody, resBody FindByInventoryPathBody 5416 5417 reqBody.Req = req 5418 5419 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5420 return nil, err 5421 } 5422 5423 return resBody.Res, nil 5424} 5425 5426type FindByIpBody struct { 5427 Req *types.FindByIp `xml:"urn:vim25 FindByIp,omitempty"` 5428 Res *types.FindByIpResponse `xml:"urn:vim25 FindByIpResponse,omitempty"` 5429 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5430} 5431 5432func (b *FindByIpBody) Fault() *soap.Fault { return b.Fault_ } 5433 5434func FindByIp(ctx context.Context, r soap.RoundTripper, req *types.FindByIp) (*types.FindByIpResponse, error) { 5435 var reqBody, resBody FindByIpBody 5436 5437 reqBody.Req = req 5438 5439 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5440 return nil, err 5441 } 5442 5443 return resBody.Res, nil 5444} 5445 5446type FindByUuidBody struct { 5447 Req *types.FindByUuid `xml:"urn:vim25 FindByUuid,omitempty"` 5448 Res *types.FindByUuidResponse `xml:"urn:vim25 FindByUuidResponse,omitempty"` 5449 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5450} 5451 5452func (b *FindByUuidBody) Fault() *soap.Fault { return b.Fault_ } 5453 5454func FindByUuid(ctx context.Context, r soap.RoundTripper, req *types.FindByUuid) (*types.FindByUuidResponse, error) { 5455 var reqBody, resBody FindByUuidBody 5456 5457 reqBody.Req = req 5458 5459 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5460 return nil, err 5461 } 5462 5463 return resBody.Res, nil 5464} 5465 5466type FindChildBody struct { 5467 Req *types.FindChild `xml:"urn:vim25 FindChild,omitempty"` 5468 Res *types.FindChildResponse `xml:"urn:vim25 FindChildResponse,omitempty"` 5469 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5470} 5471 5472func (b *FindChildBody) Fault() *soap.Fault { return b.Fault_ } 5473 5474func FindChild(ctx context.Context, r soap.RoundTripper, req *types.FindChild) (*types.FindChildResponse, error) { 5475 var reqBody, resBody FindChildBody 5476 5477 reqBody.Req = req 5478 5479 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5480 return nil, err 5481 } 5482 5483 return resBody.Res, nil 5484} 5485 5486type FindExtensionBody struct { 5487 Req *types.FindExtension `xml:"urn:vim25 FindExtension,omitempty"` 5488 Res *types.FindExtensionResponse `xml:"urn:vim25 FindExtensionResponse,omitempty"` 5489 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5490} 5491 5492func (b *FindExtensionBody) Fault() *soap.Fault { return b.Fault_ } 5493 5494func FindExtension(ctx context.Context, r soap.RoundTripper, req *types.FindExtension) (*types.FindExtensionResponse, error) { 5495 var reqBody, resBody FindExtensionBody 5496 5497 reqBody.Req = req 5498 5499 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5500 return nil, err 5501 } 5502 5503 return resBody.Res, nil 5504} 5505 5506type FindRulesForVmBody struct { 5507 Req *types.FindRulesForVm `xml:"urn:vim25 FindRulesForVm,omitempty"` 5508 Res *types.FindRulesForVmResponse `xml:"urn:vim25 FindRulesForVmResponse,omitempty"` 5509 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5510} 5511 5512func (b *FindRulesForVmBody) Fault() *soap.Fault { return b.Fault_ } 5513 5514func FindRulesForVm(ctx context.Context, r soap.RoundTripper, req *types.FindRulesForVm) (*types.FindRulesForVmResponse, error) { 5515 var reqBody, resBody FindRulesForVmBody 5516 5517 reqBody.Req = req 5518 5519 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5520 return nil, err 5521 } 5522 5523 return resBody.Res, nil 5524} 5525 5526type FormatVffsBody struct { 5527 Req *types.FormatVffs `xml:"urn:vim25 FormatVffs,omitempty"` 5528 Res *types.FormatVffsResponse `xml:"urn:vim25 FormatVffsResponse,omitempty"` 5529 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5530} 5531 5532func (b *FormatVffsBody) Fault() *soap.Fault { return b.Fault_ } 5533 5534func FormatVffs(ctx context.Context, r soap.RoundTripper, req *types.FormatVffs) (*types.FormatVffsResponse, error) { 5535 var reqBody, resBody FormatVffsBody 5536 5537 reqBody.Req = req 5538 5539 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5540 return nil, err 5541 } 5542 5543 return resBody.Res, nil 5544} 5545 5546type FormatVmfsBody struct { 5547 Req *types.FormatVmfs `xml:"urn:vim25 FormatVmfs,omitempty"` 5548 Res *types.FormatVmfsResponse `xml:"urn:vim25 FormatVmfsResponse,omitempty"` 5549 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5550} 5551 5552func (b *FormatVmfsBody) Fault() *soap.Fault { return b.Fault_ } 5553 5554func FormatVmfs(ctx context.Context, r soap.RoundTripper, req *types.FormatVmfs) (*types.FormatVmfsResponse, error) { 5555 var reqBody, resBody FormatVmfsBody 5556 5557 reqBody.Req = req 5558 5559 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5560 return nil, err 5561 } 5562 5563 return resBody.Res, nil 5564} 5565 5566type GenerateCertificateSigningRequestBody struct { 5567 Req *types.GenerateCertificateSigningRequest `xml:"urn:vim25 GenerateCertificateSigningRequest,omitempty"` 5568 Res *types.GenerateCertificateSigningRequestResponse `xml:"urn:vim25 GenerateCertificateSigningRequestResponse,omitempty"` 5569 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5570} 5571 5572func (b *GenerateCertificateSigningRequestBody) Fault() *soap.Fault { return b.Fault_ } 5573 5574func GenerateCertificateSigningRequest(ctx context.Context, r soap.RoundTripper, req *types.GenerateCertificateSigningRequest) (*types.GenerateCertificateSigningRequestResponse, error) { 5575 var reqBody, resBody GenerateCertificateSigningRequestBody 5576 5577 reqBody.Req = req 5578 5579 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5580 return nil, err 5581 } 5582 5583 return resBody.Res, nil 5584} 5585 5586type GenerateCertificateSigningRequestByDnBody struct { 5587 Req *types.GenerateCertificateSigningRequestByDn `xml:"urn:vim25 GenerateCertificateSigningRequestByDn,omitempty"` 5588 Res *types.GenerateCertificateSigningRequestByDnResponse `xml:"urn:vim25 GenerateCertificateSigningRequestByDnResponse,omitempty"` 5589 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5590} 5591 5592func (b *GenerateCertificateSigningRequestByDnBody) Fault() *soap.Fault { return b.Fault_ } 5593 5594func GenerateCertificateSigningRequestByDn(ctx context.Context, r soap.RoundTripper, req *types.GenerateCertificateSigningRequestByDn) (*types.GenerateCertificateSigningRequestByDnResponse, error) { 5595 var reqBody, resBody GenerateCertificateSigningRequestByDnBody 5596 5597 reqBody.Req = req 5598 5599 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5600 return nil, err 5601 } 5602 5603 return resBody.Res, nil 5604} 5605 5606type GenerateClientCsrBody struct { 5607 Req *types.GenerateClientCsr `xml:"urn:vim25 GenerateClientCsr,omitempty"` 5608 Res *types.GenerateClientCsrResponse `xml:"urn:vim25 GenerateClientCsrResponse,omitempty"` 5609 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5610} 5611 5612func (b *GenerateClientCsrBody) Fault() *soap.Fault { return b.Fault_ } 5613 5614func GenerateClientCsr(ctx context.Context, r soap.RoundTripper, req *types.GenerateClientCsr) (*types.GenerateClientCsrResponse, error) { 5615 var reqBody, resBody GenerateClientCsrBody 5616 5617 reqBody.Req = req 5618 5619 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5620 return nil, err 5621 } 5622 5623 return resBody.Res, nil 5624} 5625 5626type GenerateConfigTaskListBody struct { 5627 Req *types.GenerateConfigTaskList `xml:"urn:vim25 GenerateConfigTaskList,omitempty"` 5628 Res *types.GenerateConfigTaskListResponse `xml:"urn:vim25 GenerateConfigTaskListResponse,omitempty"` 5629 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5630} 5631 5632func (b *GenerateConfigTaskListBody) Fault() *soap.Fault { return b.Fault_ } 5633 5634func GenerateConfigTaskList(ctx context.Context, r soap.RoundTripper, req *types.GenerateConfigTaskList) (*types.GenerateConfigTaskListResponse, error) { 5635 var reqBody, resBody GenerateConfigTaskListBody 5636 5637 reqBody.Req = req 5638 5639 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5640 return nil, err 5641 } 5642 5643 return resBody.Res, nil 5644} 5645 5646type GenerateHostConfigTaskSpec_TaskBody struct { 5647 Req *types.GenerateHostConfigTaskSpec_Task `xml:"urn:vim25 GenerateHostConfigTaskSpec_Task,omitempty"` 5648 Res *types.GenerateHostConfigTaskSpec_TaskResponse `xml:"urn:vim25 GenerateHostConfigTaskSpec_TaskResponse,omitempty"` 5649 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5650} 5651 5652func (b *GenerateHostConfigTaskSpec_TaskBody) Fault() *soap.Fault { return b.Fault_ } 5653 5654func GenerateHostConfigTaskSpec_Task(ctx context.Context, r soap.RoundTripper, req *types.GenerateHostConfigTaskSpec_Task) (*types.GenerateHostConfigTaskSpec_TaskResponse, error) { 5655 var reqBody, resBody GenerateHostConfigTaskSpec_TaskBody 5656 5657 reqBody.Req = req 5658 5659 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5660 return nil, err 5661 } 5662 5663 return resBody.Res, nil 5664} 5665 5666type GenerateHostProfileTaskList_TaskBody struct { 5667 Req *types.GenerateHostProfileTaskList_Task `xml:"urn:vim25 GenerateHostProfileTaskList_Task,omitempty"` 5668 Res *types.GenerateHostProfileTaskList_TaskResponse `xml:"urn:vim25 GenerateHostProfileTaskList_TaskResponse,omitempty"` 5669 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5670} 5671 5672func (b *GenerateHostProfileTaskList_TaskBody) Fault() *soap.Fault { return b.Fault_ } 5673 5674func GenerateHostProfileTaskList_Task(ctx context.Context, r soap.RoundTripper, req *types.GenerateHostProfileTaskList_Task) (*types.GenerateHostProfileTaskList_TaskResponse, error) { 5675 var reqBody, resBody GenerateHostProfileTaskList_TaskBody 5676 5677 reqBody.Req = req 5678 5679 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5680 return nil, err 5681 } 5682 5683 return resBody.Res, nil 5684} 5685 5686type GenerateKeyBody struct { 5687 Req *types.GenerateKey `xml:"urn:vim25 GenerateKey,omitempty"` 5688 Res *types.GenerateKeyResponse `xml:"urn:vim25 GenerateKeyResponse,omitempty"` 5689 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5690} 5691 5692func (b *GenerateKeyBody) Fault() *soap.Fault { return b.Fault_ } 5693 5694func GenerateKey(ctx context.Context, r soap.RoundTripper, req *types.GenerateKey) (*types.GenerateKeyResponse, error) { 5695 var reqBody, resBody GenerateKeyBody 5696 5697 reqBody.Req = req 5698 5699 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5700 return nil, err 5701 } 5702 5703 return resBody.Res, nil 5704} 5705 5706type GenerateLogBundles_TaskBody struct { 5707 Req *types.GenerateLogBundles_Task `xml:"urn:vim25 GenerateLogBundles_Task,omitempty"` 5708 Res *types.GenerateLogBundles_TaskResponse `xml:"urn:vim25 GenerateLogBundles_TaskResponse,omitempty"` 5709 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5710} 5711 5712func (b *GenerateLogBundles_TaskBody) Fault() *soap.Fault { return b.Fault_ } 5713 5714func GenerateLogBundles_Task(ctx context.Context, r soap.RoundTripper, req *types.GenerateLogBundles_Task) (*types.GenerateLogBundles_TaskResponse, error) { 5715 var reqBody, resBody GenerateLogBundles_TaskBody 5716 5717 reqBody.Req = req 5718 5719 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5720 return nil, err 5721 } 5722 5723 return resBody.Res, nil 5724} 5725 5726type GenerateSelfSignedClientCertBody struct { 5727 Req *types.GenerateSelfSignedClientCert `xml:"urn:vim25 GenerateSelfSignedClientCert,omitempty"` 5728 Res *types.GenerateSelfSignedClientCertResponse `xml:"urn:vim25 GenerateSelfSignedClientCertResponse,omitempty"` 5729 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5730} 5731 5732func (b *GenerateSelfSignedClientCertBody) Fault() *soap.Fault { return b.Fault_ } 5733 5734func GenerateSelfSignedClientCert(ctx context.Context, r soap.RoundTripper, req *types.GenerateSelfSignedClientCert) (*types.GenerateSelfSignedClientCertResponse, error) { 5735 var reqBody, resBody GenerateSelfSignedClientCertBody 5736 5737 reqBody.Req = req 5738 5739 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5740 return nil, err 5741 } 5742 5743 return resBody.Res, nil 5744} 5745 5746type GetAlarmBody struct { 5747 Req *types.GetAlarm `xml:"urn:vim25 GetAlarm,omitempty"` 5748 Res *types.GetAlarmResponse `xml:"urn:vim25 GetAlarmResponse,omitempty"` 5749 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5750} 5751 5752func (b *GetAlarmBody) Fault() *soap.Fault { return b.Fault_ } 5753 5754func GetAlarm(ctx context.Context, r soap.RoundTripper, req *types.GetAlarm) (*types.GetAlarmResponse, error) { 5755 var reqBody, resBody GetAlarmBody 5756 5757 reqBody.Req = req 5758 5759 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5760 return nil, err 5761 } 5762 5763 return resBody.Res, nil 5764} 5765 5766type GetAlarmStateBody struct { 5767 Req *types.GetAlarmState `xml:"urn:vim25 GetAlarmState,omitempty"` 5768 Res *types.GetAlarmStateResponse `xml:"urn:vim25 GetAlarmStateResponse,omitempty"` 5769 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5770} 5771 5772func (b *GetAlarmStateBody) Fault() *soap.Fault { return b.Fault_ } 5773 5774func GetAlarmState(ctx context.Context, r soap.RoundTripper, req *types.GetAlarmState) (*types.GetAlarmStateResponse, error) { 5775 var reqBody, resBody GetAlarmStateBody 5776 5777 reqBody.Req = req 5778 5779 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5780 return nil, err 5781 } 5782 5783 return resBody.Res, nil 5784} 5785 5786type GetCustomizationSpecBody struct { 5787 Req *types.GetCustomizationSpec `xml:"urn:vim25 GetCustomizationSpec,omitempty"` 5788 Res *types.GetCustomizationSpecResponse `xml:"urn:vim25 GetCustomizationSpecResponse,omitempty"` 5789 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5790} 5791 5792func (b *GetCustomizationSpecBody) Fault() *soap.Fault { return b.Fault_ } 5793 5794func GetCustomizationSpec(ctx context.Context, r soap.RoundTripper, req *types.GetCustomizationSpec) (*types.GetCustomizationSpecResponse, error) { 5795 var reqBody, resBody GetCustomizationSpecBody 5796 5797 reqBody.Req = req 5798 5799 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5800 return nil, err 5801 } 5802 5803 return resBody.Res, nil 5804} 5805 5806type GetPublicKeyBody struct { 5807 Req *types.GetPublicKey `xml:"urn:vim25 GetPublicKey,omitempty"` 5808 Res *types.GetPublicKeyResponse `xml:"urn:vim25 GetPublicKeyResponse,omitempty"` 5809 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5810} 5811 5812func (b *GetPublicKeyBody) Fault() *soap.Fault { return b.Fault_ } 5813 5814func GetPublicKey(ctx context.Context, r soap.RoundTripper, req *types.GetPublicKey) (*types.GetPublicKeyResponse, error) { 5815 var reqBody, resBody GetPublicKeyBody 5816 5817 reqBody.Req = req 5818 5819 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5820 return nil, err 5821 } 5822 5823 return resBody.Res, nil 5824} 5825 5826type GetResourceUsageBody struct { 5827 Req *types.GetResourceUsage `xml:"urn:vim25 GetResourceUsage,omitempty"` 5828 Res *types.GetResourceUsageResponse `xml:"urn:vim25 GetResourceUsageResponse,omitempty"` 5829 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5830} 5831 5832func (b *GetResourceUsageBody) Fault() *soap.Fault { return b.Fault_ } 5833 5834func GetResourceUsage(ctx context.Context, r soap.RoundTripper, req *types.GetResourceUsage) (*types.GetResourceUsageResponse, error) { 5835 var reqBody, resBody GetResourceUsageBody 5836 5837 reqBody.Req = req 5838 5839 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5840 return nil, err 5841 } 5842 5843 return resBody.Res, nil 5844} 5845 5846type GetVchaClusterHealthBody struct { 5847 Req *types.GetVchaClusterHealth `xml:"urn:vim25 GetVchaClusterHealth,omitempty"` 5848 Res *types.GetVchaClusterHealthResponse `xml:"urn:vim25 GetVchaClusterHealthResponse,omitempty"` 5849 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5850} 5851 5852func (b *GetVchaClusterHealthBody) Fault() *soap.Fault { return b.Fault_ } 5853 5854func GetVchaClusterHealth(ctx context.Context, r soap.RoundTripper, req *types.GetVchaClusterHealth) (*types.GetVchaClusterHealthResponse, error) { 5855 var reqBody, resBody GetVchaClusterHealthBody 5856 5857 reqBody.Req = req 5858 5859 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5860 return nil, err 5861 } 5862 5863 return resBody.Res, nil 5864} 5865 5866type GetVsanObjExtAttrsBody struct { 5867 Req *types.GetVsanObjExtAttrs `xml:"urn:vim25 GetVsanObjExtAttrs,omitempty"` 5868 Res *types.GetVsanObjExtAttrsResponse `xml:"urn:vim25 GetVsanObjExtAttrsResponse,omitempty"` 5869 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5870} 5871 5872func (b *GetVsanObjExtAttrsBody) Fault() *soap.Fault { return b.Fault_ } 5873 5874func GetVsanObjExtAttrs(ctx context.Context, r soap.RoundTripper, req *types.GetVsanObjExtAttrs) (*types.GetVsanObjExtAttrsResponse, error) { 5875 var reqBody, resBody GetVsanObjExtAttrsBody 5876 5877 reqBody.Req = req 5878 5879 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5880 return nil, err 5881 } 5882 5883 return resBody.Res, nil 5884} 5885 5886type HasMonitoredEntityBody struct { 5887 Req *types.HasMonitoredEntity `xml:"urn:vim25 HasMonitoredEntity,omitempty"` 5888 Res *types.HasMonitoredEntityResponse `xml:"urn:vim25 HasMonitoredEntityResponse,omitempty"` 5889 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5890} 5891 5892func (b *HasMonitoredEntityBody) Fault() *soap.Fault { return b.Fault_ } 5893 5894func HasMonitoredEntity(ctx context.Context, r soap.RoundTripper, req *types.HasMonitoredEntity) (*types.HasMonitoredEntityResponse, error) { 5895 var reqBody, resBody HasMonitoredEntityBody 5896 5897 reqBody.Req = req 5898 5899 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5900 return nil, err 5901 } 5902 5903 return resBody.Res, nil 5904} 5905 5906type HasPrivilegeOnEntitiesBody struct { 5907 Req *types.HasPrivilegeOnEntities `xml:"urn:vim25 HasPrivilegeOnEntities,omitempty"` 5908 Res *types.HasPrivilegeOnEntitiesResponse `xml:"urn:vim25 HasPrivilegeOnEntitiesResponse,omitempty"` 5909 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5910} 5911 5912func (b *HasPrivilegeOnEntitiesBody) Fault() *soap.Fault { return b.Fault_ } 5913 5914func HasPrivilegeOnEntities(ctx context.Context, r soap.RoundTripper, req *types.HasPrivilegeOnEntities) (*types.HasPrivilegeOnEntitiesResponse, error) { 5915 var reqBody, resBody HasPrivilegeOnEntitiesBody 5916 5917 reqBody.Req = req 5918 5919 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5920 return nil, err 5921 } 5922 5923 return resBody.Res, nil 5924} 5925 5926type HasPrivilegeOnEntityBody struct { 5927 Req *types.HasPrivilegeOnEntity `xml:"urn:vim25 HasPrivilegeOnEntity,omitempty"` 5928 Res *types.HasPrivilegeOnEntityResponse `xml:"urn:vim25 HasPrivilegeOnEntityResponse,omitempty"` 5929 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5930} 5931 5932func (b *HasPrivilegeOnEntityBody) Fault() *soap.Fault { return b.Fault_ } 5933 5934func HasPrivilegeOnEntity(ctx context.Context, r soap.RoundTripper, req *types.HasPrivilegeOnEntity) (*types.HasPrivilegeOnEntityResponse, error) { 5935 var reqBody, resBody HasPrivilegeOnEntityBody 5936 5937 reqBody.Req = req 5938 5939 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5940 return nil, err 5941 } 5942 5943 return resBody.Res, nil 5944} 5945 5946type HasProviderBody struct { 5947 Req *types.HasProvider `xml:"urn:vim25 HasProvider,omitempty"` 5948 Res *types.HasProviderResponse `xml:"urn:vim25 HasProviderResponse,omitempty"` 5949 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5950} 5951 5952func (b *HasProviderBody) Fault() *soap.Fault { return b.Fault_ } 5953 5954func HasProvider(ctx context.Context, r soap.RoundTripper, req *types.HasProvider) (*types.HasProviderResponse, error) { 5955 var reqBody, resBody HasProviderBody 5956 5957 reqBody.Req = req 5958 5959 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5960 return nil, err 5961 } 5962 5963 return resBody.Res, nil 5964} 5965 5966type HasUserPrivilegeOnEntitiesBody struct { 5967 Req *types.HasUserPrivilegeOnEntities `xml:"urn:vim25 HasUserPrivilegeOnEntities,omitempty"` 5968 Res *types.HasUserPrivilegeOnEntitiesResponse `xml:"urn:vim25 HasUserPrivilegeOnEntitiesResponse,omitempty"` 5969 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5970} 5971 5972func (b *HasUserPrivilegeOnEntitiesBody) Fault() *soap.Fault { return b.Fault_ } 5973 5974func HasUserPrivilegeOnEntities(ctx context.Context, r soap.RoundTripper, req *types.HasUserPrivilegeOnEntities) (*types.HasUserPrivilegeOnEntitiesResponse, error) { 5975 var reqBody, resBody HasUserPrivilegeOnEntitiesBody 5976 5977 reqBody.Req = req 5978 5979 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 5980 return nil, err 5981 } 5982 5983 return resBody.Res, nil 5984} 5985 5986type HostClearVStorageObjectControlFlagsBody struct { 5987 Req *types.HostClearVStorageObjectControlFlags `xml:"urn:vim25 HostClearVStorageObjectControlFlags,omitempty"` 5988 Res *types.HostClearVStorageObjectControlFlagsResponse `xml:"urn:vim25 HostClearVStorageObjectControlFlagsResponse,omitempty"` 5989 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 5990} 5991 5992func (b *HostClearVStorageObjectControlFlagsBody) Fault() *soap.Fault { return b.Fault_ } 5993 5994func HostClearVStorageObjectControlFlags(ctx context.Context, r soap.RoundTripper, req *types.HostClearVStorageObjectControlFlags) (*types.HostClearVStorageObjectControlFlagsResponse, error) { 5995 var reqBody, resBody HostClearVStorageObjectControlFlagsBody 5996 5997 reqBody.Req = req 5998 5999 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6000 return nil, err 6001 } 6002 6003 return resBody.Res, nil 6004} 6005 6006type HostCloneVStorageObject_TaskBody struct { 6007 Req *types.HostCloneVStorageObject_Task `xml:"urn:vim25 HostCloneVStorageObject_Task,omitempty"` 6008 Res *types.HostCloneVStorageObject_TaskResponse `xml:"urn:vim25 HostCloneVStorageObject_TaskResponse,omitempty"` 6009 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6010} 6011 6012func (b *HostCloneVStorageObject_TaskBody) Fault() *soap.Fault { return b.Fault_ } 6013 6014func HostCloneVStorageObject_Task(ctx context.Context, r soap.RoundTripper, req *types.HostCloneVStorageObject_Task) (*types.HostCloneVStorageObject_TaskResponse, error) { 6015 var reqBody, resBody HostCloneVStorageObject_TaskBody 6016 6017 reqBody.Req = req 6018 6019 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6020 return nil, err 6021 } 6022 6023 return resBody.Res, nil 6024} 6025 6026type HostConfigVFlashCacheBody struct { 6027 Req *types.HostConfigVFlashCache `xml:"urn:vim25 HostConfigVFlashCache,omitempty"` 6028 Res *types.HostConfigVFlashCacheResponse `xml:"urn:vim25 HostConfigVFlashCacheResponse,omitempty"` 6029 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6030} 6031 6032func (b *HostConfigVFlashCacheBody) Fault() *soap.Fault { return b.Fault_ } 6033 6034func HostConfigVFlashCache(ctx context.Context, r soap.RoundTripper, req *types.HostConfigVFlashCache) (*types.HostConfigVFlashCacheResponse, error) { 6035 var reqBody, resBody HostConfigVFlashCacheBody 6036 6037 reqBody.Req = req 6038 6039 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6040 return nil, err 6041 } 6042 6043 return resBody.Res, nil 6044} 6045 6046type HostConfigureVFlashResourceBody struct { 6047 Req *types.HostConfigureVFlashResource `xml:"urn:vim25 HostConfigureVFlashResource,omitempty"` 6048 Res *types.HostConfigureVFlashResourceResponse `xml:"urn:vim25 HostConfigureVFlashResourceResponse,omitempty"` 6049 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6050} 6051 6052func (b *HostConfigureVFlashResourceBody) Fault() *soap.Fault { return b.Fault_ } 6053 6054func HostConfigureVFlashResource(ctx context.Context, r soap.RoundTripper, req *types.HostConfigureVFlashResource) (*types.HostConfigureVFlashResourceResponse, error) { 6055 var reqBody, resBody HostConfigureVFlashResourceBody 6056 6057 reqBody.Req = req 6058 6059 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6060 return nil, err 6061 } 6062 6063 return resBody.Res, nil 6064} 6065 6066type HostCreateDisk_TaskBody struct { 6067 Req *types.HostCreateDisk_Task `xml:"urn:vim25 HostCreateDisk_Task,omitempty"` 6068 Res *types.HostCreateDisk_TaskResponse `xml:"urn:vim25 HostCreateDisk_TaskResponse,omitempty"` 6069 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6070} 6071 6072func (b *HostCreateDisk_TaskBody) Fault() *soap.Fault { return b.Fault_ } 6073 6074func HostCreateDisk_Task(ctx context.Context, r soap.RoundTripper, req *types.HostCreateDisk_Task) (*types.HostCreateDisk_TaskResponse, error) { 6075 var reqBody, resBody HostCreateDisk_TaskBody 6076 6077 reqBody.Req = req 6078 6079 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6080 return nil, err 6081 } 6082 6083 return resBody.Res, nil 6084} 6085 6086type HostDeleteVStorageObject_TaskBody struct { 6087 Req *types.HostDeleteVStorageObject_Task `xml:"urn:vim25 HostDeleteVStorageObject_Task,omitempty"` 6088 Res *types.HostDeleteVStorageObject_TaskResponse `xml:"urn:vim25 HostDeleteVStorageObject_TaskResponse,omitempty"` 6089 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6090} 6091 6092func (b *HostDeleteVStorageObject_TaskBody) Fault() *soap.Fault { return b.Fault_ } 6093 6094func HostDeleteVStorageObject_Task(ctx context.Context, r soap.RoundTripper, req *types.HostDeleteVStorageObject_Task) (*types.HostDeleteVStorageObject_TaskResponse, error) { 6095 var reqBody, resBody HostDeleteVStorageObject_TaskBody 6096 6097 reqBody.Req = req 6098 6099 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6100 return nil, err 6101 } 6102 6103 return resBody.Res, nil 6104} 6105 6106type HostExtendDisk_TaskBody struct { 6107 Req *types.HostExtendDisk_Task `xml:"urn:vim25 HostExtendDisk_Task,omitempty"` 6108 Res *types.HostExtendDisk_TaskResponse `xml:"urn:vim25 HostExtendDisk_TaskResponse,omitempty"` 6109 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6110} 6111 6112func (b *HostExtendDisk_TaskBody) Fault() *soap.Fault { return b.Fault_ } 6113 6114func HostExtendDisk_Task(ctx context.Context, r soap.RoundTripper, req *types.HostExtendDisk_Task) (*types.HostExtendDisk_TaskResponse, error) { 6115 var reqBody, resBody HostExtendDisk_TaskBody 6116 6117 reqBody.Req = req 6118 6119 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6120 return nil, err 6121 } 6122 6123 return resBody.Res, nil 6124} 6125 6126type HostGetVFlashModuleDefaultConfigBody struct { 6127 Req *types.HostGetVFlashModuleDefaultConfig `xml:"urn:vim25 HostGetVFlashModuleDefaultConfig,omitempty"` 6128 Res *types.HostGetVFlashModuleDefaultConfigResponse `xml:"urn:vim25 HostGetVFlashModuleDefaultConfigResponse,omitempty"` 6129 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6130} 6131 6132func (b *HostGetVFlashModuleDefaultConfigBody) Fault() *soap.Fault { return b.Fault_ } 6133 6134func HostGetVFlashModuleDefaultConfig(ctx context.Context, r soap.RoundTripper, req *types.HostGetVFlashModuleDefaultConfig) (*types.HostGetVFlashModuleDefaultConfigResponse, error) { 6135 var reqBody, resBody HostGetVFlashModuleDefaultConfigBody 6136 6137 reqBody.Req = req 6138 6139 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6140 return nil, err 6141 } 6142 6143 return resBody.Res, nil 6144} 6145 6146type HostImageConfigGetAcceptanceBody struct { 6147 Req *types.HostImageConfigGetAcceptance `xml:"urn:vim25 HostImageConfigGetAcceptance,omitempty"` 6148 Res *types.HostImageConfigGetAcceptanceResponse `xml:"urn:vim25 HostImageConfigGetAcceptanceResponse,omitempty"` 6149 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6150} 6151 6152func (b *HostImageConfigGetAcceptanceBody) Fault() *soap.Fault { return b.Fault_ } 6153 6154func HostImageConfigGetAcceptance(ctx context.Context, r soap.RoundTripper, req *types.HostImageConfigGetAcceptance) (*types.HostImageConfigGetAcceptanceResponse, error) { 6155 var reqBody, resBody HostImageConfigGetAcceptanceBody 6156 6157 reqBody.Req = req 6158 6159 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6160 return nil, err 6161 } 6162 6163 return resBody.Res, nil 6164} 6165 6166type HostImageConfigGetProfileBody struct { 6167 Req *types.HostImageConfigGetProfile `xml:"urn:vim25 HostImageConfigGetProfile,omitempty"` 6168 Res *types.HostImageConfigGetProfileResponse `xml:"urn:vim25 HostImageConfigGetProfileResponse,omitempty"` 6169 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6170} 6171 6172func (b *HostImageConfigGetProfileBody) Fault() *soap.Fault { return b.Fault_ } 6173 6174func HostImageConfigGetProfile(ctx context.Context, r soap.RoundTripper, req *types.HostImageConfigGetProfile) (*types.HostImageConfigGetProfileResponse, error) { 6175 var reqBody, resBody HostImageConfigGetProfileBody 6176 6177 reqBody.Req = req 6178 6179 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6180 return nil, err 6181 } 6182 6183 return resBody.Res, nil 6184} 6185 6186type HostInflateDisk_TaskBody struct { 6187 Req *types.HostInflateDisk_Task `xml:"urn:vim25 HostInflateDisk_Task,omitempty"` 6188 Res *types.HostInflateDisk_TaskResponse `xml:"urn:vim25 HostInflateDisk_TaskResponse,omitempty"` 6189 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6190} 6191 6192func (b *HostInflateDisk_TaskBody) Fault() *soap.Fault { return b.Fault_ } 6193 6194func HostInflateDisk_Task(ctx context.Context, r soap.RoundTripper, req *types.HostInflateDisk_Task) (*types.HostInflateDisk_TaskResponse, error) { 6195 var reqBody, resBody HostInflateDisk_TaskBody 6196 6197 reqBody.Req = req 6198 6199 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6200 return nil, err 6201 } 6202 6203 return resBody.Res, nil 6204} 6205 6206type HostListVStorageObjectBody struct { 6207 Req *types.HostListVStorageObject `xml:"urn:vim25 HostListVStorageObject,omitempty"` 6208 Res *types.HostListVStorageObjectResponse `xml:"urn:vim25 HostListVStorageObjectResponse,omitempty"` 6209 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6210} 6211 6212func (b *HostListVStorageObjectBody) Fault() *soap.Fault { return b.Fault_ } 6213 6214func HostListVStorageObject(ctx context.Context, r soap.RoundTripper, req *types.HostListVStorageObject) (*types.HostListVStorageObjectResponse, error) { 6215 var reqBody, resBody HostListVStorageObjectBody 6216 6217 reqBody.Req = req 6218 6219 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6220 return nil, err 6221 } 6222 6223 return resBody.Res, nil 6224} 6225 6226type HostProfileResetValidationStateBody struct { 6227 Req *types.HostProfileResetValidationState `xml:"urn:vim25 HostProfileResetValidationState,omitempty"` 6228 Res *types.HostProfileResetValidationStateResponse `xml:"urn:vim25 HostProfileResetValidationStateResponse,omitempty"` 6229 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6230} 6231 6232func (b *HostProfileResetValidationStateBody) Fault() *soap.Fault { return b.Fault_ } 6233 6234func HostProfileResetValidationState(ctx context.Context, r soap.RoundTripper, req *types.HostProfileResetValidationState) (*types.HostProfileResetValidationStateResponse, error) { 6235 var reqBody, resBody HostProfileResetValidationStateBody 6236 6237 reqBody.Req = req 6238 6239 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6240 return nil, err 6241 } 6242 6243 return resBody.Res, nil 6244} 6245 6246type HostReconcileDatastoreInventory_TaskBody struct { 6247 Req *types.HostReconcileDatastoreInventory_Task `xml:"urn:vim25 HostReconcileDatastoreInventory_Task,omitempty"` 6248 Res *types.HostReconcileDatastoreInventory_TaskResponse `xml:"urn:vim25 HostReconcileDatastoreInventory_TaskResponse,omitempty"` 6249 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6250} 6251 6252func (b *HostReconcileDatastoreInventory_TaskBody) Fault() *soap.Fault { return b.Fault_ } 6253 6254func HostReconcileDatastoreInventory_Task(ctx context.Context, r soap.RoundTripper, req *types.HostReconcileDatastoreInventory_Task) (*types.HostReconcileDatastoreInventory_TaskResponse, error) { 6255 var reqBody, resBody HostReconcileDatastoreInventory_TaskBody 6256 6257 reqBody.Req = req 6258 6259 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6260 return nil, err 6261 } 6262 6263 return resBody.Res, nil 6264} 6265 6266type HostRegisterDiskBody struct { 6267 Req *types.HostRegisterDisk `xml:"urn:vim25 HostRegisterDisk,omitempty"` 6268 Res *types.HostRegisterDiskResponse `xml:"urn:vim25 HostRegisterDiskResponse,omitempty"` 6269 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6270} 6271 6272func (b *HostRegisterDiskBody) Fault() *soap.Fault { return b.Fault_ } 6273 6274func HostRegisterDisk(ctx context.Context, r soap.RoundTripper, req *types.HostRegisterDisk) (*types.HostRegisterDiskResponse, error) { 6275 var reqBody, resBody HostRegisterDiskBody 6276 6277 reqBody.Req = req 6278 6279 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6280 return nil, err 6281 } 6282 6283 return resBody.Res, nil 6284} 6285 6286type HostRelocateVStorageObject_TaskBody struct { 6287 Req *types.HostRelocateVStorageObject_Task `xml:"urn:vim25 HostRelocateVStorageObject_Task,omitempty"` 6288 Res *types.HostRelocateVStorageObject_TaskResponse `xml:"urn:vim25 HostRelocateVStorageObject_TaskResponse,omitempty"` 6289 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6290} 6291 6292func (b *HostRelocateVStorageObject_TaskBody) Fault() *soap.Fault { return b.Fault_ } 6293 6294func HostRelocateVStorageObject_Task(ctx context.Context, r soap.RoundTripper, req *types.HostRelocateVStorageObject_Task) (*types.HostRelocateVStorageObject_TaskResponse, error) { 6295 var reqBody, resBody HostRelocateVStorageObject_TaskBody 6296 6297 reqBody.Req = req 6298 6299 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6300 return nil, err 6301 } 6302 6303 return resBody.Res, nil 6304} 6305 6306type HostRemoveVFlashResourceBody struct { 6307 Req *types.HostRemoveVFlashResource `xml:"urn:vim25 HostRemoveVFlashResource,omitempty"` 6308 Res *types.HostRemoveVFlashResourceResponse `xml:"urn:vim25 HostRemoveVFlashResourceResponse,omitempty"` 6309 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6310} 6311 6312func (b *HostRemoveVFlashResourceBody) Fault() *soap.Fault { return b.Fault_ } 6313 6314func HostRemoveVFlashResource(ctx context.Context, r soap.RoundTripper, req *types.HostRemoveVFlashResource) (*types.HostRemoveVFlashResourceResponse, error) { 6315 var reqBody, resBody HostRemoveVFlashResourceBody 6316 6317 reqBody.Req = req 6318 6319 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6320 return nil, err 6321 } 6322 6323 return resBody.Res, nil 6324} 6325 6326type HostRenameVStorageObjectBody struct { 6327 Req *types.HostRenameVStorageObject `xml:"urn:vim25 HostRenameVStorageObject,omitempty"` 6328 Res *types.HostRenameVStorageObjectResponse `xml:"urn:vim25 HostRenameVStorageObjectResponse,omitempty"` 6329 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6330} 6331 6332func (b *HostRenameVStorageObjectBody) Fault() *soap.Fault { return b.Fault_ } 6333 6334func HostRenameVStorageObject(ctx context.Context, r soap.RoundTripper, req *types.HostRenameVStorageObject) (*types.HostRenameVStorageObjectResponse, error) { 6335 var reqBody, resBody HostRenameVStorageObjectBody 6336 6337 reqBody.Req = req 6338 6339 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6340 return nil, err 6341 } 6342 6343 return resBody.Res, nil 6344} 6345 6346type HostRetrieveVStorageInfrastructureObjectPolicyBody struct { 6347 Req *types.HostRetrieveVStorageInfrastructureObjectPolicy `xml:"urn:vim25 HostRetrieveVStorageInfrastructureObjectPolicy,omitempty"` 6348 Res *types.HostRetrieveVStorageInfrastructureObjectPolicyResponse `xml:"urn:vim25 HostRetrieveVStorageInfrastructureObjectPolicyResponse,omitempty"` 6349 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6350} 6351 6352func (b *HostRetrieveVStorageInfrastructureObjectPolicyBody) Fault() *soap.Fault { return b.Fault_ } 6353 6354func HostRetrieveVStorageInfrastructureObjectPolicy(ctx context.Context, r soap.RoundTripper, req *types.HostRetrieveVStorageInfrastructureObjectPolicy) (*types.HostRetrieveVStorageInfrastructureObjectPolicyResponse, error) { 6355 var reqBody, resBody HostRetrieveVStorageInfrastructureObjectPolicyBody 6356 6357 reqBody.Req = req 6358 6359 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6360 return nil, err 6361 } 6362 6363 return resBody.Res, nil 6364} 6365 6366type HostRetrieveVStorageObjectBody struct { 6367 Req *types.HostRetrieveVStorageObject `xml:"urn:vim25 HostRetrieveVStorageObject,omitempty"` 6368 Res *types.HostRetrieveVStorageObjectResponse `xml:"urn:vim25 HostRetrieveVStorageObjectResponse,omitempty"` 6369 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6370} 6371 6372func (b *HostRetrieveVStorageObjectBody) Fault() *soap.Fault { return b.Fault_ } 6373 6374func HostRetrieveVStorageObject(ctx context.Context, r soap.RoundTripper, req *types.HostRetrieveVStorageObject) (*types.HostRetrieveVStorageObjectResponse, error) { 6375 var reqBody, resBody HostRetrieveVStorageObjectBody 6376 6377 reqBody.Req = req 6378 6379 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6380 return nil, err 6381 } 6382 6383 return resBody.Res, nil 6384} 6385 6386type HostRetrieveVStorageObjectStateBody struct { 6387 Req *types.HostRetrieveVStorageObjectState `xml:"urn:vim25 HostRetrieveVStorageObjectState,omitempty"` 6388 Res *types.HostRetrieveVStorageObjectStateResponse `xml:"urn:vim25 HostRetrieveVStorageObjectStateResponse,omitempty"` 6389 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6390} 6391 6392func (b *HostRetrieveVStorageObjectStateBody) Fault() *soap.Fault { return b.Fault_ } 6393 6394func HostRetrieveVStorageObjectState(ctx context.Context, r soap.RoundTripper, req *types.HostRetrieveVStorageObjectState) (*types.HostRetrieveVStorageObjectStateResponse, error) { 6395 var reqBody, resBody HostRetrieveVStorageObjectStateBody 6396 6397 reqBody.Req = req 6398 6399 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6400 return nil, err 6401 } 6402 6403 return resBody.Res, nil 6404} 6405 6406type HostScheduleReconcileDatastoreInventoryBody struct { 6407 Req *types.HostScheduleReconcileDatastoreInventory `xml:"urn:vim25 HostScheduleReconcileDatastoreInventory,omitempty"` 6408 Res *types.HostScheduleReconcileDatastoreInventoryResponse `xml:"urn:vim25 HostScheduleReconcileDatastoreInventoryResponse,omitempty"` 6409 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6410} 6411 6412func (b *HostScheduleReconcileDatastoreInventoryBody) Fault() *soap.Fault { return b.Fault_ } 6413 6414func HostScheduleReconcileDatastoreInventory(ctx context.Context, r soap.RoundTripper, req *types.HostScheduleReconcileDatastoreInventory) (*types.HostScheduleReconcileDatastoreInventoryResponse, error) { 6415 var reqBody, resBody HostScheduleReconcileDatastoreInventoryBody 6416 6417 reqBody.Req = req 6418 6419 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6420 return nil, err 6421 } 6422 6423 return resBody.Res, nil 6424} 6425 6426type HostSetVStorageObjectControlFlagsBody struct { 6427 Req *types.HostSetVStorageObjectControlFlags `xml:"urn:vim25 HostSetVStorageObjectControlFlags,omitempty"` 6428 Res *types.HostSetVStorageObjectControlFlagsResponse `xml:"urn:vim25 HostSetVStorageObjectControlFlagsResponse,omitempty"` 6429 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6430} 6431 6432func (b *HostSetVStorageObjectControlFlagsBody) Fault() *soap.Fault { return b.Fault_ } 6433 6434func HostSetVStorageObjectControlFlags(ctx context.Context, r soap.RoundTripper, req *types.HostSetVStorageObjectControlFlags) (*types.HostSetVStorageObjectControlFlagsResponse, error) { 6435 var reqBody, resBody HostSetVStorageObjectControlFlagsBody 6436 6437 reqBody.Req = req 6438 6439 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6440 return nil, err 6441 } 6442 6443 return resBody.Res, nil 6444} 6445 6446type HostSpecGetUpdatedHostsBody struct { 6447 Req *types.HostSpecGetUpdatedHosts `xml:"urn:vim25 HostSpecGetUpdatedHosts,omitempty"` 6448 Res *types.HostSpecGetUpdatedHostsResponse `xml:"urn:vim25 HostSpecGetUpdatedHostsResponse,omitempty"` 6449 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6450} 6451 6452func (b *HostSpecGetUpdatedHostsBody) Fault() *soap.Fault { return b.Fault_ } 6453 6454func HostSpecGetUpdatedHosts(ctx context.Context, r soap.RoundTripper, req *types.HostSpecGetUpdatedHosts) (*types.HostSpecGetUpdatedHostsResponse, error) { 6455 var reqBody, resBody HostSpecGetUpdatedHostsBody 6456 6457 reqBody.Req = req 6458 6459 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6460 return nil, err 6461 } 6462 6463 return resBody.Res, nil 6464} 6465 6466type HostVStorageObjectCreateDiskFromSnapshot_TaskBody struct { 6467 Req *types.HostVStorageObjectCreateDiskFromSnapshot_Task `xml:"urn:vim25 HostVStorageObjectCreateDiskFromSnapshot_Task,omitempty"` 6468 Res *types.HostVStorageObjectCreateDiskFromSnapshot_TaskResponse `xml:"urn:vim25 HostVStorageObjectCreateDiskFromSnapshot_TaskResponse,omitempty"` 6469 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6470} 6471 6472func (b *HostVStorageObjectCreateDiskFromSnapshot_TaskBody) Fault() *soap.Fault { return b.Fault_ } 6473 6474func HostVStorageObjectCreateDiskFromSnapshot_Task(ctx context.Context, r soap.RoundTripper, req *types.HostVStorageObjectCreateDiskFromSnapshot_Task) (*types.HostVStorageObjectCreateDiskFromSnapshot_TaskResponse, error) { 6475 var reqBody, resBody HostVStorageObjectCreateDiskFromSnapshot_TaskBody 6476 6477 reqBody.Req = req 6478 6479 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6480 return nil, err 6481 } 6482 6483 return resBody.Res, nil 6484} 6485 6486type HostVStorageObjectCreateSnapshot_TaskBody struct { 6487 Req *types.HostVStorageObjectCreateSnapshot_Task `xml:"urn:vim25 HostVStorageObjectCreateSnapshot_Task,omitempty"` 6488 Res *types.HostVStorageObjectCreateSnapshot_TaskResponse `xml:"urn:vim25 HostVStorageObjectCreateSnapshot_TaskResponse,omitempty"` 6489 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6490} 6491 6492func (b *HostVStorageObjectCreateSnapshot_TaskBody) Fault() *soap.Fault { return b.Fault_ } 6493 6494func HostVStorageObjectCreateSnapshot_Task(ctx context.Context, r soap.RoundTripper, req *types.HostVStorageObjectCreateSnapshot_Task) (*types.HostVStorageObjectCreateSnapshot_TaskResponse, error) { 6495 var reqBody, resBody HostVStorageObjectCreateSnapshot_TaskBody 6496 6497 reqBody.Req = req 6498 6499 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6500 return nil, err 6501 } 6502 6503 return resBody.Res, nil 6504} 6505 6506type HostVStorageObjectDeleteSnapshot_TaskBody struct { 6507 Req *types.HostVStorageObjectDeleteSnapshot_Task `xml:"urn:vim25 HostVStorageObjectDeleteSnapshot_Task,omitempty"` 6508 Res *types.HostVStorageObjectDeleteSnapshot_TaskResponse `xml:"urn:vim25 HostVStorageObjectDeleteSnapshot_TaskResponse,omitempty"` 6509 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6510} 6511 6512func (b *HostVStorageObjectDeleteSnapshot_TaskBody) Fault() *soap.Fault { return b.Fault_ } 6513 6514func HostVStorageObjectDeleteSnapshot_Task(ctx context.Context, r soap.RoundTripper, req *types.HostVStorageObjectDeleteSnapshot_Task) (*types.HostVStorageObjectDeleteSnapshot_TaskResponse, error) { 6515 var reqBody, resBody HostVStorageObjectDeleteSnapshot_TaskBody 6516 6517 reqBody.Req = req 6518 6519 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6520 return nil, err 6521 } 6522 6523 return resBody.Res, nil 6524} 6525 6526type HostVStorageObjectRetrieveSnapshotInfoBody struct { 6527 Req *types.HostVStorageObjectRetrieveSnapshotInfo `xml:"urn:vim25 HostVStorageObjectRetrieveSnapshotInfo,omitempty"` 6528 Res *types.HostVStorageObjectRetrieveSnapshotInfoResponse `xml:"urn:vim25 HostVStorageObjectRetrieveSnapshotInfoResponse,omitempty"` 6529 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6530} 6531 6532func (b *HostVStorageObjectRetrieveSnapshotInfoBody) Fault() *soap.Fault { return b.Fault_ } 6533 6534func HostVStorageObjectRetrieveSnapshotInfo(ctx context.Context, r soap.RoundTripper, req *types.HostVStorageObjectRetrieveSnapshotInfo) (*types.HostVStorageObjectRetrieveSnapshotInfoResponse, error) { 6535 var reqBody, resBody HostVStorageObjectRetrieveSnapshotInfoBody 6536 6537 reqBody.Req = req 6538 6539 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6540 return nil, err 6541 } 6542 6543 return resBody.Res, nil 6544} 6545 6546type HostVStorageObjectRevert_TaskBody struct { 6547 Req *types.HostVStorageObjectRevert_Task `xml:"urn:vim25 HostVStorageObjectRevert_Task,omitempty"` 6548 Res *types.HostVStorageObjectRevert_TaskResponse `xml:"urn:vim25 HostVStorageObjectRevert_TaskResponse,omitempty"` 6549 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6550} 6551 6552func (b *HostVStorageObjectRevert_TaskBody) Fault() *soap.Fault { return b.Fault_ } 6553 6554func HostVStorageObjectRevert_Task(ctx context.Context, r soap.RoundTripper, req *types.HostVStorageObjectRevert_Task) (*types.HostVStorageObjectRevert_TaskResponse, error) { 6555 var reqBody, resBody HostVStorageObjectRevert_TaskBody 6556 6557 reqBody.Req = req 6558 6559 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6560 return nil, err 6561 } 6562 6563 return resBody.Res, nil 6564} 6565 6566type HttpNfcLeaseAbortBody struct { 6567 Req *types.HttpNfcLeaseAbort `xml:"urn:vim25 HttpNfcLeaseAbort,omitempty"` 6568 Res *types.HttpNfcLeaseAbortResponse `xml:"urn:vim25 HttpNfcLeaseAbortResponse,omitempty"` 6569 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6570} 6571 6572func (b *HttpNfcLeaseAbortBody) Fault() *soap.Fault { return b.Fault_ } 6573 6574func HttpNfcLeaseAbort(ctx context.Context, r soap.RoundTripper, req *types.HttpNfcLeaseAbort) (*types.HttpNfcLeaseAbortResponse, error) { 6575 var reqBody, resBody HttpNfcLeaseAbortBody 6576 6577 reqBody.Req = req 6578 6579 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6580 return nil, err 6581 } 6582 6583 return resBody.Res, nil 6584} 6585 6586type HttpNfcLeaseCompleteBody struct { 6587 Req *types.HttpNfcLeaseComplete `xml:"urn:vim25 HttpNfcLeaseComplete,omitempty"` 6588 Res *types.HttpNfcLeaseCompleteResponse `xml:"urn:vim25 HttpNfcLeaseCompleteResponse,omitempty"` 6589 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6590} 6591 6592func (b *HttpNfcLeaseCompleteBody) Fault() *soap.Fault { return b.Fault_ } 6593 6594func HttpNfcLeaseComplete(ctx context.Context, r soap.RoundTripper, req *types.HttpNfcLeaseComplete) (*types.HttpNfcLeaseCompleteResponse, error) { 6595 var reqBody, resBody HttpNfcLeaseCompleteBody 6596 6597 reqBody.Req = req 6598 6599 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6600 return nil, err 6601 } 6602 6603 return resBody.Res, nil 6604} 6605 6606type HttpNfcLeaseGetManifestBody struct { 6607 Req *types.HttpNfcLeaseGetManifest `xml:"urn:vim25 HttpNfcLeaseGetManifest,omitempty"` 6608 Res *types.HttpNfcLeaseGetManifestResponse `xml:"urn:vim25 HttpNfcLeaseGetManifestResponse,omitempty"` 6609 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6610} 6611 6612func (b *HttpNfcLeaseGetManifestBody) Fault() *soap.Fault { return b.Fault_ } 6613 6614func HttpNfcLeaseGetManifest(ctx context.Context, r soap.RoundTripper, req *types.HttpNfcLeaseGetManifest) (*types.HttpNfcLeaseGetManifestResponse, error) { 6615 var reqBody, resBody HttpNfcLeaseGetManifestBody 6616 6617 reqBody.Req = req 6618 6619 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6620 return nil, err 6621 } 6622 6623 return resBody.Res, nil 6624} 6625 6626type HttpNfcLeaseProgressBody struct { 6627 Req *types.HttpNfcLeaseProgress `xml:"urn:vim25 HttpNfcLeaseProgress,omitempty"` 6628 Res *types.HttpNfcLeaseProgressResponse `xml:"urn:vim25 HttpNfcLeaseProgressResponse,omitempty"` 6629 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6630} 6631 6632func (b *HttpNfcLeaseProgressBody) Fault() *soap.Fault { return b.Fault_ } 6633 6634func HttpNfcLeaseProgress(ctx context.Context, r soap.RoundTripper, req *types.HttpNfcLeaseProgress) (*types.HttpNfcLeaseProgressResponse, error) { 6635 var reqBody, resBody HttpNfcLeaseProgressBody 6636 6637 reqBody.Req = req 6638 6639 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6640 return nil, err 6641 } 6642 6643 return resBody.Res, nil 6644} 6645 6646type HttpNfcLeasePullFromUrls_TaskBody struct { 6647 Req *types.HttpNfcLeasePullFromUrls_Task `xml:"urn:vim25 HttpNfcLeasePullFromUrls_Task,omitempty"` 6648 Res *types.HttpNfcLeasePullFromUrls_TaskResponse `xml:"urn:vim25 HttpNfcLeasePullFromUrls_TaskResponse,omitempty"` 6649 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6650} 6651 6652func (b *HttpNfcLeasePullFromUrls_TaskBody) Fault() *soap.Fault { return b.Fault_ } 6653 6654func HttpNfcLeasePullFromUrls_Task(ctx context.Context, r soap.RoundTripper, req *types.HttpNfcLeasePullFromUrls_Task) (*types.HttpNfcLeasePullFromUrls_TaskResponse, error) { 6655 var reqBody, resBody HttpNfcLeasePullFromUrls_TaskBody 6656 6657 reqBody.Req = req 6658 6659 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6660 return nil, err 6661 } 6662 6663 return resBody.Res, nil 6664} 6665 6666type HttpNfcLeaseSetManifestChecksumTypeBody struct { 6667 Req *types.HttpNfcLeaseSetManifestChecksumType `xml:"urn:vim25 HttpNfcLeaseSetManifestChecksumType,omitempty"` 6668 Res *types.HttpNfcLeaseSetManifestChecksumTypeResponse `xml:"urn:vim25 HttpNfcLeaseSetManifestChecksumTypeResponse,omitempty"` 6669 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6670} 6671 6672func (b *HttpNfcLeaseSetManifestChecksumTypeBody) Fault() *soap.Fault { return b.Fault_ } 6673 6674func HttpNfcLeaseSetManifestChecksumType(ctx context.Context, r soap.RoundTripper, req *types.HttpNfcLeaseSetManifestChecksumType) (*types.HttpNfcLeaseSetManifestChecksumTypeResponse, error) { 6675 var reqBody, resBody HttpNfcLeaseSetManifestChecksumTypeBody 6676 6677 reqBody.Req = req 6678 6679 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6680 return nil, err 6681 } 6682 6683 return resBody.Res, nil 6684} 6685 6686type ImpersonateUserBody struct { 6687 Req *types.ImpersonateUser `xml:"urn:vim25 ImpersonateUser,omitempty"` 6688 Res *types.ImpersonateUserResponse `xml:"urn:vim25 ImpersonateUserResponse,omitempty"` 6689 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6690} 6691 6692func (b *ImpersonateUserBody) Fault() *soap.Fault { return b.Fault_ } 6693 6694func ImpersonateUser(ctx context.Context, r soap.RoundTripper, req *types.ImpersonateUser) (*types.ImpersonateUserResponse, error) { 6695 var reqBody, resBody ImpersonateUserBody 6696 6697 reqBody.Req = req 6698 6699 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6700 return nil, err 6701 } 6702 6703 return resBody.Res, nil 6704} 6705 6706type ImportCertificateForCAM_TaskBody struct { 6707 Req *types.ImportCertificateForCAM_Task `xml:"urn:vim25 ImportCertificateForCAM_Task,omitempty"` 6708 Res *types.ImportCertificateForCAM_TaskResponse `xml:"urn:vim25 ImportCertificateForCAM_TaskResponse,omitempty"` 6709 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6710} 6711 6712func (b *ImportCertificateForCAM_TaskBody) Fault() *soap.Fault { return b.Fault_ } 6713 6714func ImportCertificateForCAM_Task(ctx context.Context, r soap.RoundTripper, req *types.ImportCertificateForCAM_Task) (*types.ImportCertificateForCAM_TaskResponse, error) { 6715 var reqBody, resBody ImportCertificateForCAM_TaskBody 6716 6717 reqBody.Req = req 6718 6719 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6720 return nil, err 6721 } 6722 6723 return resBody.Res, nil 6724} 6725 6726type ImportUnmanagedSnapshotBody struct { 6727 Req *types.ImportUnmanagedSnapshot `xml:"urn:vim25 ImportUnmanagedSnapshot,omitempty"` 6728 Res *types.ImportUnmanagedSnapshotResponse `xml:"urn:vim25 ImportUnmanagedSnapshotResponse,omitempty"` 6729 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6730} 6731 6732func (b *ImportUnmanagedSnapshotBody) Fault() *soap.Fault { return b.Fault_ } 6733 6734func ImportUnmanagedSnapshot(ctx context.Context, r soap.RoundTripper, req *types.ImportUnmanagedSnapshot) (*types.ImportUnmanagedSnapshotResponse, error) { 6735 var reqBody, resBody ImportUnmanagedSnapshotBody 6736 6737 reqBody.Req = req 6738 6739 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6740 return nil, err 6741 } 6742 6743 return resBody.Res, nil 6744} 6745 6746type ImportVAppBody struct { 6747 Req *types.ImportVApp `xml:"urn:vim25 ImportVApp,omitempty"` 6748 Res *types.ImportVAppResponse `xml:"urn:vim25 ImportVAppResponse,omitempty"` 6749 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6750} 6751 6752func (b *ImportVAppBody) Fault() *soap.Fault { return b.Fault_ } 6753 6754func ImportVApp(ctx context.Context, r soap.RoundTripper, req *types.ImportVApp) (*types.ImportVAppResponse, error) { 6755 var reqBody, resBody ImportVAppBody 6756 6757 reqBody.Req = req 6758 6759 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6760 return nil, err 6761 } 6762 6763 return resBody.Res, nil 6764} 6765 6766type InflateDisk_TaskBody struct { 6767 Req *types.InflateDisk_Task `xml:"urn:vim25 InflateDisk_Task,omitempty"` 6768 Res *types.InflateDisk_TaskResponse `xml:"urn:vim25 InflateDisk_TaskResponse,omitempty"` 6769 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6770} 6771 6772func (b *InflateDisk_TaskBody) Fault() *soap.Fault { return b.Fault_ } 6773 6774func InflateDisk_Task(ctx context.Context, r soap.RoundTripper, req *types.InflateDisk_Task) (*types.InflateDisk_TaskResponse, error) { 6775 var reqBody, resBody InflateDisk_TaskBody 6776 6777 reqBody.Req = req 6778 6779 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6780 return nil, err 6781 } 6782 6783 return resBody.Res, nil 6784} 6785 6786type InflateVirtualDisk_TaskBody struct { 6787 Req *types.InflateVirtualDisk_Task `xml:"urn:vim25 InflateVirtualDisk_Task,omitempty"` 6788 Res *types.InflateVirtualDisk_TaskResponse `xml:"urn:vim25 InflateVirtualDisk_TaskResponse,omitempty"` 6789 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6790} 6791 6792func (b *InflateVirtualDisk_TaskBody) Fault() *soap.Fault { return b.Fault_ } 6793 6794func InflateVirtualDisk_Task(ctx context.Context, r soap.RoundTripper, req *types.InflateVirtualDisk_Task) (*types.InflateVirtualDisk_TaskResponse, error) { 6795 var reqBody, resBody InflateVirtualDisk_TaskBody 6796 6797 reqBody.Req = req 6798 6799 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6800 return nil, err 6801 } 6802 6803 return resBody.Res, nil 6804} 6805 6806type InitializeDisks_TaskBody struct { 6807 Req *types.InitializeDisks_Task `xml:"urn:vim25 InitializeDisks_Task,omitempty"` 6808 Res *types.InitializeDisks_TaskResponse `xml:"urn:vim25 InitializeDisks_TaskResponse,omitempty"` 6809 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6810} 6811 6812func (b *InitializeDisks_TaskBody) Fault() *soap.Fault { return b.Fault_ } 6813 6814func InitializeDisks_Task(ctx context.Context, r soap.RoundTripper, req *types.InitializeDisks_Task) (*types.InitializeDisks_TaskResponse, error) { 6815 var reqBody, resBody InitializeDisks_TaskBody 6816 6817 reqBody.Req = req 6818 6819 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6820 return nil, err 6821 } 6822 6823 return resBody.Res, nil 6824} 6825 6826type InitiateFileTransferFromGuestBody struct { 6827 Req *types.InitiateFileTransferFromGuest `xml:"urn:vim25 InitiateFileTransferFromGuest,omitempty"` 6828 Res *types.InitiateFileTransferFromGuestResponse `xml:"urn:vim25 InitiateFileTransferFromGuestResponse,omitempty"` 6829 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6830} 6831 6832func (b *InitiateFileTransferFromGuestBody) Fault() *soap.Fault { return b.Fault_ } 6833 6834func InitiateFileTransferFromGuest(ctx context.Context, r soap.RoundTripper, req *types.InitiateFileTransferFromGuest) (*types.InitiateFileTransferFromGuestResponse, error) { 6835 var reqBody, resBody InitiateFileTransferFromGuestBody 6836 6837 reqBody.Req = req 6838 6839 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6840 return nil, err 6841 } 6842 6843 return resBody.Res, nil 6844} 6845 6846type InitiateFileTransferToGuestBody struct { 6847 Req *types.InitiateFileTransferToGuest `xml:"urn:vim25 InitiateFileTransferToGuest,omitempty"` 6848 Res *types.InitiateFileTransferToGuestResponse `xml:"urn:vim25 InitiateFileTransferToGuestResponse,omitempty"` 6849 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6850} 6851 6852func (b *InitiateFileTransferToGuestBody) Fault() *soap.Fault { return b.Fault_ } 6853 6854func InitiateFileTransferToGuest(ctx context.Context, r soap.RoundTripper, req *types.InitiateFileTransferToGuest) (*types.InitiateFileTransferToGuestResponse, error) { 6855 var reqBody, resBody InitiateFileTransferToGuestBody 6856 6857 reqBody.Req = req 6858 6859 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6860 return nil, err 6861 } 6862 6863 return resBody.Res, nil 6864} 6865 6866type InstallHostPatchV2_TaskBody struct { 6867 Req *types.InstallHostPatchV2_Task `xml:"urn:vim25 InstallHostPatchV2_Task,omitempty"` 6868 Res *types.InstallHostPatchV2_TaskResponse `xml:"urn:vim25 InstallHostPatchV2_TaskResponse,omitempty"` 6869 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6870} 6871 6872func (b *InstallHostPatchV2_TaskBody) Fault() *soap.Fault { return b.Fault_ } 6873 6874func InstallHostPatchV2_Task(ctx context.Context, r soap.RoundTripper, req *types.InstallHostPatchV2_Task) (*types.InstallHostPatchV2_TaskResponse, error) { 6875 var reqBody, resBody InstallHostPatchV2_TaskBody 6876 6877 reqBody.Req = req 6878 6879 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6880 return nil, err 6881 } 6882 6883 return resBody.Res, nil 6884} 6885 6886type InstallHostPatch_TaskBody struct { 6887 Req *types.InstallHostPatch_Task `xml:"urn:vim25 InstallHostPatch_Task,omitempty"` 6888 Res *types.InstallHostPatch_TaskResponse `xml:"urn:vim25 InstallHostPatch_TaskResponse,omitempty"` 6889 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6890} 6891 6892func (b *InstallHostPatch_TaskBody) Fault() *soap.Fault { return b.Fault_ } 6893 6894func InstallHostPatch_Task(ctx context.Context, r soap.RoundTripper, req *types.InstallHostPatch_Task) (*types.InstallHostPatch_TaskResponse, error) { 6895 var reqBody, resBody InstallHostPatch_TaskBody 6896 6897 reqBody.Req = req 6898 6899 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6900 return nil, err 6901 } 6902 6903 return resBody.Res, nil 6904} 6905 6906type InstallIoFilter_TaskBody struct { 6907 Req *types.InstallIoFilter_Task `xml:"urn:vim25 InstallIoFilter_Task,omitempty"` 6908 Res *types.InstallIoFilter_TaskResponse `xml:"urn:vim25 InstallIoFilter_TaskResponse,omitempty"` 6909 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6910} 6911 6912func (b *InstallIoFilter_TaskBody) Fault() *soap.Fault { return b.Fault_ } 6913 6914func InstallIoFilter_Task(ctx context.Context, r soap.RoundTripper, req *types.InstallIoFilter_Task) (*types.InstallIoFilter_TaskResponse, error) { 6915 var reqBody, resBody InstallIoFilter_TaskBody 6916 6917 reqBody.Req = req 6918 6919 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6920 return nil, err 6921 } 6922 6923 return resBody.Res, nil 6924} 6925 6926type InstallServerCertificateBody struct { 6927 Req *types.InstallServerCertificate `xml:"urn:vim25 InstallServerCertificate,omitempty"` 6928 Res *types.InstallServerCertificateResponse `xml:"urn:vim25 InstallServerCertificateResponse,omitempty"` 6929 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6930} 6931 6932func (b *InstallServerCertificateBody) Fault() *soap.Fault { return b.Fault_ } 6933 6934func InstallServerCertificate(ctx context.Context, r soap.RoundTripper, req *types.InstallServerCertificate) (*types.InstallServerCertificateResponse, error) { 6935 var reqBody, resBody InstallServerCertificateBody 6936 6937 reqBody.Req = req 6938 6939 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6940 return nil, err 6941 } 6942 6943 return resBody.Res, nil 6944} 6945 6946type InstallSmartCardTrustAnchorBody struct { 6947 Req *types.InstallSmartCardTrustAnchor `xml:"urn:vim25 InstallSmartCardTrustAnchor,omitempty"` 6948 Res *types.InstallSmartCardTrustAnchorResponse `xml:"urn:vim25 InstallSmartCardTrustAnchorResponse,omitempty"` 6949 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6950} 6951 6952func (b *InstallSmartCardTrustAnchorBody) Fault() *soap.Fault { return b.Fault_ } 6953 6954func InstallSmartCardTrustAnchor(ctx context.Context, r soap.RoundTripper, req *types.InstallSmartCardTrustAnchor) (*types.InstallSmartCardTrustAnchorResponse, error) { 6955 var reqBody, resBody InstallSmartCardTrustAnchorBody 6956 6957 reqBody.Req = req 6958 6959 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6960 return nil, err 6961 } 6962 6963 return resBody.Res, nil 6964} 6965 6966type InstantClone_TaskBody struct { 6967 Req *types.InstantClone_Task `xml:"urn:vim25 InstantClone_Task,omitempty"` 6968 Res *types.InstantClone_TaskResponse `xml:"urn:vim25 InstantClone_TaskResponse,omitempty"` 6969 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6970} 6971 6972func (b *InstantClone_TaskBody) Fault() *soap.Fault { return b.Fault_ } 6973 6974func InstantClone_Task(ctx context.Context, r soap.RoundTripper, req *types.InstantClone_Task) (*types.InstantClone_TaskResponse, error) { 6975 var reqBody, resBody InstantClone_TaskBody 6976 6977 reqBody.Req = req 6978 6979 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 6980 return nil, err 6981 } 6982 6983 return resBody.Res, nil 6984} 6985 6986type IsSharedGraphicsActiveBody struct { 6987 Req *types.IsSharedGraphicsActive `xml:"urn:vim25 IsSharedGraphicsActive,omitempty"` 6988 Res *types.IsSharedGraphicsActiveResponse `xml:"urn:vim25 IsSharedGraphicsActiveResponse,omitempty"` 6989 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 6990} 6991 6992func (b *IsSharedGraphicsActiveBody) Fault() *soap.Fault { return b.Fault_ } 6993 6994func IsSharedGraphicsActive(ctx context.Context, r soap.RoundTripper, req *types.IsSharedGraphicsActive) (*types.IsSharedGraphicsActiveResponse, error) { 6995 var reqBody, resBody IsSharedGraphicsActiveBody 6996 6997 reqBody.Req = req 6998 6999 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7000 return nil, err 7001 } 7002 7003 return resBody.Res, nil 7004} 7005 7006type JoinDomainWithCAM_TaskBody struct { 7007 Req *types.JoinDomainWithCAM_Task `xml:"urn:vim25 JoinDomainWithCAM_Task,omitempty"` 7008 Res *types.JoinDomainWithCAM_TaskResponse `xml:"urn:vim25 JoinDomainWithCAM_TaskResponse,omitempty"` 7009 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7010} 7011 7012func (b *JoinDomainWithCAM_TaskBody) Fault() *soap.Fault { return b.Fault_ } 7013 7014func JoinDomainWithCAM_Task(ctx context.Context, r soap.RoundTripper, req *types.JoinDomainWithCAM_Task) (*types.JoinDomainWithCAM_TaskResponse, error) { 7015 var reqBody, resBody JoinDomainWithCAM_TaskBody 7016 7017 reqBody.Req = req 7018 7019 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7020 return nil, err 7021 } 7022 7023 return resBody.Res, nil 7024} 7025 7026type JoinDomain_TaskBody struct { 7027 Req *types.JoinDomain_Task `xml:"urn:vim25 JoinDomain_Task,omitempty"` 7028 Res *types.JoinDomain_TaskResponse `xml:"urn:vim25 JoinDomain_TaskResponse,omitempty"` 7029 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7030} 7031 7032func (b *JoinDomain_TaskBody) Fault() *soap.Fault { return b.Fault_ } 7033 7034func JoinDomain_Task(ctx context.Context, r soap.RoundTripper, req *types.JoinDomain_Task) (*types.JoinDomain_TaskResponse, error) { 7035 var reqBody, resBody JoinDomain_TaskBody 7036 7037 reqBody.Req = req 7038 7039 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7040 return nil, err 7041 } 7042 7043 return resBody.Res, nil 7044} 7045 7046type LeaveCurrentDomain_TaskBody struct { 7047 Req *types.LeaveCurrentDomain_Task `xml:"urn:vim25 LeaveCurrentDomain_Task,omitempty"` 7048 Res *types.LeaveCurrentDomain_TaskResponse `xml:"urn:vim25 LeaveCurrentDomain_TaskResponse,omitempty"` 7049 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7050} 7051 7052func (b *LeaveCurrentDomain_TaskBody) Fault() *soap.Fault { return b.Fault_ } 7053 7054func LeaveCurrentDomain_Task(ctx context.Context, r soap.RoundTripper, req *types.LeaveCurrentDomain_Task) (*types.LeaveCurrentDomain_TaskResponse, error) { 7055 var reqBody, resBody LeaveCurrentDomain_TaskBody 7056 7057 reqBody.Req = req 7058 7059 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7060 return nil, err 7061 } 7062 7063 return resBody.Res, nil 7064} 7065 7066type ListCACertificateRevocationListsBody struct { 7067 Req *types.ListCACertificateRevocationLists `xml:"urn:vim25 ListCACertificateRevocationLists,omitempty"` 7068 Res *types.ListCACertificateRevocationListsResponse `xml:"urn:vim25 ListCACertificateRevocationListsResponse,omitempty"` 7069 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7070} 7071 7072func (b *ListCACertificateRevocationListsBody) Fault() *soap.Fault { return b.Fault_ } 7073 7074func ListCACertificateRevocationLists(ctx context.Context, r soap.RoundTripper, req *types.ListCACertificateRevocationLists) (*types.ListCACertificateRevocationListsResponse, error) { 7075 var reqBody, resBody ListCACertificateRevocationListsBody 7076 7077 reqBody.Req = req 7078 7079 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7080 return nil, err 7081 } 7082 7083 return resBody.Res, nil 7084} 7085 7086type ListCACertificatesBody struct { 7087 Req *types.ListCACertificates `xml:"urn:vim25 ListCACertificates,omitempty"` 7088 Res *types.ListCACertificatesResponse `xml:"urn:vim25 ListCACertificatesResponse,omitempty"` 7089 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7090} 7091 7092func (b *ListCACertificatesBody) Fault() *soap.Fault { return b.Fault_ } 7093 7094func ListCACertificates(ctx context.Context, r soap.RoundTripper, req *types.ListCACertificates) (*types.ListCACertificatesResponse, error) { 7095 var reqBody, resBody ListCACertificatesBody 7096 7097 reqBody.Req = req 7098 7099 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7100 return nil, err 7101 } 7102 7103 return resBody.Res, nil 7104} 7105 7106type ListFilesInGuestBody struct { 7107 Req *types.ListFilesInGuest `xml:"urn:vim25 ListFilesInGuest,omitempty"` 7108 Res *types.ListFilesInGuestResponse `xml:"urn:vim25 ListFilesInGuestResponse,omitempty"` 7109 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7110} 7111 7112func (b *ListFilesInGuestBody) Fault() *soap.Fault { return b.Fault_ } 7113 7114func ListFilesInGuest(ctx context.Context, r soap.RoundTripper, req *types.ListFilesInGuest) (*types.ListFilesInGuestResponse, error) { 7115 var reqBody, resBody ListFilesInGuestBody 7116 7117 reqBody.Req = req 7118 7119 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7120 return nil, err 7121 } 7122 7123 return resBody.Res, nil 7124} 7125 7126type ListGuestAliasesBody struct { 7127 Req *types.ListGuestAliases `xml:"urn:vim25 ListGuestAliases,omitempty"` 7128 Res *types.ListGuestAliasesResponse `xml:"urn:vim25 ListGuestAliasesResponse,omitempty"` 7129 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7130} 7131 7132func (b *ListGuestAliasesBody) Fault() *soap.Fault { return b.Fault_ } 7133 7134func ListGuestAliases(ctx context.Context, r soap.RoundTripper, req *types.ListGuestAliases) (*types.ListGuestAliasesResponse, error) { 7135 var reqBody, resBody ListGuestAliasesBody 7136 7137 reqBody.Req = req 7138 7139 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7140 return nil, err 7141 } 7142 7143 return resBody.Res, nil 7144} 7145 7146type ListGuestMappedAliasesBody struct { 7147 Req *types.ListGuestMappedAliases `xml:"urn:vim25 ListGuestMappedAliases,omitempty"` 7148 Res *types.ListGuestMappedAliasesResponse `xml:"urn:vim25 ListGuestMappedAliasesResponse,omitempty"` 7149 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7150} 7151 7152func (b *ListGuestMappedAliasesBody) Fault() *soap.Fault { return b.Fault_ } 7153 7154func ListGuestMappedAliases(ctx context.Context, r soap.RoundTripper, req *types.ListGuestMappedAliases) (*types.ListGuestMappedAliasesResponse, error) { 7155 var reqBody, resBody ListGuestMappedAliasesBody 7156 7157 reqBody.Req = req 7158 7159 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7160 return nil, err 7161 } 7162 7163 return resBody.Res, nil 7164} 7165 7166type ListKeysBody struct { 7167 Req *types.ListKeys `xml:"urn:vim25 ListKeys,omitempty"` 7168 Res *types.ListKeysResponse `xml:"urn:vim25 ListKeysResponse,omitempty"` 7169 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7170} 7171 7172func (b *ListKeysBody) Fault() *soap.Fault { return b.Fault_ } 7173 7174func ListKeys(ctx context.Context, r soap.RoundTripper, req *types.ListKeys) (*types.ListKeysResponse, error) { 7175 var reqBody, resBody ListKeysBody 7176 7177 reqBody.Req = req 7178 7179 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7180 return nil, err 7181 } 7182 7183 return resBody.Res, nil 7184} 7185 7186type ListKmipServersBody struct { 7187 Req *types.ListKmipServers `xml:"urn:vim25 ListKmipServers,omitempty"` 7188 Res *types.ListKmipServersResponse `xml:"urn:vim25 ListKmipServersResponse,omitempty"` 7189 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7190} 7191 7192func (b *ListKmipServersBody) Fault() *soap.Fault { return b.Fault_ } 7193 7194func ListKmipServers(ctx context.Context, r soap.RoundTripper, req *types.ListKmipServers) (*types.ListKmipServersResponse, error) { 7195 var reqBody, resBody ListKmipServersBody 7196 7197 reqBody.Req = req 7198 7199 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7200 return nil, err 7201 } 7202 7203 return resBody.Res, nil 7204} 7205 7206type ListProcessesInGuestBody struct { 7207 Req *types.ListProcessesInGuest `xml:"urn:vim25 ListProcessesInGuest,omitempty"` 7208 Res *types.ListProcessesInGuestResponse `xml:"urn:vim25 ListProcessesInGuestResponse,omitempty"` 7209 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7210} 7211 7212func (b *ListProcessesInGuestBody) Fault() *soap.Fault { return b.Fault_ } 7213 7214func ListProcessesInGuest(ctx context.Context, r soap.RoundTripper, req *types.ListProcessesInGuest) (*types.ListProcessesInGuestResponse, error) { 7215 var reqBody, resBody ListProcessesInGuestBody 7216 7217 reqBody.Req = req 7218 7219 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7220 return nil, err 7221 } 7222 7223 return resBody.Res, nil 7224} 7225 7226type ListRegistryKeysInGuestBody struct { 7227 Req *types.ListRegistryKeysInGuest `xml:"urn:vim25 ListRegistryKeysInGuest,omitempty"` 7228 Res *types.ListRegistryKeysInGuestResponse `xml:"urn:vim25 ListRegistryKeysInGuestResponse,omitempty"` 7229 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7230} 7231 7232func (b *ListRegistryKeysInGuestBody) Fault() *soap.Fault { return b.Fault_ } 7233 7234func ListRegistryKeysInGuest(ctx context.Context, r soap.RoundTripper, req *types.ListRegistryKeysInGuest) (*types.ListRegistryKeysInGuestResponse, error) { 7235 var reqBody, resBody ListRegistryKeysInGuestBody 7236 7237 reqBody.Req = req 7238 7239 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7240 return nil, err 7241 } 7242 7243 return resBody.Res, nil 7244} 7245 7246type ListRegistryValuesInGuestBody struct { 7247 Req *types.ListRegistryValuesInGuest `xml:"urn:vim25 ListRegistryValuesInGuest,omitempty"` 7248 Res *types.ListRegistryValuesInGuestResponse `xml:"urn:vim25 ListRegistryValuesInGuestResponse,omitempty"` 7249 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7250} 7251 7252func (b *ListRegistryValuesInGuestBody) Fault() *soap.Fault { return b.Fault_ } 7253 7254func ListRegistryValuesInGuest(ctx context.Context, r soap.RoundTripper, req *types.ListRegistryValuesInGuest) (*types.ListRegistryValuesInGuestResponse, error) { 7255 var reqBody, resBody ListRegistryValuesInGuestBody 7256 7257 reqBody.Req = req 7258 7259 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7260 return nil, err 7261 } 7262 7263 return resBody.Res, nil 7264} 7265 7266type ListSmartCardTrustAnchorsBody struct { 7267 Req *types.ListSmartCardTrustAnchors `xml:"urn:vim25 ListSmartCardTrustAnchors,omitempty"` 7268 Res *types.ListSmartCardTrustAnchorsResponse `xml:"urn:vim25 ListSmartCardTrustAnchorsResponse,omitempty"` 7269 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7270} 7271 7272func (b *ListSmartCardTrustAnchorsBody) Fault() *soap.Fault { return b.Fault_ } 7273 7274func ListSmartCardTrustAnchors(ctx context.Context, r soap.RoundTripper, req *types.ListSmartCardTrustAnchors) (*types.ListSmartCardTrustAnchorsResponse, error) { 7275 var reqBody, resBody ListSmartCardTrustAnchorsBody 7276 7277 reqBody.Req = req 7278 7279 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7280 return nil, err 7281 } 7282 7283 return resBody.Res, nil 7284} 7285 7286type ListTagsAttachedToVStorageObjectBody struct { 7287 Req *types.ListTagsAttachedToVStorageObject `xml:"urn:vim25 ListTagsAttachedToVStorageObject,omitempty"` 7288 Res *types.ListTagsAttachedToVStorageObjectResponse `xml:"urn:vim25 ListTagsAttachedToVStorageObjectResponse,omitempty"` 7289 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7290} 7291 7292func (b *ListTagsAttachedToVStorageObjectBody) Fault() *soap.Fault { return b.Fault_ } 7293 7294func ListTagsAttachedToVStorageObject(ctx context.Context, r soap.RoundTripper, req *types.ListTagsAttachedToVStorageObject) (*types.ListTagsAttachedToVStorageObjectResponse, error) { 7295 var reqBody, resBody ListTagsAttachedToVStorageObjectBody 7296 7297 reqBody.Req = req 7298 7299 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7300 return nil, err 7301 } 7302 7303 return resBody.Res, nil 7304} 7305 7306type ListVStorageObjectBody struct { 7307 Req *types.ListVStorageObject `xml:"urn:vim25 ListVStorageObject,omitempty"` 7308 Res *types.ListVStorageObjectResponse `xml:"urn:vim25 ListVStorageObjectResponse,omitempty"` 7309 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7310} 7311 7312func (b *ListVStorageObjectBody) Fault() *soap.Fault { return b.Fault_ } 7313 7314func ListVStorageObject(ctx context.Context, r soap.RoundTripper, req *types.ListVStorageObject) (*types.ListVStorageObjectResponse, error) { 7315 var reqBody, resBody ListVStorageObjectBody 7316 7317 reqBody.Req = req 7318 7319 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7320 return nil, err 7321 } 7322 7323 return resBody.Res, nil 7324} 7325 7326type ListVStorageObjectsAttachedToTagBody struct { 7327 Req *types.ListVStorageObjectsAttachedToTag `xml:"urn:vim25 ListVStorageObjectsAttachedToTag,omitempty"` 7328 Res *types.ListVStorageObjectsAttachedToTagResponse `xml:"urn:vim25 ListVStorageObjectsAttachedToTagResponse,omitempty"` 7329 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7330} 7331 7332func (b *ListVStorageObjectsAttachedToTagBody) Fault() *soap.Fault { return b.Fault_ } 7333 7334func ListVStorageObjectsAttachedToTag(ctx context.Context, r soap.RoundTripper, req *types.ListVStorageObjectsAttachedToTag) (*types.ListVStorageObjectsAttachedToTagResponse, error) { 7335 var reqBody, resBody ListVStorageObjectsAttachedToTagBody 7336 7337 reqBody.Req = req 7338 7339 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7340 return nil, err 7341 } 7342 7343 return resBody.Res, nil 7344} 7345 7346type LogUserEventBody struct { 7347 Req *types.LogUserEvent `xml:"urn:vim25 LogUserEvent,omitempty"` 7348 Res *types.LogUserEventResponse `xml:"urn:vim25 LogUserEventResponse,omitempty"` 7349 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7350} 7351 7352func (b *LogUserEventBody) Fault() *soap.Fault { return b.Fault_ } 7353 7354func LogUserEvent(ctx context.Context, r soap.RoundTripper, req *types.LogUserEvent) (*types.LogUserEventResponse, error) { 7355 var reqBody, resBody LogUserEventBody 7356 7357 reqBody.Req = req 7358 7359 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7360 return nil, err 7361 } 7362 7363 return resBody.Res, nil 7364} 7365 7366type LoginBody struct { 7367 Req *types.Login `xml:"urn:vim25 Login,omitempty"` 7368 Res *types.LoginResponse `xml:"urn:vim25 LoginResponse,omitempty"` 7369 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7370} 7371 7372func (b *LoginBody) Fault() *soap.Fault { return b.Fault_ } 7373 7374func Login(ctx context.Context, r soap.RoundTripper, req *types.Login) (*types.LoginResponse, error) { 7375 var reqBody, resBody LoginBody 7376 7377 reqBody.Req = req 7378 7379 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7380 return nil, err 7381 } 7382 7383 return resBody.Res, nil 7384} 7385 7386type LoginBySSPIBody struct { 7387 Req *types.LoginBySSPI `xml:"urn:vim25 LoginBySSPI,omitempty"` 7388 Res *types.LoginBySSPIResponse `xml:"urn:vim25 LoginBySSPIResponse,omitempty"` 7389 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7390} 7391 7392func (b *LoginBySSPIBody) Fault() *soap.Fault { return b.Fault_ } 7393 7394func LoginBySSPI(ctx context.Context, r soap.RoundTripper, req *types.LoginBySSPI) (*types.LoginBySSPIResponse, error) { 7395 var reqBody, resBody LoginBySSPIBody 7396 7397 reqBody.Req = req 7398 7399 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7400 return nil, err 7401 } 7402 7403 return resBody.Res, nil 7404} 7405 7406type LoginByTokenBody struct { 7407 Req *types.LoginByToken `xml:"urn:vim25 LoginByToken,omitempty"` 7408 Res *types.LoginByTokenResponse `xml:"urn:vim25 LoginByTokenResponse,omitempty"` 7409 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7410} 7411 7412func (b *LoginByTokenBody) Fault() *soap.Fault { return b.Fault_ } 7413 7414func LoginByToken(ctx context.Context, r soap.RoundTripper, req *types.LoginByToken) (*types.LoginByTokenResponse, error) { 7415 var reqBody, resBody LoginByTokenBody 7416 7417 reqBody.Req = req 7418 7419 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7420 return nil, err 7421 } 7422 7423 return resBody.Res, nil 7424} 7425 7426type LoginExtensionByCertificateBody struct { 7427 Req *types.LoginExtensionByCertificate `xml:"urn:vim25 LoginExtensionByCertificate,omitempty"` 7428 Res *types.LoginExtensionByCertificateResponse `xml:"urn:vim25 LoginExtensionByCertificateResponse,omitempty"` 7429 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7430} 7431 7432func (b *LoginExtensionByCertificateBody) Fault() *soap.Fault { return b.Fault_ } 7433 7434func LoginExtensionByCertificate(ctx context.Context, r soap.RoundTripper, req *types.LoginExtensionByCertificate) (*types.LoginExtensionByCertificateResponse, error) { 7435 var reqBody, resBody LoginExtensionByCertificateBody 7436 7437 reqBody.Req = req 7438 7439 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7440 return nil, err 7441 } 7442 7443 return resBody.Res, nil 7444} 7445 7446type LoginExtensionBySubjectNameBody struct { 7447 Req *types.LoginExtensionBySubjectName `xml:"urn:vim25 LoginExtensionBySubjectName,omitempty"` 7448 Res *types.LoginExtensionBySubjectNameResponse `xml:"urn:vim25 LoginExtensionBySubjectNameResponse,omitempty"` 7449 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7450} 7451 7452func (b *LoginExtensionBySubjectNameBody) Fault() *soap.Fault { return b.Fault_ } 7453 7454func LoginExtensionBySubjectName(ctx context.Context, r soap.RoundTripper, req *types.LoginExtensionBySubjectName) (*types.LoginExtensionBySubjectNameResponse, error) { 7455 var reqBody, resBody LoginExtensionBySubjectNameBody 7456 7457 reqBody.Req = req 7458 7459 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7460 return nil, err 7461 } 7462 7463 return resBody.Res, nil 7464} 7465 7466type LogoutBody struct { 7467 Req *types.Logout `xml:"urn:vim25 Logout,omitempty"` 7468 Res *types.LogoutResponse `xml:"urn:vim25 LogoutResponse,omitempty"` 7469 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7470} 7471 7472func (b *LogoutBody) Fault() *soap.Fault { return b.Fault_ } 7473 7474func Logout(ctx context.Context, r soap.RoundTripper, req *types.Logout) (*types.LogoutResponse, error) { 7475 var reqBody, resBody LogoutBody 7476 7477 reqBody.Req = req 7478 7479 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7480 return nil, err 7481 } 7482 7483 return resBody.Res, nil 7484} 7485 7486type LookupDvPortGroupBody struct { 7487 Req *types.LookupDvPortGroup `xml:"urn:vim25 LookupDvPortGroup,omitempty"` 7488 Res *types.LookupDvPortGroupResponse `xml:"urn:vim25 LookupDvPortGroupResponse,omitempty"` 7489 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7490} 7491 7492func (b *LookupDvPortGroupBody) Fault() *soap.Fault { return b.Fault_ } 7493 7494func LookupDvPortGroup(ctx context.Context, r soap.RoundTripper, req *types.LookupDvPortGroup) (*types.LookupDvPortGroupResponse, error) { 7495 var reqBody, resBody LookupDvPortGroupBody 7496 7497 reqBody.Req = req 7498 7499 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7500 return nil, err 7501 } 7502 7503 return resBody.Res, nil 7504} 7505 7506type LookupVmOverheadMemoryBody struct { 7507 Req *types.LookupVmOverheadMemory `xml:"urn:vim25 LookupVmOverheadMemory,omitempty"` 7508 Res *types.LookupVmOverheadMemoryResponse `xml:"urn:vim25 LookupVmOverheadMemoryResponse,omitempty"` 7509 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7510} 7511 7512func (b *LookupVmOverheadMemoryBody) Fault() *soap.Fault { return b.Fault_ } 7513 7514func LookupVmOverheadMemory(ctx context.Context, r soap.RoundTripper, req *types.LookupVmOverheadMemory) (*types.LookupVmOverheadMemoryResponse, error) { 7515 var reqBody, resBody LookupVmOverheadMemoryBody 7516 7517 reqBody.Req = req 7518 7519 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7520 return nil, err 7521 } 7522 7523 return resBody.Res, nil 7524} 7525 7526type MakeDirectoryBody struct { 7527 Req *types.MakeDirectory `xml:"urn:vim25 MakeDirectory,omitempty"` 7528 Res *types.MakeDirectoryResponse `xml:"urn:vim25 MakeDirectoryResponse,omitempty"` 7529 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7530} 7531 7532func (b *MakeDirectoryBody) Fault() *soap.Fault { return b.Fault_ } 7533 7534func MakeDirectory(ctx context.Context, r soap.RoundTripper, req *types.MakeDirectory) (*types.MakeDirectoryResponse, error) { 7535 var reqBody, resBody MakeDirectoryBody 7536 7537 reqBody.Req = req 7538 7539 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7540 return nil, err 7541 } 7542 7543 return resBody.Res, nil 7544} 7545 7546type MakeDirectoryInGuestBody struct { 7547 Req *types.MakeDirectoryInGuest `xml:"urn:vim25 MakeDirectoryInGuest,omitempty"` 7548 Res *types.MakeDirectoryInGuestResponse `xml:"urn:vim25 MakeDirectoryInGuestResponse,omitempty"` 7549 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7550} 7551 7552func (b *MakeDirectoryInGuestBody) Fault() *soap.Fault { return b.Fault_ } 7553 7554func MakeDirectoryInGuest(ctx context.Context, r soap.RoundTripper, req *types.MakeDirectoryInGuest) (*types.MakeDirectoryInGuestResponse, error) { 7555 var reqBody, resBody MakeDirectoryInGuestBody 7556 7557 reqBody.Req = req 7558 7559 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7560 return nil, err 7561 } 7562 7563 return resBody.Res, nil 7564} 7565 7566type MakePrimaryVM_TaskBody struct { 7567 Req *types.MakePrimaryVM_Task `xml:"urn:vim25 MakePrimaryVM_Task,omitempty"` 7568 Res *types.MakePrimaryVM_TaskResponse `xml:"urn:vim25 MakePrimaryVM_TaskResponse,omitempty"` 7569 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7570} 7571 7572func (b *MakePrimaryVM_TaskBody) Fault() *soap.Fault { return b.Fault_ } 7573 7574func MakePrimaryVM_Task(ctx context.Context, r soap.RoundTripper, req *types.MakePrimaryVM_Task) (*types.MakePrimaryVM_TaskResponse, error) { 7575 var reqBody, resBody MakePrimaryVM_TaskBody 7576 7577 reqBody.Req = req 7578 7579 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7580 return nil, err 7581 } 7582 7583 return resBody.Res, nil 7584} 7585 7586type MarkAsLocal_TaskBody struct { 7587 Req *types.MarkAsLocal_Task `xml:"urn:vim25 MarkAsLocal_Task,omitempty"` 7588 Res *types.MarkAsLocal_TaskResponse `xml:"urn:vim25 MarkAsLocal_TaskResponse,omitempty"` 7589 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7590} 7591 7592func (b *MarkAsLocal_TaskBody) Fault() *soap.Fault { return b.Fault_ } 7593 7594func MarkAsLocal_Task(ctx context.Context, r soap.RoundTripper, req *types.MarkAsLocal_Task) (*types.MarkAsLocal_TaskResponse, error) { 7595 var reqBody, resBody MarkAsLocal_TaskBody 7596 7597 reqBody.Req = req 7598 7599 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7600 return nil, err 7601 } 7602 7603 return resBody.Res, nil 7604} 7605 7606type MarkAsNonLocal_TaskBody struct { 7607 Req *types.MarkAsNonLocal_Task `xml:"urn:vim25 MarkAsNonLocal_Task,omitempty"` 7608 Res *types.MarkAsNonLocal_TaskResponse `xml:"urn:vim25 MarkAsNonLocal_TaskResponse,omitempty"` 7609 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7610} 7611 7612func (b *MarkAsNonLocal_TaskBody) Fault() *soap.Fault { return b.Fault_ } 7613 7614func MarkAsNonLocal_Task(ctx context.Context, r soap.RoundTripper, req *types.MarkAsNonLocal_Task) (*types.MarkAsNonLocal_TaskResponse, error) { 7615 var reqBody, resBody MarkAsNonLocal_TaskBody 7616 7617 reqBody.Req = req 7618 7619 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7620 return nil, err 7621 } 7622 7623 return resBody.Res, nil 7624} 7625 7626type MarkAsNonSsd_TaskBody struct { 7627 Req *types.MarkAsNonSsd_Task `xml:"urn:vim25 MarkAsNonSsd_Task,omitempty"` 7628 Res *types.MarkAsNonSsd_TaskResponse `xml:"urn:vim25 MarkAsNonSsd_TaskResponse,omitempty"` 7629 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7630} 7631 7632func (b *MarkAsNonSsd_TaskBody) Fault() *soap.Fault { return b.Fault_ } 7633 7634func MarkAsNonSsd_Task(ctx context.Context, r soap.RoundTripper, req *types.MarkAsNonSsd_Task) (*types.MarkAsNonSsd_TaskResponse, error) { 7635 var reqBody, resBody MarkAsNonSsd_TaskBody 7636 7637 reqBody.Req = req 7638 7639 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7640 return nil, err 7641 } 7642 7643 return resBody.Res, nil 7644} 7645 7646type MarkAsSsd_TaskBody struct { 7647 Req *types.MarkAsSsd_Task `xml:"urn:vim25 MarkAsSsd_Task,omitempty"` 7648 Res *types.MarkAsSsd_TaskResponse `xml:"urn:vim25 MarkAsSsd_TaskResponse,omitempty"` 7649 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7650} 7651 7652func (b *MarkAsSsd_TaskBody) Fault() *soap.Fault { return b.Fault_ } 7653 7654func MarkAsSsd_Task(ctx context.Context, r soap.RoundTripper, req *types.MarkAsSsd_Task) (*types.MarkAsSsd_TaskResponse, error) { 7655 var reqBody, resBody MarkAsSsd_TaskBody 7656 7657 reqBody.Req = req 7658 7659 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7660 return nil, err 7661 } 7662 7663 return resBody.Res, nil 7664} 7665 7666type MarkAsTemplateBody struct { 7667 Req *types.MarkAsTemplate `xml:"urn:vim25 MarkAsTemplate,omitempty"` 7668 Res *types.MarkAsTemplateResponse `xml:"urn:vim25 MarkAsTemplateResponse,omitempty"` 7669 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7670} 7671 7672func (b *MarkAsTemplateBody) Fault() *soap.Fault { return b.Fault_ } 7673 7674func MarkAsTemplate(ctx context.Context, r soap.RoundTripper, req *types.MarkAsTemplate) (*types.MarkAsTemplateResponse, error) { 7675 var reqBody, resBody MarkAsTemplateBody 7676 7677 reqBody.Req = req 7678 7679 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7680 return nil, err 7681 } 7682 7683 return resBody.Res, nil 7684} 7685 7686type MarkAsVirtualMachineBody struct { 7687 Req *types.MarkAsVirtualMachine `xml:"urn:vim25 MarkAsVirtualMachine,omitempty"` 7688 Res *types.MarkAsVirtualMachineResponse `xml:"urn:vim25 MarkAsVirtualMachineResponse,omitempty"` 7689 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7690} 7691 7692func (b *MarkAsVirtualMachineBody) Fault() *soap.Fault { return b.Fault_ } 7693 7694func MarkAsVirtualMachine(ctx context.Context, r soap.RoundTripper, req *types.MarkAsVirtualMachine) (*types.MarkAsVirtualMachineResponse, error) { 7695 var reqBody, resBody MarkAsVirtualMachineBody 7696 7697 reqBody.Req = req 7698 7699 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7700 return nil, err 7701 } 7702 7703 return resBody.Res, nil 7704} 7705 7706type MarkDefaultBody struct { 7707 Req *types.MarkDefault `xml:"urn:vim25 MarkDefault,omitempty"` 7708 Res *types.MarkDefaultResponse `xml:"urn:vim25 MarkDefaultResponse,omitempty"` 7709 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7710} 7711 7712func (b *MarkDefaultBody) Fault() *soap.Fault { return b.Fault_ } 7713 7714func MarkDefault(ctx context.Context, r soap.RoundTripper, req *types.MarkDefault) (*types.MarkDefaultResponse, error) { 7715 var reqBody, resBody MarkDefaultBody 7716 7717 reqBody.Req = req 7718 7719 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7720 return nil, err 7721 } 7722 7723 return resBody.Res, nil 7724} 7725 7726type MarkForRemovalBody struct { 7727 Req *types.MarkForRemoval `xml:"urn:vim25 MarkForRemoval,omitempty"` 7728 Res *types.MarkForRemovalResponse `xml:"urn:vim25 MarkForRemovalResponse,omitempty"` 7729 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7730} 7731 7732func (b *MarkForRemovalBody) Fault() *soap.Fault { return b.Fault_ } 7733 7734func MarkForRemoval(ctx context.Context, r soap.RoundTripper, req *types.MarkForRemoval) (*types.MarkForRemovalResponse, error) { 7735 var reqBody, resBody MarkForRemovalBody 7736 7737 reqBody.Req = req 7738 7739 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7740 return nil, err 7741 } 7742 7743 return resBody.Res, nil 7744} 7745 7746type MergeDvs_TaskBody struct { 7747 Req *types.MergeDvs_Task `xml:"urn:vim25 MergeDvs_Task,omitempty"` 7748 Res *types.MergeDvs_TaskResponse `xml:"urn:vim25 MergeDvs_TaskResponse,omitempty"` 7749 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7750} 7751 7752func (b *MergeDvs_TaskBody) Fault() *soap.Fault { return b.Fault_ } 7753 7754func MergeDvs_Task(ctx context.Context, r soap.RoundTripper, req *types.MergeDvs_Task) (*types.MergeDvs_TaskResponse, error) { 7755 var reqBody, resBody MergeDvs_TaskBody 7756 7757 reqBody.Req = req 7758 7759 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7760 return nil, err 7761 } 7762 7763 return resBody.Res, nil 7764} 7765 7766type MergePermissionsBody struct { 7767 Req *types.MergePermissions `xml:"urn:vim25 MergePermissions,omitempty"` 7768 Res *types.MergePermissionsResponse `xml:"urn:vim25 MergePermissionsResponse,omitempty"` 7769 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7770} 7771 7772func (b *MergePermissionsBody) Fault() *soap.Fault { return b.Fault_ } 7773 7774func MergePermissions(ctx context.Context, r soap.RoundTripper, req *types.MergePermissions) (*types.MergePermissionsResponse, error) { 7775 var reqBody, resBody MergePermissionsBody 7776 7777 reqBody.Req = req 7778 7779 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7780 return nil, err 7781 } 7782 7783 return resBody.Res, nil 7784} 7785 7786type MigrateVM_TaskBody struct { 7787 Req *types.MigrateVM_Task `xml:"urn:vim25 MigrateVM_Task,omitempty"` 7788 Res *types.MigrateVM_TaskResponse `xml:"urn:vim25 MigrateVM_TaskResponse,omitempty"` 7789 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7790} 7791 7792func (b *MigrateVM_TaskBody) Fault() *soap.Fault { return b.Fault_ } 7793 7794func MigrateVM_Task(ctx context.Context, r soap.RoundTripper, req *types.MigrateVM_Task) (*types.MigrateVM_TaskResponse, error) { 7795 var reqBody, resBody MigrateVM_TaskBody 7796 7797 reqBody.Req = req 7798 7799 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7800 return nil, err 7801 } 7802 7803 return resBody.Res, nil 7804} 7805 7806type ModifyListViewBody struct { 7807 Req *types.ModifyListView `xml:"urn:vim25 ModifyListView,omitempty"` 7808 Res *types.ModifyListViewResponse `xml:"urn:vim25 ModifyListViewResponse,omitempty"` 7809 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7810} 7811 7812func (b *ModifyListViewBody) Fault() *soap.Fault { return b.Fault_ } 7813 7814func ModifyListView(ctx context.Context, r soap.RoundTripper, req *types.ModifyListView) (*types.ModifyListViewResponse, error) { 7815 var reqBody, resBody ModifyListViewBody 7816 7817 reqBody.Req = req 7818 7819 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7820 return nil, err 7821 } 7822 7823 return resBody.Res, nil 7824} 7825 7826type MountToolsInstallerBody struct { 7827 Req *types.MountToolsInstaller `xml:"urn:vim25 MountToolsInstaller,omitempty"` 7828 Res *types.MountToolsInstallerResponse `xml:"urn:vim25 MountToolsInstallerResponse,omitempty"` 7829 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7830} 7831 7832func (b *MountToolsInstallerBody) Fault() *soap.Fault { return b.Fault_ } 7833 7834func MountToolsInstaller(ctx context.Context, r soap.RoundTripper, req *types.MountToolsInstaller) (*types.MountToolsInstallerResponse, error) { 7835 var reqBody, resBody MountToolsInstallerBody 7836 7837 reqBody.Req = req 7838 7839 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7840 return nil, err 7841 } 7842 7843 return resBody.Res, nil 7844} 7845 7846type MountVffsVolumeBody struct { 7847 Req *types.MountVffsVolume `xml:"urn:vim25 MountVffsVolume,omitempty"` 7848 Res *types.MountVffsVolumeResponse `xml:"urn:vim25 MountVffsVolumeResponse,omitempty"` 7849 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7850} 7851 7852func (b *MountVffsVolumeBody) Fault() *soap.Fault { return b.Fault_ } 7853 7854func MountVffsVolume(ctx context.Context, r soap.RoundTripper, req *types.MountVffsVolume) (*types.MountVffsVolumeResponse, error) { 7855 var reqBody, resBody MountVffsVolumeBody 7856 7857 reqBody.Req = req 7858 7859 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7860 return nil, err 7861 } 7862 7863 return resBody.Res, nil 7864} 7865 7866type MountVmfsVolumeBody struct { 7867 Req *types.MountVmfsVolume `xml:"urn:vim25 MountVmfsVolume,omitempty"` 7868 Res *types.MountVmfsVolumeResponse `xml:"urn:vim25 MountVmfsVolumeResponse,omitempty"` 7869 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7870} 7871 7872func (b *MountVmfsVolumeBody) Fault() *soap.Fault { return b.Fault_ } 7873 7874func MountVmfsVolume(ctx context.Context, r soap.RoundTripper, req *types.MountVmfsVolume) (*types.MountVmfsVolumeResponse, error) { 7875 var reqBody, resBody MountVmfsVolumeBody 7876 7877 reqBody.Req = req 7878 7879 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7880 return nil, err 7881 } 7882 7883 return resBody.Res, nil 7884} 7885 7886type MountVmfsVolumeEx_TaskBody struct { 7887 Req *types.MountVmfsVolumeEx_Task `xml:"urn:vim25 MountVmfsVolumeEx_Task,omitempty"` 7888 Res *types.MountVmfsVolumeEx_TaskResponse `xml:"urn:vim25 MountVmfsVolumeEx_TaskResponse,omitempty"` 7889 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7890} 7891 7892func (b *MountVmfsVolumeEx_TaskBody) Fault() *soap.Fault { return b.Fault_ } 7893 7894func MountVmfsVolumeEx_Task(ctx context.Context, r soap.RoundTripper, req *types.MountVmfsVolumeEx_Task) (*types.MountVmfsVolumeEx_TaskResponse, error) { 7895 var reqBody, resBody MountVmfsVolumeEx_TaskBody 7896 7897 reqBody.Req = req 7898 7899 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7900 return nil, err 7901 } 7902 7903 return resBody.Res, nil 7904} 7905 7906type MoveDVPort_TaskBody struct { 7907 Req *types.MoveDVPort_Task `xml:"urn:vim25 MoveDVPort_Task,omitempty"` 7908 Res *types.MoveDVPort_TaskResponse `xml:"urn:vim25 MoveDVPort_TaskResponse,omitempty"` 7909 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7910} 7911 7912func (b *MoveDVPort_TaskBody) Fault() *soap.Fault { return b.Fault_ } 7913 7914func MoveDVPort_Task(ctx context.Context, r soap.RoundTripper, req *types.MoveDVPort_Task) (*types.MoveDVPort_TaskResponse, error) { 7915 var reqBody, resBody MoveDVPort_TaskBody 7916 7917 reqBody.Req = req 7918 7919 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7920 return nil, err 7921 } 7922 7923 return resBody.Res, nil 7924} 7925 7926type MoveDatastoreFile_TaskBody struct { 7927 Req *types.MoveDatastoreFile_Task `xml:"urn:vim25 MoveDatastoreFile_Task,omitempty"` 7928 Res *types.MoveDatastoreFile_TaskResponse `xml:"urn:vim25 MoveDatastoreFile_TaskResponse,omitempty"` 7929 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7930} 7931 7932func (b *MoveDatastoreFile_TaskBody) Fault() *soap.Fault { return b.Fault_ } 7933 7934func MoveDatastoreFile_Task(ctx context.Context, r soap.RoundTripper, req *types.MoveDatastoreFile_Task) (*types.MoveDatastoreFile_TaskResponse, error) { 7935 var reqBody, resBody MoveDatastoreFile_TaskBody 7936 7937 reqBody.Req = req 7938 7939 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7940 return nil, err 7941 } 7942 7943 return resBody.Res, nil 7944} 7945 7946type MoveDirectoryInGuestBody struct { 7947 Req *types.MoveDirectoryInGuest `xml:"urn:vim25 MoveDirectoryInGuest,omitempty"` 7948 Res *types.MoveDirectoryInGuestResponse `xml:"urn:vim25 MoveDirectoryInGuestResponse,omitempty"` 7949 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7950} 7951 7952func (b *MoveDirectoryInGuestBody) Fault() *soap.Fault { return b.Fault_ } 7953 7954func MoveDirectoryInGuest(ctx context.Context, r soap.RoundTripper, req *types.MoveDirectoryInGuest) (*types.MoveDirectoryInGuestResponse, error) { 7955 var reqBody, resBody MoveDirectoryInGuestBody 7956 7957 reqBody.Req = req 7958 7959 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7960 return nil, err 7961 } 7962 7963 return resBody.Res, nil 7964} 7965 7966type MoveFileInGuestBody struct { 7967 Req *types.MoveFileInGuest `xml:"urn:vim25 MoveFileInGuest,omitempty"` 7968 Res *types.MoveFileInGuestResponse `xml:"urn:vim25 MoveFileInGuestResponse,omitempty"` 7969 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7970} 7971 7972func (b *MoveFileInGuestBody) Fault() *soap.Fault { return b.Fault_ } 7973 7974func MoveFileInGuest(ctx context.Context, r soap.RoundTripper, req *types.MoveFileInGuest) (*types.MoveFileInGuestResponse, error) { 7975 var reqBody, resBody MoveFileInGuestBody 7976 7977 reqBody.Req = req 7978 7979 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 7980 return nil, err 7981 } 7982 7983 return resBody.Res, nil 7984} 7985 7986type MoveHostInto_TaskBody struct { 7987 Req *types.MoveHostInto_Task `xml:"urn:vim25 MoveHostInto_Task,omitempty"` 7988 Res *types.MoveHostInto_TaskResponse `xml:"urn:vim25 MoveHostInto_TaskResponse,omitempty"` 7989 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 7990} 7991 7992func (b *MoveHostInto_TaskBody) Fault() *soap.Fault { return b.Fault_ } 7993 7994func MoveHostInto_Task(ctx context.Context, r soap.RoundTripper, req *types.MoveHostInto_Task) (*types.MoveHostInto_TaskResponse, error) { 7995 var reqBody, resBody MoveHostInto_TaskBody 7996 7997 reqBody.Req = req 7998 7999 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8000 return nil, err 8001 } 8002 8003 return resBody.Res, nil 8004} 8005 8006type MoveIntoFolder_TaskBody struct { 8007 Req *types.MoveIntoFolder_Task `xml:"urn:vim25 MoveIntoFolder_Task,omitempty"` 8008 Res *types.MoveIntoFolder_TaskResponse `xml:"urn:vim25 MoveIntoFolder_TaskResponse,omitempty"` 8009 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8010} 8011 8012func (b *MoveIntoFolder_TaskBody) Fault() *soap.Fault { return b.Fault_ } 8013 8014func MoveIntoFolder_Task(ctx context.Context, r soap.RoundTripper, req *types.MoveIntoFolder_Task) (*types.MoveIntoFolder_TaskResponse, error) { 8015 var reqBody, resBody MoveIntoFolder_TaskBody 8016 8017 reqBody.Req = req 8018 8019 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8020 return nil, err 8021 } 8022 8023 return resBody.Res, nil 8024} 8025 8026type MoveIntoResourcePoolBody struct { 8027 Req *types.MoveIntoResourcePool `xml:"urn:vim25 MoveIntoResourcePool,omitempty"` 8028 Res *types.MoveIntoResourcePoolResponse `xml:"urn:vim25 MoveIntoResourcePoolResponse,omitempty"` 8029 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8030} 8031 8032func (b *MoveIntoResourcePoolBody) Fault() *soap.Fault { return b.Fault_ } 8033 8034func MoveIntoResourcePool(ctx context.Context, r soap.RoundTripper, req *types.MoveIntoResourcePool) (*types.MoveIntoResourcePoolResponse, error) { 8035 var reqBody, resBody MoveIntoResourcePoolBody 8036 8037 reqBody.Req = req 8038 8039 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8040 return nil, err 8041 } 8042 8043 return resBody.Res, nil 8044} 8045 8046type MoveInto_TaskBody struct { 8047 Req *types.MoveInto_Task `xml:"urn:vim25 MoveInto_Task,omitempty"` 8048 Res *types.MoveInto_TaskResponse `xml:"urn:vim25 MoveInto_TaskResponse,omitempty"` 8049 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8050} 8051 8052func (b *MoveInto_TaskBody) Fault() *soap.Fault { return b.Fault_ } 8053 8054func MoveInto_Task(ctx context.Context, r soap.RoundTripper, req *types.MoveInto_Task) (*types.MoveInto_TaskResponse, error) { 8055 var reqBody, resBody MoveInto_TaskBody 8056 8057 reqBody.Req = req 8058 8059 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8060 return nil, err 8061 } 8062 8063 return resBody.Res, nil 8064} 8065 8066type MoveVirtualDisk_TaskBody struct { 8067 Req *types.MoveVirtualDisk_Task `xml:"urn:vim25 MoveVirtualDisk_Task,omitempty"` 8068 Res *types.MoveVirtualDisk_TaskResponse `xml:"urn:vim25 MoveVirtualDisk_TaskResponse,omitempty"` 8069 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8070} 8071 8072func (b *MoveVirtualDisk_TaskBody) Fault() *soap.Fault { return b.Fault_ } 8073 8074func MoveVirtualDisk_Task(ctx context.Context, r soap.RoundTripper, req *types.MoveVirtualDisk_Task) (*types.MoveVirtualDisk_TaskResponse, error) { 8075 var reqBody, resBody MoveVirtualDisk_TaskBody 8076 8077 reqBody.Req = req 8078 8079 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8080 return nil, err 8081 } 8082 8083 return resBody.Res, nil 8084} 8085 8086type OpenInventoryViewFolderBody struct { 8087 Req *types.OpenInventoryViewFolder `xml:"urn:vim25 OpenInventoryViewFolder,omitempty"` 8088 Res *types.OpenInventoryViewFolderResponse `xml:"urn:vim25 OpenInventoryViewFolderResponse,omitempty"` 8089 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8090} 8091 8092func (b *OpenInventoryViewFolderBody) Fault() *soap.Fault { return b.Fault_ } 8093 8094func OpenInventoryViewFolder(ctx context.Context, r soap.RoundTripper, req *types.OpenInventoryViewFolder) (*types.OpenInventoryViewFolderResponse, error) { 8095 var reqBody, resBody OpenInventoryViewFolderBody 8096 8097 reqBody.Req = req 8098 8099 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8100 return nil, err 8101 } 8102 8103 return resBody.Res, nil 8104} 8105 8106type OverwriteCustomizationSpecBody struct { 8107 Req *types.OverwriteCustomizationSpec `xml:"urn:vim25 OverwriteCustomizationSpec,omitempty"` 8108 Res *types.OverwriteCustomizationSpecResponse `xml:"urn:vim25 OverwriteCustomizationSpecResponse,omitempty"` 8109 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8110} 8111 8112func (b *OverwriteCustomizationSpecBody) Fault() *soap.Fault { return b.Fault_ } 8113 8114func OverwriteCustomizationSpec(ctx context.Context, r soap.RoundTripper, req *types.OverwriteCustomizationSpec) (*types.OverwriteCustomizationSpecResponse, error) { 8115 var reqBody, resBody OverwriteCustomizationSpecBody 8116 8117 reqBody.Req = req 8118 8119 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8120 return nil, err 8121 } 8122 8123 return resBody.Res, nil 8124} 8125 8126type ParseDescriptorBody struct { 8127 Req *types.ParseDescriptor `xml:"urn:vim25 ParseDescriptor,omitempty"` 8128 Res *types.ParseDescriptorResponse `xml:"urn:vim25 ParseDescriptorResponse,omitempty"` 8129 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8130} 8131 8132func (b *ParseDescriptorBody) Fault() *soap.Fault { return b.Fault_ } 8133 8134func ParseDescriptor(ctx context.Context, r soap.RoundTripper, req *types.ParseDescriptor) (*types.ParseDescriptorResponse, error) { 8135 var reqBody, resBody ParseDescriptorBody 8136 8137 reqBody.Req = req 8138 8139 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8140 return nil, err 8141 } 8142 8143 return resBody.Res, nil 8144} 8145 8146type PerformDvsProductSpecOperation_TaskBody struct { 8147 Req *types.PerformDvsProductSpecOperation_Task `xml:"urn:vim25 PerformDvsProductSpecOperation_Task,omitempty"` 8148 Res *types.PerformDvsProductSpecOperation_TaskResponse `xml:"urn:vim25 PerformDvsProductSpecOperation_TaskResponse,omitempty"` 8149 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8150} 8151 8152func (b *PerformDvsProductSpecOperation_TaskBody) Fault() *soap.Fault { return b.Fault_ } 8153 8154func PerformDvsProductSpecOperation_Task(ctx context.Context, r soap.RoundTripper, req *types.PerformDvsProductSpecOperation_Task) (*types.PerformDvsProductSpecOperation_TaskResponse, error) { 8155 var reqBody, resBody PerformDvsProductSpecOperation_TaskBody 8156 8157 reqBody.Req = req 8158 8159 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8160 return nil, err 8161 } 8162 8163 return resBody.Res, nil 8164} 8165 8166type PerformVsanUpgradePreflightCheckBody struct { 8167 Req *types.PerformVsanUpgradePreflightCheck `xml:"urn:vim25 PerformVsanUpgradePreflightCheck,omitempty"` 8168 Res *types.PerformVsanUpgradePreflightCheckResponse `xml:"urn:vim25 PerformVsanUpgradePreflightCheckResponse,omitempty"` 8169 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8170} 8171 8172func (b *PerformVsanUpgradePreflightCheckBody) Fault() *soap.Fault { return b.Fault_ } 8173 8174func PerformVsanUpgradePreflightCheck(ctx context.Context, r soap.RoundTripper, req *types.PerformVsanUpgradePreflightCheck) (*types.PerformVsanUpgradePreflightCheckResponse, error) { 8175 var reqBody, resBody PerformVsanUpgradePreflightCheckBody 8176 8177 reqBody.Req = req 8178 8179 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8180 return nil, err 8181 } 8182 8183 return resBody.Res, nil 8184} 8185 8186type PerformVsanUpgrade_TaskBody struct { 8187 Req *types.PerformVsanUpgrade_Task `xml:"urn:vim25 PerformVsanUpgrade_Task,omitempty"` 8188 Res *types.PerformVsanUpgrade_TaskResponse `xml:"urn:vim25 PerformVsanUpgrade_TaskResponse,omitempty"` 8189 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8190} 8191 8192func (b *PerformVsanUpgrade_TaskBody) Fault() *soap.Fault { return b.Fault_ } 8193 8194func PerformVsanUpgrade_Task(ctx context.Context, r soap.RoundTripper, req *types.PerformVsanUpgrade_Task) (*types.PerformVsanUpgrade_TaskResponse, error) { 8195 var reqBody, resBody PerformVsanUpgrade_TaskBody 8196 8197 reqBody.Req = req 8198 8199 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8200 return nil, err 8201 } 8202 8203 return resBody.Res, nil 8204} 8205 8206type PlaceVmBody struct { 8207 Req *types.PlaceVm `xml:"urn:vim25 PlaceVm,omitempty"` 8208 Res *types.PlaceVmResponse `xml:"urn:vim25 PlaceVmResponse,omitempty"` 8209 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8210} 8211 8212func (b *PlaceVmBody) Fault() *soap.Fault { return b.Fault_ } 8213 8214func PlaceVm(ctx context.Context, r soap.RoundTripper, req *types.PlaceVm) (*types.PlaceVmResponse, error) { 8215 var reqBody, resBody PlaceVmBody 8216 8217 reqBody.Req = req 8218 8219 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8220 return nil, err 8221 } 8222 8223 return resBody.Res, nil 8224} 8225 8226type PostEventBody struct { 8227 Req *types.PostEvent `xml:"urn:vim25 PostEvent,omitempty"` 8228 Res *types.PostEventResponse `xml:"urn:vim25 PostEventResponse,omitempty"` 8229 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8230} 8231 8232func (b *PostEventBody) Fault() *soap.Fault { return b.Fault_ } 8233 8234func PostEvent(ctx context.Context, r soap.RoundTripper, req *types.PostEvent) (*types.PostEventResponse, error) { 8235 var reqBody, resBody PostEventBody 8236 8237 reqBody.Req = req 8238 8239 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8240 return nil, err 8241 } 8242 8243 return resBody.Res, nil 8244} 8245 8246type PostHealthUpdatesBody struct { 8247 Req *types.PostHealthUpdates `xml:"urn:vim25 PostHealthUpdates,omitempty"` 8248 Res *types.PostHealthUpdatesResponse `xml:"urn:vim25 PostHealthUpdatesResponse,omitempty"` 8249 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8250} 8251 8252func (b *PostHealthUpdatesBody) Fault() *soap.Fault { return b.Fault_ } 8253 8254func PostHealthUpdates(ctx context.Context, r soap.RoundTripper, req *types.PostHealthUpdates) (*types.PostHealthUpdatesResponse, error) { 8255 var reqBody, resBody PostHealthUpdatesBody 8256 8257 reqBody.Req = req 8258 8259 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8260 return nil, err 8261 } 8262 8263 return resBody.Res, nil 8264} 8265 8266type PowerDownHostToStandBy_TaskBody struct { 8267 Req *types.PowerDownHostToStandBy_Task `xml:"urn:vim25 PowerDownHostToStandBy_Task,omitempty"` 8268 Res *types.PowerDownHostToStandBy_TaskResponse `xml:"urn:vim25 PowerDownHostToStandBy_TaskResponse,omitempty"` 8269 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8270} 8271 8272func (b *PowerDownHostToStandBy_TaskBody) Fault() *soap.Fault { return b.Fault_ } 8273 8274func PowerDownHostToStandBy_Task(ctx context.Context, r soap.RoundTripper, req *types.PowerDownHostToStandBy_Task) (*types.PowerDownHostToStandBy_TaskResponse, error) { 8275 var reqBody, resBody PowerDownHostToStandBy_TaskBody 8276 8277 reqBody.Req = req 8278 8279 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8280 return nil, err 8281 } 8282 8283 return resBody.Res, nil 8284} 8285 8286type PowerOffVApp_TaskBody struct { 8287 Req *types.PowerOffVApp_Task `xml:"urn:vim25 PowerOffVApp_Task,omitempty"` 8288 Res *types.PowerOffVApp_TaskResponse `xml:"urn:vim25 PowerOffVApp_TaskResponse,omitempty"` 8289 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8290} 8291 8292func (b *PowerOffVApp_TaskBody) Fault() *soap.Fault { return b.Fault_ } 8293 8294func PowerOffVApp_Task(ctx context.Context, r soap.RoundTripper, req *types.PowerOffVApp_Task) (*types.PowerOffVApp_TaskResponse, error) { 8295 var reqBody, resBody PowerOffVApp_TaskBody 8296 8297 reqBody.Req = req 8298 8299 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8300 return nil, err 8301 } 8302 8303 return resBody.Res, nil 8304} 8305 8306type PowerOffVM_TaskBody struct { 8307 Req *types.PowerOffVM_Task `xml:"urn:vim25 PowerOffVM_Task,omitempty"` 8308 Res *types.PowerOffVM_TaskResponse `xml:"urn:vim25 PowerOffVM_TaskResponse,omitempty"` 8309 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8310} 8311 8312func (b *PowerOffVM_TaskBody) Fault() *soap.Fault { return b.Fault_ } 8313 8314func PowerOffVM_Task(ctx context.Context, r soap.RoundTripper, req *types.PowerOffVM_Task) (*types.PowerOffVM_TaskResponse, error) { 8315 var reqBody, resBody PowerOffVM_TaskBody 8316 8317 reqBody.Req = req 8318 8319 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8320 return nil, err 8321 } 8322 8323 return resBody.Res, nil 8324} 8325 8326type PowerOnMultiVM_TaskBody struct { 8327 Req *types.PowerOnMultiVM_Task `xml:"urn:vim25 PowerOnMultiVM_Task,omitempty"` 8328 Res *types.PowerOnMultiVM_TaskResponse `xml:"urn:vim25 PowerOnMultiVM_TaskResponse,omitempty"` 8329 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8330} 8331 8332func (b *PowerOnMultiVM_TaskBody) Fault() *soap.Fault { return b.Fault_ } 8333 8334func PowerOnMultiVM_Task(ctx context.Context, r soap.RoundTripper, req *types.PowerOnMultiVM_Task) (*types.PowerOnMultiVM_TaskResponse, error) { 8335 var reqBody, resBody PowerOnMultiVM_TaskBody 8336 8337 reqBody.Req = req 8338 8339 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8340 return nil, err 8341 } 8342 8343 return resBody.Res, nil 8344} 8345 8346type PowerOnVApp_TaskBody struct { 8347 Req *types.PowerOnVApp_Task `xml:"urn:vim25 PowerOnVApp_Task,omitempty"` 8348 Res *types.PowerOnVApp_TaskResponse `xml:"urn:vim25 PowerOnVApp_TaskResponse,omitempty"` 8349 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8350} 8351 8352func (b *PowerOnVApp_TaskBody) Fault() *soap.Fault { return b.Fault_ } 8353 8354func PowerOnVApp_Task(ctx context.Context, r soap.RoundTripper, req *types.PowerOnVApp_Task) (*types.PowerOnVApp_TaskResponse, error) { 8355 var reqBody, resBody PowerOnVApp_TaskBody 8356 8357 reqBody.Req = req 8358 8359 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8360 return nil, err 8361 } 8362 8363 return resBody.Res, nil 8364} 8365 8366type PowerOnVM_TaskBody struct { 8367 Req *types.PowerOnVM_Task `xml:"urn:vim25 PowerOnVM_Task,omitempty"` 8368 Res *types.PowerOnVM_TaskResponse `xml:"urn:vim25 PowerOnVM_TaskResponse,omitempty"` 8369 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8370} 8371 8372func (b *PowerOnVM_TaskBody) Fault() *soap.Fault { return b.Fault_ } 8373 8374func PowerOnVM_Task(ctx context.Context, r soap.RoundTripper, req *types.PowerOnVM_Task) (*types.PowerOnVM_TaskResponse, error) { 8375 var reqBody, resBody PowerOnVM_TaskBody 8376 8377 reqBody.Req = req 8378 8379 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8380 return nil, err 8381 } 8382 8383 return resBody.Res, nil 8384} 8385 8386type PowerUpHostFromStandBy_TaskBody struct { 8387 Req *types.PowerUpHostFromStandBy_Task `xml:"urn:vim25 PowerUpHostFromStandBy_Task,omitempty"` 8388 Res *types.PowerUpHostFromStandBy_TaskResponse `xml:"urn:vim25 PowerUpHostFromStandBy_TaskResponse,omitempty"` 8389 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8390} 8391 8392func (b *PowerUpHostFromStandBy_TaskBody) Fault() *soap.Fault { return b.Fault_ } 8393 8394func PowerUpHostFromStandBy_Task(ctx context.Context, r soap.RoundTripper, req *types.PowerUpHostFromStandBy_Task) (*types.PowerUpHostFromStandBy_TaskResponse, error) { 8395 var reqBody, resBody PowerUpHostFromStandBy_TaskBody 8396 8397 reqBody.Req = req 8398 8399 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8400 return nil, err 8401 } 8402 8403 return resBody.Res, nil 8404} 8405 8406type PrepareCryptoBody struct { 8407 Req *types.PrepareCrypto `xml:"urn:vim25 PrepareCrypto,omitempty"` 8408 Res *types.PrepareCryptoResponse `xml:"urn:vim25 PrepareCryptoResponse,omitempty"` 8409 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8410} 8411 8412func (b *PrepareCryptoBody) Fault() *soap.Fault { return b.Fault_ } 8413 8414func PrepareCrypto(ctx context.Context, r soap.RoundTripper, req *types.PrepareCrypto) (*types.PrepareCryptoResponse, error) { 8415 var reqBody, resBody PrepareCryptoBody 8416 8417 reqBody.Req = req 8418 8419 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8420 return nil, err 8421 } 8422 8423 return resBody.Res, nil 8424} 8425 8426type PromoteDisks_TaskBody struct { 8427 Req *types.PromoteDisks_Task `xml:"urn:vim25 PromoteDisks_Task,omitempty"` 8428 Res *types.PromoteDisks_TaskResponse `xml:"urn:vim25 PromoteDisks_TaskResponse,omitempty"` 8429 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8430} 8431 8432func (b *PromoteDisks_TaskBody) Fault() *soap.Fault { return b.Fault_ } 8433 8434func PromoteDisks_Task(ctx context.Context, r soap.RoundTripper, req *types.PromoteDisks_Task) (*types.PromoteDisks_TaskResponse, error) { 8435 var reqBody, resBody PromoteDisks_TaskBody 8436 8437 reqBody.Req = req 8438 8439 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8440 return nil, err 8441 } 8442 8443 return resBody.Res, nil 8444} 8445 8446type PutUsbScanCodesBody struct { 8447 Req *types.PutUsbScanCodes `xml:"urn:vim25 PutUsbScanCodes,omitempty"` 8448 Res *types.PutUsbScanCodesResponse `xml:"urn:vim25 PutUsbScanCodesResponse,omitempty"` 8449 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8450} 8451 8452func (b *PutUsbScanCodesBody) Fault() *soap.Fault { return b.Fault_ } 8453 8454func PutUsbScanCodes(ctx context.Context, r soap.RoundTripper, req *types.PutUsbScanCodes) (*types.PutUsbScanCodesResponse, error) { 8455 var reqBody, resBody PutUsbScanCodesBody 8456 8457 reqBody.Req = req 8458 8459 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8460 return nil, err 8461 } 8462 8463 return resBody.Res, nil 8464} 8465 8466type QueryAnswerFileStatusBody struct { 8467 Req *types.QueryAnswerFileStatus `xml:"urn:vim25 QueryAnswerFileStatus,omitempty"` 8468 Res *types.QueryAnswerFileStatusResponse `xml:"urn:vim25 QueryAnswerFileStatusResponse,omitempty"` 8469 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8470} 8471 8472func (b *QueryAnswerFileStatusBody) Fault() *soap.Fault { return b.Fault_ } 8473 8474func QueryAnswerFileStatus(ctx context.Context, r soap.RoundTripper, req *types.QueryAnswerFileStatus) (*types.QueryAnswerFileStatusResponse, error) { 8475 var reqBody, resBody QueryAnswerFileStatusBody 8476 8477 reqBody.Req = req 8478 8479 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8480 return nil, err 8481 } 8482 8483 return resBody.Res, nil 8484} 8485 8486type QueryAssignedLicensesBody struct { 8487 Req *types.QueryAssignedLicenses `xml:"urn:vim25 QueryAssignedLicenses,omitempty"` 8488 Res *types.QueryAssignedLicensesResponse `xml:"urn:vim25 QueryAssignedLicensesResponse,omitempty"` 8489 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8490} 8491 8492func (b *QueryAssignedLicensesBody) Fault() *soap.Fault { return b.Fault_ } 8493 8494func QueryAssignedLicenses(ctx context.Context, r soap.RoundTripper, req *types.QueryAssignedLicenses) (*types.QueryAssignedLicensesResponse, error) { 8495 var reqBody, resBody QueryAssignedLicensesBody 8496 8497 reqBody.Req = req 8498 8499 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8500 return nil, err 8501 } 8502 8503 return resBody.Res, nil 8504} 8505 8506type QueryAvailableDisksForVmfsBody struct { 8507 Req *types.QueryAvailableDisksForVmfs `xml:"urn:vim25 QueryAvailableDisksForVmfs,omitempty"` 8508 Res *types.QueryAvailableDisksForVmfsResponse `xml:"urn:vim25 QueryAvailableDisksForVmfsResponse,omitempty"` 8509 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8510} 8511 8512func (b *QueryAvailableDisksForVmfsBody) Fault() *soap.Fault { return b.Fault_ } 8513 8514func QueryAvailableDisksForVmfs(ctx context.Context, r soap.RoundTripper, req *types.QueryAvailableDisksForVmfs) (*types.QueryAvailableDisksForVmfsResponse, error) { 8515 var reqBody, resBody QueryAvailableDisksForVmfsBody 8516 8517 reqBody.Req = req 8518 8519 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8520 return nil, err 8521 } 8522 8523 return resBody.Res, nil 8524} 8525 8526type QueryAvailableDvsSpecBody struct { 8527 Req *types.QueryAvailableDvsSpec `xml:"urn:vim25 QueryAvailableDvsSpec,omitempty"` 8528 Res *types.QueryAvailableDvsSpecResponse `xml:"urn:vim25 QueryAvailableDvsSpecResponse,omitempty"` 8529 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8530} 8531 8532func (b *QueryAvailableDvsSpecBody) Fault() *soap.Fault { return b.Fault_ } 8533 8534func QueryAvailableDvsSpec(ctx context.Context, r soap.RoundTripper, req *types.QueryAvailableDvsSpec) (*types.QueryAvailableDvsSpecResponse, error) { 8535 var reqBody, resBody QueryAvailableDvsSpecBody 8536 8537 reqBody.Req = req 8538 8539 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8540 return nil, err 8541 } 8542 8543 return resBody.Res, nil 8544} 8545 8546type QueryAvailablePartitionBody struct { 8547 Req *types.QueryAvailablePartition `xml:"urn:vim25 QueryAvailablePartition,omitempty"` 8548 Res *types.QueryAvailablePartitionResponse `xml:"urn:vim25 QueryAvailablePartitionResponse,omitempty"` 8549 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8550} 8551 8552func (b *QueryAvailablePartitionBody) Fault() *soap.Fault { return b.Fault_ } 8553 8554func QueryAvailablePartition(ctx context.Context, r soap.RoundTripper, req *types.QueryAvailablePartition) (*types.QueryAvailablePartitionResponse, error) { 8555 var reqBody, resBody QueryAvailablePartitionBody 8556 8557 reqBody.Req = req 8558 8559 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8560 return nil, err 8561 } 8562 8563 return resBody.Res, nil 8564} 8565 8566type QueryAvailablePerfMetricBody struct { 8567 Req *types.QueryAvailablePerfMetric `xml:"urn:vim25 QueryAvailablePerfMetric,omitempty"` 8568 Res *types.QueryAvailablePerfMetricResponse `xml:"urn:vim25 QueryAvailablePerfMetricResponse,omitempty"` 8569 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8570} 8571 8572func (b *QueryAvailablePerfMetricBody) Fault() *soap.Fault { return b.Fault_ } 8573 8574func QueryAvailablePerfMetric(ctx context.Context, r soap.RoundTripper, req *types.QueryAvailablePerfMetric) (*types.QueryAvailablePerfMetricResponse, error) { 8575 var reqBody, resBody QueryAvailablePerfMetricBody 8576 8577 reqBody.Req = req 8578 8579 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8580 return nil, err 8581 } 8582 8583 return resBody.Res, nil 8584} 8585 8586type QueryAvailableSsdsBody struct { 8587 Req *types.QueryAvailableSsds `xml:"urn:vim25 QueryAvailableSsds,omitempty"` 8588 Res *types.QueryAvailableSsdsResponse `xml:"urn:vim25 QueryAvailableSsdsResponse,omitempty"` 8589 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8590} 8591 8592func (b *QueryAvailableSsdsBody) Fault() *soap.Fault { return b.Fault_ } 8593 8594func QueryAvailableSsds(ctx context.Context, r soap.RoundTripper, req *types.QueryAvailableSsds) (*types.QueryAvailableSsdsResponse, error) { 8595 var reqBody, resBody QueryAvailableSsdsBody 8596 8597 reqBody.Req = req 8598 8599 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8600 return nil, err 8601 } 8602 8603 return resBody.Res, nil 8604} 8605 8606type QueryAvailableTimeZonesBody struct { 8607 Req *types.QueryAvailableTimeZones `xml:"urn:vim25 QueryAvailableTimeZones,omitempty"` 8608 Res *types.QueryAvailableTimeZonesResponse `xml:"urn:vim25 QueryAvailableTimeZonesResponse,omitempty"` 8609 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8610} 8611 8612func (b *QueryAvailableTimeZonesBody) Fault() *soap.Fault { return b.Fault_ } 8613 8614func QueryAvailableTimeZones(ctx context.Context, r soap.RoundTripper, req *types.QueryAvailableTimeZones) (*types.QueryAvailableTimeZonesResponse, error) { 8615 var reqBody, resBody QueryAvailableTimeZonesBody 8616 8617 reqBody.Req = req 8618 8619 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8620 return nil, err 8621 } 8622 8623 return resBody.Res, nil 8624} 8625 8626type QueryBootDevicesBody struct { 8627 Req *types.QueryBootDevices `xml:"urn:vim25 QueryBootDevices,omitempty"` 8628 Res *types.QueryBootDevicesResponse `xml:"urn:vim25 QueryBootDevicesResponse,omitempty"` 8629 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8630} 8631 8632func (b *QueryBootDevicesBody) Fault() *soap.Fault { return b.Fault_ } 8633 8634func QueryBootDevices(ctx context.Context, r soap.RoundTripper, req *types.QueryBootDevices) (*types.QueryBootDevicesResponse, error) { 8635 var reqBody, resBody QueryBootDevicesBody 8636 8637 reqBody.Req = req 8638 8639 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8640 return nil, err 8641 } 8642 8643 return resBody.Res, nil 8644} 8645 8646type QueryBoundVnicsBody struct { 8647 Req *types.QueryBoundVnics `xml:"urn:vim25 QueryBoundVnics,omitempty"` 8648 Res *types.QueryBoundVnicsResponse `xml:"urn:vim25 QueryBoundVnicsResponse,omitempty"` 8649 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8650} 8651 8652func (b *QueryBoundVnicsBody) Fault() *soap.Fault { return b.Fault_ } 8653 8654func QueryBoundVnics(ctx context.Context, r soap.RoundTripper, req *types.QueryBoundVnics) (*types.QueryBoundVnicsResponse, error) { 8655 var reqBody, resBody QueryBoundVnicsBody 8656 8657 reqBody.Req = req 8658 8659 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8660 return nil, err 8661 } 8662 8663 return resBody.Res, nil 8664} 8665 8666type QueryCandidateNicsBody struct { 8667 Req *types.QueryCandidateNics `xml:"urn:vim25 QueryCandidateNics,omitempty"` 8668 Res *types.QueryCandidateNicsResponse `xml:"urn:vim25 QueryCandidateNicsResponse,omitempty"` 8669 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8670} 8671 8672func (b *QueryCandidateNicsBody) Fault() *soap.Fault { return b.Fault_ } 8673 8674func QueryCandidateNics(ctx context.Context, r soap.RoundTripper, req *types.QueryCandidateNics) (*types.QueryCandidateNicsResponse, error) { 8675 var reqBody, resBody QueryCandidateNicsBody 8676 8677 reqBody.Req = req 8678 8679 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8680 return nil, err 8681 } 8682 8683 return resBody.Res, nil 8684} 8685 8686type QueryChangedDiskAreasBody struct { 8687 Req *types.QueryChangedDiskAreas `xml:"urn:vim25 QueryChangedDiskAreas,omitempty"` 8688 Res *types.QueryChangedDiskAreasResponse `xml:"urn:vim25 QueryChangedDiskAreasResponse,omitempty"` 8689 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8690} 8691 8692func (b *QueryChangedDiskAreasBody) Fault() *soap.Fault { return b.Fault_ } 8693 8694func QueryChangedDiskAreas(ctx context.Context, r soap.RoundTripper, req *types.QueryChangedDiskAreas) (*types.QueryChangedDiskAreasResponse, error) { 8695 var reqBody, resBody QueryChangedDiskAreasBody 8696 8697 reqBody.Req = req 8698 8699 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8700 return nil, err 8701 } 8702 8703 return resBody.Res, nil 8704} 8705 8706type QueryCmmdsBody struct { 8707 Req *types.QueryCmmds `xml:"urn:vim25 QueryCmmds,omitempty"` 8708 Res *types.QueryCmmdsResponse `xml:"urn:vim25 QueryCmmdsResponse,omitempty"` 8709 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8710} 8711 8712func (b *QueryCmmdsBody) Fault() *soap.Fault { return b.Fault_ } 8713 8714func QueryCmmds(ctx context.Context, r soap.RoundTripper, req *types.QueryCmmds) (*types.QueryCmmdsResponse, error) { 8715 var reqBody, resBody QueryCmmdsBody 8716 8717 reqBody.Req = req 8718 8719 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8720 return nil, err 8721 } 8722 8723 return resBody.Res, nil 8724} 8725 8726type QueryCompatibleHostForExistingDvsBody struct { 8727 Req *types.QueryCompatibleHostForExistingDvs `xml:"urn:vim25 QueryCompatibleHostForExistingDvs,omitempty"` 8728 Res *types.QueryCompatibleHostForExistingDvsResponse `xml:"urn:vim25 QueryCompatibleHostForExistingDvsResponse,omitempty"` 8729 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8730} 8731 8732func (b *QueryCompatibleHostForExistingDvsBody) Fault() *soap.Fault { return b.Fault_ } 8733 8734func QueryCompatibleHostForExistingDvs(ctx context.Context, r soap.RoundTripper, req *types.QueryCompatibleHostForExistingDvs) (*types.QueryCompatibleHostForExistingDvsResponse, error) { 8735 var reqBody, resBody QueryCompatibleHostForExistingDvsBody 8736 8737 reqBody.Req = req 8738 8739 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8740 return nil, err 8741 } 8742 8743 return resBody.Res, nil 8744} 8745 8746type QueryCompatibleHostForNewDvsBody struct { 8747 Req *types.QueryCompatibleHostForNewDvs `xml:"urn:vim25 QueryCompatibleHostForNewDvs,omitempty"` 8748 Res *types.QueryCompatibleHostForNewDvsResponse `xml:"urn:vim25 QueryCompatibleHostForNewDvsResponse,omitempty"` 8749 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8750} 8751 8752func (b *QueryCompatibleHostForNewDvsBody) Fault() *soap.Fault { return b.Fault_ } 8753 8754func QueryCompatibleHostForNewDvs(ctx context.Context, r soap.RoundTripper, req *types.QueryCompatibleHostForNewDvs) (*types.QueryCompatibleHostForNewDvsResponse, error) { 8755 var reqBody, resBody QueryCompatibleHostForNewDvsBody 8756 8757 reqBody.Req = req 8758 8759 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8760 return nil, err 8761 } 8762 8763 return resBody.Res, nil 8764} 8765 8766type QueryComplianceStatusBody struct { 8767 Req *types.QueryComplianceStatus `xml:"urn:vim25 QueryComplianceStatus,omitempty"` 8768 Res *types.QueryComplianceStatusResponse `xml:"urn:vim25 QueryComplianceStatusResponse,omitempty"` 8769 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8770} 8771 8772func (b *QueryComplianceStatusBody) Fault() *soap.Fault { return b.Fault_ } 8773 8774func QueryComplianceStatus(ctx context.Context, r soap.RoundTripper, req *types.QueryComplianceStatus) (*types.QueryComplianceStatusResponse, error) { 8775 var reqBody, resBody QueryComplianceStatusBody 8776 8777 reqBody.Req = req 8778 8779 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8780 return nil, err 8781 } 8782 8783 return resBody.Res, nil 8784} 8785 8786type QueryConfigOptionBody struct { 8787 Req *types.QueryConfigOption `xml:"urn:vim25 QueryConfigOption,omitempty"` 8788 Res *types.QueryConfigOptionResponse `xml:"urn:vim25 QueryConfigOptionResponse,omitempty"` 8789 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8790} 8791 8792func (b *QueryConfigOptionBody) Fault() *soap.Fault { return b.Fault_ } 8793 8794func QueryConfigOption(ctx context.Context, r soap.RoundTripper, req *types.QueryConfigOption) (*types.QueryConfigOptionResponse, error) { 8795 var reqBody, resBody QueryConfigOptionBody 8796 8797 reqBody.Req = req 8798 8799 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8800 return nil, err 8801 } 8802 8803 return resBody.Res, nil 8804} 8805 8806type QueryConfigOptionDescriptorBody struct { 8807 Req *types.QueryConfigOptionDescriptor `xml:"urn:vim25 QueryConfigOptionDescriptor,omitempty"` 8808 Res *types.QueryConfigOptionDescriptorResponse `xml:"urn:vim25 QueryConfigOptionDescriptorResponse,omitempty"` 8809 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8810} 8811 8812func (b *QueryConfigOptionDescriptorBody) Fault() *soap.Fault { return b.Fault_ } 8813 8814func QueryConfigOptionDescriptor(ctx context.Context, r soap.RoundTripper, req *types.QueryConfigOptionDescriptor) (*types.QueryConfigOptionDescriptorResponse, error) { 8815 var reqBody, resBody QueryConfigOptionDescriptorBody 8816 8817 reqBody.Req = req 8818 8819 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8820 return nil, err 8821 } 8822 8823 return resBody.Res, nil 8824} 8825 8826type QueryConfigOptionExBody struct { 8827 Req *types.QueryConfigOptionEx `xml:"urn:vim25 QueryConfigOptionEx,omitempty"` 8828 Res *types.QueryConfigOptionExResponse `xml:"urn:vim25 QueryConfigOptionExResponse,omitempty"` 8829 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8830} 8831 8832func (b *QueryConfigOptionExBody) Fault() *soap.Fault { return b.Fault_ } 8833 8834func QueryConfigOptionEx(ctx context.Context, r soap.RoundTripper, req *types.QueryConfigOptionEx) (*types.QueryConfigOptionExResponse, error) { 8835 var reqBody, resBody QueryConfigOptionExBody 8836 8837 reqBody.Req = req 8838 8839 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8840 return nil, err 8841 } 8842 8843 return resBody.Res, nil 8844} 8845 8846type QueryConfigTargetBody struct { 8847 Req *types.QueryConfigTarget `xml:"urn:vim25 QueryConfigTarget,omitempty"` 8848 Res *types.QueryConfigTargetResponse `xml:"urn:vim25 QueryConfigTargetResponse,omitempty"` 8849 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8850} 8851 8852func (b *QueryConfigTargetBody) Fault() *soap.Fault { return b.Fault_ } 8853 8854func QueryConfigTarget(ctx context.Context, r soap.RoundTripper, req *types.QueryConfigTarget) (*types.QueryConfigTargetResponse, error) { 8855 var reqBody, resBody QueryConfigTargetBody 8856 8857 reqBody.Req = req 8858 8859 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8860 return nil, err 8861 } 8862 8863 return resBody.Res, nil 8864} 8865 8866type QueryConfiguredModuleOptionStringBody struct { 8867 Req *types.QueryConfiguredModuleOptionString `xml:"urn:vim25 QueryConfiguredModuleOptionString,omitempty"` 8868 Res *types.QueryConfiguredModuleOptionStringResponse `xml:"urn:vim25 QueryConfiguredModuleOptionStringResponse,omitempty"` 8869 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8870} 8871 8872func (b *QueryConfiguredModuleOptionStringBody) Fault() *soap.Fault { return b.Fault_ } 8873 8874func QueryConfiguredModuleOptionString(ctx context.Context, r soap.RoundTripper, req *types.QueryConfiguredModuleOptionString) (*types.QueryConfiguredModuleOptionStringResponse, error) { 8875 var reqBody, resBody QueryConfiguredModuleOptionStringBody 8876 8877 reqBody.Req = req 8878 8879 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8880 return nil, err 8881 } 8882 8883 return resBody.Res, nil 8884} 8885 8886type QueryConnectionInfoBody struct { 8887 Req *types.QueryConnectionInfo `xml:"urn:vim25 QueryConnectionInfo,omitempty"` 8888 Res *types.QueryConnectionInfoResponse `xml:"urn:vim25 QueryConnectionInfoResponse,omitempty"` 8889 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8890} 8891 8892func (b *QueryConnectionInfoBody) Fault() *soap.Fault { return b.Fault_ } 8893 8894func QueryConnectionInfo(ctx context.Context, r soap.RoundTripper, req *types.QueryConnectionInfo) (*types.QueryConnectionInfoResponse, error) { 8895 var reqBody, resBody QueryConnectionInfoBody 8896 8897 reqBody.Req = req 8898 8899 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8900 return nil, err 8901 } 8902 8903 return resBody.Res, nil 8904} 8905 8906type QueryConnectionInfoViaSpecBody struct { 8907 Req *types.QueryConnectionInfoViaSpec `xml:"urn:vim25 QueryConnectionInfoViaSpec,omitempty"` 8908 Res *types.QueryConnectionInfoViaSpecResponse `xml:"urn:vim25 QueryConnectionInfoViaSpecResponse,omitempty"` 8909 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8910} 8911 8912func (b *QueryConnectionInfoViaSpecBody) Fault() *soap.Fault { return b.Fault_ } 8913 8914func QueryConnectionInfoViaSpec(ctx context.Context, r soap.RoundTripper, req *types.QueryConnectionInfoViaSpec) (*types.QueryConnectionInfoViaSpecResponse, error) { 8915 var reqBody, resBody QueryConnectionInfoViaSpecBody 8916 8917 reqBody.Req = req 8918 8919 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8920 return nil, err 8921 } 8922 8923 return resBody.Res, nil 8924} 8925 8926type QueryDatastorePerformanceSummaryBody struct { 8927 Req *types.QueryDatastorePerformanceSummary `xml:"urn:vim25 QueryDatastorePerformanceSummary,omitempty"` 8928 Res *types.QueryDatastorePerformanceSummaryResponse `xml:"urn:vim25 QueryDatastorePerformanceSummaryResponse,omitempty"` 8929 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8930} 8931 8932func (b *QueryDatastorePerformanceSummaryBody) Fault() *soap.Fault { return b.Fault_ } 8933 8934func QueryDatastorePerformanceSummary(ctx context.Context, r soap.RoundTripper, req *types.QueryDatastorePerformanceSummary) (*types.QueryDatastorePerformanceSummaryResponse, error) { 8935 var reqBody, resBody QueryDatastorePerformanceSummaryBody 8936 8937 reqBody.Req = req 8938 8939 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8940 return nil, err 8941 } 8942 8943 return resBody.Res, nil 8944} 8945 8946type QueryDateTimeBody struct { 8947 Req *types.QueryDateTime `xml:"urn:vim25 QueryDateTime,omitempty"` 8948 Res *types.QueryDateTimeResponse `xml:"urn:vim25 QueryDateTimeResponse,omitempty"` 8949 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8950} 8951 8952func (b *QueryDateTimeBody) Fault() *soap.Fault { return b.Fault_ } 8953 8954func QueryDateTime(ctx context.Context, r soap.RoundTripper, req *types.QueryDateTime) (*types.QueryDateTimeResponse, error) { 8955 var reqBody, resBody QueryDateTimeBody 8956 8957 reqBody.Req = req 8958 8959 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8960 return nil, err 8961 } 8962 8963 return resBody.Res, nil 8964} 8965 8966type QueryDescriptionsBody struct { 8967 Req *types.QueryDescriptions `xml:"urn:vim25 QueryDescriptions,omitempty"` 8968 Res *types.QueryDescriptionsResponse `xml:"urn:vim25 QueryDescriptionsResponse,omitempty"` 8969 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8970} 8971 8972func (b *QueryDescriptionsBody) Fault() *soap.Fault { return b.Fault_ } 8973 8974func QueryDescriptions(ctx context.Context, r soap.RoundTripper, req *types.QueryDescriptions) (*types.QueryDescriptionsResponse, error) { 8975 var reqBody, resBody QueryDescriptionsBody 8976 8977 reqBody.Req = req 8978 8979 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 8980 return nil, err 8981 } 8982 8983 return resBody.Res, nil 8984} 8985 8986type QueryDisksForVsanBody struct { 8987 Req *types.QueryDisksForVsan `xml:"urn:vim25 QueryDisksForVsan,omitempty"` 8988 Res *types.QueryDisksForVsanResponse `xml:"urn:vim25 QueryDisksForVsanResponse,omitempty"` 8989 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 8990} 8991 8992func (b *QueryDisksForVsanBody) Fault() *soap.Fault { return b.Fault_ } 8993 8994func QueryDisksForVsan(ctx context.Context, r soap.RoundTripper, req *types.QueryDisksForVsan) (*types.QueryDisksForVsanResponse, error) { 8995 var reqBody, resBody QueryDisksForVsanBody 8996 8997 reqBody.Req = req 8998 8999 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9000 return nil, err 9001 } 9002 9003 return resBody.Res, nil 9004} 9005 9006type QueryDisksUsingFilterBody struct { 9007 Req *types.QueryDisksUsingFilter `xml:"urn:vim25 QueryDisksUsingFilter,omitempty"` 9008 Res *types.QueryDisksUsingFilterResponse `xml:"urn:vim25 QueryDisksUsingFilterResponse,omitempty"` 9009 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9010} 9011 9012func (b *QueryDisksUsingFilterBody) Fault() *soap.Fault { return b.Fault_ } 9013 9014func QueryDisksUsingFilter(ctx context.Context, r soap.RoundTripper, req *types.QueryDisksUsingFilter) (*types.QueryDisksUsingFilterResponse, error) { 9015 var reqBody, resBody QueryDisksUsingFilterBody 9016 9017 reqBody.Req = req 9018 9019 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9020 return nil, err 9021 } 9022 9023 return resBody.Res, nil 9024} 9025 9026type QueryDvsByUuidBody struct { 9027 Req *types.QueryDvsByUuid `xml:"urn:vim25 QueryDvsByUuid,omitempty"` 9028 Res *types.QueryDvsByUuidResponse `xml:"urn:vim25 QueryDvsByUuidResponse,omitempty"` 9029 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9030} 9031 9032func (b *QueryDvsByUuidBody) Fault() *soap.Fault { return b.Fault_ } 9033 9034func QueryDvsByUuid(ctx context.Context, r soap.RoundTripper, req *types.QueryDvsByUuid) (*types.QueryDvsByUuidResponse, error) { 9035 var reqBody, resBody QueryDvsByUuidBody 9036 9037 reqBody.Req = req 9038 9039 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9040 return nil, err 9041 } 9042 9043 return resBody.Res, nil 9044} 9045 9046type QueryDvsCheckCompatibilityBody struct { 9047 Req *types.QueryDvsCheckCompatibility `xml:"urn:vim25 QueryDvsCheckCompatibility,omitempty"` 9048 Res *types.QueryDvsCheckCompatibilityResponse `xml:"urn:vim25 QueryDvsCheckCompatibilityResponse,omitempty"` 9049 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9050} 9051 9052func (b *QueryDvsCheckCompatibilityBody) Fault() *soap.Fault { return b.Fault_ } 9053 9054func QueryDvsCheckCompatibility(ctx context.Context, r soap.RoundTripper, req *types.QueryDvsCheckCompatibility) (*types.QueryDvsCheckCompatibilityResponse, error) { 9055 var reqBody, resBody QueryDvsCheckCompatibilityBody 9056 9057 reqBody.Req = req 9058 9059 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9060 return nil, err 9061 } 9062 9063 return resBody.Res, nil 9064} 9065 9066type QueryDvsCompatibleHostSpecBody struct { 9067 Req *types.QueryDvsCompatibleHostSpec `xml:"urn:vim25 QueryDvsCompatibleHostSpec,omitempty"` 9068 Res *types.QueryDvsCompatibleHostSpecResponse `xml:"urn:vim25 QueryDvsCompatibleHostSpecResponse,omitempty"` 9069 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9070} 9071 9072func (b *QueryDvsCompatibleHostSpecBody) Fault() *soap.Fault { return b.Fault_ } 9073 9074func QueryDvsCompatibleHostSpec(ctx context.Context, r soap.RoundTripper, req *types.QueryDvsCompatibleHostSpec) (*types.QueryDvsCompatibleHostSpecResponse, error) { 9075 var reqBody, resBody QueryDvsCompatibleHostSpecBody 9076 9077 reqBody.Req = req 9078 9079 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9080 return nil, err 9081 } 9082 9083 return resBody.Res, nil 9084} 9085 9086type QueryDvsConfigTargetBody struct { 9087 Req *types.QueryDvsConfigTarget `xml:"urn:vim25 QueryDvsConfigTarget,omitempty"` 9088 Res *types.QueryDvsConfigTargetResponse `xml:"urn:vim25 QueryDvsConfigTargetResponse,omitempty"` 9089 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9090} 9091 9092func (b *QueryDvsConfigTargetBody) Fault() *soap.Fault { return b.Fault_ } 9093 9094func QueryDvsConfigTarget(ctx context.Context, r soap.RoundTripper, req *types.QueryDvsConfigTarget) (*types.QueryDvsConfigTargetResponse, error) { 9095 var reqBody, resBody QueryDvsConfigTargetBody 9096 9097 reqBody.Req = req 9098 9099 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9100 return nil, err 9101 } 9102 9103 return resBody.Res, nil 9104} 9105 9106type QueryDvsFeatureCapabilityBody struct { 9107 Req *types.QueryDvsFeatureCapability `xml:"urn:vim25 QueryDvsFeatureCapability,omitempty"` 9108 Res *types.QueryDvsFeatureCapabilityResponse `xml:"urn:vim25 QueryDvsFeatureCapabilityResponse,omitempty"` 9109 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9110} 9111 9112func (b *QueryDvsFeatureCapabilityBody) Fault() *soap.Fault { return b.Fault_ } 9113 9114func QueryDvsFeatureCapability(ctx context.Context, r soap.RoundTripper, req *types.QueryDvsFeatureCapability) (*types.QueryDvsFeatureCapabilityResponse, error) { 9115 var reqBody, resBody QueryDvsFeatureCapabilityBody 9116 9117 reqBody.Req = req 9118 9119 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9120 return nil, err 9121 } 9122 9123 return resBody.Res, nil 9124} 9125 9126type QueryEventsBody struct { 9127 Req *types.QueryEvents `xml:"urn:vim25 QueryEvents,omitempty"` 9128 Res *types.QueryEventsResponse `xml:"urn:vim25 QueryEventsResponse,omitempty"` 9129 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9130} 9131 9132func (b *QueryEventsBody) Fault() *soap.Fault { return b.Fault_ } 9133 9134func QueryEvents(ctx context.Context, r soap.RoundTripper, req *types.QueryEvents) (*types.QueryEventsResponse, error) { 9135 var reqBody, resBody QueryEventsBody 9136 9137 reqBody.Req = req 9138 9139 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9140 return nil, err 9141 } 9142 9143 return resBody.Res, nil 9144} 9145 9146type QueryExpressionMetadataBody struct { 9147 Req *types.QueryExpressionMetadata `xml:"urn:vim25 QueryExpressionMetadata,omitempty"` 9148 Res *types.QueryExpressionMetadataResponse `xml:"urn:vim25 QueryExpressionMetadataResponse,omitempty"` 9149 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9150} 9151 9152func (b *QueryExpressionMetadataBody) Fault() *soap.Fault { return b.Fault_ } 9153 9154func QueryExpressionMetadata(ctx context.Context, r soap.RoundTripper, req *types.QueryExpressionMetadata) (*types.QueryExpressionMetadataResponse, error) { 9155 var reqBody, resBody QueryExpressionMetadataBody 9156 9157 reqBody.Req = req 9158 9159 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9160 return nil, err 9161 } 9162 9163 return resBody.Res, nil 9164} 9165 9166type QueryExtensionIpAllocationUsageBody struct { 9167 Req *types.QueryExtensionIpAllocationUsage `xml:"urn:vim25 QueryExtensionIpAllocationUsage,omitempty"` 9168 Res *types.QueryExtensionIpAllocationUsageResponse `xml:"urn:vim25 QueryExtensionIpAllocationUsageResponse,omitempty"` 9169 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9170} 9171 9172func (b *QueryExtensionIpAllocationUsageBody) Fault() *soap.Fault { return b.Fault_ } 9173 9174func QueryExtensionIpAllocationUsage(ctx context.Context, r soap.RoundTripper, req *types.QueryExtensionIpAllocationUsage) (*types.QueryExtensionIpAllocationUsageResponse, error) { 9175 var reqBody, resBody QueryExtensionIpAllocationUsageBody 9176 9177 reqBody.Req = req 9178 9179 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9180 return nil, err 9181 } 9182 9183 return resBody.Res, nil 9184} 9185 9186type QueryFaultToleranceCompatibilityBody struct { 9187 Req *types.QueryFaultToleranceCompatibility `xml:"urn:vim25 QueryFaultToleranceCompatibility,omitempty"` 9188 Res *types.QueryFaultToleranceCompatibilityResponse `xml:"urn:vim25 QueryFaultToleranceCompatibilityResponse,omitempty"` 9189 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9190} 9191 9192func (b *QueryFaultToleranceCompatibilityBody) Fault() *soap.Fault { return b.Fault_ } 9193 9194func QueryFaultToleranceCompatibility(ctx context.Context, r soap.RoundTripper, req *types.QueryFaultToleranceCompatibility) (*types.QueryFaultToleranceCompatibilityResponse, error) { 9195 var reqBody, resBody QueryFaultToleranceCompatibilityBody 9196 9197 reqBody.Req = req 9198 9199 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9200 return nil, err 9201 } 9202 9203 return resBody.Res, nil 9204} 9205 9206type QueryFaultToleranceCompatibilityExBody struct { 9207 Req *types.QueryFaultToleranceCompatibilityEx `xml:"urn:vim25 QueryFaultToleranceCompatibilityEx,omitempty"` 9208 Res *types.QueryFaultToleranceCompatibilityExResponse `xml:"urn:vim25 QueryFaultToleranceCompatibilityExResponse,omitempty"` 9209 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9210} 9211 9212func (b *QueryFaultToleranceCompatibilityExBody) Fault() *soap.Fault { return b.Fault_ } 9213 9214func QueryFaultToleranceCompatibilityEx(ctx context.Context, r soap.RoundTripper, req *types.QueryFaultToleranceCompatibilityEx) (*types.QueryFaultToleranceCompatibilityExResponse, error) { 9215 var reqBody, resBody QueryFaultToleranceCompatibilityExBody 9216 9217 reqBody.Req = req 9218 9219 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9220 return nil, err 9221 } 9222 9223 return resBody.Res, nil 9224} 9225 9226type QueryFilterEntitiesBody struct { 9227 Req *types.QueryFilterEntities `xml:"urn:vim25 QueryFilterEntities,omitempty"` 9228 Res *types.QueryFilterEntitiesResponse `xml:"urn:vim25 QueryFilterEntitiesResponse,omitempty"` 9229 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9230} 9231 9232func (b *QueryFilterEntitiesBody) Fault() *soap.Fault { return b.Fault_ } 9233 9234func QueryFilterEntities(ctx context.Context, r soap.RoundTripper, req *types.QueryFilterEntities) (*types.QueryFilterEntitiesResponse, error) { 9235 var reqBody, resBody QueryFilterEntitiesBody 9236 9237 reqBody.Req = req 9238 9239 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9240 return nil, err 9241 } 9242 9243 return resBody.Res, nil 9244} 9245 9246type QueryFilterInfoIdsBody struct { 9247 Req *types.QueryFilterInfoIds `xml:"urn:vim25 QueryFilterInfoIds,omitempty"` 9248 Res *types.QueryFilterInfoIdsResponse `xml:"urn:vim25 QueryFilterInfoIdsResponse,omitempty"` 9249 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9250} 9251 9252func (b *QueryFilterInfoIdsBody) Fault() *soap.Fault { return b.Fault_ } 9253 9254func QueryFilterInfoIds(ctx context.Context, r soap.RoundTripper, req *types.QueryFilterInfoIds) (*types.QueryFilterInfoIdsResponse, error) { 9255 var reqBody, resBody QueryFilterInfoIdsBody 9256 9257 reqBody.Req = req 9258 9259 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9260 return nil, err 9261 } 9262 9263 return resBody.Res, nil 9264} 9265 9266type QueryFilterListBody struct { 9267 Req *types.QueryFilterList `xml:"urn:vim25 QueryFilterList,omitempty"` 9268 Res *types.QueryFilterListResponse `xml:"urn:vim25 QueryFilterListResponse,omitempty"` 9269 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9270} 9271 9272func (b *QueryFilterListBody) Fault() *soap.Fault { return b.Fault_ } 9273 9274func QueryFilterList(ctx context.Context, r soap.RoundTripper, req *types.QueryFilterList) (*types.QueryFilterListResponse, error) { 9275 var reqBody, resBody QueryFilterListBody 9276 9277 reqBody.Req = req 9278 9279 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9280 return nil, err 9281 } 9282 9283 return resBody.Res, nil 9284} 9285 9286type QueryFilterNameBody struct { 9287 Req *types.QueryFilterName `xml:"urn:vim25 QueryFilterName,omitempty"` 9288 Res *types.QueryFilterNameResponse `xml:"urn:vim25 QueryFilterNameResponse,omitempty"` 9289 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9290} 9291 9292func (b *QueryFilterNameBody) Fault() *soap.Fault { return b.Fault_ } 9293 9294func QueryFilterName(ctx context.Context, r soap.RoundTripper, req *types.QueryFilterName) (*types.QueryFilterNameResponse, error) { 9295 var reqBody, resBody QueryFilterNameBody 9296 9297 reqBody.Req = req 9298 9299 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9300 return nil, err 9301 } 9302 9303 return resBody.Res, nil 9304} 9305 9306type QueryFirmwareConfigUploadURLBody struct { 9307 Req *types.QueryFirmwareConfigUploadURL `xml:"urn:vim25 QueryFirmwareConfigUploadURL,omitempty"` 9308 Res *types.QueryFirmwareConfigUploadURLResponse `xml:"urn:vim25 QueryFirmwareConfigUploadURLResponse,omitempty"` 9309 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9310} 9311 9312func (b *QueryFirmwareConfigUploadURLBody) Fault() *soap.Fault { return b.Fault_ } 9313 9314func QueryFirmwareConfigUploadURL(ctx context.Context, r soap.RoundTripper, req *types.QueryFirmwareConfigUploadURL) (*types.QueryFirmwareConfigUploadURLResponse, error) { 9315 var reqBody, resBody QueryFirmwareConfigUploadURLBody 9316 9317 reqBody.Req = req 9318 9319 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9320 return nil, err 9321 } 9322 9323 return resBody.Res, nil 9324} 9325 9326type QueryHealthUpdateInfosBody struct { 9327 Req *types.QueryHealthUpdateInfos `xml:"urn:vim25 QueryHealthUpdateInfos,omitempty"` 9328 Res *types.QueryHealthUpdateInfosResponse `xml:"urn:vim25 QueryHealthUpdateInfosResponse,omitempty"` 9329 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9330} 9331 9332func (b *QueryHealthUpdateInfosBody) Fault() *soap.Fault { return b.Fault_ } 9333 9334func QueryHealthUpdateInfos(ctx context.Context, r soap.RoundTripper, req *types.QueryHealthUpdateInfos) (*types.QueryHealthUpdateInfosResponse, error) { 9335 var reqBody, resBody QueryHealthUpdateInfosBody 9336 9337 reqBody.Req = req 9338 9339 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9340 return nil, err 9341 } 9342 9343 return resBody.Res, nil 9344} 9345 9346type QueryHealthUpdatesBody struct { 9347 Req *types.QueryHealthUpdates `xml:"urn:vim25 QueryHealthUpdates,omitempty"` 9348 Res *types.QueryHealthUpdatesResponse `xml:"urn:vim25 QueryHealthUpdatesResponse,omitempty"` 9349 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9350} 9351 9352func (b *QueryHealthUpdatesBody) Fault() *soap.Fault { return b.Fault_ } 9353 9354func QueryHealthUpdates(ctx context.Context, r soap.RoundTripper, req *types.QueryHealthUpdates) (*types.QueryHealthUpdatesResponse, error) { 9355 var reqBody, resBody QueryHealthUpdatesBody 9356 9357 reqBody.Req = req 9358 9359 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9360 return nil, err 9361 } 9362 9363 return resBody.Res, nil 9364} 9365 9366type QueryHostConnectionInfoBody struct { 9367 Req *types.QueryHostConnectionInfo `xml:"urn:vim25 QueryHostConnectionInfo,omitempty"` 9368 Res *types.QueryHostConnectionInfoResponse `xml:"urn:vim25 QueryHostConnectionInfoResponse,omitempty"` 9369 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9370} 9371 9372func (b *QueryHostConnectionInfoBody) Fault() *soap.Fault { return b.Fault_ } 9373 9374func QueryHostConnectionInfo(ctx context.Context, r soap.RoundTripper, req *types.QueryHostConnectionInfo) (*types.QueryHostConnectionInfoResponse, error) { 9375 var reqBody, resBody QueryHostConnectionInfoBody 9376 9377 reqBody.Req = req 9378 9379 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9380 return nil, err 9381 } 9382 9383 return resBody.Res, nil 9384} 9385 9386type QueryHostPatch_TaskBody struct { 9387 Req *types.QueryHostPatch_Task `xml:"urn:vim25 QueryHostPatch_Task,omitempty"` 9388 Res *types.QueryHostPatch_TaskResponse `xml:"urn:vim25 QueryHostPatch_TaskResponse,omitempty"` 9389 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9390} 9391 9392func (b *QueryHostPatch_TaskBody) Fault() *soap.Fault { return b.Fault_ } 9393 9394func QueryHostPatch_Task(ctx context.Context, r soap.RoundTripper, req *types.QueryHostPatch_Task) (*types.QueryHostPatch_TaskResponse, error) { 9395 var reqBody, resBody QueryHostPatch_TaskBody 9396 9397 reqBody.Req = req 9398 9399 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9400 return nil, err 9401 } 9402 9403 return resBody.Res, nil 9404} 9405 9406type QueryHostProfileMetadataBody struct { 9407 Req *types.QueryHostProfileMetadata `xml:"urn:vim25 QueryHostProfileMetadata,omitempty"` 9408 Res *types.QueryHostProfileMetadataResponse `xml:"urn:vim25 QueryHostProfileMetadataResponse,omitempty"` 9409 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9410} 9411 9412func (b *QueryHostProfileMetadataBody) Fault() *soap.Fault { return b.Fault_ } 9413 9414func QueryHostProfileMetadata(ctx context.Context, r soap.RoundTripper, req *types.QueryHostProfileMetadata) (*types.QueryHostProfileMetadataResponse, error) { 9415 var reqBody, resBody QueryHostProfileMetadataBody 9416 9417 reqBody.Req = req 9418 9419 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9420 return nil, err 9421 } 9422 9423 return resBody.Res, nil 9424} 9425 9426type QueryHostStatusBody struct { 9427 Req *types.QueryHostStatus `xml:"urn:vim25 QueryHostStatus,omitempty"` 9428 Res *types.QueryHostStatusResponse `xml:"urn:vim25 QueryHostStatusResponse,omitempty"` 9429 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9430} 9431 9432func (b *QueryHostStatusBody) Fault() *soap.Fault { return b.Fault_ } 9433 9434func QueryHostStatus(ctx context.Context, r soap.RoundTripper, req *types.QueryHostStatus) (*types.QueryHostStatusResponse, error) { 9435 var reqBody, resBody QueryHostStatusBody 9436 9437 reqBody.Req = req 9438 9439 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9440 return nil, err 9441 } 9442 9443 return resBody.Res, nil 9444} 9445 9446type QueryIORMConfigOptionBody struct { 9447 Req *types.QueryIORMConfigOption `xml:"urn:vim25 QueryIORMConfigOption,omitempty"` 9448 Res *types.QueryIORMConfigOptionResponse `xml:"urn:vim25 QueryIORMConfigOptionResponse,omitempty"` 9449 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9450} 9451 9452func (b *QueryIORMConfigOptionBody) Fault() *soap.Fault { return b.Fault_ } 9453 9454func QueryIORMConfigOption(ctx context.Context, r soap.RoundTripper, req *types.QueryIORMConfigOption) (*types.QueryIORMConfigOptionResponse, error) { 9455 var reqBody, resBody QueryIORMConfigOptionBody 9456 9457 reqBody.Req = req 9458 9459 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9460 return nil, err 9461 } 9462 9463 return resBody.Res, nil 9464} 9465 9466type QueryIPAllocationsBody struct { 9467 Req *types.QueryIPAllocations `xml:"urn:vim25 QueryIPAllocations,omitempty"` 9468 Res *types.QueryIPAllocationsResponse `xml:"urn:vim25 QueryIPAllocationsResponse,omitempty"` 9469 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9470} 9471 9472func (b *QueryIPAllocationsBody) Fault() *soap.Fault { return b.Fault_ } 9473 9474func QueryIPAllocations(ctx context.Context, r soap.RoundTripper, req *types.QueryIPAllocations) (*types.QueryIPAllocationsResponse, error) { 9475 var reqBody, resBody QueryIPAllocationsBody 9476 9477 reqBody.Req = req 9478 9479 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9480 return nil, err 9481 } 9482 9483 return resBody.Res, nil 9484} 9485 9486type QueryIoFilterInfoBody struct { 9487 Req *types.QueryIoFilterInfo `xml:"urn:vim25 QueryIoFilterInfo,omitempty"` 9488 Res *types.QueryIoFilterInfoResponse `xml:"urn:vim25 QueryIoFilterInfoResponse,omitempty"` 9489 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9490} 9491 9492func (b *QueryIoFilterInfoBody) Fault() *soap.Fault { return b.Fault_ } 9493 9494func QueryIoFilterInfo(ctx context.Context, r soap.RoundTripper, req *types.QueryIoFilterInfo) (*types.QueryIoFilterInfoResponse, error) { 9495 var reqBody, resBody QueryIoFilterInfoBody 9496 9497 reqBody.Req = req 9498 9499 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9500 return nil, err 9501 } 9502 9503 return resBody.Res, nil 9504} 9505 9506type QueryIoFilterIssuesBody struct { 9507 Req *types.QueryIoFilterIssues `xml:"urn:vim25 QueryIoFilterIssues,omitempty"` 9508 Res *types.QueryIoFilterIssuesResponse `xml:"urn:vim25 QueryIoFilterIssuesResponse,omitempty"` 9509 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9510} 9511 9512func (b *QueryIoFilterIssuesBody) Fault() *soap.Fault { return b.Fault_ } 9513 9514func QueryIoFilterIssues(ctx context.Context, r soap.RoundTripper, req *types.QueryIoFilterIssues) (*types.QueryIoFilterIssuesResponse, error) { 9515 var reqBody, resBody QueryIoFilterIssuesBody 9516 9517 reqBody.Req = req 9518 9519 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9520 return nil, err 9521 } 9522 9523 return resBody.Res, nil 9524} 9525 9526type QueryIpPoolsBody struct { 9527 Req *types.QueryIpPools `xml:"urn:vim25 QueryIpPools,omitempty"` 9528 Res *types.QueryIpPoolsResponse `xml:"urn:vim25 QueryIpPoolsResponse,omitempty"` 9529 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9530} 9531 9532func (b *QueryIpPoolsBody) Fault() *soap.Fault { return b.Fault_ } 9533 9534func QueryIpPools(ctx context.Context, r soap.RoundTripper, req *types.QueryIpPools) (*types.QueryIpPoolsResponse, error) { 9535 var reqBody, resBody QueryIpPoolsBody 9536 9537 reqBody.Req = req 9538 9539 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9540 return nil, err 9541 } 9542 9543 return resBody.Res, nil 9544} 9545 9546type QueryLicenseSourceAvailabilityBody struct { 9547 Req *types.QueryLicenseSourceAvailability `xml:"urn:vim25 QueryLicenseSourceAvailability,omitempty"` 9548 Res *types.QueryLicenseSourceAvailabilityResponse `xml:"urn:vim25 QueryLicenseSourceAvailabilityResponse,omitempty"` 9549 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9550} 9551 9552func (b *QueryLicenseSourceAvailabilityBody) Fault() *soap.Fault { return b.Fault_ } 9553 9554func QueryLicenseSourceAvailability(ctx context.Context, r soap.RoundTripper, req *types.QueryLicenseSourceAvailability) (*types.QueryLicenseSourceAvailabilityResponse, error) { 9555 var reqBody, resBody QueryLicenseSourceAvailabilityBody 9556 9557 reqBody.Req = req 9558 9559 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9560 return nil, err 9561 } 9562 9563 return resBody.Res, nil 9564} 9565 9566type QueryLicenseUsageBody struct { 9567 Req *types.QueryLicenseUsage `xml:"urn:vim25 QueryLicenseUsage,omitempty"` 9568 Res *types.QueryLicenseUsageResponse `xml:"urn:vim25 QueryLicenseUsageResponse,omitempty"` 9569 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9570} 9571 9572func (b *QueryLicenseUsageBody) Fault() *soap.Fault { return b.Fault_ } 9573 9574func QueryLicenseUsage(ctx context.Context, r soap.RoundTripper, req *types.QueryLicenseUsage) (*types.QueryLicenseUsageResponse, error) { 9575 var reqBody, resBody QueryLicenseUsageBody 9576 9577 reqBody.Req = req 9578 9579 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9580 return nil, err 9581 } 9582 9583 return resBody.Res, nil 9584} 9585 9586type QueryLockdownExceptionsBody struct { 9587 Req *types.QueryLockdownExceptions `xml:"urn:vim25 QueryLockdownExceptions,omitempty"` 9588 Res *types.QueryLockdownExceptionsResponse `xml:"urn:vim25 QueryLockdownExceptionsResponse,omitempty"` 9589 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9590} 9591 9592func (b *QueryLockdownExceptionsBody) Fault() *soap.Fault { return b.Fault_ } 9593 9594func QueryLockdownExceptions(ctx context.Context, r soap.RoundTripper, req *types.QueryLockdownExceptions) (*types.QueryLockdownExceptionsResponse, error) { 9595 var reqBody, resBody QueryLockdownExceptionsBody 9596 9597 reqBody.Req = req 9598 9599 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9600 return nil, err 9601 } 9602 9603 return resBody.Res, nil 9604} 9605 9606type QueryManagedByBody struct { 9607 Req *types.QueryManagedBy `xml:"urn:vim25 QueryManagedBy,omitempty"` 9608 Res *types.QueryManagedByResponse `xml:"urn:vim25 QueryManagedByResponse,omitempty"` 9609 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9610} 9611 9612func (b *QueryManagedByBody) Fault() *soap.Fault { return b.Fault_ } 9613 9614func QueryManagedBy(ctx context.Context, r soap.RoundTripper, req *types.QueryManagedBy) (*types.QueryManagedByResponse, error) { 9615 var reqBody, resBody QueryManagedByBody 9616 9617 reqBody.Req = req 9618 9619 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9620 return nil, err 9621 } 9622 9623 return resBody.Res, nil 9624} 9625 9626type QueryMemoryOverheadBody struct { 9627 Req *types.QueryMemoryOverhead `xml:"urn:vim25 QueryMemoryOverhead,omitempty"` 9628 Res *types.QueryMemoryOverheadResponse `xml:"urn:vim25 QueryMemoryOverheadResponse,omitempty"` 9629 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9630} 9631 9632func (b *QueryMemoryOverheadBody) Fault() *soap.Fault { return b.Fault_ } 9633 9634func QueryMemoryOverhead(ctx context.Context, r soap.RoundTripper, req *types.QueryMemoryOverhead) (*types.QueryMemoryOverheadResponse, error) { 9635 var reqBody, resBody QueryMemoryOverheadBody 9636 9637 reqBody.Req = req 9638 9639 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9640 return nil, err 9641 } 9642 9643 return resBody.Res, nil 9644} 9645 9646type QueryMemoryOverheadExBody struct { 9647 Req *types.QueryMemoryOverheadEx `xml:"urn:vim25 QueryMemoryOverheadEx,omitempty"` 9648 Res *types.QueryMemoryOverheadExResponse `xml:"urn:vim25 QueryMemoryOverheadExResponse,omitempty"` 9649 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9650} 9651 9652func (b *QueryMemoryOverheadExBody) Fault() *soap.Fault { return b.Fault_ } 9653 9654func QueryMemoryOverheadEx(ctx context.Context, r soap.RoundTripper, req *types.QueryMemoryOverheadEx) (*types.QueryMemoryOverheadExResponse, error) { 9655 var reqBody, resBody QueryMemoryOverheadExBody 9656 9657 reqBody.Req = req 9658 9659 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9660 return nil, err 9661 } 9662 9663 return resBody.Res, nil 9664} 9665 9666type QueryMigrationDependenciesBody struct { 9667 Req *types.QueryMigrationDependencies `xml:"urn:vim25 QueryMigrationDependencies,omitempty"` 9668 Res *types.QueryMigrationDependenciesResponse `xml:"urn:vim25 QueryMigrationDependenciesResponse,omitempty"` 9669 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9670} 9671 9672func (b *QueryMigrationDependenciesBody) Fault() *soap.Fault { return b.Fault_ } 9673 9674func QueryMigrationDependencies(ctx context.Context, r soap.RoundTripper, req *types.QueryMigrationDependencies) (*types.QueryMigrationDependenciesResponse, error) { 9675 var reqBody, resBody QueryMigrationDependenciesBody 9676 9677 reqBody.Req = req 9678 9679 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9680 return nil, err 9681 } 9682 9683 return resBody.Res, nil 9684} 9685 9686type QueryModulesBody struct { 9687 Req *types.QueryModules `xml:"urn:vim25 QueryModules,omitempty"` 9688 Res *types.QueryModulesResponse `xml:"urn:vim25 QueryModulesResponse,omitempty"` 9689 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9690} 9691 9692func (b *QueryModulesBody) Fault() *soap.Fault { return b.Fault_ } 9693 9694func QueryModules(ctx context.Context, r soap.RoundTripper, req *types.QueryModules) (*types.QueryModulesResponse, error) { 9695 var reqBody, resBody QueryModulesBody 9696 9697 reqBody.Req = req 9698 9699 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9700 return nil, err 9701 } 9702 9703 return resBody.Res, nil 9704} 9705 9706type QueryMonitoredEntitiesBody struct { 9707 Req *types.QueryMonitoredEntities `xml:"urn:vim25 QueryMonitoredEntities,omitempty"` 9708 Res *types.QueryMonitoredEntitiesResponse `xml:"urn:vim25 QueryMonitoredEntitiesResponse,omitempty"` 9709 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9710} 9711 9712func (b *QueryMonitoredEntitiesBody) Fault() *soap.Fault { return b.Fault_ } 9713 9714func QueryMonitoredEntities(ctx context.Context, r soap.RoundTripper, req *types.QueryMonitoredEntities) (*types.QueryMonitoredEntitiesResponse, error) { 9715 var reqBody, resBody QueryMonitoredEntitiesBody 9716 9717 reqBody.Req = req 9718 9719 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9720 return nil, err 9721 } 9722 9723 return resBody.Res, nil 9724} 9725 9726type QueryNFSUserBody struct { 9727 Req *types.QueryNFSUser `xml:"urn:vim25 QueryNFSUser,omitempty"` 9728 Res *types.QueryNFSUserResponse `xml:"urn:vim25 QueryNFSUserResponse,omitempty"` 9729 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9730} 9731 9732func (b *QueryNFSUserBody) Fault() *soap.Fault { return b.Fault_ } 9733 9734func QueryNFSUser(ctx context.Context, r soap.RoundTripper, req *types.QueryNFSUser) (*types.QueryNFSUserResponse, error) { 9735 var reqBody, resBody QueryNFSUserBody 9736 9737 reqBody.Req = req 9738 9739 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9740 return nil, err 9741 } 9742 9743 return resBody.Res, nil 9744} 9745 9746type QueryNetConfigBody struct { 9747 Req *types.QueryNetConfig `xml:"urn:vim25 QueryNetConfig,omitempty"` 9748 Res *types.QueryNetConfigResponse `xml:"urn:vim25 QueryNetConfigResponse,omitempty"` 9749 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9750} 9751 9752func (b *QueryNetConfigBody) Fault() *soap.Fault { return b.Fault_ } 9753 9754func QueryNetConfig(ctx context.Context, r soap.RoundTripper, req *types.QueryNetConfig) (*types.QueryNetConfigResponse, error) { 9755 var reqBody, resBody QueryNetConfigBody 9756 9757 reqBody.Req = req 9758 9759 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9760 return nil, err 9761 } 9762 9763 return resBody.Res, nil 9764} 9765 9766type QueryNetworkHintBody struct { 9767 Req *types.QueryNetworkHint `xml:"urn:vim25 QueryNetworkHint,omitempty"` 9768 Res *types.QueryNetworkHintResponse `xml:"urn:vim25 QueryNetworkHintResponse,omitempty"` 9769 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9770} 9771 9772func (b *QueryNetworkHintBody) Fault() *soap.Fault { return b.Fault_ } 9773 9774func QueryNetworkHint(ctx context.Context, r soap.RoundTripper, req *types.QueryNetworkHint) (*types.QueryNetworkHintResponse, error) { 9775 var reqBody, resBody QueryNetworkHintBody 9776 9777 reqBody.Req = req 9778 9779 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9780 return nil, err 9781 } 9782 9783 return resBody.Res, nil 9784} 9785 9786type QueryObjectsOnPhysicalVsanDiskBody struct { 9787 Req *types.QueryObjectsOnPhysicalVsanDisk `xml:"urn:vim25 QueryObjectsOnPhysicalVsanDisk,omitempty"` 9788 Res *types.QueryObjectsOnPhysicalVsanDiskResponse `xml:"urn:vim25 QueryObjectsOnPhysicalVsanDiskResponse,omitempty"` 9789 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9790} 9791 9792func (b *QueryObjectsOnPhysicalVsanDiskBody) Fault() *soap.Fault { return b.Fault_ } 9793 9794func QueryObjectsOnPhysicalVsanDisk(ctx context.Context, r soap.RoundTripper, req *types.QueryObjectsOnPhysicalVsanDisk) (*types.QueryObjectsOnPhysicalVsanDiskResponse, error) { 9795 var reqBody, resBody QueryObjectsOnPhysicalVsanDiskBody 9796 9797 reqBody.Req = req 9798 9799 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9800 return nil, err 9801 } 9802 9803 return resBody.Res, nil 9804} 9805 9806type QueryOptionsBody struct { 9807 Req *types.QueryOptions `xml:"urn:vim25 QueryOptions,omitempty"` 9808 Res *types.QueryOptionsResponse `xml:"urn:vim25 QueryOptionsResponse,omitempty"` 9809 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9810} 9811 9812func (b *QueryOptionsBody) Fault() *soap.Fault { return b.Fault_ } 9813 9814func QueryOptions(ctx context.Context, r soap.RoundTripper, req *types.QueryOptions) (*types.QueryOptionsResponse, error) { 9815 var reqBody, resBody QueryOptionsBody 9816 9817 reqBody.Req = req 9818 9819 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9820 return nil, err 9821 } 9822 9823 return resBody.Res, nil 9824} 9825 9826type QueryPartitionCreateDescBody struct { 9827 Req *types.QueryPartitionCreateDesc `xml:"urn:vim25 QueryPartitionCreateDesc,omitempty"` 9828 Res *types.QueryPartitionCreateDescResponse `xml:"urn:vim25 QueryPartitionCreateDescResponse,omitempty"` 9829 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9830} 9831 9832func (b *QueryPartitionCreateDescBody) Fault() *soap.Fault { return b.Fault_ } 9833 9834func QueryPartitionCreateDesc(ctx context.Context, r soap.RoundTripper, req *types.QueryPartitionCreateDesc) (*types.QueryPartitionCreateDescResponse, error) { 9835 var reqBody, resBody QueryPartitionCreateDescBody 9836 9837 reqBody.Req = req 9838 9839 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9840 return nil, err 9841 } 9842 9843 return resBody.Res, nil 9844} 9845 9846type QueryPartitionCreateOptionsBody struct { 9847 Req *types.QueryPartitionCreateOptions `xml:"urn:vim25 QueryPartitionCreateOptions,omitempty"` 9848 Res *types.QueryPartitionCreateOptionsResponse `xml:"urn:vim25 QueryPartitionCreateOptionsResponse,omitempty"` 9849 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9850} 9851 9852func (b *QueryPartitionCreateOptionsBody) Fault() *soap.Fault { return b.Fault_ } 9853 9854func QueryPartitionCreateOptions(ctx context.Context, r soap.RoundTripper, req *types.QueryPartitionCreateOptions) (*types.QueryPartitionCreateOptionsResponse, error) { 9855 var reqBody, resBody QueryPartitionCreateOptionsBody 9856 9857 reqBody.Req = req 9858 9859 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9860 return nil, err 9861 } 9862 9863 return resBody.Res, nil 9864} 9865 9866type QueryPathSelectionPolicyOptionsBody struct { 9867 Req *types.QueryPathSelectionPolicyOptions `xml:"urn:vim25 QueryPathSelectionPolicyOptions,omitempty"` 9868 Res *types.QueryPathSelectionPolicyOptionsResponse `xml:"urn:vim25 QueryPathSelectionPolicyOptionsResponse,omitempty"` 9869 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9870} 9871 9872func (b *QueryPathSelectionPolicyOptionsBody) Fault() *soap.Fault { return b.Fault_ } 9873 9874func QueryPathSelectionPolicyOptions(ctx context.Context, r soap.RoundTripper, req *types.QueryPathSelectionPolicyOptions) (*types.QueryPathSelectionPolicyOptionsResponse, error) { 9875 var reqBody, resBody QueryPathSelectionPolicyOptionsBody 9876 9877 reqBody.Req = req 9878 9879 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9880 return nil, err 9881 } 9882 9883 return resBody.Res, nil 9884} 9885 9886type QueryPerfBody struct { 9887 Req *types.QueryPerf `xml:"urn:vim25 QueryPerf,omitempty"` 9888 Res *types.QueryPerfResponse `xml:"urn:vim25 QueryPerfResponse,omitempty"` 9889 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9890} 9891 9892func (b *QueryPerfBody) Fault() *soap.Fault { return b.Fault_ } 9893 9894func QueryPerf(ctx context.Context, r soap.RoundTripper, req *types.QueryPerf) (*types.QueryPerfResponse, error) { 9895 var reqBody, resBody QueryPerfBody 9896 9897 reqBody.Req = req 9898 9899 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9900 return nil, err 9901 } 9902 9903 return resBody.Res, nil 9904} 9905 9906type QueryPerfCompositeBody struct { 9907 Req *types.QueryPerfComposite `xml:"urn:vim25 QueryPerfComposite,omitempty"` 9908 Res *types.QueryPerfCompositeResponse `xml:"urn:vim25 QueryPerfCompositeResponse,omitempty"` 9909 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9910} 9911 9912func (b *QueryPerfCompositeBody) Fault() *soap.Fault { return b.Fault_ } 9913 9914func QueryPerfComposite(ctx context.Context, r soap.RoundTripper, req *types.QueryPerfComposite) (*types.QueryPerfCompositeResponse, error) { 9915 var reqBody, resBody QueryPerfCompositeBody 9916 9917 reqBody.Req = req 9918 9919 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9920 return nil, err 9921 } 9922 9923 return resBody.Res, nil 9924} 9925 9926type QueryPerfCounterBody struct { 9927 Req *types.QueryPerfCounter `xml:"urn:vim25 QueryPerfCounter,omitempty"` 9928 Res *types.QueryPerfCounterResponse `xml:"urn:vim25 QueryPerfCounterResponse,omitempty"` 9929 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9930} 9931 9932func (b *QueryPerfCounterBody) Fault() *soap.Fault { return b.Fault_ } 9933 9934func QueryPerfCounter(ctx context.Context, r soap.RoundTripper, req *types.QueryPerfCounter) (*types.QueryPerfCounterResponse, error) { 9935 var reqBody, resBody QueryPerfCounterBody 9936 9937 reqBody.Req = req 9938 9939 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9940 return nil, err 9941 } 9942 9943 return resBody.Res, nil 9944} 9945 9946type QueryPerfCounterByLevelBody struct { 9947 Req *types.QueryPerfCounterByLevel `xml:"urn:vim25 QueryPerfCounterByLevel,omitempty"` 9948 Res *types.QueryPerfCounterByLevelResponse `xml:"urn:vim25 QueryPerfCounterByLevelResponse,omitempty"` 9949 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9950} 9951 9952func (b *QueryPerfCounterByLevelBody) Fault() *soap.Fault { return b.Fault_ } 9953 9954func QueryPerfCounterByLevel(ctx context.Context, r soap.RoundTripper, req *types.QueryPerfCounterByLevel) (*types.QueryPerfCounterByLevelResponse, error) { 9955 var reqBody, resBody QueryPerfCounterByLevelBody 9956 9957 reqBody.Req = req 9958 9959 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9960 return nil, err 9961 } 9962 9963 return resBody.Res, nil 9964} 9965 9966type QueryPerfProviderSummaryBody struct { 9967 Req *types.QueryPerfProviderSummary `xml:"urn:vim25 QueryPerfProviderSummary,omitempty"` 9968 Res *types.QueryPerfProviderSummaryResponse `xml:"urn:vim25 QueryPerfProviderSummaryResponse,omitempty"` 9969 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9970} 9971 9972func (b *QueryPerfProviderSummaryBody) Fault() *soap.Fault { return b.Fault_ } 9973 9974func QueryPerfProviderSummary(ctx context.Context, r soap.RoundTripper, req *types.QueryPerfProviderSummary) (*types.QueryPerfProviderSummaryResponse, error) { 9975 var reqBody, resBody QueryPerfProviderSummaryBody 9976 9977 reqBody.Req = req 9978 9979 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 9980 return nil, err 9981 } 9982 9983 return resBody.Res, nil 9984} 9985 9986type QueryPhysicalVsanDisksBody struct { 9987 Req *types.QueryPhysicalVsanDisks `xml:"urn:vim25 QueryPhysicalVsanDisks,omitempty"` 9988 Res *types.QueryPhysicalVsanDisksResponse `xml:"urn:vim25 QueryPhysicalVsanDisksResponse,omitempty"` 9989 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 9990} 9991 9992func (b *QueryPhysicalVsanDisksBody) Fault() *soap.Fault { return b.Fault_ } 9993 9994func QueryPhysicalVsanDisks(ctx context.Context, r soap.RoundTripper, req *types.QueryPhysicalVsanDisks) (*types.QueryPhysicalVsanDisksResponse, error) { 9995 var reqBody, resBody QueryPhysicalVsanDisksBody 9996 9997 reqBody.Req = req 9998 9999 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10000 return nil, err 10001 } 10002 10003 return resBody.Res, nil 10004} 10005 10006type QueryPnicStatusBody struct { 10007 Req *types.QueryPnicStatus `xml:"urn:vim25 QueryPnicStatus,omitempty"` 10008 Res *types.QueryPnicStatusResponse `xml:"urn:vim25 QueryPnicStatusResponse,omitempty"` 10009 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10010} 10011 10012func (b *QueryPnicStatusBody) Fault() *soap.Fault { return b.Fault_ } 10013 10014func QueryPnicStatus(ctx context.Context, r soap.RoundTripper, req *types.QueryPnicStatus) (*types.QueryPnicStatusResponse, error) { 10015 var reqBody, resBody QueryPnicStatusBody 10016 10017 reqBody.Req = req 10018 10019 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10020 return nil, err 10021 } 10022 10023 return resBody.Res, nil 10024} 10025 10026type QueryPolicyMetadataBody struct { 10027 Req *types.QueryPolicyMetadata `xml:"urn:vim25 QueryPolicyMetadata,omitempty"` 10028 Res *types.QueryPolicyMetadataResponse `xml:"urn:vim25 QueryPolicyMetadataResponse,omitempty"` 10029 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10030} 10031 10032func (b *QueryPolicyMetadataBody) Fault() *soap.Fault { return b.Fault_ } 10033 10034func QueryPolicyMetadata(ctx context.Context, r soap.RoundTripper, req *types.QueryPolicyMetadata) (*types.QueryPolicyMetadataResponse, error) { 10035 var reqBody, resBody QueryPolicyMetadataBody 10036 10037 reqBody.Req = req 10038 10039 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10040 return nil, err 10041 } 10042 10043 return resBody.Res, nil 10044} 10045 10046type QueryProfileStructureBody struct { 10047 Req *types.QueryProfileStructure `xml:"urn:vim25 QueryProfileStructure,omitempty"` 10048 Res *types.QueryProfileStructureResponse `xml:"urn:vim25 QueryProfileStructureResponse,omitempty"` 10049 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10050} 10051 10052func (b *QueryProfileStructureBody) Fault() *soap.Fault { return b.Fault_ } 10053 10054func QueryProfileStructure(ctx context.Context, r soap.RoundTripper, req *types.QueryProfileStructure) (*types.QueryProfileStructureResponse, error) { 10055 var reqBody, resBody QueryProfileStructureBody 10056 10057 reqBody.Req = req 10058 10059 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10060 return nil, err 10061 } 10062 10063 return resBody.Res, nil 10064} 10065 10066type QueryProviderListBody struct { 10067 Req *types.QueryProviderList `xml:"urn:vim25 QueryProviderList,omitempty"` 10068 Res *types.QueryProviderListResponse `xml:"urn:vim25 QueryProviderListResponse,omitempty"` 10069 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10070} 10071 10072func (b *QueryProviderListBody) Fault() *soap.Fault { return b.Fault_ } 10073 10074func QueryProviderList(ctx context.Context, r soap.RoundTripper, req *types.QueryProviderList) (*types.QueryProviderListResponse, error) { 10075 var reqBody, resBody QueryProviderListBody 10076 10077 reqBody.Req = req 10078 10079 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10080 return nil, err 10081 } 10082 10083 return resBody.Res, nil 10084} 10085 10086type QueryProviderNameBody struct { 10087 Req *types.QueryProviderName `xml:"urn:vim25 QueryProviderName,omitempty"` 10088 Res *types.QueryProviderNameResponse `xml:"urn:vim25 QueryProviderNameResponse,omitempty"` 10089 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10090} 10091 10092func (b *QueryProviderNameBody) Fault() *soap.Fault { return b.Fault_ } 10093 10094func QueryProviderName(ctx context.Context, r soap.RoundTripper, req *types.QueryProviderName) (*types.QueryProviderNameResponse, error) { 10095 var reqBody, resBody QueryProviderNameBody 10096 10097 reqBody.Req = req 10098 10099 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10100 return nil, err 10101 } 10102 10103 return resBody.Res, nil 10104} 10105 10106type QueryResourceConfigOptionBody struct { 10107 Req *types.QueryResourceConfigOption `xml:"urn:vim25 QueryResourceConfigOption,omitempty"` 10108 Res *types.QueryResourceConfigOptionResponse `xml:"urn:vim25 QueryResourceConfigOptionResponse,omitempty"` 10109 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10110} 10111 10112func (b *QueryResourceConfigOptionBody) Fault() *soap.Fault { return b.Fault_ } 10113 10114func QueryResourceConfigOption(ctx context.Context, r soap.RoundTripper, req *types.QueryResourceConfigOption) (*types.QueryResourceConfigOptionResponse, error) { 10115 var reqBody, resBody QueryResourceConfigOptionBody 10116 10117 reqBody.Req = req 10118 10119 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10120 return nil, err 10121 } 10122 10123 return resBody.Res, nil 10124} 10125 10126type QueryServiceListBody struct { 10127 Req *types.QueryServiceList `xml:"urn:vim25 QueryServiceList,omitempty"` 10128 Res *types.QueryServiceListResponse `xml:"urn:vim25 QueryServiceListResponse,omitempty"` 10129 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10130} 10131 10132func (b *QueryServiceListBody) Fault() *soap.Fault { return b.Fault_ } 10133 10134func QueryServiceList(ctx context.Context, r soap.RoundTripper, req *types.QueryServiceList) (*types.QueryServiceListResponse, error) { 10135 var reqBody, resBody QueryServiceListBody 10136 10137 reqBody.Req = req 10138 10139 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10140 return nil, err 10141 } 10142 10143 return resBody.Res, nil 10144} 10145 10146type QueryStorageArrayTypePolicyOptionsBody struct { 10147 Req *types.QueryStorageArrayTypePolicyOptions `xml:"urn:vim25 QueryStorageArrayTypePolicyOptions,omitempty"` 10148 Res *types.QueryStorageArrayTypePolicyOptionsResponse `xml:"urn:vim25 QueryStorageArrayTypePolicyOptionsResponse,omitempty"` 10149 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10150} 10151 10152func (b *QueryStorageArrayTypePolicyOptionsBody) Fault() *soap.Fault { return b.Fault_ } 10153 10154func QueryStorageArrayTypePolicyOptions(ctx context.Context, r soap.RoundTripper, req *types.QueryStorageArrayTypePolicyOptions) (*types.QueryStorageArrayTypePolicyOptionsResponse, error) { 10155 var reqBody, resBody QueryStorageArrayTypePolicyOptionsBody 10156 10157 reqBody.Req = req 10158 10159 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10160 return nil, err 10161 } 10162 10163 return resBody.Res, nil 10164} 10165 10166type QuerySupportedFeaturesBody struct { 10167 Req *types.QuerySupportedFeatures `xml:"urn:vim25 QuerySupportedFeatures,omitempty"` 10168 Res *types.QuerySupportedFeaturesResponse `xml:"urn:vim25 QuerySupportedFeaturesResponse,omitempty"` 10169 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10170} 10171 10172func (b *QuerySupportedFeaturesBody) Fault() *soap.Fault { return b.Fault_ } 10173 10174func QuerySupportedFeatures(ctx context.Context, r soap.RoundTripper, req *types.QuerySupportedFeatures) (*types.QuerySupportedFeaturesResponse, error) { 10175 var reqBody, resBody QuerySupportedFeaturesBody 10176 10177 reqBody.Req = req 10178 10179 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10180 return nil, err 10181 } 10182 10183 return resBody.Res, nil 10184} 10185 10186type QuerySyncingVsanObjectsBody struct { 10187 Req *types.QuerySyncingVsanObjects `xml:"urn:vim25 QuerySyncingVsanObjects,omitempty"` 10188 Res *types.QuerySyncingVsanObjectsResponse `xml:"urn:vim25 QuerySyncingVsanObjectsResponse,omitempty"` 10189 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10190} 10191 10192func (b *QuerySyncingVsanObjectsBody) Fault() *soap.Fault { return b.Fault_ } 10193 10194func QuerySyncingVsanObjects(ctx context.Context, r soap.RoundTripper, req *types.QuerySyncingVsanObjects) (*types.QuerySyncingVsanObjectsResponse, error) { 10195 var reqBody, resBody QuerySyncingVsanObjectsBody 10196 10197 reqBody.Req = req 10198 10199 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10200 return nil, err 10201 } 10202 10203 return resBody.Res, nil 10204} 10205 10206type QuerySystemUsersBody struct { 10207 Req *types.QuerySystemUsers `xml:"urn:vim25 QuerySystemUsers,omitempty"` 10208 Res *types.QuerySystemUsersResponse `xml:"urn:vim25 QuerySystemUsersResponse,omitempty"` 10209 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10210} 10211 10212func (b *QuerySystemUsersBody) Fault() *soap.Fault { return b.Fault_ } 10213 10214func QuerySystemUsers(ctx context.Context, r soap.RoundTripper, req *types.QuerySystemUsers) (*types.QuerySystemUsersResponse, error) { 10215 var reqBody, resBody QuerySystemUsersBody 10216 10217 reqBody.Req = req 10218 10219 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10220 return nil, err 10221 } 10222 10223 return resBody.Res, nil 10224} 10225 10226type QueryTargetCapabilitiesBody struct { 10227 Req *types.QueryTargetCapabilities `xml:"urn:vim25 QueryTargetCapabilities,omitempty"` 10228 Res *types.QueryTargetCapabilitiesResponse `xml:"urn:vim25 QueryTargetCapabilitiesResponse,omitempty"` 10229 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10230} 10231 10232func (b *QueryTargetCapabilitiesBody) Fault() *soap.Fault { return b.Fault_ } 10233 10234func QueryTargetCapabilities(ctx context.Context, r soap.RoundTripper, req *types.QueryTargetCapabilities) (*types.QueryTargetCapabilitiesResponse, error) { 10235 var reqBody, resBody QueryTargetCapabilitiesBody 10236 10237 reqBody.Req = req 10238 10239 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10240 return nil, err 10241 } 10242 10243 return resBody.Res, nil 10244} 10245 10246type QueryTpmAttestationReportBody struct { 10247 Req *types.QueryTpmAttestationReport `xml:"urn:vim25 QueryTpmAttestationReport,omitempty"` 10248 Res *types.QueryTpmAttestationReportResponse `xml:"urn:vim25 QueryTpmAttestationReportResponse,omitempty"` 10249 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10250} 10251 10252func (b *QueryTpmAttestationReportBody) Fault() *soap.Fault { return b.Fault_ } 10253 10254func QueryTpmAttestationReport(ctx context.Context, r soap.RoundTripper, req *types.QueryTpmAttestationReport) (*types.QueryTpmAttestationReportResponse, error) { 10255 var reqBody, resBody QueryTpmAttestationReportBody 10256 10257 reqBody.Req = req 10258 10259 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10260 return nil, err 10261 } 10262 10263 return resBody.Res, nil 10264} 10265 10266type QueryUnmonitoredHostsBody struct { 10267 Req *types.QueryUnmonitoredHosts `xml:"urn:vim25 QueryUnmonitoredHosts,omitempty"` 10268 Res *types.QueryUnmonitoredHostsResponse `xml:"urn:vim25 QueryUnmonitoredHostsResponse,omitempty"` 10269 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10270} 10271 10272func (b *QueryUnmonitoredHostsBody) Fault() *soap.Fault { return b.Fault_ } 10273 10274func QueryUnmonitoredHosts(ctx context.Context, r soap.RoundTripper, req *types.QueryUnmonitoredHosts) (*types.QueryUnmonitoredHostsResponse, error) { 10275 var reqBody, resBody QueryUnmonitoredHostsBody 10276 10277 reqBody.Req = req 10278 10279 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10280 return nil, err 10281 } 10282 10283 return resBody.Res, nil 10284} 10285 10286type QueryUnownedFilesBody struct { 10287 Req *types.QueryUnownedFiles `xml:"urn:vim25 QueryUnownedFiles,omitempty"` 10288 Res *types.QueryUnownedFilesResponse `xml:"urn:vim25 QueryUnownedFilesResponse,omitempty"` 10289 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10290} 10291 10292func (b *QueryUnownedFilesBody) Fault() *soap.Fault { return b.Fault_ } 10293 10294func QueryUnownedFiles(ctx context.Context, r soap.RoundTripper, req *types.QueryUnownedFiles) (*types.QueryUnownedFilesResponse, error) { 10295 var reqBody, resBody QueryUnownedFilesBody 10296 10297 reqBody.Req = req 10298 10299 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10300 return nil, err 10301 } 10302 10303 return resBody.Res, nil 10304} 10305 10306type QueryUnresolvedVmfsVolumeBody struct { 10307 Req *types.QueryUnresolvedVmfsVolume `xml:"urn:vim25 QueryUnresolvedVmfsVolume,omitempty"` 10308 Res *types.QueryUnresolvedVmfsVolumeResponse `xml:"urn:vim25 QueryUnresolvedVmfsVolumeResponse,omitempty"` 10309 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10310} 10311 10312func (b *QueryUnresolvedVmfsVolumeBody) Fault() *soap.Fault { return b.Fault_ } 10313 10314func QueryUnresolvedVmfsVolume(ctx context.Context, r soap.RoundTripper, req *types.QueryUnresolvedVmfsVolume) (*types.QueryUnresolvedVmfsVolumeResponse, error) { 10315 var reqBody, resBody QueryUnresolvedVmfsVolumeBody 10316 10317 reqBody.Req = req 10318 10319 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10320 return nil, err 10321 } 10322 10323 return resBody.Res, nil 10324} 10325 10326type QueryUnresolvedVmfsVolumesBody struct { 10327 Req *types.QueryUnresolvedVmfsVolumes `xml:"urn:vim25 QueryUnresolvedVmfsVolumes,omitempty"` 10328 Res *types.QueryUnresolvedVmfsVolumesResponse `xml:"urn:vim25 QueryUnresolvedVmfsVolumesResponse,omitempty"` 10329 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10330} 10331 10332func (b *QueryUnresolvedVmfsVolumesBody) Fault() *soap.Fault { return b.Fault_ } 10333 10334func QueryUnresolvedVmfsVolumes(ctx context.Context, r soap.RoundTripper, req *types.QueryUnresolvedVmfsVolumes) (*types.QueryUnresolvedVmfsVolumesResponse, error) { 10335 var reqBody, resBody QueryUnresolvedVmfsVolumesBody 10336 10337 reqBody.Req = req 10338 10339 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10340 return nil, err 10341 } 10342 10343 return resBody.Res, nil 10344} 10345 10346type QueryUsedVlanIdInDvsBody struct { 10347 Req *types.QueryUsedVlanIdInDvs `xml:"urn:vim25 QueryUsedVlanIdInDvs,omitempty"` 10348 Res *types.QueryUsedVlanIdInDvsResponse `xml:"urn:vim25 QueryUsedVlanIdInDvsResponse,omitempty"` 10349 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10350} 10351 10352func (b *QueryUsedVlanIdInDvsBody) Fault() *soap.Fault { return b.Fault_ } 10353 10354func QueryUsedVlanIdInDvs(ctx context.Context, r soap.RoundTripper, req *types.QueryUsedVlanIdInDvs) (*types.QueryUsedVlanIdInDvsResponse, error) { 10355 var reqBody, resBody QueryUsedVlanIdInDvsBody 10356 10357 reqBody.Req = req 10358 10359 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10360 return nil, err 10361 } 10362 10363 return resBody.Res, nil 10364} 10365 10366type QueryVMotionCompatibilityBody struct { 10367 Req *types.QueryVMotionCompatibility `xml:"urn:vim25 QueryVMotionCompatibility,omitempty"` 10368 Res *types.QueryVMotionCompatibilityResponse `xml:"urn:vim25 QueryVMotionCompatibilityResponse,omitempty"` 10369 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10370} 10371 10372func (b *QueryVMotionCompatibilityBody) Fault() *soap.Fault { return b.Fault_ } 10373 10374func QueryVMotionCompatibility(ctx context.Context, r soap.RoundTripper, req *types.QueryVMotionCompatibility) (*types.QueryVMotionCompatibilityResponse, error) { 10375 var reqBody, resBody QueryVMotionCompatibilityBody 10376 10377 reqBody.Req = req 10378 10379 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10380 return nil, err 10381 } 10382 10383 return resBody.Res, nil 10384} 10385 10386type QueryVMotionCompatibilityEx_TaskBody struct { 10387 Req *types.QueryVMotionCompatibilityEx_Task `xml:"urn:vim25 QueryVMotionCompatibilityEx_Task,omitempty"` 10388 Res *types.QueryVMotionCompatibilityEx_TaskResponse `xml:"urn:vim25 QueryVMotionCompatibilityEx_TaskResponse,omitempty"` 10389 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10390} 10391 10392func (b *QueryVMotionCompatibilityEx_TaskBody) Fault() *soap.Fault { return b.Fault_ } 10393 10394func QueryVMotionCompatibilityEx_Task(ctx context.Context, r soap.RoundTripper, req *types.QueryVMotionCompatibilityEx_Task) (*types.QueryVMotionCompatibilityEx_TaskResponse, error) { 10395 var reqBody, resBody QueryVMotionCompatibilityEx_TaskBody 10396 10397 reqBody.Req = req 10398 10399 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10400 return nil, err 10401 } 10402 10403 return resBody.Res, nil 10404} 10405 10406type QueryVirtualDiskFragmentationBody struct { 10407 Req *types.QueryVirtualDiskFragmentation `xml:"urn:vim25 QueryVirtualDiskFragmentation,omitempty"` 10408 Res *types.QueryVirtualDiskFragmentationResponse `xml:"urn:vim25 QueryVirtualDiskFragmentationResponse,omitempty"` 10409 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10410} 10411 10412func (b *QueryVirtualDiskFragmentationBody) Fault() *soap.Fault { return b.Fault_ } 10413 10414func QueryVirtualDiskFragmentation(ctx context.Context, r soap.RoundTripper, req *types.QueryVirtualDiskFragmentation) (*types.QueryVirtualDiskFragmentationResponse, error) { 10415 var reqBody, resBody QueryVirtualDiskFragmentationBody 10416 10417 reqBody.Req = req 10418 10419 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10420 return nil, err 10421 } 10422 10423 return resBody.Res, nil 10424} 10425 10426type QueryVirtualDiskGeometryBody struct { 10427 Req *types.QueryVirtualDiskGeometry `xml:"urn:vim25 QueryVirtualDiskGeometry,omitempty"` 10428 Res *types.QueryVirtualDiskGeometryResponse `xml:"urn:vim25 QueryVirtualDiskGeometryResponse,omitempty"` 10429 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10430} 10431 10432func (b *QueryVirtualDiskGeometryBody) Fault() *soap.Fault { return b.Fault_ } 10433 10434func QueryVirtualDiskGeometry(ctx context.Context, r soap.RoundTripper, req *types.QueryVirtualDiskGeometry) (*types.QueryVirtualDiskGeometryResponse, error) { 10435 var reqBody, resBody QueryVirtualDiskGeometryBody 10436 10437 reqBody.Req = req 10438 10439 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10440 return nil, err 10441 } 10442 10443 return resBody.Res, nil 10444} 10445 10446type QueryVirtualDiskUuidBody struct { 10447 Req *types.QueryVirtualDiskUuid `xml:"urn:vim25 QueryVirtualDiskUuid,omitempty"` 10448 Res *types.QueryVirtualDiskUuidResponse `xml:"urn:vim25 QueryVirtualDiskUuidResponse,omitempty"` 10449 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10450} 10451 10452func (b *QueryVirtualDiskUuidBody) Fault() *soap.Fault { return b.Fault_ } 10453 10454func QueryVirtualDiskUuid(ctx context.Context, r soap.RoundTripper, req *types.QueryVirtualDiskUuid) (*types.QueryVirtualDiskUuidResponse, error) { 10455 var reqBody, resBody QueryVirtualDiskUuidBody 10456 10457 reqBody.Req = req 10458 10459 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10460 return nil, err 10461 } 10462 10463 return resBody.Res, nil 10464} 10465 10466type QueryVmfsConfigOptionBody struct { 10467 Req *types.QueryVmfsConfigOption `xml:"urn:vim25 QueryVmfsConfigOption,omitempty"` 10468 Res *types.QueryVmfsConfigOptionResponse `xml:"urn:vim25 QueryVmfsConfigOptionResponse,omitempty"` 10469 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10470} 10471 10472func (b *QueryVmfsConfigOptionBody) Fault() *soap.Fault { return b.Fault_ } 10473 10474func QueryVmfsConfigOption(ctx context.Context, r soap.RoundTripper, req *types.QueryVmfsConfigOption) (*types.QueryVmfsConfigOptionResponse, error) { 10475 var reqBody, resBody QueryVmfsConfigOptionBody 10476 10477 reqBody.Req = req 10478 10479 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10480 return nil, err 10481 } 10482 10483 return resBody.Res, nil 10484} 10485 10486type QueryVmfsDatastoreCreateOptionsBody struct { 10487 Req *types.QueryVmfsDatastoreCreateOptions `xml:"urn:vim25 QueryVmfsDatastoreCreateOptions,omitempty"` 10488 Res *types.QueryVmfsDatastoreCreateOptionsResponse `xml:"urn:vim25 QueryVmfsDatastoreCreateOptionsResponse,omitempty"` 10489 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10490} 10491 10492func (b *QueryVmfsDatastoreCreateOptionsBody) Fault() *soap.Fault { return b.Fault_ } 10493 10494func QueryVmfsDatastoreCreateOptions(ctx context.Context, r soap.RoundTripper, req *types.QueryVmfsDatastoreCreateOptions) (*types.QueryVmfsDatastoreCreateOptionsResponse, error) { 10495 var reqBody, resBody QueryVmfsDatastoreCreateOptionsBody 10496 10497 reqBody.Req = req 10498 10499 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10500 return nil, err 10501 } 10502 10503 return resBody.Res, nil 10504} 10505 10506type QueryVmfsDatastoreExpandOptionsBody struct { 10507 Req *types.QueryVmfsDatastoreExpandOptions `xml:"urn:vim25 QueryVmfsDatastoreExpandOptions,omitempty"` 10508 Res *types.QueryVmfsDatastoreExpandOptionsResponse `xml:"urn:vim25 QueryVmfsDatastoreExpandOptionsResponse,omitempty"` 10509 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10510} 10511 10512func (b *QueryVmfsDatastoreExpandOptionsBody) Fault() *soap.Fault { return b.Fault_ } 10513 10514func QueryVmfsDatastoreExpandOptions(ctx context.Context, r soap.RoundTripper, req *types.QueryVmfsDatastoreExpandOptions) (*types.QueryVmfsDatastoreExpandOptionsResponse, error) { 10515 var reqBody, resBody QueryVmfsDatastoreExpandOptionsBody 10516 10517 reqBody.Req = req 10518 10519 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10520 return nil, err 10521 } 10522 10523 return resBody.Res, nil 10524} 10525 10526type QueryVmfsDatastoreExtendOptionsBody struct { 10527 Req *types.QueryVmfsDatastoreExtendOptions `xml:"urn:vim25 QueryVmfsDatastoreExtendOptions,omitempty"` 10528 Res *types.QueryVmfsDatastoreExtendOptionsResponse `xml:"urn:vim25 QueryVmfsDatastoreExtendOptionsResponse,omitempty"` 10529 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10530} 10531 10532func (b *QueryVmfsDatastoreExtendOptionsBody) Fault() *soap.Fault { return b.Fault_ } 10533 10534func QueryVmfsDatastoreExtendOptions(ctx context.Context, r soap.RoundTripper, req *types.QueryVmfsDatastoreExtendOptions) (*types.QueryVmfsDatastoreExtendOptionsResponse, error) { 10535 var reqBody, resBody QueryVmfsDatastoreExtendOptionsBody 10536 10537 reqBody.Req = req 10538 10539 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10540 return nil, err 10541 } 10542 10543 return resBody.Res, nil 10544} 10545 10546type QueryVnicStatusBody struct { 10547 Req *types.QueryVnicStatus `xml:"urn:vim25 QueryVnicStatus,omitempty"` 10548 Res *types.QueryVnicStatusResponse `xml:"urn:vim25 QueryVnicStatusResponse,omitempty"` 10549 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10550} 10551 10552func (b *QueryVnicStatusBody) Fault() *soap.Fault { return b.Fault_ } 10553 10554func QueryVnicStatus(ctx context.Context, r soap.RoundTripper, req *types.QueryVnicStatus) (*types.QueryVnicStatusResponse, error) { 10555 var reqBody, resBody QueryVnicStatusBody 10556 10557 reqBody.Req = req 10558 10559 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10560 return nil, err 10561 } 10562 10563 return resBody.Res, nil 10564} 10565 10566type QueryVsanObjectUuidsByFilterBody struct { 10567 Req *types.QueryVsanObjectUuidsByFilter `xml:"urn:vim25 QueryVsanObjectUuidsByFilter,omitempty"` 10568 Res *types.QueryVsanObjectUuidsByFilterResponse `xml:"urn:vim25 QueryVsanObjectUuidsByFilterResponse,omitempty"` 10569 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10570} 10571 10572func (b *QueryVsanObjectUuidsByFilterBody) Fault() *soap.Fault { return b.Fault_ } 10573 10574func QueryVsanObjectUuidsByFilter(ctx context.Context, r soap.RoundTripper, req *types.QueryVsanObjectUuidsByFilter) (*types.QueryVsanObjectUuidsByFilterResponse, error) { 10575 var reqBody, resBody QueryVsanObjectUuidsByFilterBody 10576 10577 reqBody.Req = req 10578 10579 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10580 return nil, err 10581 } 10582 10583 return resBody.Res, nil 10584} 10585 10586type QueryVsanObjectsBody struct { 10587 Req *types.QueryVsanObjects `xml:"urn:vim25 QueryVsanObjects,omitempty"` 10588 Res *types.QueryVsanObjectsResponse `xml:"urn:vim25 QueryVsanObjectsResponse,omitempty"` 10589 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10590} 10591 10592func (b *QueryVsanObjectsBody) Fault() *soap.Fault { return b.Fault_ } 10593 10594func QueryVsanObjects(ctx context.Context, r soap.RoundTripper, req *types.QueryVsanObjects) (*types.QueryVsanObjectsResponse, error) { 10595 var reqBody, resBody QueryVsanObjectsBody 10596 10597 reqBody.Req = req 10598 10599 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10600 return nil, err 10601 } 10602 10603 return resBody.Res, nil 10604} 10605 10606type QueryVsanStatisticsBody struct { 10607 Req *types.QueryVsanStatistics `xml:"urn:vim25 QueryVsanStatistics,omitempty"` 10608 Res *types.QueryVsanStatisticsResponse `xml:"urn:vim25 QueryVsanStatisticsResponse,omitempty"` 10609 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10610} 10611 10612func (b *QueryVsanStatisticsBody) Fault() *soap.Fault { return b.Fault_ } 10613 10614func QueryVsanStatistics(ctx context.Context, r soap.RoundTripper, req *types.QueryVsanStatistics) (*types.QueryVsanStatisticsResponse, error) { 10615 var reqBody, resBody QueryVsanStatisticsBody 10616 10617 reqBody.Req = req 10618 10619 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10620 return nil, err 10621 } 10622 10623 return resBody.Res, nil 10624} 10625 10626type QueryVsanUpgradeStatusBody struct { 10627 Req *types.QueryVsanUpgradeStatus `xml:"urn:vim25 QueryVsanUpgradeStatus,omitempty"` 10628 Res *types.QueryVsanUpgradeStatusResponse `xml:"urn:vim25 QueryVsanUpgradeStatusResponse,omitempty"` 10629 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10630} 10631 10632func (b *QueryVsanUpgradeStatusBody) Fault() *soap.Fault { return b.Fault_ } 10633 10634func QueryVsanUpgradeStatus(ctx context.Context, r soap.RoundTripper, req *types.QueryVsanUpgradeStatus) (*types.QueryVsanUpgradeStatusResponse, error) { 10635 var reqBody, resBody QueryVsanUpgradeStatusBody 10636 10637 reqBody.Req = req 10638 10639 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10640 return nil, err 10641 } 10642 10643 return resBody.Res, nil 10644} 10645 10646type ReadEnvironmentVariableInGuestBody struct { 10647 Req *types.ReadEnvironmentVariableInGuest `xml:"urn:vim25 ReadEnvironmentVariableInGuest,omitempty"` 10648 Res *types.ReadEnvironmentVariableInGuestResponse `xml:"urn:vim25 ReadEnvironmentVariableInGuestResponse,omitempty"` 10649 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10650} 10651 10652func (b *ReadEnvironmentVariableInGuestBody) Fault() *soap.Fault { return b.Fault_ } 10653 10654func ReadEnvironmentVariableInGuest(ctx context.Context, r soap.RoundTripper, req *types.ReadEnvironmentVariableInGuest) (*types.ReadEnvironmentVariableInGuestResponse, error) { 10655 var reqBody, resBody ReadEnvironmentVariableInGuestBody 10656 10657 reqBody.Req = req 10658 10659 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10660 return nil, err 10661 } 10662 10663 return resBody.Res, nil 10664} 10665 10666type ReadNextEventsBody struct { 10667 Req *types.ReadNextEvents `xml:"urn:vim25 ReadNextEvents,omitempty"` 10668 Res *types.ReadNextEventsResponse `xml:"urn:vim25 ReadNextEventsResponse,omitempty"` 10669 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10670} 10671 10672func (b *ReadNextEventsBody) Fault() *soap.Fault { return b.Fault_ } 10673 10674func ReadNextEvents(ctx context.Context, r soap.RoundTripper, req *types.ReadNextEvents) (*types.ReadNextEventsResponse, error) { 10675 var reqBody, resBody ReadNextEventsBody 10676 10677 reqBody.Req = req 10678 10679 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10680 return nil, err 10681 } 10682 10683 return resBody.Res, nil 10684} 10685 10686type ReadNextTasksBody struct { 10687 Req *types.ReadNextTasks `xml:"urn:vim25 ReadNextTasks,omitempty"` 10688 Res *types.ReadNextTasksResponse `xml:"urn:vim25 ReadNextTasksResponse,omitempty"` 10689 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10690} 10691 10692func (b *ReadNextTasksBody) Fault() *soap.Fault { return b.Fault_ } 10693 10694func ReadNextTasks(ctx context.Context, r soap.RoundTripper, req *types.ReadNextTasks) (*types.ReadNextTasksResponse, error) { 10695 var reqBody, resBody ReadNextTasksBody 10696 10697 reqBody.Req = req 10698 10699 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10700 return nil, err 10701 } 10702 10703 return resBody.Res, nil 10704} 10705 10706type ReadPreviousEventsBody struct { 10707 Req *types.ReadPreviousEvents `xml:"urn:vim25 ReadPreviousEvents,omitempty"` 10708 Res *types.ReadPreviousEventsResponse `xml:"urn:vim25 ReadPreviousEventsResponse,omitempty"` 10709 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10710} 10711 10712func (b *ReadPreviousEventsBody) Fault() *soap.Fault { return b.Fault_ } 10713 10714func ReadPreviousEvents(ctx context.Context, r soap.RoundTripper, req *types.ReadPreviousEvents) (*types.ReadPreviousEventsResponse, error) { 10715 var reqBody, resBody ReadPreviousEventsBody 10716 10717 reqBody.Req = req 10718 10719 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10720 return nil, err 10721 } 10722 10723 return resBody.Res, nil 10724} 10725 10726type ReadPreviousTasksBody struct { 10727 Req *types.ReadPreviousTasks `xml:"urn:vim25 ReadPreviousTasks,omitempty"` 10728 Res *types.ReadPreviousTasksResponse `xml:"urn:vim25 ReadPreviousTasksResponse,omitempty"` 10729 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10730} 10731 10732func (b *ReadPreviousTasksBody) Fault() *soap.Fault { return b.Fault_ } 10733 10734func ReadPreviousTasks(ctx context.Context, r soap.RoundTripper, req *types.ReadPreviousTasks) (*types.ReadPreviousTasksResponse, error) { 10735 var reqBody, resBody ReadPreviousTasksBody 10736 10737 reqBody.Req = req 10738 10739 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10740 return nil, err 10741 } 10742 10743 return resBody.Res, nil 10744} 10745 10746type RebootGuestBody struct { 10747 Req *types.RebootGuest `xml:"urn:vim25 RebootGuest,omitempty"` 10748 Res *types.RebootGuestResponse `xml:"urn:vim25 RebootGuestResponse,omitempty"` 10749 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10750} 10751 10752func (b *RebootGuestBody) Fault() *soap.Fault { return b.Fault_ } 10753 10754func RebootGuest(ctx context.Context, r soap.RoundTripper, req *types.RebootGuest) (*types.RebootGuestResponse, error) { 10755 var reqBody, resBody RebootGuestBody 10756 10757 reqBody.Req = req 10758 10759 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10760 return nil, err 10761 } 10762 10763 return resBody.Res, nil 10764} 10765 10766type RebootHost_TaskBody struct { 10767 Req *types.RebootHost_Task `xml:"urn:vim25 RebootHost_Task,omitempty"` 10768 Res *types.RebootHost_TaskResponse `xml:"urn:vim25 RebootHost_TaskResponse,omitempty"` 10769 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10770} 10771 10772func (b *RebootHost_TaskBody) Fault() *soap.Fault { return b.Fault_ } 10773 10774func RebootHost_Task(ctx context.Context, r soap.RoundTripper, req *types.RebootHost_Task) (*types.RebootHost_TaskResponse, error) { 10775 var reqBody, resBody RebootHost_TaskBody 10776 10777 reqBody.Req = req 10778 10779 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10780 return nil, err 10781 } 10782 10783 return resBody.Res, nil 10784} 10785 10786type RecommendDatastoresBody struct { 10787 Req *types.RecommendDatastores `xml:"urn:vim25 RecommendDatastores,omitempty"` 10788 Res *types.RecommendDatastoresResponse `xml:"urn:vim25 RecommendDatastoresResponse,omitempty"` 10789 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10790} 10791 10792func (b *RecommendDatastoresBody) Fault() *soap.Fault { return b.Fault_ } 10793 10794func RecommendDatastores(ctx context.Context, r soap.RoundTripper, req *types.RecommendDatastores) (*types.RecommendDatastoresResponse, error) { 10795 var reqBody, resBody RecommendDatastoresBody 10796 10797 reqBody.Req = req 10798 10799 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10800 return nil, err 10801 } 10802 10803 return resBody.Res, nil 10804} 10805 10806type RecommendHostsForVmBody struct { 10807 Req *types.RecommendHostsForVm `xml:"urn:vim25 RecommendHostsForVm,omitempty"` 10808 Res *types.RecommendHostsForVmResponse `xml:"urn:vim25 RecommendHostsForVmResponse,omitempty"` 10809 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10810} 10811 10812func (b *RecommendHostsForVmBody) Fault() *soap.Fault { return b.Fault_ } 10813 10814func RecommendHostsForVm(ctx context.Context, r soap.RoundTripper, req *types.RecommendHostsForVm) (*types.RecommendHostsForVmResponse, error) { 10815 var reqBody, resBody RecommendHostsForVmBody 10816 10817 reqBody.Req = req 10818 10819 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10820 return nil, err 10821 } 10822 10823 return resBody.Res, nil 10824} 10825 10826type RecommissionVsanNode_TaskBody struct { 10827 Req *types.RecommissionVsanNode_Task `xml:"urn:vim25 RecommissionVsanNode_Task,omitempty"` 10828 Res *types.RecommissionVsanNode_TaskResponse `xml:"urn:vim25 RecommissionVsanNode_TaskResponse,omitempty"` 10829 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10830} 10831 10832func (b *RecommissionVsanNode_TaskBody) Fault() *soap.Fault { return b.Fault_ } 10833 10834func RecommissionVsanNode_Task(ctx context.Context, r soap.RoundTripper, req *types.RecommissionVsanNode_Task) (*types.RecommissionVsanNode_TaskResponse, error) { 10835 var reqBody, resBody RecommissionVsanNode_TaskBody 10836 10837 reqBody.Req = req 10838 10839 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10840 return nil, err 10841 } 10842 10843 return resBody.Res, nil 10844} 10845 10846type ReconcileDatastoreInventory_TaskBody struct { 10847 Req *types.ReconcileDatastoreInventory_Task `xml:"urn:vim25 ReconcileDatastoreInventory_Task,omitempty"` 10848 Res *types.ReconcileDatastoreInventory_TaskResponse `xml:"urn:vim25 ReconcileDatastoreInventory_TaskResponse,omitempty"` 10849 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10850} 10851 10852func (b *ReconcileDatastoreInventory_TaskBody) Fault() *soap.Fault { return b.Fault_ } 10853 10854func ReconcileDatastoreInventory_Task(ctx context.Context, r soap.RoundTripper, req *types.ReconcileDatastoreInventory_Task) (*types.ReconcileDatastoreInventory_TaskResponse, error) { 10855 var reqBody, resBody ReconcileDatastoreInventory_TaskBody 10856 10857 reqBody.Req = req 10858 10859 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10860 return nil, err 10861 } 10862 10863 return resBody.Res, nil 10864} 10865 10866type ReconfigVM_TaskBody struct { 10867 Req *types.ReconfigVM_Task `xml:"urn:vim25 ReconfigVM_Task,omitempty"` 10868 Res *types.ReconfigVM_TaskResponse `xml:"urn:vim25 ReconfigVM_TaskResponse,omitempty"` 10869 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10870} 10871 10872func (b *ReconfigVM_TaskBody) Fault() *soap.Fault { return b.Fault_ } 10873 10874func ReconfigVM_Task(ctx context.Context, r soap.RoundTripper, req *types.ReconfigVM_Task) (*types.ReconfigVM_TaskResponse, error) { 10875 var reqBody, resBody ReconfigVM_TaskBody 10876 10877 reqBody.Req = req 10878 10879 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10880 return nil, err 10881 } 10882 10883 return resBody.Res, nil 10884} 10885 10886type ReconfigurationSatisfiableBody struct { 10887 Req *types.ReconfigurationSatisfiable `xml:"urn:vim25 ReconfigurationSatisfiable,omitempty"` 10888 Res *types.ReconfigurationSatisfiableResponse `xml:"urn:vim25 ReconfigurationSatisfiableResponse,omitempty"` 10889 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10890} 10891 10892func (b *ReconfigurationSatisfiableBody) Fault() *soap.Fault { return b.Fault_ } 10893 10894func ReconfigurationSatisfiable(ctx context.Context, r soap.RoundTripper, req *types.ReconfigurationSatisfiable) (*types.ReconfigurationSatisfiableResponse, error) { 10895 var reqBody, resBody ReconfigurationSatisfiableBody 10896 10897 reqBody.Req = req 10898 10899 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10900 return nil, err 10901 } 10902 10903 return resBody.Res, nil 10904} 10905 10906type ReconfigureAlarmBody struct { 10907 Req *types.ReconfigureAlarm `xml:"urn:vim25 ReconfigureAlarm,omitempty"` 10908 Res *types.ReconfigureAlarmResponse `xml:"urn:vim25 ReconfigureAlarmResponse,omitempty"` 10909 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10910} 10911 10912func (b *ReconfigureAlarmBody) Fault() *soap.Fault { return b.Fault_ } 10913 10914func ReconfigureAlarm(ctx context.Context, r soap.RoundTripper, req *types.ReconfigureAlarm) (*types.ReconfigureAlarmResponse, error) { 10915 var reqBody, resBody ReconfigureAlarmBody 10916 10917 reqBody.Req = req 10918 10919 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10920 return nil, err 10921 } 10922 10923 return resBody.Res, nil 10924} 10925 10926type ReconfigureAutostartBody struct { 10927 Req *types.ReconfigureAutostart `xml:"urn:vim25 ReconfigureAutostart,omitempty"` 10928 Res *types.ReconfigureAutostartResponse `xml:"urn:vim25 ReconfigureAutostartResponse,omitempty"` 10929 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10930} 10931 10932func (b *ReconfigureAutostartBody) Fault() *soap.Fault { return b.Fault_ } 10933 10934func ReconfigureAutostart(ctx context.Context, r soap.RoundTripper, req *types.ReconfigureAutostart) (*types.ReconfigureAutostartResponse, error) { 10935 var reqBody, resBody ReconfigureAutostartBody 10936 10937 reqBody.Req = req 10938 10939 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10940 return nil, err 10941 } 10942 10943 return resBody.Res, nil 10944} 10945 10946type ReconfigureCluster_TaskBody struct { 10947 Req *types.ReconfigureCluster_Task `xml:"urn:vim25 ReconfigureCluster_Task,omitempty"` 10948 Res *types.ReconfigureCluster_TaskResponse `xml:"urn:vim25 ReconfigureCluster_TaskResponse,omitempty"` 10949 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10950} 10951 10952func (b *ReconfigureCluster_TaskBody) Fault() *soap.Fault { return b.Fault_ } 10953 10954func ReconfigureCluster_Task(ctx context.Context, r soap.RoundTripper, req *types.ReconfigureCluster_Task) (*types.ReconfigureCluster_TaskResponse, error) { 10955 var reqBody, resBody ReconfigureCluster_TaskBody 10956 10957 reqBody.Req = req 10958 10959 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10960 return nil, err 10961 } 10962 10963 return resBody.Res, nil 10964} 10965 10966type ReconfigureComputeResource_TaskBody struct { 10967 Req *types.ReconfigureComputeResource_Task `xml:"urn:vim25 ReconfigureComputeResource_Task,omitempty"` 10968 Res *types.ReconfigureComputeResource_TaskResponse `xml:"urn:vim25 ReconfigureComputeResource_TaskResponse,omitempty"` 10969 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10970} 10971 10972func (b *ReconfigureComputeResource_TaskBody) Fault() *soap.Fault { return b.Fault_ } 10973 10974func ReconfigureComputeResource_Task(ctx context.Context, r soap.RoundTripper, req *types.ReconfigureComputeResource_Task) (*types.ReconfigureComputeResource_TaskResponse, error) { 10975 var reqBody, resBody ReconfigureComputeResource_TaskBody 10976 10977 reqBody.Req = req 10978 10979 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 10980 return nil, err 10981 } 10982 10983 return resBody.Res, nil 10984} 10985 10986type ReconfigureDVPort_TaskBody struct { 10987 Req *types.ReconfigureDVPort_Task `xml:"urn:vim25 ReconfigureDVPort_Task,omitempty"` 10988 Res *types.ReconfigureDVPort_TaskResponse `xml:"urn:vim25 ReconfigureDVPort_TaskResponse,omitempty"` 10989 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 10990} 10991 10992func (b *ReconfigureDVPort_TaskBody) Fault() *soap.Fault { return b.Fault_ } 10993 10994func ReconfigureDVPort_Task(ctx context.Context, r soap.RoundTripper, req *types.ReconfigureDVPort_Task) (*types.ReconfigureDVPort_TaskResponse, error) { 10995 var reqBody, resBody ReconfigureDVPort_TaskBody 10996 10997 reqBody.Req = req 10998 10999 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11000 return nil, err 11001 } 11002 11003 return resBody.Res, nil 11004} 11005 11006type ReconfigureDVPortgroup_TaskBody struct { 11007 Req *types.ReconfigureDVPortgroup_Task `xml:"urn:vim25 ReconfigureDVPortgroup_Task,omitempty"` 11008 Res *types.ReconfigureDVPortgroup_TaskResponse `xml:"urn:vim25 ReconfigureDVPortgroup_TaskResponse,omitempty"` 11009 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11010} 11011 11012func (b *ReconfigureDVPortgroup_TaskBody) Fault() *soap.Fault { return b.Fault_ } 11013 11014func ReconfigureDVPortgroup_Task(ctx context.Context, r soap.RoundTripper, req *types.ReconfigureDVPortgroup_Task) (*types.ReconfigureDVPortgroup_TaskResponse, error) { 11015 var reqBody, resBody ReconfigureDVPortgroup_TaskBody 11016 11017 reqBody.Req = req 11018 11019 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11020 return nil, err 11021 } 11022 11023 return resBody.Res, nil 11024} 11025 11026type ReconfigureDatacenter_TaskBody struct { 11027 Req *types.ReconfigureDatacenter_Task `xml:"urn:vim25 ReconfigureDatacenter_Task,omitempty"` 11028 Res *types.ReconfigureDatacenter_TaskResponse `xml:"urn:vim25 ReconfigureDatacenter_TaskResponse,omitempty"` 11029 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11030} 11031 11032func (b *ReconfigureDatacenter_TaskBody) Fault() *soap.Fault { return b.Fault_ } 11033 11034func ReconfigureDatacenter_Task(ctx context.Context, r soap.RoundTripper, req *types.ReconfigureDatacenter_Task) (*types.ReconfigureDatacenter_TaskResponse, error) { 11035 var reqBody, resBody ReconfigureDatacenter_TaskBody 11036 11037 reqBody.Req = req 11038 11039 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11040 return nil, err 11041 } 11042 11043 return resBody.Res, nil 11044} 11045 11046type ReconfigureDomObjectBody struct { 11047 Req *types.ReconfigureDomObject `xml:"urn:vim25 ReconfigureDomObject,omitempty"` 11048 Res *types.ReconfigureDomObjectResponse `xml:"urn:vim25 ReconfigureDomObjectResponse,omitempty"` 11049 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11050} 11051 11052func (b *ReconfigureDomObjectBody) Fault() *soap.Fault { return b.Fault_ } 11053 11054func ReconfigureDomObject(ctx context.Context, r soap.RoundTripper, req *types.ReconfigureDomObject) (*types.ReconfigureDomObjectResponse, error) { 11055 var reqBody, resBody ReconfigureDomObjectBody 11056 11057 reqBody.Req = req 11058 11059 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11060 return nil, err 11061 } 11062 11063 return resBody.Res, nil 11064} 11065 11066type ReconfigureDvs_TaskBody struct { 11067 Req *types.ReconfigureDvs_Task `xml:"urn:vim25 ReconfigureDvs_Task,omitempty"` 11068 Res *types.ReconfigureDvs_TaskResponse `xml:"urn:vim25 ReconfigureDvs_TaskResponse,omitempty"` 11069 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11070} 11071 11072func (b *ReconfigureDvs_TaskBody) Fault() *soap.Fault { return b.Fault_ } 11073 11074func ReconfigureDvs_Task(ctx context.Context, r soap.RoundTripper, req *types.ReconfigureDvs_Task) (*types.ReconfigureDvs_TaskResponse, error) { 11075 var reqBody, resBody ReconfigureDvs_TaskBody 11076 11077 reqBody.Req = req 11078 11079 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11080 return nil, err 11081 } 11082 11083 return resBody.Res, nil 11084} 11085 11086type ReconfigureHostForDAS_TaskBody struct { 11087 Req *types.ReconfigureHostForDAS_Task `xml:"urn:vim25 ReconfigureHostForDAS_Task,omitempty"` 11088 Res *types.ReconfigureHostForDAS_TaskResponse `xml:"urn:vim25 ReconfigureHostForDAS_TaskResponse,omitempty"` 11089 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11090} 11091 11092func (b *ReconfigureHostForDAS_TaskBody) Fault() *soap.Fault { return b.Fault_ } 11093 11094func ReconfigureHostForDAS_Task(ctx context.Context, r soap.RoundTripper, req *types.ReconfigureHostForDAS_Task) (*types.ReconfigureHostForDAS_TaskResponse, error) { 11095 var reqBody, resBody ReconfigureHostForDAS_TaskBody 11096 11097 reqBody.Req = req 11098 11099 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11100 return nil, err 11101 } 11102 11103 return resBody.Res, nil 11104} 11105 11106type ReconfigureScheduledTaskBody struct { 11107 Req *types.ReconfigureScheduledTask `xml:"urn:vim25 ReconfigureScheduledTask,omitempty"` 11108 Res *types.ReconfigureScheduledTaskResponse `xml:"urn:vim25 ReconfigureScheduledTaskResponse,omitempty"` 11109 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11110} 11111 11112func (b *ReconfigureScheduledTaskBody) Fault() *soap.Fault { return b.Fault_ } 11113 11114func ReconfigureScheduledTask(ctx context.Context, r soap.RoundTripper, req *types.ReconfigureScheduledTask) (*types.ReconfigureScheduledTaskResponse, error) { 11115 var reqBody, resBody ReconfigureScheduledTaskBody 11116 11117 reqBody.Req = req 11118 11119 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11120 return nil, err 11121 } 11122 11123 return resBody.Res, nil 11124} 11125 11126type ReconfigureServiceConsoleReservationBody struct { 11127 Req *types.ReconfigureServiceConsoleReservation `xml:"urn:vim25 ReconfigureServiceConsoleReservation,omitempty"` 11128 Res *types.ReconfigureServiceConsoleReservationResponse `xml:"urn:vim25 ReconfigureServiceConsoleReservationResponse,omitempty"` 11129 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11130} 11131 11132func (b *ReconfigureServiceConsoleReservationBody) Fault() *soap.Fault { return b.Fault_ } 11133 11134func ReconfigureServiceConsoleReservation(ctx context.Context, r soap.RoundTripper, req *types.ReconfigureServiceConsoleReservation) (*types.ReconfigureServiceConsoleReservationResponse, error) { 11135 var reqBody, resBody ReconfigureServiceConsoleReservationBody 11136 11137 reqBody.Req = req 11138 11139 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11140 return nil, err 11141 } 11142 11143 return resBody.Res, nil 11144} 11145 11146type ReconfigureSnmpAgentBody struct { 11147 Req *types.ReconfigureSnmpAgent `xml:"urn:vim25 ReconfigureSnmpAgent,omitempty"` 11148 Res *types.ReconfigureSnmpAgentResponse `xml:"urn:vim25 ReconfigureSnmpAgentResponse,omitempty"` 11149 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11150} 11151 11152func (b *ReconfigureSnmpAgentBody) Fault() *soap.Fault { return b.Fault_ } 11153 11154func ReconfigureSnmpAgent(ctx context.Context, r soap.RoundTripper, req *types.ReconfigureSnmpAgent) (*types.ReconfigureSnmpAgentResponse, error) { 11155 var reqBody, resBody ReconfigureSnmpAgentBody 11156 11157 reqBody.Req = req 11158 11159 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11160 return nil, err 11161 } 11162 11163 return resBody.Res, nil 11164} 11165 11166type ReconfigureVirtualMachineReservationBody struct { 11167 Req *types.ReconfigureVirtualMachineReservation `xml:"urn:vim25 ReconfigureVirtualMachineReservation,omitempty"` 11168 Res *types.ReconfigureVirtualMachineReservationResponse `xml:"urn:vim25 ReconfigureVirtualMachineReservationResponse,omitempty"` 11169 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11170} 11171 11172func (b *ReconfigureVirtualMachineReservationBody) Fault() *soap.Fault { return b.Fault_ } 11173 11174func ReconfigureVirtualMachineReservation(ctx context.Context, r soap.RoundTripper, req *types.ReconfigureVirtualMachineReservation) (*types.ReconfigureVirtualMachineReservationResponse, error) { 11175 var reqBody, resBody ReconfigureVirtualMachineReservationBody 11176 11177 reqBody.Req = req 11178 11179 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11180 return nil, err 11181 } 11182 11183 return resBody.Res, nil 11184} 11185 11186type ReconnectHost_TaskBody struct { 11187 Req *types.ReconnectHost_Task `xml:"urn:vim25 ReconnectHost_Task,omitempty"` 11188 Res *types.ReconnectHost_TaskResponse `xml:"urn:vim25 ReconnectHost_TaskResponse,omitempty"` 11189 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11190} 11191 11192func (b *ReconnectHost_TaskBody) Fault() *soap.Fault { return b.Fault_ } 11193 11194func ReconnectHost_Task(ctx context.Context, r soap.RoundTripper, req *types.ReconnectHost_Task) (*types.ReconnectHost_TaskResponse, error) { 11195 var reqBody, resBody ReconnectHost_TaskBody 11196 11197 reqBody.Req = req 11198 11199 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11200 return nil, err 11201 } 11202 11203 return resBody.Res, nil 11204} 11205 11206type RectifyDvsHost_TaskBody struct { 11207 Req *types.RectifyDvsHost_Task `xml:"urn:vim25 RectifyDvsHost_Task,omitempty"` 11208 Res *types.RectifyDvsHost_TaskResponse `xml:"urn:vim25 RectifyDvsHost_TaskResponse,omitempty"` 11209 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11210} 11211 11212func (b *RectifyDvsHost_TaskBody) Fault() *soap.Fault { return b.Fault_ } 11213 11214func RectifyDvsHost_Task(ctx context.Context, r soap.RoundTripper, req *types.RectifyDvsHost_Task) (*types.RectifyDvsHost_TaskResponse, error) { 11215 var reqBody, resBody RectifyDvsHost_TaskBody 11216 11217 reqBody.Req = req 11218 11219 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11220 return nil, err 11221 } 11222 11223 return resBody.Res, nil 11224} 11225 11226type RectifyDvsOnHost_TaskBody struct { 11227 Req *types.RectifyDvsOnHost_Task `xml:"urn:vim25 RectifyDvsOnHost_Task,omitempty"` 11228 Res *types.RectifyDvsOnHost_TaskResponse `xml:"urn:vim25 RectifyDvsOnHost_TaskResponse,omitempty"` 11229 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11230} 11231 11232func (b *RectifyDvsOnHost_TaskBody) Fault() *soap.Fault { return b.Fault_ } 11233 11234func RectifyDvsOnHost_Task(ctx context.Context, r soap.RoundTripper, req *types.RectifyDvsOnHost_Task) (*types.RectifyDvsOnHost_TaskResponse, error) { 11235 var reqBody, resBody RectifyDvsOnHost_TaskBody 11236 11237 reqBody.Req = req 11238 11239 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11240 return nil, err 11241 } 11242 11243 return resBody.Res, nil 11244} 11245 11246type RefreshBody struct { 11247 Req *types.Refresh `xml:"urn:vim25 Refresh,omitempty"` 11248 Res *types.RefreshResponse `xml:"urn:vim25 RefreshResponse,omitempty"` 11249 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11250} 11251 11252func (b *RefreshBody) Fault() *soap.Fault { return b.Fault_ } 11253 11254func Refresh(ctx context.Context, r soap.RoundTripper, req *types.Refresh) (*types.RefreshResponse, error) { 11255 var reqBody, resBody RefreshBody 11256 11257 reqBody.Req = req 11258 11259 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11260 return nil, err 11261 } 11262 11263 return resBody.Res, nil 11264} 11265 11266type RefreshDVPortStateBody struct { 11267 Req *types.RefreshDVPortState `xml:"urn:vim25 RefreshDVPortState,omitempty"` 11268 Res *types.RefreshDVPortStateResponse `xml:"urn:vim25 RefreshDVPortStateResponse,omitempty"` 11269 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11270} 11271 11272func (b *RefreshDVPortStateBody) Fault() *soap.Fault { return b.Fault_ } 11273 11274func RefreshDVPortState(ctx context.Context, r soap.RoundTripper, req *types.RefreshDVPortState) (*types.RefreshDVPortStateResponse, error) { 11275 var reqBody, resBody RefreshDVPortStateBody 11276 11277 reqBody.Req = req 11278 11279 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11280 return nil, err 11281 } 11282 11283 return resBody.Res, nil 11284} 11285 11286type RefreshDatastoreBody struct { 11287 Req *types.RefreshDatastore `xml:"urn:vim25 RefreshDatastore,omitempty"` 11288 Res *types.RefreshDatastoreResponse `xml:"urn:vim25 RefreshDatastoreResponse,omitempty"` 11289 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11290} 11291 11292func (b *RefreshDatastoreBody) Fault() *soap.Fault { return b.Fault_ } 11293 11294func RefreshDatastore(ctx context.Context, r soap.RoundTripper, req *types.RefreshDatastore) (*types.RefreshDatastoreResponse, error) { 11295 var reqBody, resBody RefreshDatastoreBody 11296 11297 reqBody.Req = req 11298 11299 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11300 return nil, err 11301 } 11302 11303 return resBody.Res, nil 11304} 11305 11306type RefreshDatastoreStorageInfoBody struct { 11307 Req *types.RefreshDatastoreStorageInfo `xml:"urn:vim25 RefreshDatastoreStorageInfo,omitempty"` 11308 Res *types.RefreshDatastoreStorageInfoResponse `xml:"urn:vim25 RefreshDatastoreStorageInfoResponse,omitempty"` 11309 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11310} 11311 11312func (b *RefreshDatastoreStorageInfoBody) Fault() *soap.Fault { return b.Fault_ } 11313 11314func RefreshDatastoreStorageInfo(ctx context.Context, r soap.RoundTripper, req *types.RefreshDatastoreStorageInfo) (*types.RefreshDatastoreStorageInfoResponse, error) { 11315 var reqBody, resBody RefreshDatastoreStorageInfoBody 11316 11317 reqBody.Req = req 11318 11319 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11320 return nil, err 11321 } 11322 11323 return resBody.Res, nil 11324} 11325 11326type RefreshDateTimeSystemBody struct { 11327 Req *types.RefreshDateTimeSystem `xml:"urn:vim25 RefreshDateTimeSystem,omitempty"` 11328 Res *types.RefreshDateTimeSystemResponse `xml:"urn:vim25 RefreshDateTimeSystemResponse,omitempty"` 11329 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11330} 11331 11332func (b *RefreshDateTimeSystemBody) Fault() *soap.Fault { return b.Fault_ } 11333 11334func RefreshDateTimeSystem(ctx context.Context, r soap.RoundTripper, req *types.RefreshDateTimeSystem) (*types.RefreshDateTimeSystemResponse, error) { 11335 var reqBody, resBody RefreshDateTimeSystemBody 11336 11337 reqBody.Req = req 11338 11339 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11340 return nil, err 11341 } 11342 11343 return resBody.Res, nil 11344} 11345 11346type RefreshFirewallBody struct { 11347 Req *types.RefreshFirewall `xml:"urn:vim25 RefreshFirewall,omitempty"` 11348 Res *types.RefreshFirewallResponse `xml:"urn:vim25 RefreshFirewallResponse,omitempty"` 11349 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11350} 11351 11352func (b *RefreshFirewallBody) Fault() *soap.Fault { return b.Fault_ } 11353 11354func RefreshFirewall(ctx context.Context, r soap.RoundTripper, req *types.RefreshFirewall) (*types.RefreshFirewallResponse, error) { 11355 var reqBody, resBody RefreshFirewallBody 11356 11357 reqBody.Req = req 11358 11359 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11360 return nil, err 11361 } 11362 11363 return resBody.Res, nil 11364} 11365 11366type RefreshGraphicsManagerBody struct { 11367 Req *types.RefreshGraphicsManager `xml:"urn:vim25 RefreshGraphicsManager,omitempty"` 11368 Res *types.RefreshGraphicsManagerResponse `xml:"urn:vim25 RefreshGraphicsManagerResponse,omitempty"` 11369 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11370} 11371 11372func (b *RefreshGraphicsManagerBody) Fault() *soap.Fault { return b.Fault_ } 11373 11374func RefreshGraphicsManager(ctx context.Context, r soap.RoundTripper, req *types.RefreshGraphicsManager) (*types.RefreshGraphicsManagerResponse, error) { 11375 var reqBody, resBody RefreshGraphicsManagerBody 11376 11377 reqBody.Req = req 11378 11379 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11380 return nil, err 11381 } 11382 11383 return resBody.Res, nil 11384} 11385 11386type RefreshHealthStatusSystemBody struct { 11387 Req *types.RefreshHealthStatusSystem `xml:"urn:vim25 RefreshHealthStatusSystem,omitempty"` 11388 Res *types.RefreshHealthStatusSystemResponse `xml:"urn:vim25 RefreshHealthStatusSystemResponse,omitempty"` 11389 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11390} 11391 11392func (b *RefreshHealthStatusSystemBody) Fault() *soap.Fault { return b.Fault_ } 11393 11394func RefreshHealthStatusSystem(ctx context.Context, r soap.RoundTripper, req *types.RefreshHealthStatusSystem) (*types.RefreshHealthStatusSystemResponse, error) { 11395 var reqBody, resBody RefreshHealthStatusSystemBody 11396 11397 reqBody.Req = req 11398 11399 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11400 return nil, err 11401 } 11402 11403 return resBody.Res, nil 11404} 11405 11406type RefreshNetworkSystemBody struct { 11407 Req *types.RefreshNetworkSystem `xml:"urn:vim25 RefreshNetworkSystem,omitempty"` 11408 Res *types.RefreshNetworkSystemResponse `xml:"urn:vim25 RefreshNetworkSystemResponse,omitempty"` 11409 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11410} 11411 11412func (b *RefreshNetworkSystemBody) Fault() *soap.Fault { return b.Fault_ } 11413 11414func RefreshNetworkSystem(ctx context.Context, r soap.RoundTripper, req *types.RefreshNetworkSystem) (*types.RefreshNetworkSystemResponse, error) { 11415 var reqBody, resBody RefreshNetworkSystemBody 11416 11417 reqBody.Req = req 11418 11419 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11420 return nil, err 11421 } 11422 11423 return resBody.Res, nil 11424} 11425 11426type RefreshRecommendationBody struct { 11427 Req *types.RefreshRecommendation `xml:"urn:vim25 RefreshRecommendation,omitempty"` 11428 Res *types.RefreshRecommendationResponse `xml:"urn:vim25 RefreshRecommendationResponse,omitempty"` 11429 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11430} 11431 11432func (b *RefreshRecommendationBody) Fault() *soap.Fault { return b.Fault_ } 11433 11434func RefreshRecommendation(ctx context.Context, r soap.RoundTripper, req *types.RefreshRecommendation) (*types.RefreshRecommendationResponse, error) { 11435 var reqBody, resBody RefreshRecommendationBody 11436 11437 reqBody.Req = req 11438 11439 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11440 return nil, err 11441 } 11442 11443 return resBody.Res, nil 11444} 11445 11446type RefreshRuntimeBody struct { 11447 Req *types.RefreshRuntime `xml:"urn:vim25 RefreshRuntime,omitempty"` 11448 Res *types.RefreshRuntimeResponse `xml:"urn:vim25 RefreshRuntimeResponse,omitempty"` 11449 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11450} 11451 11452func (b *RefreshRuntimeBody) Fault() *soap.Fault { return b.Fault_ } 11453 11454func RefreshRuntime(ctx context.Context, r soap.RoundTripper, req *types.RefreshRuntime) (*types.RefreshRuntimeResponse, error) { 11455 var reqBody, resBody RefreshRuntimeBody 11456 11457 reqBody.Req = req 11458 11459 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11460 return nil, err 11461 } 11462 11463 return resBody.Res, nil 11464} 11465 11466type RefreshServicesBody struct { 11467 Req *types.RefreshServices `xml:"urn:vim25 RefreshServices,omitempty"` 11468 Res *types.RefreshServicesResponse `xml:"urn:vim25 RefreshServicesResponse,omitempty"` 11469 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11470} 11471 11472func (b *RefreshServicesBody) Fault() *soap.Fault { return b.Fault_ } 11473 11474func RefreshServices(ctx context.Context, r soap.RoundTripper, req *types.RefreshServices) (*types.RefreshServicesResponse, error) { 11475 var reqBody, resBody RefreshServicesBody 11476 11477 reqBody.Req = req 11478 11479 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11480 return nil, err 11481 } 11482 11483 return resBody.Res, nil 11484} 11485 11486type RefreshStorageDrsRecommendationBody struct { 11487 Req *types.RefreshStorageDrsRecommendation `xml:"urn:vim25 RefreshStorageDrsRecommendation,omitempty"` 11488 Res *types.RefreshStorageDrsRecommendationResponse `xml:"urn:vim25 RefreshStorageDrsRecommendationResponse,omitempty"` 11489 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11490} 11491 11492func (b *RefreshStorageDrsRecommendationBody) Fault() *soap.Fault { return b.Fault_ } 11493 11494func RefreshStorageDrsRecommendation(ctx context.Context, r soap.RoundTripper, req *types.RefreshStorageDrsRecommendation) (*types.RefreshStorageDrsRecommendationResponse, error) { 11495 var reqBody, resBody RefreshStorageDrsRecommendationBody 11496 11497 reqBody.Req = req 11498 11499 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11500 return nil, err 11501 } 11502 11503 return resBody.Res, nil 11504} 11505 11506type RefreshStorageDrsRecommendationsForPod_TaskBody struct { 11507 Req *types.RefreshStorageDrsRecommendationsForPod_Task `xml:"urn:vim25 RefreshStorageDrsRecommendationsForPod_Task,omitempty"` 11508 Res *types.RefreshStorageDrsRecommendationsForPod_TaskResponse `xml:"urn:vim25 RefreshStorageDrsRecommendationsForPod_TaskResponse,omitempty"` 11509 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11510} 11511 11512func (b *RefreshStorageDrsRecommendationsForPod_TaskBody) Fault() *soap.Fault { return b.Fault_ } 11513 11514func RefreshStorageDrsRecommendationsForPod_Task(ctx context.Context, r soap.RoundTripper, req *types.RefreshStorageDrsRecommendationsForPod_Task) (*types.RefreshStorageDrsRecommendationsForPod_TaskResponse, error) { 11515 var reqBody, resBody RefreshStorageDrsRecommendationsForPod_TaskBody 11516 11517 reqBody.Req = req 11518 11519 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11520 return nil, err 11521 } 11522 11523 return resBody.Res, nil 11524} 11525 11526type RefreshStorageInfoBody struct { 11527 Req *types.RefreshStorageInfo `xml:"urn:vim25 RefreshStorageInfo,omitempty"` 11528 Res *types.RefreshStorageInfoResponse `xml:"urn:vim25 RefreshStorageInfoResponse,omitempty"` 11529 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11530} 11531 11532func (b *RefreshStorageInfoBody) Fault() *soap.Fault { return b.Fault_ } 11533 11534func RefreshStorageInfo(ctx context.Context, r soap.RoundTripper, req *types.RefreshStorageInfo) (*types.RefreshStorageInfoResponse, error) { 11535 var reqBody, resBody RefreshStorageInfoBody 11536 11537 reqBody.Req = req 11538 11539 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11540 return nil, err 11541 } 11542 11543 return resBody.Res, nil 11544} 11545 11546type RefreshStorageSystemBody struct { 11547 Req *types.RefreshStorageSystem `xml:"urn:vim25 RefreshStorageSystem,omitempty"` 11548 Res *types.RefreshStorageSystemResponse `xml:"urn:vim25 RefreshStorageSystemResponse,omitempty"` 11549 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11550} 11551 11552func (b *RefreshStorageSystemBody) Fault() *soap.Fault { return b.Fault_ } 11553 11554func RefreshStorageSystem(ctx context.Context, r soap.RoundTripper, req *types.RefreshStorageSystem) (*types.RefreshStorageSystemResponse, error) { 11555 var reqBody, resBody RefreshStorageSystemBody 11556 11557 reqBody.Req = req 11558 11559 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11560 return nil, err 11561 } 11562 11563 return resBody.Res, nil 11564} 11565 11566type RegisterChildVM_TaskBody struct { 11567 Req *types.RegisterChildVM_Task `xml:"urn:vim25 RegisterChildVM_Task,omitempty"` 11568 Res *types.RegisterChildVM_TaskResponse `xml:"urn:vim25 RegisterChildVM_TaskResponse,omitempty"` 11569 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11570} 11571 11572func (b *RegisterChildVM_TaskBody) Fault() *soap.Fault { return b.Fault_ } 11573 11574func RegisterChildVM_Task(ctx context.Context, r soap.RoundTripper, req *types.RegisterChildVM_Task) (*types.RegisterChildVM_TaskResponse, error) { 11575 var reqBody, resBody RegisterChildVM_TaskBody 11576 11577 reqBody.Req = req 11578 11579 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11580 return nil, err 11581 } 11582 11583 return resBody.Res, nil 11584} 11585 11586type RegisterDiskBody struct { 11587 Req *types.RegisterDisk `xml:"urn:vim25 RegisterDisk,omitempty"` 11588 Res *types.RegisterDiskResponse `xml:"urn:vim25 RegisterDiskResponse,omitempty"` 11589 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11590} 11591 11592func (b *RegisterDiskBody) Fault() *soap.Fault { return b.Fault_ } 11593 11594func RegisterDisk(ctx context.Context, r soap.RoundTripper, req *types.RegisterDisk) (*types.RegisterDiskResponse, error) { 11595 var reqBody, resBody RegisterDiskBody 11596 11597 reqBody.Req = req 11598 11599 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11600 return nil, err 11601 } 11602 11603 return resBody.Res, nil 11604} 11605 11606type RegisterExtensionBody struct { 11607 Req *types.RegisterExtension `xml:"urn:vim25 RegisterExtension,omitempty"` 11608 Res *types.RegisterExtensionResponse `xml:"urn:vim25 RegisterExtensionResponse,omitempty"` 11609 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11610} 11611 11612func (b *RegisterExtensionBody) Fault() *soap.Fault { return b.Fault_ } 11613 11614func RegisterExtension(ctx context.Context, r soap.RoundTripper, req *types.RegisterExtension) (*types.RegisterExtensionResponse, error) { 11615 var reqBody, resBody RegisterExtensionBody 11616 11617 reqBody.Req = req 11618 11619 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11620 return nil, err 11621 } 11622 11623 return resBody.Res, nil 11624} 11625 11626type RegisterHealthUpdateProviderBody struct { 11627 Req *types.RegisterHealthUpdateProvider `xml:"urn:vim25 RegisterHealthUpdateProvider,omitempty"` 11628 Res *types.RegisterHealthUpdateProviderResponse `xml:"urn:vim25 RegisterHealthUpdateProviderResponse,omitempty"` 11629 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11630} 11631 11632func (b *RegisterHealthUpdateProviderBody) Fault() *soap.Fault { return b.Fault_ } 11633 11634func RegisterHealthUpdateProvider(ctx context.Context, r soap.RoundTripper, req *types.RegisterHealthUpdateProvider) (*types.RegisterHealthUpdateProviderResponse, error) { 11635 var reqBody, resBody RegisterHealthUpdateProviderBody 11636 11637 reqBody.Req = req 11638 11639 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11640 return nil, err 11641 } 11642 11643 return resBody.Res, nil 11644} 11645 11646type RegisterKmipServerBody struct { 11647 Req *types.RegisterKmipServer `xml:"urn:vim25 RegisterKmipServer,omitempty"` 11648 Res *types.RegisterKmipServerResponse `xml:"urn:vim25 RegisterKmipServerResponse,omitempty"` 11649 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11650} 11651 11652func (b *RegisterKmipServerBody) Fault() *soap.Fault { return b.Fault_ } 11653 11654func RegisterKmipServer(ctx context.Context, r soap.RoundTripper, req *types.RegisterKmipServer) (*types.RegisterKmipServerResponse, error) { 11655 var reqBody, resBody RegisterKmipServerBody 11656 11657 reqBody.Req = req 11658 11659 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11660 return nil, err 11661 } 11662 11663 return resBody.Res, nil 11664} 11665 11666type RegisterVM_TaskBody struct { 11667 Req *types.RegisterVM_Task `xml:"urn:vim25 RegisterVM_Task,omitempty"` 11668 Res *types.RegisterVM_TaskResponse `xml:"urn:vim25 RegisterVM_TaskResponse,omitempty"` 11669 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11670} 11671 11672func (b *RegisterVM_TaskBody) Fault() *soap.Fault { return b.Fault_ } 11673 11674func RegisterVM_Task(ctx context.Context, r soap.RoundTripper, req *types.RegisterVM_Task) (*types.RegisterVM_TaskResponse, error) { 11675 var reqBody, resBody RegisterVM_TaskBody 11676 11677 reqBody.Req = req 11678 11679 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11680 return nil, err 11681 } 11682 11683 return resBody.Res, nil 11684} 11685 11686type ReleaseCredentialsInGuestBody struct { 11687 Req *types.ReleaseCredentialsInGuest `xml:"urn:vim25 ReleaseCredentialsInGuest,omitempty"` 11688 Res *types.ReleaseCredentialsInGuestResponse `xml:"urn:vim25 ReleaseCredentialsInGuestResponse,omitempty"` 11689 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11690} 11691 11692func (b *ReleaseCredentialsInGuestBody) Fault() *soap.Fault { return b.Fault_ } 11693 11694func ReleaseCredentialsInGuest(ctx context.Context, r soap.RoundTripper, req *types.ReleaseCredentialsInGuest) (*types.ReleaseCredentialsInGuestResponse, error) { 11695 var reqBody, resBody ReleaseCredentialsInGuestBody 11696 11697 reqBody.Req = req 11698 11699 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11700 return nil, err 11701 } 11702 11703 return resBody.Res, nil 11704} 11705 11706type ReleaseIpAllocationBody struct { 11707 Req *types.ReleaseIpAllocation `xml:"urn:vim25 ReleaseIpAllocation,omitempty"` 11708 Res *types.ReleaseIpAllocationResponse `xml:"urn:vim25 ReleaseIpAllocationResponse,omitempty"` 11709 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11710} 11711 11712func (b *ReleaseIpAllocationBody) Fault() *soap.Fault { return b.Fault_ } 11713 11714func ReleaseIpAllocation(ctx context.Context, r soap.RoundTripper, req *types.ReleaseIpAllocation) (*types.ReleaseIpAllocationResponse, error) { 11715 var reqBody, resBody ReleaseIpAllocationBody 11716 11717 reqBody.Req = req 11718 11719 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11720 return nil, err 11721 } 11722 11723 return resBody.Res, nil 11724} 11725 11726type ReleaseManagedSnapshotBody struct { 11727 Req *types.ReleaseManagedSnapshot `xml:"urn:vim25 ReleaseManagedSnapshot,omitempty"` 11728 Res *types.ReleaseManagedSnapshotResponse `xml:"urn:vim25 ReleaseManagedSnapshotResponse,omitempty"` 11729 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11730} 11731 11732func (b *ReleaseManagedSnapshotBody) Fault() *soap.Fault { return b.Fault_ } 11733 11734func ReleaseManagedSnapshot(ctx context.Context, r soap.RoundTripper, req *types.ReleaseManagedSnapshot) (*types.ReleaseManagedSnapshotResponse, error) { 11735 var reqBody, resBody ReleaseManagedSnapshotBody 11736 11737 reqBody.Req = req 11738 11739 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11740 return nil, err 11741 } 11742 11743 return resBody.Res, nil 11744} 11745 11746type ReloadBody struct { 11747 Req *types.Reload `xml:"urn:vim25 Reload,omitempty"` 11748 Res *types.ReloadResponse `xml:"urn:vim25 ReloadResponse,omitempty"` 11749 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11750} 11751 11752func (b *ReloadBody) Fault() *soap.Fault { return b.Fault_ } 11753 11754func Reload(ctx context.Context, r soap.RoundTripper, req *types.Reload) (*types.ReloadResponse, error) { 11755 var reqBody, resBody ReloadBody 11756 11757 reqBody.Req = req 11758 11759 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11760 return nil, err 11761 } 11762 11763 return resBody.Res, nil 11764} 11765 11766type RelocateVM_TaskBody struct { 11767 Req *types.RelocateVM_Task `xml:"urn:vim25 RelocateVM_Task,omitempty"` 11768 Res *types.RelocateVM_TaskResponse `xml:"urn:vim25 RelocateVM_TaskResponse,omitempty"` 11769 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11770} 11771 11772func (b *RelocateVM_TaskBody) Fault() *soap.Fault { return b.Fault_ } 11773 11774func RelocateVM_Task(ctx context.Context, r soap.RoundTripper, req *types.RelocateVM_Task) (*types.RelocateVM_TaskResponse, error) { 11775 var reqBody, resBody RelocateVM_TaskBody 11776 11777 reqBody.Req = req 11778 11779 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11780 return nil, err 11781 } 11782 11783 return resBody.Res, nil 11784} 11785 11786type RelocateVStorageObject_TaskBody struct { 11787 Req *types.RelocateVStorageObject_Task `xml:"urn:vim25 RelocateVStorageObject_Task,omitempty"` 11788 Res *types.RelocateVStorageObject_TaskResponse `xml:"urn:vim25 RelocateVStorageObject_TaskResponse,omitempty"` 11789 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11790} 11791 11792func (b *RelocateVStorageObject_TaskBody) Fault() *soap.Fault { return b.Fault_ } 11793 11794func RelocateVStorageObject_Task(ctx context.Context, r soap.RoundTripper, req *types.RelocateVStorageObject_Task) (*types.RelocateVStorageObject_TaskResponse, error) { 11795 var reqBody, resBody RelocateVStorageObject_TaskBody 11796 11797 reqBody.Req = req 11798 11799 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11800 return nil, err 11801 } 11802 11803 return resBody.Res, nil 11804} 11805 11806type RemoveAlarmBody struct { 11807 Req *types.RemoveAlarm `xml:"urn:vim25 RemoveAlarm,omitempty"` 11808 Res *types.RemoveAlarmResponse `xml:"urn:vim25 RemoveAlarmResponse,omitempty"` 11809 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11810} 11811 11812func (b *RemoveAlarmBody) Fault() *soap.Fault { return b.Fault_ } 11813 11814func RemoveAlarm(ctx context.Context, r soap.RoundTripper, req *types.RemoveAlarm) (*types.RemoveAlarmResponse, error) { 11815 var reqBody, resBody RemoveAlarmBody 11816 11817 reqBody.Req = req 11818 11819 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11820 return nil, err 11821 } 11822 11823 return resBody.Res, nil 11824} 11825 11826type RemoveAllSnapshots_TaskBody struct { 11827 Req *types.RemoveAllSnapshots_Task `xml:"urn:vim25 RemoveAllSnapshots_Task,omitempty"` 11828 Res *types.RemoveAllSnapshots_TaskResponse `xml:"urn:vim25 RemoveAllSnapshots_TaskResponse,omitempty"` 11829 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11830} 11831 11832func (b *RemoveAllSnapshots_TaskBody) Fault() *soap.Fault { return b.Fault_ } 11833 11834func RemoveAllSnapshots_Task(ctx context.Context, r soap.RoundTripper, req *types.RemoveAllSnapshots_Task) (*types.RemoveAllSnapshots_TaskResponse, error) { 11835 var reqBody, resBody RemoveAllSnapshots_TaskBody 11836 11837 reqBody.Req = req 11838 11839 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11840 return nil, err 11841 } 11842 11843 return resBody.Res, nil 11844} 11845 11846type RemoveAssignedLicenseBody struct { 11847 Req *types.RemoveAssignedLicense `xml:"urn:vim25 RemoveAssignedLicense,omitempty"` 11848 Res *types.RemoveAssignedLicenseResponse `xml:"urn:vim25 RemoveAssignedLicenseResponse,omitempty"` 11849 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11850} 11851 11852func (b *RemoveAssignedLicenseBody) Fault() *soap.Fault { return b.Fault_ } 11853 11854func RemoveAssignedLicense(ctx context.Context, r soap.RoundTripper, req *types.RemoveAssignedLicense) (*types.RemoveAssignedLicenseResponse, error) { 11855 var reqBody, resBody RemoveAssignedLicenseBody 11856 11857 reqBody.Req = req 11858 11859 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11860 return nil, err 11861 } 11862 11863 return resBody.Res, nil 11864} 11865 11866type RemoveAuthorizationRoleBody struct { 11867 Req *types.RemoveAuthorizationRole `xml:"urn:vim25 RemoveAuthorizationRole,omitempty"` 11868 Res *types.RemoveAuthorizationRoleResponse `xml:"urn:vim25 RemoveAuthorizationRoleResponse,omitempty"` 11869 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11870} 11871 11872func (b *RemoveAuthorizationRoleBody) Fault() *soap.Fault { return b.Fault_ } 11873 11874func RemoveAuthorizationRole(ctx context.Context, r soap.RoundTripper, req *types.RemoveAuthorizationRole) (*types.RemoveAuthorizationRoleResponse, error) { 11875 var reqBody, resBody RemoveAuthorizationRoleBody 11876 11877 reqBody.Req = req 11878 11879 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11880 return nil, err 11881 } 11882 11883 return resBody.Res, nil 11884} 11885 11886type RemoveCustomFieldDefBody struct { 11887 Req *types.RemoveCustomFieldDef `xml:"urn:vim25 RemoveCustomFieldDef,omitempty"` 11888 Res *types.RemoveCustomFieldDefResponse `xml:"urn:vim25 RemoveCustomFieldDefResponse,omitempty"` 11889 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11890} 11891 11892func (b *RemoveCustomFieldDefBody) Fault() *soap.Fault { return b.Fault_ } 11893 11894func RemoveCustomFieldDef(ctx context.Context, r soap.RoundTripper, req *types.RemoveCustomFieldDef) (*types.RemoveCustomFieldDefResponse, error) { 11895 var reqBody, resBody RemoveCustomFieldDefBody 11896 11897 reqBody.Req = req 11898 11899 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11900 return nil, err 11901 } 11902 11903 return resBody.Res, nil 11904} 11905 11906type RemoveDatastoreBody struct { 11907 Req *types.RemoveDatastore `xml:"urn:vim25 RemoveDatastore,omitempty"` 11908 Res *types.RemoveDatastoreResponse `xml:"urn:vim25 RemoveDatastoreResponse,omitempty"` 11909 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11910} 11911 11912func (b *RemoveDatastoreBody) Fault() *soap.Fault { return b.Fault_ } 11913 11914func RemoveDatastore(ctx context.Context, r soap.RoundTripper, req *types.RemoveDatastore) (*types.RemoveDatastoreResponse, error) { 11915 var reqBody, resBody RemoveDatastoreBody 11916 11917 reqBody.Req = req 11918 11919 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11920 return nil, err 11921 } 11922 11923 return resBody.Res, nil 11924} 11925 11926type RemoveDatastoreEx_TaskBody struct { 11927 Req *types.RemoveDatastoreEx_Task `xml:"urn:vim25 RemoveDatastoreEx_Task,omitempty"` 11928 Res *types.RemoveDatastoreEx_TaskResponse `xml:"urn:vim25 RemoveDatastoreEx_TaskResponse,omitempty"` 11929 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11930} 11931 11932func (b *RemoveDatastoreEx_TaskBody) Fault() *soap.Fault { return b.Fault_ } 11933 11934func RemoveDatastoreEx_Task(ctx context.Context, r soap.RoundTripper, req *types.RemoveDatastoreEx_Task) (*types.RemoveDatastoreEx_TaskResponse, error) { 11935 var reqBody, resBody RemoveDatastoreEx_TaskBody 11936 11937 reqBody.Req = req 11938 11939 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11940 return nil, err 11941 } 11942 11943 return resBody.Res, nil 11944} 11945 11946type RemoveDiskMapping_TaskBody struct { 11947 Req *types.RemoveDiskMapping_Task `xml:"urn:vim25 RemoveDiskMapping_Task,omitempty"` 11948 Res *types.RemoveDiskMapping_TaskResponse `xml:"urn:vim25 RemoveDiskMapping_TaskResponse,omitempty"` 11949 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11950} 11951 11952func (b *RemoveDiskMapping_TaskBody) Fault() *soap.Fault { return b.Fault_ } 11953 11954func RemoveDiskMapping_Task(ctx context.Context, r soap.RoundTripper, req *types.RemoveDiskMapping_Task) (*types.RemoveDiskMapping_TaskResponse, error) { 11955 var reqBody, resBody RemoveDiskMapping_TaskBody 11956 11957 reqBody.Req = req 11958 11959 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11960 return nil, err 11961 } 11962 11963 return resBody.Res, nil 11964} 11965 11966type RemoveDisk_TaskBody struct { 11967 Req *types.RemoveDisk_Task `xml:"urn:vim25 RemoveDisk_Task,omitempty"` 11968 Res *types.RemoveDisk_TaskResponse `xml:"urn:vim25 RemoveDisk_TaskResponse,omitempty"` 11969 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11970} 11971 11972func (b *RemoveDisk_TaskBody) Fault() *soap.Fault { return b.Fault_ } 11973 11974func RemoveDisk_Task(ctx context.Context, r soap.RoundTripper, req *types.RemoveDisk_Task) (*types.RemoveDisk_TaskResponse, error) { 11975 var reqBody, resBody RemoveDisk_TaskBody 11976 11977 reqBody.Req = req 11978 11979 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 11980 return nil, err 11981 } 11982 11983 return resBody.Res, nil 11984} 11985 11986type RemoveEntityPermissionBody struct { 11987 Req *types.RemoveEntityPermission `xml:"urn:vim25 RemoveEntityPermission,omitempty"` 11988 Res *types.RemoveEntityPermissionResponse `xml:"urn:vim25 RemoveEntityPermissionResponse,omitempty"` 11989 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 11990} 11991 11992func (b *RemoveEntityPermissionBody) Fault() *soap.Fault { return b.Fault_ } 11993 11994func RemoveEntityPermission(ctx context.Context, r soap.RoundTripper, req *types.RemoveEntityPermission) (*types.RemoveEntityPermissionResponse, error) { 11995 var reqBody, resBody RemoveEntityPermissionBody 11996 11997 reqBody.Req = req 11998 11999 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12000 return nil, err 12001 } 12002 12003 return resBody.Res, nil 12004} 12005 12006type RemoveFilterBody struct { 12007 Req *types.RemoveFilter `xml:"urn:vim25 RemoveFilter,omitempty"` 12008 Res *types.RemoveFilterResponse `xml:"urn:vim25 RemoveFilterResponse,omitempty"` 12009 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12010} 12011 12012func (b *RemoveFilterBody) Fault() *soap.Fault { return b.Fault_ } 12013 12014func RemoveFilter(ctx context.Context, r soap.RoundTripper, req *types.RemoveFilter) (*types.RemoveFilterResponse, error) { 12015 var reqBody, resBody RemoveFilterBody 12016 12017 reqBody.Req = req 12018 12019 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12020 return nil, err 12021 } 12022 12023 return resBody.Res, nil 12024} 12025 12026type RemoveFilterEntitiesBody struct { 12027 Req *types.RemoveFilterEntities `xml:"urn:vim25 RemoveFilterEntities,omitempty"` 12028 Res *types.RemoveFilterEntitiesResponse `xml:"urn:vim25 RemoveFilterEntitiesResponse,omitempty"` 12029 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12030} 12031 12032func (b *RemoveFilterEntitiesBody) Fault() *soap.Fault { return b.Fault_ } 12033 12034func RemoveFilterEntities(ctx context.Context, r soap.RoundTripper, req *types.RemoveFilterEntities) (*types.RemoveFilterEntitiesResponse, error) { 12035 var reqBody, resBody RemoveFilterEntitiesBody 12036 12037 reqBody.Req = req 12038 12039 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12040 return nil, err 12041 } 12042 12043 return resBody.Res, nil 12044} 12045 12046type RemoveGroupBody struct { 12047 Req *types.RemoveGroup `xml:"urn:vim25 RemoveGroup,omitempty"` 12048 Res *types.RemoveGroupResponse `xml:"urn:vim25 RemoveGroupResponse,omitempty"` 12049 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12050} 12051 12052func (b *RemoveGroupBody) Fault() *soap.Fault { return b.Fault_ } 12053 12054func RemoveGroup(ctx context.Context, r soap.RoundTripper, req *types.RemoveGroup) (*types.RemoveGroupResponse, error) { 12055 var reqBody, resBody RemoveGroupBody 12056 12057 reqBody.Req = req 12058 12059 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12060 return nil, err 12061 } 12062 12063 return resBody.Res, nil 12064} 12065 12066type RemoveGuestAliasBody struct { 12067 Req *types.RemoveGuestAlias `xml:"urn:vim25 RemoveGuestAlias,omitempty"` 12068 Res *types.RemoveGuestAliasResponse `xml:"urn:vim25 RemoveGuestAliasResponse,omitempty"` 12069 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12070} 12071 12072func (b *RemoveGuestAliasBody) Fault() *soap.Fault { return b.Fault_ } 12073 12074func RemoveGuestAlias(ctx context.Context, r soap.RoundTripper, req *types.RemoveGuestAlias) (*types.RemoveGuestAliasResponse, error) { 12075 var reqBody, resBody RemoveGuestAliasBody 12076 12077 reqBody.Req = req 12078 12079 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12080 return nil, err 12081 } 12082 12083 return resBody.Res, nil 12084} 12085 12086type RemoveGuestAliasByCertBody struct { 12087 Req *types.RemoveGuestAliasByCert `xml:"urn:vim25 RemoveGuestAliasByCert,omitempty"` 12088 Res *types.RemoveGuestAliasByCertResponse `xml:"urn:vim25 RemoveGuestAliasByCertResponse,omitempty"` 12089 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12090} 12091 12092func (b *RemoveGuestAliasByCertBody) Fault() *soap.Fault { return b.Fault_ } 12093 12094func RemoveGuestAliasByCert(ctx context.Context, r soap.RoundTripper, req *types.RemoveGuestAliasByCert) (*types.RemoveGuestAliasByCertResponse, error) { 12095 var reqBody, resBody RemoveGuestAliasByCertBody 12096 12097 reqBody.Req = req 12098 12099 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12100 return nil, err 12101 } 12102 12103 return resBody.Res, nil 12104} 12105 12106type RemoveInternetScsiSendTargetsBody struct { 12107 Req *types.RemoveInternetScsiSendTargets `xml:"urn:vim25 RemoveInternetScsiSendTargets,omitempty"` 12108 Res *types.RemoveInternetScsiSendTargetsResponse `xml:"urn:vim25 RemoveInternetScsiSendTargetsResponse,omitempty"` 12109 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12110} 12111 12112func (b *RemoveInternetScsiSendTargetsBody) Fault() *soap.Fault { return b.Fault_ } 12113 12114func RemoveInternetScsiSendTargets(ctx context.Context, r soap.RoundTripper, req *types.RemoveInternetScsiSendTargets) (*types.RemoveInternetScsiSendTargetsResponse, error) { 12115 var reqBody, resBody RemoveInternetScsiSendTargetsBody 12116 12117 reqBody.Req = req 12118 12119 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12120 return nil, err 12121 } 12122 12123 return resBody.Res, nil 12124} 12125 12126type RemoveInternetScsiStaticTargetsBody struct { 12127 Req *types.RemoveInternetScsiStaticTargets `xml:"urn:vim25 RemoveInternetScsiStaticTargets,omitempty"` 12128 Res *types.RemoveInternetScsiStaticTargetsResponse `xml:"urn:vim25 RemoveInternetScsiStaticTargetsResponse,omitempty"` 12129 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12130} 12131 12132func (b *RemoveInternetScsiStaticTargetsBody) Fault() *soap.Fault { return b.Fault_ } 12133 12134func RemoveInternetScsiStaticTargets(ctx context.Context, r soap.RoundTripper, req *types.RemoveInternetScsiStaticTargets) (*types.RemoveInternetScsiStaticTargetsResponse, error) { 12135 var reqBody, resBody RemoveInternetScsiStaticTargetsBody 12136 12137 reqBody.Req = req 12138 12139 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12140 return nil, err 12141 } 12142 12143 return resBody.Res, nil 12144} 12145 12146type RemoveKeyBody struct { 12147 Req *types.RemoveKey `xml:"urn:vim25 RemoveKey,omitempty"` 12148 Res *types.RemoveKeyResponse `xml:"urn:vim25 RemoveKeyResponse,omitempty"` 12149 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12150} 12151 12152func (b *RemoveKeyBody) Fault() *soap.Fault { return b.Fault_ } 12153 12154func RemoveKey(ctx context.Context, r soap.RoundTripper, req *types.RemoveKey) (*types.RemoveKeyResponse, error) { 12155 var reqBody, resBody RemoveKeyBody 12156 12157 reqBody.Req = req 12158 12159 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12160 return nil, err 12161 } 12162 12163 return resBody.Res, nil 12164} 12165 12166type RemoveKeysBody struct { 12167 Req *types.RemoveKeys `xml:"urn:vim25 RemoveKeys,omitempty"` 12168 Res *types.RemoveKeysResponse `xml:"urn:vim25 RemoveKeysResponse,omitempty"` 12169 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12170} 12171 12172func (b *RemoveKeysBody) Fault() *soap.Fault { return b.Fault_ } 12173 12174func RemoveKeys(ctx context.Context, r soap.RoundTripper, req *types.RemoveKeys) (*types.RemoveKeysResponse, error) { 12175 var reqBody, resBody RemoveKeysBody 12176 12177 reqBody.Req = req 12178 12179 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12180 return nil, err 12181 } 12182 12183 return resBody.Res, nil 12184} 12185 12186type RemoveKmipServerBody struct { 12187 Req *types.RemoveKmipServer `xml:"urn:vim25 RemoveKmipServer,omitempty"` 12188 Res *types.RemoveKmipServerResponse `xml:"urn:vim25 RemoveKmipServerResponse,omitempty"` 12189 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12190} 12191 12192func (b *RemoveKmipServerBody) Fault() *soap.Fault { return b.Fault_ } 12193 12194func RemoveKmipServer(ctx context.Context, r soap.RoundTripper, req *types.RemoveKmipServer) (*types.RemoveKmipServerResponse, error) { 12195 var reqBody, resBody RemoveKmipServerBody 12196 12197 reqBody.Req = req 12198 12199 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12200 return nil, err 12201 } 12202 12203 return resBody.Res, nil 12204} 12205 12206type RemoveLicenseBody struct { 12207 Req *types.RemoveLicense `xml:"urn:vim25 RemoveLicense,omitempty"` 12208 Res *types.RemoveLicenseResponse `xml:"urn:vim25 RemoveLicenseResponse,omitempty"` 12209 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12210} 12211 12212func (b *RemoveLicenseBody) Fault() *soap.Fault { return b.Fault_ } 12213 12214func RemoveLicense(ctx context.Context, r soap.RoundTripper, req *types.RemoveLicense) (*types.RemoveLicenseResponse, error) { 12215 var reqBody, resBody RemoveLicenseBody 12216 12217 reqBody.Req = req 12218 12219 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12220 return nil, err 12221 } 12222 12223 return resBody.Res, nil 12224} 12225 12226type RemoveLicenseLabelBody struct { 12227 Req *types.RemoveLicenseLabel `xml:"urn:vim25 RemoveLicenseLabel,omitempty"` 12228 Res *types.RemoveLicenseLabelResponse `xml:"urn:vim25 RemoveLicenseLabelResponse,omitempty"` 12229 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12230} 12231 12232func (b *RemoveLicenseLabelBody) Fault() *soap.Fault { return b.Fault_ } 12233 12234func RemoveLicenseLabel(ctx context.Context, r soap.RoundTripper, req *types.RemoveLicenseLabel) (*types.RemoveLicenseLabelResponse, error) { 12235 var reqBody, resBody RemoveLicenseLabelBody 12236 12237 reqBody.Req = req 12238 12239 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12240 return nil, err 12241 } 12242 12243 return resBody.Res, nil 12244} 12245 12246type RemoveMonitoredEntitiesBody struct { 12247 Req *types.RemoveMonitoredEntities `xml:"urn:vim25 RemoveMonitoredEntities,omitempty"` 12248 Res *types.RemoveMonitoredEntitiesResponse `xml:"urn:vim25 RemoveMonitoredEntitiesResponse,omitempty"` 12249 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12250} 12251 12252func (b *RemoveMonitoredEntitiesBody) Fault() *soap.Fault { return b.Fault_ } 12253 12254func RemoveMonitoredEntities(ctx context.Context, r soap.RoundTripper, req *types.RemoveMonitoredEntities) (*types.RemoveMonitoredEntitiesResponse, error) { 12255 var reqBody, resBody RemoveMonitoredEntitiesBody 12256 12257 reqBody.Req = req 12258 12259 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12260 return nil, err 12261 } 12262 12263 return resBody.Res, nil 12264} 12265 12266type RemoveNetworkResourcePoolBody struct { 12267 Req *types.RemoveNetworkResourcePool `xml:"urn:vim25 RemoveNetworkResourcePool,omitempty"` 12268 Res *types.RemoveNetworkResourcePoolResponse `xml:"urn:vim25 RemoveNetworkResourcePoolResponse,omitempty"` 12269 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12270} 12271 12272func (b *RemoveNetworkResourcePoolBody) Fault() *soap.Fault { return b.Fault_ } 12273 12274func RemoveNetworkResourcePool(ctx context.Context, r soap.RoundTripper, req *types.RemoveNetworkResourcePool) (*types.RemoveNetworkResourcePoolResponse, error) { 12275 var reqBody, resBody RemoveNetworkResourcePoolBody 12276 12277 reqBody.Req = req 12278 12279 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12280 return nil, err 12281 } 12282 12283 return resBody.Res, nil 12284} 12285 12286type RemovePerfIntervalBody struct { 12287 Req *types.RemovePerfInterval `xml:"urn:vim25 RemovePerfInterval,omitempty"` 12288 Res *types.RemovePerfIntervalResponse `xml:"urn:vim25 RemovePerfIntervalResponse,omitempty"` 12289 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12290} 12291 12292func (b *RemovePerfIntervalBody) Fault() *soap.Fault { return b.Fault_ } 12293 12294func RemovePerfInterval(ctx context.Context, r soap.RoundTripper, req *types.RemovePerfInterval) (*types.RemovePerfIntervalResponse, error) { 12295 var reqBody, resBody RemovePerfIntervalBody 12296 12297 reqBody.Req = req 12298 12299 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12300 return nil, err 12301 } 12302 12303 return resBody.Res, nil 12304} 12305 12306type RemovePortGroupBody struct { 12307 Req *types.RemovePortGroup `xml:"urn:vim25 RemovePortGroup,omitempty"` 12308 Res *types.RemovePortGroupResponse `xml:"urn:vim25 RemovePortGroupResponse,omitempty"` 12309 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12310} 12311 12312func (b *RemovePortGroupBody) Fault() *soap.Fault { return b.Fault_ } 12313 12314func RemovePortGroup(ctx context.Context, r soap.RoundTripper, req *types.RemovePortGroup) (*types.RemovePortGroupResponse, error) { 12315 var reqBody, resBody RemovePortGroupBody 12316 12317 reqBody.Req = req 12318 12319 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12320 return nil, err 12321 } 12322 12323 return resBody.Res, nil 12324} 12325 12326type RemoveScheduledTaskBody struct { 12327 Req *types.RemoveScheduledTask `xml:"urn:vim25 RemoveScheduledTask,omitempty"` 12328 Res *types.RemoveScheduledTaskResponse `xml:"urn:vim25 RemoveScheduledTaskResponse,omitempty"` 12329 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12330} 12331 12332func (b *RemoveScheduledTaskBody) Fault() *soap.Fault { return b.Fault_ } 12333 12334func RemoveScheduledTask(ctx context.Context, r soap.RoundTripper, req *types.RemoveScheduledTask) (*types.RemoveScheduledTaskResponse, error) { 12335 var reqBody, resBody RemoveScheduledTaskBody 12336 12337 reqBody.Req = req 12338 12339 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12340 return nil, err 12341 } 12342 12343 return resBody.Res, nil 12344} 12345 12346type RemoveServiceConsoleVirtualNicBody struct { 12347 Req *types.RemoveServiceConsoleVirtualNic `xml:"urn:vim25 RemoveServiceConsoleVirtualNic,omitempty"` 12348 Res *types.RemoveServiceConsoleVirtualNicResponse `xml:"urn:vim25 RemoveServiceConsoleVirtualNicResponse,omitempty"` 12349 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12350} 12351 12352func (b *RemoveServiceConsoleVirtualNicBody) Fault() *soap.Fault { return b.Fault_ } 12353 12354func RemoveServiceConsoleVirtualNic(ctx context.Context, r soap.RoundTripper, req *types.RemoveServiceConsoleVirtualNic) (*types.RemoveServiceConsoleVirtualNicResponse, error) { 12355 var reqBody, resBody RemoveServiceConsoleVirtualNicBody 12356 12357 reqBody.Req = req 12358 12359 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12360 return nil, err 12361 } 12362 12363 return resBody.Res, nil 12364} 12365 12366type RemoveSmartCardTrustAnchorBody struct { 12367 Req *types.RemoveSmartCardTrustAnchor `xml:"urn:vim25 RemoveSmartCardTrustAnchor,omitempty"` 12368 Res *types.RemoveSmartCardTrustAnchorResponse `xml:"urn:vim25 RemoveSmartCardTrustAnchorResponse,omitempty"` 12369 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12370} 12371 12372func (b *RemoveSmartCardTrustAnchorBody) Fault() *soap.Fault { return b.Fault_ } 12373 12374func RemoveSmartCardTrustAnchor(ctx context.Context, r soap.RoundTripper, req *types.RemoveSmartCardTrustAnchor) (*types.RemoveSmartCardTrustAnchorResponse, error) { 12375 var reqBody, resBody RemoveSmartCardTrustAnchorBody 12376 12377 reqBody.Req = req 12378 12379 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12380 return nil, err 12381 } 12382 12383 return resBody.Res, nil 12384} 12385 12386type RemoveSmartCardTrustAnchorByFingerprintBody struct { 12387 Req *types.RemoveSmartCardTrustAnchorByFingerprint `xml:"urn:vim25 RemoveSmartCardTrustAnchorByFingerprint,omitempty"` 12388 Res *types.RemoveSmartCardTrustAnchorByFingerprintResponse `xml:"urn:vim25 RemoveSmartCardTrustAnchorByFingerprintResponse,omitempty"` 12389 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12390} 12391 12392func (b *RemoveSmartCardTrustAnchorByFingerprintBody) Fault() *soap.Fault { return b.Fault_ } 12393 12394func RemoveSmartCardTrustAnchorByFingerprint(ctx context.Context, r soap.RoundTripper, req *types.RemoveSmartCardTrustAnchorByFingerprint) (*types.RemoveSmartCardTrustAnchorByFingerprintResponse, error) { 12395 var reqBody, resBody RemoveSmartCardTrustAnchorByFingerprintBody 12396 12397 reqBody.Req = req 12398 12399 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12400 return nil, err 12401 } 12402 12403 return resBody.Res, nil 12404} 12405 12406type RemoveSnapshot_TaskBody struct { 12407 Req *types.RemoveSnapshot_Task `xml:"urn:vim25 RemoveSnapshot_Task,omitempty"` 12408 Res *types.RemoveSnapshot_TaskResponse `xml:"urn:vim25 RemoveSnapshot_TaskResponse,omitempty"` 12409 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12410} 12411 12412func (b *RemoveSnapshot_TaskBody) Fault() *soap.Fault { return b.Fault_ } 12413 12414func RemoveSnapshot_Task(ctx context.Context, r soap.RoundTripper, req *types.RemoveSnapshot_Task) (*types.RemoveSnapshot_TaskResponse, error) { 12415 var reqBody, resBody RemoveSnapshot_TaskBody 12416 12417 reqBody.Req = req 12418 12419 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12420 return nil, err 12421 } 12422 12423 return resBody.Res, nil 12424} 12425 12426type RemoveUserBody struct { 12427 Req *types.RemoveUser `xml:"urn:vim25 RemoveUser,omitempty"` 12428 Res *types.RemoveUserResponse `xml:"urn:vim25 RemoveUserResponse,omitempty"` 12429 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12430} 12431 12432func (b *RemoveUserBody) Fault() *soap.Fault { return b.Fault_ } 12433 12434func RemoveUser(ctx context.Context, r soap.RoundTripper, req *types.RemoveUser) (*types.RemoveUserResponse, error) { 12435 var reqBody, resBody RemoveUserBody 12436 12437 reqBody.Req = req 12438 12439 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12440 return nil, err 12441 } 12442 12443 return resBody.Res, nil 12444} 12445 12446type RemoveVirtualNicBody struct { 12447 Req *types.RemoveVirtualNic `xml:"urn:vim25 RemoveVirtualNic,omitempty"` 12448 Res *types.RemoveVirtualNicResponse `xml:"urn:vim25 RemoveVirtualNicResponse,omitempty"` 12449 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12450} 12451 12452func (b *RemoveVirtualNicBody) Fault() *soap.Fault { return b.Fault_ } 12453 12454func RemoveVirtualNic(ctx context.Context, r soap.RoundTripper, req *types.RemoveVirtualNic) (*types.RemoveVirtualNicResponse, error) { 12455 var reqBody, resBody RemoveVirtualNicBody 12456 12457 reqBody.Req = req 12458 12459 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12460 return nil, err 12461 } 12462 12463 return resBody.Res, nil 12464} 12465 12466type RemoveVirtualSwitchBody struct { 12467 Req *types.RemoveVirtualSwitch `xml:"urn:vim25 RemoveVirtualSwitch,omitempty"` 12468 Res *types.RemoveVirtualSwitchResponse `xml:"urn:vim25 RemoveVirtualSwitchResponse,omitempty"` 12469 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12470} 12471 12472func (b *RemoveVirtualSwitchBody) Fault() *soap.Fault { return b.Fault_ } 12473 12474func RemoveVirtualSwitch(ctx context.Context, r soap.RoundTripper, req *types.RemoveVirtualSwitch) (*types.RemoveVirtualSwitchResponse, error) { 12475 var reqBody, resBody RemoveVirtualSwitchBody 12476 12477 reqBody.Req = req 12478 12479 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12480 return nil, err 12481 } 12482 12483 return resBody.Res, nil 12484} 12485 12486type RenameCustomFieldDefBody struct { 12487 Req *types.RenameCustomFieldDef `xml:"urn:vim25 RenameCustomFieldDef,omitempty"` 12488 Res *types.RenameCustomFieldDefResponse `xml:"urn:vim25 RenameCustomFieldDefResponse,omitempty"` 12489 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12490} 12491 12492func (b *RenameCustomFieldDefBody) Fault() *soap.Fault { return b.Fault_ } 12493 12494func RenameCustomFieldDef(ctx context.Context, r soap.RoundTripper, req *types.RenameCustomFieldDef) (*types.RenameCustomFieldDefResponse, error) { 12495 var reqBody, resBody RenameCustomFieldDefBody 12496 12497 reqBody.Req = req 12498 12499 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12500 return nil, err 12501 } 12502 12503 return resBody.Res, nil 12504} 12505 12506type RenameCustomizationSpecBody struct { 12507 Req *types.RenameCustomizationSpec `xml:"urn:vim25 RenameCustomizationSpec,omitempty"` 12508 Res *types.RenameCustomizationSpecResponse `xml:"urn:vim25 RenameCustomizationSpecResponse,omitempty"` 12509 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12510} 12511 12512func (b *RenameCustomizationSpecBody) Fault() *soap.Fault { return b.Fault_ } 12513 12514func RenameCustomizationSpec(ctx context.Context, r soap.RoundTripper, req *types.RenameCustomizationSpec) (*types.RenameCustomizationSpecResponse, error) { 12515 var reqBody, resBody RenameCustomizationSpecBody 12516 12517 reqBody.Req = req 12518 12519 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12520 return nil, err 12521 } 12522 12523 return resBody.Res, nil 12524} 12525 12526type RenameDatastoreBody struct { 12527 Req *types.RenameDatastore `xml:"urn:vim25 RenameDatastore,omitempty"` 12528 Res *types.RenameDatastoreResponse `xml:"urn:vim25 RenameDatastoreResponse,omitempty"` 12529 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12530} 12531 12532func (b *RenameDatastoreBody) Fault() *soap.Fault { return b.Fault_ } 12533 12534func RenameDatastore(ctx context.Context, r soap.RoundTripper, req *types.RenameDatastore) (*types.RenameDatastoreResponse, error) { 12535 var reqBody, resBody RenameDatastoreBody 12536 12537 reqBody.Req = req 12538 12539 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12540 return nil, err 12541 } 12542 12543 return resBody.Res, nil 12544} 12545 12546type RenameSnapshotBody struct { 12547 Req *types.RenameSnapshot `xml:"urn:vim25 RenameSnapshot,omitempty"` 12548 Res *types.RenameSnapshotResponse `xml:"urn:vim25 RenameSnapshotResponse,omitempty"` 12549 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12550} 12551 12552func (b *RenameSnapshotBody) Fault() *soap.Fault { return b.Fault_ } 12553 12554func RenameSnapshot(ctx context.Context, r soap.RoundTripper, req *types.RenameSnapshot) (*types.RenameSnapshotResponse, error) { 12555 var reqBody, resBody RenameSnapshotBody 12556 12557 reqBody.Req = req 12558 12559 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12560 return nil, err 12561 } 12562 12563 return resBody.Res, nil 12564} 12565 12566type RenameVStorageObjectBody struct { 12567 Req *types.RenameVStorageObject `xml:"urn:vim25 RenameVStorageObject,omitempty"` 12568 Res *types.RenameVStorageObjectResponse `xml:"urn:vim25 RenameVStorageObjectResponse,omitempty"` 12569 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12570} 12571 12572func (b *RenameVStorageObjectBody) Fault() *soap.Fault { return b.Fault_ } 12573 12574func RenameVStorageObject(ctx context.Context, r soap.RoundTripper, req *types.RenameVStorageObject) (*types.RenameVStorageObjectResponse, error) { 12575 var reqBody, resBody RenameVStorageObjectBody 12576 12577 reqBody.Req = req 12578 12579 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12580 return nil, err 12581 } 12582 12583 return resBody.Res, nil 12584} 12585 12586type Rename_TaskBody struct { 12587 Req *types.Rename_Task `xml:"urn:vim25 Rename_Task,omitempty"` 12588 Res *types.Rename_TaskResponse `xml:"urn:vim25 Rename_TaskResponse,omitempty"` 12589 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12590} 12591 12592func (b *Rename_TaskBody) Fault() *soap.Fault { return b.Fault_ } 12593 12594func Rename_Task(ctx context.Context, r soap.RoundTripper, req *types.Rename_Task) (*types.Rename_TaskResponse, error) { 12595 var reqBody, resBody Rename_TaskBody 12596 12597 reqBody.Req = req 12598 12599 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12600 return nil, err 12601 } 12602 12603 return resBody.Res, nil 12604} 12605 12606type ReplaceCACertificatesAndCRLsBody struct { 12607 Req *types.ReplaceCACertificatesAndCRLs `xml:"urn:vim25 ReplaceCACertificatesAndCRLs,omitempty"` 12608 Res *types.ReplaceCACertificatesAndCRLsResponse `xml:"urn:vim25 ReplaceCACertificatesAndCRLsResponse,omitempty"` 12609 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12610} 12611 12612func (b *ReplaceCACertificatesAndCRLsBody) Fault() *soap.Fault { return b.Fault_ } 12613 12614func ReplaceCACertificatesAndCRLs(ctx context.Context, r soap.RoundTripper, req *types.ReplaceCACertificatesAndCRLs) (*types.ReplaceCACertificatesAndCRLsResponse, error) { 12615 var reqBody, resBody ReplaceCACertificatesAndCRLsBody 12616 12617 reqBody.Req = req 12618 12619 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12620 return nil, err 12621 } 12622 12623 return resBody.Res, nil 12624} 12625 12626type ReplaceSmartCardTrustAnchorsBody struct { 12627 Req *types.ReplaceSmartCardTrustAnchors `xml:"urn:vim25 ReplaceSmartCardTrustAnchors,omitempty"` 12628 Res *types.ReplaceSmartCardTrustAnchorsResponse `xml:"urn:vim25 ReplaceSmartCardTrustAnchorsResponse,omitempty"` 12629 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12630} 12631 12632func (b *ReplaceSmartCardTrustAnchorsBody) Fault() *soap.Fault { return b.Fault_ } 12633 12634func ReplaceSmartCardTrustAnchors(ctx context.Context, r soap.RoundTripper, req *types.ReplaceSmartCardTrustAnchors) (*types.ReplaceSmartCardTrustAnchorsResponse, error) { 12635 var reqBody, resBody ReplaceSmartCardTrustAnchorsBody 12636 12637 reqBody.Req = req 12638 12639 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12640 return nil, err 12641 } 12642 12643 return resBody.Res, nil 12644} 12645 12646type RescanAllHbaBody struct { 12647 Req *types.RescanAllHba `xml:"urn:vim25 RescanAllHba,omitempty"` 12648 Res *types.RescanAllHbaResponse `xml:"urn:vim25 RescanAllHbaResponse,omitempty"` 12649 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12650} 12651 12652func (b *RescanAllHbaBody) Fault() *soap.Fault { return b.Fault_ } 12653 12654func RescanAllHba(ctx context.Context, r soap.RoundTripper, req *types.RescanAllHba) (*types.RescanAllHbaResponse, error) { 12655 var reqBody, resBody RescanAllHbaBody 12656 12657 reqBody.Req = req 12658 12659 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12660 return nil, err 12661 } 12662 12663 return resBody.Res, nil 12664} 12665 12666type RescanHbaBody struct { 12667 Req *types.RescanHba `xml:"urn:vim25 RescanHba,omitempty"` 12668 Res *types.RescanHbaResponse `xml:"urn:vim25 RescanHbaResponse,omitempty"` 12669 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12670} 12671 12672func (b *RescanHbaBody) Fault() *soap.Fault { return b.Fault_ } 12673 12674func RescanHba(ctx context.Context, r soap.RoundTripper, req *types.RescanHba) (*types.RescanHbaResponse, error) { 12675 var reqBody, resBody RescanHbaBody 12676 12677 reqBody.Req = req 12678 12679 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12680 return nil, err 12681 } 12682 12683 return resBody.Res, nil 12684} 12685 12686type RescanVffsBody struct { 12687 Req *types.RescanVffs `xml:"urn:vim25 RescanVffs,omitempty"` 12688 Res *types.RescanVffsResponse `xml:"urn:vim25 RescanVffsResponse,omitempty"` 12689 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12690} 12691 12692func (b *RescanVffsBody) Fault() *soap.Fault { return b.Fault_ } 12693 12694func RescanVffs(ctx context.Context, r soap.RoundTripper, req *types.RescanVffs) (*types.RescanVffsResponse, error) { 12695 var reqBody, resBody RescanVffsBody 12696 12697 reqBody.Req = req 12698 12699 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12700 return nil, err 12701 } 12702 12703 return resBody.Res, nil 12704} 12705 12706type RescanVmfsBody struct { 12707 Req *types.RescanVmfs `xml:"urn:vim25 RescanVmfs,omitempty"` 12708 Res *types.RescanVmfsResponse `xml:"urn:vim25 RescanVmfsResponse,omitempty"` 12709 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12710} 12711 12712func (b *RescanVmfsBody) Fault() *soap.Fault { return b.Fault_ } 12713 12714func RescanVmfs(ctx context.Context, r soap.RoundTripper, req *types.RescanVmfs) (*types.RescanVmfsResponse, error) { 12715 var reqBody, resBody RescanVmfsBody 12716 12717 reqBody.Req = req 12718 12719 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12720 return nil, err 12721 } 12722 12723 return resBody.Res, nil 12724} 12725 12726type ResetCollectorBody struct { 12727 Req *types.ResetCollector `xml:"urn:vim25 ResetCollector,omitempty"` 12728 Res *types.ResetCollectorResponse `xml:"urn:vim25 ResetCollectorResponse,omitempty"` 12729 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12730} 12731 12732func (b *ResetCollectorBody) Fault() *soap.Fault { return b.Fault_ } 12733 12734func ResetCollector(ctx context.Context, r soap.RoundTripper, req *types.ResetCollector) (*types.ResetCollectorResponse, error) { 12735 var reqBody, resBody ResetCollectorBody 12736 12737 reqBody.Req = req 12738 12739 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12740 return nil, err 12741 } 12742 12743 return resBody.Res, nil 12744} 12745 12746type ResetCounterLevelMappingBody struct { 12747 Req *types.ResetCounterLevelMapping `xml:"urn:vim25 ResetCounterLevelMapping,omitempty"` 12748 Res *types.ResetCounterLevelMappingResponse `xml:"urn:vim25 ResetCounterLevelMappingResponse,omitempty"` 12749 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12750} 12751 12752func (b *ResetCounterLevelMappingBody) Fault() *soap.Fault { return b.Fault_ } 12753 12754func ResetCounterLevelMapping(ctx context.Context, r soap.RoundTripper, req *types.ResetCounterLevelMapping) (*types.ResetCounterLevelMappingResponse, error) { 12755 var reqBody, resBody ResetCounterLevelMappingBody 12756 12757 reqBody.Req = req 12758 12759 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12760 return nil, err 12761 } 12762 12763 return resBody.Res, nil 12764} 12765 12766type ResetEntityPermissionsBody struct { 12767 Req *types.ResetEntityPermissions `xml:"urn:vim25 ResetEntityPermissions,omitempty"` 12768 Res *types.ResetEntityPermissionsResponse `xml:"urn:vim25 ResetEntityPermissionsResponse,omitempty"` 12769 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12770} 12771 12772func (b *ResetEntityPermissionsBody) Fault() *soap.Fault { return b.Fault_ } 12773 12774func ResetEntityPermissions(ctx context.Context, r soap.RoundTripper, req *types.ResetEntityPermissions) (*types.ResetEntityPermissionsResponse, error) { 12775 var reqBody, resBody ResetEntityPermissionsBody 12776 12777 reqBody.Req = req 12778 12779 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12780 return nil, err 12781 } 12782 12783 return resBody.Res, nil 12784} 12785 12786type ResetFirmwareToFactoryDefaultsBody struct { 12787 Req *types.ResetFirmwareToFactoryDefaults `xml:"urn:vim25 ResetFirmwareToFactoryDefaults,omitempty"` 12788 Res *types.ResetFirmwareToFactoryDefaultsResponse `xml:"urn:vim25 ResetFirmwareToFactoryDefaultsResponse,omitempty"` 12789 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12790} 12791 12792func (b *ResetFirmwareToFactoryDefaultsBody) Fault() *soap.Fault { return b.Fault_ } 12793 12794func ResetFirmwareToFactoryDefaults(ctx context.Context, r soap.RoundTripper, req *types.ResetFirmwareToFactoryDefaults) (*types.ResetFirmwareToFactoryDefaultsResponse, error) { 12795 var reqBody, resBody ResetFirmwareToFactoryDefaultsBody 12796 12797 reqBody.Req = req 12798 12799 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12800 return nil, err 12801 } 12802 12803 return resBody.Res, nil 12804} 12805 12806type ResetGuestInformationBody struct { 12807 Req *types.ResetGuestInformation `xml:"urn:vim25 ResetGuestInformation,omitempty"` 12808 Res *types.ResetGuestInformationResponse `xml:"urn:vim25 ResetGuestInformationResponse,omitempty"` 12809 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12810} 12811 12812func (b *ResetGuestInformationBody) Fault() *soap.Fault { return b.Fault_ } 12813 12814func ResetGuestInformation(ctx context.Context, r soap.RoundTripper, req *types.ResetGuestInformation) (*types.ResetGuestInformationResponse, error) { 12815 var reqBody, resBody ResetGuestInformationBody 12816 12817 reqBody.Req = req 12818 12819 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12820 return nil, err 12821 } 12822 12823 return resBody.Res, nil 12824} 12825 12826type ResetListViewBody struct { 12827 Req *types.ResetListView `xml:"urn:vim25 ResetListView,omitempty"` 12828 Res *types.ResetListViewResponse `xml:"urn:vim25 ResetListViewResponse,omitempty"` 12829 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12830} 12831 12832func (b *ResetListViewBody) Fault() *soap.Fault { return b.Fault_ } 12833 12834func ResetListView(ctx context.Context, r soap.RoundTripper, req *types.ResetListView) (*types.ResetListViewResponse, error) { 12835 var reqBody, resBody ResetListViewBody 12836 12837 reqBody.Req = req 12838 12839 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12840 return nil, err 12841 } 12842 12843 return resBody.Res, nil 12844} 12845 12846type ResetListViewFromViewBody struct { 12847 Req *types.ResetListViewFromView `xml:"urn:vim25 ResetListViewFromView,omitempty"` 12848 Res *types.ResetListViewFromViewResponse `xml:"urn:vim25 ResetListViewFromViewResponse,omitempty"` 12849 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12850} 12851 12852func (b *ResetListViewFromViewBody) Fault() *soap.Fault { return b.Fault_ } 12853 12854func ResetListViewFromView(ctx context.Context, r soap.RoundTripper, req *types.ResetListViewFromView) (*types.ResetListViewFromViewResponse, error) { 12855 var reqBody, resBody ResetListViewFromViewBody 12856 12857 reqBody.Req = req 12858 12859 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12860 return nil, err 12861 } 12862 12863 return resBody.Res, nil 12864} 12865 12866type ResetSystemHealthInfoBody struct { 12867 Req *types.ResetSystemHealthInfo `xml:"urn:vim25 ResetSystemHealthInfo,omitempty"` 12868 Res *types.ResetSystemHealthInfoResponse `xml:"urn:vim25 ResetSystemHealthInfoResponse,omitempty"` 12869 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12870} 12871 12872func (b *ResetSystemHealthInfoBody) Fault() *soap.Fault { return b.Fault_ } 12873 12874func ResetSystemHealthInfo(ctx context.Context, r soap.RoundTripper, req *types.ResetSystemHealthInfo) (*types.ResetSystemHealthInfoResponse, error) { 12875 var reqBody, resBody ResetSystemHealthInfoBody 12876 12877 reqBody.Req = req 12878 12879 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12880 return nil, err 12881 } 12882 12883 return resBody.Res, nil 12884} 12885 12886type ResetVM_TaskBody struct { 12887 Req *types.ResetVM_Task `xml:"urn:vim25 ResetVM_Task,omitempty"` 12888 Res *types.ResetVM_TaskResponse `xml:"urn:vim25 ResetVM_TaskResponse,omitempty"` 12889 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12890} 12891 12892func (b *ResetVM_TaskBody) Fault() *soap.Fault { return b.Fault_ } 12893 12894func ResetVM_Task(ctx context.Context, r soap.RoundTripper, req *types.ResetVM_Task) (*types.ResetVM_TaskResponse, error) { 12895 var reqBody, resBody ResetVM_TaskBody 12896 12897 reqBody.Req = req 12898 12899 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12900 return nil, err 12901 } 12902 12903 return resBody.Res, nil 12904} 12905 12906type ResignatureUnresolvedVmfsVolume_TaskBody struct { 12907 Req *types.ResignatureUnresolvedVmfsVolume_Task `xml:"urn:vim25 ResignatureUnresolvedVmfsVolume_Task,omitempty"` 12908 Res *types.ResignatureUnresolvedVmfsVolume_TaskResponse `xml:"urn:vim25 ResignatureUnresolvedVmfsVolume_TaskResponse,omitempty"` 12909 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12910} 12911 12912func (b *ResignatureUnresolvedVmfsVolume_TaskBody) Fault() *soap.Fault { return b.Fault_ } 12913 12914func ResignatureUnresolvedVmfsVolume_Task(ctx context.Context, r soap.RoundTripper, req *types.ResignatureUnresolvedVmfsVolume_Task) (*types.ResignatureUnresolvedVmfsVolume_TaskResponse, error) { 12915 var reqBody, resBody ResignatureUnresolvedVmfsVolume_TaskBody 12916 12917 reqBody.Req = req 12918 12919 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12920 return nil, err 12921 } 12922 12923 return resBody.Res, nil 12924} 12925 12926type ResolveInstallationErrorsOnCluster_TaskBody struct { 12927 Req *types.ResolveInstallationErrorsOnCluster_Task `xml:"urn:vim25 ResolveInstallationErrorsOnCluster_Task,omitempty"` 12928 Res *types.ResolveInstallationErrorsOnCluster_TaskResponse `xml:"urn:vim25 ResolveInstallationErrorsOnCluster_TaskResponse,omitempty"` 12929 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12930} 12931 12932func (b *ResolveInstallationErrorsOnCluster_TaskBody) Fault() *soap.Fault { return b.Fault_ } 12933 12934func ResolveInstallationErrorsOnCluster_Task(ctx context.Context, r soap.RoundTripper, req *types.ResolveInstallationErrorsOnCluster_Task) (*types.ResolveInstallationErrorsOnCluster_TaskResponse, error) { 12935 var reqBody, resBody ResolveInstallationErrorsOnCluster_TaskBody 12936 12937 reqBody.Req = req 12938 12939 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12940 return nil, err 12941 } 12942 12943 return resBody.Res, nil 12944} 12945 12946type ResolveInstallationErrorsOnHost_TaskBody struct { 12947 Req *types.ResolveInstallationErrorsOnHost_Task `xml:"urn:vim25 ResolveInstallationErrorsOnHost_Task,omitempty"` 12948 Res *types.ResolveInstallationErrorsOnHost_TaskResponse `xml:"urn:vim25 ResolveInstallationErrorsOnHost_TaskResponse,omitempty"` 12949 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12950} 12951 12952func (b *ResolveInstallationErrorsOnHost_TaskBody) Fault() *soap.Fault { return b.Fault_ } 12953 12954func ResolveInstallationErrorsOnHost_Task(ctx context.Context, r soap.RoundTripper, req *types.ResolveInstallationErrorsOnHost_Task) (*types.ResolveInstallationErrorsOnHost_TaskResponse, error) { 12955 var reqBody, resBody ResolveInstallationErrorsOnHost_TaskBody 12956 12957 reqBody.Req = req 12958 12959 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12960 return nil, err 12961 } 12962 12963 return resBody.Res, nil 12964} 12965 12966type ResolveMultipleUnresolvedVmfsVolumesBody struct { 12967 Req *types.ResolveMultipleUnresolvedVmfsVolumes `xml:"urn:vim25 ResolveMultipleUnresolvedVmfsVolumes,omitempty"` 12968 Res *types.ResolveMultipleUnresolvedVmfsVolumesResponse `xml:"urn:vim25 ResolveMultipleUnresolvedVmfsVolumesResponse,omitempty"` 12969 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12970} 12971 12972func (b *ResolveMultipleUnresolvedVmfsVolumesBody) Fault() *soap.Fault { return b.Fault_ } 12973 12974func ResolveMultipleUnresolvedVmfsVolumes(ctx context.Context, r soap.RoundTripper, req *types.ResolveMultipleUnresolvedVmfsVolumes) (*types.ResolveMultipleUnresolvedVmfsVolumesResponse, error) { 12975 var reqBody, resBody ResolveMultipleUnresolvedVmfsVolumesBody 12976 12977 reqBody.Req = req 12978 12979 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 12980 return nil, err 12981 } 12982 12983 return resBody.Res, nil 12984} 12985 12986type ResolveMultipleUnresolvedVmfsVolumesEx_TaskBody struct { 12987 Req *types.ResolveMultipleUnresolvedVmfsVolumesEx_Task `xml:"urn:vim25 ResolveMultipleUnresolvedVmfsVolumesEx_Task,omitempty"` 12988 Res *types.ResolveMultipleUnresolvedVmfsVolumesEx_TaskResponse `xml:"urn:vim25 ResolveMultipleUnresolvedVmfsVolumesEx_TaskResponse,omitempty"` 12989 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 12990} 12991 12992func (b *ResolveMultipleUnresolvedVmfsVolumesEx_TaskBody) Fault() *soap.Fault { return b.Fault_ } 12993 12994func ResolveMultipleUnresolvedVmfsVolumesEx_Task(ctx context.Context, r soap.RoundTripper, req *types.ResolveMultipleUnresolvedVmfsVolumesEx_Task) (*types.ResolveMultipleUnresolvedVmfsVolumesEx_TaskResponse, error) { 12995 var reqBody, resBody ResolveMultipleUnresolvedVmfsVolumesEx_TaskBody 12996 12997 reqBody.Req = req 12998 12999 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13000 return nil, err 13001 } 13002 13003 return resBody.Res, nil 13004} 13005 13006type RestartServiceBody struct { 13007 Req *types.RestartService `xml:"urn:vim25 RestartService,omitempty"` 13008 Res *types.RestartServiceResponse `xml:"urn:vim25 RestartServiceResponse,omitempty"` 13009 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13010} 13011 13012func (b *RestartServiceBody) Fault() *soap.Fault { return b.Fault_ } 13013 13014func RestartService(ctx context.Context, r soap.RoundTripper, req *types.RestartService) (*types.RestartServiceResponse, error) { 13015 var reqBody, resBody RestartServiceBody 13016 13017 reqBody.Req = req 13018 13019 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13020 return nil, err 13021 } 13022 13023 return resBody.Res, nil 13024} 13025 13026type RestartServiceConsoleVirtualNicBody struct { 13027 Req *types.RestartServiceConsoleVirtualNic `xml:"urn:vim25 RestartServiceConsoleVirtualNic,omitempty"` 13028 Res *types.RestartServiceConsoleVirtualNicResponse `xml:"urn:vim25 RestartServiceConsoleVirtualNicResponse,omitempty"` 13029 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13030} 13031 13032func (b *RestartServiceConsoleVirtualNicBody) Fault() *soap.Fault { return b.Fault_ } 13033 13034func RestartServiceConsoleVirtualNic(ctx context.Context, r soap.RoundTripper, req *types.RestartServiceConsoleVirtualNic) (*types.RestartServiceConsoleVirtualNicResponse, error) { 13035 var reqBody, resBody RestartServiceConsoleVirtualNicBody 13036 13037 reqBody.Req = req 13038 13039 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13040 return nil, err 13041 } 13042 13043 return resBody.Res, nil 13044} 13045 13046type RestoreFirmwareConfigurationBody struct { 13047 Req *types.RestoreFirmwareConfiguration `xml:"urn:vim25 RestoreFirmwareConfiguration,omitempty"` 13048 Res *types.RestoreFirmwareConfigurationResponse `xml:"urn:vim25 RestoreFirmwareConfigurationResponse,omitempty"` 13049 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13050} 13051 13052func (b *RestoreFirmwareConfigurationBody) Fault() *soap.Fault { return b.Fault_ } 13053 13054func RestoreFirmwareConfiguration(ctx context.Context, r soap.RoundTripper, req *types.RestoreFirmwareConfiguration) (*types.RestoreFirmwareConfigurationResponse, error) { 13055 var reqBody, resBody RestoreFirmwareConfigurationBody 13056 13057 reqBody.Req = req 13058 13059 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13060 return nil, err 13061 } 13062 13063 return resBody.Res, nil 13064} 13065 13066type RetrieveAllPermissionsBody struct { 13067 Req *types.RetrieveAllPermissions `xml:"urn:vim25 RetrieveAllPermissions,omitempty"` 13068 Res *types.RetrieveAllPermissionsResponse `xml:"urn:vim25 RetrieveAllPermissionsResponse,omitempty"` 13069 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13070} 13071 13072func (b *RetrieveAllPermissionsBody) Fault() *soap.Fault { return b.Fault_ } 13073 13074func RetrieveAllPermissions(ctx context.Context, r soap.RoundTripper, req *types.RetrieveAllPermissions) (*types.RetrieveAllPermissionsResponse, error) { 13075 var reqBody, resBody RetrieveAllPermissionsBody 13076 13077 reqBody.Req = req 13078 13079 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13080 return nil, err 13081 } 13082 13083 return resBody.Res, nil 13084} 13085 13086type RetrieveAnswerFileBody struct { 13087 Req *types.RetrieveAnswerFile `xml:"urn:vim25 RetrieveAnswerFile,omitempty"` 13088 Res *types.RetrieveAnswerFileResponse `xml:"urn:vim25 RetrieveAnswerFileResponse,omitempty"` 13089 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13090} 13091 13092func (b *RetrieveAnswerFileBody) Fault() *soap.Fault { return b.Fault_ } 13093 13094func RetrieveAnswerFile(ctx context.Context, r soap.RoundTripper, req *types.RetrieveAnswerFile) (*types.RetrieveAnswerFileResponse, error) { 13095 var reqBody, resBody RetrieveAnswerFileBody 13096 13097 reqBody.Req = req 13098 13099 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13100 return nil, err 13101 } 13102 13103 return resBody.Res, nil 13104} 13105 13106type RetrieveAnswerFileForProfileBody struct { 13107 Req *types.RetrieveAnswerFileForProfile `xml:"urn:vim25 RetrieveAnswerFileForProfile,omitempty"` 13108 Res *types.RetrieveAnswerFileForProfileResponse `xml:"urn:vim25 RetrieveAnswerFileForProfileResponse,omitempty"` 13109 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13110} 13111 13112func (b *RetrieveAnswerFileForProfileBody) Fault() *soap.Fault { return b.Fault_ } 13113 13114func RetrieveAnswerFileForProfile(ctx context.Context, r soap.RoundTripper, req *types.RetrieveAnswerFileForProfile) (*types.RetrieveAnswerFileForProfileResponse, error) { 13115 var reqBody, resBody RetrieveAnswerFileForProfileBody 13116 13117 reqBody.Req = req 13118 13119 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13120 return nil, err 13121 } 13122 13123 return resBody.Res, nil 13124} 13125 13126type RetrieveArgumentDescriptionBody struct { 13127 Req *types.RetrieveArgumentDescription `xml:"urn:vim25 RetrieveArgumentDescription,omitempty"` 13128 Res *types.RetrieveArgumentDescriptionResponse `xml:"urn:vim25 RetrieveArgumentDescriptionResponse,omitempty"` 13129 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13130} 13131 13132func (b *RetrieveArgumentDescriptionBody) Fault() *soap.Fault { return b.Fault_ } 13133 13134func RetrieveArgumentDescription(ctx context.Context, r soap.RoundTripper, req *types.RetrieveArgumentDescription) (*types.RetrieveArgumentDescriptionResponse, error) { 13135 var reqBody, resBody RetrieveArgumentDescriptionBody 13136 13137 reqBody.Req = req 13138 13139 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13140 return nil, err 13141 } 13142 13143 return resBody.Res, nil 13144} 13145 13146type RetrieveClientCertBody struct { 13147 Req *types.RetrieveClientCert `xml:"urn:vim25 RetrieveClientCert,omitempty"` 13148 Res *types.RetrieveClientCertResponse `xml:"urn:vim25 RetrieveClientCertResponse,omitempty"` 13149 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13150} 13151 13152func (b *RetrieveClientCertBody) Fault() *soap.Fault { return b.Fault_ } 13153 13154func RetrieveClientCert(ctx context.Context, r soap.RoundTripper, req *types.RetrieveClientCert) (*types.RetrieveClientCertResponse, error) { 13155 var reqBody, resBody RetrieveClientCertBody 13156 13157 reqBody.Req = req 13158 13159 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13160 return nil, err 13161 } 13162 13163 return resBody.Res, nil 13164} 13165 13166type RetrieveClientCsrBody struct { 13167 Req *types.RetrieveClientCsr `xml:"urn:vim25 RetrieveClientCsr,omitempty"` 13168 Res *types.RetrieveClientCsrResponse `xml:"urn:vim25 RetrieveClientCsrResponse,omitempty"` 13169 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13170} 13171 13172func (b *RetrieveClientCsrBody) Fault() *soap.Fault { return b.Fault_ } 13173 13174func RetrieveClientCsr(ctx context.Context, r soap.RoundTripper, req *types.RetrieveClientCsr) (*types.RetrieveClientCsrResponse, error) { 13175 var reqBody, resBody RetrieveClientCsrBody 13176 13177 reqBody.Req = req 13178 13179 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13180 return nil, err 13181 } 13182 13183 return resBody.Res, nil 13184} 13185 13186type RetrieveDasAdvancedRuntimeInfoBody struct { 13187 Req *types.RetrieveDasAdvancedRuntimeInfo `xml:"urn:vim25 RetrieveDasAdvancedRuntimeInfo,omitempty"` 13188 Res *types.RetrieveDasAdvancedRuntimeInfoResponse `xml:"urn:vim25 RetrieveDasAdvancedRuntimeInfoResponse,omitempty"` 13189 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13190} 13191 13192func (b *RetrieveDasAdvancedRuntimeInfoBody) Fault() *soap.Fault { return b.Fault_ } 13193 13194func RetrieveDasAdvancedRuntimeInfo(ctx context.Context, r soap.RoundTripper, req *types.RetrieveDasAdvancedRuntimeInfo) (*types.RetrieveDasAdvancedRuntimeInfoResponse, error) { 13195 var reqBody, resBody RetrieveDasAdvancedRuntimeInfoBody 13196 13197 reqBody.Req = req 13198 13199 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13200 return nil, err 13201 } 13202 13203 return resBody.Res, nil 13204} 13205 13206type RetrieveDescriptionBody struct { 13207 Req *types.RetrieveDescription `xml:"urn:vim25 RetrieveDescription,omitempty"` 13208 Res *types.RetrieveDescriptionResponse `xml:"urn:vim25 RetrieveDescriptionResponse,omitempty"` 13209 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13210} 13211 13212func (b *RetrieveDescriptionBody) Fault() *soap.Fault { return b.Fault_ } 13213 13214func RetrieveDescription(ctx context.Context, r soap.RoundTripper, req *types.RetrieveDescription) (*types.RetrieveDescriptionResponse, error) { 13215 var reqBody, resBody RetrieveDescriptionBody 13216 13217 reqBody.Req = req 13218 13219 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13220 return nil, err 13221 } 13222 13223 return resBody.Res, nil 13224} 13225 13226type RetrieveDiskPartitionInfoBody struct { 13227 Req *types.RetrieveDiskPartitionInfo `xml:"urn:vim25 RetrieveDiskPartitionInfo,omitempty"` 13228 Res *types.RetrieveDiskPartitionInfoResponse `xml:"urn:vim25 RetrieveDiskPartitionInfoResponse,omitempty"` 13229 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13230} 13231 13232func (b *RetrieveDiskPartitionInfoBody) Fault() *soap.Fault { return b.Fault_ } 13233 13234func RetrieveDiskPartitionInfo(ctx context.Context, r soap.RoundTripper, req *types.RetrieveDiskPartitionInfo) (*types.RetrieveDiskPartitionInfoResponse, error) { 13235 var reqBody, resBody RetrieveDiskPartitionInfoBody 13236 13237 reqBody.Req = req 13238 13239 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13240 return nil, err 13241 } 13242 13243 return resBody.Res, nil 13244} 13245 13246type RetrieveEntityPermissionsBody struct { 13247 Req *types.RetrieveEntityPermissions `xml:"urn:vim25 RetrieveEntityPermissions,omitempty"` 13248 Res *types.RetrieveEntityPermissionsResponse `xml:"urn:vim25 RetrieveEntityPermissionsResponse,omitempty"` 13249 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13250} 13251 13252func (b *RetrieveEntityPermissionsBody) Fault() *soap.Fault { return b.Fault_ } 13253 13254func RetrieveEntityPermissions(ctx context.Context, r soap.RoundTripper, req *types.RetrieveEntityPermissions) (*types.RetrieveEntityPermissionsResponse, error) { 13255 var reqBody, resBody RetrieveEntityPermissionsBody 13256 13257 reqBody.Req = req 13258 13259 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13260 return nil, err 13261 } 13262 13263 return resBody.Res, nil 13264} 13265 13266type RetrieveEntityScheduledTaskBody struct { 13267 Req *types.RetrieveEntityScheduledTask `xml:"urn:vim25 RetrieveEntityScheduledTask,omitempty"` 13268 Res *types.RetrieveEntityScheduledTaskResponse `xml:"urn:vim25 RetrieveEntityScheduledTaskResponse,omitempty"` 13269 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13270} 13271 13272func (b *RetrieveEntityScheduledTaskBody) Fault() *soap.Fault { return b.Fault_ } 13273 13274func RetrieveEntityScheduledTask(ctx context.Context, r soap.RoundTripper, req *types.RetrieveEntityScheduledTask) (*types.RetrieveEntityScheduledTaskResponse, error) { 13275 var reqBody, resBody RetrieveEntityScheduledTaskBody 13276 13277 reqBody.Req = req 13278 13279 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13280 return nil, err 13281 } 13282 13283 return resBody.Res, nil 13284} 13285 13286type RetrieveHardwareUptimeBody struct { 13287 Req *types.RetrieveHardwareUptime `xml:"urn:vim25 RetrieveHardwareUptime,omitempty"` 13288 Res *types.RetrieveHardwareUptimeResponse `xml:"urn:vim25 RetrieveHardwareUptimeResponse,omitempty"` 13289 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13290} 13291 13292func (b *RetrieveHardwareUptimeBody) Fault() *soap.Fault { return b.Fault_ } 13293 13294func RetrieveHardwareUptime(ctx context.Context, r soap.RoundTripper, req *types.RetrieveHardwareUptime) (*types.RetrieveHardwareUptimeResponse, error) { 13295 var reqBody, resBody RetrieveHardwareUptimeBody 13296 13297 reqBody.Req = req 13298 13299 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13300 return nil, err 13301 } 13302 13303 return resBody.Res, nil 13304} 13305 13306type RetrieveHostAccessControlEntriesBody struct { 13307 Req *types.RetrieveHostAccessControlEntries `xml:"urn:vim25 RetrieveHostAccessControlEntries,omitempty"` 13308 Res *types.RetrieveHostAccessControlEntriesResponse `xml:"urn:vim25 RetrieveHostAccessControlEntriesResponse,omitempty"` 13309 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13310} 13311 13312func (b *RetrieveHostAccessControlEntriesBody) Fault() *soap.Fault { return b.Fault_ } 13313 13314func RetrieveHostAccessControlEntries(ctx context.Context, r soap.RoundTripper, req *types.RetrieveHostAccessControlEntries) (*types.RetrieveHostAccessControlEntriesResponse, error) { 13315 var reqBody, resBody RetrieveHostAccessControlEntriesBody 13316 13317 reqBody.Req = req 13318 13319 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13320 return nil, err 13321 } 13322 13323 return resBody.Res, nil 13324} 13325 13326type RetrieveHostCustomizationsBody struct { 13327 Req *types.RetrieveHostCustomizations `xml:"urn:vim25 RetrieveHostCustomizations,omitempty"` 13328 Res *types.RetrieveHostCustomizationsResponse `xml:"urn:vim25 RetrieveHostCustomizationsResponse,omitempty"` 13329 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13330} 13331 13332func (b *RetrieveHostCustomizationsBody) Fault() *soap.Fault { return b.Fault_ } 13333 13334func RetrieveHostCustomizations(ctx context.Context, r soap.RoundTripper, req *types.RetrieveHostCustomizations) (*types.RetrieveHostCustomizationsResponse, error) { 13335 var reqBody, resBody RetrieveHostCustomizationsBody 13336 13337 reqBody.Req = req 13338 13339 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13340 return nil, err 13341 } 13342 13343 return resBody.Res, nil 13344} 13345 13346type RetrieveHostCustomizationsForProfileBody struct { 13347 Req *types.RetrieveHostCustomizationsForProfile `xml:"urn:vim25 RetrieveHostCustomizationsForProfile,omitempty"` 13348 Res *types.RetrieveHostCustomizationsForProfileResponse `xml:"urn:vim25 RetrieveHostCustomizationsForProfileResponse,omitempty"` 13349 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13350} 13351 13352func (b *RetrieveHostCustomizationsForProfileBody) Fault() *soap.Fault { return b.Fault_ } 13353 13354func RetrieveHostCustomizationsForProfile(ctx context.Context, r soap.RoundTripper, req *types.RetrieveHostCustomizationsForProfile) (*types.RetrieveHostCustomizationsForProfileResponse, error) { 13355 var reqBody, resBody RetrieveHostCustomizationsForProfileBody 13356 13357 reqBody.Req = req 13358 13359 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13360 return nil, err 13361 } 13362 13363 return resBody.Res, nil 13364} 13365 13366type RetrieveHostSpecificationBody struct { 13367 Req *types.RetrieveHostSpecification `xml:"urn:vim25 RetrieveHostSpecification,omitempty"` 13368 Res *types.RetrieveHostSpecificationResponse `xml:"urn:vim25 RetrieveHostSpecificationResponse,omitempty"` 13369 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13370} 13371 13372func (b *RetrieveHostSpecificationBody) Fault() *soap.Fault { return b.Fault_ } 13373 13374func RetrieveHostSpecification(ctx context.Context, r soap.RoundTripper, req *types.RetrieveHostSpecification) (*types.RetrieveHostSpecificationResponse, error) { 13375 var reqBody, resBody RetrieveHostSpecificationBody 13376 13377 reqBody.Req = req 13378 13379 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13380 return nil, err 13381 } 13382 13383 return resBody.Res, nil 13384} 13385 13386type RetrieveKmipServerCertBody struct { 13387 Req *types.RetrieveKmipServerCert `xml:"urn:vim25 RetrieveKmipServerCert,omitempty"` 13388 Res *types.RetrieveKmipServerCertResponse `xml:"urn:vim25 RetrieveKmipServerCertResponse,omitempty"` 13389 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13390} 13391 13392func (b *RetrieveKmipServerCertBody) Fault() *soap.Fault { return b.Fault_ } 13393 13394func RetrieveKmipServerCert(ctx context.Context, r soap.RoundTripper, req *types.RetrieveKmipServerCert) (*types.RetrieveKmipServerCertResponse, error) { 13395 var reqBody, resBody RetrieveKmipServerCertBody 13396 13397 reqBody.Req = req 13398 13399 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13400 return nil, err 13401 } 13402 13403 return resBody.Res, nil 13404} 13405 13406type RetrieveKmipServersStatus_TaskBody struct { 13407 Req *types.RetrieveKmipServersStatus_Task `xml:"urn:vim25 RetrieveKmipServersStatus_Task,omitempty"` 13408 Res *types.RetrieveKmipServersStatus_TaskResponse `xml:"urn:vim25 RetrieveKmipServersStatus_TaskResponse,omitempty"` 13409 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13410} 13411 13412func (b *RetrieveKmipServersStatus_TaskBody) Fault() *soap.Fault { return b.Fault_ } 13413 13414func RetrieveKmipServersStatus_Task(ctx context.Context, r soap.RoundTripper, req *types.RetrieveKmipServersStatus_Task) (*types.RetrieveKmipServersStatus_TaskResponse, error) { 13415 var reqBody, resBody RetrieveKmipServersStatus_TaskBody 13416 13417 reqBody.Req = req 13418 13419 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13420 return nil, err 13421 } 13422 13423 return resBody.Res, nil 13424} 13425 13426type RetrieveObjectScheduledTaskBody struct { 13427 Req *types.RetrieveObjectScheduledTask `xml:"urn:vim25 RetrieveObjectScheduledTask,omitempty"` 13428 Res *types.RetrieveObjectScheduledTaskResponse `xml:"urn:vim25 RetrieveObjectScheduledTaskResponse,omitempty"` 13429 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13430} 13431 13432func (b *RetrieveObjectScheduledTaskBody) Fault() *soap.Fault { return b.Fault_ } 13433 13434func RetrieveObjectScheduledTask(ctx context.Context, r soap.RoundTripper, req *types.RetrieveObjectScheduledTask) (*types.RetrieveObjectScheduledTaskResponse, error) { 13435 var reqBody, resBody RetrieveObjectScheduledTaskBody 13436 13437 reqBody.Req = req 13438 13439 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13440 return nil, err 13441 } 13442 13443 return resBody.Res, nil 13444} 13445 13446type RetrieveProductComponentsBody struct { 13447 Req *types.RetrieveProductComponents `xml:"urn:vim25 RetrieveProductComponents,omitempty"` 13448 Res *types.RetrieveProductComponentsResponse `xml:"urn:vim25 RetrieveProductComponentsResponse,omitempty"` 13449 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13450} 13451 13452func (b *RetrieveProductComponentsBody) Fault() *soap.Fault { return b.Fault_ } 13453 13454func RetrieveProductComponents(ctx context.Context, r soap.RoundTripper, req *types.RetrieveProductComponents) (*types.RetrieveProductComponentsResponse, error) { 13455 var reqBody, resBody RetrieveProductComponentsBody 13456 13457 reqBody.Req = req 13458 13459 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13460 return nil, err 13461 } 13462 13463 return resBody.Res, nil 13464} 13465 13466type RetrievePropertiesBody struct { 13467 Req *types.RetrieveProperties `xml:"urn:vim25 RetrieveProperties,omitempty"` 13468 Res *types.RetrievePropertiesResponse `xml:"urn:vim25 RetrievePropertiesResponse,omitempty"` 13469 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13470} 13471 13472func (b *RetrievePropertiesBody) Fault() *soap.Fault { return b.Fault_ } 13473 13474func RetrieveProperties(ctx context.Context, r soap.RoundTripper, req *types.RetrieveProperties) (*types.RetrievePropertiesResponse, error) { 13475 var reqBody, resBody RetrievePropertiesBody 13476 13477 reqBody.Req = req 13478 13479 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13480 return nil, err 13481 } 13482 13483 return resBody.Res, nil 13484} 13485 13486type RetrievePropertiesExBody struct { 13487 Req *types.RetrievePropertiesEx `xml:"urn:vim25 RetrievePropertiesEx,omitempty"` 13488 Res *types.RetrievePropertiesExResponse `xml:"urn:vim25 RetrievePropertiesExResponse,omitempty"` 13489 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13490} 13491 13492func (b *RetrievePropertiesExBody) Fault() *soap.Fault { return b.Fault_ } 13493 13494func RetrievePropertiesEx(ctx context.Context, r soap.RoundTripper, req *types.RetrievePropertiesEx) (*types.RetrievePropertiesExResponse, error) { 13495 var reqBody, resBody RetrievePropertiesExBody 13496 13497 reqBody.Req = req 13498 13499 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13500 return nil, err 13501 } 13502 13503 return resBody.Res, nil 13504} 13505 13506type RetrieveRolePermissionsBody struct { 13507 Req *types.RetrieveRolePermissions `xml:"urn:vim25 RetrieveRolePermissions,omitempty"` 13508 Res *types.RetrieveRolePermissionsResponse `xml:"urn:vim25 RetrieveRolePermissionsResponse,omitempty"` 13509 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13510} 13511 13512func (b *RetrieveRolePermissionsBody) Fault() *soap.Fault { return b.Fault_ } 13513 13514func RetrieveRolePermissions(ctx context.Context, r soap.RoundTripper, req *types.RetrieveRolePermissions) (*types.RetrieveRolePermissionsResponse, error) { 13515 var reqBody, resBody RetrieveRolePermissionsBody 13516 13517 reqBody.Req = req 13518 13519 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13520 return nil, err 13521 } 13522 13523 return resBody.Res, nil 13524} 13525 13526type RetrieveSelfSignedClientCertBody struct { 13527 Req *types.RetrieveSelfSignedClientCert `xml:"urn:vim25 RetrieveSelfSignedClientCert,omitempty"` 13528 Res *types.RetrieveSelfSignedClientCertResponse `xml:"urn:vim25 RetrieveSelfSignedClientCertResponse,omitempty"` 13529 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13530} 13531 13532func (b *RetrieveSelfSignedClientCertBody) Fault() *soap.Fault { return b.Fault_ } 13533 13534func RetrieveSelfSignedClientCert(ctx context.Context, r soap.RoundTripper, req *types.RetrieveSelfSignedClientCert) (*types.RetrieveSelfSignedClientCertResponse, error) { 13535 var reqBody, resBody RetrieveSelfSignedClientCertBody 13536 13537 reqBody.Req = req 13538 13539 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13540 return nil, err 13541 } 13542 13543 return resBody.Res, nil 13544} 13545 13546type RetrieveServiceContentBody struct { 13547 Req *types.RetrieveServiceContent `xml:"urn:vim25 RetrieveServiceContent,omitempty"` 13548 Res *types.RetrieveServiceContentResponse `xml:"urn:vim25 RetrieveServiceContentResponse,omitempty"` 13549 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13550} 13551 13552func (b *RetrieveServiceContentBody) Fault() *soap.Fault { return b.Fault_ } 13553 13554func RetrieveServiceContent(ctx context.Context, r soap.RoundTripper, req *types.RetrieveServiceContent) (*types.RetrieveServiceContentResponse, error) { 13555 var reqBody, resBody RetrieveServiceContentBody 13556 13557 reqBody.Req = req 13558 13559 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13560 return nil, err 13561 } 13562 13563 return resBody.Res, nil 13564} 13565 13566type RetrieveSnapshotInfoBody struct { 13567 Req *types.RetrieveSnapshotInfo `xml:"urn:vim25 RetrieveSnapshotInfo,omitempty"` 13568 Res *types.RetrieveSnapshotInfoResponse `xml:"urn:vim25 RetrieveSnapshotInfoResponse,omitempty"` 13569 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13570} 13571 13572func (b *RetrieveSnapshotInfoBody) Fault() *soap.Fault { return b.Fault_ } 13573 13574func RetrieveSnapshotInfo(ctx context.Context, r soap.RoundTripper, req *types.RetrieveSnapshotInfo) (*types.RetrieveSnapshotInfoResponse, error) { 13575 var reqBody, resBody RetrieveSnapshotInfoBody 13576 13577 reqBody.Req = req 13578 13579 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13580 return nil, err 13581 } 13582 13583 return resBody.Res, nil 13584} 13585 13586type RetrieveUserGroupsBody struct { 13587 Req *types.RetrieveUserGroups `xml:"urn:vim25 RetrieveUserGroups,omitempty"` 13588 Res *types.RetrieveUserGroupsResponse `xml:"urn:vim25 RetrieveUserGroupsResponse,omitempty"` 13589 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13590} 13591 13592func (b *RetrieveUserGroupsBody) Fault() *soap.Fault { return b.Fault_ } 13593 13594func RetrieveUserGroups(ctx context.Context, r soap.RoundTripper, req *types.RetrieveUserGroups) (*types.RetrieveUserGroupsResponse, error) { 13595 var reqBody, resBody RetrieveUserGroupsBody 13596 13597 reqBody.Req = req 13598 13599 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13600 return nil, err 13601 } 13602 13603 return resBody.Res, nil 13604} 13605 13606type RetrieveVStorageInfrastructureObjectPolicyBody struct { 13607 Req *types.RetrieveVStorageInfrastructureObjectPolicy `xml:"urn:vim25 RetrieveVStorageInfrastructureObjectPolicy,omitempty"` 13608 Res *types.RetrieveVStorageInfrastructureObjectPolicyResponse `xml:"urn:vim25 RetrieveVStorageInfrastructureObjectPolicyResponse,omitempty"` 13609 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13610} 13611 13612func (b *RetrieveVStorageInfrastructureObjectPolicyBody) Fault() *soap.Fault { return b.Fault_ } 13613 13614func RetrieveVStorageInfrastructureObjectPolicy(ctx context.Context, r soap.RoundTripper, req *types.RetrieveVStorageInfrastructureObjectPolicy) (*types.RetrieveVStorageInfrastructureObjectPolicyResponse, error) { 13615 var reqBody, resBody RetrieveVStorageInfrastructureObjectPolicyBody 13616 13617 reqBody.Req = req 13618 13619 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13620 return nil, err 13621 } 13622 13623 return resBody.Res, nil 13624} 13625 13626type RetrieveVStorageObjectBody struct { 13627 Req *types.RetrieveVStorageObject `xml:"urn:vim25 RetrieveVStorageObject,omitempty"` 13628 Res *types.RetrieveVStorageObjectResponse `xml:"urn:vim25 RetrieveVStorageObjectResponse,omitempty"` 13629 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13630} 13631 13632func (b *RetrieveVStorageObjectBody) Fault() *soap.Fault { return b.Fault_ } 13633 13634func RetrieveVStorageObject(ctx context.Context, r soap.RoundTripper, req *types.RetrieveVStorageObject) (*types.RetrieveVStorageObjectResponse, error) { 13635 var reqBody, resBody RetrieveVStorageObjectBody 13636 13637 reqBody.Req = req 13638 13639 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13640 return nil, err 13641 } 13642 13643 return resBody.Res, nil 13644} 13645 13646type RetrieveVStorageObjectAssociationsBody struct { 13647 Req *types.RetrieveVStorageObjectAssociations `xml:"urn:vim25 RetrieveVStorageObjectAssociations,omitempty"` 13648 Res *types.RetrieveVStorageObjectAssociationsResponse `xml:"urn:vim25 RetrieveVStorageObjectAssociationsResponse,omitempty"` 13649 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13650} 13651 13652func (b *RetrieveVStorageObjectAssociationsBody) Fault() *soap.Fault { return b.Fault_ } 13653 13654func RetrieveVStorageObjectAssociations(ctx context.Context, r soap.RoundTripper, req *types.RetrieveVStorageObjectAssociations) (*types.RetrieveVStorageObjectAssociationsResponse, error) { 13655 var reqBody, resBody RetrieveVStorageObjectAssociationsBody 13656 13657 reqBody.Req = req 13658 13659 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13660 return nil, err 13661 } 13662 13663 return resBody.Res, nil 13664} 13665 13666type RetrieveVStorageObjectStateBody struct { 13667 Req *types.RetrieveVStorageObjectState `xml:"urn:vim25 RetrieveVStorageObjectState,omitempty"` 13668 Res *types.RetrieveVStorageObjectStateResponse `xml:"urn:vim25 RetrieveVStorageObjectStateResponse,omitempty"` 13669 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13670} 13671 13672func (b *RetrieveVStorageObjectStateBody) Fault() *soap.Fault { return b.Fault_ } 13673 13674func RetrieveVStorageObjectState(ctx context.Context, r soap.RoundTripper, req *types.RetrieveVStorageObjectState) (*types.RetrieveVStorageObjectStateResponse, error) { 13675 var reqBody, resBody RetrieveVStorageObjectStateBody 13676 13677 reqBody.Req = req 13678 13679 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13680 return nil, err 13681 } 13682 13683 return resBody.Res, nil 13684} 13685 13686type RevertToCurrentSnapshot_TaskBody struct { 13687 Req *types.RevertToCurrentSnapshot_Task `xml:"urn:vim25 RevertToCurrentSnapshot_Task,omitempty"` 13688 Res *types.RevertToCurrentSnapshot_TaskResponse `xml:"urn:vim25 RevertToCurrentSnapshot_TaskResponse,omitempty"` 13689 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13690} 13691 13692func (b *RevertToCurrentSnapshot_TaskBody) Fault() *soap.Fault { return b.Fault_ } 13693 13694func RevertToCurrentSnapshot_Task(ctx context.Context, r soap.RoundTripper, req *types.RevertToCurrentSnapshot_Task) (*types.RevertToCurrentSnapshot_TaskResponse, error) { 13695 var reqBody, resBody RevertToCurrentSnapshot_TaskBody 13696 13697 reqBody.Req = req 13698 13699 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13700 return nil, err 13701 } 13702 13703 return resBody.Res, nil 13704} 13705 13706type RevertToSnapshot_TaskBody struct { 13707 Req *types.RevertToSnapshot_Task `xml:"urn:vim25 RevertToSnapshot_Task,omitempty"` 13708 Res *types.RevertToSnapshot_TaskResponse `xml:"urn:vim25 RevertToSnapshot_TaskResponse,omitempty"` 13709 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13710} 13711 13712func (b *RevertToSnapshot_TaskBody) Fault() *soap.Fault { return b.Fault_ } 13713 13714func RevertToSnapshot_Task(ctx context.Context, r soap.RoundTripper, req *types.RevertToSnapshot_Task) (*types.RevertToSnapshot_TaskResponse, error) { 13715 var reqBody, resBody RevertToSnapshot_TaskBody 13716 13717 reqBody.Req = req 13718 13719 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13720 return nil, err 13721 } 13722 13723 return resBody.Res, nil 13724} 13725 13726type RevertVStorageObject_TaskBody struct { 13727 Req *types.RevertVStorageObject_Task `xml:"urn:vim25 RevertVStorageObject_Task,omitempty"` 13728 Res *types.RevertVStorageObject_TaskResponse `xml:"urn:vim25 RevertVStorageObject_TaskResponse,omitempty"` 13729 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13730} 13731 13732func (b *RevertVStorageObject_TaskBody) Fault() *soap.Fault { return b.Fault_ } 13733 13734func RevertVStorageObject_Task(ctx context.Context, r soap.RoundTripper, req *types.RevertVStorageObject_Task) (*types.RevertVStorageObject_TaskResponse, error) { 13735 var reqBody, resBody RevertVStorageObject_TaskBody 13736 13737 reqBody.Req = req 13738 13739 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13740 return nil, err 13741 } 13742 13743 return resBody.Res, nil 13744} 13745 13746type RewindCollectorBody struct { 13747 Req *types.RewindCollector `xml:"urn:vim25 RewindCollector,omitempty"` 13748 Res *types.RewindCollectorResponse `xml:"urn:vim25 RewindCollectorResponse,omitempty"` 13749 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13750} 13751 13752func (b *RewindCollectorBody) Fault() *soap.Fault { return b.Fault_ } 13753 13754func RewindCollector(ctx context.Context, r soap.RoundTripper, req *types.RewindCollector) (*types.RewindCollectorResponse, error) { 13755 var reqBody, resBody RewindCollectorBody 13756 13757 reqBody.Req = req 13758 13759 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13760 return nil, err 13761 } 13762 13763 return resBody.Res, nil 13764} 13765 13766type RunScheduledTaskBody struct { 13767 Req *types.RunScheduledTask `xml:"urn:vim25 RunScheduledTask,omitempty"` 13768 Res *types.RunScheduledTaskResponse `xml:"urn:vim25 RunScheduledTaskResponse,omitempty"` 13769 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13770} 13771 13772func (b *RunScheduledTaskBody) Fault() *soap.Fault { return b.Fault_ } 13773 13774func RunScheduledTask(ctx context.Context, r soap.RoundTripper, req *types.RunScheduledTask) (*types.RunScheduledTaskResponse, error) { 13775 var reqBody, resBody RunScheduledTaskBody 13776 13777 reqBody.Req = req 13778 13779 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13780 return nil, err 13781 } 13782 13783 return resBody.Res, nil 13784} 13785 13786type RunVsanPhysicalDiskDiagnosticsBody struct { 13787 Req *types.RunVsanPhysicalDiskDiagnostics `xml:"urn:vim25 RunVsanPhysicalDiskDiagnostics,omitempty"` 13788 Res *types.RunVsanPhysicalDiskDiagnosticsResponse `xml:"urn:vim25 RunVsanPhysicalDiskDiagnosticsResponse,omitempty"` 13789 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13790} 13791 13792func (b *RunVsanPhysicalDiskDiagnosticsBody) Fault() *soap.Fault { return b.Fault_ } 13793 13794func RunVsanPhysicalDiskDiagnostics(ctx context.Context, r soap.RoundTripper, req *types.RunVsanPhysicalDiskDiagnostics) (*types.RunVsanPhysicalDiskDiagnosticsResponse, error) { 13795 var reqBody, resBody RunVsanPhysicalDiskDiagnosticsBody 13796 13797 reqBody.Req = req 13798 13799 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13800 return nil, err 13801 } 13802 13803 return resBody.Res, nil 13804} 13805 13806type ScanHostPatchV2_TaskBody struct { 13807 Req *types.ScanHostPatchV2_Task `xml:"urn:vim25 ScanHostPatchV2_Task,omitempty"` 13808 Res *types.ScanHostPatchV2_TaskResponse `xml:"urn:vim25 ScanHostPatchV2_TaskResponse,omitempty"` 13809 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13810} 13811 13812func (b *ScanHostPatchV2_TaskBody) Fault() *soap.Fault { return b.Fault_ } 13813 13814func ScanHostPatchV2_Task(ctx context.Context, r soap.RoundTripper, req *types.ScanHostPatchV2_Task) (*types.ScanHostPatchV2_TaskResponse, error) { 13815 var reqBody, resBody ScanHostPatchV2_TaskBody 13816 13817 reqBody.Req = req 13818 13819 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13820 return nil, err 13821 } 13822 13823 return resBody.Res, nil 13824} 13825 13826type ScanHostPatch_TaskBody struct { 13827 Req *types.ScanHostPatch_Task `xml:"urn:vim25 ScanHostPatch_Task,omitempty"` 13828 Res *types.ScanHostPatch_TaskResponse `xml:"urn:vim25 ScanHostPatch_TaskResponse,omitempty"` 13829 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13830} 13831 13832func (b *ScanHostPatch_TaskBody) Fault() *soap.Fault { return b.Fault_ } 13833 13834func ScanHostPatch_Task(ctx context.Context, r soap.RoundTripper, req *types.ScanHostPatch_Task) (*types.ScanHostPatch_TaskResponse, error) { 13835 var reqBody, resBody ScanHostPatch_TaskBody 13836 13837 reqBody.Req = req 13838 13839 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13840 return nil, err 13841 } 13842 13843 return resBody.Res, nil 13844} 13845 13846type ScheduleReconcileDatastoreInventoryBody struct { 13847 Req *types.ScheduleReconcileDatastoreInventory `xml:"urn:vim25 ScheduleReconcileDatastoreInventory,omitempty"` 13848 Res *types.ScheduleReconcileDatastoreInventoryResponse `xml:"urn:vim25 ScheduleReconcileDatastoreInventoryResponse,omitempty"` 13849 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13850} 13851 13852func (b *ScheduleReconcileDatastoreInventoryBody) Fault() *soap.Fault { return b.Fault_ } 13853 13854func ScheduleReconcileDatastoreInventory(ctx context.Context, r soap.RoundTripper, req *types.ScheduleReconcileDatastoreInventory) (*types.ScheduleReconcileDatastoreInventoryResponse, error) { 13855 var reqBody, resBody ScheduleReconcileDatastoreInventoryBody 13856 13857 reqBody.Req = req 13858 13859 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13860 return nil, err 13861 } 13862 13863 return resBody.Res, nil 13864} 13865 13866type SearchDatastoreSubFolders_TaskBody struct { 13867 Req *types.SearchDatastoreSubFolders_Task `xml:"urn:vim25 SearchDatastoreSubFolders_Task,omitempty"` 13868 Res *types.SearchDatastoreSubFolders_TaskResponse `xml:"urn:vim25 SearchDatastoreSubFolders_TaskResponse,omitempty"` 13869 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13870} 13871 13872func (b *SearchDatastoreSubFolders_TaskBody) Fault() *soap.Fault { return b.Fault_ } 13873 13874func SearchDatastoreSubFolders_Task(ctx context.Context, r soap.RoundTripper, req *types.SearchDatastoreSubFolders_Task) (*types.SearchDatastoreSubFolders_TaskResponse, error) { 13875 var reqBody, resBody SearchDatastoreSubFolders_TaskBody 13876 13877 reqBody.Req = req 13878 13879 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13880 return nil, err 13881 } 13882 13883 return resBody.Res, nil 13884} 13885 13886type SearchDatastore_TaskBody struct { 13887 Req *types.SearchDatastore_Task `xml:"urn:vim25 SearchDatastore_Task,omitempty"` 13888 Res *types.SearchDatastore_TaskResponse `xml:"urn:vim25 SearchDatastore_TaskResponse,omitempty"` 13889 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13890} 13891 13892func (b *SearchDatastore_TaskBody) Fault() *soap.Fault { return b.Fault_ } 13893 13894func SearchDatastore_Task(ctx context.Context, r soap.RoundTripper, req *types.SearchDatastore_Task) (*types.SearchDatastore_TaskResponse, error) { 13895 var reqBody, resBody SearchDatastore_TaskBody 13896 13897 reqBody.Req = req 13898 13899 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13900 return nil, err 13901 } 13902 13903 return resBody.Res, nil 13904} 13905 13906type SelectActivePartitionBody struct { 13907 Req *types.SelectActivePartition `xml:"urn:vim25 SelectActivePartition,omitempty"` 13908 Res *types.SelectActivePartitionResponse `xml:"urn:vim25 SelectActivePartitionResponse,omitempty"` 13909 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13910} 13911 13912func (b *SelectActivePartitionBody) Fault() *soap.Fault { return b.Fault_ } 13913 13914func SelectActivePartition(ctx context.Context, r soap.RoundTripper, req *types.SelectActivePartition) (*types.SelectActivePartitionResponse, error) { 13915 var reqBody, resBody SelectActivePartitionBody 13916 13917 reqBody.Req = req 13918 13919 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13920 return nil, err 13921 } 13922 13923 return resBody.Res, nil 13924} 13925 13926type SelectVnicBody struct { 13927 Req *types.SelectVnic `xml:"urn:vim25 SelectVnic,omitempty"` 13928 Res *types.SelectVnicResponse `xml:"urn:vim25 SelectVnicResponse,omitempty"` 13929 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13930} 13931 13932func (b *SelectVnicBody) Fault() *soap.Fault { return b.Fault_ } 13933 13934func SelectVnic(ctx context.Context, r soap.RoundTripper, req *types.SelectVnic) (*types.SelectVnicResponse, error) { 13935 var reqBody, resBody SelectVnicBody 13936 13937 reqBody.Req = req 13938 13939 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13940 return nil, err 13941 } 13942 13943 return resBody.Res, nil 13944} 13945 13946type SelectVnicForNicTypeBody struct { 13947 Req *types.SelectVnicForNicType `xml:"urn:vim25 SelectVnicForNicType,omitempty"` 13948 Res *types.SelectVnicForNicTypeResponse `xml:"urn:vim25 SelectVnicForNicTypeResponse,omitempty"` 13949 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13950} 13951 13952func (b *SelectVnicForNicTypeBody) Fault() *soap.Fault { return b.Fault_ } 13953 13954func SelectVnicForNicType(ctx context.Context, r soap.RoundTripper, req *types.SelectVnicForNicType) (*types.SelectVnicForNicTypeResponse, error) { 13955 var reqBody, resBody SelectVnicForNicTypeBody 13956 13957 reqBody.Req = req 13958 13959 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13960 return nil, err 13961 } 13962 13963 return resBody.Res, nil 13964} 13965 13966type SendNMIBody struct { 13967 Req *types.SendNMI `xml:"urn:vim25 SendNMI,omitempty"` 13968 Res *types.SendNMIResponse `xml:"urn:vim25 SendNMIResponse,omitempty"` 13969 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13970} 13971 13972func (b *SendNMIBody) Fault() *soap.Fault { return b.Fault_ } 13973 13974func SendNMI(ctx context.Context, r soap.RoundTripper, req *types.SendNMI) (*types.SendNMIResponse, error) { 13975 var reqBody, resBody SendNMIBody 13976 13977 reqBody.Req = req 13978 13979 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 13980 return nil, err 13981 } 13982 13983 return resBody.Res, nil 13984} 13985 13986type SendTestNotificationBody struct { 13987 Req *types.SendTestNotification `xml:"urn:vim25 SendTestNotification,omitempty"` 13988 Res *types.SendTestNotificationResponse `xml:"urn:vim25 SendTestNotificationResponse,omitempty"` 13989 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 13990} 13991 13992func (b *SendTestNotificationBody) Fault() *soap.Fault { return b.Fault_ } 13993 13994func SendTestNotification(ctx context.Context, r soap.RoundTripper, req *types.SendTestNotification) (*types.SendTestNotificationResponse, error) { 13995 var reqBody, resBody SendTestNotificationBody 13996 13997 reqBody.Req = req 13998 13999 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14000 return nil, err 14001 } 14002 14003 return resBody.Res, nil 14004} 14005 14006type SessionIsActiveBody struct { 14007 Req *types.SessionIsActive `xml:"urn:vim25 SessionIsActive,omitempty"` 14008 Res *types.SessionIsActiveResponse `xml:"urn:vim25 SessionIsActiveResponse,omitempty"` 14009 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14010} 14011 14012func (b *SessionIsActiveBody) Fault() *soap.Fault { return b.Fault_ } 14013 14014func SessionIsActive(ctx context.Context, r soap.RoundTripper, req *types.SessionIsActive) (*types.SessionIsActiveResponse, error) { 14015 var reqBody, resBody SessionIsActiveBody 14016 14017 reqBody.Req = req 14018 14019 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14020 return nil, err 14021 } 14022 14023 return resBody.Res, nil 14024} 14025 14026type SetCollectorPageSizeBody struct { 14027 Req *types.SetCollectorPageSize `xml:"urn:vim25 SetCollectorPageSize,omitempty"` 14028 Res *types.SetCollectorPageSizeResponse `xml:"urn:vim25 SetCollectorPageSizeResponse,omitempty"` 14029 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14030} 14031 14032func (b *SetCollectorPageSizeBody) Fault() *soap.Fault { return b.Fault_ } 14033 14034func SetCollectorPageSize(ctx context.Context, r soap.RoundTripper, req *types.SetCollectorPageSize) (*types.SetCollectorPageSizeResponse, error) { 14035 var reqBody, resBody SetCollectorPageSizeBody 14036 14037 reqBody.Req = req 14038 14039 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14040 return nil, err 14041 } 14042 14043 return resBody.Res, nil 14044} 14045 14046type SetDisplayTopologyBody struct { 14047 Req *types.SetDisplayTopology `xml:"urn:vim25 SetDisplayTopology,omitempty"` 14048 Res *types.SetDisplayTopologyResponse `xml:"urn:vim25 SetDisplayTopologyResponse,omitempty"` 14049 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14050} 14051 14052func (b *SetDisplayTopologyBody) Fault() *soap.Fault { return b.Fault_ } 14053 14054func SetDisplayTopology(ctx context.Context, r soap.RoundTripper, req *types.SetDisplayTopology) (*types.SetDisplayTopologyResponse, error) { 14055 var reqBody, resBody SetDisplayTopologyBody 14056 14057 reqBody.Req = req 14058 14059 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14060 return nil, err 14061 } 14062 14063 return resBody.Res, nil 14064} 14065 14066type SetEntityPermissionsBody struct { 14067 Req *types.SetEntityPermissions `xml:"urn:vim25 SetEntityPermissions,omitempty"` 14068 Res *types.SetEntityPermissionsResponse `xml:"urn:vim25 SetEntityPermissionsResponse,omitempty"` 14069 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14070} 14071 14072func (b *SetEntityPermissionsBody) Fault() *soap.Fault { return b.Fault_ } 14073 14074func SetEntityPermissions(ctx context.Context, r soap.RoundTripper, req *types.SetEntityPermissions) (*types.SetEntityPermissionsResponse, error) { 14075 var reqBody, resBody SetEntityPermissionsBody 14076 14077 reqBody.Req = req 14078 14079 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14080 return nil, err 14081 } 14082 14083 return resBody.Res, nil 14084} 14085 14086type SetExtensionCertificateBody struct { 14087 Req *types.SetExtensionCertificate `xml:"urn:vim25 SetExtensionCertificate,omitempty"` 14088 Res *types.SetExtensionCertificateResponse `xml:"urn:vim25 SetExtensionCertificateResponse,omitempty"` 14089 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14090} 14091 14092func (b *SetExtensionCertificateBody) Fault() *soap.Fault { return b.Fault_ } 14093 14094func SetExtensionCertificate(ctx context.Context, r soap.RoundTripper, req *types.SetExtensionCertificate) (*types.SetExtensionCertificateResponse, error) { 14095 var reqBody, resBody SetExtensionCertificateBody 14096 14097 reqBody.Req = req 14098 14099 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14100 return nil, err 14101 } 14102 14103 return resBody.Res, nil 14104} 14105 14106type SetFieldBody struct { 14107 Req *types.SetField `xml:"urn:vim25 SetField,omitempty"` 14108 Res *types.SetFieldResponse `xml:"urn:vim25 SetFieldResponse,omitempty"` 14109 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14110} 14111 14112func (b *SetFieldBody) Fault() *soap.Fault { return b.Fault_ } 14113 14114func SetField(ctx context.Context, r soap.RoundTripper, req *types.SetField) (*types.SetFieldResponse, error) { 14115 var reqBody, resBody SetFieldBody 14116 14117 reqBody.Req = req 14118 14119 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14120 return nil, err 14121 } 14122 14123 return resBody.Res, nil 14124} 14125 14126type SetLicenseEditionBody struct { 14127 Req *types.SetLicenseEdition `xml:"urn:vim25 SetLicenseEdition,omitempty"` 14128 Res *types.SetLicenseEditionResponse `xml:"urn:vim25 SetLicenseEditionResponse,omitempty"` 14129 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14130} 14131 14132func (b *SetLicenseEditionBody) Fault() *soap.Fault { return b.Fault_ } 14133 14134func SetLicenseEdition(ctx context.Context, r soap.RoundTripper, req *types.SetLicenseEdition) (*types.SetLicenseEditionResponse, error) { 14135 var reqBody, resBody SetLicenseEditionBody 14136 14137 reqBody.Req = req 14138 14139 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14140 return nil, err 14141 } 14142 14143 return resBody.Res, nil 14144} 14145 14146type SetLocaleBody struct { 14147 Req *types.SetLocale `xml:"urn:vim25 SetLocale,omitempty"` 14148 Res *types.SetLocaleResponse `xml:"urn:vim25 SetLocaleResponse,omitempty"` 14149 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14150} 14151 14152func (b *SetLocaleBody) Fault() *soap.Fault { return b.Fault_ } 14153 14154func SetLocale(ctx context.Context, r soap.RoundTripper, req *types.SetLocale) (*types.SetLocaleResponse, error) { 14155 var reqBody, resBody SetLocaleBody 14156 14157 reqBody.Req = req 14158 14159 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14160 return nil, err 14161 } 14162 14163 return resBody.Res, nil 14164} 14165 14166type SetMultipathLunPolicyBody struct { 14167 Req *types.SetMultipathLunPolicy `xml:"urn:vim25 SetMultipathLunPolicy,omitempty"` 14168 Res *types.SetMultipathLunPolicyResponse `xml:"urn:vim25 SetMultipathLunPolicyResponse,omitempty"` 14169 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14170} 14171 14172func (b *SetMultipathLunPolicyBody) Fault() *soap.Fault { return b.Fault_ } 14173 14174func SetMultipathLunPolicy(ctx context.Context, r soap.RoundTripper, req *types.SetMultipathLunPolicy) (*types.SetMultipathLunPolicyResponse, error) { 14175 var reqBody, resBody SetMultipathLunPolicyBody 14176 14177 reqBody.Req = req 14178 14179 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14180 return nil, err 14181 } 14182 14183 return resBody.Res, nil 14184} 14185 14186type SetNFSUserBody struct { 14187 Req *types.SetNFSUser `xml:"urn:vim25 SetNFSUser,omitempty"` 14188 Res *types.SetNFSUserResponse `xml:"urn:vim25 SetNFSUserResponse,omitempty"` 14189 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14190} 14191 14192func (b *SetNFSUserBody) Fault() *soap.Fault { return b.Fault_ } 14193 14194func SetNFSUser(ctx context.Context, r soap.RoundTripper, req *types.SetNFSUser) (*types.SetNFSUserResponse, error) { 14195 var reqBody, resBody SetNFSUserBody 14196 14197 reqBody.Req = req 14198 14199 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14200 return nil, err 14201 } 14202 14203 return resBody.Res, nil 14204} 14205 14206type SetPublicKeyBody struct { 14207 Req *types.SetPublicKey `xml:"urn:vim25 SetPublicKey,omitempty"` 14208 Res *types.SetPublicKeyResponse `xml:"urn:vim25 SetPublicKeyResponse,omitempty"` 14209 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14210} 14211 14212func (b *SetPublicKeyBody) Fault() *soap.Fault { return b.Fault_ } 14213 14214func SetPublicKey(ctx context.Context, r soap.RoundTripper, req *types.SetPublicKey) (*types.SetPublicKeyResponse, error) { 14215 var reqBody, resBody SetPublicKeyBody 14216 14217 reqBody.Req = req 14218 14219 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14220 return nil, err 14221 } 14222 14223 return resBody.Res, nil 14224} 14225 14226type SetRegistryValueInGuestBody struct { 14227 Req *types.SetRegistryValueInGuest `xml:"urn:vim25 SetRegistryValueInGuest,omitempty"` 14228 Res *types.SetRegistryValueInGuestResponse `xml:"urn:vim25 SetRegistryValueInGuestResponse,omitempty"` 14229 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14230} 14231 14232func (b *SetRegistryValueInGuestBody) Fault() *soap.Fault { return b.Fault_ } 14233 14234func SetRegistryValueInGuest(ctx context.Context, r soap.RoundTripper, req *types.SetRegistryValueInGuest) (*types.SetRegistryValueInGuestResponse, error) { 14235 var reqBody, resBody SetRegistryValueInGuestBody 14236 14237 reqBody.Req = req 14238 14239 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14240 return nil, err 14241 } 14242 14243 return resBody.Res, nil 14244} 14245 14246type SetScreenResolutionBody struct { 14247 Req *types.SetScreenResolution `xml:"urn:vim25 SetScreenResolution,omitempty"` 14248 Res *types.SetScreenResolutionResponse `xml:"urn:vim25 SetScreenResolutionResponse,omitempty"` 14249 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14250} 14251 14252func (b *SetScreenResolutionBody) Fault() *soap.Fault { return b.Fault_ } 14253 14254func SetScreenResolution(ctx context.Context, r soap.RoundTripper, req *types.SetScreenResolution) (*types.SetScreenResolutionResponse, error) { 14255 var reqBody, resBody SetScreenResolutionBody 14256 14257 reqBody.Req = req 14258 14259 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14260 return nil, err 14261 } 14262 14263 return resBody.Res, nil 14264} 14265 14266type SetTaskDescriptionBody struct { 14267 Req *types.SetTaskDescription `xml:"urn:vim25 SetTaskDescription,omitempty"` 14268 Res *types.SetTaskDescriptionResponse `xml:"urn:vim25 SetTaskDescriptionResponse,omitempty"` 14269 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14270} 14271 14272func (b *SetTaskDescriptionBody) Fault() *soap.Fault { return b.Fault_ } 14273 14274func SetTaskDescription(ctx context.Context, r soap.RoundTripper, req *types.SetTaskDescription) (*types.SetTaskDescriptionResponse, error) { 14275 var reqBody, resBody SetTaskDescriptionBody 14276 14277 reqBody.Req = req 14278 14279 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14280 return nil, err 14281 } 14282 14283 return resBody.Res, nil 14284} 14285 14286type SetTaskStateBody struct { 14287 Req *types.SetTaskState `xml:"urn:vim25 SetTaskState,omitempty"` 14288 Res *types.SetTaskStateResponse `xml:"urn:vim25 SetTaskStateResponse,omitempty"` 14289 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14290} 14291 14292func (b *SetTaskStateBody) Fault() *soap.Fault { return b.Fault_ } 14293 14294func SetTaskState(ctx context.Context, r soap.RoundTripper, req *types.SetTaskState) (*types.SetTaskStateResponse, error) { 14295 var reqBody, resBody SetTaskStateBody 14296 14297 reqBody.Req = req 14298 14299 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14300 return nil, err 14301 } 14302 14303 return resBody.Res, nil 14304} 14305 14306type SetVStorageObjectControlFlagsBody struct { 14307 Req *types.SetVStorageObjectControlFlags `xml:"urn:vim25 SetVStorageObjectControlFlags,omitempty"` 14308 Res *types.SetVStorageObjectControlFlagsResponse `xml:"urn:vim25 SetVStorageObjectControlFlagsResponse,omitempty"` 14309 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14310} 14311 14312func (b *SetVStorageObjectControlFlagsBody) Fault() *soap.Fault { return b.Fault_ } 14313 14314func SetVStorageObjectControlFlags(ctx context.Context, r soap.RoundTripper, req *types.SetVStorageObjectControlFlags) (*types.SetVStorageObjectControlFlagsResponse, error) { 14315 var reqBody, resBody SetVStorageObjectControlFlagsBody 14316 14317 reqBody.Req = req 14318 14319 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14320 return nil, err 14321 } 14322 14323 return resBody.Res, nil 14324} 14325 14326type SetVirtualDiskUuidBody struct { 14327 Req *types.SetVirtualDiskUuid `xml:"urn:vim25 SetVirtualDiskUuid,omitempty"` 14328 Res *types.SetVirtualDiskUuidResponse `xml:"urn:vim25 SetVirtualDiskUuidResponse,omitempty"` 14329 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14330} 14331 14332func (b *SetVirtualDiskUuidBody) Fault() *soap.Fault { return b.Fault_ } 14333 14334func SetVirtualDiskUuid(ctx context.Context, r soap.RoundTripper, req *types.SetVirtualDiskUuid) (*types.SetVirtualDiskUuidResponse, error) { 14335 var reqBody, resBody SetVirtualDiskUuidBody 14336 14337 reqBody.Req = req 14338 14339 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14340 return nil, err 14341 } 14342 14343 return resBody.Res, nil 14344} 14345 14346type ShrinkVirtualDisk_TaskBody struct { 14347 Req *types.ShrinkVirtualDisk_Task `xml:"urn:vim25 ShrinkVirtualDisk_Task,omitempty"` 14348 Res *types.ShrinkVirtualDisk_TaskResponse `xml:"urn:vim25 ShrinkVirtualDisk_TaskResponse,omitempty"` 14349 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14350} 14351 14352func (b *ShrinkVirtualDisk_TaskBody) Fault() *soap.Fault { return b.Fault_ } 14353 14354func ShrinkVirtualDisk_Task(ctx context.Context, r soap.RoundTripper, req *types.ShrinkVirtualDisk_Task) (*types.ShrinkVirtualDisk_TaskResponse, error) { 14355 var reqBody, resBody ShrinkVirtualDisk_TaskBody 14356 14357 reqBody.Req = req 14358 14359 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14360 return nil, err 14361 } 14362 14363 return resBody.Res, nil 14364} 14365 14366type ShutdownGuestBody struct { 14367 Req *types.ShutdownGuest `xml:"urn:vim25 ShutdownGuest,omitempty"` 14368 Res *types.ShutdownGuestResponse `xml:"urn:vim25 ShutdownGuestResponse,omitempty"` 14369 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14370} 14371 14372func (b *ShutdownGuestBody) Fault() *soap.Fault { return b.Fault_ } 14373 14374func ShutdownGuest(ctx context.Context, r soap.RoundTripper, req *types.ShutdownGuest) (*types.ShutdownGuestResponse, error) { 14375 var reqBody, resBody ShutdownGuestBody 14376 14377 reqBody.Req = req 14378 14379 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14380 return nil, err 14381 } 14382 14383 return resBody.Res, nil 14384} 14385 14386type ShutdownHost_TaskBody struct { 14387 Req *types.ShutdownHost_Task `xml:"urn:vim25 ShutdownHost_Task,omitempty"` 14388 Res *types.ShutdownHost_TaskResponse `xml:"urn:vim25 ShutdownHost_TaskResponse,omitempty"` 14389 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14390} 14391 14392func (b *ShutdownHost_TaskBody) Fault() *soap.Fault { return b.Fault_ } 14393 14394func ShutdownHost_Task(ctx context.Context, r soap.RoundTripper, req *types.ShutdownHost_Task) (*types.ShutdownHost_TaskResponse, error) { 14395 var reqBody, resBody ShutdownHost_TaskBody 14396 14397 reqBody.Req = req 14398 14399 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14400 return nil, err 14401 } 14402 14403 return resBody.Res, nil 14404} 14405 14406type StageHostPatch_TaskBody struct { 14407 Req *types.StageHostPatch_Task `xml:"urn:vim25 StageHostPatch_Task,omitempty"` 14408 Res *types.StageHostPatch_TaskResponse `xml:"urn:vim25 StageHostPatch_TaskResponse,omitempty"` 14409 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14410} 14411 14412func (b *StageHostPatch_TaskBody) Fault() *soap.Fault { return b.Fault_ } 14413 14414func StageHostPatch_Task(ctx context.Context, r soap.RoundTripper, req *types.StageHostPatch_Task) (*types.StageHostPatch_TaskResponse, error) { 14415 var reqBody, resBody StageHostPatch_TaskBody 14416 14417 reqBody.Req = req 14418 14419 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14420 return nil, err 14421 } 14422 14423 return resBody.Res, nil 14424} 14425 14426type StampAllRulesWithUuid_TaskBody struct { 14427 Req *types.StampAllRulesWithUuid_Task `xml:"urn:vim25 StampAllRulesWithUuid_Task,omitempty"` 14428 Res *types.StampAllRulesWithUuid_TaskResponse `xml:"urn:vim25 StampAllRulesWithUuid_TaskResponse,omitempty"` 14429 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14430} 14431 14432func (b *StampAllRulesWithUuid_TaskBody) Fault() *soap.Fault { return b.Fault_ } 14433 14434func StampAllRulesWithUuid_Task(ctx context.Context, r soap.RoundTripper, req *types.StampAllRulesWithUuid_Task) (*types.StampAllRulesWithUuid_TaskResponse, error) { 14435 var reqBody, resBody StampAllRulesWithUuid_TaskBody 14436 14437 reqBody.Req = req 14438 14439 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14440 return nil, err 14441 } 14442 14443 return resBody.Res, nil 14444} 14445 14446type StandbyGuestBody struct { 14447 Req *types.StandbyGuest `xml:"urn:vim25 StandbyGuest,omitempty"` 14448 Res *types.StandbyGuestResponse `xml:"urn:vim25 StandbyGuestResponse,omitempty"` 14449 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14450} 14451 14452func (b *StandbyGuestBody) Fault() *soap.Fault { return b.Fault_ } 14453 14454func StandbyGuest(ctx context.Context, r soap.RoundTripper, req *types.StandbyGuest) (*types.StandbyGuestResponse, error) { 14455 var reqBody, resBody StandbyGuestBody 14456 14457 reqBody.Req = req 14458 14459 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14460 return nil, err 14461 } 14462 14463 return resBody.Res, nil 14464} 14465 14466type StartProgramInGuestBody struct { 14467 Req *types.StartProgramInGuest `xml:"urn:vim25 StartProgramInGuest,omitempty"` 14468 Res *types.StartProgramInGuestResponse `xml:"urn:vim25 StartProgramInGuestResponse,omitempty"` 14469 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14470} 14471 14472func (b *StartProgramInGuestBody) Fault() *soap.Fault { return b.Fault_ } 14473 14474func StartProgramInGuest(ctx context.Context, r soap.RoundTripper, req *types.StartProgramInGuest) (*types.StartProgramInGuestResponse, error) { 14475 var reqBody, resBody StartProgramInGuestBody 14476 14477 reqBody.Req = req 14478 14479 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14480 return nil, err 14481 } 14482 14483 return resBody.Res, nil 14484} 14485 14486type StartRecording_TaskBody struct { 14487 Req *types.StartRecording_Task `xml:"urn:vim25 StartRecording_Task,omitempty"` 14488 Res *types.StartRecording_TaskResponse `xml:"urn:vim25 StartRecording_TaskResponse,omitempty"` 14489 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14490} 14491 14492func (b *StartRecording_TaskBody) Fault() *soap.Fault { return b.Fault_ } 14493 14494func StartRecording_Task(ctx context.Context, r soap.RoundTripper, req *types.StartRecording_Task) (*types.StartRecording_TaskResponse, error) { 14495 var reqBody, resBody StartRecording_TaskBody 14496 14497 reqBody.Req = req 14498 14499 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14500 return nil, err 14501 } 14502 14503 return resBody.Res, nil 14504} 14505 14506type StartReplaying_TaskBody struct { 14507 Req *types.StartReplaying_Task `xml:"urn:vim25 StartReplaying_Task,omitempty"` 14508 Res *types.StartReplaying_TaskResponse `xml:"urn:vim25 StartReplaying_TaskResponse,omitempty"` 14509 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14510} 14511 14512func (b *StartReplaying_TaskBody) Fault() *soap.Fault { return b.Fault_ } 14513 14514func StartReplaying_Task(ctx context.Context, r soap.RoundTripper, req *types.StartReplaying_Task) (*types.StartReplaying_TaskResponse, error) { 14515 var reqBody, resBody StartReplaying_TaskBody 14516 14517 reqBody.Req = req 14518 14519 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14520 return nil, err 14521 } 14522 14523 return resBody.Res, nil 14524} 14525 14526type StartServiceBody struct { 14527 Req *types.StartService `xml:"urn:vim25 StartService,omitempty"` 14528 Res *types.StartServiceResponse `xml:"urn:vim25 StartServiceResponse,omitempty"` 14529 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14530} 14531 14532func (b *StartServiceBody) Fault() *soap.Fault { return b.Fault_ } 14533 14534func StartService(ctx context.Context, r soap.RoundTripper, req *types.StartService) (*types.StartServiceResponse, error) { 14535 var reqBody, resBody StartServiceBody 14536 14537 reqBody.Req = req 14538 14539 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14540 return nil, err 14541 } 14542 14543 return resBody.Res, nil 14544} 14545 14546type StopRecording_TaskBody struct { 14547 Req *types.StopRecording_Task `xml:"urn:vim25 StopRecording_Task,omitempty"` 14548 Res *types.StopRecording_TaskResponse `xml:"urn:vim25 StopRecording_TaskResponse,omitempty"` 14549 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14550} 14551 14552func (b *StopRecording_TaskBody) Fault() *soap.Fault { return b.Fault_ } 14553 14554func StopRecording_Task(ctx context.Context, r soap.RoundTripper, req *types.StopRecording_Task) (*types.StopRecording_TaskResponse, error) { 14555 var reqBody, resBody StopRecording_TaskBody 14556 14557 reqBody.Req = req 14558 14559 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14560 return nil, err 14561 } 14562 14563 return resBody.Res, nil 14564} 14565 14566type StopReplaying_TaskBody struct { 14567 Req *types.StopReplaying_Task `xml:"urn:vim25 StopReplaying_Task,omitempty"` 14568 Res *types.StopReplaying_TaskResponse `xml:"urn:vim25 StopReplaying_TaskResponse,omitempty"` 14569 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14570} 14571 14572func (b *StopReplaying_TaskBody) Fault() *soap.Fault { return b.Fault_ } 14573 14574func StopReplaying_Task(ctx context.Context, r soap.RoundTripper, req *types.StopReplaying_Task) (*types.StopReplaying_TaskResponse, error) { 14575 var reqBody, resBody StopReplaying_TaskBody 14576 14577 reqBody.Req = req 14578 14579 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14580 return nil, err 14581 } 14582 14583 return resBody.Res, nil 14584} 14585 14586type StopServiceBody struct { 14587 Req *types.StopService `xml:"urn:vim25 StopService,omitempty"` 14588 Res *types.StopServiceResponse `xml:"urn:vim25 StopServiceResponse,omitempty"` 14589 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14590} 14591 14592func (b *StopServiceBody) Fault() *soap.Fault { return b.Fault_ } 14593 14594func StopService(ctx context.Context, r soap.RoundTripper, req *types.StopService) (*types.StopServiceResponse, error) { 14595 var reqBody, resBody StopServiceBody 14596 14597 reqBody.Req = req 14598 14599 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14600 return nil, err 14601 } 14602 14603 return resBody.Res, nil 14604} 14605 14606type SuspendVApp_TaskBody struct { 14607 Req *types.SuspendVApp_Task `xml:"urn:vim25 SuspendVApp_Task,omitempty"` 14608 Res *types.SuspendVApp_TaskResponse `xml:"urn:vim25 SuspendVApp_TaskResponse,omitempty"` 14609 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14610} 14611 14612func (b *SuspendVApp_TaskBody) Fault() *soap.Fault { return b.Fault_ } 14613 14614func SuspendVApp_Task(ctx context.Context, r soap.RoundTripper, req *types.SuspendVApp_Task) (*types.SuspendVApp_TaskResponse, error) { 14615 var reqBody, resBody SuspendVApp_TaskBody 14616 14617 reqBody.Req = req 14618 14619 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14620 return nil, err 14621 } 14622 14623 return resBody.Res, nil 14624} 14625 14626type SuspendVM_TaskBody struct { 14627 Req *types.SuspendVM_Task `xml:"urn:vim25 SuspendVM_Task,omitempty"` 14628 Res *types.SuspendVM_TaskResponse `xml:"urn:vim25 SuspendVM_TaskResponse,omitempty"` 14629 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14630} 14631 14632func (b *SuspendVM_TaskBody) Fault() *soap.Fault { return b.Fault_ } 14633 14634func SuspendVM_Task(ctx context.Context, r soap.RoundTripper, req *types.SuspendVM_Task) (*types.SuspendVM_TaskResponse, error) { 14635 var reqBody, resBody SuspendVM_TaskBody 14636 14637 reqBody.Req = req 14638 14639 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14640 return nil, err 14641 } 14642 14643 return resBody.Res, nil 14644} 14645 14646type TerminateFaultTolerantVM_TaskBody struct { 14647 Req *types.TerminateFaultTolerantVM_Task `xml:"urn:vim25 TerminateFaultTolerantVM_Task,omitempty"` 14648 Res *types.TerminateFaultTolerantVM_TaskResponse `xml:"urn:vim25 TerminateFaultTolerantVM_TaskResponse,omitempty"` 14649 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14650} 14651 14652func (b *TerminateFaultTolerantVM_TaskBody) Fault() *soap.Fault { return b.Fault_ } 14653 14654func TerminateFaultTolerantVM_Task(ctx context.Context, r soap.RoundTripper, req *types.TerminateFaultTolerantVM_Task) (*types.TerminateFaultTolerantVM_TaskResponse, error) { 14655 var reqBody, resBody TerminateFaultTolerantVM_TaskBody 14656 14657 reqBody.Req = req 14658 14659 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14660 return nil, err 14661 } 14662 14663 return resBody.Res, nil 14664} 14665 14666type TerminateProcessInGuestBody struct { 14667 Req *types.TerminateProcessInGuest `xml:"urn:vim25 TerminateProcessInGuest,omitempty"` 14668 Res *types.TerminateProcessInGuestResponse `xml:"urn:vim25 TerminateProcessInGuestResponse,omitempty"` 14669 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14670} 14671 14672func (b *TerminateProcessInGuestBody) Fault() *soap.Fault { return b.Fault_ } 14673 14674func TerminateProcessInGuest(ctx context.Context, r soap.RoundTripper, req *types.TerminateProcessInGuest) (*types.TerminateProcessInGuestResponse, error) { 14675 var reqBody, resBody TerminateProcessInGuestBody 14676 14677 reqBody.Req = req 14678 14679 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14680 return nil, err 14681 } 14682 14683 return resBody.Res, nil 14684} 14685 14686type TerminateSessionBody struct { 14687 Req *types.TerminateSession `xml:"urn:vim25 TerminateSession,omitempty"` 14688 Res *types.TerminateSessionResponse `xml:"urn:vim25 TerminateSessionResponse,omitempty"` 14689 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14690} 14691 14692func (b *TerminateSessionBody) Fault() *soap.Fault { return b.Fault_ } 14693 14694func TerminateSession(ctx context.Context, r soap.RoundTripper, req *types.TerminateSession) (*types.TerminateSessionResponse, error) { 14695 var reqBody, resBody TerminateSessionBody 14696 14697 reqBody.Req = req 14698 14699 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14700 return nil, err 14701 } 14702 14703 return resBody.Res, nil 14704} 14705 14706type TerminateVMBody struct { 14707 Req *types.TerminateVM `xml:"urn:vim25 TerminateVM,omitempty"` 14708 Res *types.TerminateVMResponse `xml:"urn:vim25 TerminateVMResponse,omitempty"` 14709 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14710} 14711 14712func (b *TerminateVMBody) Fault() *soap.Fault { return b.Fault_ } 14713 14714func TerminateVM(ctx context.Context, r soap.RoundTripper, req *types.TerminateVM) (*types.TerminateVMResponse, error) { 14715 var reqBody, resBody TerminateVMBody 14716 14717 reqBody.Req = req 14718 14719 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14720 return nil, err 14721 } 14722 14723 return resBody.Res, nil 14724} 14725 14726type TurnDiskLocatorLedOff_TaskBody struct { 14727 Req *types.TurnDiskLocatorLedOff_Task `xml:"urn:vim25 TurnDiskLocatorLedOff_Task,omitempty"` 14728 Res *types.TurnDiskLocatorLedOff_TaskResponse `xml:"urn:vim25 TurnDiskLocatorLedOff_TaskResponse,omitempty"` 14729 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14730} 14731 14732func (b *TurnDiskLocatorLedOff_TaskBody) Fault() *soap.Fault { return b.Fault_ } 14733 14734func TurnDiskLocatorLedOff_Task(ctx context.Context, r soap.RoundTripper, req *types.TurnDiskLocatorLedOff_Task) (*types.TurnDiskLocatorLedOff_TaskResponse, error) { 14735 var reqBody, resBody TurnDiskLocatorLedOff_TaskBody 14736 14737 reqBody.Req = req 14738 14739 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14740 return nil, err 14741 } 14742 14743 return resBody.Res, nil 14744} 14745 14746type TurnDiskLocatorLedOn_TaskBody struct { 14747 Req *types.TurnDiskLocatorLedOn_Task `xml:"urn:vim25 TurnDiskLocatorLedOn_Task,omitempty"` 14748 Res *types.TurnDiskLocatorLedOn_TaskResponse `xml:"urn:vim25 TurnDiskLocatorLedOn_TaskResponse,omitempty"` 14749 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14750} 14751 14752func (b *TurnDiskLocatorLedOn_TaskBody) Fault() *soap.Fault { return b.Fault_ } 14753 14754func TurnDiskLocatorLedOn_Task(ctx context.Context, r soap.RoundTripper, req *types.TurnDiskLocatorLedOn_Task) (*types.TurnDiskLocatorLedOn_TaskResponse, error) { 14755 var reqBody, resBody TurnDiskLocatorLedOn_TaskBody 14756 14757 reqBody.Req = req 14758 14759 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14760 return nil, err 14761 } 14762 14763 return resBody.Res, nil 14764} 14765 14766type TurnOffFaultToleranceForVM_TaskBody struct { 14767 Req *types.TurnOffFaultToleranceForVM_Task `xml:"urn:vim25 TurnOffFaultToleranceForVM_Task,omitempty"` 14768 Res *types.TurnOffFaultToleranceForVM_TaskResponse `xml:"urn:vim25 TurnOffFaultToleranceForVM_TaskResponse,omitempty"` 14769 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14770} 14771 14772func (b *TurnOffFaultToleranceForVM_TaskBody) Fault() *soap.Fault { return b.Fault_ } 14773 14774func TurnOffFaultToleranceForVM_Task(ctx context.Context, r soap.RoundTripper, req *types.TurnOffFaultToleranceForVM_Task) (*types.TurnOffFaultToleranceForVM_TaskResponse, error) { 14775 var reqBody, resBody TurnOffFaultToleranceForVM_TaskBody 14776 14777 reqBody.Req = req 14778 14779 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14780 return nil, err 14781 } 14782 14783 return resBody.Res, nil 14784} 14785 14786type UnassignUserFromGroupBody struct { 14787 Req *types.UnassignUserFromGroup `xml:"urn:vim25 UnassignUserFromGroup,omitempty"` 14788 Res *types.UnassignUserFromGroupResponse `xml:"urn:vim25 UnassignUserFromGroupResponse,omitempty"` 14789 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14790} 14791 14792func (b *UnassignUserFromGroupBody) Fault() *soap.Fault { return b.Fault_ } 14793 14794func UnassignUserFromGroup(ctx context.Context, r soap.RoundTripper, req *types.UnassignUserFromGroup) (*types.UnassignUserFromGroupResponse, error) { 14795 var reqBody, resBody UnassignUserFromGroupBody 14796 14797 reqBody.Req = req 14798 14799 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14800 return nil, err 14801 } 14802 14803 return resBody.Res, nil 14804} 14805 14806type UnbindVnicBody struct { 14807 Req *types.UnbindVnic `xml:"urn:vim25 UnbindVnic,omitempty"` 14808 Res *types.UnbindVnicResponse `xml:"urn:vim25 UnbindVnicResponse,omitempty"` 14809 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14810} 14811 14812func (b *UnbindVnicBody) Fault() *soap.Fault { return b.Fault_ } 14813 14814func UnbindVnic(ctx context.Context, r soap.RoundTripper, req *types.UnbindVnic) (*types.UnbindVnicResponse, error) { 14815 var reqBody, resBody UnbindVnicBody 14816 14817 reqBody.Req = req 14818 14819 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14820 return nil, err 14821 } 14822 14823 return resBody.Res, nil 14824} 14825 14826type UninstallHostPatch_TaskBody struct { 14827 Req *types.UninstallHostPatch_Task `xml:"urn:vim25 UninstallHostPatch_Task,omitempty"` 14828 Res *types.UninstallHostPatch_TaskResponse `xml:"urn:vim25 UninstallHostPatch_TaskResponse,omitempty"` 14829 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14830} 14831 14832func (b *UninstallHostPatch_TaskBody) Fault() *soap.Fault { return b.Fault_ } 14833 14834func UninstallHostPatch_Task(ctx context.Context, r soap.RoundTripper, req *types.UninstallHostPatch_Task) (*types.UninstallHostPatch_TaskResponse, error) { 14835 var reqBody, resBody UninstallHostPatch_TaskBody 14836 14837 reqBody.Req = req 14838 14839 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14840 return nil, err 14841 } 14842 14843 return resBody.Res, nil 14844} 14845 14846type UninstallIoFilter_TaskBody struct { 14847 Req *types.UninstallIoFilter_Task `xml:"urn:vim25 UninstallIoFilter_Task,omitempty"` 14848 Res *types.UninstallIoFilter_TaskResponse `xml:"urn:vim25 UninstallIoFilter_TaskResponse,omitempty"` 14849 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14850} 14851 14852func (b *UninstallIoFilter_TaskBody) Fault() *soap.Fault { return b.Fault_ } 14853 14854func UninstallIoFilter_Task(ctx context.Context, r soap.RoundTripper, req *types.UninstallIoFilter_Task) (*types.UninstallIoFilter_TaskResponse, error) { 14855 var reqBody, resBody UninstallIoFilter_TaskBody 14856 14857 reqBody.Req = req 14858 14859 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14860 return nil, err 14861 } 14862 14863 return resBody.Res, nil 14864} 14865 14866type UninstallServiceBody struct { 14867 Req *types.UninstallService `xml:"urn:vim25 UninstallService,omitempty"` 14868 Res *types.UninstallServiceResponse `xml:"urn:vim25 UninstallServiceResponse,omitempty"` 14869 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14870} 14871 14872func (b *UninstallServiceBody) Fault() *soap.Fault { return b.Fault_ } 14873 14874func UninstallService(ctx context.Context, r soap.RoundTripper, req *types.UninstallService) (*types.UninstallServiceResponse, error) { 14875 var reqBody, resBody UninstallServiceBody 14876 14877 reqBody.Req = req 14878 14879 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14880 return nil, err 14881 } 14882 14883 return resBody.Res, nil 14884} 14885 14886type UnmapVmfsVolumeEx_TaskBody struct { 14887 Req *types.UnmapVmfsVolumeEx_Task `xml:"urn:vim25 UnmapVmfsVolumeEx_Task,omitempty"` 14888 Res *types.UnmapVmfsVolumeEx_TaskResponse `xml:"urn:vim25 UnmapVmfsVolumeEx_TaskResponse,omitempty"` 14889 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14890} 14891 14892func (b *UnmapVmfsVolumeEx_TaskBody) Fault() *soap.Fault { return b.Fault_ } 14893 14894func UnmapVmfsVolumeEx_Task(ctx context.Context, r soap.RoundTripper, req *types.UnmapVmfsVolumeEx_Task) (*types.UnmapVmfsVolumeEx_TaskResponse, error) { 14895 var reqBody, resBody UnmapVmfsVolumeEx_TaskBody 14896 14897 reqBody.Req = req 14898 14899 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14900 return nil, err 14901 } 14902 14903 return resBody.Res, nil 14904} 14905 14906type UnmountDiskMapping_TaskBody struct { 14907 Req *types.UnmountDiskMapping_Task `xml:"urn:vim25 UnmountDiskMapping_Task,omitempty"` 14908 Res *types.UnmountDiskMapping_TaskResponse `xml:"urn:vim25 UnmountDiskMapping_TaskResponse,omitempty"` 14909 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14910} 14911 14912func (b *UnmountDiskMapping_TaskBody) Fault() *soap.Fault { return b.Fault_ } 14913 14914func UnmountDiskMapping_Task(ctx context.Context, r soap.RoundTripper, req *types.UnmountDiskMapping_Task) (*types.UnmountDiskMapping_TaskResponse, error) { 14915 var reqBody, resBody UnmountDiskMapping_TaskBody 14916 14917 reqBody.Req = req 14918 14919 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14920 return nil, err 14921 } 14922 14923 return resBody.Res, nil 14924} 14925 14926type UnmountForceMountedVmfsVolumeBody struct { 14927 Req *types.UnmountForceMountedVmfsVolume `xml:"urn:vim25 UnmountForceMountedVmfsVolume,omitempty"` 14928 Res *types.UnmountForceMountedVmfsVolumeResponse `xml:"urn:vim25 UnmountForceMountedVmfsVolumeResponse,omitempty"` 14929 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14930} 14931 14932func (b *UnmountForceMountedVmfsVolumeBody) Fault() *soap.Fault { return b.Fault_ } 14933 14934func UnmountForceMountedVmfsVolume(ctx context.Context, r soap.RoundTripper, req *types.UnmountForceMountedVmfsVolume) (*types.UnmountForceMountedVmfsVolumeResponse, error) { 14935 var reqBody, resBody UnmountForceMountedVmfsVolumeBody 14936 14937 reqBody.Req = req 14938 14939 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14940 return nil, err 14941 } 14942 14943 return resBody.Res, nil 14944} 14945 14946type UnmountToolsInstallerBody struct { 14947 Req *types.UnmountToolsInstaller `xml:"urn:vim25 UnmountToolsInstaller,omitempty"` 14948 Res *types.UnmountToolsInstallerResponse `xml:"urn:vim25 UnmountToolsInstallerResponse,omitempty"` 14949 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14950} 14951 14952func (b *UnmountToolsInstallerBody) Fault() *soap.Fault { return b.Fault_ } 14953 14954func UnmountToolsInstaller(ctx context.Context, r soap.RoundTripper, req *types.UnmountToolsInstaller) (*types.UnmountToolsInstallerResponse, error) { 14955 var reqBody, resBody UnmountToolsInstallerBody 14956 14957 reqBody.Req = req 14958 14959 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14960 return nil, err 14961 } 14962 14963 return resBody.Res, nil 14964} 14965 14966type UnmountVffsVolumeBody struct { 14967 Req *types.UnmountVffsVolume `xml:"urn:vim25 UnmountVffsVolume,omitempty"` 14968 Res *types.UnmountVffsVolumeResponse `xml:"urn:vim25 UnmountVffsVolumeResponse,omitempty"` 14969 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14970} 14971 14972func (b *UnmountVffsVolumeBody) Fault() *soap.Fault { return b.Fault_ } 14973 14974func UnmountVffsVolume(ctx context.Context, r soap.RoundTripper, req *types.UnmountVffsVolume) (*types.UnmountVffsVolumeResponse, error) { 14975 var reqBody, resBody UnmountVffsVolumeBody 14976 14977 reqBody.Req = req 14978 14979 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 14980 return nil, err 14981 } 14982 14983 return resBody.Res, nil 14984} 14985 14986type UnmountVmfsVolumeBody struct { 14987 Req *types.UnmountVmfsVolume `xml:"urn:vim25 UnmountVmfsVolume,omitempty"` 14988 Res *types.UnmountVmfsVolumeResponse `xml:"urn:vim25 UnmountVmfsVolumeResponse,omitempty"` 14989 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 14990} 14991 14992func (b *UnmountVmfsVolumeBody) Fault() *soap.Fault { return b.Fault_ } 14993 14994func UnmountVmfsVolume(ctx context.Context, r soap.RoundTripper, req *types.UnmountVmfsVolume) (*types.UnmountVmfsVolumeResponse, error) { 14995 var reqBody, resBody UnmountVmfsVolumeBody 14996 14997 reqBody.Req = req 14998 14999 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15000 return nil, err 15001 } 15002 15003 return resBody.Res, nil 15004} 15005 15006type UnmountVmfsVolumeEx_TaskBody struct { 15007 Req *types.UnmountVmfsVolumeEx_Task `xml:"urn:vim25 UnmountVmfsVolumeEx_Task,omitempty"` 15008 Res *types.UnmountVmfsVolumeEx_TaskResponse `xml:"urn:vim25 UnmountVmfsVolumeEx_TaskResponse,omitempty"` 15009 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15010} 15011 15012func (b *UnmountVmfsVolumeEx_TaskBody) Fault() *soap.Fault { return b.Fault_ } 15013 15014func UnmountVmfsVolumeEx_Task(ctx context.Context, r soap.RoundTripper, req *types.UnmountVmfsVolumeEx_Task) (*types.UnmountVmfsVolumeEx_TaskResponse, error) { 15015 var reqBody, resBody UnmountVmfsVolumeEx_TaskBody 15016 15017 reqBody.Req = req 15018 15019 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15020 return nil, err 15021 } 15022 15023 return resBody.Res, nil 15024} 15025 15026type UnregisterAndDestroy_TaskBody struct { 15027 Req *types.UnregisterAndDestroy_Task `xml:"urn:vim25 UnregisterAndDestroy_Task,omitempty"` 15028 Res *types.UnregisterAndDestroy_TaskResponse `xml:"urn:vim25 UnregisterAndDestroy_TaskResponse,omitempty"` 15029 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15030} 15031 15032func (b *UnregisterAndDestroy_TaskBody) Fault() *soap.Fault { return b.Fault_ } 15033 15034func UnregisterAndDestroy_Task(ctx context.Context, r soap.RoundTripper, req *types.UnregisterAndDestroy_Task) (*types.UnregisterAndDestroy_TaskResponse, error) { 15035 var reqBody, resBody UnregisterAndDestroy_TaskBody 15036 15037 reqBody.Req = req 15038 15039 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15040 return nil, err 15041 } 15042 15043 return resBody.Res, nil 15044} 15045 15046type UnregisterExtensionBody struct { 15047 Req *types.UnregisterExtension `xml:"urn:vim25 UnregisterExtension,omitempty"` 15048 Res *types.UnregisterExtensionResponse `xml:"urn:vim25 UnregisterExtensionResponse,omitempty"` 15049 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15050} 15051 15052func (b *UnregisterExtensionBody) Fault() *soap.Fault { return b.Fault_ } 15053 15054func UnregisterExtension(ctx context.Context, r soap.RoundTripper, req *types.UnregisterExtension) (*types.UnregisterExtensionResponse, error) { 15055 var reqBody, resBody UnregisterExtensionBody 15056 15057 reqBody.Req = req 15058 15059 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15060 return nil, err 15061 } 15062 15063 return resBody.Res, nil 15064} 15065 15066type UnregisterHealthUpdateProviderBody struct { 15067 Req *types.UnregisterHealthUpdateProvider `xml:"urn:vim25 UnregisterHealthUpdateProvider,omitempty"` 15068 Res *types.UnregisterHealthUpdateProviderResponse `xml:"urn:vim25 UnregisterHealthUpdateProviderResponse,omitempty"` 15069 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15070} 15071 15072func (b *UnregisterHealthUpdateProviderBody) Fault() *soap.Fault { return b.Fault_ } 15073 15074func UnregisterHealthUpdateProvider(ctx context.Context, r soap.RoundTripper, req *types.UnregisterHealthUpdateProvider) (*types.UnregisterHealthUpdateProviderResponse, error) { 15075 var reqBody, resBody UnregisterHealthUpdateProviderBody 15076 15077 reqBody.Req = req 15078 15079 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15080 return nil, err 15081 } 15082 15083 return resBody.Res, nil 15084} 15085 15086type UnregisterVMBody struct { 15087 Req *types.UnregisterVM `xml:"urn:vim25 UnregisterVM,omitempty"` 15088 Res *types.UnregisterVMResponse `xml:"urn:vim25 UnregisterVMResponse,omitempty"` 15089 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15090} 15091 15092func (b *UnregisterVMBody) Fault() *soap.Fault { return b.Fault_ } 15093 15094func UnregisterVM(ctx context.Context, r soap.RoundTripper, req *types.UnregisterVM) (*types.UnregisterVMResponse, error) { 15095 var reqBody, resBody UnregisterVMBody 15096 15097 reqBody.Req = req 15098 15099 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15100 return nil, err 15101 } 15102 15103 return resBody.Res, nil 15104} 15105 15106type UpdateAnswerFile_TaskBody struct { 15107 Req *types.UpdateAnswerFile_Task `xml:"urn:vim25 UpdateAnswerFile_Task,omitempty"` 15108 Res *types.UpdateAnswerFile_TaskResponse `xml:"urn:vim25 UpdateAnswerFile_TaskResponse,omitempty"` 15109 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15110} 15111 15112func (b *UpdateAnswerFile_TaskBody) Fault() *soap.Fault { return b.Fault_ } 15113 15114func UpdateAnswerFile_Task(ctx context.Context, r soap.RoundTripper, req *types.UpdateAnswerFile_Task) (*types.UpdateAnswerFile_TaskResponse, error) { 15115 var reqBody, resBody UpdateAnswerFile_TaskBody 15116 15117 reqBody.Req = req 15118 15119 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15120 return nil, err 15121 } 15122 15123 return resBody.Res, nil 15124} 15125 15126type UpdateAssignedLicenseBody struct { 15127 Req *types.UpdateAssignedLicense `xml:"urn:vim25 UpdateAssignedLicense,omitempty"` 15128 Res *types.UpdateAssignedLicenseResponse `xml:"urn:vim25 UpdateAssignedLicenseResponse,omitempty"` 15129 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15130} 15131 15132func (b *UpdateAssignedLicenseBody) Fault() *soap.Fault { return b.Fault_ } 15133 15134func UpdateAssignedLicense(ctx context.Context, r soap.RoundTripper, req *types.UpdateAssignedLicense) (*types.UpdateAssignedLicenseResponse, error) { 15135 var reqBody, resBody UpdateAssignedLicenseBody 15136 15137 reqBody.Req = req 15138 15139 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15140 return nil, err 15141 } 15142 15143 return resBody.Res, nil 15144} 15145 15146type UpdateAuthorizationRoleBody struct { 15147 Req *types.UpdateAuthorizationRole `xml:"urn:vim25 UpdateAuthorizationRole,omitempty"` 15148 Res *types.UpdateAuthorizationRoleResponse `xml:"urn:vim25 UpdateAuthorizationRoleResponse,omitempty"` 15149 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15150} 15151 15152func (b *UpdateAuthorizationRoleBody) Fault() *soap.Fault { return b.Fault_ } 15153 15154func UpdateAuthorizationRole(ctx context.Context, r soap.RoundTripper, req *types.UpdateAuthorizationRole) (*types.UpdateAuthorizationRoleResponse, error) { 15155 var reqBody, resBody UpdateAuthorizationRoleBody 15156 15157 reqBody.Req = req 15158 15159 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15160 return nil, err 15161 } 15162 15163 return resBody.Res, nil 15164} 15165 15166type UpdateBootDeviceBody struct { 15167 Req *types.UpdateBootDevice `xml:"urn:vim25 UpdateBootDevice,omitempty"` 15168 Res *types.UpdateBootDeviceResponse `xml:"urn:vim25 UpdateBootDeviceResponse,omitempty"` 15169 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15170} 15171 15172func (b *UpdateBootDeviceBody) Fault() *soap.Fault { return b.Fault_ } 15173 15174func UpdateBootDevice(ctx context.Context, r soap.RoundTripper, req *types.UpdateBootDevice) (*types.UpdateBootDeviceResponse, error) { 15175 var reqBody, resBody UpdateBootDeviceBody 15176 15177 reqBody.Req = req 15178 15179 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15180 return nil, err 15181 } 15182 15183 return resBody.Res, nil 15184} 15185 15186type UpdateChildResourceConfigurationBody struct { 15187 Req *types.UpdateChildResourceConfiguration `xml:"urn:vim25 UpdateChildResourceConfiguration,omitempty"` 15188 Res *types.UpdateChildResourceConfigurationResponse `xml:"urn:vim25 UpdateChildResourceConfigurationResponse,omitempty"` 15189 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15190} 15191 15192func (b *UpdateChildResourceConfigurationBody) Fault() *soap.Fault { return b.Fault_ } 15193 15194func UpdateChildResourceConfiguration(ctx context.Context, r soap.RoundTripper, req *types.UpdateChildResourceConfiguration) (*types.UpdateChildResourceConfigurationResponse, error) { 15195 var reqBody, resBody UpdateChildResourceConfigurationBody 15196 15197 reqBody.Req = req 15198 15199 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15200 return nil, err 15201 } 15202 15203 return resBody.Res, nil 15204} 15205 15206type UpdateClusterProfileBody struct { 15207 Req *types.UpdateClusterProfile `xml:"urn:vim25 UpdateClusterProfile,omitempty"` 15208 Res *types.UpdateClusterProfileResponse `xml:"urn:vim25 UpdateClusterProfileResponse,omitempty"` 15209 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15210} 15211 15212func (b *UpdateClusterProfileBody) Fault() *soap.Fault { return b.Fault_ } 15213 15214func UpdateClusterProfile(ctx context.Context, r soap.RoundTripper, req *types.UpdateClusterProfile) (*types.UpdateClusterProfileResponse, error) { 15215 var reqBody, resBody UpdateClusterProfileBody 15216 15217 reqBody.Req = req 15218 15219 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15220 return nil, err 15221 } 15222 15223 return resBody.Res, nil 15224} 15225 15226type UpdateConfigBody struct { 15227 Req *types.UpdateConfig `xml:"urn:vim25 UpdateConfig,omitempty"` 15228 Res *types.UpdateConfigResponse `xml:"urn:vim25 UpdateConfigResponse,omitempty"` 15229 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15230} 15231 15232func (b *UpdateConfigBody) Fault() *soap.Fault { return b.Fault_ } 15233 15234func UpdateConfig(ctx context.Context, r soap.RoundTripper, req *types.UpdateConfig) (*types.UpdateConfigResponse, error) { 15235 var reqBody, resBody UpdateConfigBody 15236 15237 reqBody.Req = req 15238 15239 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15240 return nil, err 15241 } 15242 15243 return resBody.Res, nil 15244} 15245 15246type UpdateConsoleIpRouteConfigBody struct { 15247 Req *types.UpdateConsoleIpRouteConfig `xml:"urn:vim25 UpdateConsoleIpRouteConfig,omitempty"` 15248 Res *types.UpdateConsoleIpRouteConfigResponse `xml:"urn:vim25 UpdateConsoleIpRouteConfigResponse,omitempty"` 15249 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15250} 15251 15252func (b *UpdateConsoleIpRouteConfigBody) Fault() *soap.Fault { return b.Fault_ } 15253 15254func UpdateConsoleIpRouteConfig(ctx context.Context, r soap.RoundTripper, req *types.UpdateConsoleIpRouteConfig) (*types.UpdateConsoleIpRouteConfigResponse, error) { 15255 var reqBody, resBody UpdateConsoleIpRouteConfigBody 15256 15257 reqBody.Req = req 15258 15259 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15260 return nil, err 15261 } 15262 15263 return resBody.Res, nil 15264} 15265 15266type UpdateCounterLevelMappingBody struct { 15267 Req *types.UpdateCounterLevelMapping `xml:"urn:vim25 UpdateCounterLevelMapping,omitempty"` 15268 Res *types.UpdateCounterLevelMappingResponse `xml:"urn:vim25 UpdateCounterLevelMappingResponse,omitempty"` 15269 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15270} 15271 15272func (b *UpdateCounterLevelMappingBody) Fault() *soap.Fault { return b.Fault_ } 15273 15274func UpdateCounterLevelMapping(ctx context.Context, r soap.RoundTripper, req *types.UpdateCounterLevelMapping) (*types.UpdateCounterLevelMappingResponse, error) { 15275 var reqBody, resBody UpdateCounterLevelMappingBody 15276 15277 reqBody.Req = req 15278 15279 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15280 return nil, err 15281 } 15282 15283 return resBody.Res, nil 15284} 15285 15286type UpdateDVSHealthCheckConfig_TaskBody struct { 15287 Req *types.UpdateDVSHealthCheckConfig_Task `xml:"urn:vim25 UpdateDVSHealthCheckConfig_Task,omitempty"` 15288 Res *types.UpdateDVSHealthCheckConfig_TaskResponse `xml:"urn:vim25 UpdateDVSHealthCheckConfig_TaskResponse,omitempty"` 15289 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15290} 15291 15292func (b *UpdateDVSHealthCheckConfig_TaskBody) Fault() *soap.Fault { return b.Fault_ } 15293 15294func UpdateDVSHealthCheckConfig_Task(ctx context.Context, r soap.RoundTripper, req *types.UpdateDVSHealthCheckConfig_Task) (*types.UpdateDVSHealthCheckConfig_TaskResponse, error) { 15295 var reqBody, resBody UpdateDVSHealthCheckConfig_TaskBody 15296 15297 reqBody.Req = req 15298 15299 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15300 return nil, err 15301 } 15302 15303 return resBody.Res, nil 15304} 15305 15306type UpdateDVSLacpGroupConfig_TaskBody struct { 15307 Req *types.UpdateDVSLacpGroupConfig_Task `xml:"urn:vim25 UpdateDVSLacpGroupConfig_Task,omitempty"` 15308 Res *types.UpdateDVSLacpGroupConfig_TaskResponse `xml:"urn:vim25 UpdateDVSLacpGroupConfig_TaskResponse,omitempty"` 15309 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15310} 15311 15312func (b *UpdateDVSLacpGroupConfig_TaskBody) Fault() *soap.Fault { return b.Fault_ } 15313 15314func UpdateDVSLacpGroupConfig_Task(ctx context.Context, r soap.RoundTripper, req *types.UpdateDVSLacpGroupConfig_Task) (*types.UpdateDVSLacpGroupConfig_TaskResponse, error) { 15315 var reqBody, resBody UpdateDVSLacpGroupConfig_TaskBody 15316 15317 reqBody.Req = req 15318 15319 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15320 return nil, err 15321 } 15322 15323 return resBody.Res, nil 15324} 15325 15326type UpdateDateTimeBody struct { 15327 Req *types.UpdateDateTime `xml:"urn:vim25 UpdateDateTime,omitempty"` 15328 Res *types.UpdateDateTimeResponse `xml:"urn:vim25 UpdateDateTimeResponse,omitempty"` 15329 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15330} 15331 15332func (b *UpdateDateTimeBody) Fault() *soap.Fault { return b.Fault_ } 15333 15334func UpdateDateTime(ctx context.Context, r soap.RoundTripper, req *types.UpdateDateTime) (*types.UpdateDateTimeResponse, error) { 15335 var reqBody, resBody UpdateDateTimeBody 15336 15337 reqBody.Req = req 15338 15339 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15340 return nil, err 15341 } 15342 15343 return resBody.Res, nil 15344} 15345 15346type UpdateDateTimeConfigBody struct { 15347 Req *types.UpdateDateTimeConfig `xml:"urn:vim25 UpdateDateTimeConfig,omitempty"` 15348 Res *types.UpdateDateTimeConfigResponse `xml:"urn:vim25 UpdateDateTimeConfigResponse,omitempty"` 15349 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15350} 15351 15352func (b *UpdateDateTimeConfigBody) Fault() *soap.Fault { return b.Fault_ } 15353 15354func UpdateDateTimeConfig(ctx context.Context, r soap.RoundTripper, req *types.UpdateDateTimeConfig) (*types.UpdateDateTimeConfigResponse, error) { 15355 var reqBody, resBody UpdateDateTimeConfigBody 15356 15357 reqBody.Req = req 15358 15359 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15360 return nil, err 15361 } 15362 15363 return resBody.Res, nil 15364} 15365 15366type UpdateDefaultPolicyBody struct { 15367 Req *types.UpdateDefaultPolicy `xml:"urn:vim25 UpdateDefaultPolicy,omitempty"` 15368 Res *types.UpdateDefaultPolicyResponse `xml:"urn:vim25 UpdateDefaultPolicyResponse,omitempty"` 15369 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15370} 15371 15372func (b *UpdateDefaultPolicyBody) Fault() *soap.Fault { return b.Fault_ } 15373 15374func UpdateDefaultPolicy(ctx context.Context, r soap.RoundTripper, req *types.UpdateDefaultPolicy) (*types.UpdateDefaultPolicyResponse, error) { 15375 var reqBody, resBody UpdateDefaultPolicyBody 15376 15377 reqBody.Req = req 15378 15379 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15380 return nil, err 15381 } 15382 15383 return resBody.Res, nil 15384} 15385 15386type UpdateDiskPartitionsBody struct { 15387 Req *types.UpdateDiskPartitions `xml:"urn:vim25 UpdateDiskPartitions,omitempty"` 15388 Res *types.UpdateDiskPartitionsResponse `xml:"urn:vim25 UpdateDiskPartitionsResponse,omitempty"` 15389 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15390} 15391 15392func (b *UpdateDiskPartitionsBody) Fault() *soap.Fault { return b.Fault_ } 15393 15394func UpdateDiskPartitions(ctx context.Context, r soap.RoundTripper, req *types.UpdateDiskPartitions) (*types.UpdateDiskPartitionsResponse, error) { 15395 var reqBody, resBody UpdateDiskPartitionsBody 15396 15397 reqBody.Req = req 15398 15399 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15400 return nil, err 15401 } 15402 15403 return resBody.Res, nil 15404} 15405 15406type UpdateDnsConfigBody struct { 15407 Req *types.UpdateDnsConfig `xml:"urn:vim25 UpdateDnsConfig,omitempty"` 15408 Res *types.UpdateDnsConfigResponse `xml:"urn:vim25 UpdateDnsConfigResponse,omitempty"` 15409 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15410} 15411 15412func (b *UpdateDnsConfigBody) Fault() *soap.Fault { return b.Fault_ } 15413 15414func UpdateDnsConfig(ctx context.Context, r soap.RoundTripper, req *types.UpdateDnsConfig) (*types.UpdateDnsConfigResponse, error) { 15415 var reqBody, resBody UpdateDnsConfigBody 15416 15417 reqBody.Req = req 15418 15419 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15420 return nil, err 15421 } 15422 15423 return resBody.Res, nil 15424} 15425 15426type UpdateDvsCapabilityBody struct { 15427 Req *types.UpdateDvsCapability `xml:"urn:vim25 UpdateDvsCapability,omitempty"` 15428 Res *types.UpdateDvsCapabilityResponse `xml:"urn:vim25 UpdateDvsCapabilityResponse,omitempty"` 15429 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15430} 15431 15432func (b *UpdateDvsCapabilityBody) Fault() *soap.Fault { return b.Fault_ } 15433 15434func UpdateDvsCapability(ctx context.Context, r soap.RoundTripper, req *types.UpdateDvsCapability) (*types.UpdateDvsCapabilityResponse, error) { 15435 var reqBody, resBody UpdateDvsCapabilityBody 15436 15437 reqBody.Req = req 15438 15439 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15440 return nil, err 15441 } 15442 15443 return resBody.Res, nil 15444} 15445 15446type UpdateExtensionBody struct { 15447 Req *types.UpdateExtension `xml:"urn:vim25 UpdateExtension,omitempty"` 15448 Res *types.UpdateExtensionResponse `xml:"urn:vim25 UpdateExtensionResponse,omitempty"` 15449 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15450} 15451 15452func (b *UpdateExtensionBody) Fault() *soap.Fault { return b.Fault_ } 15453 15454func UpdateExtension(ctx context.Context, r soap.RoundTripper, req *types.UpdateExtension) (*types.UpdateExtensionResponse, error) { 15455 var reqBody, resBody UpdateExtensionBody 15456 15457 reqBody.Req = req 15458 15459 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15460 return nil, err 15461 } 15462 15463 return resBody.Res, nil 15464} 15465 15466type UpdateFlagsBody struct { 15467 Req *types.UpdateFlags `xml:"urn:vim25 UpdateFlags,omitempty"` 15468 Res *types.UpdateFlagsResponse `xml:"urn:vim25 UpdateFlagsResponse,omitempty"` 15469 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15470} 15471 15472func (b *UpdateFlagsBody) Fault() *soap.Fault { return b.Fault_ } 15473 15474func UpdateFlags(ctx context.Context, r soap.RoundTripper, req *types.UpdateFlags) (*types.UpdateFlagsResponse, error) { 15475 var reqBody, resBody UpdateFlagsBody 15476 15477 reqBody.Req = req 15478 15479 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15480 return nil, err 15481 } 15482 15483 return resBody.Res, nil 15484} 15485 15486type UpdateGraphicsConfigBody struct { 15487 Req *types.UpdateGraphicsConfig `xml:"urn:vim25 UpdateGraphicsConfig,omitempty"` 15488 Res *types.UpdateGraphicsConfigResponse `xml:"urn:vim25 UpdateGraphicsConfigResponse,omitempty"` 15489 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15490} 15491 15492func (b *UpdateGraphicsConfigBody) Fault() *soap.Fault { return b.Fault_ } 15493 15494func UpdateGraphicsConfig(ctx context.Context, r soap.RoundTripper, req *types.UpdateGraphicsConfig) (*types.UpdateGraphicsConfigResponse, error) { 15495 var reqBody, resBody UpdateGraphicsConfigBody 15496 15497 reqBody.Req = req 15498 15499 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15500 return nil, err 15501 } 15502 15503 return resBody.Res, nil 15504} 15505 15506type UpdateHostCustomizations_TaskBody struct { 15507 Req *types.UpdateHostCustomizations_Task `xml:"urn:vim25 UpdateHostCustomizations_Task,omitempty"` 15508 Res *types.UpdateHostCustomizations_TaskResponse `xml:"urn:vim25 UpdateHostCustomizations_TaskResponse,omitempty"` 15509 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15510} 15511 15512func (b *UpdateHostCustomizations_TaskBody) Fault() *soap.Fault { return b.Fault_ } 15513 15514func UpdateHostCustomizations_Task(ctx context.Context, r soap.RoundTripper, req *types.UpdateHostCustomizations_Task) (*types.UpdateHostCustomizations_TaskResponse, error) { 15515 var reqBody, resBody UpdateHostCustomizations_TaskBody 15516 15517 reqBody.Req = req 15518 15519 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15520 return nil, err 15521 } 15522 15523 return resBody.Res, nil 15524} 15525 15526type UpdateHostImageAcceptanceLevelBody struct { 15527 Req *types.UpdateHostImageAcceptanceLevel `xml:"urn:vim25 UpdateHostImageAcceptanceLevel,omitempty"` 15528 Res *types.UpdateHostImageAcceptanceLevelResponse `xml:"urn:vim25 UpdateHostImageAcceptanceLevelResponse,omitempty"` 15529 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15530} 15531 15532func (b *UpdateHostImageAcceptanceLevelBody) Fault() *soap.Fault { return b.Fault_ } 15533 15534func UpdateHostImageAcceptanceLevel(ctx context.Context, r soap.RoundTripper, req *types.UpdateHostImageAcceptanceLevel) (*types.UpdateHostImageAcceptanceLevelResponse, error) { 15535 var reqBody, resBody UpdateHostImageAcceptanceLevelBody 15536 15537 reqBody.Req = req 15538 15539 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15540 return nil, err 15541 } 15542 15543 return resBody.Res, nil 15544} 15545 15546type UpdateHostProfileBody struct { 15547 Req *types.UpdateHostProfile `xml:"urn:vim25 UpdateHostProfile,omitempty"` 15548 Res *types.UpdateHostProfileResponse `xml:"urn:vim25 UpdateHostProfileResponse,omitempty"` 15549 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15550} 15551 15552func (b *UpdateHostProfileBody) Fault() *soap.Fault { return b.Fault_ } 15553 15554func UpdateHostProfile(ctx context.Context, r soap.RoundTripper, req *types.UpdateHostProfile) (*types.UpdateHostProfileResponse, error) { 15555 var reqBody, resBody UpdateHostProfileBody 15556 15557 reqBody.Req = req 15558 15559 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15560 return nil, err 15561 } 15562 15563 return resBody.Res, nil 15564} 15565 15566type UpdateHostSpecificationBody struct { 15567 Req *types.UpdateHostSpecification `xml:"urn:vim25 UpdateHostSpecification,omitempty"` 15568 Res *types.UpdateHostSpecificationResponse `xml:"urn:vim25 UpdateHostSpecificationResponse,omitempty"` 15569 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15570} 15571 15572func (b *UpdateHostSpecificationBody) Fault() *soap.Fault { return b.Fault_ } 15573 15574func UpdateHostSpecification(ctx context.Context, r soap.RoundTripper, req *types.UpdateHostSpecification) (*types.UpdateHostSpecificationResponse, error) { 15575 var reqBody, resBody UpdateHostSpecificationBody 15576 15577 reqBody.Req = req 15578 15579 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15580 return nil, err 15581 } 15582 15583 return resBody.Res, nil 15584} 15585 15586type UpdateHostSubSpecificationBody struct { 15587 Req *types.UpdateHostSubSpecification `xml:"urn:vim25 UpdateHostSubSpecification,omitempty"` 15588 Res *types.UpdateHostSubSpecificationResponse `xml:"urn:vim25 UpdateHostSubSpecificationResponse,omitempty"` 15589 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15590} 15591 15592func (b *UpdateHostSubSpecificationBody) Fault() *soap.Fault { return b.Fault_ } 15593 15594func UpdateHostSubSpecification(ctx context.Context, r soap.RoundTripper, req *types.UpdateHostSubSpecification) (*types.UpdateHostSubSpecificationResponse, error) { 15595 var reqBody, resBody UpdateHostSubSpecificationBody 15596 15597 reqBody.Req = req 15598 15599 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15600 return nil, err 15601 } 15602 15603 return resBody.Res, nil 15604} 15605 15606type UpdateInternetScsiAdvancedOptionsBody struct { 15607 Req *types.UpdateInternetScsiAdvancedOptions `xml:"urn:vim25 UpdateInternetScsiAdvancedOptions,omitempty"` 15608 Res *types.UpdateInternetScsiAdvancedOptionsResponse `xml:"urn:vim25 UpdateInternetScsiAdvancedOptionsResponse,omitempty"` 15609 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15610} 15611 15612func (b *UpdateInternetScsiAdvancedOptionsBody) Fault() *soap.Fault { return b.Fault_ } 15613 15614func UpdateInternetScsiAdvancedOptions(ctx context.Context, r soap.RoundTripper, req *types.UpdateInternetScsiAdvancedOptions) (*types.UpdateInternetScsiAdvancedOptionsResponse, error) { 15615 var reqBody, resBody UpdateInternetScsiAdvancedOptionsBody 15616 15617 reqBody.Req = req 15618 15619 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15620 return nil, err 15621 } 15622 15623 return resBody.Res, nil 15624} 15625 15626type UpdateInternetScsiAliasBody struct { 15627 Req *types.UpdateInternetScsiAlias `xml:"urn:vim25 UpdateInternetScsiAlias,omitempty"` 15628 Res *types.UpdateInternetScsiAliasResponse `xml:"urn:vim25 UpdateInternetScsiAliasResponse,omitempty"` 15629 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15630} 15631 15632func (b *UpdateInternetScsiAliasBody) Fault() *soap.Fault { return b.Fault_ } 15633 15634func UpdateInternetScsiAlias(ctx context.Context, r soap.RoundTripper, req *types.UpdateInternetScsiAlias) (*types.UpdateInternetScsiAliasResponse, error) { 15635 var reqBody, resBody UpdateInternetScsiAliasBody 15636 15637 reqBody.Req = req 15638 15639 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15640 return nil, err 15641 } 15642 15643 return resBody.Res, nil 15644} 15645 15646type UpdateInternetScsiAuthenticationPropertiesBody struct { 15647 Req *types.UpdateInternetScsiAuthenticationProperties `xml:"urn:vim25 UpdateInternetScsiAuthenticationProperties,omitempty"` 15648 Res *types.UpdateInternetScsiAuthenticationPropertiesResponse `xml:"urn:vim25 UpdateInternetScsiAuthenticationPropertiesResponse,omitempty"` 15649 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15650} 15651 15652func (b *UpdateInternetScsiAuthenticationPropertiesBody) Fault() *soap.Fault { return b.Fault_ } 15653 15654func UpdateInternetScsiAuthenticationProperties(ctx context.Context, r soap.RoundTripper, req *types.UpdateInternetScsiAuthenticationProperties) (*types.UpdateInternetScsiAuthenticationPropertiesResponse, error) { 15655 var reqBody, resBody UpdateInternetScsiAuthenticationPropertiesBody 15656 15657 reqBody.Req = req 15658 15659 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15660 return nil, err 15661 } 15662 15663 return resBody.Res, nil 15664} 15665 15666type UpdateInternetScsiDigestPropertiesBody struct { 15667 Req *types.UpdateInternetScsiDigestProperties `xml:"urn:vim25 UpdateInternetScsiDigestProperties,omitempty"` 15668 Res *types.UpdateInternetScsiDigestPropertiesResponse `xml:"urn:vim25 UpdateInternetScsiDigestPropertiesResponse,omitempty"` 15669 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15670} 15671 15672func (b *UpdateInternetScsiDigestPropertiesBody) Fault() *soap.Fault { return b.Fault_ } 15673 15674func UpdateInternetScsiDigestProperties(ctx context.Context, r soap.RoundTripper, req *types.UpdateInternetScsiDigestProperties) (*types.UpdateInternetScsiDigestPropertiesResponse, error) { 15675 var reqBody, resBody UpdateInternetScsiDigestPropertiesBody 15676 15677 reqBody.Req = req 15678 15679 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15680 return nil, err 15681 } 15682 15683 return resBody.Res, nil 15684} 15685 15686type UpdateInternetScsiDiscoveryPropertiesBody struct { 15687 Req *types.UpdateInternetScsiDiscoveryProperties `xml:"urn:vim25 UpdateInternetScsiDiscoveryProperties,omitempty"` 15688 Res *types.UpdateInternetScsiDiscoveryPropertiesResponse `xml:"urn:vim25 UpdateInternetScsiDiscoveryPropertiesResponse,omitempty"` 15689 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15690} 15691 15692func (b *UpdateInternetScsiDiscoveryPropertiesBody) Fault() *soap.Fault { return b.Fault_ } 15693 15694func UpdateInternetScsiDiscoveryProperties(ctx context.Context, r soap.RoundTripper, req *types.UpdateInternetScsiDiscoveryProperties) (*types.UpdateInternetScsiDiscoveryPropertiesResponse, error) { 15695 var reqBody, resBody UpdateInternetScsiDiscoveryPropertiesBody 15696 15697 reqBody.Req = req 15698 15699 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15700 return nil, err 15701 } 15702 15703 return resBody.Res, nil 15704} 15705 15706type UpdateInternetScsiIPPropertiesBody struct { 15707 Req *types.UpdateInternetScsiIPProperties `xml:"urn:vim25 UpdateInternetScsiIPProperties,omitempty"` 15708 Res *types.UpdateInternetScsiIPPropertiesResponse `xml:"urn:vim25 UpdateInternetScsiIPPropertiesResponse,omitempty"` 15709 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15710} 15711 15712func (b *UpdateInternetScsiIPPropertiesBody) Fault() *soap.Fault { return b.Fault_ } 15713 15714func UpdateInternetScsiIPProperties(ctx context.Context, r soap.RoundTripper, req *types.UpdateInternetScsiIPProperties) (*types.UpdateInternetScsiIPPropertiesResponse, error) { 15715 var reqBody, resBody UpdateInternetScsiIPPropertiesBody 15716 15717 reqBody.Req = req 15718 15719 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15720 return nil, err 15721 } 15722 15723 return resBody.Res, nil 15724} 15725 15726type UpdateInternetScsiNameBody struct { 15727 Req *types.UpdateInternetScsiName `xml:"urn:vim25 UpdateInternetScsiName,omitempty"` 15728 Res *types.UpdateInternetScsiNameResponse `xml:"urn:vim25 UpdateInternetScsiNameResponse,omitempty"` 15729 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15730} 15731 15732func (b *UpdateInternetScsiNameBody) Fault() *soap.Fault { return b.Fault_ } 15733 15734func UpdateInternetScsiName(ctx context.Context, r soap.RoundTripper, req *types.UpdateInternetScsiName) (*types.UpdateInternetScsiNameResponse, error) { 15735 var reqBody, resBody UpdateInternetScsiNameBody 15736 15737 reqBody.Req = req 15738 15739 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15740 return nil, err 15741 } 15742 15743 return resBody.Res, nil 15744} 15745 15746type UpdateIpConfigBody struct { 15747 Req *types.UpdateIpConfig `xml:"urn:vim25 UpdateIpConfig,omitempty"` 15748 Res *types.UpdateIpConfigResponse `xml:"urn:vim25 UpdateIpConfigResponse,omitempty"` 15749 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15750} 15751 15752func (b *UpdateIpConfigBody) Fault() *soap.Fault { return b.Fault_ } 15753 15754func UpdateIpConfig(ctx context.Context, r soap.RoundTripper, req *types.UpdateIpConfig) (*types.UpdateIpConfigResponse, error) { 15755 var reqBody, resBody UpdateIpConfigBody 15756 15757 reqBody.Req = req 15758 15759 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15760 return nil, err 15761 } 15762 15763 return resBody.Res, nil 15764} 15765 15766type UpdateIpPoolBody struct { 15767 Req *types.UpdateIpPool `xml:"urn:vim25 UpdateIpPool,omitempty"` 15768 Res *types.UpdateIpPoolResponse `xml:"urn:vim25 UpdateIpPoolResponse,omitempty"` 15769 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15770} 15771 15772func (b *UpdateIpPoolBody) Fault() *soap.Fault { return b.Fault_ } 15773 15774func UpdateIpPool(ctx context.Context, r soap.RoundTripper, req *types.UpdateIpPool) (*types.UpdateIpPoolResponse, error) { 15775 var reqBody, resBody UpdateIpPoolBody 15776 15777 reqBody.Req = req 15778 15779 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15780 return nil, err 15781 } 15782 15783 return resBody.Res, nil 15784} 15785 15786type UpdateIpRouteConfigBody struct { 15787 Req *types.UpdateIpRouteConfig `xml:"urn:vim25 UpdateIpRouteConfig,omitempty"` 15788 Res *types.UpdateIpRouteConfigResponse `xml:"urn:vim25 UpdateIpRouteConfigResponse,omitempty"` 15789 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15790} 15791 15792func (b *UpdateIpRouteConfigBody) Fault() *soap.Fault { return b.Fault_ } 15793 15794func UpdateIpRouteConfig(ctx context.Context, r soap.RoundTripper, req *types.UpdateIpRouteConfig) (*types.UpdateIpRouteConfigResponse, error) { 15795 var reqBody, resBody UpdateIpRouteConfigBody 15796 15797 reqBody.Req = req 15798 15799 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15800 return nil, err 15801 } 15802 15803 return resBody.Res, nil 15804} 15805 15806type UpdateIpRouteTableConfigBody struct { 15807 Req *types.UpdateIpRouteTableConfig `xml:"urn:vim25 UpdateIpRouteTableConfig,omitempty"` 15808 Res *types.UpdateIpRouteTableConfigResponse `xml:"urn:vim25 UpdateIpRouteTableConfigResponse,omitempty"` 15809 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15810} 15811 15812func (b *UpdateIpRouteTableConfigBody) Fault() *soap.Fault { return b.Fault_ } 15813 15814func UpdateIpRouteTableConfig(ctx context.Context, r soap.RoundTripper, req *types.UpdateIpRouteTableConfig) (*types.UpdateIpRouteTableConfigResponse, error) { 15815 var reqBody, resBody UpdateIpRouteTableConfigBody 15816 15817 reqBody.Req = req 15818 15819 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15820 return nil, err 15821 } 15822 15823 return resBody.Res, nil 15824} 15825 15826type UpdateIpmiBody struct { 15827 Req *types.UpdateIpmi `xml:"urn:vim25 UpdateIpmi,omitempty"` 15828 Res *types.UpdateIpmiResponse `xml:"urn:vim25 UpdateIpmiResponse,omitempty"` 15829 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15830} 15831 15832func (b *UpdateIpmiBody) Fault() *soap.Fault { return b.Fault_ } 15833 15834func UpdateIpmi(ctx context.Context, r soap.RoundTripper, req *types.UpdateIpmi) (*types.UpdateIpmiResponse, error) { 15835 var reqBody, resBody UpdateIpmiBody 15836 15837 reqBody.Req = req 15838 15839 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15840 return nil, err 15841 } 15842 15843 return resBody.Res, nil 15844} 15845 15846type UpdateKmipServerBody struct { 15847 Req *types.UpdateKmipServer `xml:"urn:vim25 UpdateKmipServer,omitempty"` 15848 Res *types.UpdateKmipServerResponse `xml:"urn:vim25 UpdateKmipServerResponse,omitempty"` 15849 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15850} 15851 15852func (b *UpdateKmipServerBody) Fault() *soap.Fault { return b.Fault_ } 15853 15854func UpdateKmipServer(ctx context.Context, r soap.RoundTripper, req *types.UpdateKmipServer) (*types.UpdateKmipServerResponse, error) { 15855 var reqBody, resBody UpdateKmipServerBody 15856 15857 reqBody.Req = req 15858 15859 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15860 return nil, err 15861 } 15862 15863 return resBody.Res, nil 15864} 15865 15866type UpdateKmsSignedCsrClientCertBody struct { 15867 Req *types.UpdateKmsSignedCsrClientCert `xml:"urn:vim25 UpdateKmsSignedCsrClientCert,omitempty"` 15868 Res *types.UpdateKmsSignedCsrClientCertResponse `xml:"urn:vim25 UpdateKmsSignedCsrClientCertResponse,omitempty"` 15869 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15870} 15871 15872func (b *UpdateKmsSignedCsrClientCertBody) Fault() *soap.Fault { return b.Fault_ } 15873 15874func UpdateKmsSignedCsrClientCert(ctx context.Context, r soap.RoundTripper, req *types.UpdateKmsSignedCsrClientCert) (*types.UpdateKmsSignedCsrClientCertResponse, error) { 15875 var reqBody, resBody UpdateKmsSignedCsrClientCertBody 15876 15877 reqBody.Req = req 15878 15879 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15880 return nil, err 15881 } 15882 15883 return resBody.Res, nil 15884} 15885 15886type UpdateLicenseBody struct { 15887 Req *types.UpdateLicense `xml:"urn:vim25 UpdateLicense,omitempty"` 15888 Res *types.UpdateLicenseResponse `xml:"urn:vim25 UpdateLicenseResponse,omitempty"` 15889 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15890} 15891 15892func (b *UpdateLicenseBody) Fault() *soap.Fault { return b.Fault_ } 15893 15894func UpdateLicense(ctx context.Context, r soap.RoundTripper, req *types.UpdateLicense) (*types.UpdateLicenseResponse, error) { 15895 var reqBody, resBody UpdateLicenseBody 15896 15897 reqBody.Req = req 15898 15899 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15900 return nil, err 15901 } 15902 15903 return resBody.Res, nil 15904} 15905 15906type UpdateLicenseLabelBody struct { 15907 Req *types.UpdateLicenseLabel `xml:"urn:vim25 UpdateLicenseLabel,omitempty"` 15908 Res *types.UpdateLicenseLabelResponse `xml:"urn:vim25 UpdateLicenseLabelResponse,omitempty"` 15909 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15910} 15911 15912func (b *UpdateLicenseLabelBody) Fault() *soap.Fault { return b.Fault_ } 15913 15914func UpdateLicenseLabel(ctx context.Context, r soap.RoundTripper, req *types.UpdateLicenseLabel) (*types.UpdateLicenseLabelResponse, error) { 15915 var reqBody, resBody UpdateLicenseLabelBody 15916 15917 reqBody.Req = req 15918 15919 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15920 return nil, err 15921 } 15922 15923 return resBody.Res, nil 15924} 15925 15926type UpdateLinkedChildrenBody struct { 15927 Req *types.UpdateLinkedChildren `xml:"urn:vim25 UpdateLinkedChildren,omitempty"` 15928 Res *types.UpdateLinkedChildrenResponse `xml:"urn:vim25 UpdateLinkedChildrenResponse,omitempty"` 15929 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15930} 15931 15932func (b *UpdateLinkedChildrenBody) Fault() *soap.Fault { return b.Fault_ } 15933 15934func UpdateLinkedChildren(ctx context.Context, r soap.RoundTripper, req *types.UpdateLinkedChildren) (*types.UpdateLinkedChildrenResponse, error) { 15935 var reqBody, resBody UpdateLinkedChildrenBody 15936 15937 reqBody.Req = req 15938 15939 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15940 return nil, err 15941 } 15942 15943 return resBody.Res, nil 15944} 15945 15946type UpdateLocalSwapDatastoreBody struct { 15947 Req *types.UpdateLocalSwapDatastore `xml:"urn:vim25 UpdateLocalSwapDatastore,omitempty"` 15948 Res *types.UpdateLocalSwapDatastoreResponse `xml:"urn:vim25 UpdateLocalSwapDatastoreResponse,omitempty"` 15949 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15950} 15951 15952func (b *UpdateLocalSwapDatastoreBody) Fault() *soap.Fault { return b.Fault_ } 15953 15954func UpdateLocalSwapDatastore(ctx context.Context, r soap.RoundTripper, req *types.UpdateLocalSwapDatastore) (*types.UpdateLocalSwapDatastoreResponse, error) { 15955 var reqBody, resBody UpdateLocalSwapDatastoreBody 15956 15957 reqBody.Req = req 15958 15959 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15960 return nil, err 15961 } 15962 15963 return resBody.Res, nil 15964} 15965 15966type UpdateLockdownExceptionsBody struct { 15967 Req *types.UpdateLockdownExceptions `xml:"urn:vim25 UpdateLockdownExceptions,omitempty"` 15968 Res *types.UpdateLockdownExceptionsResponse `xml:"urn:vim25 UpdateLockdownExceptionsResponse,omitempty"` 15969 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15970} 15971 15972func (b *UpdateLockdownExceptionsBody) Fault() *soap.Fault { return b.Fault_ } 15973 15974func UpdateLockdownExceptions(ctx context.Context, r soap.RoundTripper, req *types.UpdateLockdownExceptions) (*types.UpdateLockdownExceptionsResponse, error) { 15975 var reqBody, resBody UpdateLockdownExceptionsBody 15976 15977 reqBody.Req = req 15978 15979 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 15980 return nil, err 15981 } 15982 15983 return resBody.Res, nil 15984} 15985 15986type UpdateModuleOptionStringBody struct { 15987 Req *types.UpdateModuleOptionString `xml:"urn:vim25 UpdateModuleOptionString,omitempty"` 15988 Res *types.UpdateModuleOptionStringResponse `xml:"urn:vim25 UpdateModuleOptionStringResponse,omitempty"` 15989 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 15990} 15991 15992func (b *UpdateModuleOptionStringBody) Fault() *soap.Fault { return b.Fault_ } 15993 15994func UpdateModuleOptionString(ctx context.Context, r soap.RoundTripper, req *types.UpdateModuleOptionString) (*types.UpdateModuleOptionStringResponse, error) { 15995 var reqBody, resBody UpdateModuleOptionStringBody 15996 15997 reqBody.Req = req 15998 15999 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16000 return nil, err 16001 } 16002 16003 return resBody.Res, nil 16004} 16005 16006type UpdateNetworkConfigBody struct { 16007 Req *types.UpdateNetworkConfig `xml:"urn:vim25 UpdateNetworkConfig,omitempty"` 16008 Res *types.UpdateNetworkConfigResponse `xml:"urn:vim25 UpdateNetworkConfigResponse,omitempty"` 16009 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16010} 16011 16012func (b *UpdateNetworkConfigBody) Fault() *soap.Fault { return b.Fault_ } 16013 16014func UpdateNetworkConfig(ctx context.Context, r soap.RoundTripper, req *types.UpdateNetworkConfig) (*types.UpdateNetworkConfigResponse, error) { 16015 var reqBody, resBody UpdateNetworkConfigBody 16016 16017 reqBody.Req = req 16018 16019 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16020 return nil, err 16021 } 16022 16023 return resBody.Res, nil 16024} 16025 16026type UpdateNetworkResourcePoolBody struct { 16027 Req *types.UpdateNetworkResourcePool `xml:"urn:vim25 UpdateNetworkResourcePool,omitempty"` 16028 Res *types.UpdateNetworkResourcePoolResponse `xml:"urn:vim25 UpdateNetworkResourcePoolResponse,omitempty"` 16029 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16030} 16031 16032func (b *UpdateNetworkResourcePoolBody) Fault() *soap.Fault { return b.Fault_ } 16033 16034func UpdateNetworkResourcePool(ctx context.Context, r soap.RoundTripper, req *types.UpdateNetworkResourcePool) (*types.UpdateNetworkResourcePoolResponse, error) { 16035 var reqBody, resBody UpdateNetworkResourcePoolBody 16036 16037 reqBody.Req = req 16038 16039 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16040 return nil, err 16041 } 16042 16043 return resBody.Res, nil 16044} 16045 16046type UpdateOptionsBody struct { 16047 Req *types.UpdateOptions `xml:"urn:vim25 UpdateOptions,omitempty"` 16048 Res *types.UpdateOptionsResponse `xml:"urn:vim25 UpdateOptionsResponse,omitempty"` 16049 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16050} 16051 16052func (b *UpdateOptionsBody) Fault() *soap.Fault { return b.Fault_ } 16053 16054func UpdateOptions(ctx context.Context, r soap.RoundTripper, req *types.UpdateOptions) (*types.UpdateOptionsResponse, error) { 16055 var reqBody, resBody UpdateOptionsBody 16056 16057 reqBody.Req = req 16058 16059 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16060 return nil, err 16061 } 16062 16063 return resBody.Res, nil 16064} 16065 16066type UpdatePassthruConfigBody struct { 16067 Req *types.UpdatePassthruConfig `xml:"urn:vim25 UpdatePassthruConfig,omitempty"` 16068 Res *types.UpdatePassthruConfigResponse `xml:"urn:vim25 UpdatePassthruConfigResponse,omitempty"` 16069 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16070} 16071 16072func (b *UpdatePassthruConfigBody) Fault() *soap.Fault { return b.Fault_ } 16073 16074func UpdatePassthruConfig(ctx context.Context, r soap.RoundTripper, req *types.UpdatePassthruConfig) (*types.UpdatePassthruConfigResponse, error) { 16075 var reqBody, resBody UpdatePassthruConfigBody 16076 16077 reqBody.Req = req 16078 16079 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16080 return nil, err 16081 } 16082 16083 return resBody.Res, nil 16084} 16085 16086type UpdatePerfIntervalBody struct { 16087 Req *types.UpdatePerfInterval `xml:"urn:vim25 UpdatePerfInterval,omitempty"` 16088 Res *types.UpdatePerfIntervalResponse `xml:"urn:vim25 UpdatePerfIntervalResponse,omitempty"` 16089 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16090} 16091 16092func (b *UpdatePerfIntervalBody) Fault() *soap.Fault { return b.Fault_ } 16093 16094func UpdatePerfInterval(ctx context.Context, r soap.RoundTripper, req *types.UpdatePerfInterval) (*types.UpdatePerfIntervalResponse, error) { 16095 var reqBody, resBody UpdatePerfIntervalBody 16096 16097 reqBody.Req = req 16098 16099 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16100 return nil, err 16101 } 16102 16103 return resBody.Res, nil 16104} 16105 16106type UpdatePhysicalNicLinkSpeedBody struct { 16107 Req *types.UpdatePhysicalNicLinkSpeed `xml:"urn:vim25 UpdatePhysicalNicLinkSpeed,omitempty"` 16108 Res *types.UpdatePhysicalNicLinkSpeedResponse `xml:"urn:vim25 UpdatePhysicalNicLinkSpeedResponse,omitempty"` 16109 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16110} 16111 16112func (b *UpdatePhysicalNicLinkSpeedBody) Fault() *soap.Fault { return b.Fault_ } 16113 16114func UpdatePhysicalNicLinkSpeed(ctx context.Context, r soap.RoundTripper, req *types.UpdatePhysicalNicLinkSpeed) (*types.UpdatePhysicalNicLinkSpeedResponse, error) { 16115 var reqBody, resBody UpdatePhysicalNicLinkSpeedBody 16116 16117 reqBody.Req = req 16118 16119 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16120 return nil, err 16121 } 16122 16123 return resBody.Res, nil 16124} 16125 16126type UpdatePortGroupBody struct { 16127 Req *types.UpdatePortGroup `xml:"urn:vim25 UpdatePortGroup,omitempty"` 16128 Res *types.UpdatePortGroupResponse `xml:"urn:vim25 UpdatePortGroupResponse,omitempty"` 16129 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16130} 16131 16132func (b *UpdatePortGroupBody) Fault() *soap.Fault { return b.Fault_ } 16133 16134func UpdatePortGroup(ctx context.Context, r soap.RoundTripper, req *types.UpdatePortGroup) (*types.UpdatePortGroupResponse, error) { 16135 var reqBody, resBody UpdatePortGroupBody 16136 16137 reqBody.Req = req 16138 16139 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16140 return nil, err 16141 } 16142 16143 return resBody.Res, nil 16144} 16145 16146type UpdateProgressBody struct { 16147 Req *types.UpdateProgress `xml:"urn:vim25 UpdateProgress,omitempty"` 16148 Res *types.UpdateProgressResponse `xml:"urn:vim25 UpdateProgressResponse,omitempty"` 16149 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16150} 16151 16152func (b *UpdateProgressBody) Fault() *soap.Fault { return b.Fault_ } 16153 16154func UpdateProgress(ctx context.Context, r soap.RoundTripper, req *types.UpdateProgress) (*types.UpdateProgressResponse, error) { 16155 var reqBody, resBody UpdateProgressBody 16156 16157 reqBody.Req = req 16158 16159 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16160 return nil, err 16161 } 16162 16163 return resBody.Res, nil 16164} 16165 16166type UpdateReferenceHostBody struct { 16167 Req *types.UpdateReferenceHost `xml:"urn:vim25 UpdateReferenceHost,omitempty"` 16168 Res *types.UpdateReferenceHostResponse `xml:"urn:vim25 UpdateReferenceHostResponse,omitempty"` 16169 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16170} 16171 16172func (b *UpdateReferenceHostBody) Fault() *soap.Fault { return b.Fault_ } 16173 16174func UpdateReferenceHost(ctx context.Context, r soap.RoundTripper, req *types.UpdateReferenceHost) (*types.UpdateReferenceHostResponse, error) { 16175 var reqBody, resBody UpdateReferenceHostBody 16176 16177 reqBody.Req = req 16178 16179 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16180 return nil, err 16181 } 16182 16183 return resBody.Res, nil 16184} 16185 16186type UpdateRulesetBody struct { 16187 Req *types.UpdateRuleset `xml:"urn:vim25 UpdateRuleset,omitempty"` 16188 Res *types.UpdateRulesetResponse `xml:"urn:vim25 UpdateRulesetResponse,omitempty"` 16189 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16190} 16191 16192func (b *UpdateRulesetBody) Fault() *soap.Fault { return b.Fault_ } 16193 16194func UpdateRuleset(ctx context.Context, r soap.RoundTripper, req *types.UpdateRuleset) (*types.UpdateRulesetResponse, error) { 16195 var reqBody, resBody UpdateRulesetBody 16196 16197 reqBody.Req = req 16198 16199 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16200 return nil, err 16201 } 16202 16203 return resBody.Res, nil 16204} 16205 16206type UpdateScsiLunDisplayNameBody struct { 16207 Req *types.UpdateScsiLunDisplayName `xml:"urn:vim25 UpdateScsiLunDisplayName,omitempty"` 16208 Res *types.UpdateScsiLunDisplayNameResponse `xml:"urn:vim25 UpdateScsiLunDisplayNameResponse,omitempty"` 16209 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16210} 16211 16212func (b *UpdateScsiLunDisplayNameBody) Fault() *soap.Fault { return b.Fault_ } 16213 16214func UpdateScsiLunDisplayName(ctx context.Context, r soap.RoundTripper, req *types.UpdateScsiLunDisplayName) (*types.UpdateScsiLunDisplayNameResponse, error) { 16215 var reqBody, resBody UpdateScsiLunDisplayNameBody 16216 16217 reqBody.Req = req 16218 16219 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16220 return nil, err 16221 } 16222 16223 return resBody.Res, nil 16224} 16225 16226type UpdateSelfSignedClientCertBody struct { 16227 Req *types.UpdateSelfSignedClientCert `xml:"urn:vim25 UpdateSelfSignedClientCert,omitempty"` 16228 Res *types.UpdateSelfSignedClientCertResponse `xml:"urn:vim25 UpdateSelfSignedClientCertResponse,omitempty"` 16229 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16230} 16231 16232func (b *UpdateSelfSignedClientCertBody) Fault() *soap.Fault { return b.Fault_ } 16233 16234func UpdateSelfSignedClientCert(ctx context.Context, r soap.RoundTripper, req *types.UpdateSelfSignedClientCert) (*types.UpdateSelfSignedClientCertResponse, error) { 16235 var reqBody, resBody UpdateSelfSignedClientCertBody 16236 16237 reqBody.Req = req 16238 16239 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16240 return nil, err 16241 } 16242 16243 return resBody.Res, nil 16244} 16245 16246type UpdateServiceConsoleVirtualNicBody struct { 16247 Req *types.UpdateServiceConsoleVirtualNic `xml:"urn:vim25 UpdateServiceConsoleVirtualNic,omitempty"` 16248 Res *types.UpdateServiceConsoleVirtualNicResponse `xml:"urn:vim25 UpdateServiceConsoleVirtualNicResponse,omitempty"` 16249 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16250} 16251 16252func (b *UpdateServiceConsoleVirtualNicBody) Fault() *soap.Fault { return b.Fault_ } 16253 16254func UpdateServiceConsoleVirtualNic(ctx context.Context, r soap.RoundTripper, req *types.UpdateServiceConsoleVirtualNic) (*types.UpdateServiceConsoleVirtualNicResponse, error) { 16255 var reqBody, resBody UpdateServiceConsoleVirtualNicBody 16256 16257 reqBody.Req = req 16258 16259 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16260 return nil, err 16261 } 16262 16263 return resBody.Res, nil 16264} 16265 16266type UpdateServiceMessageBody struct { 16267 Req *types.UpdateServiceMessage `xml:"urn:vim25 UpdateServiceMessage,omitempty"` 16268 Res *types.UpdateServiceMessageResponse `xml:"urn:vim25 UpdateServiceMessageResponse,omitempty"` 16269 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16270} 16271 16272func (b *UpdateServiceMessageBody) Fault() *soap.Fault { return b.Fault_ } 16273 16274func UpdateServiceMessage(ctx context.Context, r soap.RoundTripper, req *types.UpdateServiceMessage) (*types.UpdateServiceMessageResponse, error) { 16275 var reqBody, resBody UpdateServiceMessageBody 16276 16277 reqBody.Req = req 16278 16279 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16280 return nil, err 16281 } 16282 16283 return resBody.Res, nil 16284} 16285 16286type UpdateServicePolicyBody struct { 16287 Req *types.UpdateServicePolicy `xml:"urn:vim25 UpdateServicePolicy,omitempty"` 16288 Res *types.UpdateServicePolicyResponse `xml:"urn:vim25 UpdateServicePolicyResponse,omitempty"` 16289 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16290} 16291 16292func (b *UpdateServicePolicyBody) Fault() *soap.Fault { return b.Fault_ } 16293 16294func UpdateServicePolicy(ctx context.Context, r soap.RoundTripper, req *types.UpdateServicePolicy) (*types.UpdateServicePolicyResponse, error) { 16295 var reqBody, resBody UpdateServicePolicyBody 16296 16297 reqBody.Req = req 16298 16299 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16300 return nil, err 16301 } 16302 16303 return resBody.Res, nil 16304} 16305 16306type UpdateSoftwareInternetScsiEnabledBody struct { 16307 Req *types.UpdateSoftwareInternetScsiEnabled `xml:"urn:vim25 UpdateSoftwareInternetScsiEnabled,omitempty"` 16308 Res *types.UpdateSoftwareInternetScsiEnabledResponse `xml:"urn:vim25 UpdateSoftwareInternetScsiEnabledResponse,omitempty"` 16309 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16310} 16311 16312func (b *UpdateSoftwareInternetScsiEnabledBody) Fault() *soap.Fault { return b.Fault_ } 16313 16314func UpdateSoftwareInternetScsiEnabled(ctx context.Context, r soap.RoundTripper, req *types.UpdateSoftwareInternetScsiEnabled) (*types.UpdateSoftwareInternetScsiEnabledResponse, error) { 16315 var reqBody, resBody UpdateSoftwareInternetScsiEnabledBody 16316 16317 reqBody.Req = req 16318 16319 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16320 return nil, err 16321 } 16322 16323 return resBody.Res, nil 16324} 16325 16326type UpdateSystemResourcesBody struct { 16327 Req *types.UpdateSystemResources `xml:"urn:vim25 UpdateSystemResources,omitempty"` 16328 Res *types.UpdateSystemResourcesResponse `xml:"urn:vim25 UpdateSystemResourcesResponse,omitempty"` 16329 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16330} 16331 16332func (b *UpdateSystemResourcesBody) Fault() *soap.Fault { return b.Fault_ } 16333 16334func UpdateSystemResources(ctx context.Context, r soap.RoundTripper, req *types.UpdateSystemResources) (*types.UpdateSystemResourcesResponse, error) { 16335 var reqBody, resBody UpdateSystemResourcesBody 16336 16337 reqBody.Req = req 16338 16339 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16340 return nil, err 16341 } 16342 16343 return resBody.Res, nil 16344} 16345 16346type UpdateSystemSwapConfigurationBody struct { 16347 Req *types.UpdateSystemSwapConfiguration `xml:"urn:vim25 UpdateSystemSwapConfiguration,omitempty"` 16348 Res *types.UpdateSystemSwapConfigurationResponse `xml:"urn:vim25 UpdateSystemSwapConfigurationResponse,omitempty"` 16349 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16350} 16351 16352func (b *UpdateSystemSwapConfigurationBody) Fault() *soap.Fault { return b.Fault_ } 16353 16354func UpdateSystemSwapConfiguration(ctx context.Context, r soap.RoundTripper, req *types.UpdateSystemSwapConfiguration) (*types.UpdateSystemSwapConfigurationResponse, error) { 16355 var reqBody, resBody UpdateSystemSwapConfigurationBody 16356 16357 reqBody.Req = req 16358 16359 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16360 return nil, err 16361 } 16362 16363 return resBody.Res, nil 16364} 16365 16366type UpdateSystemUsersBody struct { 16367 Req *types.UpdateSystemUsers `xml:"urn:vim25 UpdateSystemUsers,omitempty"` 16368 Res *types.UpdateSystemUsersResponse `xml:"urn:vim25 UpdateSystemUsersResponse,omitempty"` 16369 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16370} 16371 16372func (b *UpdateSystemUsersBody) Fault() *soap.Fault { return b.Fault_ } 16373 16374func UpdateSystemUsers(ctx context.Context, r soap.RoundTripper, req *types.UpdateSystemUsers) (*types.UpdateSystemUsersResponse, error) { 16375 var reqBody, resBody UpdateSystemUsersBody 16376 16377 reqBody.Req = req 16378 16379 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16380 return nil, err 16381 } 16382 16383 return resBody.Res, nil 16384} 16385 16386type UpdateUserBody struct { 16387 Req *types.UpdateUser `xml:"urn:vim25 UpdateUser,omitempty"` 16388 Res *types.UpdateUserResponse `xml:"urn:vim25 UpdateUserResponse,omitempty"` 16389 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16390} 16391 16392func (b *UpdateUserBody) Fault() *soap.Fault { return b.Fault_ } 16393 16394func UpdateUser(ctx context.Context, r soap.RoundTripper, req *types.UpdateUser) (*types.UpdateUserResponse, error) { 16395 var reqBody, resBody UpdateUserBody 16396 16397 reqBody.Req = req 16398 16399 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16400 return nil, err 16401 } 16402 16403 return resBody.Res, nil 16404} 16405 16406type UpdateVAppConfigBody struct { 16407 Req *types.UpdateVAppConfig `xml:"urn:vim25 UpdateVAppConfig,omitempty"` 16408 Res *types.UpdateVAppConfigResponse `xml:"urn:vim25 UpdateVAppConfigResponse,omitempty"` 16409 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16410} 16411 16412func (b *UpdateVAppConfigBody) Fault() *soap.Fault { return b.Fault_ } 16413 16414func UpdateVAppConfig(ctx context.Context, r soap.RoundTripper, req *types.UpdateVAppConfig) (*types.UpdateVAppConfigResponse, error) { 16415 var reqBody, resBody UpdateVAppConfigBody 16416 16417 reqBody.Req = req 16418 16419 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16420 return nil, err 16421 } 16422 16423 return resBody.Res, nil 16424} 16425 16426type UpdateVStorageInfrastructureObjectPolicy_TaskBody struct { 16427 Req *types.UpdateVStorageInfrastructureObjectPolicy_Task `xml:"urn:vim25 UpdateVStorageInfrastructureObjectPolicy_Task,omitempty"` 16428 Res *types.UpdateVStorageInfrastructureObjectPolicy_TaskResponse `xml:"urn:vim25 UpdateVStorageInfrastructureObjectPolicy_TaskResponse,omitempty"` 16429 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16430} 16431 16432func (b *UpdateVStorageInfrastructureObjectPolicy_TaskBody) Fault() *soap.Fault { return b.Fault_ } 16433 16434func UpdateVStorageInfrastructureObjectPolicy_Task(ctx context.Context, r soap.RoundTripper, req *types.UpdateVStorageInfrastructureObjectPolicy_Task) (*types.UpdateVStorageInfrastructureObjectPolicy_TaskResponse, error) { 16435 var reqBody, resBody UpdateVStorageInfrastructureObjectPolicy_TaskBody 16436 16437 reqBody.Req = req 16438 16439 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16440 return nil, err 16441 } 16442 16443 return resBody.Res, nil 16444} 16445 16446type UpdateVStorageObjectPolicy_TaskBody struct { 16447 Req *types.UpdateVStorageObjectPolicy_Task `xml:"urn:vim25 UpdateVStorageObjectPolicy_Task,omitempty"` 16448 Res *types.UpdateVStorageObjectPolicy_TaskResponse `xml:"urn:vim25 UpdateVStorageObjectPolicy_TaskResponse,omitempty"` 16449 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16450} 16451 16452func (b *UpdateVStorageObjectPolicy_TaskBody) Fault() *soap.Fault { return b.Fault_ } 16453 16454func UpdateVStorageObjectPolicy_Task(ctx context.Context, r soap.RoundTripper, req *types.UpdateVStorageObjectPolicy_Task) (*types.UpdateVStorageObjectPolicy_TaskResponse, error) { 16455 var reqBody, resBody UpdateVStorageObjectPolicy_TaskBody 16456 16457 reqBody.Req = req 16458 16459 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16460 return nil, err 16461 } 16462 16463 return resBody.Res, nil 16464} 16465 16466type UpdateVVolVirtualMachineFiles_TaskBody struct { 16467 Req *types.UpdateVVolVirtualMachineFiles_Task `xml:"urn:vim25 UpdateVVolVirtualMachineFiles_Task,omitempty"` 16468 Res *types.UpdateVVolVirtualMachineFiles_TaskResponse `xml:"urn:vim25 UpdateVVolVirtualMachineFiles_TaskResponse,omitempty"` 16469 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16470} 16471 16472func (b *UpdateVVolVirtualMachineFiles_TaskBody) Fault() *soap.Fault { return b.Fault_ } 16473 16474func UpdateVVolVirtualMachineFiles_Task(ctx context.Context, r soap.RoundTripper, req *types.UpdateVVolVirtualMachineFiles_Task) (*types.UpdateVVolVirtualMachineFiles_TaskResponse, error) { 16475 var reqBody, resBody UpdateVVolVirtualMachineFiles_TaskBody 16476 16477 reqBody.Req = req 16478 16479 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16480 return nil, err 16481 } 16482 16483 return resBody.Res, nil 16484} 16485 16486type UpdateVirtualMachineFiles_TaskBody struct { 16487 Req *types.UpdateVirtualMachineFiles_Task `xml:"urn:vim25 UpdateVirtualMachineFiles_Task,omitempty"` 16488 Res *types.UpdateVirtualMachineFiles_TaskResponse `xml:"urn:vim25 UpdateVirtualMachineFiles_TaskResponse,omitempty"` 16489 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16490} 16491 16492func (b *UpdateVirtualMachineFiles_TaskBody) Fault() *soap.Fault { return b.Fault_ } 16493 16494func UpdateVirtualMachineFiles_Task(ctx context.Context, r soap.RoundTripper, req *types.UpdateVirtualMachineFiles_Task) (*types.UpdateVirtualMachineFiles_TaskResponse, error) { 16495 var reqBody, resBody UpdateVirtualMachineFiles_TaskBody 16496 16497 reqBody.Req = req 16498 16499 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16500 return nil, err 16501 } 16502 16503 return resBody.Res, nil 16504} 16505 16506type UpdateVirtualNicBody struct { 16507 Req *types.UpdateVirtualNic `xml:"urn:vim25 UpdateVirtualNic,omitempty"` 16508 Res *types.UpdateVirtualNicResponse `xml:"urn:vim25 UpdateVirtualNicResponse,omitempty"` 16509 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16510} 16511 16512func (b *UpdateVirtualNicBody) Fault() *soap.Fault { return b.Fault_ } 16513 16514func UpdateVirtualNic(ctx context.Context, r soap.RoundTripper, req *types.UpdateVirtualNic) (*types.UpdateVirtualNicResponse, error) { 16515 var reqBody, resBody UpdateVirtualNicBody 16516 16517 reqBody.Req = req 16518 16519 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16520 return nil, err 16521 } 16522 16523 return resBody.Res, nil 16524} 16525 16526type UpdateVirtualSwitchBody struct { 16527 Req *types.UpdateVirtualSwitch `xml:"urn:vim25 UpdateVirtualSwitch,omitempty"` 16528 Res *types.UpdateVirtualSwitchResponse `xml:"urn:vim25 UpdateVirtualSwitchResponse,omitempty"` 16529 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16530} 16531 16532func (b *UpdateVirtualSwitchBody) Fault() *soap.Fault { return b.Fault_ } 16533 16534func UpdateVirtualSwitch(ctx context.Context, r soap.RoundTripper, req *types.UpdateVirtualSwitch) (*types.UpdateVirtualSwitchResponse, error) { 16535 var reqBody, resBody UpdateVirtualSwitchBody 16536 16537 reqBody.Req = req 16538 16539 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16540 return nil, err 16541 } 16542 16543 return resBody.Res, nil 16544} 16545 16546type UpdateVmfsUnmapBandwidthBody struct { 16547 Req *types.UpdateVmfsUnmapBandwidth `xml:"urn:vim25 UpdateVmfsUnmapBandwidth,omitempty"` 16548 Res *types.UpdateVmfsUnmapBandwidthResponse `xml:"urn:vim25 UpdateVmfsUnmapBandwidthResponse,omitempty"` 16549 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16550} 16551 16552func (b *UpdateVmfsUnmapBandwidthBody) Fault() *soap.Fault { return b.Fault_ } 16553 16554func UpdateVmfsUnmapBandwidth(ctx context.Context, r soap.RoundTripper, req *types.UpdateVmfsUnmapBandwidth) (*types.UpdateVmfsUnmapBandwidthResponse, error) { 16555 var reqBody, resBody UpdateVmfsUnmapBandwidthBody 16556 16557 reqBody.Req = req 16558 16559 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16560 return nil, err 16561 } 16562 16563 return resBody.Res, nil 16564} 16565 16566type UpdateVmfsUnmapPriorityBody struct { 16567 Req *types.UpdateVmfsUnmapPriority `xml:"urn:vim25 UpdateVmfsUnmapPriority,omitempty"` 16568 Res *types.UpdateVmfsUnmapPriorityResponse `xml:"urn:vim25 UpdateVmfsUnmapPriorityResponse,omitempty"` 16569 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16570} 16571 16572func (b *UpdateVmfsUnmapPriorityBody) Fault() *soap.Fault { return b.Fault_ } 16573 16574func UpdateVmfsUnmapPriority(ctx context.Context, r soap.RoundTripper, req *types.UpdateVmfsUnmapPriority) (*types.UpdateVmfsUnmapPriorityResponse, error) { 16575 var reqBody, resBody UpdateVmfsUnmapPriorityBody 16576 16577 reqBody.Req = req 16578 16579 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16580 return nil, err 16581 } 16582 16583 return resBody.Res, nil 16584} 16585 16586type UpdateVsan_TaskBody struct { 16587 Req *types.UpdateVsan_Task `xml:"urn:vim25 UpdateVsan_Task,omitempty"` 16588 Res *types.UpdateVsan_TaskResponse `xml:"urn:vim25 UpdateVsan_TaskResponse,omitempty"` 16589 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16590} 16591 16592func (b *UpdateVsan_TaskBody) Fault() *soap.Fault { return b.Fault_ } 16593 16594func UpdateVsan_Task(ctx context.Context, r soap.RoundTripper, req *types.UpdateVsan_Task) (*types.UpdateVsan_TaskResponse, error) { 16595 var reqBody, resBody UpdateVsan_TaskBody 16596 16597 reqBody.Req = req 16598 16599 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16600 return nil, err 16601 } 16602 16603 return resBody.Res, nil 16604} 16605 16606type UpgradeIoFilter_TaskBody struct { 16607 Req *types.UpgradeIoFilter_Task `xml:"urn:vim25 UpgradeIoFilter_Task,omitempty"` 16608 Res *types.UpgradeIoFilter_TaskResponse `xml:"urn:vim25 UpgradeIoFilter_TaskResponse,omitempty"` 16609 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16610} 16611 16612func (b *UpgradeIoFilter_TaskBody) Fault() *soap.Fault { return b.Fault_ } 16613 16614func UpgradeIoFilter_Task(ctx context.Context, r soap.RoundTripper, req *types.UpgradeIoFilter_Task) (*types.UpgradeIoFilter_TaskResponse, error) { 16615 var reqBody, resBody UpgradeIoFilter_TaskBody 16616 16617 reqBody.Req = req 16618 16619 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16620 return nil, err 16621 } 16622 16623 return resBody.Res, nil 16624} 16625 16626type UpgradeTools_TaskBody struct { 16627 Req *types.UpgradeTools_Task `xml:"urn:vim25 UpgradeTools_Task,omitempty"` 16628 Res *types.UpgradeTools_TaskResponse `xml:"urn:vim25 UpgradeTools_TaskResponse,omitempty"` 16629 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16630} 16631 16632func (b *UpgradeTools_TaskBody) Fault() *soap.Fault { return b.Fault_ } 16633 16634func UpgradeTools_Task(ctx context.Context, r soap.RoundTripper, req *types.UpgradeTools_Task) (*types.UpgradeTools_TaskResponse, error) { 16635 var reqBody, resBody UpgradeTools_TaskBody 16636 16637 reqBody.Req = req 16638 16639 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16640 return nil, err 16641 } 16642 16643 return resBody.Res, nil 16644} 16645 16646type UpgradeVM_TaskBody struct { 16647 Req *types.UpgradeVM_Task `xml:"urn:vim25 UpgradeVM_Task,omitempty"` 16648 Res *types.UpgradeVM_TaskResponse `xml:"urn:vim25 UpgradeVM_TaskResponse,omitempty"` 16649 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16650} 16651 16652func (b *UpgradeVM_TaskBody) Fault() *soap.Fault { return b.Fault_ } 16653 16654func UpgradeVM_Task(ctx context.Context, r soap.RoundTripper, req *types.UpgradeVM_Task) (*types.UpgradeVM_TaskResponse, error) { 16655 var reqBody, resBody UpgradeVM_TaskBody 16656 16657 reqBody.Req = req 16658 16659 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16660 return nil, err 16661 } 16662 16663 return resBody.Res, nil 16664} 16665 16666type UpgradeVmLayoutBody struct { 16667 Req *types.UpgradeVmLayout `xml:"urn:vim25 UpgradeVmLayout,omitempty"` 16668 Res *types.UpgradeVmLayoutResponse `xml:"urn:vim25 UpgradeVmLayoutResponse,omitempty"` 16669 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16670} 16671 16672func (b *UpgradeVmLayoutBody) Fault() *soap.Fault { return b.Fault_ } 16673 16674func UpgradeVmLayout(ctx context.Context, r soap.RoundTripper, req *types.UpgradeVmLayout) (*types.UpgradeVmLayoutResponse, error) { 16675 var reqBody, resBody UpgradeVmLayoutBody 16676 16677 reqBody.Req = req 16678 16679 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16680 return nil, err 16681 } 16682 16683 return resBody.Res, nil 16684} 16685 16686type UpgradeVmfsBody struct { 16687 Req *types.UpgradeVmfs `xml:"urn:vim25 UpgradeVmfs,omitempty"` 16688 Res *types.UpgradeVmfsResponse `xml:"urn:vim25 UpgradeVmfsResponse,omitempty"` 16689 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16690} 16691 16692func (b *UpgradeVmfsBody) Fault() *soap.Fault { return b.Fault_ } 16693 16694func UpgradeVmfs(ctx context.Context, r soap.RoundTripper, req *types.UpgradeVmfs) (*types.UpgradeVmfsResponse, error) { 16695 var reqBody, resBody UpgradeVmfsBody 16696 16697 reqBody.Req = req 16698 16699 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16700 return nil, err 16701 } 16702 16703 return resBody.Res, nil 16704} 16705 16706type UpgradeVsanObjectsBody struct { 16707 Req *types.UpgradeVsanObjects `xml:"urn:vim25 UpgradeVsanObjects,omitempty"` 16708 Res *types.UpgradeVsanObjectsResponse `xml:"urn:vim25 UpgradeVsanObjectsResponse,omitempty"` 16709 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16710} 16711 16712func (b *UpgradeVsanObjectsBody) Fault() *soap.Fault { return b.Fault_ } 16713 16714func UpgradeVsanObjects(ctx context.Context, r soap.RoundTripper, req *types.UpgradeVsanObjects) (*types.UpgradeVsanObjectsResponse, error) { 16715 var reqBody, resBody UpgradeVsanObjectsBody 16716 16717 reqBody.Req = req 16718 16719 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16720 return nil, err 16721 } 16722 16723 return resBody.Res, nil 16724} 16725 16726type UploadClientCertBody struct { 16727 Req *types.UploadClientCert `xml:"urn:vim25 UploadClientCert,omitempty"` 16728 Res *types.UploadClientCertResponse `xml:"urn:vim25 UploadClientCertResponse,omitempty"` 16729 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16730} 16731 16732func (b *UploadClientCertBody) Fault() *soap.Fault { return b.Fault_ } 16733 16734func UploadClientCert(ctx context.Context, r soap.RoundTripper, req *types.UploadClientCert) (*types.UploadClientCertResponse, error) { 16735 var reqBody, resBody UploadClientCertBody 16736 16737 reqBody.Req = req 16738 16739 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16740 return nil, err 16741 } 16742 16743 return resBody.Res, nil 16744} 16745 16746type UploadKmipServerCertBody struct { 16747 Req *types.UploadKmipServerCert `xml:"urn:vim25 UploadKmipServerCert,omitempty"` 16748 Res *types.UploadKmipServerCertResponse `xml:"urn:vim25 UploadKmipServerCertResponse,omitempty"` 16749 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16750} 16751 16752func (b *UploadKmipServerCertBody) Fault() *soap.Fault { return b.Fault_ } 16753 16754func UploadKmipServerCert(ctx context.Context, r soap.RoundTripper, req *types.UploadKmipServerCert) (*types.UploadKmipServerCertResponse, error) { 16755 var reqBody, resBody UploadKmipServerCertBody 16756 16757 reqBody.Req = req 16758 16759 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16760 return nil, err 16761 } 16762 16763 return resBody.Res, nil 16764} 16765 16766type VStorageObjectCreateSnapshot_TaskBody struct { 16767 Req *types.VStorageObjectCreateSnapshot_Task `xml:"urn:vim25 VStorageObjectCreateSnapshot_Task,omitempty"` 16768 Res *types.VStorageObjectCreateSnapshot_TaskResponse `xml:"urn:vim25 VStorageObjectCreateSnapshot_TaskResponse,omitempty"` 16769 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16770} 16771 16772func (b *VStorageObjectCreateSnapshot_TaskBody) Fault() *soap.Fault { return b.Fault_ } 16773 16774func VStorageObjectCreateSnapshot_Task(ctx context.Context, r soap.RoundTripper, req *types.VStorageObjectCreateSnapshot_Task) (*types.VStorageObjectCreateSnapshot_TaskResponse, error) { 16775 var reqBody, resBody VStorageObjectCreateSnapshot_TaskBody 16776 16777 reqBody.Req = req 16778 16779 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16780 return nil, err 16781 } 16782 16783 return resBody.Res, nil 16784} 16785 16786type ValidateCredentialsInGuestBody struct { 16787 Req *types.ValidateCredentialsInGuest `xml:"urn:vim25 ValidateCredentialsInGuest,omitempty"` 16788 Res *types.ValidateCredentialsInGuestResponse `xml:"urn:vim25 ValidateCredentialsInGuestResponse,omitempty"` 16789 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16790} 16791 16792func (b *ValidateCredentialsInGuestBody) Fault() *soap.Fault { return b.Fault_ } 16793 16794func ValidateCredentialsInGuest(ctx context.Context, r soap.RoundTripper, req *types.ValidateCredentialsInGuest) (*types.ValidateCredentialsInGuestResponse, error) { 16795 var reqBody, resBody ValidateCredentialsInGuestBody 16796 16797 reqBody.Req = req 16798 16799 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16800 return nil, err 16801 } 16802 16803 return resBody.Res, nil 16804} 16805 16806type ValidateHostBody struct { 16807 Req *types.ValidateHost `xml:"urn:vim25 ValidateHost,omitempty"` 16808 Res *types.ValidateHostResponse `xml:"urn:vim25 ValidateHostResponse,omitempty"` 16809 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16810} 16811 16812func (b *ValidateHostBody) Fault() *soap.Fault { return b.Fault_ } 16813 16814func ValidateHost(ctx context.Context, r soap.RoundTripper, req *types.ValidateHost) (*types.ValidateHostResponse, error) { 16815 var reqBody, resBody ValidateHostBody 16816 16817 reqBody.Req = req 16818 16819 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16820 return nil, err 16821 } 16822 16823 return resBody.Res, nil 16824} 16825 16826type ValidateHostProfileComposition_TaskBody struct { 16827 Req *types.ValidateHostProfileComposition_Task `xml:"urn:vim25 ValidateHostProfileComposition_Task,omitempty"` 16828 Res *types.ValidateHostProfileComposition_TaskResponse `xml:"urn:vim25 ValidateHostProfileComposition_TaskResponse,omitempty"` 16829 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16830} 16831 16832func (b *ValidateHostProfileComposition_TaskBody) Fault() *soap.Fault { return b.Fault_ } 16833 16834func ValidateHostProfileComposition_Task(ctx context.Context, r soap.RoundTripper, req *types.ValidateHostProfileComposition_Task) (*types.ValidateHostProfileComposition_TaskResponse, error) { 16835 var reqBody, resBody ValidateHostProfileComposition_TaskBody 16836 16837 reqBody.Req = req 16838 16839 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16840 return nil, err 16841 } 16842 16843 return resBody.Res, nil 16844} 16845 16846type ValidateMigrationBody struct { 16847 Req *types.ValidateMigration `xml:"urn:vim25 ValidateMigration,omitempty"` 16848 Res *types.ValidateMigrationResponse `xml:"urn:vim25 ValidateMigrationResponse,omitempty"` 16849 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16850} 16851 16852func (b *ValidateMigrationBody) Fault() *soap.Fault { return b.Fault_ } 16853 16854func ValidateMigration(ctx context.Context, r soap.RoundTripper, req *types.ValidateMigration) (*types.ValidateMigrationResponse, error) { 16855 var reqBody, resBody ValidateMigrationBody 16856 16857 reqBody.Req = req 16858 16859 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16860 return nil, err 16861 } 16862 16863 return resBody.Res, nil 16864} 16865 16866type ValidateStoragePodConfigBody struct { 16867 Req *types.ValidateStoragePodConfig `xml:"urn:vim25 ValidateStoragePodConfig,omitempty"` 16868 Res *types.ValidateStoragePodConfigResponse `xml:"urn:vim25 ValidateStoragePodConfigResponse,omitempty"` 16869 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16870} 16871 16872func (b *ValidateStoragePodConfigBody) Fault() *soap.Fault { return b.Fault_ } 16873 16874func ValidateStoragePodConfig(ctx context.Context, r soap.RoundTripper, req *types.ValidateStoragePodConfig) (*types.ValidateStoragePodConfigResponse, error) { 16875 var reqBody, resBody ValidateStoragePodConfigBody 16876 16877 reqBody.Req = req 16878 16879 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16880 return nil, err 16881 } 16882 16883 return resBody.Res, nil 16884} 16885 16886type WaitForUpdatesBody struct { 16887 Req *types.WaitForUpdates `xml:"urn:vim25 WaitForUpdates,omitempty"` 16888 Res *types.WaitForUpdatesResponse `xml:"urn:vim25 WaitForUpdatesResponse,omitempty"` 16889 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16890} 16891 16892func (b *WaitForUpdatesBody) Fault() *soap.Fault { return b.Fault_ } 16893 16894func WaitForUpdates(ctx context.Context, r soap.RoundTripper, req *types.WaitForUpdates) (*types.WaitForUpdatesResponse, error) { 16895 var reqBody, resBody WaitForUpdatesBody 16896 16897 reqBody.Req = req 16898 16899 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16900 return nil, err 16901 } 16902 16903 return resBody.Res, nil 16904} 16905 16906type WaitForUpdatesExBody struct { 16907 Req *types.WaitForUpdatesEx `xml:"urn:vim25 WaitForUpdatesEx,omitempty"` 16908 Res *types.WaitForUpdatesExResponse `xml:"urn:vim25 WaitForUpdatesExResponse,omitempty"` 16909 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16910} 16911 16912func (b *WaitForUpdatesExBody) Fault() *soap.Fault { return b.Fault_ } 16913 16914func WaitForUpdatesEx(ctx context.Context, r soap.RoundTripper, req *types.WaitForUpdatesEx) (*types.WaitForUpdatesExResponse, error) { 16915 var reqBody, resBody WaitForUpdatesExBody 16916 16917 reqBody.Req = req 16918 16919 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16920 return nil, err 16921 } 16922 16923 return resBody.Res, nil 16924} 16925 16926type XmlToCustomizationSpecItemBody struct { 16927 Req *types.XmlToCustomizationSpecItem `xml:"urn:vim25 XmlToCustomizationSpecItem,omitempty"` 16928 Res *types.XmlToCustomizationSpecItemResponse `xml:"urn:vim25 XmlToCustomizationSpecItemResponse,omitempty"` 16929 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16930} 16931 16932func (b *XmlToCustomizationSpecItemBody) Fault() *soap.Fault { return b.Fault_ } 16933 16934func XmlToCustomizationSpecItem(ctx context.Context, r soap.RoundTripper, req *types.XmlToCustomizationSpecItem) (*types.XmlToCustomizationSpecItemResponse, error) { 16935 var reqBody, resBody XmlToCustomizationSpecItemBody 16936 16937 reqBody.Req = req 16938 16939 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16940 return nil, err 16941 } 16942 16943 return resBody.Res, nil 16944} 16945 16946type ZeroFillVirtualDisk_TaskBody struct { 16947 Req *types.ZeroFillVirtualDisk_Task `xml:"urn:vim25 ZeroFillVirtualDisk_Task,omitempty"` 16948 Res *types.ZeroFillVirtualDisk_TaskResponse `xml:"urn:vim25 ZeroFillVirtualDisk_TaskResponse,omitempty"` 16949 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16950} 16951 16952func (b *ZeroFillVirtualDisk_TaskBody) Fault() *soap.Fault { return b.Fault_ } 16953 16954func ZeroFillVirtualDisk_Task(ctx context.Context, r soap.RoundTripper, req *types.ZeroFillVirtualDisk_Task) (*types.ZeroFillVirtualDisk_TaskResponse, error) { 16955 var reqBody, resBody ZeroFillVirtualDisk_TaskBody 16956 16957 reqBody.Req = req 16958 16959 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16960 return nil, err 16961 } 16962 16963 return resBody.Res, nil 16964} 16965 16966type ConfigureVcha_TaskBody struct { 16967 Req *types.ConfigureVcha_Task `xml:"urn:vim25 configureVcha_Task,omitempty"` 16968 Res *types.ConfigureVcha_TaskResponse `xml:"urn:vim25 configureVcha_TaskResponse,omitempty"` 16969 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16970} 16971 16972func (b *ConfigureVcha_TaskBody) Fault() *soap.Fault { return b.Fault_ } 16973 16974func ConfigureVcha_Task(ctx context.Context, r soap.RoundTripper, req *types.ConfigureVcha_Task) (*types.ConfigureVcha_TaskResponse, error) { 16975 var reqBody, resBody ConfigureVcha_TaskBody 16976 16977 reqBody.Req = req 16978 16979 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 16980 return nil, err 16981 } 16982 16983 return resBody.Res, nil 16984} 16985 16986type CreatePassiveNode_TaskBody struct { 16987 Req *types.CreatePassiveNode_Task `xml:"urn:vim25 createPassiveNode_Task,omitempty"` 16988 Res *types.CreatePassiveNode_TaskResponse `xml:"urn:vim25 createPassiveNode_TaskResponse,omitempty"` 16989 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 16990} 16991 16992func (b *CreatePassiveNode_TaskBody) Fault() *soap.Fault { return b.Fault_ } 16993 16994func CreatePassiveNode_Task(ctx context.Context, r soap.RoundTripper, req *types.CreatePassiveNode_Task) (*types.CreatePassiveNode_TaskResponse, error) { 16995 var reqBody, resBody CreatePassiveNode_TaskBody 16996 16997 reqBody.Req = req 16998 16999 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 17000 return nil, err 17001 } 17002 17003 return resBody.Res, nil 17004} 17005 17006type CreateWitnessNode_TaskBody struct { 17007 Req *types.CreateWitnessNode_Task `xml:"urn:vim25 createWitnessNode_Task,omitempty"` 17008 Res *types.CreateWitnessNode_TaskResponse `xml:"urn:vim25 createWitnessNode_TaskResponse,omitempty"` 17009 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 17010} 17011 17012func (b *CreateWitnessNode_TaskBody) Fault() *soap.Fault { return b.Fault_ } 17013 17014func CreateWitnessNode_Task(ctx context.Context, r soap.RoundTripper, req *types.CreateWitnessNode_Task) (*types.CreateWitnessNode_TaskResponse, error) { 17015 var reqBody, resBody CreateWitnessNode_TaskBody 17016 17017 reqBody.Req = req 17018 17019 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 17020 return nil, err 17021 } 17022 17023 return resBody.Res, nil 17024} 17025 17026type DeployVcha_TaskBody struct { 17027 Req *types.DeployVcha_Task `xml:"urn:vim25 deployVcha_Task,omitempty"` 17028 Res *types.DeployVcha_TaskResponse `xml:"urn:vim25 deployVcha_TaskResponse,omitempty"` 17029 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 17030} 17031 17032func (b *DeployVcha_TaskBody) Fault() *soap.Fault { return b.Fault_ } 17033 17034func DeployVcha_Task(ctx context.Context, r soap.RoundTripper, req *types.DeployVcha_Task) (*types.DeployVcha_TaskResponse, error) { 17035 var reqBody, resBody DeployVcha_TaskBody 17036 17037 reqBody.Req = req 17038 17039 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 17040 return nil, err 17041 } 17042 17043 return resBody.Res, nil 17044} 17045 17046type DestroyVcha_TaskBody struct { 17047 Req *types.DestroyVcha_Task `xml:"urn:vim25 destroyVcha_Task,omitempty"` 17048 Res *types.DestroyVcha_TaskResponse `xml:"urn:vim25 destroyVcha_TaskResponse,omitempty"` 17049 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 17050} 17051 17052func (b *DestroyVcha_TaskBody) Fault() *soap.Fault { return b.Fault_ } 17053 17054func DestroyVcha_Task(ctx context.Context, r soap.RoundTripper, req *types.DestroyVcha_Task) (*types.DestroyVcha_TaskResponse, error) { 17055 var reqBody, resBody DestroyVcha_TaskBody 17056 17057 reqBody.Req = req 17058 17059 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 17060 return nil, err 17061 } 17062 17063 return resBody.Res, nil 17064} 17065 17066type FetchSoftwarePackagesBody struct { 17067 Req *types.FetchSoftwarePackages `xml:"urn:vim25 fetchSoftwarePackages,omitempty"` 17068 Res *types.FetchSoftwarePackagesResponse `xml:"urn:vim25 fetchSoftwarePackagesResponse,omitempty"` 17069 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 17070} 17071 17072func (b *FetchSoftwarePackagesBody) Fault() *soap.Fault { return b.Fault_ } 17073 17074func FetchSoftwarePackages(ctx context.Context, r soap.RoundTripper, req *types.FetchSoftwarePackages) (*types.FetchSoftwarePackagesResponse, error) { 17075 var reqBody, resBody FetchSoftwarePackagesBody 17076 17077 reqBody.Req = req 17078 17079 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 17080 return nil, err 17081 } 17082 17083 return resBody.Res, nil 17084} 17085 17086type GetClusterModeBody struct { 17087 Req *types.GetClusterMode `xml:"urn:vim25 getClusterMode,omitempty"` 17088 Res *types.GetClusterModeResponse `xml:"urn:vim25 getClusterModeResponse,omitempty"` 17089 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 17090} 17091 17092func (b *GetClusterModeBody) Fault() *soap.Fault { return b.Fault_ } 17093 17094func GetClusterMode(ctx context.Context, r soap.RoundTripper, req *types.GetClusterMode) (*types.GetClusterModeResponse, error) { 17095 var reqBody, resBody GetClusterModeBody 17096 17097 reqBody.Req = req 17098 17099 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 17100 return nil, err 17101 } 17102 17103 return resBody.Res, nil 17104} 17105 17106type GetVchaConfigBody struct { 17107 Req *types.GetVchaConfig `xml:"urn:vim25 getVchaConfig,omitempty"` 17108 Res *types.GetVchaConfigResponse `xml:"urn:vim25 getVchaConfigResponse,omitempty"` 17109 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 17110} 17111 17112func (b *GetVchaConfigBody) Fault() *soap.Fault { return b.Fault_ } 17113 17114func GetVchaConfig(ctx context.Context, r soap.RoundTripper, req *types.GetVchaConfig) (*types.GetVchaConfigResponse, error) { 17115 var reqBody, resBody GetVchaConfigBody 17116 17117 reqBody.Req = req 17118 17119 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 17120 return nil, err 17121 } 17122 17123 return resBody.Res, nil 17124} 17125 17126type InitiateFailover_TaskBody struct { 17127 Req *types.InitiateFailover_Task `xml:"urn:vim25 initiateFailover_Task,omitempty"` 17128 Res *types.InitiateFailover_TaskResponse `xml:"urn:vim25 initiateFailover_TaskResponse,omitempty"` 17129 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 17130} 17131 17132func (b *InitiateFailover_TaskBody) Fault() *soap.Fault { return b.Fault_ } 17133 17134func InitiateFailover_Task(ctx context.Context, r soap.RoundTripper, req *types.InitiateFailover_Task) (*types.InitiateFailover_TaskResponse, error) { 17135 var reqBody, resBody InitiateFailover_TaskBody 17136 17137 reqBody.Req = req 17138 17139 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 17140 return nil, err 17141 } 17142 17143 return resBody.Res, nil 17144} 17145 17146type InstallDateBody struct { 17147 Req *types.InstallDate `xml:"urn:vim25 installDate,omitempty"` 17148 Res *types.InstallDateResponse `xml:"urn:vim25 installDateResponse,omitempty"` 17149 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 17150} 17151 17152func (b *InstallDateBody) Fault() *soap.Fault { return b.Fault_ } 17153 17154func InstallDate(ctx context.Context, r soap.RoundTripper, req *types.InstallDate) (*types.InstallDateResponse, error) { 17155 var reqBody, resBody InstallDateBody 17156 17157 reqBody.Req = req 17158 17159 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 17160 return nil, err 17161 } 17162 17163 return resBody.Res, nil 17164} 17165 17166type PrepareVcha_TaskBody struct { 17167 Req *types.PrepareVcha_Task `xml:"urn:vim25 prepareVcha_Task,omitempty"` 17168 Res *types.PrepareVcha_TaskResponse `xml:"urn:vim25 prepareVcha_TaskResponse,omitempty"` 17169 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 17170} 17171 17172func (b *PrepareVcha_TaskBody) Fault() *soap.Fault { return b.Fault_ } 17173 17174func PrepareVcha_Task(ctx context.Context, r soap.RoundTripper, req *types.PrepareVcha_Task) (*types.PrepareVcha_TaskResponse, error) { 17175 var reqBody, resBody PrepareVcha_TaskBody 17176 17177 reqBody.Req = req 17178 17179 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 17180 return nil, err 17181 } 17182 17183 return resBody.Res, nil 17184} 17185 17186type QueryDatacenterConfigOptionDescriptorBody struct { 17187 Req *types.QueryDatacenterConfigOptionDescriptor `xml:"urn:vim25 queryDatacenterConfigOptionDescriptor,omitempty"` 17188 Res *types.QueryDatacenterConfigOptionDescriptorResponse `xml:"urn:vim25 queryDatacenterConfigOptionDescriptorResponse,omitempty"` 17189 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 17190} 17191 17192func (b *QueryDatacenterConfigOptionDescriptorBody) Fault() *soap.Fault { return b.Fault_ } 17193 17194func QueryDatacenterConfigOptionDescriptor(ctx context.Context, r soap.RoundTripper, req *types.QueryDatacenterConfigOptionDescriptor) (*types.QueryDatacenterConfigOptionDescriptorResponse, error) { 17195 var reqBody, resBody QueryDatacenterConfigOptionDescriptorBody 17196 17197 reqBody.Req = req 17198 17199 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 17200 return nil, err 17201 } 17202 17203 return resBody.Res, nil 17204} 17205 17206type ReloadVirtualMachineFromPath_TaskBody struct { 17207 Req *types.ReloadVirtualMachineFromPath_Task `xml:"urn:vim25 reloadVirtualMachineFromPath_Task,omitempty"` 17208 Res *types.ReloadVirtualMachineFromPath_TaskResponse `xml:"urn:vim25 reloadVirtualMachineFromPath_TaskResponse,omitempty"` 17209 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 17210} 17211 17212func (b *ReloadVirtualMachineFromPath_TaskBody) Fault() *soap.Fault { return b.Fault_ } 17213 17214func ReloadVirtualMachineFromPath_Task(ctx context.Context, r soap.RoundTripper, req *types.ReloadVirtualMachineFromPath_Task) (*types.ReloadVirtualMachineFromPath_TaskResponse, error) { 17215 var reqBody, resBody ReloadVirtualMachineFromPath_TaskBody 17216 17217 reqBody.Req = req 17218 17219 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 17220 return nil, err 17221 } 17222 17223 return resBody.Res, nil 17224} 17225 17226type SetClusterMode_TaskBody struct { 17227 Req *types.SetClusterMode_Task `xml:"urn:vim25 setClusterMode_Task,omitempty"` 17228 Res *types.SetClusterMode_TaskResponse `xml:"urn:vim25 setClusterMode_TaskResponse,omitempty"` 17229 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 17230} 17231 17232func (b *SetClusterMode_TaskBody) Fault() *soap.Fault { return b.Fault_ } 17233 17234func SetClusterMode_Task(ctx context.Context, r soap.RoundTripper, req *types.SetClusterMode_Task) (*types.SetClusterMode_TaskResponse, error) { 17235 var reqBody, resBody SetClusterMode_TaskBody 17236 17237 reqBody.Req = req 17238 17239 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 17240 return nil, err 17241 } 17242 17243 return resBody.Res, nil 17244} 17245 17246type SetCustomValueBody struct { 17247 Req *types.SetCustomValue `xml:"urn:vim25 setCustomValue,omitempty"` 17248 Res *types.SetCustomValueResponse `xml:"urn:vim25 setCustomValueResponse,omitempty"` 17249 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 17250} 17251 17252func (b *SetCustomValueBody) Fault() *soap.Fault { return b.Fault_ } 17253 17254func SetCustomValue(ctx context.Context, r soap.RoundTripper, req *types.SetCustomValue) (*types.SetCustomValueResponse, error) { 17255 var reqBody, resBody SetCustomValueBody 17256 17257 reqBody.Req = req 17258 17259 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 17260 return nil, err 17261 } 17262 17263 return resBody.Res, nil 17264} 17265 17266type UnregisterVApp_TaskBody struct { 17267 Req *types.UnregisterVApp_Task `xml:"urn:vim25 unregisterVApp_Task,omitempty"` 17268 Res *types.UnregisterVApp_TaskResponse `xml:"urn:vim25 unregisterVApp_TaskResponse,omitempty"` 17269 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 17270} 17271 17272func (b *UnregisterVApp_TaskBody) Fault() *soap.Fault { return b.Fault_ } 17273 17274func UnregisterVApp_Task(ctx context.Context, r soap.RoundTripper, req *types.UnregisterVApp_Task) (*types.UnregisterVApp_TaskResponse, error) { 17275 var reqBody, resBody UnregisterVApp_TaskBody 17276 17277 reqBody.Req = req 17278 17279 if err := r.RoundTrip(ctx, &reqBody, &resBody); err != nil { 17280 return nil, err 17281 } 17282 17283 return resBody.Res, nil 17284} 17285