github.com/vmware/govmomi@v0.43.0/vslm/methods/methods.go (about) 1 /* 2 Copyright (c) 2014-2024 VMware, Inc. All Rights Reserved. 3 4 Licensed under the Apache License, Version 2.0 (the "License"); 5 you may not use this file except in compliance with the License. 6 You may obtain a copy of the License at 7 8 http://www.apache.org/licenses/LICENSE-2.0 9 10 Unless required by applicable law or agreed to in writing, software 11 distributed under the License is distributed on an "AS IS" BASIS, 12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 See the License for the specific language governing permissions and 14 limitations under the License. 15 */ 16 17 package methods 18 19 import ( 20 "context" 21 22 "github.com/vmware/govmomi/vim25/soap" 23 "github.com/vmware/govmomi/vslm/types" 24 ) 25 26 type RetrieveContentBody struct { 27 Req *types.RetrieveContent `xml:"urn:vslm RetrieveContent,omitempty"` 28 Res *types.RetrieveContentResponse `xml:"urn:vslm RetrieveContentResponse,omitempty"` 29 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 30 } 31 32 func (b *RetrieveContentBody) Fault() *soap.Fault { return b.Fault_ } 33 34 func RetrieveContent(ctx context.Context, r soap.RoundTripper, req *types.RetrieveContent) (*types.RetrieveContentResponse, error) { 35 var reqBody, resBody RetrieveContentBody 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 46 type VslmAttachDisk_TaskBody struct { 47 Req *types.VslmAttachDisk_Task `xml:"urn:vslm VslmAttachDisk_Task,omitempty"` 48 Res *types.VslmAttachDisk_TaskResponse `xml:"urn:vslm VslmAttachDisk_TaskResponse,omitempty"` 49 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 50 } 51 52 func (b *VslmAttachDisk_TaskBody) Fault() *soap.Fault { return b.Fault_ } 53 54 func VslmAttachDisk_Task(ctx context.Context, r soap.RoundTripper, req *types.VslmAttachDisk_Task) (*types.VslmAttachDisk_TaskResponse, error) { 55 var reqBody, resBody VslmAttachDisk_TaskBody 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 66 type VslmAttachTagToVStorageObjectBody struct { 67 Req *types.VslmAttachTagToVStorageObject `xml:"urn:vslm VslmAttachTagToVStorageObject,omitempty"` 68 Res *types.VslmAttachTagToVStorageObjectResponse `xml:"urn:vslm VslmAttachTagToVStorageObjectResponse,omitempty"` 69 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 70 } 71 72 func (b *VslmAttachTagToVStorageObjectBody) Fault() *soap.Fault { return b.Fault_ } 73 74 func VslmAttachTagToVStorageObject(ctx context.Context, r soap.RoundTripper, req *types.VslmAttachTagToVStorageObject) (*types.VslmAttachTagToVStorageObjectResponse, error) { 75 var reqBody, resBody VslmAttachTagToVStorageObjectBody 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 86 type VslmCancelTaskBody struct { 87 Req *types.VslmCancelTask `xml:"urn:vslm VslmCancelTask,omitempty"` 88 Res *types.VslmCancelTaskResponse `xml:"urn:vslm VslmCancelTaskResponse,omitempty"` 89 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 90 } 91 92 func (b *VslmCancelTaskBody) Fault() *soap.Fault { return b.Fault_ } 93 94 func VslmCancelTask(ctx context.Context, r soap.RoundTripper, req *types.VslmCancelTask) (*types.VslmCancelTaskResponse, error) { 95 var reqBody, resBody VslmCancelTaskBody 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 106 type VslmClearVStorageObjectControlFlagsBody struct { 107 Req *types.VslmClearVStorageObjectControlFlags `xml:"urn:vslm VslmClearVStorageObjectControlFlags,omitempty"` 108 Res *types.VslmClearVStorageObjectControlFlagsResponse `xml:"urn:vslm VslmClearVStorageObjectControlFlagsResponse,omitempty"` 109 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 110 } 111 112 func (b *VslmClearVStorageObjectControlFlagsBody) Fault() *soap.Fault { return b.Fault_ } 113 114 func VslmClearVStorageObjectControlFlags(ctx context.Context, r soap.RoundTripper, req *types.VslmClearVStorageObjectControlFlags) (*types.VslmClearVStorageObjectControlFlagsResponse, error) { 115 var reqBody, resBody VslmClearVStorageObjectControlFlagsBody 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 126 type VslmCloneVStorageObject_TaskBody struct { 127 Req *types.VslmCloneVStorageObject_Task `xml:"urn:vslm VslmCloneVStorageObject_Task,omitempty"` 128 Res *types.VslmCloneVStorageObject_TaskResponse `xml:"urn:vslm VslmCloneVStorageObject_TaskResponse,omitempty"` 129 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 130 } 131 132 func (b *VslmCloneVStorageObject_TaskBody) Fault() *soap.Fault { return b.Fault_ } 133 134 func VslmCloneVStorageObject_Task(ctx context.Context, r soap.RoundTripper, req *types.VslmCloneVStorageObject_Task) (*types.VslmCloneVStorageObject_TaskResponse, error) { 135 var reqBody, resBody VslmCloneVStorageObject_TaskBody 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 146 type VslmCreateDiskFromSnapshot_TaskBody struct { 147 Req *types.VslmCreateDiskFromSnapshot_Task `xml:"urn:vslm VslmCreateDiskFromSnapshot_Task,omitempty"` 148 Res *types.VslmCreateDiskFromSnapshot_TaskResponse `xml:"urn:vslm VslmCreateDiskFromSnapshot_TaskResponse,omitempty"` 149 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 150 } 151 152 func (b *VslmCreateDiskFromSnapshot_TaskBody) Fault() *soap.Fault { return b.Fault_ } 153 154 func VslmCreateDiskFromSnapshot_Task(ctx context.Context, r soap.RoundTripper, req *types.VslmCreateDiskFromSnapshot_Task) (*types.VslmCreateDiskFromSnapshot_TaskResponse, error) { 155 var reqBody, resBody VslmCreateDiskFromSnapshot_TaskBody 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 166 type VslmCreateDisk_TaskBody struct { 167 Req *types.VslmCreateDisk_Task `xml:"urn:vslm VslmCreateDisk_Task,omitempty"` 168 Res *types.VslmCreateDisk_TaskResponse `xml:"urn:vslm VslmCreateDisk_TaskResponse,omitempty"` 169 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 170 } 171 172 func (b *VslmCreateDisk_TaskBody) Fault() *soap.Fault { return b.Fault_ } 173 174 func VslmCreateDisk_Task(ctx context.Context, r soap.RoundTripper, req *types.VslmCreateDisk_Task) (*types.VslmCreateDisk_TaskResponse, error) { 175 var reqBody, resBody VslmCreateDisk_TaskBody 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 186 type VslmCreateSnapshot_TaskBody struct { 187 Req *types.VslmCreateSnapshot_Task `xml:"urn:vslm VslmCreateSnapshot_Task,omitempty"` 188 Res *types.VslmCreateSnapshot_TaskResponse `xml:"urn:vslm VslmCreateSnapshot_TaskResponse,omitempty"` 189 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 190 } 191 192 func (b *VslmCreateSnapshot_TaskBody) Fault() *soap.Fault { return b.Fault_ } 193 194 func VslmCreateSnapshot_Task(ctx context.Context, r soap.RoundTripper, req *types.VslmCreateSnapshot_Task) (*types.VslmCreateSnapshot_TaskResponse, error) { 195 var reqBody, resBody VslmCreateSnapshot_TaskBody 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 206 type VslmDeleteSnapshot_TaskBody struct { 207 Req *types.VslmDeleteSnapshot_Task `xml:"urn:vslm VslmDeleteSnapshot_Task,omitempty"` 208 Res *types.VslmDeleteSnapshot_TaskResponse `xml:"urn:vslm VslmDeleteSnapshot_TaskResponse,omitempty"` 209 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 210 } 211 212 func (b *VslmDeleteSnapshot_TaskBody) Fault() *soap.Fault { return b.Fault_ } 213 214 func VslmDeleteSnapshot_Task(ctx context.Context, r soap.RoundTripper, req *types.VslmDeleteSnapshot_Task) (*types.VslmDeleteSnapshot_TaskResponse, error) { 215 var reqBody, resBody VslmDeleteSnapshot_TaskBody 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 226 type VslmDeleteVStorageObject_TaskBody struct { 227 Req *types.VslmDeleteVStorageObject_Task `xml:"urn:vslm VslmDeleteVStorageObject_Task,omitempty"` 228 Res *types.VslmDeleteVStorageObject_TaskResponse `xml:"urn:vslm VslmDeleteVStorageObject_TaskResponse,omitempty"` 229 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 230 } 231 232 func (b *VslmDeleteVStorageObject_TaskBody) Fault() *soap.Fault { return b.Fault_ } 233 234 func VslmDeleteVStorageObject_Task(ctx context.Context, r soap.RoundTripper, req *types.VslmDeleteVStorageObject_Task) (*types.VslmDeleteVStorageObject_TaskResponse, error) { 235 var reqBody, resBody VslmDeleteVStorageObject_TaskBody 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 246 type VslmDetachTagFromVStorageObjectBody struct { 247 Req *types.VslmDetachTagFromVStorageObject `xml:"urn:vslm VslmDetachTagFromVStorageObject,omitempty"` 248 Res *types.VslmDetachTagFromVStorageObjectResponse `xml:"urn:vslm VslmDetachTagFromVStorageObjectResponse,omitempty"` 249 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 250 } 251 252 func (b *VslmDetachTagFromVStorageObjectBody) Fault() *soap.Fault { return b.Fault_ } 253 254 func VslmDetachTagFromVStorageObject(ctx context.Context, r soap.RoundTripper, req *types.VslmDetachTagFromVStorageObject) (*types.VslmDetachTagFromVStorageObjectResponse, error) { 255 var reqBody, resBody VslmDetachTagFromVStorageObjectBody 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 266 type VslmExtendDisk_TaskBody struct { 267 Req *types.VslmExtendDisk_Task `xml:"urn:vslm VslmExtendDisk_Task,omitempty"` 268 Res *types.VslmExtendDisk_TaskResponse `xml:"urn:vslm VslmExtendDisk_TaskResponse,omitempty"` 269 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 270 } 271 272 func (b *VslmExtendDisk_TaskBody) Fault() *soap.Fault { return b.Fault_ } 273 274 func VslmExtendDisk_Task(ctx context.Context, r soap.RoundTripper, req *types.VslmExtendDisk_Task) (*types.VslmExtendDisk_TaskResponse, error) { 275 var reqBody, resBody VslmExtendDisk_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 286 type VslmInflateDisk_TaskBody struct { 287 Req *types.VslmInflateDisk_Task `xml:"urn:vslm VslmInflateDisk_Task,omitempty"` 288 Res *types.VslmInflateDisk_TaskResponse `xml:"urn:vslm VslmInflateDisk_TaskResponse,omitempty"` 289 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 290 } 291 292 func (b *VslmInflateDisk_TaskBody) Fault() *soap.Fault { return b.Fault_ } 293 294 func VslmInflateDisk_Task(ctx context.Context, r soap.RoundTripper, req *types.VslmInflateDisk_Task) (*types.VslmInflateDisk_TaskResponse, error) { 295 var reqBody, resBody VslmInflateDisk_TaskBody 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 306 type VslmListTagsAttachedToVStorageObjectBody struct { 307 Req *types.VslmListTagsAttachedToVStorageObject `xml:"urn:vslm VslmListTagsAttachedToVStorageObject,omitempty"` 308 Res *types.VslmListTagsAttachedToVStorageObjectResponse `xml:"urn:vslm VslmListTagsAttachedToVStorageObjectResponse,omitempty"` 309 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 310 } 311 312 func (b *VslmListTagsAttachedToVStorageObjectBody) Fault() *soap.Fault { return b.Fault_ } 313 314 func VslmListTagsAttachedToVStorageObject(ctx context.Context, r soap.RoundTripper, req *types.VslmListTagsAttachedToVStorageObject) (*types.VslmListTagsAttachedToVStorageObjectResponse, error) { 315 var reqBody, resBody VslmListTagsAttachedToVStorageObjectBody 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 326 type VslmListVStorageObjectForSpecBody struct { 327 Req *types.VslmListVStorageObjectForSpec `xml:"urn:vslm VslmListVStorageObjectForSpec,omitempty"` 328 Res *types.VslmListVStorageObjectForSpecResponse `xml:"urn:vslm VslmListVStorageObjectForSpecResponse,omitempty"` 329 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 330 } 331 332 func (b *VslmListVStorageObjectForSpecBody) Fault() *soap.Fault { return b.Fault_ } 333 334 func VslmListVStorageObjectForSpec(ctx context.Context, r soap.RoundTripper, req *types.VslmListVStorageObjectForSpec) (*types.VslmListVStorageObjectForSpecResponse, error) { 335 var reqBody, resBody VslmListVStorageObjectForSpecBody 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 346 type VslmListVStorageObjectsAttachedToTagBody struct { 347 Req *types.VslmListVStorageObjectsAttachedToTag `xml:"urn:vslm VslmListVStorageObjectsAttachedToTag,omitempty"` 348 Res *types.VslmListVStorageObjectsAttachedToTagResponse `xml:"urn:vslm VslmListVStorageObjectsAttachedToTagResponse,omitempty"` 349 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 350 } 351 352 func (b *VslmListVStorageObjectsAttachedToTagBody) Fault() *soap.Fault { return b.Fault_ } 353 354 func VslmListVStorageObjectsAttachedToTag(ctx context.Context, r soap.RoundTripper, req *types.VslmListVStorageObjectsAttachedToTag) (*types.VslmListVStorageObjectsAttachedToTagResponse, error) { 355 var reqBody, resBody VslmListVStorageObjectsAttachedToTagBody 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 366 type VslmLoginByTokenBody struct { 367 Req *types.VslmLoginByToken `xml:"urn:vslm VslmLoginByToken,omitempty"` 368 Res *types.VslmLoginByTokenResponse `xml:"urn:vslm VslmLoginByTokenResponse,omitempty"` 369 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 370 } 371 372 func (b *VslmLoginByTokenBody) Fault() *soap.Fault { return b.Fault_ } 373 374 func VslmLoginByToken(ctx context.Context, r soap.RoundTripper, req *types.VslmLoginByToken) (*types.VslmLoginByTokenResponse, error) { 375 var reqBody, resBody VslmLoginByTokenBody 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 386 type VslmLogoutBody struct { 387 Req *types.VslmLogout `xml:"urn:vslm VslmLogout,omitempty"` 388 Res *types.VslmLogoutResponse `xml:"urn:vslm VslmLogoutResponse,omitempty"` 389 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 390 } 391 392 func (b *VslmLogoutBody) Fault() *soap.Fault { return b.Fault_ } 393 394 func VslmLogout(ctx context.Context, r soap.RoundTripper, req *types.VslmLogout) (*types.VslmLogoutResponse, error) { 395 var reqBody, resBody VslmLogoutBody 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 406 type VslmQueryChangedDiskAreasBody struct { 407 Req *types.VslmQueryChangedDiskAreas `xml:"urn:vslm VslmQueryChangedDiskAreas,omitempty"` 408 Res *types.VslmQueryChangedDiskAreasResponse `xml:"urn:vslm VslmQueryChangedDiskAreasResponse,omitempty"` 409 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 410 } 411 412 func (b *VslmQueryChangedDiskAreasBody) Fault() *soap.Fault { return b.Fault_ } 413 414 func VslmQueryChangedDiskAreas(ctx context.Context, r soap.RoundTripper, req *types.VslmQueryChangedDiskAreas) (*types.VslmQueryChangedDiskAreasResponse, error) { 415 var reqBody, resBody VslmQueryChangedDiskAreasBody 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 426 type VslmQueryDatastoreInfoBody struct { 427 Req *types.VslmQueryDatastoreInfo `xml:"urn:vslm VslmQueryDatastoreInfo,omitempty"` 428 Res *types.VslmQueryDatastoreInfoResponse `xml:"urn:vslm VslmQueryDatastoreInfoResponse,omitempty"` 429 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 430 } 431 432 func (b *VslmQueryDatastoreInfoBody) Fault() *soap.Fault { return b.Fault_ } 433 434 func VslmQueryDatastoreInfo(ctx context.Context, r soap.RoundTripper, req *types.VslmQueryDatastoreInfo) (*types.VslmQueryDatastoreInfoResponse, error) { 435 var reqBody, resBody VslmQueryDatastoreInfoBody 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 446 type VslmQueryGlobalCatalogSyncStatusBody struct { 447 Req *types.VslmQueryGlobalCatalogSyncStatus `xml:"urn:vslm VslmQueryGlobalCatalogSyncStatus,omitempty"` 448 Res *types.VslmQueryGlobalCatalogSyncStatusResponse `xml:"urn:vslm VslmQueryGlobalCatalogSyncStatusResponse,omitempty"` 449 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 450 } 451 452 func (b *VslmQueryGlobalCatalogSyncStatusBody) Fault() *soap.Fault { return b.Fault_ } 453 454 func VslmQueryGlobalCatalogSyncStatus(ctx context.Context, r soap.RoundTripper, req *types.VslmQueryGlobalCatalogSyncStatus) (*types.VslmQueryGlobalCatalogSyncStatusResponse, error) { 455 var reqBody, resBody VslmQueryGlobalCatalogSyncStatusBody 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 466 type VslmQueryGlobalCatalogSyncStatusForDatastoreBody struct { 467 Req *types.VslmQueryGlobalCatalogSyncStatusForDatastore `xml:"urn:vslm VslmQueryGlobalCatalogSyncStatusForDatastore,omitempty"` 468 Res *types.VslmQueryGlobalCatalogSyncStatusForDatastoreResponse `xml:"urn:vslm VslmQueryGlobalCatalogSyncStatusForDatastoreResponse,omitempty"` 469 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 470 } 471 472 func (b *VslmQueryGlobalCatalogSyncStatusForDatastoreBody) Fault() *soap.Fault { return b.Fault_ } 473 474 func VslmQueryGlobalCatalogSyncStatusForDatastore(ctx context.Context, r soap.RoundTripper, req *types.VslmQueryGlobalCatalogSyncStatusForDatastore) (*types.VslmQueryGlobalCatalogSyncStatusForDatastoreResponse, error) { 475 var reqBody, resBody VslmQueryGlobalCatalogSyncStatusForDatastoreBody 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 486 type VslmQueryInfoBody struct { 487 Req *types.VslmQueryInfo `xml:"urn:vslm VslmQueryInfo,omitempty"` 488 Res *types.VslmQueryInfoResponse `xml:"urn:vslm VslmQueryInfoResponse,omitempty"` 489 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 490 } 491 492 func (b *VslmQueryInfoBody) Fault() *soap.Fault { return b.Fault_ } 493 494 func VslmQueryInfo(ctx context.Context, r soap.RoundTripper, req *types.VslmQueryInfo) (*types.VslmQueryInfoResponse, error) { 495 var reqBody, resBody VslmQueryInfoBody 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 506 type VslmQueryTaskResultBody struct { 507 Req *types.VslmQueryTaskResult `xml:"urn:vslm VslmQueryTaskResult,omitempty"` 508 Res *types.VslmQueryTaskResultResponse `xml:"urn:vslm VslmQueryTaskResultResponse,omitempty"` 509 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 510 } 511 512 func (b *VslmQueryTaskResultBody) Fault() *soap.Fault { return b.Fault_ } 513 514 func VslmQueryTaskResult(ctx context.Context, r soap.RoundTripper, req *types.VslmQueryTaskResult) (*types.VslmQueryTaskResultResponse, error) { 515 var reqBody, resBody VslmQueryTaskResultBody 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 526 type VslmReconcileDatastoreInventory_TaskBody struct { 527 Req *types.VslmReconcileDatastoreInventory_Task `xml:"urn:vslm VslmReconcileDatastoreInventory_Task,omitempty"` 528 Res *types.VslmReconcileDatastoreInventory_TaskResponse `xml:"urn:vslm VslmReconcileDatastoreInventory_TaskResponse,omitempty"` 529 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 530 } 531 532 func (b *VslmReconcileDatastoreInventory_TaskBody) Fault() *soap.Fault { return b.Fault_ } 533 534 func VslmReconcileDatastoreInventory_Task(ctx context.Context, r soap.RoundTripper, req *types.VslmReconcileDatastoreInventory_Task) (*types.VslmReconcileDatastoreInventory_TaskResponse, error) { 535 var reqBody, resBody VslmReconcileDatastoreInventory_TaskBody 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 546 type VslmRegisterDiskBody struct { 547 Req *types.VslmRegisterDisk `xml:"urn:vslm VslmRegisterDisk,omitempty"` 548 Res *types.VslmRegisterDiskResponse `xml:"urn:vslm VslmRegisterDiskResponse,omitempty"` 549 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 550 } 551 552 func (b *VslmRegisterDiskBody) Fault() *soap.Fault { return b.Fault_ } 553 554 func VslmRegisterDisk(ctx context.Context, r soap.RoundTripper, req *types.VslmRegisterDisk) (*types.VslmRegisterDiskResponse, error) { 555 var reqBody, resBody VslmRegisterDiskBody 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 566 type VslmRelocateVStorageObject_TaskBody struct { 567 Req *types.VslmRelocateVStorageObject_Task `xml:"urn:vslm VslmRelocateVStorageObject_Task,omitempty"` 568 Res *types.VslmRelocateVStorageObject_TaskResponse `xml:"urn:vslm VslmRelocateVStorageObject_TaskResponse,omitempty"` 569 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 570 } 571 572 func (b *VslmRelocateVStorageObject_TaskBody) Fault() *soap.Fault { return b.Fault_ } 573 574 func VslmRelocateVStorageObject_Task(ctx context.Context, r soap.RoundTripper, req *types.VslmRelocateVStorageObject_Task) (*types.VslmRelocateVStorageObject_TaskResponse, error) { 575 var reqBody, resBody VslmRelocateVStorageObject_TaskBody 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 586 type VslmRenameVStorageObjectBody struct { 587 Req *types.VslmRenameVStorageObject `xml:"urn:vslm VslmRenameVStorageObject,omitempty"` 588 Res *types.VslmRenameVStorageObjectResponse `xml:"urn:vslm VslmRenameVStorageObjectResponse,omitempty"` 589 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 590 } 591 592 func (b *VslmRenameVStorageObjectBody) Fault() *soap.Fault { return b.Fault_ } 593 594 func VslmRenameVStorageObject(ctx context.Context, r soap.RoundTripper, req *types.VslmRenameVStorageObject) (*types.VslmRenameVStorageObjectResponse, error) { 595 var reqBody, resBody VslmRenameVStorageObjectBody 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 606 type VslmRetrieveSnapshotDetailsBody struct { 607 Req *types.VslmRetrieveSnapshotDetails `xml:"urn:vslm VslmRetrieveSnapshotDetails,omitempty"` 608 Res *types.VslmRetrieveSnapshotDetailsResponse `xml:"urn:vslm VslmRetrieveSnapshotDetailsResponse,omitempty"` 609 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 610 } 611 612 func (b *VslmRetrieveSnapshotDetailsBody) Fault() *soap.Fault { return b.Fault_ } 613 614 func VslmRetrieveSnapshotDetails(ctx context.Context, r soap.RoundTripper, req *types.VslmRetrieveSnapshotDetails) (*types.VslmRetrieveSnapshotDetailsResponse, error) { 615 var reqBody, resBody VslmRetrieveSnapshotDetailsBody 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 626 type VslmRetrieveSnapshotInfoBody struct { 627 Req *types.VslmRetrieveSnapshotInfo `xml:"urn:vslm VslmRetrieveSnapshotInfo,omitempty"` 628 Res *types.VslmRetrieveSnapshotInfoResponse `xml:"urn:vslm VslmRetrieveSnapshotInfoResponse,omitempty"` 629 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 630 } 631 632 func (b *VslmRetrieveSnapshotInfoBody) Fault() *soap.Fault { return b.Fault_ } 633 634 func VslmRetrieveSnapshotInfo(ctx context.Context, r soap.RoundTripper, req *types.VslmRetrieveSnapshotInfo) (*types.VslmRetrieveSnapshotInfoResponse, error) { 635 var reqBody, resBody VslmRetrieveSnapshotInfoBody 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 646 type VslmRetrieveVStorageInfrastructureObjectPolicyBody struct { 647 Req *types.VslmRetrieveVStorageInfrastructureObjectPolicy `xml:"urn:vslm VslmRetrieveVStorageInfrastructureObjectPolicy,omitempty"` 648 Res *types.VslmRetrieveVStorageInfrastructureObjectPolicyResponse `xml:"urn:vslm VslmRetrieveVStorageInfrastructureObjectPolicyResponse,omitempty"` 649 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 650 } 651 652 func (b *VslmRetrieveVStorageInfrastructureObjectPolicyBody) Fault() *soap.Fault { return b.Fault_ } 653 654 func VslmRetrieveVStorageInfrastructureObjectPolicy(ctx context.Context, r soap.RoundTripper, req *types.VslmRetrieveVStorageInfrastructureObjectPolicy) (*types.VslmRetrieveVStorageInfrastructureObjectPolicyResponse, error) { 655 var reqBody, resBody VslmRetrieveVStorageInfrastructureObjectPolicyBody 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 666 type VslmRetrieveVStorageObjectBody struct { 667 Req *types.VslmRetrieveVStorageObject `xml:"urn:vslm VslmRetrieveVStorageObject,omitempty"` 668 Res *types.VslmRetrieveVStorageObjectResponse `xml:"urn:vslm VslmRetrieveVStorageObjectResponse,omitempty"` 669 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 670 } 671 672 func (b *VslmRetrieveVStorageObjectBody) Fault() *soap.Fault { return b.Fault_ } 673 674 func VslmRetrieveVStorageObject(ctx context.Context, r soap.RoundTripper, req *types.VslmRetrieveVStorageObject) (*types.VslmRetrieveVStorageObjectResponse, error) { 675 var reqBody, resBody VslmRetrieveVStorageObjectBody 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 686 type VslmRetrieveVStorageObjectAssociationsBody struct { 687 Req *types.VslmRetrieveVStorageObjectAssociations `xml:"urn:vslm VslmRetrieveVStorageObjectAssociations,omitempty"` 688 Res *types.VslmRetrieveVStorageObjectAssociationsResponse `xml:"urn:vslm VslmRetrieveVStorageObjectAssociationsResponse,omitempty"` 689 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 690 } 691 692 func (b *VslmRetrieveVStorageObjectAssociationsBody) Fault() *soap.Fault { return b.Fault_ } 693 694 func VslmRetrieveVStorageObjectAssociations(ctx context.Context, r soap.RoundTripper, req *types.VslmRetrieveVStorageObjectAssociations) (*types.VslmRetrieveVStorageObjectAssociationsResponse, error) { 695 var reqBody, resBody VslmRetrieveVStorageObjectAssociationsBody 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 706 type VslmRetrieveVStorageObjectMetadataBody struct { 707 Req *types.VslmRetrieveVStorageObjectMetadata `xml:"urn:vslm VslmRetrieveVStorageObjectMetadata,omitempty"` 708 Res *types.VslmRetrieveVStorageObjectMetadataResponse `xml:"urn:vslm VslmRetrieveVStorageObjectMetadataResponse,omitempty"` 709 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 710 } 711 712 func (b *VslmRetrieveVStorageObjectMetadataBody) Fault() *soap.Fault { return b.Fault_ } 713 714 func VslmRetrieveVStorageObjectMetadata(ctx context.Context, r soap.RoundTripper, req *types.VslmRetrieveVStorageObjectMetadata) (*types.VslmRetrieveVStorageObjectMetadataResponse, error) { 715 var reqBody, resBody VslmRetrieveVStorageObjectMetadataBody 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 726 type VslmRetrieveVStorageObjectMetadataValueBody struct { 727 Req *types.VslmRetrieveVStorageObjectMetadataValue `xml:"urn:vslm VslmRetrieveVStorageObjectMetadataValue,omitempty"` 728 Res *types.VslmRetrieveVStorageObjectMetadataValueResponse `xml:"urn:vslm VslmRetrieveVStorageObjectMetadataValueResponse,omitempty"` 729 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 730 } 731 732 func (b *VslmRetrieveVStorageObjectMetadataValueBody) Fault() *soap.Fault { return b.Fault_ } 733 734 func VslmRetrieveVStorageObjectMetadataValue(ctx context.Context, r soap.RoundTripper, req *types.VslmRetrieveVStorageObjectMetadataValue) (*types.VslmRetrieveVStorageObjectMetadataValueResponse, error) { 735 var reqBody, resBody VslmRetrieveVStorageObjectMetadataValueBody 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 746 type VslmRetrieveVStorageObjectStateBody struct { 747 Req *types.VslmRetrieveVStorageObjectState `xml:"urn:vslm VslmRetrieveVStorageObjectState,omitempty"` 748 Res *types.VslmRetrieveVStorageObjectStateResponse `xml:"urn:vslm VslmRetrieveVStorageObjectStateResponse,omitempty"` 749 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 750 } 751 752 func (b *VslmRetrieveVStorageObjectStateBody) Fault() *soap.Fault { return b.Fault_ } 753 754 func VslmRetrieveVStorageObjectState(ctx context.Context, r soap.RoundTripper, req *types.VslmRetrieveVStorageObjectState) (*types.VslmRetrieveVStorageObjectStateResponse, error) { 755 var reqBody, resBody VslmRetrieveVStorageObjectStateBody 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 766 type VslmRetrieveVStorageObjectsBody struct { 767 Req *types.VslmRetrieveVStorageObjects `xml:"urn:vslm VslmRetrieveVStorageObjects,omitempty"` 768 Res *types.VslmRetrieveVStorageObjectsResponse `xml:"urn:vslm VslmRetrieveVStorageObjectsResponse,omitempty"` 769 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 770 } 771 772 func (b *VslmRetrieveVStorageObjectsBody) Fault() *soap.Fault { return b.Fault_ } 773 774 func VslmRetrieveVStorageObjects(ctx context.Context, r soap.RoundTripper, req *types.VslmRetrieveVStorageObjects) (*types.VslmRetrieveVStorageObjectsResponse, error) { 775 var reqBody, resBody VslmRetrieveVStorageObjectsBody 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 786 type VslmRevertVStorageObject_TaskBody struct { 787 Req *types.VslmRevertVStorageObject_Task `xml:"urn:vslm VslmRevertVStorageObject_Task,omitempty"` 788 Res *types.VslmRevertVStorageObject_TaskResponse `xml:"urn:vslm VslmRevertVStorageObject_TaskResponse,omitempty"` 789 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 790 } 791 792 func (b *VslmRevertVStorageObject_TaskBody) Fault() *soap.Fault { return b.Fault_ } 793 794 func VslmRevertVStorageObject_Task(ctx context.Context, r soap.RoundTripper, req *types.VslmRevertVStorageObject_Task) (*types.VslmRevertVStorageObject_TaskResponse, error) { 795 var reqBody, resBody VslmRevertVStorageObject_TaskBody 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 806 type VslmScheduleReconcileDatastoreInventoryBody struct { 807 Req *types.VslmScheduleReconcileDatastoreInventory `xml:"urn:vslm VslmScheduleReconcileDatastoreInventory,omitempty"` 808 Res *types.VslmScheduleReconcileDatastoreInventoryResponse `xml:"urn:vslm VslmScheduleReconcileDatastoreInventoryResponse,omitempty"` 809 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 810 } 811 812 func (b *VslmScheduleReconcileDatastoreInventoryBody) Fault() *soap.Fault { return b.Fault_ } 813 814 func VslmScheduleReconcileDatastoreInventory(ctx context.Context, r soap.RoundTripper, req *types.VslmScheduleReconcileDatastoreInventory) (*types.VslmScheduleReconcileDatastoreInventoryResponse, error) { 815 var reqBody, resBody VslmScheduleReconcileDatastoreInventoryBody 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 826 type VslmSetVStorageObjectControlFlagsBody struct { 827 Req *types.VslmSetVStorageObjectControlFlags `xml:"urn:vslm VslmSetVStorageObjectControlFlags,omitempty"` 828 Res *types.VslmSetVStorageObjectControlFlagsResponse `xml:"urn:vslm VslmSetVStorageObjectControlFlagsResponse,omitempty"` 829 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 830 } 831 832 func (b *VslmSetVStorageObjectControlFlagsBody) Fault() *soap.Fault { return b.Fault_ } 833 834 func VslmSetVStorageObjectControlFlags(ctx context.Context, r soap.RoundTripper, req *types.VslmSetVStorageObjectControlFlags) (*types.VslmSetVStorageObjectControlFlagsResponse, error) { 835 var reqBody, resBody VslmSetVStorageObjectControlFlagsBody 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 846 type VslmSyncDatastoreBody struct { 847 Req *types.VslmSyncDatastore `xml:"urn:vslm VslmSyncDatastore,omitempty"` 848 Res *types.VslmSyncDatastoreResponse `xml:"urn:vslm VslmSyncDatastoreResponse,omitempty"` 849 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 850 } 851 852 func (b *VslmSyncDatastoreBody) Fault() *soap.Fault { return b.Fault_ } 853 854 func VslmSyncDatastore(ctx context.Context, r soap.RoundTripper, req *types.VslmSyncDatastore) (*types.VslmSyncDatastoreResponse, error) { 855 var reqBody, resBody VslmSyncDatastoreBody 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 866 type VslmUpdateVStorageInfrastructureObjectPolicy_TaskBody struct { 867 Req *types.VslmUpdateVStorageInfrastructureObjectPolicy_Task `xml:"urn:vslm VslmUpdateVStorageInfrastructureObjectPolicy_Task,omitempty"` 868 Res *types.VslmUpdateVStorageInfrastructureObjectPolicy_TaskResponse `xml:"urn:vslm VslmUpdateVStorageInfrastructureObjectPolicy_TaskResponse,omitempty"` 869 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 870 } 871 872 func (b *VslmUpdateVStorageInfrastructureObjectPolicy_TaskBody) Fault() *soap.Fault { return b.Fault_ } 873 874 func VslmUpdateVStorageInfrastructureObjectPolicy_Task(ctx context.Context, r soap.RoundTripper, req *types.VslmUpdateVStorageInfrastructureObjectPolicy_Task) (*types.VslmUpdateVStorageInfrastructureObjectPolicy_TaskResponse, error) { 875 var reqBody, resBody VslmUpdateVStorageInfrastructureObjectPolicy_TaskBody 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 886 type VslmUpdateVStorageObjectMetadata_TaskBody struct { 887 Req *types.VslmUpdateVStorageObjectMetadata_Task `xml:"urn:vslm VslmUpdateVStorageObjectMetadata_Task,omitempty"` 888 Res *types.VslmUpdateVStorageObjectMetadata_TaskResponse `xml:"urn:vslm VslmUpdateVStorageObjectMetadata_TaskResponse,omitempty"` 889 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 890 } 891 892 func (b *VslmUpdateVStorageObjectMetadata_TaskBody) Fault() *soap.Fault { return b.Fault_ } 893 894 func VslmUpdateVStorageObjectMetadata_Task(ctx context.Context, r soap.RoundTripper, req *types.VslmUpdateVStorageObjectMetadata_Task) (*types.VslmUpdateVStorageObjectMetadata_TaskResponse, error) { 895 var reqBody, resBody VslmUpdateVStorageObjectMetadata_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 906 type VslmUpdateVstorageObjectCrypto_TaskBody struct { 907 Req *types.VslmUpdateVstorageObjectCrypto_Task `xml:"urn:vslm VslmUpdateVstorageObjectCrypto_Task,omitempty"` 908 Res *types.VslmUpdateVstorageObjectCrypto_TaskResponse `xml:"urn:vslm VslmUpdateVstorageObjectCrypto_TaskResponse,omitempty"` 909 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 910 } 911 912 func (b *VslmUpdateVstorageObjectCrypto_TaskBody) Fault() *soap.Fault { return b.Fault_ } 913 914 func VslmUpdateVstorageObjectCrypto_Task(ctx context.Context, r soap.RoundTripper, req *types.VslmUpdateVstorageObjectCrypto_Task) (*types.VslmUpdateVstorageObjectCrypto_TaskResponse, error) { 915 var reqBody, resBody VslmUpdateVstorageObjectCrypto_TaskBody 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 926 type VslmUpdateVstorageObjectPolicy_TaskBody struct { 927 Req *types.VslmUpdateVstorageObjectPolicy_Task `xml:"urn:vslm VslmUpdateVstorageObjectPolicy_Task,omitempty"` 928 Res *types.VslmUpdateVstorageObjectPolicy_TaskResponse `xml:"urn:vslm VslmUpdateVstorageObjectPolicy_TaskResponse,omitempty"` 929 Fault_ *soap.Fault `xml:"http://schemas.xmlsoap.org/soap/envelope/ Fault,omitempty"` 930 } 931 932 func (b *VslmUpdateVstorageObjectPolicy_TaskBody) Fault() *soap.Fault { return b.Fault_ } 933 934 func VslmUpdateVstorageObjectPolicy_Task(ctx context.Context, r soap.RoundTripper, req *types.VslmUpdateVstorageObjectPolicy_Task) (*types.VslmUpdateVstorageObjectPolicy_TaskResponse, error) { 935 var reqBody, resBody VslmUpdateVstorageObjectPolicy_TaskBody 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 }