zz_api_transformers.go raw
1 // Copyright 2022-2025 The sacloud/iaas-api-go Authors
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 // generated by 'github.com/sacloud/iaas-api-go/internal/tools/gen-api-transformer'; DO NOT EDIT
16
17 package iaas
18
19 import (
20 "encoding/json"
21
22 "github.com/sacloud/iaas-api-go/mapconv"
23 "github.com/sacloud/iaas-api-go/types"
24 )
25
26 func (o *ArchiveOp) transformFindArgs(conditions *FindCondition) (*archiveFindRequestEnvelope, error) {
27 if conditions == nil {
28 conditions = &FindCondition{}
29 }
30 var arg0 interface{} = conditions
31 if v, ok := arg0.(argumentDefaulter); ok {
32 arg0 = v.setDefaults()
33 }
34 args := &struct {
35 Arg0 interface{} `mapconv:",squash"`
36 }{
37 Arg0: arg0,
38 }
39
40 v := &archiveFindRequestEnvelope{}
41 if err := mapconv.ConvertTo(args, v); err != nil {
42 return nil, err
43 }
44 return v, nil
45 }
46
47 func (o *ArchiveOp) transformFindResults(data []byte) (*ArchiveFindResult, error) {
48 nakedResponse := &archiveFindResponseEnvelope{}
49 if err := json.Unmarshal(data, nakedResponse); err != nil {
50 return nil, err
51 }
52
53 results := &ArchiveFindResult{}
54 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
55 return nil, err
56 }
57 return results, nil
58 }
59
60 func (o *ArchiveOp) transformCreateArgs(param *ArchiveCreateRequest) (*archiveCreateRequestEnvelope, error) {
61 if param == nil {
62 param = &ArchiveCreateRequest{}
63 }
64 var arg0 interface{} = param
65 if v, ok := arg0.(argumentDefaulter); ok {
66 arg0 = v.setDefaults()
67 }
68 args := &struct {
69 Arg0 interface{} `mapconv:"Archive,recursive"`
70 }{
71 Arg0: arg0,
72 }
73
74 v := &archiveCreateRequestEnvelope{}
75 if err := mapconv.ConvertTo(args, v); err != nil {
76 return nil, err
77 }
78 return v, nil
79 }
80
81 func (o *ArchiveOp) transformCreateResults(data []byte) (*archiveCreateResult, error) {
82 nakedResponse := &archiveCreateResponseEnvelope{}
83 if err := json.Unmarshal(data, nakedResponse); err != nil {
84 return nil, err
85 }
86
87 results := &archiveCreateResult{}
88 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
89 return nil, err
90 }
91 return results, nil
92 }
93
94 func (o *ArchiveOp) transformCreateBlankArgs(param *ArchiveCreateBlankRequest) (*archiveCreateBlankRequestEnvelope, error) {
95 if param == nil {
96 param = &ArchiveCreateBlankRequest{}
97 }
98 var arg0 interface{} = param
99 if v, ok := arg0.(argumentDefaulter); ok {
100 arg0 = v.setDefaults()
101 }
102 args := &struct {
103 Arg0 interface{} `mapconv:"Archive,recursive"`
104 }{
105 Arg0: arg0,
106 }
107
108 v := &archiveCreateBlankRequestEnvelope{}
109 if err := mapconv.ConvertTo(args, v); err != nil {
110 return nil, err
111 }
112 return v, nil
113 }
114
115 func (o *ArchiveOp) transformCreateBlankResults(data []byte) (*archiveCreateBlankResult, error) {
116 nakedResponse := &archiveCreateBlankResponseEnvelope{}
117 if err := json.Unmarshal(data, nakedResponse); err != nil {
118 return nil, err
119 }
120
121 results := &archiveCreateBlankResult{}
122 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
123 return nil, err
124 }
125 return results, nil
126 }
127
128 func (o *ArchiveOp) transformReadResults(data []byte) (*archiveReadResult, error) {
129 nakedResponse := &archiveReadResponseEnvelope{}
130 if err := json.Unmarshal(data, nakedResponse); err != nil {
131 return nil, err
132 }
133
134 results := &archiveReadResult{}
135 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
136 return nil, err
137 }
138 return results, nil
139 }
140
141 func (o *ArchiveOp) transformUpdateArgs(id types.ID, param *ArchiveUpdateRequest) (*archiveUpdateRequestEnvelope, error) {
142 if id == types.ID(int64(0)) {
143 id = types.ID(int64(0))
144 }
145 var arg0 interface{} = id
146 if v, ok := arg0.(argumentDefaulter); ok {
147 arg0 = v.setDefaults()
148 }
149 if param == nil {
150 param = &ArchiveUpdateRequest{}
151 }
152 var arg1 interface{} = param
153 if v, ok := arg1.(argumentDefaulter); ok {
154 arg1 = v.setDefaults()
155 }
156 args := &struct {
157 Arg0 interface{}
158 Arg1 interface{} `mapconv:"Archive,recursive"`
159 }{
160 Arg0: arg0,
161 Arg1: arg1,
162 }
163
164 v := &archiveUpdateRequestEnvelope{}
165 if err := mapconv.ConvertTo(args, v); err != nil {
166 return nil, err
167 }
168 return v, nil
169 }
170
171 func (o *ArchiveOp) transformUpdateResults(data []byte) (*archiveUpdateResult, error) {
172 nakedResponse := &archiveUpdateResponseEnvelope{}
173 if err := json.Unmarshal(data, nakedResponse); err != nil {
174 return nil, err
175 }
176
177 results := &archiveUpdateResult{}
178 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
179 return nil, err
180 }
181 return results, nil
182 }
183
184 func (o *ArchiveOp) transformOpenFTPArgs(id types.ID, openOption *OpenFTPRequest) (*archiveOpenFTPRequestEnvelope, error) {
185 if id == types.ID(int64(0)) {
186 id = types.ID(int64(0))
187 }
188 var arg0 interface{} = id
189 if v, ok := arg0.(argumentDefaulter); ok {
190 arg0 = v.setDefaults()
191 }
192 if openOption == nil {
193 openOption = &OpenFTPRequest{}
194 }
195 var arg1 interface{} = openOption
196 if v, ok := arg1.(argumentDefaulter); ok {
197 arg1 = v.setDefaults()
198 }
199 args := &struct {
200 Arg0 interface{}
201 Arg1 interface{} `mapconv:",squash"`
202 }{
203 Arg0: arg0,
204 Arg1: arg1,
205 }
206
207 v := &archiveOpenFTPRequestEnvelope{}
208 if err := mapconv.ConvertTo(args, v); err != nil {
209 return nil, err
210 }
211 return v, nil
212 }
213
214 func (o *ArchiveOp) transformOpenFTPResults(data []byte) (*archiveOpenFTPResult, error) {
215 nakedResponse := &archiveOpenFTPResponseEnvelope{}
216 if err := json.Unmarshal(data, nakedResponse); err != nil {
217 return nil, err
218 }
219
220 results := &archiveOpenFTPResult{}
221 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
222 return nil, err
223 }
224 return results, nil
225 }
226
227 func (o *ArchiveOp) transformShareArgs(id types.ID) (*archiveShareRequestEnvelope, error) {
228 if id == types.ID(int64(0)) {
229 id = types.ID(int64(0))
230 }
231 var arg0 interface{} = id
232 if v, ok := arg0.(argumentDefaulter); ok {
233 arg0 = v.setDefaults()
234 }
235 args := &struct {
236 Arg0 interface{}
237 }{
238 Arg0: arg0,
239 }
240
241 v := &archiveShareRequestEnvelope{}
242 if err := mapconv.ConvertTo(args, v); err != nil {
243 return nil, err
244 }
245 return v, nil
246 }
247
248 func (o *ArchiveOp) transformShareResults(data []byte) (*archiveShareResult, error) {
249 nakedResponse := &archiveShareResponseEnvelope{}
250 if err := json.Unmarshal(data, nakedResponse); err != nil {
251 return nil, err
252 }
253
254 results := &archiveShareResult{}
255 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
256 return nil, err
257 }
258 return results, nil
259 }
260
261 func (o *ArchiveOp) transformCreateFromSharedArgs(sourceArchiveID types.ID, destZoneID types.ID, param *ArchiveCreateRequestFromShared) (*archiveCreateFromSharedRequestEnvelope, error) {
262 if sourceArchiveID == types.ID(int64(0)) {
263 sourceArchiveID = types.ID(int64(0))
264 }
265 var arg0 interface{} = sourceArchiveID
266 if v, ok := arg0.(argumentDefaulter); ok {
267 arg0 = v.setDefaults()
268 }
269 if destZoneID == types.ID(int64(0)) {
270 destZoneID = types.ID(int64(0))
271 }
272 var arg1 interface{} = destZoneID
273 if v, ok := arg1.(argumentDefaulter); ok {
274 arg1 = v.setDefaults()
275 }
276 if param == nil {
277 param = &ArchiveCreateRequestFromShared{}
278 }
279 var arg2 interface{} = param
280 if v, ok := arg2.(argumentDefaulter); ok {
281 arg2 = v.setDefaults()
282 }
283 args := &struct {
284 Arg0 interface{}
285 Arg1 interface{}
286 Arg2 interface{} `mapconv:"Archive,recursive"`
287 }{
288 Arg0: arg0,
289 Arg1: arg1,
290 Arg2: arg2,
291 }
292
293 v := &archiveCreateFromSharedRequestEnvelope{}
294 if err := mapconv.ConvertTo(args, v); err != nil {
295 return nil, err
296 }
297 return v, nil
298 }
299
300 func (o *ArchiveOp) transformCreateFromSharedResults(data []byte) (*archiveCreateFromSharedResult, error) {
301 nakedResponse := &archiveCreateFromSharedResponseEnvelope{}
302 if err := json.Unmarshal(data, nakedResponse); err != nil {
303 return nil, err
304 }
305
306 results := &archiveCreateFromSharedResult{}
307 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
308 return nil, err
309 }
310 return results, nil
311 }
312
313 func (o *ArchiveOp) transformTransferArgs(sourceArchiveID types.ID, destZoneID types.ID, param *ArchiveTransferRequest) (*archiveTransferRequestEnvelope, error) {
314 if sourceArchiveID == types.ID(int64(0)) {
315 sourceArchiveID = types.ID(int64(0))
316 }
317 var arg0 interface{} = sourceArchiveID
318 if v, ok := arg0.(argumentDefaulter); ok {
319 arg0 = v.setDefaults()
320 }
321 if destZoneID == types.ID(int64(0)) {
322 destZoneID = types.ID(int64(0))
323 }
324 var arg1 interface{} = destZoneID
325 if v, ok := arg1.(argumentDefaulter); ok {
326 arg1 = v.setDefaults()
327 }
328 if param == nil {
329 param = &ArchiveTransferRequest{}
330 }
331 var arg2 interface{} = param
332 if v, ok := arg2.(argumentDefaulter); ok {
333 arg2 = v.setDefaults()
334 }
335 args := &struct {
336 Arg0 interface{}
337 Arg1 interface{}
338 Arg2 interface{} `mapconv:"Archive,recursive"`
339 }{
340 Arg0: arg0,
341 Arg1: arg1,
342 Arg2: arg2,
343 }
344
345 v := &archiveTransferRequestEnvelope{}
346 if err := mapconv.ConvertTo(args, v); err != nil {
347 return nil, err
348 }
349 return v, nil
350 }
351
352 func (o *ArchiveOp) transformTransferResults(data []byte) (*archiveTransferResult, error) {
353 nakedResponse := &archiveTransferResponseEnvelope{}
354 if err := json.Unmarshal(data, nakedResponse); err != nil {
355 return nil, err
356 }
357
358 results := &archiveTransferResult{}
359 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
360 return nil, err
361 }
362 return results, nil
363 }
364
365 func (o *AuthStatusOp) transformReadResults(data []byte) (*authStatusReadResult, error) {
366 nakedResponse := &authStatusReadResponseEnvelope{}
367 if err := json.Unmarshal(data, nakedResponse); err != nil {
368 return nil, err
369 }
370
371 results := &authStatusReadResult{}
372 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
373 return nil, err
374 }
375 return results, nil
376 }
377
378 func (o *AutoBackupOp) transformFindArgs(conditions *FindCondition) (*autoBackupFindRequestEnvelope, error) {
379 if conditions == nil {
380 conditions = &FindCondition{}
381 }
382 var arg0 interface{} = conditions
383 if v, ok := arg0.(argumentDefaulter); ok {
384 arg0 = v.setDefaults()
385 }
386 args := &struct {
387 Arg0 interface{} `mapconv:",squash"`
388 }{
389 Arg0: arg0,
390 }
391
392 v := &autoBackupFindRequestEnvelope{}
393 if err := mapconv.ConvertTo(args, v); err != nil {
394 return nil, err
395 }
396 return v, nil
397 }
398
399 func (o *AutoBackupOp) transformFindResults(data []byte) (*AutoBackupFindResult, error) {
400 nakedResponse := &autoBackupFindResponseEnvelope{}
401 if err := json.Unmarshal(data, nakedResponse); err != nil {
402 return nil, err
403 }
404
405 results := &AutoBackupFindResult{}
406 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
407 return nil, err
408 }
409 return results, nil
410 }
411
412 func (o *AutoBackupOp) transformCreateArgs(param *AutoBackupCreateRequest) (*autoBackupCreateRequestEnvelope, error) {
413 if param == nil {
414 param = &AutoBackupCreateRequest{}
415 }
416 var arg0 interface{} = param
417 if v, ok := arg0.(argumentDefaulter); ok {
418 arg0 = v.setDefaults()
419 }
420 args := &struct {
421 Arg0 interface{} `mapconv:"CommonServiceItem,recursive"`
422 }{
423 Arg0: arg0,
424 }
425
426 v := &autoBackupCreateRequestEnvelope{}
427 if err := mapconv.ConvertTo(args, v); err != nil {
428 return nil, err
429 }
430 return v, nil
431 }
432
433 func (o *AutoBackupOp) transformCreateResults(data []byte) (*autoBackupCreateResult, error) {
434 nakedResponse := &autoBackupCreateResponseEnvelope{}
435 if err := json.Unmarshal(data, nakedResponse); err != nil {
436 return nil, err
437 }
438
439 results := &autoBackupCreateResult{}
440 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
441 return nil, err
442 }
443 return results, nil
444 }
445
446 func (o *AutoBackupOp) transformReadResults(data []byte) (*autoBackupReadResult, error) {
447 nakedResponse := &autoBackupReadResponseEnvelope{}
448 if err := json.Unmarshal(data, nakedResponse); err != nil {
449 return nil, err
450 }
451
452 results := &autoBackupReadResult{}
453 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
454 return nil, err
455 }
456 return results, nil
457 }
458
459 func (o *AutoBackupOp) transformUpdateArgs(id types.ID, param *AutoBackupUpdateRequest) (*autoBackupUpdateRequestEnvelope, error) {
460 if id == types.ID(int64(0)) {
461 id = types.ID(int64(0))
462 }
463 var arg0 interface{} = id
464 if v, ok := arg0.(argumentDefaulter); ok {
465 arg0 = v.setDefaults()
466 }
467 if param == nil {
468 param = &AutoBackupUpdateRequest{}
469 }
470 var arg1 interface{} = param
471 if v, ok := arg1.(argumentDefaulter); ok {
472 arg1 = v.setDefaults()
473 }
474 args := &struct {
475 Arg0 interface{}
476 Arg1 interface{} `mapconv:"CommonServiceItem,recursive"`
477 }{
478 Arg0: arg0,
479 Arg1: arg1,
480 }
481
482 v := &autoBackupUpdateRequestEnvelope{}
483 if err := mapconv.ConvertTo(args, v); err != nil {
484 return nil, err
485 }
486 return v, nil
487 }
488
489 func (o *AutoBackupOp) transformUpdateResults(data []byte) (*autoBackupUpdateResult, error) {
490 nakedResponse := &autoBackupUpdateResponseEnvelope{}
491 if err := json.Unmarshal(data, nakedResponse); err != nil {
492 return nil, err
493 }
494
495 results := &autoBackupUpdateResult{}
496 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
497 return nil, err
498 }
499 return results, nil
500 }
501
502 func (o *AutoBackupOp) transformUpdateSettingsArgs(id types.ID, param *AutoBackupUpdateSettingsRequest) (*autoBackupUpdateSettingsRequestEnvelope, error) {
503 if id == types.ID(int64(0)) {
504 id = types.ID(int64(0))
505 }
506 var arg0 interface{} = id
507 if v, ok := arg0.(argumentDefaulter); ok {
508 arg0 = v.setDefaults()
509 }
510 if param == nil {
511 param = &AutoBackupUpdateSettingsRequest{}
512 }
513 var arg1 interface{} = param
514 if v, ok := arg1.(argumentDefaulter); ok {
515 arg1 = v.setDefaults()
516 }
517 args := &struct {
518 Arg0 interface{}
519 Arg1 interface{} `mapconv:"CommonServiceItem,recursive"`
520 }{
521 Arg0: arg0,
522 Arg1: arg1,
523 }
524
525 v := &autoBackupUpdateSettingsRequestEnvelope{}
526 if err := mapconv.ConvertTo(args, v); err != nil {
527 return nil, err
528 }
529 return v, nil
530 }
531
532 func (o *AutoBackupOp) transformUpdateSettingsResults(data []byte) (*autoBackupUpdateSettingsResult, error) {
533 nakedResponse := &autoBackupUpdateSettingsResponseEnvelope{}
534 if err := json.Unmarshal(data, nakedResponse); err != nil {
535 return nil, err
536 }
537
538 results := &autoBackupUpdateSettingsResult{}
539 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
540 return nil, err
541 }
542 return results, nil
543 }
544
545 func (o *AutoScaleOp) transformFindArgs(conditions *FindCondition) (*autoScaleFindRequestEnvelope, error) {
546 if conditions == nil {
547 conditions = &FindCondition{}
548 }
549 var arg0 interface{} = conditions
550 if v, ok := arg0.(argumentDefaulter); ok {
551 arg0 = v.setDefaults()
552 }
553 args := &struct {
554 Arg0 interface{} `mapconv:",squash"`
555 }{
556 Arg0: arg0,
557 }
558
559 v := &autoScaleFindRequestEnvelope{}
560 if err := mapconv.ConvertTo(args, v); err != nil {
561 return nil, err
562 }
563 return v, nil
564 }
565
566 func (o *AutoScaleOp) transformFindResults(data []byte) (*AutoScaleFindResult, error) {
567 nakedResponse := &autoScaleFindResponseEnvelope{}
568 if err := json.Unmarshal(data, nakedResponse); err != nil {
569 return nil, err
570 }
571
572 results := &AutoScaleFindResult{}
573 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
574 return nil, err
575 }
576 return results, nil
577 }
578
579 func (o *AutoScaleOp) transformCreateArgs(param *AutoScaleCreateRequest) (*autoScaleCreateRequestEnvelope, error) {
580 if param == nil {
581 param = &AutoScaleCreateRequest{}
582 }
583 var arg0 interface{} = param
584 if v, ok := arg0.(argumentDefaulter); ok {
585 arg0 = v.setDefaults()
586 }
587 args := &struct {
588 Arg0 interface{} `mapconv:"CommonServiceItem,recursive"`
589 }{
590 Arg0: arg0,
591 }
592
593 v := &autoScaleCreateRequestEnvelope{}
594 if err := mapconv.ConvertTo(args, v); err != nil {
595 return nil, err
596 }
597 return v, nil
598 }
599
600 func (o *AutoScaleOp) transformCreateResults(data []byte) (*autoScaleCreateResult, error) {
601 nakedResponse := &autoScaleCreateResponseEnvelope{}
602 if err := json.Unmarshal(data, nakedResponse); err != nil {
603 return nil, err
604 }
605
606 results := &autoScaleCreateResult{}
607 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
608 return nil, err
609 }
610 return results, nil
611 }
612
613 func (o *AutoScaleOp) transformReadResults(data []byte) (*autoScaleReadResult, error) {
614 nakedResponse := &autoScaleReadResponseEnvelope{}
615 if err := json.Unmarshal(data, nakedResponse); err != nil {
616 return nil, err
617 }
618
619 results := &autoScaleReadResult{}
620 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
621 return nil, err
622 }
623 return results, nil
624 }
625
626 func (o *AutoScaleOp) transformUpdateArgs(id types.ID, param *AutoScaleUpdateRequest) (*autoScaleUpdateRequestEnvelope, error) {
627 if id == types.ID(int64(0)) {
628 id = types.ID(int64(0))
629 }
630 var arg0 interface{} = id
631 if v, ok := arg0.(argumentDefaulter); ok {
632 arg0 = v.setDefaults()
633 }
634 if param == nil {
635 param = &AutoScaleUpdateRequest{}
636 }
637 var arg1 interface{} = param
638 if v, ok := arg1.(argumentDefaulter); ok {
639 arg1 = v.setDefaults()
640 }
641 args := &struct {
642 Arg0 interface{}
643 Arg1 interface{} `mapconv:"CommonServiceItem,recursive"`
644 }{
645 Arg0: arg0,
646 Arg1: arg1,
647 }
648
649 v := &autoScaleUpdateRequestEnvelope{}
650 if err := mapconv.ConvertTo(args, v); err != nil {
651 return nil, err
652 }
653 return v, nil
654 }
655
656 func (o *AutoScaleOp) transformUpdateResults(data []byte) (*autoScaleUpdateResult, error) {
657 nakedResponse := &autoScaleUpdateResponseEnvelope{}
658 if err := json.Unmarshal(data, nakedResponse); err != nil {
659 return nil, err
660 }
661
662 results := &autoScaleUpdateResult{}
663 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
664 return nil, err
665 }
666 return results, nil
667 }
668
669 func (o *AutoScaleOp) transformUpdateSettingsArgs(id types.ID, param *AutoScaleUpdateSettingsRequest) (*autoScaleUpdateSettingsRequestEnvelope, error) {
670 if id == types.ID(int64(0)) {
671 id = types.ID(int64(0))
672 }
673 var arg0 interface{} = id
674 if v, ok := arg0.(argumentDefaulter); ok {
675 arg0 = v.setDefaults()
676 }
677 if param == nil {
678 param = &AutoScaleUpdateSettingsRequest{}
679 }
680 var arg1 interface{} = param
681 if v, ok := arg1.(argumentDefaulter); ok {
682 arg1 = v.setDefaults()
683 }
684 args := &struct {
685 Arg0 interface{}
686 Arg1 interface{} `mapconv:"CommonServiceItem,recursive"`
687 }{
688 Arg0: arg0,
689 Arg1: arg1,
690 }
691
692 v := &autoScaleUpdateSettingsRequestEnvelope{}
693 if err := mapconv.ConvertTo(args, v); err != nil {
694 return nil, err
695 }
696 return v, nil
697 }
698
699 func (o *AutoScaleOp) transformUpdateSettingsResults(data []byte) (*autoScaleUpdateSettingsResult, error) {
700 nakedResponse := &autoScaleUpdateSettingsResponseEnvelope{}
701 if err := json.Unmarshal(data, nakedResponse); err != nil {
702 return nil, err
703 }
704
705 results := &autoScaleUpdateSettingsResult{}
706 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
707 return nil, err
708 }
709 return results, nil
710 }
711
712 func (o *AutoScaleOp) transformStatusResults(data []byte) (*autoScaleStatusResult, error) {
713 nakedResponse := &autoScaleStatusResponseEnvelope{}
714 if err := json.Unmarshal(data, nakedResponse); err != nil {
715 return nil, err
716 }
717
718 results := &autoScaleStatusResult{}
719 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
720 return nil, err
721 }
722 return results, nil
723 }
724
725 func (o *BillOp) transformByContractResults(data []byte) (*BillByContractResult, error) {
726 nakedResponse := &billByContractResponseEnvelope{}
727 if err := json.Unmarshal(data, nakedResponse); err != nil {
728 return nil, err
729 }
730
731 results := &BillByContractResult{}
732 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
733 return nil, err
734 }
735 return results, nil
736 }
737
738 func (o *BillOp) transformByContractYearResults(data []byte) (*BillByContractYearResult, error) {
739 nakedResponse := &billByContractYearResponseEnvelope{}
740 if err := json.Unmarshal(data, nakedResponse); err != nil {
741 return nil, err
742 }
743
744 results := &BillByContractYearResult{}
745 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
746 return nil, err
747 }
748 return results, nil
749 }
750
751 func (o *BillOp) transformByContractYearMonthResults(data []byte) (*BillByContractYearMonthResult, error) {
752 nakedResponse := &billByContractYearMonthResponseEnvelope{}
753 if err := json.Unmarshal(data, nakedResponse); err != nil {
754 return nil, err
755 }
756
757 results := &BillByContractYearMonthResult{}
758 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
759 return nil, err
760 }
761 return results, nil
762 }
763
764 func (o *BillOp) transformReadResults(data []byte) (*BillReadResult, error) {
765 nakedResponse := &billReadResponseEnvelope{}
766 if err := json.Unmarshal(data, nakedResponse); err != nil {
767 return nil, err
768 }
769
770 results := &BillReadResult{}
771 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
772 return nil, err
773 }
774 return results, nil
775 }
776
777 func (o *BillOp) transformDetailsResults(data []byte) (*BillDetailsResult, error) {
778 nakedResponse := &billDetailsResponseEnvelope{}
779 if err := json.Unmarshal(data, nakedResponse); err != nil {
780 return nil, err
781 }
782
783 results := &BillDetailsResult{}
784 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
785 return nil, err
786 }
787 return results, nil
788 }
789
790 func (o *BillOp) transformDetailsCSVResults(data []byte) (*billDetailsCSVResult, error) {
791 nakedResponse := &billDetailsCSVResponseEnvelope{}
792 if err := json.Unmarshal(data, nakedResponse); err != nil {
793 return nil, err
794 }
795
796 results := &billDetailsCSVResult{}
797 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
798 return nil, err
799 }
800 return results, nil
801 }
802
803 func (o *BridgeOp) transformFindArgs(conditions *FindCondition) (*bridgeFindRequestEnvelope, error) {
804 if conditions == nil {
805 conditions = &FindCondition{}
806 }
807 var arg0 interface{} = conditions
808 if v, ok := arg0.(argumentDefaulter); ok {
809 arg0 = v.setDefaults()
810 }
811 args := &struct {
812 Arg0 interface{} `mapconv:",squash"`
813 }{
814 Arg0: arg0,
815 }
816
817 v := &bridgeFindRequestEnvelope{}
818 if err := mapconv.ConvertTo(args, v); err != nil {
819 return nil, err
820 }
821 return v, nil
822 }
823
824 func (o *BridgeOp) transformFindResults(data []byte) (*BridgeFindResult, error) {
825 nakedResponse := &bridgeFindResponseEnvelope{}
826 if err := json.Unmarshal(data, nakedResponse); err != nil {
827 return nil, err
828 }
829
830 results := &BridgeFindResult{}
831 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
832 return nil, err
833 }
834 return results, nil
835 }
836
837 func (o *BridgeOp) transformCreateArgs(param *BridgeCreateRequest) (*bridgeCreateRequestEnvelope, error) {
838 if param == nil {
839 param = &BridgeCreateRequest{}
840 }
841 var arg0 interface{} = param
842 if v, ok := arg0.(argumentDefaulter); ok {
843 arg0 = v.setDefaults()
844 }
845 args := &struct {
846 Arg0 interface{} `mapconv:"Bridge,recursive"`
847 }{
848 Arg0: arg0,
849 }
850
851 v := &bridgeCreateRequestEnvelope{}
852 if err := mapconv.ConvertTo(args, v); err != nil {
853 return nil, err
854 }
855 return v, nil
856 }
857
858 func (o *BridgeOp) transformCreateResults(data []byte) (*bridgeCreateResult, error) {
859 nakedResponse := &bridgeCreateResponseEnvelope{}
860 if err := json.Unmarshal(data, nakedResponse); err != nil {
861 return nil, err
862 }
863
864 results := &bridgeCreateResult{}
865 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
866 return nil, err
867 }
868 return results, nil
869 }
870
871 func (o *BridgeOp) transformReadResults(data []byte) (*bridgeReadResult, error) {
872 nakedResponse := &bridgeReadResponseEnvelope{}
873 if err := json.Unmarshal(data, nakedResponse); err != nil {
874 return nil, err
875 }
876
877 results := &bridgeReadResult{}
878 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
879 return nil, err
880 }
881 return results, nil
882 }
883
884 func (o *BridgeOp) transformUpdateArgs(id types.ID, param *BridgeUpdateRequest) (*bridgeUpdateRequestEnvelope, error) {
885 if id == types.ID(int64(0)) {
886 id = types.ID(int64(0))
887 }
888 var arg0 interface{} = id
889 if v, ok := arg0.(argumentDefaulter); ok {
890 arg0 = v.setDefaults()
891 }
892 if param == nil {
893 param = &BridgeUpdateRequest{}
894 }
895 var arg1 interface{} = param
896 if v, ok := arg1.(argumentDefaulter); ok {
897 arg1 = v.setDefaults()
898 }
899 args := &struct {
900 Arg0 interface{}
901 Arg1 interface{} `mapconv:"Bridge,recursive"`
902 }{
903 Arg0: arg0,
904 Arg1: arg1,
905 }
906
907 v := &bridgeUpdateRequestEnvelope{}
908 if err := mapconv.ConvertTo(args, v); err != nil {
909 return nil, err
910 }
911 return v, nil
912 }
913
914 func (o *BridgeOp) transformUpdateResults(data []byte) (*bridgeUpdateResult, error) {
915 nakedResponse := &bridgeUpdateResponseEnvelope{}
916 if err := json.Unmarshal(data, nakedResponse); err != nil {
917 return nil, err
918 }
919
920 results := &bridgeUpdateResult{}
921 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
922 return nil, err
923 }
924 return results, nil
925 }
926
927 func (o *CDROMOp) transformFindArgs(conditions *FindCondition) (*cDROMFindRequestEnvelope, error) {
928 if conditions == nil {
929 conditions = &FindCondition{}
930 }
931 var arg0 interface{} = conditions
932 if v, ok := arg0.(argumentDefaulter); ok {
933 arg0 = v.setDefaults()
934 }
935 args := &struct {
936 Arg0 interface{} `mapconv:",squash"`
937 }{
938 Arg0: arg0,
939 }
940
941 v := &cDROMFindRequestEnvelope{}
942 if err := mapconv.ConvertTo(args, v); err != nil {
943 return nil, err
944 }
945 return v, nil
946 }
947
948 func (o *CDROMOp) transformFindResults(data []byte) (*CDROMFindResult, error) {
949 nakedResponse := &cDROMFindResponseEnvelope{}
950 if err := json.Unmarshal(data, nakedResponse); err != nil {
951 return nil, err
952 }
953
954 results := &CDROMFindResult{}
955 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
956 return nil, err
957 }
958 return results, nil
959 }
960
961 func (o *CDROMOp) transformCreateArgs(param *CDROMCreateRequest) (*cDROMCreateRequestEnvelope, error) {
962 if param == nil {
963 param = &CDROMCreateRequest{}
964 }
965 var arg0 interface{} = param
966 if v, ok := arg0.(argumentDefaulter); ok {
967 arg0 = v.setDefaults()
968 }
969 args := &struct {
970 Arg0 interface{} `mapconv:"CDROM,recursive"`
971 }{
972 Arg0: arg0,
973 }
974
975 v := &cDROMCreateRequestEnvelope{}
976 if err := mapconv.ConvertTo(args, v); err != nil {
977 return nil, err
978 }
979 return v, nil
980 }
981
982 func (o *CDROMOp) transformCreateResults(data []byte) (*cDROMCreateResult, error) {
983 nakedResponse := &cDROMCreateResponseEnvelope{}
984 if err := json.Unmarshal(data, nakedResponse); err != nil {
985 return nil, err
986 }
987
988 results := &cDROMCreateResult{}
989 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
990 return nil, err
991 }
992 return results, nil
993 }
994
995 func (o *CDROMOp) transformReadResults(data []byte) (*cDROMReadResult, error) {
996 nakedResponse := &cDROMReadResponseEnvelope{}
997 if err := json.Unmarshal(data, nakedResponse); err != nil {
998 return nil, err
999 }
1000
1001 results := &cDROMReadResult{}
1002 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1003 return nil, err
1004 }
1005 return results, nil
1006 }
1007
1008 func (o *CDROMOp) transformUpdateArgs(id types.ID, param *CDROMUpdateRequest) (*cDROMUpdateRequestEnvelope, error) {
1009 if id == types.ID(int64(0)) {
1010 id = types.ID(int64(0))
1011 }
1012 var arg0 interface{} = id
1013 if v, ok := arg0.(argumentDefaulter); ok {
1014 arg0 = v.setDefaults()
1015 }
1016 if param == nil {
1017 param = &CDROMUpdateRequest{}
1018 }
1019 var arg1 interface{} = param
1020 if v, ok := arg1.(argumentDefaulter); ok {
1021 arg1 = v.setDefaults()
1022 }
1023 args := &struct {
1024 Arg0 interface{}
1025 Arg1 interface{} `mapconv:"CDROM,recursive"`
1026 }{
1027 Arg0: arg0,
1028 Arg1: arg1,
1029 }
1030
1031 v := &cDROMUpdateRequestEnvelope{}
1032 if err := mapconv.ConvertTo(args, v); err != nil {
1033 return nil, err
1034 }
1035 return v, nil
1036 }
1037
1038 func (o *CDROMOp) transformUpdateResults(data []byte) (*cDROMUpdateResult, error) {
1039 nakedResponse := &cDROMUpdateResponseEnvelope{}
1040 if err := json.Unmarshal(data, nakedResponse); err != nil {
1041 return nil, err
1042 }
1043
1044 results := &cDROMUpdateResult{}
1045 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1046 return nil, err
1047 }
1048 return results, nil
1049 }
1050
1051 func (o *CDROMOp) transformOpenFTPArgs(id types.ID, openOption *OpenFTPRequest) (*cDROMOpenFTPRequestEnvelope, error) {
1052 if id == types.ID(int64(0)) {
1053 id = types.ID(int64(0))
1054 }
1055 var arg0 interface{} = id
1056 if v, ok := arg0.(argumentDefaulter); ok {
1057 arg0 = v.setDefaults()
1058 }
1059 if openOption == nil {
1060 openOption = &OpenFTPRequest{}
1061 }
1062 var arg1 interface{} = openOption
1063 if v, ok := arg1.(argumentDefaulter); ok {
1064 arg1 = v.setDefaults()
1065 }
1066 args := &struct {
1067 Arg0 interface{}
1068 Arg1 interface{} `mapconv:",squash"`
1069 }{
1070 Arg0: arg0,
1071 Arg1: arg1,
1072 }
1073
1074 v := &cDROMOpenFTPRequestEnvelope{}
1075 if err := mapconv.ConvertTo(args, v); err != nil {
1076 return nil, err
1077 }
1078 return v, nil
1079 }
1080
1081 func (o *CDROMOp) transformOpenFTPResults(data []byte) (*cDROMOpenFTPResult, error) {
1082 nakedResponse := &cDROMOpenFTPResponseEnvelope{}
1083 if err := json.Unmarshal(data, nakedResponse); err != nil {
1084 return nil, err
1085 }
1086
1087 results := &cDROMOpenFTPResult{}
1088 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1089 return nil, err
1090 }
1091 return results, nil
1092 }
1093
1094 func (o *CertificateAuthorityOp) transformFindArgs(conditions *FindCondition) (*certificateAuthorityFindRequestEnvelope, error) {
1095 if conditions == nil {
1096 conditions = &FindCondition{}
1097 }
1098 var arg0 interface{} = conditions
1099 if v, ok := arg0.(argumentDefaulter); ok {
1100 arg0 = v.setDefaults()
1101 }
1102 args := &struct {
1103 Arg0 interface{} `mapconv:",squash"`
1104 }{
1105 Arg0: arg0,
1106 }
1107
1108 v := &certificateAuthorityFindRequestEnvelope{}
1109 if err := mapconv.ConvertTo(args, v); err != nil {
1110 return nil, err
1111 }
1112 return v, nil
1113 }
1114
1115 func (o *CertificateAuthorityOp) transformFindResults(data []byte) (*CertificateAuthorityFindResult, error) {
1116 nakedResponse := &certificateAuthorityFindResponseEnvelope{}
1117 if err := json.Unmarshal(data, nakedResponse); err != nil {
1118 return nil, err
1119 }
1120
1121 results := &CertificateAuthorityFindResult{}
1122 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1123 return nil, err
1124 }
1125 return results, nil
1126 }
1127
1128 func (o *CertificateAuthorityOp) transformCreateArgs(param *CertificateAuthorityCreateRequest) (*certificateAuthorityCreateRequestEnvelope, error) {
1129 if param == nil {
1130 param = &CertificateAuthorityCreateRequest{}
1131 }
1132 var arg0 interface{} = param
1133 if v, ok := arg0.(argumentDefaulter); ok {
1134 arg0 = v.setDefaults()
1135 }
1136 args := &struct {
1137 Arg0 interface{} `mapconv:"CommonServiceItem,recursive"`
1138 }{
1139 Arg0: arg0,
1140 }
1141
1142 v := &certificateAuthorityCreateRequestEnvelope{}
1143 if err := mapconv.ConvertTo(args, v); err != nil {
1144 return nil, err
1145 }
1146 return v, nil
1147 }
1148
1149 func (o *CertificateAuthorityOp) transformCreateResults(data []byte) (*certificateAuthorityCreateResult, error) {
1150 nakedResponse := &certificateAuthorityCreateResponseEnvelope{}
1151 if err := json.Unmarshal(data, nakedResponse); err != nil {
1152 return nil, err
1153 }
1154
1155 results := &certificateAuthorityCreateResult{}
1156 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1157 return nil, err
1158 }
1159 return results, nil
1160 }
1161
1162 func (o *CertificateAuthorityOp) transformReadResults(data []byte) (*certificateAuthorityReadResult, error) {
1163 nakedResponse := &certificateAuthorityReadResponseEnvelope{}
1164 if err := json.Unmarshal(data, nakedResponse); err != nil {
1165 return nil, err
1166 }
1167
1168 results := &certificateAuthorityReadResult{}
1169 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1170 return nil, err
1171 }
1172 return results, nil
1173 }
1174
1175 func (o *CertificateAuthorityOp) transformUpdateArgs(id types.ID, param *CertificateAuthorityUpdateRequest) (*certificateAuthorityUpdateRequestEnvelope, error) {
1176 if id == types.ID(int64(0)) {
1177 id = types.ID(int64(0))
1178 }
1179 var arg0 interface{} = id
1180 if v, ok := arg0.(argumentDefaulter); ok {
1181 arg0 = v.setDefaults()
1182 }
1183 if param == nil {
1184 param = &CertificateAuthorityUpdateRequest{}
1185 }
1186 var arg1 interface{} = param
1187 if v, ok := arg1.(argumentDefaulter); ok {
1188 arg1 = v.setDefaults()
1189 }
1190 args := &struct {
1191 Arg0 interface{}
1192 Arg1 interface{} `mapconv:"CommonServiceItem,recursive"`
1193 }{
1194 Arg0: arg0,
1195 Arg1: arg1,
1196 }
1197
1198 v := &certificateAuthorityUpdateRequestEnvelope{}
1199 if err := mapconv.ConvertTo(args, v); err != nil {
1200 return nil, err
1201 }
1202 return v, nil
1203 }
1204
1205 func (o *CertificateAuthorityOp) transformUpdateResults(data []byte) (*certificateAuthorityUpdateResult, error) {
1206 nakedResponse := &certificateAuthorityUpdateResponseEnvelope{}
1207 if err := json.Unmarshal(data, nakedResponse); err != nil {
1208 return nil, err
1209 }
1210
1211 results := &certificateAuthorityUpdateResult{}
1212 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1213 return nil, err
1214 }
1215 return results, nil
1216 }
1217
1218 func (o *CertificateAuthorityOp) transformDetailResults(data []byte) (*certificateAuthorityDetailResult, error) {
1219 nakedResponse := &certificateAuthorityDetailResponseEnvelope{}
1220 if err := json.Unmarshal(data, nakedResponse); err != nil {
1221 return nil, err
1222 }
1223
1224 results := &certificateAuthorityDetailResult{}
1225 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1226 return nil, err
1227 }
1228 return results, nil
1229 }
1230
1231 func (o *CertificateAuthorityOp) transformAddClientArgs(id types.ID, param *CertificateAuthorityAddClientParam) (*certificateAuthorityAddClientRequestEnvelope, error) {
1232 if id == types.ID(int64(0)) {
1233 id = types.ID(int64(0))
1234 }
1235 var arg0 interface{} = id
1236 if v, ok := arg0.(argumentDefaulter); ok {
1237 arg0 = v.setDefaults()
1238 }
1239 if param == nil {
1240 param = &CertificateAuthorityAddClientParam{}
1241 }
1242 var arg1 interface{} = param
1243 if v, ok := arg1.(argumentDefaulter); ok {
1244 arg1 = v.setDefaults()
1245 }
1246 args := &struct {
1247 Arg0 interface{}
1248 Arg1 interface{} `mapconv:"CertificateAuthority.Status,recursive"`
1249 }{
1250 Arg0: arg0,
1251 Arg1: arg1,
1252 }
1253
1254 v := &certificateAuthorityAddClientRequestEnvelope{}
1255 if err := mapconv.ConvertTo(args, v); err != nil {
1256 return nil, err
1257 }
1258 return v, nil
1259 }
1260
1261 func (o *CertificateAuthorityOp) transformAddClientResults(data []byte) (*certificateAuthorityAddClientResult, error) {
1262 nakedResponse := &certificateAuthorityAddClientResponseEnvelope{}
1263 if err := json.Unmarshal(data, nakedResponse); err != nil {
1264 return nil, err
1265 }
1266
1267 results := &certificateAuthorityAddClientResult{}
1268 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1269 return nil, err
1270 }
1271 return results, nil
1272 }
1273
1274 func (o *CertificateAuthorityOp) transformListClientsResults(data []byte) (*CertificateAuthorityListClientsResult, error) {
1275 nakedResponse := &certificateAuthorityListClientsResponseEnvelope{}
1276 if err := json.Unmarshal(data, nakedResponse); err != nil {
1277 return nil, err
1278 }
1279
1280 results := &CertificateAuthorityListClientsResult{}
1281 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1282 return nil, err
1283 }
1284 return results, nil
1285 }
1286
1287 func (o *CertificateAuthorityOp) transformReadClientResults(data []byte) (*certificateAuthorityReadClientResult, error) {
1288 nakedResponse := &certificateAuthorityReadClientResponseEnvelope{}
1289 if err := json.Unmarshal(data, nakedResponse); err != nil {
1290 return nil, err
1291 }
1292
1293 results := &certificateAuthorityReadClientResult{}
1294 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1295 return nil, err
1296 }
1297 return results, nil
1298 }
1299
1300 func (o *CertificateAuthorityOp) transformAddServerArgs(id types.ID, param *CertificateAuthorityAddServerParam) (*certificateAuthorityAddServerRequestEnvelope, error) {
1301 if id == types.ID(int64(0)) {
1302 id = types.ID(int64(0))
1303 }
1304 var arg0 interface{} = id
1305 if v, ok := arg0.(argumentDefaulter); ok {
1306 arg0 = v.setDefaults()
1307 }
1308 if param == nil {
1309 param = &CertificateAuthorityAddServerParam{}
1310 }
1311 var arg1 interface{} = param
1312 if v, ok := arg1.(argumentDefaulter); ok {
1313 arg1 = v.setDefaults()
1314 }
1315 args := &struct {
1316 Arg0 interface{}
1317 Arg1 interface{} `mapconv:"CertificateAuthority.Status,recursive"`
1318 }{
1319 Arg0: arg0,
1320 Arg1: arg1,
1321 }
1322
1323 v := &certificateAuthorityAddServerRequestEnvelope{}
1324 if err := mapconv.ConvertTo(args, v); err != nil {
1325 return nil, err
1326 }
1327 return v, nil
1328 }
1329
1330 func (o *CertificateAuthorityOp) transformAddServerResults(data []byte) (*certificateAuthorityAddServerResult, error) {
1331 nakedResponse := &certificateAuthorityAddServerResponseEnvelope{}
1332 if err := json.Unmarshal(data, nakedResponse); err != nil {
1333 return nil, err
1334 }
1335
1336 results := &certificateAuthorityAddServerResult{}
1337 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1338 return nil, err
1339 }
1340 return results, nil
1341 }
1342
1343 func (o *CertificateAuthorityOp) transformListServersResults(data []byte) (*CertificateAuthorityListServersResult, error) {
1344 nakedResponse := &certificateAuthorityListServersResponseEnvelope{}
1345 if err := json.Unmarshal(data, nakedResponse); err != nil {
1346 return nil, err
1347 }
1348
1349 results := &CertificateAuthorityListServersResult{}
1350 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1351 return nil, err
1352 }
1353 return results, nil
1354 }
1355
1356 func (o *CertificateAuthorityOp) transformReadServerResults(data []byte) (*certificateAuthorityReadServerResult, error) {
1357 nakedResponse := &certificateAuthorityReadServerResponseEnvelope{}
1358 if err := json.Unmarshal(data, nakedResponse); err != nil {
1359 return nil, err
1360 }
1361
1362 results := &certificateAuthorityReadServerResult{}
1363 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1364 return nil, err
1365 }
1366 return results, nil
1367 }
1368
1369 func (o *ContainerRegistryOp) transformFindArgs(conditions *FindCondition) (*containerRegistryFindRequestEnvelope, error) {
1370 if conditions == nil {
1371 conditions = &FindCondition{}
1372 }
1373 var arg0 interface{} = conditions
1374 if v, ok := arg0.(argumentDefaulter); ok {
1375 arg0 = v.setDefaults()
1376 }
1377 args := &struct {
1378 Arg0 interface{} `mapconv:",squash"`
1379 }{
1380 Arg0: arg0,
1381 }
1382
1383 v := &containerRegistryFindRequestEnvelope{}
1384 if err := mapconv.ConvertTo(args, v); err != nil {
1385 return nil, err
1386 }
1387 return v, nil
1388 }
1389
1390 func (o *ContainerRegistryOp) transformFindResults(data []byte) (*ContainerRegistryFindResult, error) {
1391 nakedResponse := &containerRegistryFindResponseEnvelope{}
1392 if err := json.Unmarshal(data, nakedResponse); err != nil {
1393 return nil, err
1394 }
1395
1396 results := &ContainerRegistryFindResult{}
1397 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1398 return nil, err
1399 }
1400 return results, nil
1401 }
1402
1403 func (o *ContainerRegistryOp) transformCreateArgs(param *ContainerRegistryCreateRequest) (*containerRegistryCreateRequestEnvelope, error) {
1404 if param == nil {
1405 param = &ContainerRegistryCreateRequest{}
1406 }
1407 var arg0 interface{} = param
1408 if v, ok := arg0.(argumentDefaulter); ok {
1409 arg0 = v.setDefaults()
1410 }
1411 args := &struct {
1412 Arg0 interface{} `mapconv:"CommonServiceItem,recursive"`
1413 }{
1414 Arg0: arg0,
1415 }
1416
1417 v := &containerRegistryCreateRequestEnvelope{}
1418 if err := mapconv.ConvertTo(args, v); err != nil {
1419 return nil, err
1420 }
1421 return v, nil
1422 }
1423
1424 func (o *ContainerRegistryOp) transformCreateResults(data []byte) (*containerRegistryCreateResult, error) {
1425 nakedResponse := &containerRegistryCreateResponseEnvelope{}
1426 if err := json.Unmarshal(data, nakedResponse); err != nil {
1427 return nil, err
1428 }
1429
1430 results := &containerRegistryCreateResult{}
1431 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1432 return nil, err
1433 }
1434 return results, nil
1435 }
1436
1437 func (o *ContainerRegistryOp) transformReadResults(data []byte) (*containerRegistryReadResult, error) {
1438 nakedResponse := &containerRegistryReadResponseEnvelope{}
1439 if err := json.Unmarshal(data, nakedResponse); err != nil {
1440 return nil, err
1441 }
1442
1443 results := &containerRegistryReadResult{}
1444 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1445 return nil, err
1446 }
1447 return results, nil
1448 }
1449
1450 func (o *ContainerRegistryOp) transformUpdateArgs(id types.ID, param *ContainerRegistryUpdateRequest) (*containerRegistryUpdateRequestEnvelope, error) {
1451 if id == types.ID(int64(0)) {
1452 id = types.ID(int64(0))
1453 }
1454 var arg0 interface{} = id
1455 if v, ok := arg0.(argumentDefaulter); ok {
1456 arg0 = v.setDefaults()
1457 }
1458 if param == nil {
1459 param = &ContainerRegistryUpdateRequest{}
1460 }
1461 var arg1 interface{} = param
1462 if v, ok := arg1.(argumentDefaulter); ok {
1463 arg1 = v.setDefaults()
1464 }
1465 args := &struct {
1466 Arg0 interface{}
1467 Arg1 interface{} `mapconv:"CommonServiceItem,recursive"`
1468 }{
1469 Arg0: arg0,
1470 Arg1: arg1,
1471 }
1472
1473 v := &containerRegistryUpdateRequestEnvelope{}
1474 if err := mapconv.ConvertTo(args, v); err != nil {
1475 return nil, err
1476 }
1477 return v, nil
1478 }
1479
1480 func (o *ContainerRegistryOp) transformUpdateResults(data []byte) (*containerRegistryUpdateResult, error) {
1481 nakedResponse := &containerRegistryUpdateResponseEnvelope{}
1482 if err := json.Unmarshal(data, nakedResponse); err != nil {
1483 return nil, err
1484 }
1485
1486 results := &containerRegistryUpdateResult{}
1487 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1488 return nil, err
1489 }
1490 return results, nil
1491 }
1492
1493 func (o *ContainerRegistryOp) transformUpdateSettingsArgs(id types.ID, param *ContainerRegistryUpdateSettingsRequest) (*containerRegistryUpdateSettingsRequestEnvelope, error) {
1494 if id == types.ID(int64(0)) {
1495 id = types.ID(int64(0))
1496 }
1497 var arg0 interface{} = id
1498 if v, ok := arg0.(argumentDefaulter); ok {
1499 arg0 = v.setDefaults()
1500 }
1501 if param == nil {
1502 param = &ContainerRegistryUpdateSettingsRequest{}
1503 }
1504 var arg1 interface{} = param
1505 if v, ok := arg1.(argumentDefaulter); ok {
1506 arg1 = v.setDefaults()
1507 }
1508 args := &struct {
1509 Arg0 interface{}
1510 Arg1 interface{} `mapconv:"CommonServiceItem,recursive"`
1511 }{
1512 Arg0: arg0,
1513 Arg1: arg1,
1514 }
1515
1516 v := &containerRegistryUpdateSettingsRequestEnvelope{}
1517 if err := mapconv.ConvertTo(args, v); err != nil {
1518 return nil, err
1519 }
1520 return v, nil
1521 }
1522
1523 func (o *ContainerRegistryOp) transformUpdateSettingsResults(data []byte) (*containerRegistryUpdateSettingsResult, error) {
1524 nakedResponse := &containerRegistryUpdateSettingsResponseEnvelope{}
1525 if err := json.Unmarshal(data, nakedResponse); err != nil {
1526 return nil, err
1527 }
1528
1529 results := &containerRegistryUpdateSettingsResult{}
1530 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1531 return nil, err
1532 }
1533 return results, nil
1534 }
1535
1536 func (o *ContainerRegistryOp) transformListUsersResults(data []byte) (*containerRegistryListUsersResult, error) {
1537 nakedResponse := &containerRegistryListUsersResponseEnvelope{}
1538 if err := json.Unmarshal(data, nakedResponse); err != nil {
1539 return nil, err
1540 }
1541
1542 results := &containerRegistryListUsersResult{}
1543 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1544 return nil, err
1545 }
1546 return results, nil
1547 }
1548
1549 func (o *ContainerRegistryOp) transformAddUserArgs(id types.ID, param *ContainerRegistryUserCreateRequest) (*containerRegistryAddUserRequestEnvelope, error) {
1550 if id == types.ID(int64(0)) {
1551 id = types.ID(int64(0))
1552 }
1553 var arg0 interface{} = id
1554 if v, ok := arg0.(argumentDefaulter); ok {
1555 arg0 = v.setDefaults()
1556 }
1557 if param == nil {
1558 param = &ContainerRegistryUserCreateRequest{}
1559 }
1560 var arg1 interface{} = param
1561 if v, ok := arg1.(argumentDefaulter); ok {
1562 arg1 = v.setDefaults()
1563 }
1564 args := &struct {
1565 Arg0 interface{}
1566 Arg1 interface{} `mapconv:"ContainerRegistry,recursive"`
1567 }{
1568 Arg0: arg0,
1569 Arg1: arg1,
1570 }
1571
1572 v := &containerRegistryAddUserRequestEnvelope{}
1573 if err := mapconv.ConvertTo(args, v); err != nil {
1574 return nil, err
1575 }
1576 return v, nil
1577 }
1578
1579 func (o *ContainerRegistryOp) transformUpdateUserArgs(id types.ID, username string, param *ContainerRegistryUserUpdateRequest) (*containerRegistryUpdateUserRequestEnvelope, error) {
1580 if id == types.ID(int64(0)) {
1581 id = types.ID(int64(0))
1582 }
1583 var arg0 interface{} = id
1584 if v, ok := arg0.(argumentDefaulter); ok {
1585 arg0 = v.setDefaults()
1586 }
1587 if username == "" {
1588 username = ""
1589 }
1590 var arg1 interface{} = username
1591 if v, ok := arg1.(argumentDefaulter); ok {
1592 arg1 = v.setDefaults()
1593 }
1594 if param == nil {
1595 param = &ContainerRegistryUserUpdateRequest{}
1596 }
1597 var arg2 interface{} = param
1598 if v, ok := arg2.(argumentDefaulter); ok {
1599 arg2 = v.setDefaults()
1600 }
1601 args := &struct {
1602 Arg0 interface{}
1603 Arg1 interface{}
1604 Arg2 interface{} `mapconv:"ContainerRegistry,recursive"`
1605 }{
1606 Arg0: arg0,
1607 Arg1: arg1,
1608 Arg2: arg2,
1609 }
1610
1611 v := &containerRegistryUpdateUserRequestEnvelope{}
1612 if err := mapconv.ConvertTo(args, v); err != nil {
1613 return nil, err
1614 }
1615 return v, nil
1616 }
1617
1618 func (o *CouponOp) transformFindResults(data []byte) (*CouponFindResult, error) {
1619 nakedResponse := &couponFindResponseEnvelope{}
1620 if err := json.Unmarshal(data, nakedResponse); err != nil {
1621 return nil, err
1622 }
1623
1624 results := &CouponFindResult{}
1625 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1626 return nil, err
1627 }
1628 return results, nil
1629 }
1630
1631 func (o *DatabaseOp) transformFindArgs(conditions *FindCondition) (*databaseFindRequestEnvelope, error) {
1632 if conditions == nil {
1633 conditions = &FindCondition{}
1634 }
1635 var arg0 interface{} = conditions
1636 if v, ok := arg0.(argumentDefaulter); ok {
1637 arg0 = v.setDefaults()
1638 }
1639 args := &struct {
1640 Arg0 interface{} `mapconv:",squash"`
1641 }{
1642 Arg0: arg0,
1643 }
1644
1645 v := &databaseFindRequestEnvelope{}
1646 if err := mapconv.ConvertTo(args, v); err != nil {
1647 return nil, err
1648 }
1649 return v, nil
1650 }
1651
1652 func (o *DatabaseOp) transformFindResults(data []byte) (*DatabaseFindResult, error) {
1653 nakedResponse := &databaseFindResponseEnvelope{}
1654 if err := json.Unmarshal(data, nakedResponse); err != nil {
1655 return nil, err
1656 }
1657
1658 results := &DatabaseFindResult{}
1659 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1660 return nil, err
1661 }
1662 return results, nil
1663 }
1664
1665 func (o *DatabaseOp) transformCreateArgs(param *DatabaseCreateRequest) (*databaseCreateRequestEnvelope, error) {
1666 if param == nil {
1667 param = &DatabaseCreateRequest{}
1668 }
1669 var arg0 interface{} = param
1670 if v, ok := arg0.(argumentDefaulter); ok {
1671 arg0 = v.setDefaults()
1672 }
1673 args := &struct {
1674 Arg0 interface{} `mapconv:"Appliance,recursive"`
1675 }{
1676 Arg0: arg0,
1677 }
1678
1679 v := &databaseCreateRequestEnvelope{}
1680 if err := mapconv.ConvertTo(args, v); err != nil {
1681 return nil, err
1682 }
1683 return v, nil
1684 }
1685
1686 func (o *DatabaseOp) transformCreateResults(data []byte) (*databaseCreateResult, error) {
1687 nakedResponse := &databaseCreateResponseEnvelope{}
1688 if err := json.Unmarshal(data, nakedResponse); err != nil {
1689 return nil, err
1690 }
1691
1692 results := &databaseCreateResult{}
1693 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1694 return nil, err
1695 }
1696 return results, nil
1697 }
1698
1699 func (o *DatabaseOp) transformReadResults(data []byte) (*databaseReadResult, error) {
1700 nakedResponse := &databaseReadResponseEnvelope{}
1701 if err := json.Unmarshal(data, nakedResponse); err != nil {
1702 return nil, err
1703 }
1704
1705 results := &databaseReadResult{}
1706 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1707 return nil, err
1708 }
1709 return results, nil
1710 }
1711
1712 func (o *DatabaseOp) transformUpdateArgs(id types.ID, param *DatabaseUpdateRequest) (*databaseUpdateRequestEnvelope, error) {
1713 if id == types.ID(int64(0)) {
1714 id = types.ID(int64(0))
1715 }
1716 var arg0 interface{} = id
1717 if v, ok := arg0.(argumentDefaulter); ok {
1718 arg0 = v.setDefaults()
1719 }
1720 if param == nil {
1721 param = &DatabaseUpdateRequest{}
1722 }
1723 var arg1 interface{} = param
1724 if v, ok := arg1.(argumentDefaulter); ok {
1725 arg1 = v.setDefaults()
1726 }
1727 args := &struct {
1728 Arg0 interface{}
1729 Arg1 interface{} `mapconv:"Appliance,recursive"`
1730 }{
1731 Arg0: arg0,
1732 Arg1: arg1,
1733 }
1734
1735 v := &databaseUpdateRequestEnvelope{}
1736 if err := mapconv.ConvertTo(args, v); err != nil {
1737 return nil, err
1738 }
1739 return v, nil
1740 }
1741
1742 func (o *DatabaseOp) transformUpdateResults(data []byte) (*databaseUpdateResult, error) {
1743 nakedResponse := &databaseUpdateResponseEnvelope{}
1744 if err := json.Unmarshal(data, nakedResponse); err != nil {
1745 return nil, err
1746 }
1747
1748 results := &databaseUpdateResult{}
1749 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1750 return nil, err
1751 }
1752 return results, nil
1753 }
1754
1755 func (o *DatabaseOp) transformUpdateSettingsArgs(id types.ID, param *DatabaseUpdateSettingsRequest) (*databaseUpdateSettingsRequestEnvelope, error) {
1756 if id == types.ID(int64(0)) {
1757 id = types.ID(int64(0))
1758 }
1759 var arg0 interface{} = id
1760 if v, ok := arg0.(argumentDefaulter); ok {
1761 arg0 = v.setDefaults()
1762 }
1763 if param == nil {
1764 param = &DatabaseUpdateSettingsRequest{}
1765 }
1766 var arg1 interface{} = param
1767 if v, ok := arg1.(argumentDefaulter); ok {
1768 arg1 = v.setDefaults()
1769 }
1770 args := &struct {
1771 Arg0 interface{}
1772 Arg1 interface{} `mapconv:"Appliance,recursive"`
1773 }{
1774 Arg0: arg0,
1775 Arg1: arg1,
1776 }
1777
1778 v := &databaseUpdateSettingsRequestEnvelope{}
1779 if err := mapconv.ConvertTo(args, v); err != nil {
1780 return nil, err
1781 }
1782 return v, nil
1783 }
1784
1785 func (o *DatabaseOp) transformUpdateSettingsResults(data []byte) (*databaseUpdateSettingsResult, error) {
1786 nakedResponse := &databaseUpdateSettingsResponseEnvelope{}
1787 if err := json.Unmarshal(data, nakedResponse); err != nil {
1788 return nil, err
1789 }
1790
1791 results := &databaseUpdateSettingsResult{}
1792 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1793 return nil, err
1794 }
1795 return results, nil
1796 }
1797
1798 func (o *DatabaseOp) transformShutdownArgs(id types.ID, shutdownOption *ShutdownOption) (*databaseShutdownRequestEnvelope, error) {
1799 if id == types.ID(int64(0)) {
1800 id = types.ID(int64(0))
1801 }
1802 var arg0 interface{} = id
1803 if v, ok := arg0.(argumentDefaulter); ok {
1804 arg0 = v.setDefaults()
1805 }
1806 if shutdownOption == nil {
1807 shutdownOption = &ShutdownOption{}
1808 }
1809 var arg1 interface{} = shutdownOption
1810 if v, ok := arg1.(argumentDefaulter); ok {
1811 arg1 = v.setDefaults()
1812 }
1813 args := &struct {
1814 Arg0 interface{}
1815 Arg1 interface{} `mapconv:",squash"`
1816 }{
1817 Arg0: arg0,
1818 Arg1: arg1,
1819 }
1820
1821 v := &databaseShutdownRequestEnvelope{}
1822 if err := mapconv.ConvertTo(args, v); err != nil {
1823 return nil, err
1824 }
1825 return v, nil
1826 }
1827
1828 func (o *DatabaseOp) transformMonitorCPUArgs(id types.ID, condition *MonitorCondition) (*databaseMonitorCPURequestEnvelope, error) {
1829 if id == types.ID(int64(0)) {
1830 id = types.ID(int64(0))
1831 }
1832 var arg0 interface{} = id
1833 if v, ok := arg0.(argumentDefaulter); ok {
1834 arg0 = v.setDefaults()
1835 }
1836 if condition == nil {
1837 condition = &MonitorCondition{}
1838 }
1839 var arg1 interface{} = condition
1840 if v, ok := arg1.(argumentDefaulter); ok {
1841 arg1 = v.setDefaults()
1842 }
1843 args := &struct {
1844 Arg0 interface{}
1845 Arg1 interface{} `mapconv:",squash"`
1846 }{
1847 Arg0: arg0,
1848 Arg1: arg1,
1849 }
1850
1851 v := &databaseMonitorCPURequestEnvelope{}
1852 if err := mapconv.ConvertTo(args, v); err != nil {
1853 return nil, err
1854 }
1855 return v, nil
1856 }
1857
1858 func (o *DatabaseOp) transformMonitorCPUResults(data []byte) (*databaseMonitorCPUResult, error) {
1859 nakedResponse := &databaseMonitorCPUResponseEnvelope{}
1860 if err := json.Unmarshal(data, nakedResponse); err != nil {
1861 return nil, err
1862 }
1863
1864 results := &databaseMonitorCPUResult{}
1865 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1866 return nil, err
1867 }
1868 return results, nil
1869 }
1870
1871 func (o *DatabaseOp) transformMonitorDiskArgs(id types.ID, condition *MonitorCondition) (*databaseMonitorDiskRequestEnvelope, error) {
1872 if id == types.ID(int64(0)) {
1873 id = types.ID(int64(0))
1874 }
1875 var arg0 interface{} = id
1876 if v, ok := arg0.(argumentDefaulter); ok {
1877 arg0 = v.setDefaults()
1878 }
1879 if condition == nil {
1880 condition = &MonitorCondition{}
1881 }
1882 var arg1 interface{} = condition
1883 if v, ok := arg1.(argumentDefaulter); ok {
1884 arg1 = v.setDefaults()
1885 }
1886 args := &struct {
1887 Arg0 interface{}
1888 Arg1 interface{} `mapconv:",squash"`
1889 }{
1890 Arg0: arg0,
1891 Arg1: arg1,
1892 }
1893
1894 v := &databaseMonitorDiskRequestEnvelope{}
1895 if err := mapconv.ConvertTo(args, v); err != nil {
1896 return nil, err
1897 }
1898 return v, nil
1899 }
1900
1901 func (o *DatabaseOp) transformMonitorDiskResults(data []byte) (*databaseMonitorDiskResult, error) {
1902 nakedResponse := &databaseMonitorDiskResponseEnvelope{}
1903 if err := json.Unmarshal(data, nakedResponse); err != nil {
1904 return nil, err
1905 }
1906
1907 results := &databaseMonitorDiskResult{}
1908 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1909 return nil, err
1910 }
1911 return results, nil
1912 }
1913
1914 func (o *DatabaseOp) transformMonitorInterfaceArgs(id types.ID, condition *MonitorCondition) (*databaseMonitorInterfaceRequestEnvelope, error) {
1915 if id == types.ID(int64(0)) {
1916 id = types.ID(int64(0))
1917 }
1918 var arg0 interface{} = id
1919 if v, ok := arg0.(argumentDefaulter); ok {
1920 arg0 = v.setDefaults()
1921 }
1922 if condition == nil {
1923 condition = &MonitorCondition{}
1924 }
1925 var arg1 interface{} = condition
1926 if v, ok := arg1.(argumentDefaulter); ok {
1927 arg1 = v.setDefaults()
1928 }
1929 args := &struct {
1930 Arg0 interface{}
1931 Arg1 interface{} `mapconv:",squash"`
1932 }{
1933 Arg0: arg0,
1934 Arg1: arg1,
1935 }
1936
1937 v := &databaseMonitorInterfaceRequestEnvelope{}
1938 if err := mapconv.ConvertTo(args, v); err != nil {
1939 return nil, err
1940 }
1941 return v, nil
1942 }
1943
1944 func (o *DatabaseOp) transformMonitorInterfaceResults(data []byte) (*databaseMonitorInterfaceResult, error) {
1945 nakedResponse := &databaseMonitorInterfaceResponseEnvelope{}
1946 if err := json.Unmarshal(data, nakedResponse); err != nil {
1947 return nil, err
1948 }
1949
1950 results := &databaseMonitorInterfaceResult{}
1951 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1952 return nil, err
1953 }
1954 return results, nil
1955 }
1956
1957 func (o *DatabaseOp) transformMonitorDatabaseArgs(id types.ID, condition *MonitorCondition) (*databaseMonitorDatabaseRequestEnvelope, error) {
1958 if id == types.ID(int64(0)) {
1959 id = types.ID(int64(0))
1960 }
1961 var arg0 interface{} = id
1962 if v, ok := arg0.(argumentDefaulter); ok {
1963 arg0 = v.setDefaults()
1964 }
1965 if condition == nil {
1966 condition = &MonitorCondition{}
1967 }
1968 var arg1 interface{} = condition
1969 if v, ok := arg1.(argumentDefaulter); ok {
1970 arg1 = v.setDefaults()
1971 }
1972 args := &struct {
1973 Arg0 interface{}
1974 Arg1 interface{} `mapconv:",squash"`
1975 }{
1976 Arg0: arg0,
1977 Arg1: arg1,
1978 }
1979
1980 v := &databaseMonitorDatabaseRequestEnvelope{}
1981 if err := mapconv.ConvertTo(args, v); err != nil {
1982 return nil, err
1983 }
1984 return v, nil
1985 }
1986
1987 func (o *DatabaseOp) transformMonitorDatabaseResults(data []byte) (*databaseMonitorDatabaseResult, error) {
1988 nakedResponse := &databaseMonitorDatabaseResponseEnvelope{}
1989 if err := json.Unmarshal(data, nakedResponse); err != nil {
1990 return nil, err
1991 }
1992
1993 results := &databaseMonitorDatabaseResult{}
1994 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
1995 return nil, err
1996 }
1997 return results, nil
1998 }
1999
2000 func (o *DatabaseOp) transformStatusResults(data []byte) (*databaseStatusResult, error) {
2001 nakedResponse := &databaseStatusResponseEnvelope{}
2002 if err := json.Unmarshal(data, nakedResponse); err != nil {
2003 return nil, err
2004 }
2005
2006 results := &databaseStatusResult{}
2007 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
2008 return nil, err
2009 }
2010 return results, nil
2011 }
2012
2013 func (o *DatabaseOp) transformGetParameterResults(data []byte) (*databaseGetParameterResult, error) {
2014 nakedResponse := &databaseGetParameterResponseEnvelope{}
2015 if err := json.Unmarshal(data, nakedResponse); err != nil {
2016 return nil, err
2017 }
2018
2019 results := &databaseGetParameterResult{}
2020 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
2021 return nil, err
2022 }
2023 return results, nil
2024 }
2025
2026 func (o *DatabaseOp) transformSetParameterArgs(id types.ID, param map[string]interface{}) (*databaseSetParameterRequestEnvelope, error) {
2027 if id == types.ID(int64(0)) {
2028 id = types.ID(int64(0))
2029 }
2030 var arg0 interface{} = id
2031 if v, ok := arg0.(argumentDefaulter); ok {
2032 arg0 = v.setDefaults()
2033 }
2034 if param == nil {
2035 param = map[string]interface{}{}
2036 }
2037 var arg1 interface{} = param
2038 if v, ok := arg1.(argumentDefaulter); ok {
2039 arg1 = v.setDefaults()
2040 }
2041 args := &struct {
2042 Arg0 interface{}
2043 Arg1 interface{} `mapconv:"Parameter.Attr"`
2044 }{
2045 Arg0: arg0,
2046 Arg1: arg1,
2047 }
2048
2049 v := &databaseSetParameterRequestEnvelope{}
2050 if err := mapconv.ConvertTo(args, v); err != nil {
2051 return nil, err
2052 }
2053 return v, nil
2054 }
2055
2056 func (o *DiskOp) transformFindArgs(conditions *FindCondition) (*diskFindRequestEnvelope, error) {
2057 if conditions == nil {
2058 conditions = &FindCondition{}
2059 }
2060 var arg0 interface{} = conditions
2061 if v, ok := arg0.(argumentDefaulter); ok {
2062 arg0 = v.setDefaults()
2063 }
2064 args := &struct {
2065 Arg0 interface{} `mapconv:",squash"`
2066 }{
2067 Arg0: arg0,
2068 }
2069
2070 v := &diskFindRequestEnvelope{}
2071 if err := mapconv.ConvertTo(args, v); err != nil {
2072 return nil, err
2073 }
2074 return v, nil
2075 }
2076
2077 func (o *DiskOp) transformFindResults(data []byte) (*DiskFindResult, error) {
2078 nakedResponse := &diskFindResponseEnvelope{}
2079 if err := json.Unmarshal(data, nakedResponse); err != nil {
2080 return nil, err
2081 }
2082
2083 results := &DiskFindResult{}
2084 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
2085 return nil, err
2086 }
2087 return results, nil
2088 }
2089
2090 func (o *DiskOp) transformCreateArgs(createParam *DiskCreateRequest, distantFrom []types.ID, kmeKeyID types.ID) (*diskCreateRequestEnvelope, error) {
2091 if createParam == nil {
2092 createParam = &DiskCreateRequest{}
2093 }
2094 var arg0 interface{} = createParam
2095 if v, ok := arg0.(argumentDefaulter); ok {
2096 arg0 = v.setDefaults()
2097 }
2098 if distantFrom == nil {
2099 distantFrom = []types.ID{}
2100 }
2101 var arg1 interface{} = distantFrom
2102 if v, ok := arg1.(argumentDefaulter); ok {
2103 arg1 = v.setDefaults()
2104 }
2105 if kmeKeyID == types.ID(int64(0)) {
2106 kmeKeyID = types.ID(int64(0))
2107 }
2108 var arg2 interface{} = kmeKeyID
2109 if v, ok := arg2.(argumentDefaulter); ok {
2110 arg2 = v.setDefaults()
2111 }
2112 args := &struct {
2113 Arg0 interface{} `mapconv:"Disk,recursive"`
2114 Arg1 interface{} `mapconv:"DistantFrom"`
2115 Arg2 interface{} `mapconv:"KMSKey.ID"`
2116 }{
2117 Arg0: arg0,
2118 Arg1: arg1,
2119 Arg2: arg2,
2120 }
2121
2122 v := &diskCreateRequestEnvelope{}
2123 if err := mapconv.ConvertTo(args, v); err != nil {
2124 return nil, err
2125 }
2126 return v, nil
2127 }
2128
2129 func (o *DiskOp) transformCreateResults(data []byte) (*diskCreateResult, error) {
2130 nakedResponse := &diskCreateResponseEnvelope{}
2131 if err := json.Unmarshal(data, nakedResponse); err != nil {
2132 return nil, err
2133 }
2134
2135 results := &diskCreateResult{}
2136 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
2137 return nil, err
2138 }
2139 return results, nil
2140 }
2141
2142 func (o *DiskOp) transformConfigArgs(id types.ID, edit *DiskEditRequest) (*diskConfigRequestEnvelope, error) {
2143 if id == types.ID(int64(0)) {
2144 id = types.ID(int64(0))
2145 }
2146 var arg0 interface{} = id
2147 if v, ok := arg0.(argumentDefaulter); ok {
2148 arg0 = v.setDefaults()
2149 }
2150 if edit == nil {
2151 edit = &DiskEditRequest{}
2152 }
2153 var arg1 interface{} = edit
2154 if v, ok := arg1.(argumentDefaulter); ok {
2155 arg1 = v.setDefaults()
2156 }
2157 args := &struct {
2158 Arg0 interface{}
2159 Arg1 interface{} `mapconv:",squash"`
2160 }{
2161 Arg0: arg0,
2162 Arg1: arg1,
2163 }
2164
2165 v := &diskConfigRequestEnvelope{}
2166 if err := mapconv.ConvertTo(args, v); err != nil {
2167 return nil, err
2168 }
2169 return v, nil
2170 }
2171
2172 func (o *DiskOp) transformCreateWithConfigArgs(createParam *DiskCreateRequest, editParam *DiskEditRequest, bootAtAvailable bool, distantFrom []types.ID, kmeKeyID types.ID) (*diskCreateWithConfigRequestEnvelope, error) {
2173 if createParam == nil {
2174 createParam = &DiskCreateRequest{}
2175 }
2176 var arg0 interface{} = createParam
2177 if v, ok := arg0.(argumentDefaulter); ok {
2178 arg0 = v.setDefaults()
2179 }
2180 if editParam == nil {
2181 editParam = &DiskEditRequest{}
2182 }
2183 var arg1 interface{} = editParam
2184 if v, ok := arg1.(argumentDefaulter); ok {
2185 arg1 = v.setDefaults()
2186 }
2187 if bootAtAvailable == false {
2188 bootAtAvailable = false
2189 }
2190 var arg2 interface{} = bootAtAvailable
2191 if v, ok := arg2.(argumentDefaulter); ok {
2192 arg2 = v.setDefaults()
2193 }
2194 if distantFrom == nil {
2195 distantFrom = []types.ID{}
2196 }
2197 var arg3 interface{} = distantFrom
2198 if v, ok := arg3.(argumentDefaulter); ok {
2199 arg3 = v.setDefaults()
2200 }
2201 if kmeKeyID == types.ID(int64(0)) {
2202 kmeKeyID = types.ID(int64(0))
2203 }
2204 var arg4 interface{} = kmeKeyID
2205 if v, ok := arg4.(argumentDefaulter); ok {
2206 arg4 = v.setDefaults()
2207 }
2208 args := &struct {
2209 Arg0 interface{} `mapconv:"Disk,recursive"`
2210 Arg1 interface{} `mapconv:"Config,recursive"`
2211 Arg2 interface{} `mapconv:"BootAtAvailable"`
2212 Arg3 interface{} `mapconv:"DistantFrom"`
2213 Arg4 interface{} `mapconv:"KMSKey.ID"`
2214 }{
2215 Arg0: arg0,
2216 Arg1: arg1,
2217 Arg2: arg2,
2218 Arg3: arg3,
2219 Arg4: arg4,
2220 }
2221
2222 v := &diskCreateWithConfigRequestEnvelope{}
2223 if err := mapconv.ConvertTo(args, v); err != nil {
2224 return nil, err
2225 }
2226 return v, nil
2227 }
2228
2229 func (o *DiskOp) transformCreateWithConfigResults(data []byte) (*diskCreateWithConfigResult, error) {
2230 nakedResponse := &diskCreateWithConfigResponseEnvelope{}
2231 if err := json.Unmarshal(data, nakedResponse); err != nil {
2232 return nil, err
2233 }
2234
2235 results := &diskCreateWithConfigResult{}
2236 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
2237 return nil, err
2238 }
2239 return results, nil
2240 }
2241
2242 func (o *DiskOp) transformResizePartitionArgs(id types.ID, param *DiskResizePartitionRequest) (*diskResizePartitionRequestEnvelope, error) {
2243 if id == types.ID(int64(0)) {
2244 id = types.ID(int64(0))
2245 }
2246 var arg0 interface{} = id
2247 if v, ok := arg0.(argumentDefaulter); ok {
2248 arg0 = v.setDefaults()
2249 }
2250 if param == nil {
2251 param = &DiskResizePartitionRequest{}
2252 }
2253 var arg1 interface{} = param
2254 if v, ok := arg1.(argumentDefaulter); ok {
2255 arg1 = v.setDefaults()
2256 }
2257 args := &struct {
2258 Arg0 interface{}
2259 Arg1 interface{} `mapconv:",squash"`
2260 }{
2261 Arg0: arg0,
2262 Arg1: arg1,
2263 }
2264
2265 v := &diskResizePartitionRequestEnvelope{}
2266 if err := mapconv.ConvertTo(args, v); err != nil {
2267 return nil, err
2268 }
2269 return v, nil
2270 }
2271
2272 func (o *DiskOp) transformReadResults(data []byte) (*diskReadResult, error) {
2273 nakedResponse := &diskReadResponseEnvelope{}
2274 if err := json.Unmarshal(data, nakedResponse); err != nil {
2275 return nil, err
2276 }
2277
2278 results := &diskReadResult{}
2279 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
2280 return nil, err
2281 }
2282 return results, nil
2283 }
2284
2285 func (o *DiskOp) transformUpdateArgs(id types.ID, param *DiskUpdateRequest) (*diskUpdateRequestEnvelope, error) {
2286 if id == types.ID(int64(0)) {
2287 id = types.ID(int64(0))
2288 }
2289 var arg0 interface{} = id
2290 if v, ok := arg0.(argumentDefaulter); ok {
2291 arg0 = v.setDefaults()
2292 }
2293 if param == nil {
2294 param = &DiskUpdateRequest{}
2295 }
2296 var arg1 interface{} = param
2297 if v, ok := arg1.(argumentDefaulter); ok {
2298 arg1 = v.setDefaults()
2299 }
2300 args := &struct {
2301 Arg0 interface{}
2302 Arg1 interface{} `mapconv:"Disk,recursive"`
2303 }{
2304 Arg0: arg0,
2305 Arg1: arg1,
2306 }
2307
2308 v := &diskUpdateRequestEnvelope{}
2309 if err := mapconv.ConvertTo(args, v); err != nil {
2310 return nil, err
2311 }
2312 return v, nil
2313 }
2314
2315 func (o *DiskOp) transformUpdateResults(data []byte) (*diskUpdateResult, error) {
2316 nakedResponse := &diskUpdateResponseEnvelope{}
2317 if err := json.Unmarshal(data, nakedResponse); err != nil {
2318 return nil, err
2319 }
2320
2321 results := &diskUpdateResult{}
2322 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
2323 return nil, err
2324 }
2325 return results, nil
2326 }
2327
2328 func (o *DiskOp) transformMonitorArgs(id types.ID, condition *MonitorCondition) (*diskMonitorRequestEnvelope, error) {
2329 if id == types.ID(int64(0)) {
2330 id = types.ID(int64(0))
2331 }
2332 var arg0 interface{} = id
2333 if v, ok := arg0.(argumentDefaulter); ok {
2334 arg0 = v.setDefaults()
2335 }
2336 if condition == nil {
2337 condition = &MonitorCondition{}
2338 }
2339 var arg1 interface{} = condition
2340 if v, ok := arg1.(argumentDefaulter); ok {
2341 arg1 = v.setDefaults()
2342 }
2343 args := &struct {
2344 Arg0 interface{}
2345 Arg1 interface{} `mapconv:",squash"`
2346 }{
2347 Arg0: arg0,
2348 Arg1: arg1,
2349 }
2350
2351 v := &diskMonitorRequestEnvelope{}
2352 if err := mapconv.ConvertTo(args, v); err != nil {
2353 return nil, err
2354 }
2355 return v, nil
2356 }
2357
2358 func (o *DiskOp) transformMonitorResults(data []byte) (*diskMonitorResult, error) {
2359 nakedResponse := &diskMonitorResponseEnvelope{}
2360 if err := json.Unmarshal(data, nakedResponse); err != nil {
2361 return nil, err
2362 }
2363
2364 results := &diskMonitorResult{}
2365 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
2366 return nil, err
2367 }
2368 return results, nil
2369 }
2370
2371 func (o *DiskOp) transformMonitorDiskArgs(id types.ID, condition *MonitorCondition) (*diskMonitorDiskRequestEnvelope, error) {
2372 if id == types.ID(int64(0)) {
2373 id = types.ID(int64(0))
2374 }
2375 var arg0 interface{} = id
2376 if v, ok := arg0.(argumentDefaulter); ok {
2377 arg0 = v.setDefaults()
2378 }
2379 if condition == nil {
2380 condition = &MonitorCondition{}
2381 }
2382 var arg1 interface{} = condition
2383 if v, ok := arg1.(argumentDefaulter); ok {
2384 arg1 = v.setDefaults()
2385 }
2386 args := &struct {
2387 Arg0 interface{}
2388 Arg1 interface{} `mapconv:",squash"`
2389 }{
2390 Arg0: arg0,
2391 Arg1: arg1,
2392 }
2393
2394 v := &diskMonitorDiskRequestEnvelope{}
2395 if err := mapconv.ConvertTo(args, v); err != nil {
2396 return nil, err
2397 }
2398 return v, nil
2399 }
2400
2401 func (o *DiskOp) transformMonitorDiskResults(data []byte) (*diskMonitorDiskResult, error) {
2402 nakedResponse := &diskMonitorDiskResponseEnvelope{}
2403 if err := json.Unmarshal(data, nakedResponse); err != nil {
2404 return nil, err
2405 }
2406
2407 results := &diskMonitorDiskResult{}
2408 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
2409 return nil, err
2410 }
2411 return results, nil
2412 }
2413
2414 func (o *DiskPlanOp) transformFindArgs(conditions *FindCondition) (*diskPlanFindRequestEnvelope, error) {
2415 if conditions == nil {
2416 conditions = &FindCondition{}
2417 }
2418 var arg0 interface{} = conditions
2419 if v, ok := arg0.(argumentDefaulter); ok {
2420 arg0 = v.setDefaults()
2421 }
2422 args := &struct {
2423 Arg0 interface{} `mapconv:",squash"`
2424 }{
2425 Arg0: arg0,
2426 }
2427
2428 v := &diskPlanFindRequestEnvelope{}
2429 if err := mapconv.ConvertTo(args, v); err != nil {
2430 return nil, err
2431 }
2432 return v, nil
2433 }
2434
2435 func (o *DiskPlanOp) transformFindResults(data []byte) (*DiskPlanFindResult, error) {
2436 nakedResponse := &diskPlanFindResponseEnvelope{}
2437 if err := json.Unmarshal(data, nakedResponse); err != nil {
2438 return nil, err
2439 }
2440
2441 results := &DiskPlanFindResult{}
2442 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
2443 return nil, err
2444 }
2445 return results, nil
2446 }
2447
2448 func (o *DiskPlanOp) transformReadResults(data []byte) (*diskPlanReadResult, error) {
2449 nakedResponse := &diskPlanReadResponseEnvelope{}
2450 if err := json.Unmarshal(data, nakedResponse); err != nil {
2451 return nil, err
2452 }
2453
2454 results := &diskPlanReadResult{}
2455 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
2456 return nil, err
2457 }
2458 return results, nil
2459 }
2460
2461 func (o *DNSOp) transformFindArgs(conditions *FindCondition) (*dNSFindRequestEnvelope, error) {
2462 if conditions == nil {
2463 conditions = &FindCondition{}
2464 }
2465 var arg0 interface{} = conditions
2466 if v, ok := arg0.(argumentDefaulter); ok {
2467 arg0 = v.setDefaults()
2468 }
2469 args := &struct {
2470 Arg0 interface{} `mapconv:",squash"`
2471 }{
2472 Arg0: arg0,
2473 }
2474
2475 v := &dNSFindRequestEnvelope{}
2476 if err := mapconv.ConvertTo(args, v); err != nil {
2477 return nil, err
2478 }
2479 return v, nil
2480 }
2481
2482 func (o *DNSOp) transformFindResults(data []byte) (*DNSFindResult, error) {
2483 nakedResponse := &dNSFindResponseEnvelope{}
2484 if err := json.Unmarshal(data, nakedResponse); err != nil {
2485 return nil, err
2486 }
2487
2488 results := &DNSFindResult{}
2489 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
2490 return nil, err
2491 }
2492 return results, nil
2493 }
2494
2495 func (o *DNSOp) transformCreateArgs(param *DNSCreateRequest) (*dNSCreateRequestEnvelope, error) {
2496 if param == nil {
2497 param = &DNSCreateRequest{}
2498 }
2499 var arg0 interface{} = param
2500 if v, ok := arg0.(argumentDefaulter); ok {
2501 arg0 = v.setDefaults()
2502 }
2503 args := &struct {
2504 Arg0 interface{} `mapconv:"CommonServiceItem,recursive"`
2505 }{
2506 Arg0: arg0,
2507 }
2508
2509 v := &dNSCreateRequestEnvelope{}
2510 if err := mapconv.ConvertTo(args, v); err != nil {
2511 return nil, err
2512 }
2513 return v, nil
2514 }
2515
2516 func (o *DNSOp) transformCreateResults(data []byte) (*dNSCreateResult, error) {
2517 nakedResponse := &dNSCreateResponseEnvelope{}
2518 if err := json.Unmarshal(data, nakedResponse); err != nil {
2519 return nil, err
2520 }
2521
2522 results := &dNSCreateResult{}
2523 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
2524 return nil, err
2525 }
2526 return results, nil
2527 }
2528
2529 func (o *DNSOp) transformReadResults(data []byte) (*dNSReadResult, error) {
2530 nakedResponse := &dNSReadResponseEnvelope{}
2531 if err := json.Unmarshal(data, nakedResponse); err != nil {
2532 return nil, err
2533 }
2534
2535 results := &dNSReadResult{}
2536 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
2537 return nil, err
2538 }
2539 return results, nil
2540 }
2541
2542 func (o *DNSOp) transformUpdateArgs(id types.ID, param *DNSUpdateRequest) (*dNSUpdateRequestEnvelope, error) {
2543 if id == types.ID(int64(0)) {
2544 id = types.ID(int64(0))
2545 }
2546 var arg0 interface{} = id
2547 if v, ok := arg0.(argumentDefaulter); ok {
2548 arg0 = v.setDefaults()
2549 }
2550 if param == nil {
2551 param = &DNSUpdateRequest{}
2552 }
2553 var arg1 interface{} = param
2554 if v, ok := arg1.(argumentDefaulter); ok {
2555 arg1 = v.setDefaults()
2556 }
2557 args := &struct {
2558 Arg0 interface{}
2559 Arg1 interface{} `mapconv:"CommonServiceItem,recursive"`
2560 }{
2561 Arg0: arg0,
2562 Arg1: arg1,
2563 }
2564
2565 v := &dNSUpdateRequestEnvelope{}
2566 if err := mapconv.ConvertTo(args, v); err != nil {
2567 return nil, err
2568 }
2569 return v, nil
2570 }
2571
2572 func (o *DNSOp) transformUpdateResults(data []byte) (*dNSUpdateResult, error) {
2573 nakedResponse := &dNSUpdateResponseEnvelope{}
2574 if err := json.Unmarshal(data, nakedResponse); err != nil {
2575 return nil, err
2576 }
2577
2578 results := &dNSUpdateResult{}
2579 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
2580 return nil, err
2581 }
2582 return results, nil
2583 }
2584
2585 func (o *DNSOp) transformUpdateSettingsArgs(id types.ID, param *DNSUpdateSettingsRequest) (*dNSUpdateSettingsRequestEnvelope, error) {
2586 if id == types.ID(int64(0)) {
2587 id = types.ID(int64(0))
2588 }
2589 var arg0 interface{} = id
2590 if v, ok := arg0.(argumentDefaulter); ok {
2591 arg0 = v.setDefaults()
2592 }
2593 if param == nil {
2594 param = &DNSUpdateSettingsRequest{}
2595 }
2596 var arg1 interface{} = param
2597 if v, ok := arg1.(argumentDefaulter); ok {
2598 arg1 = v.setDefaults()
2599 }
2600 args := &struct {
2601 Arg0 interface{}
2602 Arg1 interface{} `mapconv:"CommonServiceItem,recursive"`
2603 }{
2604 Arg0: arg0,
2605 Arg1: arg1,
2606 }
2607
2608 v := &dNSUpdateSettingsRequestEnvelope{}
2609 if err := mapconv.ConvertTo(args, v); err != nil {
2610 return nil, err
2611 }
2612 return v, nil
2613 }
2614
2615 func (o *DNSOp) transformUpdateSettingsResults(data []byte) (*dNSUpdateSettingsResult, error) {
2616 nakedResponse := &dNSUpdateSettingsResponseEnvelope{}
2617 if err := json.Unmarshal(data, nakedResponse); err != nil {
2618 return nil, err
2619 }
2620
2621 results := &dNSUpdateSettingsResult{}
2622 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
2623 return nil, err
2624 }
2625 return results, nil
2626 }
2627
2628 func (o *EnhancedDBOp) transformFindArgs(conditions *FindCondition) (*enhancedDBFindRequestEnvelope, error) {
2629 if conditions == nil {
2630 conditions = &FindCondition{}
2631 }
2632 var arg0 interface{} = conditions
2633 if v, ok := arg0.(argumentDefaulter); ok {
2634 arg0 = v.setDefaults()
2635 }
2636 args := &struct {
2637 Arg0 interface{} `mapconv:",squash"`
2638 }{
2639 Arg0: arg0,
2640 }
2641
2642 v := &enhancedDBFindRequestEnvelope{}
2643 if err := mapconv.ConvertTo(args, v); err != nil {
2644 return nil, err
2645 }
2646 return v, nil
2647 }
2648
2649 func (o *EnhancedDBOp) transformFindResults(data []byte) (*EnhancedDBFindResult, error) {
2650 nakedResponse := &enhancedDBFindResponseEnvelope{}
2651 if err := json.Unmarshal(data, nakedResponse); err != nil {
2652 return nil, err
2653 }
2654
2655 results := &EnhancedDBFindResult{}
2656 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
2657 return nil, err
2658 }
2659 return results, nil
2660 }
2661
2662 func (o *EnhancedDBOp) transformCreateArgs(param *EnhancedDBCreateRequest) (*enhancedDBCreateRequestEnvelope, error) {
2663 if param == nil {
2664 param = &EnhancedDBCreateRequest{}
2665 }
2666 var arg0 interface{} = param
2667 if v, ok := arg0.(argumentDefaulter); ok {
2668 arg0 = v.setDefaults()
2669 }
2670 args := &struct {
2671 Arg0 interface{} `mapconv:"CommonServiceItem,recursive"`
2672 }{
2673 Arg0: arg0,
2674 }
2675
2676 v := &enhancedDBCreateRequestEnvelope{}
2677 if err := mapconv.ConvertTo(args, v); err != nil {
2678 return nil, err
2679 }
2680 return v, nil
2681 }
2682
2683 func (o *EnhancedDBOp) transformCreateResults(data []byte) (*enhancedDBCreateResult, error) {
2684 nakedResponse := &enhancedDBCreateResponseEnvelope{}
2685 if err := json.Unmarshal(data, nakedResponse); err != nil {
2686 return nil, err
2687 }
2688
2689 results := &enhancedDBCreateResult{}
2690 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
2691 return nil, err
2692 }
2693 return results, nil
2694 }
2695
2696 func (o *EnhancedDBOp) transformReadResults(data []byte) (*enhancedDBReadResult, error) {
2697 nakedResponse := &enhancedDBReadResponseEnvelope{}
2698 if err := json.Unmarshal(data, nakedResponse); err != nil {
2699 return nil, err
2700 }
2701
2702 results := &enhancedDBReadResult{}
2703 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
2704 return nil, err
2705 }
2706 return results, nil
2707 }
2708
2709 func (o *EnhancedDBOp) transformUpdateArgs(id types.ID, param *EnhancedDBUpdateRequest) (*enhancedDBUpdateRequestEnvelope, error) {
2710 if id == types.ID(int64(0)) {
2711 id = types.ID(int64(0))
2712 }
2713 var arg0 interface{} = id
2714 if v, ok := arg0.(argumentDefaulter); ok {
2715 arg0 = v.setDefaults()
2716 }
2717 if param == nil {
2718 param = &EnhancedDBUpdateRequest{}
2719 }
2720 var arg1 interface{} = param
2721 if v, ok := arg1.(argumentDefaulter); ok {
2722 arg1 = v.setDefaults()
2723 }
2724 args := &struct {
2725 Arg0 interface{}
2726 Arg1 interface{} `mapconv:"CommonServiceItem,recursive"`
2727 }{
2728 Arg0: arg0,
2729 Arg1: arg1,
2730 }
2731
2732 v := &enhancedDBUpdateRequestEnvelope{}
2733 if err := mapconv.ConvertTo(args, v); err != nil {
2734 return nil, err
2735 }
2736 return v, nil
2737 }
2738
2739 func (o *EnhancedDBOp) transformUpdateResults(data []byte) (*enhancedDBUpdateResult, error) {
2740 nakedResponse := &enhancedDBUpdateResponseEnvelope{}
2741 if err := json.Unmarshal(data, nakedResponse); err != nil {
2742 return nil, err
2743 }
2744
2745 results := &enhancedDBUpdateResult{}
2746 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
2747 return nil, err
2748 }
2749 return results, nil
2750 }
2751
2752 func (o *EnhancedDBOp) transformSetPasswordArgs(id types.ID, param *EnhancedDBSetPasswordRequest) (*enhancedDBSetPasswordRequestEnvelope, error) {
2753 if id == types.ID(int64(0)) {
2754 id = types.ID(int64(0))
2755 }
2756 var arg0 interface{} = id
2757 if v, ok := arg0.(argumentDefaulter); ok {
2758 arg0 = v.setDefaults()
2759 }
2760 if param == nil {
2761 param = &EnhancedDBSetPasswordRequest{}
2762 }
2763 var arg1 interface{} = param
2764 if v, ok := arg1.(argumentDefaulter); ok {
2765 arg1 = v.setDefaults()
2766 }
2767 args := &struct {
2768 Arg0 interface{}
2769 Arg1 interface{} `mapconv:"CommonServiceItem,recursive"`
2770 }{
2771 Arg0: arg0,
2772 Arg1: arg1,
2773 }
2774
2775 v := &enhancedDBSetPasswordRequestEnvelope{}
2776 if err := mapconv.ConvertTo(args, v); err != nil {
2777 return nil, err
2778 }
2779 return v, nil
2780 }
2781
2782 func (o *EnhancedDBOp) transformGetConfigResults(data []byte) (*enhancedDBGetConfigResult, error) {
2783 nakedResponse := &enhancedDBGetConfigResponseEnvelope{}
2784 if err := json.Unmarshal(data, nakedResponse); err != nil {
2785 return nil, err
2786 }
2787
2788 results := &enhancedDBGetConfigResult{}
2789 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
2790 return nil, err
2791 }
2792 return results, nil
2793 }
2794
2795 func (o *EnhancedDBOp) transformSetConfigArgs(id types.ID, param *EnhancedDBSetConfigRequest) (*enhancedDBSetConfigRequestEnvelope, error) {
2796 if id == types.ID(int64(0)) {
2797 id = types.ID(int64(0))
2798 }
2799 var arg0 interface{} = id
2800 if v, ok := arg0.(argumentDefaulter); ok {
2801 arg0 = v.setDefaults()
2802 }
2803 if param == nil {
2804 param = &EnhancedDBSetConfigRequest{}
2805 }
2806 var arg1 interface{} = param
2807 if v, ok := arg1.(argumentDefaulter); ok {
2808 arg1 = v.setDefaults()
2809 }
2810 args := &struct {
2811 Arg0 interface{}
2812 Arg1 interface{} `mapconv:"CommonServiceItem,recursive"`
2813 }{
2814 Arg0: arg0,
2815 Arg1: arg1,
2816 }
2817
2818 v := &enhancedDBSetConfigRequestEnvelope{}
2819 if err := mapconv.ConvertTo(args, v); err != nil {
2820 return nil, err
2821 }
2822 return v, nil
2823 }
2824
2825 func (o *ESMEOp) transformFindArgs(conditions *FindCondition) (*eSMEFindRequestEnvelope, error) {
2826 if conditions == nil {
2827 conditions = &FindCondition{}
2828 }
2829 var arg0 interface{} = conditions
2830 if v, ok := arg0.(argumentDefaulter); ok {
2831 arg0 = v.setDefaults()
2832 }
2833 args := &struct {
2834 Arg0 interface{} `mapconv:",squash"`
2835 }{
2836 Arg0: arg0,
2837 }
2838
2839 v := &eSMEFindRequestEnvelope{}
2840 if err := mapconv.ConvertTo(args, v); err != nil {
2841 return nil, err
2842 }
2843 return v, nil
2844 }
2845
2846 func (o *ESMEOp) transformFindResults(data []byte) (*ESMEFindResult, error) {
2847 nakedResponse := &eSMEFindResponseEnvelope{}
2848 if err := json.Unmarshal(data, nakedResponse); err != nil {
2849 return nil, err
2850 }
2851
2852 results := &ESMEFindResult{}
2853 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
2854 return nil, err
2855 }
2856 return results, nil
2857 }
2858
2859 func (o *ESMEOp) transformCreateArgs(param *ESMECreateRequest) (*eSMECreateRequestEnvelope, error) {
2860 if param == nil {
2861 param = &ESMECreateRequest{}
2862 }
2863 var arg0 interface{} = param
2864 if v, ok := arg0.(argumentDefaulter); ok {
2865 arg0 = v.setDefaults()
2866 }
2867 args := &struct {
2868 Arg0 interface{} `mapconv:"CommonServiceItem,recursive"`
2869 }{
2870 Arg0: arg0,
2871 }
2872
2873 v := &eSMECreateRequestEnvelope{}
2874 if err := mapconv.ConvertTo(args, v); err != nil {
2875 return nil, err
2876 }
2877 return v, nil
2878 }
2879
2880 func (o *ESMEOp) transformCreateResults(data []byte) (*eSMECreateResult, error) {
2881 nakedResponse := &eSMECreateResponseEnvelope{}
2882 if err := json.Unmarshal(data, nakedResponse); err != nil {
2883 return nil, err
2884 }
2885
2886 results := &eSMECreateResult{}
2887 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
2888 return nil, err
2889 }
2890 return results, nil
2891 }
2892
2893 func (o *ESMEOp) transformReadResults(data []byte) (*eSMEReadResult, error) {
2894 nakedResponse := &eSMEReadResponseEnvelope{}
2895 if err := json.Unmarshal(data, nakedResponse); err != nil {
2896 return nil, err
2897 }
2898
2899 results := &eSMEReadResult{}
2900 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
2901 return nil, err
2902 }
2903 return results, nil
2904 }
2905
2906 func (o *ESMEOp) transformUpdateArgs(id types.ID, param *ESMEUpdateRequest) (*eSMEUpdateRequestEnvelope, error) {
2907 if id == types.ID(int64(0)) {
2908 id = types.ID(int64(0))
2909 }
2910 var arg0 interface{} = id
2911 if v, ok := arg0.(argumentDefaulter); ok {
2912 arg0 = v.setDefaults()
2913 }
2914 if param == nil {
2915 param = &ESMEUpdateRequest{}
2916 }
2917 var arg1 interface{} = param
2918 if v, ok := arg1.(argumentDefaulter); ok {
2919 arg1 = v.setDefaults()
2920 }
2921 args := &struct {
2922 Arg0 interface{}
2923 Arg1 interface{} `mapconv:"CommonServiceItem,recursive"`
2924 }{
2925 Arg0: arg0,
2926 Arg1: arg1,
2927 }
2928
2929 v := &eSMEUpdateRequestEnvelope{}
2930 if err := mapconv.ConvertTo(args, v); err != nil {
2931 return nil, err
2932 }
2933 return v, nil
2934 }
2935
2936 func (o *ESMEOp) transformUpdateResults(data []byte) (*eSMEUpdateResult, error) {
2937 nakedResponse := &eSMEUpdateResponseEnvelope{}
2938 if err := json.Unmarshal(data, nakedResponse); err != nil {
2939 return nil, err
2940 }
2941
2942 results := &eSMEUpdateResult{}
2943 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
2944 return nil, err
2945 }
2946 return results, nil
2947 }
2948
2949 func (o *ESMEOp) transformSendMessageWithGeneratedOTPArgs(id types.ID, param *ESMESendMessageWithGeneratedOTPRequest) (*eSMESendMessageWithGeneratedOTPRequestEnvelope, error) {
2950 if id == types.ID(int64(0)) {
2951 id = types.ID(int64(0))
2952 }
2953 var arg0 interface{} = id
2954 if v, ok := arg0.(argumentDefaulter); ok {
2955 arg0 = v.setDefaults()
2956 }
2957 if param == nil {
2958 param = &ESMESendMessageWithGeneratedOTPRequest{}
2959 }
2960 var arg1 interface{} = param
2961 if v, ok := arg1.(argumentDefaulter); ok {
2962 arg1 = v.setDefaults()
2963 }
2964 args := &struct {
2965 Arg0 interface{}
2966 Arg1 interface{} `mapconv:"ESME,recursive"`
2967 }{
2968 Arg0: arg0,
2969 Arg1: arg1,
2970 }
2971
2972 v := &eSMESendMessageWithGeneratedOTPRequestEnvelope{}
2973 if err := mapconv.ConvertTo(args, v); err != nil {
2974 return nil, err
2975 }
2976 return v, nil
2977 }
2978
2979 func (o *ESMEOp) transformSendMessageWithGeneratedOTPResults(data []byte) (*eSMESendMessageWithGeneratedOTPResult, error) {
2980 nakedResponse := &eSMESendMessageWithGeneratedOTPResponseEnvelope{}
2981 if err := json.Unmarshal(data, nakedResponse); err != nil {
2982 return nil, err
2983 }
2984
2985 results := &eSMESendMessageWithGeneratedOTPResult{}
2986 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
2987 return nil, err
2988 }
2989 return results, nil
2990 }
2991
2992 func (o *ESMEOp) transformSendMessageWithInputtedOTPArgs(id types.ID, param *ESMESendMessageWithInputtedOTPRequest) (*eSMESendMessageWithInputtedOTPRequestEnvelope, error) {
2993 if id == types.ID(int64(0)) {
2994 id = types.ID(int64(0))
2995 }
2996 var arg0 interface{} = id
2997 if v, ok := arg0.(argumentDefaulter); ok {
2998 arg0 = v.setDefaults()
2999 }
3000 if param == nil {
3001 param = &ESMESendMessageWithInputtedOTPRequest{}
3002 }
3003 var arg1 interface{} = param
3004 if v, ok := arg1.(argumentDefaulter); ok {
3005 arg1 = v.setDefaults()
3006 }
3007 args := &struct {
3008 Arg0 interface{}
3009 Arg1 interface{} `mapconv:"ESME,recursive"`
3010 }{
3011 Arg0: arg0,
3012 Arg1: arg1,
3013 }
3014
3015 v := &eSMESendMessageWithInputtedOTPRequestEnvelope{}
3016 if err := mapconv.ConvertTo(args, v); err != nil {
3017 return nil, err
3018 }
3019 return v, nil
3020 }
3021
3022 func (o *ESMEOp) transformSendMessageWithInputtedOTPResults(data []byte) (*eSMESendMessageWithInputtedOTPResult, error) {
3023 nakedResponse := &eSMESendMessageWithInputtedOTPResponseEnvelope{}
3024 if err := json.Unmarshal(data, nakedResponse); err != nil {
3025 return nil, err
3026 }
3027
3028 results := &eSMESendMessageWithInputtedOTPResult{}
3029 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3030 return nil, err
3031 }
3032 return results, nil
3033 }
3034
3035 func (o *ESMEOp) transformLogsResults(data []byte) (*eSMELogsResult, error) {
3036 nakedResponse := &eSMELogsResponseEnvelope{}
3037 if err := json.Unmarshal(data, nakedResponse); err != nil {
3038 return nil, err
3039 }
3040
3041 results := &eSMELogsResult{}
3042 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3043 return nil, err
3044 }
3045 return results, nil
3046 }
3047
3048 func (o *GSLBOp) transformFindArgs(conditions *FindCondition) (*gSLBFindRequestEnvelope, error) {
3049 if conditions == nil {
3050 conditions = &FindCondition{}
3051 }
3052 var arg0 interface{} = conditions
3053 if v, ok := arg0.(argumentDefaulter); ok {
3054 arg0 = v.setDefaults()
3055 }
3056 args := &struct {
3057 Arg0 interface{} `mapconv:",squash"`
3058 }{
3059 Arg0: arg0,
3060 }
3061
3062 v := &gSLBFindRequestEnvelope{}
3063 if err := mapconv.ConvertTo(args, v); err != nil {
3064 return nil, err
3065 }
3066 return v, nil
3067 }
3068
3069 func (o *GSLBOp) transformFindResults(data []byte) (*GSLBFindResult, error) {
3070 nakedResponse := &gSLBFindResponseEnvelope{}
3071 if err := json.Unmarshal(data, nakedResponse); err != nil {
3072 return nil, err
3073 }
3074
3075 results := &GSLBFindResult{}
3076 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3077 return nil, err
3078 }
3079 return results, nil
3080 }
3081
3082 func (o *GSLBOp) transformCreateArgs(param *GSLBCreateRequest) (*gSLBCreateRequestEnvelope, error) {
3083 if param == nil {
3084 param = &GSLBCreateRequest{}
3085 }
3086 var arg0 interface{} = param
3087 if v, ok := arg0.(argumentDefaulter); ok {
3088 arg0 = v.setDefaults()
3089 }
3090 args := &struct {
3091 Arg0 interface{} `mapconv:"CommonServiceItem,recursive"`
3092 }{
3093 Arg0: arg0,
3094 }
3095
3096 v := &gSLBCreateRequestEnvelope{}
3097 if err := mapconv.ConvertTo(args, v); err != nil {
3098 return nil, err
3099 }
3100 return v, nil
3101 }
3102
3103 func (o *GSLBOp) transformCreateResults(data []byte) (*gSLBCreateResult, error) {
3104 nakedResponse := &gSLBCreateResponseEnvelope{}
3105 if err := json.Unmarshal(data, nakedResponse); err != nil {
3106 return nil, err
3107 }
3108
3109 results := &gSLBCreateResult{}
3110 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3111 return nil, err
3112 }
3113 return results, nil
3114 }
3115
3116 func (o *GSLBOp) transformReadResults(data []byte) (*gSLBReadResult, error) {
3117 nakedResponse := &gSLBReadResponseEnvelope{}
3118 if err := json.Unmarshal(data, nakedResponse); err != nil {
3119 return nil, err
3120 }
3121
3122 results := &gSLBReadResult{}
3123 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3124 return nil, err
3125 }
3126 return results, nil
3127 }
3128
3129 func (o *GSLBOp) transformUpdateArgs(id types.ID, param *GSLBUpdateRequest) (*gSLBUpdateRequestEnvelope, error) {
3130 if id == types.ID(int64(0)) {
3131 id = types.ID(int64(0))
3132 }
3133 var arg0 interface{} = id
3134 if v, ok := arg0.(argumentDefaulter); ok {
3135 arg0 = v.setDefaults()
3136 }
3137 if param == nil {
3138 param = &GSLBUpdateRequest{}
3139 }
3140 var arg1 interface{} = param
3141 if v, ok := arg1.(argumentDefaulter); ok {
3142 arg1 = v.setDefaults()
3143 }
3144 args := &struct {
3145 Arg0 interface{}
3146 Arg1 interface{} `mapconv:"CommonServiceItem,recursive"`
3147 }{
3148 Arg0: arg0,
3149 Arg1: arg1,
3150 }
3151
3152 v := &gSLBUpdateRequestEnvelope{}
3153 if err := mapconv.ConvertTo(args, v); err != nil {
3154 return nil, err
3155 }
3156 return v, nil
3157 }
3158
3159 func (o *GSLBOp) transformUpdateResults(data []byte) (*gSLBUpdateResult, error) {
3160 nakedResponse := &gSLBUpdateResponseEnvelope{}
3161 if err := json.Unmarshal(data, nakedResponse); err != nil {
3162 return nil, err
3163 }
3164
3165 results := &gSLBUpdateResult{}
3166 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3167 return nil, err
3168 }
3169 return results, nil
3170 }
3171
3172 func (o *GSLBOp) transformUpdateSettingsArgs(id types.ID, param *GSLBUpdateSettingsRequest) (*gSLBUpdateSettingsRequestEnvelope, error) {
3173 if id == types.ID(int64(0)) {
3174 id = types.ID(int64(0))
3175 }
3176 var arg0 interface{} = id
3177 if v, ok := arg0.(argumentDefaulter); ok {
3178 arg0 = v.setDefaults()
3179 }
3180 if param == nil {
3181 param = &GSLBUpdateSettingsRequest{}
3182 }
3183 var arg1 interface{} = param
3184 if v, ok := arg1.(argumentDefaulter); ok {
3185 arg1 = v.setDefaults()
3186 }
3187 args := &struct {
3188 Arg0 interface{}
3189 Arg1 interface{} `mapconv:"CommonServiceItem,recursive"`
3190 }{
3191 Arg0: arg0,
3192 Arg1: arg1,
3193 }
3194
3195 v := &gSLBUpdateSettingsRequestEnvelope{}
3196 if err := mapconv.ConvertTo(args, v); err != nil {
3197 return nil, err
3198 }
3199 return v, nil
3200 }
3201
3202 func (o *GSLBOp) transformUpdateSettingsResults(data []byte) (*gSLBUpdateSettingsResult, error) {
3203 nakedResponse := &gSLBUpdateSettingsResponseEnvelope{}
3204 if err := json.Unmarshal(data, nakedResponse); err != nil {
3205 return nil, err
3206 }
3207
3208 results := &gSLBUpdateSettingsResult{}
3209 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3210 return nil, err
3211 }
3212 return results, nil
3213 }
3214
3215 func (o *IconOp) transformFindArgs(conditions *FindCondition) (*iconFindRequestEnvelope, error) {
3216 if conditions == nil {
3217 conditions = &FindCondition{}
3218 }
3219 var arg0 interface{} = conditions
3220 if v, ok := arg0.(argumentDefaulter); ok {
3221 arg0 = v.setDefaults()
3222 }
3223 args := &struct {
3224 Arg0 interface{} `mapconv:",squash"`
3225 }{
3226 Arg0: arg0,
3227 }
3228
3229 v := &iconFindRequestEnvelope{}
3230 if err := mapconv.ConvertTo(args, v); err != nil {
3231 return nil, err
3232 }
3233 return v, nil
3234 }
3235
3236 func (o *IconOp) transformFindResults(data []byte) (*IconFindResult, error) {
3237 nakedResponse := &iconFindResponseEnvelope{}
3238 if err := json.Unmarshal(data, nakedResponse); err != nil {
3239 return nil, err
3240 }
3241
3242 results := &IconFindResult{}
3243 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3244 return nil, err
3245 }
3246 return results, nil
3247 }
3248
3249 func (o *IconOp) transformCreateArgs(param *IconCreateRequest) (*iconCreateRequestEnvelope, error) {
3250 if param == nil {
3251 param = &IconCreateRequest{}
3252 }
3253 var arg0 interface{} = param
3254 if v, ok := arg0.(argumentDefaulter); ok {
3255 arg0 = v.setDefaults()
3256 }
3257 args := &struct {
3258 Arg0 interface{} `mapconv:"Icon,recursive"`
3259 }{
3260 Arg0: arg0,
3261 }
3262
3263 v := &iconCreateRequestEnvelope{}
3264 if err := mapconv.ConvertTo(args, v); err != nil {
3265 return nil, err
3266 }
3267 return v, nil
3268 }
3269
3270 func (o *IconOp) transformCreateResults(data []byte) (*iconCreateResult, error) {
3271 nakedResponse := &iconCreateResponseEnvelope{}
3272 if err := json.Unmarshal(data, nakedResponse); err != nil {
3273 return nil, err
3274 }
3275
3276 results := &iconCreateResult{}
3277 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3278 return nil, err
3279 }
3280 return results, nil
3281 }
3282
3283 func (o *IconOp) transformReadResults(data []byte) (*iconReadResult, error) {
3284 nakedResponse := &iconReadResponseEnvelope{}
3285 if err := json.Unmarshal(data, nakedResponse); err != nil {
3286 return nil, err
3287 }
3288
3289 results := &iconReadResult{}
3290 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3291 return nil, err
3292 }
3293 return results, nil
3294 }
3295
3296 func (o *IconOp) transformUpdateArgs(id types.ID, param *IconUpdateRequest) (*iconUpdateRequestEnvelope, error) {
3297 if id == types.ID(int64(0)) {
3298 id = types.ID(int64(0))
3299 }
3300 var arg0 interface{} = id
3301 if v, ok := arg0.(argumentDefaulter); ok {
3302 arg0 = v.setDefaults()
3303 }
3304 if param == nil {
3305 param = &IconUpdateRequest{}
3306 }
3307 var arg1 interface{} = param
3308 if v, ok := arg1.(argumentDefaulter); ok {
3309 arg1 = v.setDefaults()
3310 }
3311 args := &struct {
3312 Arg0 interface{}
3313 Arg1 interface{} `mapconv:"Icon,recursive"`
3314 }{
3315 Arg0: arg0,
3316 Arg1: arg1,
3317 }
3318
3319 v := &iconUpdateRequestEnvelope{}
3320 if err := mapconv.ConvertTo(args, v); err != nil {
3321 return nil, err
3322 }
3323 return v, nil
3324 }
3325
3326 func (o *IconOp) transformUpdateResults(data []byte) (*iconUpdateResult, error) {
3327 nakedResponse := &iconUpdateResponseEnvelope{}
3328 if err := json.Unmarshal(data, nakedResponse); err != nil {
3329 return nil, err
3330 }
3331
3332 results := &iconUpdateResult{}
3333 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3334 return nil, err
3335 }
3336 return results, nil
3337 }
3338
3339 func (o *InterfaceOp) transformFindArgs(conditions *FindCondition) (*interfaceFindRequestEnvelope, error) {
3340 if conditions == nil {
3341 conditions = &FindCondition{}
3342 }
3343 var arg0 interface{} = conditions
3344 if v, ok := arg0.(argumentDefaulter); ok {
3345 arg0 = v.setDefaults()
3346 }
3347 args := &struct {
3348 Arg0 interface{} `mapconv:",squash"`
3349 }{
3350 Arg0: arg0,
3351 }
3352
3353 v := &interfaceFindRequestEnvelope{}
3354 if err := mapconv.ConvertTo(args, v); err != nil {
3355 return nil, err
3356 }
3357 return v, nil
3358 }
3359
3360 func (o *InterfaceOp) transformFindResults(data []byte) (*InterfaceFindResult, error) {
3361 nakedResponse := &interfaceFindResponseEnvelope{}
3362 if err := json.Unmarshal(data, nakedResponse); err != nil {
3363 return nil, err
3364 }
3365
3366 results := &InterfaceFindResult{}
3367 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3368 return nil, err
3369 }
3370 return results, nil
3371 }
3372
3373 func (o *InterfaceOp) transformCreateArgs(param *InterfaceCreateRequest) (*interfaceCreateRequestEnvelope, error) {
3374 if param == nil {
3375 param = &InterfaceCreateRequest{}
3376 }
3377 var arg0 interface{} = param
3378 if v, ok := arg0.(argumentDefaulter); ok {
3379 arg0 = v.setDefaults()
3380 }
3381 args := &struct {
3382 Arg0 interface{} `mapconv:"Interface,recursive"`
3383 }{
3384 Arg0: arg0,
3385 }
3386
3387 v := &interfaceCreateRequestEnvelope{}
3388 if err := mapconv.ConvertTo(args, v); err != nil {
3389 return nil, err
3390 }
3391 return v, nil
3392 }
3393
3394 func (o *InterfaceOp) transformCreateResults(data []byte) (*interfaceCreateResult, error) {
3395 nakedResponse := &interfaceCreateResponseEnvelope{}
3396 if err := json.Unmarshal(data, nakedResponse); err != nil {
3397 return nil, err
3398 }
3399
3400 results := &interfaceCreateResult{}
3401 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3402 return nil, err
3403 }
3404 return results, nil
3405 }
3406
3407 func (o *InterfaceOp) transformReadResults(data []byte) (*interfaceReadResult, error) {
3408 nakedResponse := &interfaceReadResponseEnvelope{}
3409 if err := json.Unmarshal(data, nakedResponse); err != nil {
3410 return nil, err
3411 }
3412
3413 results := &interfaceReadResult{}
3414 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3415 return nil, err
3416 }
3417 return results, nil
3418 }
3419
3420 func (o *InterfaceOp) transformUpdateArgs(id types.ID, param *InterfaceUpdateRequest) (*interfaceUpdateRequestEnvelope, error) {
3421 if id == types.ID(int64(0)) {
3422 id = types.ID(int64(0))
3423 }
3424 var arg0 interface{} = id
3425 if v, ok := arg0.(argumentDefaulter); ok {
3426 arg0 = v.setDefaults()
3427 }
3428 if param == nil {
3429 param = &InterfaceUpdateRequest{}
3430 }
3431 var arg1 interface{} = param
3432 if v, ok := arg1.(argumentDefaulter); ok {
3433 arg1 = v.setDefaults()
3434 }
3435 args := &struct {
3436 Arg0 interface{}
3437 Arg1 interface{} `mapconv:"Interface,recursive"`
3438 }{
3439 Arg0: arg0,
3440 Arg1: arg1,
3441 }
3442
3443 v := &interfaceUpdateRequestEnvelope{}
3444 if err := mapconv.ConvertTo(args, v); err != nil {
3445 return nil, err
3446 }
3447 return v, nil
3448 }
3449
3450 func (o *InterfaceOp) transformUpdateResults(data []byte) (*interfaceUpdateResult, error) {
3451 nakedResponse := &interfaceUpdateResponseEnvelope{}
3452 if err := json.Unmarshal(data, nakedResponse); err != nil {
3453 return nil, err
3454 }
3455
3456 results := &interfaceUpdateResult{}
3457 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3458 return nil, err
3459 }
3460 return results, nil
3461 }
3462
3463 func (o *InterfaceOp) transformMonitorArgs(id types.ID, condition *MonitorCondition) (*interfaceMonitorRequestEnvelope, error) {
3464 if id == types.ID(int64(0)) {
3465 id = types.ID(int64(0))
3466 }
3467 var arg0 interface{} = id
3468 if v, ok := arg0.(argumentDefaulter); ok {
3469 arg0 = v.setDefaults()
3470 }
3471 if condition == nil {
3472 condition = &MonitorCondition{}
3473 }
3474 var arg1 interface{} = condition
3475 if v, ok := arg1.(argumentDefaulter); ok {
3476 arg1 = v.setDefaults()
3477 }
3478 args := &struct {
3479 Arg0 interface{}
3480 Arg1 interface{} `mapconv:",squash"`
3481 }{
3482 Arg0: arg0,
3483 Arg1: arg1,
3484 }
3485
3486 v := &interfaceMonitorRequestEnvelope{}
3487 if err := mapconv.ConvertTo(args, v); err != nil {
3488 return nil, err
3489 }
3490 return v, nil
3491 }
3492
3493 func (o *InterfaceOp) transformMonitorResults(data []byte) (*interfaceMonitorResult, error) {
3494 nakedResponse := &interfaceMonitorResponseEnvelope{}
3495 if err := json.Unmarshal(data, nakedResponse); err != nil {
3496 return nil, err
3497 }
3498
3499 results := &interfaceMonitorResult{}
3500 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3501 return nil, err
3502 }
3503 return results, nil
3504 }
3505
3506 func (o *InternetOp) transformFindArgs(conditions *FindCondition) (*internetFindRequestEnvelope, error) {
3507 if conditions == nil {
3508 conditions = &FindCondition{}
3509 }
3510 var arg0 interface{} = conditions
3511 if v, ok := arg0.(argumentDefaulter); ok {
3512 arg0 = v.setDefaults()
3513 }
3514 args := &struct {
3515 Arg0 interface{} `mapconv:",squash"`
3516 }{
3517 Arg0: arg0,
3518 }
3519
3520 v := &internetFindRequestEnvelope{}
3521 if err := mapconv.ConvertTo(args, v); err != nil {
3522 return nil, err
3523 }
3524 return v, nil
3525 }
3526
3527 func (o *InternetOp) transformFindResults(data []byte) (*InternetFindResult, error) {
3528 nakedResponse := &internetFindResponseEnvelope{}
3529 if err := json.Unmarshal(data, nakedResponse); err != nil {
3530 return nil, err
3531 }
3532
3533 results := &InternetFindResult{}
3534 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3535 return nil, err
3536 }
3537 return results, nil
3538 }
3539
3540 func (o *InternetOp) transformCreateArgs(param *InternetCreateRequest) (*internetCreateRequestEnvelope, error) {
3541 if param == nil {
3542 param = &InternetCreateRequest{}
3543 }
3544 var arg0 interface{} = param
3545 if v, ok := arg0.(argumentDefaulter); ok {
3546 arg0 = v.setDefaults()
3547 }
3548 args := &struct {
3549 Arg0 interface{} `mapconv:"Internet,recursive"`
3550 }{
3551 Arg0: arg0,
3552 }
3553
3554 v := &internetCreateRequestEnvelope{}
3555 if err := mapconv.ConvertTo(args, v); err != nil {
3556 return nil, err
3557 }
3558 return v, nil
3559 }
3560
3561 func (o *InternetOp) transformCreateResults(data []byte) (*internetCreateResult, error) {
3562 nakedResponse := &internetCreateResponseEnvelope{}
3563 if err := json.Unmarshal(data, nakedResponse); err != nil {
3564 return nil, err
3565 }
3566
3567 results := &internetCreateResult{}
3568 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3569 return nil, err
3570 }
3571 return results, nil
3572 }
3573
3574 func (o *InternetOp) transformReadResults(data []byte) (*internetReadResult, error) {
3575 nakedResponse := &internetReadResponseEnvelope{}
3576 if err := json.Unmarshal(data, nakedResponse); err != nil {
3577 return nil, err
3578 }
3579
3580 results := &internetReadResult{}
3581 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3582 return nil, err
3583 }
3584 return results, nil
3585 }
3586
3587 func (o *InternetOp) transformUpdateArgs(id types.ID, param *InternetUpdateRequest) (*internetUpdateRequestEnvelope, error) {
3588 if id == types.ID(int64(0)) {
3589 id = types.ID(int64(0))
3590 }
3591 var arg0 interface{} = id
3592 if v, ok := arg0.(argumentDefaulter); ok {
3593 arg0 = v.setDefaults()
3594 }
3595 if param == nil {
3596 param = &InternetUpdateRequest{}
3597 }
3598 var arg1 interface{} = param
3599 if v, ok := arg1.(argumentDefaulter); ok {
3600 arg1 = v.setDefaults()
3601 }
3602 args := &struct {
3603 Arg0 interface{}
3604 Arg1 interface{} `mapconv:"Internet,recursive"`
3605 }{
3606 Arg0: arg0,
3607 Arg1: arg1,
3608 }
3609
3610 v := &internetUpdateRequestEnvelope{}
3611 if err := mapconv.ConvertTo(args, v); err != nil {
3612 return nil, err
3613 }
3614 return v, nil
3615 }
3616
3617 func (o *InternetOp) transformUpdateResults(data []byte) (*internetUpdateResult, error) {
3618 nakedResponse := &internetUpdateResponseEnvelope{}
3619 if err := json.Unmarshal(data, nakedResponse); err != nil {
3620 return nil, err
3621 }
3622
3623 results := &internetUpdateResult{}
3624 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3625 return nil, err
3626 }
3627 return results, nil
3628 }
3629
3630 func (o *InternetOp) transformUpdateBandWidthArgs(id types.ID, param *InternetUpdateBandWidthRequest) (*internetUpdateBandWidthRequestEnvelope, error) {
3631 if id == types.ID(int64(0)) {
3632 id = types.ID(int64(0))
3633 }
3634 var arg0 interface{} = id
3635 if v, ok := arg0.(argumentDefaulter); ok {
3636 arg0 = v.setDefaults()
3637 }
3638 if param == nil {
3639 param = &InternetUpdateBandWidthRequest{}
3640 }
3641 var arg1 interface{} = param
3642 if v, ok := arg1.(argumentDefaulter); ok {
3643 arg1 = v.setDefaults()
3644 }
3645 args := &struct {
3646 Arg0 interface{}
3647 Arg1 interface{} `mapconv:"Internet,recursive"`
3648 }{
3649 Arg0: arg0,
3650 Arg1: arg1,
3651 }
3652
3653 v := &internetUpdateBandWidthRequestEnvelope{}
3654 if err := mapconv.ConvertTo(args, v); err != nil {
3655 return nil, err
3656 }
3657 return v, nil
3658 }
3659
3660 func (o *InternetOp) transformUpdateBandWidthResults(data []byte) (*internetUpdateBandWidthResult, error) {
3661 nakedResponse := &internetUpdateBandWidthResponseEnvelope{}
3662 if err := json.Unmarshal(data, nakedResponse); err != nil {
3663 return nil, err
3664 }
3665
3666 results := &internetUpdateBandWidthResult{}
3667 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3668 return nil, err
3669 }
3670 return results, nil
3671 }
3672
3673 func (o *InternetOp) transformAddSubnetArgs(id types.ID, param *InternetAddSubnetRequest) (*internetAddSubnetRequestEnvelope, error) {
3674 if id == types.ID(int64(0)) {
3675 id = types.ID(int64(0))
3676 }
3677 var arg0 interface{} = id
3678 if v, ok := arg0.(argumentDefaulter); ok {
3679 arg0 = v.setDefaults()
3680 }
3681 if param == nil {
3682 param = &InternetAddSubnetRequest{}
3683 }
3684 var arg1 interface{} = param
3685 if v, ok := arg1.(argumentDefaulter); ok {
3686 arg1 = v.setDefaults()
3687 }
3688 args := &struct {
3689 Arg0 interface{}
3690 Arg1 interface{} `mapconv:",squash"`
3691 }{
3692 Arg0: arg0,
3693 Arg1: arg1,
3694 }
3695
3696 v := &internetAddSubnetRequestEnvelope{}
3697 if err := mapconv.ConvertTo(args, v); err != nil {
3698 return nil, err
3699 }
3700 return v, nil
3701 }
3702
3703 func (o *InternetOp) transformAddSubnetResults(data []byte) (*internetAddSubnetResult, error) {
3704 nakedResponse := &internetAddSubnetResponseEnvelope{}
3705 if err := json.Unmarshal(data, nakedResponse); err != nil {
3706 return nil, err
3707 }
3708
3709 results := &internetAddSubnetResult{}
3710 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3711 return nil, err
3712 }
3713 return results, nil
3714 }
3715
3716 func (o *InternetOp) transformUpdateSubnetArgs(id types.ID, subnetID types.ID, param *InternetUpdateSubnetRequest) (*internetUpdateSubnetRequestEnvelope, error) {
3717 if id == types.ID(int64(0)) {
3718 id = types.ID(int64(0))
3719 }
3720 var arg0 interface{} = id
3721 if v, ok := arg0.(argumentDefaulter); ok {
3722 arg0 = v.setDefaults()
3723 }
3724 if subnetID == types.ID(int64(0)) {
3725 subnetID = types.ID(int64(0))
3726 }
3727 var arg1 interface{} = subnetID
3728 if v, ok := arg1.(argumentDefaulter); ok {
3729 arg1 = v.setDefaults()
3730 }
3731 if param == nil {
3732 param = &InternetUpdateSubnetRequest{}
3733 }
3734 var arg2 interface{} = param
3735 if v, ok := arg2.(argumentDefaulter); ok {
3736 arg2 = v.setDefaults()
3737 }
3738 args := &struct {
3739 Arg0 interface{}
3740 Arg1 interface{}
3741 Arg2 interface{} `mapconv:",squash"`
3742 }{
3743 Arg0: arg0,
3744 Arg1: arg1,
3745 Arg2: arg2,
3746 }
3747
3748 v := &internetUpdateSubnetRequestEnvelope{}
3749 if err := mapconv.ConvertTo(args, v); err != nil {
3750 return nil, err
3751 }
3752 return v, nil
3753 }
3754
3755 func (o *InternetOp) transformUpdateSubnetResults(data []byte) (*internetUpdateSubnetResult, error) {
3756 nakedResponse := &internetUpdateSubnetResponseEnvelope{}
3757 if err := json.Unmarshal(data, nakedResponse); err != nil {
3758 return nil, err
3759 }
3760
3761 results := &internetUpdateSubnetResult{}
3762 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3763 return nil, err
3764 }
3765 return results, nil
3766 }
3767
3768 func (o *InternetOp) transformMonitorArgs(id types.ID, condition *MonitorCondition) (*internetMonitorRequestEnvelope, error) {
3769 if id == types.ID(int64(0)) {
3770 id = types.ID(int64(0))
3771 }
3772 var arg0 interface{} = id
3773 if v, ok := arg0.(argumentDefaulter); ok {
3774 arg0 = v.setDefaults()
3775 }
3776 if condition == nil {
3777 condition = &MonitorCondition{}
3778 }
3779 var arg1 interface{} = condition
3780 if v, ok := arg1.(argumentDefaulter); ok {
3781 arg1 = v.setDefaults()
3782 }
3783 args := &struct {
3784 Arg0 interface{}
3785 Arg1 interface{} `mapconv:",squash"`
3786 }{
3787 Arg0: arg0,
3788 Arg1: arg1,
3789 }
3790
3791 v := &internetMonitorRequestEnvelope{}
3792 if err := mapconv.ConvertTo(args, v); err != nil {
3793 return nil, err
3794 }
3795 return v, nil
3796 }
3797
3798 func (o *InternetOp) transformMonitorResults(data []byte) (*internetMonitorResult, error) {
3799 nakedResponse := &internetMonitorResponseEnvelope{}
3800 if err := json.Unmarshal(data, nakedResponse); err != nil {
3801 return nil, err
3802 }
3803
3804 results := &internetMonitorResult{}
3805 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3806 return nil, err
3807 }
3808 return results, nil
3809 }
3810
3811 func (o *InternetOp) transformMonitorRouterArgs(id types.ID, condition *MonitorCondition) (*internetMonitorRouterRequestEnvelope, error) {
3812 if id == types.ID(int64(0)) {
3813 id = types.ID(int64(0))
3814 }
3815 var arg0 interface{} = id
3816 if v, ok := arg0.(argumentDefaulter); ok {
3817 arg0 = v.setDefaults()
3818 }
3819 if condition == nil {
3820 condition = &MonitorCondition{}
3821 }
3822 var arg1 interface{} = condition
3823 if v, ok := arg1.(argumentDefaulter); ok {
3824 arg1 = v.setDefaults()
3825 }
3826 args := &struct {
3827 Arg0 interface{}
3828 Arg1 interface{} `mapconv:",squash"`
3829 }{
3830 Arg0: arg0,
3831 Arg1: arg1,
3832 }
3833
3834 v := &internetMonitorRouterRequestEnvelope{}
3835 if err := mapconv.ConvertTo(args, v); err != nil {
3836 return nil, err
3837 }
3838 return v, nil
3839 }
3840
3841 func (o *InternetOp) transformMonitorRouterResults(data []byte) (*internetMonitorRouterResult, error) {
3842 nakedResponse := &internetMonitorRouterResponseEnvelope{}
3843 if err := json.Unmarshal(data, nakedResponse); err != nil {
3844 return nil, err
3845 }
3846
3847 results := &internetMonitorRouterResult{}
3848 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3849 return nil, err
3850 }
3851 return results, nil
3852 }
3853
3854 func (o *InternetOp) transformEnableIPv6Results(data []byte) (*internetEnableIPv6Result, error) {
3855 nakedResponse := &internetEnableIPv6ResponseEnvelope{}
3856 if err := json.Unmarshal(data, nakedResponse); err != nil {
3857 return nil, err
3858 }
3859
3860 results := &internetEnableIPv6Result{}
3861 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3862 return nil, err
3863 }
3864 return results, nil
3865 }
3866
3867 func (o *InternetPlanOp) transformFindArgs(conditions *FindCondition) (*internetPlanFindRequestEnvelope, error) {
3868 if conditions == nil {
3869 conditions = &FindCondition{}
3870 }
3871 var arg0 interface{} = conditions
3872 if v, ok := arg0.(argumentDefaulter); ok {
3873 arg0 = v.setDefaults()
3874 }
3875 args := &struct {
3876 Arg0 interface{} `mapconv:",squash"`
3877 }{
3878 Arg0: arg0,
3879 }
3880
3881 v := &internetPlanFindRequestEnvelope{}
3882 if err := mapconv.ConvertTo(args, v); err != nil {
3883 return nil, err
3884 }
3885 return v, nil
3886 }
3887
3888 func (o *InternetPlanOp) transformFindResults(data []byte) (*InternetPlanFindResult, error) {
3889 nakedResponse := &internetPlanFindResponseEnvelope{}
3890 if err := json.Unmarshal(data, nakedResponse); err != nil {
3891 return nil, err
3892 }
3893
3894 results := &InternetPlanFindResult{}
3895 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3896 return nil, err
3897 }
3898 return results, nil
3899 }
3900
3901 func (o *InternetPlanOp) transformReadResults(data []byte) (*internetPlanReadResult, error) {
3902 nakedResponse := &internetPlanReadResponseEnvelope{}
3903 if err := json.Unmarshal(data, nakedResponse); err != nil {
3904 return nil, err
3905 }
3906
3907 results := &internetPlanReadResult{}
3908 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3909 return nil, err
3910 }
3911 return results, nil
3912 }
3913
3914 func (o *IPAddressOp) transformListResults(data []byte) (*IPAddressListResult, error) {
3915 nakedResponse := &iPAddressListResponseEnvelope{}
3916 if err := json.Unmarshal(data, nakedResponse); err != nil {
3917 return nil, err
3918 }
3919
3920 results := &IPAddressListResult{}
3921 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3922 return nil, err
3923 }
3924 return results, nil
3925 }
3926
3927 func (o *IPAddressOp) transformReadResults(data []byte) (*iPAddressReadResult, error) {
3928 nakedResponse := &iPAddressReadResponseEnvelope{}
3929 if err := json.Unmarshal(data, nakedResponse); err != nil {
3930 return nil, err
3931 }
3932
3933 results := &iPAddressReadResult{}
3934 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3935 return nil, err
3936 }
3937 return results, nil
3938 }
3939
3940 func (o *IPAddressOp) transformUpdateHostNameArgs(ipAddress string, hostName string) (*iPAddressUpdateHostNameRequestEnvelope, error) {
3941 if ipAddress == "" {
3942 ipAddress = ""
3943 }
3944 var arg0 interface{} = ipAddress
3945 if v, ok := arg0.(argumentDefaulter); ok {
3946 arg0 = v.setDefaults()
3947 }
3948 if hostName == "" {
3949 hostName = ""
3950 }
3951 var arg1 interface{} = hostName
3952 if v, ok := arg1.(argumentDefaulter); ok {
3953 arg1 = v.setDefaults()
3954 }
3955 args := &struct {
3956 Arg0 interface{}
3957 Arg1 interface{} `mapconv:"IPAddress.HostName"`
3958 }{
3959 Arg0: arg0,
3960 Arg1: arg1,
3961 }
3962
3963 v := &iPAddressUpdateHostNameRequestEnvelope{}
3964 if err := mapconv.ConvertTo(args, v); err != nil {
3965 return nil, err
3966 }
3967 return v, nil
3968 }
3969
3970 func (o *IPAddressOp) transformUpdateHostNameResults(data []byte) (*iPAddressUpdateHostNameResult, error) {
3971 nakedResponse := &iPAddressUpdateHostNameResponseEnvelope{}
3972 if err := json.Unmarshal(data, nakedResponse); err != nil {
3973 return nil, err
3974 }
3975
3976 results := &iPAddressUpdateHostNameResult{}
3977 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3978 return nil, err
3979 }
3980 return results, nil
3981 }
3982
3983 func (o *IPv6NetOp) transformListResults(data []byte) (*IPv6NetListResult, error) {
3984 nakedResponse := &iPv6NetListResponseEnvelope{}
3985 if err := json.Unmarshal(data, nakedResponse); err != nil {
3986 return nil, err
3987 }
3988
3989 results := &IPv6NetListResult{}
3990 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
3991 return nil, err
3992 }
3993 return results, nil
3994 }
3995
3996 func (o *IPv6NetOp) transformFindArgs(conditions *FindCondition) (*iPv6NetFindRequestEnvelope, error) {
3997 if conditions == nil {
3998 conditions = &FindCondition{}
3999 }
4000 var arg0 interface{} = conditions
4001 if v, ok := arg0.(argumentDefaulter); ok {
4002 arg0 = v.setDefaults()
4003 }
4004 args := &struct {
4005 Arg0 interface{} `mapconv:",squash"`
4006 }{
4007 Arg0: arg0,
4008 }
4009
4010 v := &iPv6NetFindRequestEnvelope{}
4011 if err := mapconv.ConvertTo(args, v); err != nil {
4012 return nil, err
4013 }
4014 return v, nil
4015 }
4016
4017 func (o *IPv6NetOp) transformFindResults(data []byte) (*IPv6NetFindResult, error) {
4018 nakedResponse := &iPv6NetFindResponseEnvelope{}
4019 if err := json.Unmarshal(data, nakedResponse); err != nil {
4020 return nil, err
4021 }
4022
4023 results := &IPv6NetFindResult{}
4024 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4025 return nil, err
4026 }
4027 return results, nil
4028 }
4029
4030 func (o *IPv6NetOp) transformReadResults(data []byte) (*iPv6NetReadResult, error) {
4031 nakedResponse := &iPv6NetReadResponseEnvelope{}
4032 if err := json.Unmarshal(data, nakedResponse); err != nil {
4033 return nil, err
4034 }
4035
4036 results := &iPv6NetReadResult{}
4037 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4038 return nil, err
4039 }
4040 return results, nil
4041 }
4042
4043 func (o *IPv6AddrOp) transformFindArgs(conditions *FindCondition) (*iPv6AddrFindRequestEnvelope, error) {
4044 if conditions == nil {
4045 conditions = &FindCondition{}
4046 }
4047 var arg0 interface{} = conditions
4048 if v, ok := arg0.(argumentDefaulter); ok {
4049 arg0 = v.setDefaults()
4050 }
4051 args := &struct {
4052 Arg0 interface{} `mapconv:",squash"`
4053 }{
4054 Arg0: arg0,
4055 }
4056
4057 v := &iPv6AddrFindRequestEnvelope{}
4058 if err := mapconv.ConvertTo(args, v); err != nil {
4059 return nil, err
4060 }
4061 return v, nil
4062 }
4063
4064 func (o *IPv6AddrOp) transformFindResults(data []byte) (*IPv6AddrFindResult, error) {
4065 nakedResponse := &iPv6AddrFindResponseEnvelope{}
4066 if err := json.Unmarshal(data, nakedResponse); err != nil {
4067 return nil, err
4068 }
4069
4070 results := &IPv6AddrFindResult{}
4071 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4072 return nil, err
4073 }
4074 return results, nil
4075 }
4076
4077 func (o *IPv6AddrOp) transformCreateArgs(param *IPv6AddrCreateRequest) (*iPv6AddrCreateRequestEnvelope, error) {
4078 if param == nil {
4079 param = &IPv6AddrCreateRequest{}
4080 }
4081 var arg0 interface{} = param
4082 if v, ok := arg0.(argumentDefaulter); ok {
4083 arg0 = v.setDefaults()
4084 }
4085 args := &struct {
4086 Arg0 interface{} `mapconv:"IPv6Addr,recursive"`
4087 }{
4088 Arg0: arg0,
4089 }
4090
4091 v := &iPv6AddrCreateRequestEnvelope{}
4092 if err := mapconv.ConvertTo(args, v); err != nil {
4093 return nil, err
4094 }
4095 return v, nil
4096 }
4097
4098 func (o *IPv6AddrOp) transformCreateResults(data []byte) (*iPv6AddrCreateResult, error) {
4099 nakedResponse := &iPv6AddrCreateResponseEnvelope{}
4100 if err := json.Unmarshal(data, nakedResponse); err != nil {
4101 return nil, err
4102 }
4103
4104 results := &iPv6AddrCreateResult{}
4105 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4106 return nil, err
4107 }
4108 return results, nil
4109 }
4110
4111 func (o *IPv6AddrOp) transformReadResults(data []byte) (*iPv6AddrReadResult, error) {
4112 nakedResponse := &iPv6AddrReadResponseEnvelope{}
4113 if err := json.Unmarshal(data, nakedResponse); err != nil {
4114 return nil, err
4115 }
4116
4117 results := &iPv6AddrReadResult{}
4118 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4119 return nil, err
4120 }
4121 return results, nil
4122 }
4123
4124 func (o *IPv6AddrOp) transformUpdateArgs(ipv6addr string, param *IPv6AddrUpdateRequest) (*iPv6AddrUpdateRequestEnvelope, error) {
4125 if ipv6addr == "" {
4126 ipv6addr = ""
4127 }
4128 var arg0 interface{} = ipv6addr
4129 if v, ok := arg0.(argumentDefaulter); ok {
4130 arg0 = v.setDefaults()
4131 }
4132 if param == nil {
4133 param = &IPv6AddrUpdateRequest{}
4134 }
4135 var arg1 interface{} = param
4136 if v, ok := arg1.(argumentDefaulter); ok {
4137 arg1 = v.setDefaults()
4138 }
4139 args := &struct {
4140 Arg0 interface{}
4141 Arg1 interface{} `mapconv:"IPv6Addr,recursive"`
4142 }{
4143 Arg0: arg0,
4144 Arg1: arg1,
4145 }
4146
4147 v := &iPv6AddrUpdateRequestEnvelope{}
4148 if err := mapconv.ConvertTo(args, v); err != nil {
4149 return nil, err
4150 }
4151 return v, nil
4152 }
4153
4154 func (o *IPv6AddrOp) transformUpdateResults(data []byte) (*iPv6AddrUpdateResult, error) {
4155 nakedResponse := &iPv6AddrUpdateResponseEnvelope{}
4156 if err := json.Unmarshal(data, nakedResponse); err != nil {
4157 return nil, err
4158 }
4159
4160 results := &iPv6AddrUpdateResult{}
4161 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4162 return nil, err
4163 }
4164 return results, nil
4165 }
4166
4167 func (o *LicenseOp) transformFindArgs(conditions *FindCondition) (*licenseFindRequestEnvelope, error) {
4168 if conditions == nil {
4169 conditions = &FindCondition{}
4170 }
4171 var arg0 interface{} = conditions
4172 if v, ok := arg0.(argumentDefaulter); ok {
4173 arg0 = v.setDefaults()
4174 }
4175 args := &struct {
4176 Arg0 interface{} `mapconv:",squash"`
4177 }{
4178 Arg0: arg0,
4179 }
4180
4181 v := &licenseFindRequestEnvelope{}
4182 if err := mapconv.ConvertTo(args, v); err != nil {
4183 return nil, err
4184 }
4185 return v, nil
4186 }
4187
4188 func (o *LicenseOp) transformFindResults(data []byte) (*LicenseFindResult, error) {
4189 nakedResponse := &licenseFindResponseEnvelope{}
4190 if err := json.Unmarshal(data, nakedResponse); err != nil {
4191 return nil, err
4192 }
4193
4194 results := &LicenseFindResult{}
4195 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4196 return nil, err
4197 }
4198 return results, nil
4199 }
4200
4201 func (o *LicenseOp) transformCreateArgs(param *LicenseCreateRequest) (*licenseCreateRequestEnvelope, error) {
4202 if param == nil {
4203 param = &LicenseCreateRequest{}
4204 }
4205 var arg0 interface{} = param
4206 if v, ok := arg0.(argumentDefaulter); ok {
4207 arg0 = v.setDefaults()
4208 }
4209 args := &struct {
4210 Arg0 interface{} `mapconv:"License,recursive"`
4211 }{
4212 Arg0: arg0,
4213 }
4214
4215 v := &licenseCreateRequestEnvelope{}
4216 if err := mapconv.ConvertTo(args, v); err != nil {
4217 return nil, err
4218 }
4219 return v, nil
4220 }
4221
4222 func (o *LicenseOp) transformCreateResults(data []byte) (*licenseCreateResult, error) {
4223 nakedResponse := &licenseCreateResponseEnvelope{}
4224 if err := json.Unmarshal(data, nakedResponse); err != nil {
4225 return nil, err
4226 }
4227
4228 results := &licenseCreateResult{}
4229 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4230 return nil, err
4231 }
4232 return results, nil
4233 }
4234
4235 func (o *LicenseOp) transformReadResults(data []byte) (*licenseReadResult, error) {
4236 nakedResponse := &licenseReadResponseEnvelope{}
4237 if err := json.Unmarshal(data, nakedResponse); err != nil {
4238 return nil, err
4239 }
4240
4241 results := &licenseReadResult{}
4242 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4243 return nil, err
4244 }
4245 return results, nil
4246 }
4247
4248 func (o *LicenseOp) transformUpdateArgs(id types.ID, param *LicenseUpdateRequest) (*licenseUpdateRequestEnvelope, error) {
4249 if id == types.ID(int64(0)) {
4250 id = types.ID(int64(0))
4251 }
4252 var arg0 interface{} = id
4253 if v, ok := arg0.(argumentDefaulter); ok {
4254 arg0 = v.setDefaults()
4255 }
4256 if param == nil {
4257 param = &LicenseUpdateRequest{}
4258 }
4259 var arg1 interface{} = param
4260 if v, ok := arg1.(argumentDefaulter); ok {
4261 arg1 = v.setDefaults()
4262 }
4263 args := &struct {
4264 Arg0 interface{}
4265 Arg1 interface{} `mapconv:"License,recursive"`
4266 }{
4267 Arg0: arg0,
4268 Arg1: arg1,
4269 }
4270
4271 v := &licenseUpdateRequestEnvelope{}
4272 if err := mapconv.ConvertTo(args, v); err != nil {
4273 return nil, err
4274 }
4275 return v, nil
4276 }
4277
4278 func (o *LicenseOp) transformUpdateResults(data []byte) (*licenseUpdateResult, error) {
4279 nakedResponse := &licenseUpdateResponseEnvelope{}
4280 if err := json.Unmarshal(data, nakedResponse); err != nil {
4281 return nil, err
4282 }
4283
4284 results := &licenseUpdateResult{}
4285 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4286 return nil, err
4287 }
4288 return results, nil
4289 }
4290
4291 func (o *LicenseInfoOp) transformFindArgs(conditions *FindCondition) (*licenseInfoFindRequestEnvelope, error) {
4292 if conditions == nil {
4293 conditions = &FindCondition{}
4294 }
4295 var arg0 interface{} = conditions
4296 if v, ok := arg0.(argumentDefaulter); ok {
4297 arg0 = v.setDefaults()
4298 }
4299 args := &struct {
4300 Arg0 interface{} `mapconv:",squash"`
4301 }{
4302 Arg0: arg0,
4303 }
4304
4305 v := &licenseInfoFindRequestEnvelope{}
4306 if err := mapconv.ConvertTo(args, v); err != nil {
4307 return nil, err
4308 }
4309 return v, nil
4310 }
4311
4312 func (o *LicenseInfoOp) transformFindResults(data []byte) (*LicenseInfoFindResult, error) {
4313 nakedResponse := &licenseInfoFindResponseEnvelope{}
4314 if err := json.Unmarshal(data, nakedResponse); err != nil {
4315 return nil, err
4316 }
4317
4318 results := &LicenseInfoFindResult{}
4319 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4320 return nil, err
4321 }
4322 return results, nil
4323 }
4324
4325 func (o *LicenseInfoOp) transformReadResults(data []byte) (*licenseInfoReadResult, error) {
4326 nakedResponse := &licenseInfoReadResponseEnvelope{}
4327 if err := json.Unmarshal(data, nakedResponse); err != nil {
4328 return nil, err
4329 }
4330
4331 results := &licenseInfoReadResult{}
4332 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4333 return nil, err
4334 }
4335 return results, nil
4336 }
4337
4338 func (o *LoadBalancerOp) transformFindArgs(conditions *FindCondition) (*loadBalancerFindRequestEnvelope, error) {
4339 if conditions == nil {
4340 conditions = &FindCondition{}
4341 }
4342 var arg0 interface{} = conditions
4343 if v, ok := arg0.(argumentDefaulter); ok {
4344 arg0 = v.setDefaults()
4345 }
4346 args := &struct {
4347 Arg0 interface{} `mapconv:",squash"`
4348 }{
4349 Arg0: arg0,
4350 }
4351
4352 v := &loadBalancerFindRequestEnvelope{}
4353 if err := mapconv.ConvertTo(args, v); err != nil {
4354 return nil, err
4355 }
4356 return v, nil
4357 }
4358
4359 func (o *LoadBalancerOp) transformFindResults(data []byte) (*LoadBalancerFindResult, error) {
4360 nakedResponse := &loadBalancerFindResponseEnvelope{}
4361 if err := json.Unmarshal(data, nakedResponse); err != nil {
4362 return nil, err
4363 }
4364
4365 results := &LoadBalancerFindResult{}
4366 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4367 return nil, err
4368 }
4369 return results, nil
4370 }
4371
4372 func (o *LoadBalancerOp) transformCreateArgs(param *LoadBalancerCreateRequest) (*loadBalancerCreateRequestEnvelope, error) {
4373 if param == nil {
4374 param = &LoadBalancerCreateRequest{}
4375 }
4376 var arg0 interface{} = param
4377 if v, ok := arg0.(argumentDefaulter); ok {
4378 arg0 = v.setDefaults()
4379 }
4380 args := &struct {
4381 Arg0 interface{} `mapconv:"Appliance,recursive"`
4382 }{
4383 Arg0: arg0,
4384 }
4385
4386 v := &loadBalancerCreateRequestEnvelope{}
4387 if err := mapconv.ConvertTo(args, v); err != nil {
4388 return nil, err
4389 }
4390 return v, nil
4391 }
4392
4393 func (o *LoadBalancerOp) transformCreateResults(data []byte) (*loadBalancerCreateResult, error) {
4394 nakedResponse := &loadBalancerCreateResponseEnvelope{}
4395 if err := json.Unmarshal(data, nakedResponse); err != nil {
4396 return nil, err
4397 }
4398
4399 results := &loadBalancerCreateResult{}
4400 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4401 return nil, err
4402 }
4403 return results, nil
4404 }
4405
4406 func (o *LoadBalancerOp) transformReadResults(data []byte) (*loadBalancerReadResult, error) {
4407 nakedResponse := &loadBalancerReadResponseEnvelope{}
4408 if err := json.Unmarshal(data, nakedResponse); err != nil {
4409 return nil, err
4410 }
4411
4412 results := &loadBalancerReadResult{}
4413 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4414 return nil, err
4415 }
4416 return results, nil
4417 }
4418
4419 func (o *LoadBalancerOp) transformUpdateArgs(id types.ID, param *LoadBalancerUpdateRequest) (*loadBalancerUpdateRequestEnvelope, error) {
4420 if id == types.ID(int64(0)) {
4421 id = types.ID(int64(0))
4422 }
4423 var arg0 interface{} = id
4424 if v, ok := arg0.(argumentDefaulter); ok {
4425 arg0 = v.setDefaults()
4426 }
4427 if param == nil {
4428 param = &LoadBalancerUpdateRequest{}
4429 }
4430 var arg1 interface{} = param
4431 if v, ok := arg1.(argumentDefaulter); ok {
4432 arg1 = v.setDefaults()
4433 }
4434 args := &struct {
4435 Arg0 interface{}
4436 Arg1 interface{} `mapconv:"Appliance,recursive"`
4437 }{
4438 Arg0: arg0,
4439 Arg1: arg1,
4440 }
4441
4442 v := &loadBalancerUpdateRequestEnvelope{}
4443 if err := mapconv.ConvertTo(args, v); err != nil {
4444 return nil, err
4445 }
4446 return v, nil
4447 }
4448
4449 func (o *LoadBalancerOp) transformUpdateResults(data []byte) (*loadBalancerUpdateResult, error) {
4450 nakedResponse := &loadBalancerUpdateResponseEnvelope{}
4451 if err := json.Unmarshal(data, nakedResponse); err != nil {
4452 return nil, err
4453 }
4454
4455 results := &loadBalancerUpdateResult{}
4456 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4457 return nil, err
4458 }
4459 return results, nil
4460 }
4461
4462 func (o *LoadBalancerOp) transformUpdateSettingsArgs(id types.ID, param *LoadBalancerUpdateSettingsRequest) (*loadBalancerUpdateSettingsRequestEnvelope, error) {
4463 if id == types.ID(int64(0)) {
4464 id = types.ID(int64(0))
4465 }
4466 var arg0 interface{} = id
4467 if v, ok := arg0.(argumentDefaulter); ok {
4468 arg0 = v.setDefaults()
4469 }
4470 if param == nil {
4471 param = &LoadBalancerUpdateSettingsRequest{}
4472 }
4473 var arg1 interface{} = param
4474 if v, ok := arg1.(argumentDefaulter); ok {
4475 arg1 = v.setDefaults()
4476 }
4477 args := &struct {
4478 Arg0 interface{}
4479 Arg1 interface{} `mapconv:"Appliance,recursive"`
4480 }{
4481 Arg0: arg0,
4482 Arg1: arg1,
4483 }
4484
4485 v := &loadBalancerUpdateSettingsRequestEnvelope{}
4486 if err := mapconv.ConvertTo(args, v); err != nil {
4487 return nil, err
4488 }
4489 return v, nil
4490 }
4491
4492 func (o *LoadBalancerOp) transformUpdateSettingsResults(data []byte) (*loadBalancerUpdateSettingsResult, error) {
4493 nakedResponse := &loadBalancerUpdateSettingsResponseEnvelope{}
4494 if err := json.Unmarshal(data, nakedResponse); err != nil {
4495 return nil, err
4496 }
4497
4498 results := &loadBalancerUpdateSettingsResult{}
4499 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4500 return nil, err
4501 }
4502 return results, nil
4503 }
4504
4505 func (o *LoadBalancerOp) transformShutdownArgs(id types.ID, shutdownOption *ShutdownOption) (*loadBalancerShutdownRequestEnvelope, error) {
4506 if id == types.ID(int64(0)) {
4507 id = types.ID(int64(0))
4508 }
4509 var arg0 interface{} = id
4510 if v, ok := arg0.(argumentDefaulter); ok {
4511 arg0 = v.setDefaults()
4512 }
4513 if shutdownOption == nil {
4514 shutdownOption = &ShutdownOption{}
4515 }
4516 var arg1 interface{} = shutdownOption
4517 if v, ok := arg1.(argumentDefaulter); ok {
4518 arg1 = v.setDefaults()
4519 }
4520 args := &struct {
4521 Arg0 interface{}
4522 Arg1 interface{} `mapconv:",squash"`
4523 }{
4524 Arg0: arg0,
4525 Arg1: arg1,
4526 }
4527
4528 v := &loadBalancerShutdownRequestEnvelope{}
4529 if err := mapconv.ConvertTo(args, v); err != nil {
4530 return nil, err
4531 }
4532 return v, nil
4533 }
4534
4535 func (o *LoadBalancerOp) transformMonitorCPUArgs(id types.ID, condition *MonitorCondition) (*loadBalancerMonitorCPURequestEnvelope, error) {
4536 if id == types.ID(int64(0)) {
4537 id = types.ID(int64(0))
4538 }
4539 var arg0 interface{} = id
4540 if v, ok := arg0.(argumentDefaulter); ok {
4541 arg0 = v.setDefaults()
4542 }
4543 if condition == nil {
4544 condition = &MonitorCondition{}
4545 }
4546 var arg1 interface{} = condition
4547 if v, ok := arg1.(argumentDefaulter); ok {
4548 arg1 = v.setDefaults()
4549 }
4550 args := &struct {
4551 Arg0 interface{}
4552 Arg1 interface{} `mapconv:",squash"`
4553 }{
4554 Arg0: arg0,
4555 Arg1: arg1,
4556 }
4557
4558 v := &loadBalancerMonitorCPURequestEnvelope{}
4559 if err := mapconv.ConvertTo(args, v); err != nil {
4560 return nil, err
4561 }
4562 return v, nil
4563 }
4564
4565 func (o *LoadBalancerOp) transformMonitorCPUResults(data []byte) (*loadBalancerMonitorCPUResult, error) {
4566 nakedResponse := &loadBalancerMonitorCPUResponseEnvelope{}
4567 if err := json.Unmarshal(data, nakedResponse); err != nil {
4568 return nil, err
4569 }
4570
4571 results := &loadBalancerMonitorCPUResult{}
4572 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4573 return nil, err
4574 }
4575 return results, nil
4576 }
4577
4578 func (o *LoadBalancerOp) transformMonitorInterfaceArgs(id types.ID, condition *MonitorCondition) (*loadBalancerMonitorInterfaceRequestEnvelope, error) {
4579 if id == types.ID(int64(0)) {
4580 id = types.ID(int64(0))
4581 }
4582 var arg0 interface{} = id
4583 if v, ok := arg0.(argumentDefaulter); ok {
4584 arg0 = v.setDefaults()
4585 }
4586 if condition == nil {
4587 condition = &MonitorCondition{}
4588 }
4589 var arg1 interface{} = condition
4590 if v, ok := arg1.(argumentDefaulter); ok {
4591 arg1 = v.setDefaults()
4592 }
4593 args := &struct {
4594 Arg0 interface{}
4595 Arg1 interface{} `mapconv:",squash"`
4596 }{
4597 Arg0: arg0,
4598 Arg1: arg1,
4599 }
4600
4601 v := &loadBalancerMonitorInterfaceRequestEnvelope{}
4602 if err := mapconv.ConvertTo(args, v); err != nil {
4603 return nil, err
4604 }
4605 return v, nil
4606 }
4607
4608 func (o *LoadBalancerOp) transformMonitorInterfaceResults(data []byte) (*loadBalancerMonitorInterfaceResult, error) {
4609 nakedResponse := &loadBalancerMonitorInterfaceResponseEnvelope{}
4610 if err := json.Unmarshal(data, nakedResponse); err != nil {
4611 return nil, err
4612 }
4613
4614 results := &loadBalancerMonitorInterfaceResult{}
4615 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4616 return nil, err
4617 }
4618 return results, nil
4619 }
4620
4621 func (o *LoadBalancerOp) transformStatusResults(data []byte) (*LoadBalancerStatusResult, error) {
4622 nakedResponse := &loadBalancerStatusResponseEnvelope{}
4623 if err := json.Unmarshal(data, nakedResponse); err != nil {
4624 return nil, err
4625 }
4626
4627 results := &LoadBalancerStatusResult{}
4628 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4629 return nil, err
4630 }
4631 return results, nil
4632 }
4633
4634 func (o *LocalRouterOp) transformFindArgs(conditions *FindCondition) (*localRouterFindRequestEnvelope, error) {
4635 if conditions == nil {
4636 conditions = &FindCondition{}
4637 }
4638 var arg0 interface{} = conditions
4639 if v, ok := arg0.(argumentDefaulter); ok {
4640 arg0 = v.setDefaults()
4641 }
4642 args := &struct {
4643 Arg0 interface{} `mapconv:",squash"`
4644 }{
4645 Arg0: arg0,
4646 }
4647
4648 v := &localRouterFindRequestEnvelope{}
4649 if err := mapconv.ConvertTo(args, v); err != nil {
4650 return nil, err
4651 }
4652 return v, nil
4653 }
4654
4655 func (o *LocalRouterOp) transformFindResults(data []byte) (*LocalRouterFindResult, error) {
4656 nakedResponse := &localRouterFindResponseEnvelope{}
4657 if err := json.Unmarshal(data, nakedResponse); err != nil {
4658 return nil, err
4659 }
4660
4661 results := &LocalRouterFindResult{}
4662 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4663 return nil, err
4664 }
4665 return results, nil
4666 }
4667
4668 func (o *LocalRouterOp) transformCreateArgs(param *LocalRouterCreateRequest) (*localRouterCreateRequestEnvelope, error) {
4669 if param == nil {
4670 param = &LocalRouterCreateRequest{}
4671 }
4672 var arg0 interface{} = param
4673 if v, ok := arg0.(argumentDefaulter); ok {
4674 arg0 = v.setDefaults()
4675 }
4676 args := &struct {
4677 Arg0 interface{} `mapconv:"CommonServiceItem,recursive"`
4678 }{
4679 Arg0: arg0,
4680 }
4681
4682 v := &localRouterCreateRequestEnvelope{}
4683 if err := mapconv.ConvertTo(args, v); err != nil {
4684 return nil, err
4685 }
4686 return v, nil
4687 }
4688
4689 func (o *LocalRouterOp) transformCreateResults(data []byte) (*localRouterCreateResult, error) {
4690 nakedResponse := &localRouterCreateResponseEnvelope{}
4691 if err := json.Unmarshal(data, nakedResponse); err != nil {
4692 return nil, err
4693 }
4694
4695 results := &localRouterCreateResult{}
4696 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4697 return nil, err
4698 }
4699 return results, nil
4700 }
4701
4702 func (o *LocalRouterOp) transformReadResults(data []byte) (*localRouterReadResult, error) {
4703 nakedResponse := &localRouterReadResponseEnvelope{}
4704 if err := json.Unmarshal(data, nakedResponse); err != nil {
4705 return nil, err
4706 }
4707
4708 results := &localRouterReadResult{}
4709 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4710 return nil, err
4711 }
4712 return results, nil
4713 }
4714
4715 func (o *LocalRouterOp) transformUpdateArgs(id types.ID, param *LocalRouterUpdateRequest) (*localRouterUpdateRequestEnvelope, error) {
4716 if id == types.ID(int64(0)) {
4717 id = types.ID(int64(0))
4718 }
4719 var arg0 interface{} = id
4720 if v, ok := arg0.(argumentDefaulter); ok {
4721 arg0 = v.setDefaults()
4722 }
4723 if param == nil {
4724 param = &LocalRouterUpdateRequest{}
4725 }
4726 var arg1 interface{} = param
4727 if v, ok := arg1.(argumentDefaulter); ok {
4728 arg1 = v.setDefaults()
4729 }
4730 args := &struct {
4731 Arg0 interface{}
4732 Arg1 interface{} `mapconv:"CommonServiceItem,recursive"`
4733 }{
4734 Arg0: arg0,
4735 Arg1: arg1,
4736 }
4737
4738 v := &localRouterUpdateRequestEnvelope{}
4739 if err := mapconv.ConvertTo(args, v); err != nil {
4740 return nil, err
4741 }
4742 return v, nil
4743 }
4744
4745 func (o *LocalRouterOp) transformUpdateResults(data []byte) (*localRouterUpdateResult, error) {
4746 nakedResponse := &localRouterUpdateResponseEnvelope{}
4747 if err := json.Unmarshal(data, nakedResponse); err != nil {
4748 return nil, err
4749 }
4750
4751 results := &localRouterUpdateResult{}
4752 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4753 return nil, err
4754 }
4755 return results, nil
4756 }
4757
4758 func (o *LocalRouterOp) transformUpdateSettingsArgs(id types.ID, param *LocalRouterUpdateSettingsRequest) (*localRouterUpdateSettingsRequestEnvelope, error) {
4759 if id == types.ID(int64(0)) {
4760 id = types.ID(int64(0))
4761 }
4762 var arg0 interface{} = id
4763 if v, ok := arg0.(argumentDefaulter); ok {
4764 arg0 = v.setDefaults()
4765 }
4766 if param == nil {
4767 param = &LocalRouterUpdateSettingsRequest{}
4768 }
4769 var arg1 interface{} = param
4770 if v, ok := arg1.(argumentDefaulter); ok {
4771 arg1 = v.setDefaults()
4772 }
4773 args := &struct {
4774 Arg0 interface{}
4775 Arg1 interface{} `mapconv:"CommonServiceItem,recursive"`
4776 }{
4777 Arg0: arg0,
4778 Arg1: arg1,
4779 }
4780
4781 v := &localRouterUpdateSettingsRequestEnvelope{}
4782 if err := mapconv.ConvertTo(args, v); err != nil {
4783 return nil, err
4784 }
4785 return v, nil
4786 }
4787
4788 func (o *LocalRouterOp) transformUpdateSettingsResults(data []byte) (*localRouterUpdateSettingsResult, error) {
4789 nakedResponse := &localRouterUpdateSettingsResponseEnvelope{}
4790 if err := json.Unmarshal(data, nakedResponse); err != nil {
4791 return nil, err
4792 }
4793
4794 results := &localRouterUpdateSettingsResult{}
4795 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4796 return nil, err
4797 }
4798 return results, nil
4799 }
4800
4801 func (o *LocalRouterOp) transformHealthStatusResults(data []byte) (*localRouterHealthStatusResult, error) {
4802 nakedResponse := &localRouterHealthStatusResponseEnvelope{}
4803 if err := json.Unmarshal(data, nakedResponse); err != nil {
4804 return nil, err
4805 }
4806
4807 results := &localRouterHealthStatusResult{}
4808 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4809 return nil, err
4810 }
4811 return results, nil
4812 }
4813
4814 func (o *LocalRouterOp) transformMonitorLocalRouterArgs(id types.ID, condition *MonitorCondition) (*localRouterMonitorLocalRouterRequestEnvelope, error) {
4815 if id == types.ID(int64(0)) {
4816 id = types.ID(int64(0))
4817 }
4818 var arg0 interface{} = id
4819 if v, ok := arg0.(argumentDefaulter); ok {
4820 arg0 = v.setDefaults()
4821 }
4822 if condition == nil {
4823 condition = &MonitorCondition{}
4824 }
4825 var arg1 interface{} = condition
4826 if v, ok := arg1.(argumentDefaulter); ok {
4827 arg1 = v.setDefaults()
4828 }
4829 args := &struct {
4830 Arg0 interface{}
4831 Arg1 interface{} `mapconv:",squash"`
4832 }{
4833 Arg0: arg0,
4834 Arg1: arg1,
4835 }
4836
4837 v := &localRouterMonitorLocalRouterRequestEnvelope{}
4838 if err := mapconv.ConvertTo(args, v); err != nil {
4839 return nil, err
4840 }
4841 return v, nil
4842 }
4843
4844 func (o *LocalRouterOp) transformMonitorLocalRouterResults(data []byte) (*localRouterMonitorLocalRouterResult, error) {
4845 nakedResponse := &localRouterMonitorLocalRouterResponseEnvelope{}
4846 if err := json.Unmarshal(data, nakedResponse); err != nil {
4847 return nil, err
4848 }
4849
4850 results := &localRouterMonitorLocalRouterResult{}
4851 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4852 return nil, err
4853 }
4854 return results, nil
4855 }
4856
4857 func (o *MobileGatewayOp) transformFindArgs(conditions *FindCondition) (*mobileGatewayFindRequestEnvelope, error) {
4858 if conditions == nil {
4859 conditions = &FindCondition{}
4860 }
4861 var arg0 interface{} = conditions
4862 if v, ok := arg0.(argumentDefaulter); ok {
4863 arg0 = v.setDefaults()
4864 }
4865 args := &struct {
4866 Arg0 interface{} `mapconv:",squash"`
4867 }{
4868 Arg0: arg0,
4869 }
4870
4871 v := &mobileGatewayFindRequestEnvelope{}
4872 if err := mapconv.ConvertTo(args, v); err != nil {
4873 return nil, err
4874 }
4875 return v, nil
4876 }
4877
4878 func (o *MobileGatewayOp) transformFindResults(data []byte) (*MobileGatewayFindResult, error) {
4879 nakedResponse := &mobileGatewayFindResponseEnvelope{}
4880 if err := json.Unmarshal(data, nakedResponse); err != nil {
4881 return nil, err
4882 }
4883
4884 results := &MobileGatewayFindResult{}
4885 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4886 return nil, err
4887 }
4888 return results, nil
4889 }
4890
4891 func (o *MobileGatewayOp) transformCreateArgs(param *MobileGatewayCreateRequest) (*mobileGatewayCreateRequestEnvelope, error) {
4892 if param == nil {
4893 param = &MobileGatewayCreateRequest{}
4894 }
4895 var arg0 interface{} = param
4896 if v, ok := arg0.(argumentDefaulter); ok {
4897 arg0 = v.setDefaults()
4898 }
4899 args := &struct {
4900 Arg0 interface{} `mapconv:"Appliance,recursive"`
4901 }{
4902 Arg0: arg0,
4903 }
4904
4905 v := &mobileGatewayCreateRequestEnvelope{}
4906 if err := mapconv.ConvertTo(args, v); err != nil {
4907 return nil, err
4908 }
4909 return v, nil
4910 }
4911
4912 func (o *MobileGatewayOp) transformCreateResults(data []byte) (*mobileGatewayCreateResult, error) {
4913 nakedResponse := &mobileGatewayCreateResponseEnvelope{}
4914 if err := json.Unmarshal(data, nakedResponse); err != nil {
4915 return nil, err
4916 }
4917
4918 results := &mobileGatewayCreateResult{}
4919 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4920 return nil, err
4921 }
4922 return results, nil
4923 }
4924
4925 func (o *MobileGatewayOp) transformReadResults(data []byte) (*mobileGatewayReadResult, error) {
4926 nakedResponse := &mobileGatewayReadResponseEnvelope{}
4927 if err := json.Unmarshal(data, nakedResponse); err != nil {
4928 return nil, err
4929 }
4930
4931 results := &mobileGatewayReadResult{}
4932 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4933 return nil, err
4934 }
4935 return results, nil
4936 }
4937
4938 func (o *MobileGatewayOp) transformUpdateArgs(id types.ID, param *MobileGatewayUpdateRequest) (*mobileGatewayUpdateRequestEnvelope, error) {
4939 if id == types.ID(int64(0)) {
4940 id = types.ID(int64(0))
4941 }
4942 var arg0 interface{} = id
4943 if v, ok := arg0.(argumentDefaulter); ok {
4944 arg0 = v.setDefaults()
4945 }
4946 if param == nil {
4947 param = &MobileGatewayUpdateRequest{}
4948 }
4949 var arg1 interface{} = param
4950 if v, ok := arg1.(argumentDefaulter); ok {
4951 arg1 = v.setDefaults()
4952 }
4953 args := &struct {
4954 Arg0 interface{}
4955 Arg1 interface{} `mapconv:"Appliance,recursive"`
4956 }{
4957 Arg0: arg0,
4958 Arg1: arg1,
4959 }
4960
4961 v := &mobileGatewayUpdateRequestEnvelope{}
4962 if err := mapconv.ConvertTo(args, v); err != nil {
4963 return nil, err
4964 }
4965 return v, nil
4966 }
4967
4968 func (o *MobileGatewayOp) transformUpdateResults(data []byte) (*mobileGatewayUpdateResult, error) {
4969 nakedResponse := &mobileGatewayUpdateResponseEnvelope{}
4970 if err := json.Unmarshal(data, nakedResponse); err != nil {
4971 return nil, err
4972 }
4973
4974 results := &mobileGatewayUpdateResult{}
4975 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
4976 return nil, err
4977 }
4978 return results, nil
4979 }
4980
4981 func (o *MobileGatewayOp) transformUpdateSettingsArgs(id types.ID, param *MobileGatewayUpdateSettingsRequest) (*mobileGatewayUpdateSettingsRequestEnvelope, error) {
4982 if id == types.ID(int64(0)) {
4983 id = types.ID(int64(0))
4984 }
4985 var arg0 interface{} = id
4986 if v, ok := arg0.(argumentDefaulter); ok {
4987 arg0 = v.setDefaults()
4988 }
4989 if param == nil {
4990 param = &MobileGatewayUpdateSettingsRequest{}
4991 }
4992 var arg1 interface{} = param
4993 if v, ok := arg1.(argumentDefaulter); ok {
4994 arg1 = v.setDefaults()
4995 }
4996 args := &struct {
4997 Arg0 interface{}
4998 Arg1 interface{} `mapconv:"Appliance,recursive"`
4999 }{
5000 Arg0: arg0,
5001 Arg1: arg1,
5002 }
5003
5004 v := &mobileGatewayUpdateSettingsRequestEnvelope{}
5005 if err := mapconv.ConvertTo(args, v); err != nil {
5006 return nil, err
5007 }
5008 return v, nil
5009 }
5010
5011 func (o *MobileGatewayOp) transformUpdateSettingsResults(data []byte) (*mobileGatewayUpdateSettingsResult, error) {
5012 nakedResponse := &mobileGatewayUpdateSettingsResponseEnvelope{}
5013 if err := json.Unmarshal(data, nakedResponse); err != nil {
5014 return nil, err
5015 }
5016
5017 results := &mobileGatewayUpdateSettingsResult{}
5018 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
5019 return nil, err
5020 }
5021 return results, nil
5022 }
5023
5024 func (o *MobileGatewayOp) transformShutdownArgs(id types.ID, shutdownOption *ShutdownOption) (*mobileGatewayShutdownRequestEnvelope, error) {
5025 if id == types.ID(int64(0)) {
5026 id = types.ID(int64(0))
5027 }
5028 var arg0 interface{} = id
5029 if v, ok := arg0.(argumentDefaulter); ok {
5030 arg0 = v.setDefaults()
5031 }
5032 if shutdownOption == nil {
5033 shutdownOption = &ShutdownOption{}
5034 }
5035 var arg1 interface{} = shutdownOption
5036 if v, ok := arg1.(argumentDefaulter); ok {
5037 arg1 = v.setDefaults()
5038 }
5039 args := &struct {
5040 Arg0 interface{}
5041 Arg1 interface{} `mapconv:",squash"`
5042 }{
5043 Arg0: arg0,
5044 Arg1: arg1,
5045 }
5046
5047 v := &mobileGatewayShutdownRequestEnvelope{}
5048 if err := mapconv.ConvertTo(args, v); err != nil {
5049 return nil, err
5050 }
5051 return v, nil
5052 }
5053
5054 func (o *MobileGatewayOp) transformGetDNSResults(data []byte) (*mobileGatewayGetDNSResult, error) {
5055 nakedResponse := &mobileGatewayGetDNSResponseEnvelope{}
5056 if err := json.Unmarshal(data, nakedResponse); err != nil {
5057 return nil, err
5058 }
5059
5060 results := &mobileGatewayGetDNSResult{}
5061 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
5062 return nil, err
5063 }
5064 return results, nil
5065 }
5066
5067 func (o *MobileGatewayOp) transformSetDNSArgs(id types.ID, param *MobileGatewayDNSSetting) (*mobileGatewaySetDNSRequestEnvelope, error) {
5068 if id == types.ID(int64(0)) {
5069 id = types.ID(int64(0))
5070 }
5071 var arg0 interface{} = id
5072 if v, ok := arg0.(argumentDefaulter); ok {
5073 arg0 = v.setDefaults()
5074 }
5075 if param == nil {
5076 param = &MobileGatewayDNSSetting{}
5077 }
5078 var arg1 interface{} = param
5079 if v, ok := arg1.(argumentDefaulter); ok {
5080 arg1 = v.setDefaults()
5081 }
5082 args := &struct {
5083 Arg0 interface{}
5084 Arg1 interface{} `mapconv:"SIMGroup,recursive"`
5085 }{
5086 Arg0: arg0,
5087 Arg1: arg1,
5088 }
5089
5090 v := &mobileGatewaySetDNSRequestEnvelope{}
5091 if err := mapconv.ConvertTo(args, v); err != nil {
5092 return nil, err
5093 }
5094 return v, nil
5095 }
5096
5097 func (o *MobileGatewayOp) transformGetSIMRoutesResults(data []byte) (*mobileGatewayGetSIMRoutesResult, error) {
5098 nakedResponse := &mobileGatewayGetSIMRoutesResponseEnvelope{}
5099 if err := json.Unmarshal(data, nakedResponse); err != nil {
5100 return nil, err
5101 }
5102
5103 results := &mobileGatewayGetSIMRoutesResult{}
5104 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
5105 return nil, err
5106 }
5107 return results, nil
5108 }
5109
5110 func (o *MobileGatewayOp) transformSetSIMRoutesArgs(id types.ID, param []*MobileGatewaySIMRouteParam) (*mobileGatewaySetSIMRoutesRequestEnvelope, error) {
5111 if id == types.ID(int64(0)) {
5112 id = types.ID(int64(0))
5113 }
5114 var arg0 interface{} = id
5115 if v, ok := arg0.(argumentDefaulter); ok {
5116 arg0 = v.setDefaults()
5117 }
5118 if param == nil {
5119 param = []*MobileGatewaySIMRouteParam{}
5120 }
5121 var arg1 interface{} = param
5122 if v, ok := arg1.(argumentDefaulter); ok {
5123 arg1 = v.setDefaults()
5124 }
5125 args := &struct {
5126 Arg0 interface{}
5127 Arg1 interface{} `mapconv:"[]SIMRoutes,recursive"`
5128 }{
5129 Arg0: arg0,
5130 Arg1: arg1,
5131 }
5132
5133 v := &mobileGatewaySetSIMRoutesRequestEnvelope{}
5134 if err := mapconv.ConvertTo(args, v); err != nil {
5135 return nil, err
5136 }
5137 return v, nil
5138 }
5139
5140 func (o *MobileGatewayOp) transformListSIMResults(data []byte) (*mobileGatewayListSIMResult, error) {
5141 nakedResponse := &mobileGatewayListSIMResponseEnvelope{}
5142 if err := json.Unmarshal(data, nakedResponse); err != nil {
5143 return nil, err
5144 }
5145
5146 results := &mobileGatewayListSIMResult{}
5147 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
5148 return nil, err
5149 }
5150 return results, nil
5151 }
5152
5153 func (o *MobileGatewayOp) transformAddSIMArgs(id types.ID, param *MobileGatewayAddSIMRequest) (*mobileGatewayAddSIMRequestEnvelope, error) {
5154 if id == types.ID(int64(0)) {
5155 id = types.ID(int64(0))
5156 }
5157 var arg0 interface{} = id
5158 if v, ok := arg0.(argumentDefaulter); ok {
5159 arg0 = v.setDefaults()
5160 }
5161 if param == nil {
5162 param = &MobileGatewayAddSIMRequest{}
5163 }
5164 var arg1 interface{} = param
5165 if v, ok := arg1.(argumentDefaulter); ok {
5166 arg1 = v.setDefaults()
5167 }
5168 args := &struct {
5169 Arg0 interface{}
5170 Arg1 interface{} `mapconv:"SIM,recursive"`
5171 }{
5172 Arg0: arg0,
5173 Arg1: arg1,
5174 }
5175
5176 v := &mobileGatewayAddSIMRequestEnvelope{}
5177 if err := mapconv.ConvertTo(args, v); err != nil {
5178 return nil, err
5179 }
5180 return v, nil
5181 }
5182
5183 func (o *MobileGatewayOp) transformLogsResults(data []byte) (*mobileGatewayLogsResult, error) {
5184 nakedResponse := &mobileGatewayLogsResponseEnvelope{}
5185 if err := json.Unmarshal(data, nakedResponse); err != nil {
5186 return nil, err
5187 }
5188
5189 results := &mobileGatewayLogsResult{}
5190 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
5191 return nil, err
5192 }
5193 return results, nil
5194 }
5195
5196 func (o *MobileGatewayOp) transformGetTrafficConfigResults(data []byte) (*mobileGatewayGetTrafficConfigResult, error) {
5197 nakedResponse := &mobileGatewayGetTrafficConfigResponseEnvelope{}
5198 if err := json.Unmarshal(data, nakedResponse); err != nil {
5199 return nil, err
5200 }
5201
5202 results := &mobileGatewayGetTrafficConfigResult{}
5203 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
5204 return nil, err
5205 }
5206 return results, nil
5207 }
5208
5209 func (o *MobileGatewayOp) transformSetTrafficConfigArgs(id types.ID, param *MobileGatewayTrafficControl) (*mobileGatewaySetTrafficConfigRequestEnvelope, error) {
5210 if id == types.ID(int64(0)) {
5211 id = types.ID(int64(0))
5212 }
5213 var arg0 interface{} = id
5214 if v, ok := arg0.(argumentDefaulter); ok {
5215 arg0 = v.setDefaults()
5216 }
5217 if param == nil {
5218 param = &MobileGatewayTrafficControl{}
5219 }
5220 var arg1 interface{} = param
5221 if v, ok := arg1.(argumentDefaulter); ok {
5222 arg1 = v.setDefaults()
5223 }
5224 args := &struct {
5225 Arg0 interface{}
5226 Arg1 interface{} `mapconv:"TrafficMonitoring,recursive"`
5227 }{
5228 Arg0: arg0,
5229 Arg1: arg1,
5230 }
5231
5232 v := &mobileGatewaySetTrafficConfigRequestEnvelope{}
5233 if err := mapconv.ConvertTo(args, v); err != nil {
5234 return nil, err
5235 }
5236 return v, nil
5237 }
5238
5239 func (o *MobileGatewayOp) transformTrafficStatusResults(data []byte) (*mobileGatewayTrafficStatusResult, error) {
5240 nakedResponse := &mobileGatewayTrafficStatusResponseEnvelope{}
5241 if err := json.Unmarshal(data, nakedResponse); err != nil {
5242 return nil, err
5243 }
5244
5245 results := &mobileGatewayTrafficStatusResult{}
5246 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
5247 return nil, err
5248 }
5249 return results, nil
5250 }
5251
5252 func (o *MobileGatewayOp) transformMonitorInterfaceArgs(id types.ID, index int, condition *MonitorCondition) (*mobileGatewayMonitorInterfaceRequestEnvelope, error) {
5253 if id == types.ID(int64(0)) {
5254 id = types.ID(int64(0))
5255 }
5256 var arg0 interface{} = id
5257 if v, ok := arg0.(argumentDefaulter); ok {
5258 arg0 = v.setDefaults()
5259 }
5260 if index == 0 {
5261 index = 0
5262 }
5263 var arg1 interface{} = index
5264 if v, ok := arg1.(argumentDefaulter); ok {
5265 arg1 = v.setDefaults()
5266 }
5267 if condition == nil {
5268 condition = &MonitorCondition{}
5269 }
5270 var arg2 interface{} = condition
5271 if v, ok := arg2.(argumentDefaulter); ok {
5272 arg2 = v.setDefaults()
5273 }
5274 args := &struct {
5275 Arg0 interface{}
5276 Arg1 interface{}
5277 Arg2 interface{} `mapconv:",squash"`
5278 }{
5279 Arg0: arg0,
5280 Arg1: arg1,
5281 Arg2: arg2,
5282 }
5283
5284 v := &mobileGatewayMonitorInterfaceRequestEnvelope{}
5285 if err := mapconv.ConvertTo(args, v); err != nil {
5286 return nil, err
5287 }
5288 return v, nil
5289 }
5290
5291 func (o *MobileGatewayOp) transformMonitorInterfaceResults(data []byte) (*mobileGatewayMonitorInterfaceResult, error) {
5292 nakedResponse := &mobileGatewayMonitorInterfaceResponseEnvelope{}
5293 if err := json.Unmarshal(data, nakedResponse); err != nil {
5294 return nil, err
5295 }
5296
5297 results := &mobileGatewayMonitorInterfaceResult{}
5298 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
5299 return nil, err
5300 }
5301 return results, nil
5302 }
5303
5304 func (o *NFSOp) transformFindArgs(conditions *FindCondition) (*nFSFindRequestEnvelope, error) {
5305 if conditions == nil {
5306 conditions = &FindCondition{}
5307 }
5308 var arg0 interface{} = conditions
5309 if v, ok := arg0.(argumentDefaulter); ok {
5310 arg0 = v.setDefaults()
5311 }
5312 args := &struct {
5313 Arg0 interface{} `mapconv:",squash"`
5314 }{
5315 Arg0: arg0,
5316 }
5317
5318 v := &nFSFindRequestEnvelope{}
5319 if err := mapconv.ConvertTo(args, v); err != nil {
5320 return nil, err
5321 }
5322 return v, nil
5323 }
5324
5325 func (o *NFSOp) transformFindResults(data []byte) (*NFSFindResult, error) {
5326 nakedResponse := &nFSFindResponseEnvelope{}
5327 if err := json.Unmarshal(data, nakedResponse); err != nil {
5328 return nil, err
5329 }
5330
5331 results := &NFSFindResult{}
5332 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
5333 return nil, err
5334 }
5335 return results, nil
5336 }
5337
5338 func (o *NFSOp) transformCreateArgs(param *NFSCreateRequest) (*nFSCreateRequestEnvelope, error) {
5339 if param == nil {
5340 param = &NFSCreateRequest{}
5341 }
5342 var arg0 interface{} = param
5343 if v, ok := arg0.(argumentDefaulter); ok {
5344 arg0 = v.setDefaults()
5345 }
5346 args := &struct {
5347 Arg0 interface{} `mapconv:"Appliance,recursive"`
5348 }{
5349 Arg0: arg0,
5350 }
5351
5352 v := &nFSCreateRequestEnvelope{}
5353 if err := mapconv.ConvertTo(args, v); err != nil {
5354 return nil, err
5355 }
5356 return v, nil
5357 }
5358
5359 func (o *NFSOp) transformCreateResults(data []byte) (*nFSCreateResult, error) {
5360 nakedResponse := &nFSCreateResponseEnvelope{}
5361 if err := json.Unmarshal(data, nakedResponse); err != nil {
5362 return nil, err
5363 }
5364
5365 results := &nFSCreateResult{}
5366 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
5367 return nil, err
5368 }
5369 return results, nil
5370 }
5371
5372 func (o *NFSOp) transformReadResults(data []byte) (*nFSReadResult, error) {
5373 nakedResponse := &nFSReadResponseEnvelope{}
5374 if err := json.Unmarshal(data, nakedResponse); err != nil {
5375 return nil, err
5376 }
5377
5378 results := &nFSReadResult{}
5379 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
5380 return nil, err
5381 }
5382 return results, nil
5383 }
5384
5385 func (o *NFSOp) transformUpdateArgs(id types.ID, param *NFSUpdateRequest) (*nFSUpdateRequestEnvelope, error) {
5386 if id == types.ID(int64(0)) {
5387 id = types.ID(int64(0))
5388 }
5389 var arg0 interface{} = id
5390 if v, ok := arg0.(argumentDefaulter); ok {
5391 arg0 = v.setDefaults()
5392 }
5393 if param == nil {
5394 param = &NFSUpdateRequest{}
5395 }
5396 var arg1 interface{} = param
5397 if v, ok := arg1.(argumentDefaulter); ok {
5398 arg1 = v.setDefaults()
5399 }
5400 args := &struct {
5401 Arg0 interface{}
5402 Arg1 interface{} `mapconv:"Appliance,recursive"`
5403 }{
5404 Arg0: arg0,
5405 Arg1: arg1,
5406 }
5407
5408 v := &nFSUpdateRequestEnvelope{}
5409 if err := mapconv.ConvertTo(args, v); err != nil {
5410 return nil, err
5411 }
5412 return v, nil
5413 }
5414
5415 func (o *NFSOp) transformUpdateResults(data []byte) (*nFSUpdateResult, error) {
5416 nakedResponse := &nFSUpdateResponseEnvelope{}
5417 if err := json.Unmarshal(data, nakedResponse); err != nil {
5418 return nil, err
5419 }
5420
5421 results := &nFSUpdateResult{}
5422 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
5423 return nil, err
5424 }
5425 return results, nil
5426 }
5427
5428 func (o *NFSOp) transformShutdownArgs(id types.ID, shutdownOption *ShutdownOption) (*nFSShutdownRequestEnvelope, error) {
5429 if id == types.ID(int64(0)) {
5430 id = types.ID(int64(0))
5431 }
5432 var arg0 interface{} = id
5433 if v, ok := arg0.(argumentDefaulter); ok {
5434 arg0 = v.setDefaults()
5435 }
5436 if shutdownOption == nil {
5437 shutdownOption = &ShutdownOption{}
5438 }
5439 var arg1 interface{} = shutdownOption
5440 if v, ok := arg1.(argumentDefaulter); ok {
5441 arg1 = v.setDefaults()
5442 }
5443 args := &struct {
5444 Arg0 interface{}
5445 Arg1 interface{} `mapconv:",squash"`
5446 }{
5447 Arg0: arg0,
5448 Arg1: arg1,
5449 }
5450
5451 v := &nFSShutdownRequestEnvelope{}
5452 if err := mapconv.ConvertTo(args, v); err != nil {
5453 return nil, err
5454 }
5455 return v, nil
5456 }
5457
5458 func (o *NFSOp) transformMonitorCPUArgs(id types.ID, condition *MonitorCondition) (*nFSMonitorCPURequestEnvelope, error) {
5459 if id == types.ID(int64(0)) {
5460 id = types.ID(int64(0))
5461 }
5462 var arg0 interface{} = id
5463 if v, ok := arg0.(argumentDefaulter); ok {
5464 arg0 = v.setDefaults()
5465 }
5466 if condition == nil {
5467 condition = &MonitorCondition{}
5468 }
5469 var arg1 interface{} = condition
5470 if v, ok := arg1.(argumentDefaulter); ok {
5471 arg1 = v.setDefaults()
5472 }
5473 args := &struct {
5474 Arg0 interface{}
5475 Arg1 interface{} `mapconv:",squash"`
5476 }{
5477 Arg0: arg0,
5478 Arg1: arg1,
5479 }
5480
5481 v := &nFSMonitorCPURequestEnvelope{}
5482 if err := mapconv.ConvertTo(args, v); err != nil {
5483 return nil, err
5484 }
5485 return v, nil
5486 }
5487
5488 func (o *NFSOp) transformMonitorCPUResults(data []byte) (*nFSMonitorCPUResult, error) {
5489 nakedResponse := &nFSMonitorCPUResponseEnvelope{}
5490 if err := json.Unmarshal(data, nakedResponse); err != nil {
5491 return nil, err
5492 }
5493
5494 results := &nFSMonitorCPUResult{}
5495 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
5496 return nil, err
5497 }
5498 return results, nil
5499 }
5500
5501 func (o *NFSOp) transformMonitorFreeDiskSizeArgs(id types.ID, condition *MonitorCondition) (*nFSMonitorFreeDiskSizeRequestEnvelope, error) {
5502 if id == types.ID(int64(0)) {
5503 id = types.ID(int64(0))
5504 }
5505 var arg0 interface{} = id
5506 if v, ok := arg0.(argumentDefaulter); ok {
5507 arg0 = v.setDefaults()
5508 }
5509 if condition == nil {
5510 condition = &MonitorCondition{}
5511 }
5512 var arg1 interface{} = condition
5513 if v, ok := arg1.(argumentDefaulter); ok {
5514 arg1 = v.setDefaults()
5515 }
5516 args := &struct {
5517 Arg0 interface{}
5518 Arg1 interface{} `mapconv:",squash"`
5519 }{
5520 Arg0: arg0,
5521 Arg1: arg1,
5522 }
5523
5524 v := &nFSMonitorFreeDiskSizeRequestEnvelope{}
5525 if err := mapconv.ConvertTo(args, v); err != nil {
5526 return nil, err
5527 }
5528 return v, nil
5529 }
5530
5531 func (o *NFSOp) transformMonitorFreeDiskSizeResults(data []byte) (*nFSMonitorFreeDiskSizeResult, error) {
5532 nakedResponse := &nFSMonitorFreeDiskSizeResponseEnvelope{}
5533 if err := json.Unmarshal(data, nakedResponse); err != nil {
5534 return nil, err
5535 }
5536
5537 results := &nFSMonitorFreeDiskSizeResult{}
5538 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
5539 return nil, err
5540 }
5541 return results, nil
5542 }
5543
5544 func (o *NFSOp) transformMonitorInterfaceArgs(id types.ID, condition *MonitorCondition) (*nFSMonitorInterfaceRequestEnvelope, error) {
5545 if id == types.ID(int64(0)) {
5546 id = types.ID(int64(0))
5547 }
5548 var arg0 interface{} = id
5549 if v, ok := arg0.(argumentDefaulter); ok {
5550 arg0 = v.setDefaults()
5551 }
5552 if condition == nil {
5553 condition = &MonitorCondition{}
5554 }
5555 var arg1 interface{} = condition
5556 if v, ok := arg1.(argumentDefaulter); ok {
5557 arg1 = v.setDefaults()
5558 }
5559 args := &struct {
5560 Arg0 interface{}
5561 Arg1 interface{} `mapconv:",squash"`
5562 }{
5563 Arg0: arg0,
5564 Arg1: arg1,
5565 }
5566
5567 v := &nFSMonitorInterfaceRequestEnvelope{}
5568 if err := mapconv.ConvertTo(args, v); err != nil {
5569 return nil, err
5570 }
5571 return v, nil
5572 }
5573
5574 func (o *NFSOp) transformMonitorInterfaceResults(data []byte) (*nFSMonitorInterfaceResult, error) {
5575 nakedResponse := &nFSMonitorInterfaceResponseEnvelope{}
5576 if err := json.Unmarshal(data, nakedResponse); err != nil {
5577 return nil, err
5578 }
5579
5580 results := &nFSMonitorInterfaceResult{}
5581 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
5582 return nil, err
5583 }
5584 return results, nil
5585 }
5586
5587 func (o *NoteOp) transformFindArgs(conditions *FindCondition) (*noteFindRequestEnvelope, error) {
5588 if conditions == nil {
5589 conditions = &FindCondition{}
5590 }
5591 var arg0 interface{} = conditions
5592 if v, ok := arg0.(argumentDefaulter); ok {
5593 arg0 = v.setDefaults()
5594 }
5595 args := &struct {
5596 Arg0 interface{} `mapconv:",squash"`
5597 }{
5598 Arg0: arg0,
5599 }
5600
5601 v := ¬eFindRequestEnvelope{}
5602 if err := mapconv.ConvertTo(args, v); err != nil {
5603 return nil, err
5604 }
5605 return v, nil
5606 }
5607
5608 func (o *NoteOp) transformFindResults(data []byte) (*NoteFindResult, error) {
5609 nakedResponse := ¬eFindResponseEnvelope{}
5610 if err := json.Unmarshal(data, nakedResponse); err != nil {
5611 return nil, err
5612 }
5613
5614 results := &NoteFindResult{}
5615 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
5616 return nil, err
5617 }
5618 return results, nil
5619 }
5620
5621 func (o *NoteOp) transformCreateArgs(param *NoteCreateRequest) (*noteCreateRequestEnvelope, error) {
5622 if param == nil {
5623 param = &NoteCreateRequest{}
5624 }
5625 var arg0 interface{} = param
5626 if v, ok := arg0.(argumentDefaulter); ok {
5627 arg0 = v.setDefaults()
5628 }
5629 args := &struct {
5630 Arg0 interface{} `mapconv:"Note,recursive"`
5631 }{
5632 Arg0: arg0,
5633 }
5634
5635 v := ¬eCreateRequestEnvelope{}
5636 if err := mapconv.ConvertTo(args, v); err != nil {
5637 return nil, err
5638 }
5639 return v, nil
5640 }
5641
5642 func (o *NoteOp) transformCreateResults(data []byte) (*noteCreateResult, error) {
5643 nakedResponse := ¬eCreateResponseEnvelope{}
5644 if err := json.Unmarshal(data, nakedResponse); err != nil {
5645 return nil, err
5646 }
5647
5648 results := ¬eCreateResult{}
5649 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
5650 return nil, err
5651 }
5652 return results, nil
5653 }
5654
5655 func (o *NoteOp) transformReadResults(data []byte) (*noteReadResult, error) {
5656 nakedResponse := ¬eReadResponseEnvelope{}
5657 if err := json.Unmarshal(data, nakedResponse); err != nil {
5658 return nil, err
5659 }
5660
5661 results := ¬eReadResult{}
5662 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
5663 return nil, err
5664 }
5665 return results, nil
5666 }
5667
5668 func (o *NoteOp) transformUpdateArgs(id types.ID, param *NoteUpdateRequest) (*noteUpdateRequestEnvelope, error) {
5669 if id == types.ID(int64(0)) {
5670 id = types.ID(int64(0))
5671 }
5672 var arg0 interface{} = id
5673 if v, ok := arg0.(argumentDefaulter); ok {
5674 arg0 = v.setDefaults()
5675 }
5676 if param == nil {
5677 param = &NoteUpdateRequest{}
5678 }
5679 var arg1 interface{} = param
5680 if v, ok := arg1.(argumentDefaulter); ok {
5681 arg1 = v.setDefaults()
5682 }
5683 args := &struct {
5684 Arg0 interface{}
5685 Arg1 interface{} `mapconv:"Note,recursive"`
5686 }{
5687 Arg0: arg0,
5688 Arg1: arg1,
5689 }
5690
5691 v := ¬eUpdateRequestEnvelope{}
5692 if err := mapconv.ConvertTo(args, v); err != nil {
5693 return nil, err
5694 }
5695 return v, nil
5696 }
5697
5698 func (o *NoteOp) transformUpdateResults(data []byte) (*noteUpdateResult, error) {
5699 nakedResponse := ¬eUpdateResponseEnvelope{}
5700 if err := json.Unmarshal(data, nakedResponse); err != nil {
5701 return nil, err
5702 }
5703
5704 results := ¬eUpdateResult{}
5705 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
5706 return nil, err
5707 }
5708 return results, nil
5709 }
5710
5711 func (o *PacketFilterOp) transformFindArgs(conditions *FindCondition) (*packetFilterFindRequestEnvelope, error) {
5712 if conditions == nil {
5713 conditions = &FindCondition{}
5714 }
5715 var arg0 interface{} = conditions
5716 if v, ok := arg0.(argumentDefaulter); ok {
5717 arg0 = v.setDefaults()
5718 }
5719 args := &struct {
5720 Arg0 interface{} `mapconv:",squash"`
5721 }{
5722 Arg0: arg0,
5723 }
5724
5725 v := &packetFilterFindRequestEnvelope{}
5726 if err := mapconv.ConvertTo(args, v); err != nil {
5727 return nil, err
5728 }
5729 return v, nil
5730 }
5731
5732 func (o *PacketFilterOp) transformFindResults(data []byte) (*PacketFilterFindResult, error) {
5733 nakedResponse := &packetFilterFindResponseEnvelope{}
5734 if err := json.Unmarshal(data, nakedResponse); err != nil {
5735 return nil, err
5736 }
5737
5738 results := &PacketFilterFindResult{}
5739 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
5740 return nil, err
5741 }
5742 return results, nil
5743 }
5744
5745 func (o *PacketFilterOp) transformCreateArgs(param *PacketFilterCreateRequest) (*packetFilterCreateRequestEnvelope, error) {
5746 if param == nil {
5747 param = &PacketFilterCreateRequest{}
5748 }
5749 var arg0 interface{} = param
5750 if v, ok := arg0.(argumentDefaulter); ok {
5751 arg0 = v.setDefaults()
5752 }
5753 args := &struct {
5754 Arg0 interface{} `mapconv:"PacketFilter,recursive"`
5755 }{
5756 Arg0: arg0,
5757 }
5758
5759 v := &packetFilterCreateRequestEnvelope{}
5760 if err := mapconv.ConvertTo(args, v); err != nil {
5761 return nil, err
5762 }
5763 return v, nil
5764 }
5765
5766 func (o *PacketFilterOp) transformCreateResults(data []byte) (*packetFilterCreateResult, error) {
5767 nakedResponse := &packetFilterCreateResponseEnvelope{}
5768 if err := json.Unmarshal(data, nakedResponse); err != nil {
5769 return nil, err
5770 }
5771
5772 results := &packetFilterCreateResult{}
5773 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
5774 return nil, err
5775 }
5776 return results, nil
5777 }
5778
5779 func (o *PacketFilterOp) transformReadResults(data []byte) (*packetFilterReadResult, error) {
5780 nakedResponse := &packetFilterReadResponseEnvelope{}
5781 if err := json.Unmarshal(data, nakedResponse); err != nil {
5782 return nil, err
5783 }
5784
5785 results := &packetFilterReadResult{}
5786 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
5787 return nil, err
5788 }
5789 return results, nil
5790 }
5791
5792 func (o *PacketFilterOp) transformUpdateArgs(id types.ID, updateParam *PacketFilterUpdateRequest, originalExpressionHash string) (*packetFilterUpdateRequestEnvelope, error) {
5793 if id == types.ID(int64(0)) {
5794 id = types.ID(int64(0))
5795 }
5796 var arg0 interface{} = id
5797 if v, ok := arg0.(argumentDefaulter); ok {
5798 arg0 = v.setDefaults()
5799 }
5800 if updateParam == nil {
5801 updateParam = &PacketFilterUpdateRequest{}
5802 }
5803 var arg1 interface{} = updateParam
5804 if v, ok := arg1.(argumentDefaulter); ok {
5805 arg1 = v.setDefaults()
5806 }
5807 if originalExpressionHash == "" {
5808 originalExpressionHash = ""
5809 }
5810 var arg2 interface{} = originalExpressionHash
5811 if v, ok := arg2.(argumentDefaulter); ok {
5812 arg2 = v.setDefaults()
5813 }
5814 args := &struct {
5815 Arg0 interface{}
5816 Arg1 interface{} `mapconv:"PacketFilter,recursive"`
5817 Arg2 interface{} `mapconv:"OriginalExpressionHash"`
5818 }{
5819 Arg0: arg0,
5820 Arg1: arg1,
5821 Arg2: arg2,
5822 }
5823
5824 v := &packetFilterUpdateRequestEnvelope{}
5825 if err := mapconv.ConvertTo(args, v); err != nil {
5826 return nil, err
5827 }
5828 return v, nil
5829 }
5830
5831 func (o *PacketFilterOp) transformUpdateResults(data []byte) (*packetFilterUpdateResult, error) {
5832 nakedResponse := &packetFilterUpdateResponseEnvelope{}
5833 if err := json.Unmarshal(data, nakedResponse); err != nil {
5834 return nil, err
5835 }
5836
5837 results := &packetFilterUpdateResult{}
5838 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
5839 return nil, err
5840 }
5841 return results, nil
5842 }
5843
5844 func (o *PrivateHostOp) transformFindArgs(conditions *FindCondition) (*privateHostFindRequestEnvelope, error) {
5845 if conditions == nil {
5846 conditions = &FindCondition{}
5847 }
5848 var arg0 interface{} = conditions
5849 if v, ok := arg0.(argumentDefaulter); ok {
5850 arg0 = v.setDefaults()
5851 }
5852 args := &struct {
5853 Arg0 interface{} `mapconv:",squash"`
5854 }{
5855 Arg0: arg0,
5856 }
5857
5858 v := &privateHostFindRequestEnvelope{}
5859 if err := mapconv.ConvertTo(args, v); err != nil {
5860 return nil, err
5861 }
5862 return v, nil
5863 }
5864
5865 func (o *PrivateHostOp) transformFindResults(data []byte) (*PrivateHostFindResult, error) {
5866 nakedResponse := &privateHostFindResponseEnvelope{}
5867 if err := json.Unmarshal(data, nakedResponse); err != nil {
5868 return nil, err
5869 }
5870
5871 results := &PrivateHostFindResult{}
5872 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
5873 return nil, err
5874 }
5875 return results, nil
5876 }
5877
5878 func (o *PrivateHostOp) transformCreateArgs(param *PrivateHostCreateRequest) (*privateHostCreateRequestEnvelope, error) {
5879 if param == nil {
5880 param = &PrivateHostCreateRequest{}
5881 }
5882 var arg0 interface{} = param
5883 if v, ok := arg0.(argumentDefaulter); ok {
5884 arg0 = v.setDefaults()
5885 }
5886 args := &struct {
5887 Arg0 interface{} `mapconv:"PrivateHost,recursive"`
5888 }{
5889 Arg0: arg0,
5890 }
5891
5892 v := &privateHostCreateRequestEnvelope{}
5893 if err := mapconv.ConvertTo(args, v); err != nil {
5894 return nil, err
5895 }
5896 return v, nil
5897 }
5898
5899 func (o *PrivateHostOp) transformCreateResults(data []byte) (*privateHostCreateResult, error) {
5900 nakedResponse := &privateHostCreateResponseEnvelope{}
5901 if err := json.Unmarshal(data, nakedResponse); err != nil {
5902 return nil, err
5903 }
5904
5905 results := &privateHostCreateResult{}
5906 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
5907 return nil, err
5908 }
5909 return results, nil
5910 }
5911
5912 func (o *PrivateHostOp) transformReadResults(data []byte) (*privateHostReadResult, error) {
5913 nakedResponse := &privateHostReadResponseEnvelope{}
5914 if err := json.Unmarshal(data, nakedResponse); err != nil {
5915 return nil, err
5916 }
5917
5918 results := &privateHostReadResult{}
5919 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
5920 return nil, err
5921 }
5922 return results, nil
5923 }
5924
5925 func (o *PrivateHostOp) transformUpdateArgs(id types.ID, param *PrivateHostUpdateRequest) (*privateHostUpdateRequestEnvelope, error) {
5926 if id == types.ID(int64(0)) {
5927 id = types.ID(int64(0))
5928 }
5929 var arg0 interface{} = id
5930 if v, ok := arg0.(argumentDefaulter); ok {
5931 arg0 = v.setDefaults()
5932 }
5933 if param == nil {
5934 param = &PrivateHostUpdateRequest{}
5935 }
5936 var arg1 interface{} = param
5937 if v, ok := arg1.(argumentDefaulter); ok {
5938 arg1 = v.setDefaults()
5939 }
5940 args := &struct {
5941 Arg0 interface{}
5942 Arg1 interface{} `mapconv:"PrivateHost,recursive"`
5943 }{
5944 Arg0: arg0,
5945 Arg1: arg1,
5946 }
5947
5948 v := &privateHostUpdateRequestEnvelope{}
5949 if err := mapconv.ConvertTo(args, v); err != nil {
5950 return nil, err
5951 }
5952 return v, nil
5953 }
5954
5955 func (o *PrivateHostOp) transformUpdateResults(data []byte) (*privateHostUpdateResult, error) {
5956 nakedResponse := &privateHostUpdateResponseEnvelope{}
5957 if err := json.Unmarshal(data, nakedResponse); err != nil {
5958 return nil, err
5959 }
5960
5961 results := &privateHostUpdateResult{}
5962 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
5963 return nil, err
5964 }
5965 return results, nil
5966 }
5967
5968 func (o *PrivateHostPlanOp) transformFindArgs(conditions *FindCondition) (*privateHostPlanFindRequestEnvelope, error) {
5969 if conditions == nil {
5970 conditions = &FindCondition{}
5971 }
5972 var arg0 interface{} = conditions
5973 if v, ok := arg0.(argumentDefaulter); ok {
5974 arg0 = v.setDefaults()
5975 }
5976 args := &struct {
5977 Arg0 interface{} `mapconv:",squash"`
5978 }{
5979 Arg0: arg0,
5980 }
5981
5982 v := &privateHostPlanFindRequestEnvelope{}
5983 if err := mapconv.ConvertTo(args, v); err != nil {
5984 return nil, err
5985 }
5986 return v, nil
5987 }
5988
5989 func (o *PrivateHostPlanOp) transformFindResults(data []byte) (*PrivateHostPlanFindResult, error) {
5990 nakedResponse := &privateHostPlanFindResponseEnvelope{}
5991 if err := json.Unmarshal(data, nakedResponse); err != nil {
5992 return nil, err
5993 }
5994
5995 results := &PrivateHostPlanFindResult{}
5996 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
5997 return nil, err
5998 }
5999 return results, nil
6000 }
6001
6002 func (o *PrivateHostPlanOp) transformReadResults(data []byte) (*privateHostPlanReadResult, error) {
6003 nakedResponse := &privateHostPlanReadResponseEnvelope{}
6004 if err := json.Unmarshal(data, nakedResponse); err != nil {
6005 return nil, err
6006 }
6007
6008 results := &privateHostPlanReadResult{}
6009 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
6010 return nil, err
6011 }
6012 return results, nil
6013 }
6014
6015 func (o *ProxyLBOp) transformFindArgs(conditions *FindCondition) (*proxyLBFindRequestEnvelope, error) {
6016 if conditions == nil {
6017 conditions = &FindCondition{}
6018 }
6019 var arg0 interface{} = conditions
6020 if v, ok := arg0.(argumentDefaulter); ok {
6021 arg0 = v.setDefaults()
6022 }
6023 args := &struct {
6024 Arg0 interface{} `mapconv:",squash"`
6025 }{
6026 Arg0: arg0,
6027 }
6028
6029 v := &proxyLBFindRequestEnvelope{}
6030 if err := mapconv.ConvertTo(args, v); err != nil {
6031 return nil, err
6032 }
6033 return v, nil
6034 }
6035
6036 func (o *ProxyLBOp) transformFindResults(data []byte) (*ProxyLBFindResult, error) {
6037 nakedResponse := &proxyLBFindResponseEnvelope{}
6038 if err := json.Unmarshal(data, nakedResponse); err != nil {
6039 return nil, err
6040 }
6041
6042 results := &ProxyLBFindResult{}
6043 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
6044 return nil, err
6045 }
6046 return results, nil
6047 }
6048
6049 func (o *ProxyLBOp) transformCreateArgs(param *ProxyLBCreateRequest) (*proxyLBCreateRequestEnvelope, error) {
6050 if param == nil {
6051 param = &ProxyLBCreateRequest{}
6052 }
6053 var arg0 interface{} = param
6054 if v, ok := arg0.(argumentDefaulter); ok {
6055 arg0 = v.setDefaults()
6056 }
6057 args := &struct {
6058 Arg0 interface{} `mapconv:"CommonServiceItem,recursive"`
6059 }{
6060 Arg0: arg0,
6061 }
6062
6063 v := &proxyLBCreateRequestEnvelope{}
6064 if err := mapconv.ConvertTo(args, v); err != nil {
6065 return nil, err
6066 }
6067 return v, nil
6068 }
6069
6070 func (o *ProxyLBOp) transformCreateResults(data []byte) (*proxyLBCreateResult, error) {
6071 nakedResponse := &proxyLBCreateResponseEnvelope{}
6072 if err := json.Unmarshal(data, nakedResponse); err != nil {
6073 return nil, err
6074 }
6075
6076 results := &proxyLBCreateResult{}
6077 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
6078 return nil, err
6079 }
6080 return results, nil
6081 }
6082
6083 func (o *ProxyLBOp) transformReadResults(data []byte) (*proxyLBReadResult, error) {
6084 nakedResponse := &proxyLBReadResponseEnvelope{}
6085 if err := json.Unmarshal(data, nakedResponse); err != nil {
6086 return nil, err
6087 }
6088
6089 results := &proxyLBReadResult{}
6090 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
6091 return nil, err
6092 }
6093 return results, nil
6094 }
6095
6096 func (o *ProxyLBOp) transformUpdateArgs(id types.ID, param *ProxyLBUpdateRequest) (*proxyLBUpdateRequestEnvelope, error) {
6097 if id == types.ID(int64(0)) {
6098 id = types.ID(int64(0))
6099 }
6100 var arg0 interface{} = id
6101 if v, ok := arg0.(argumentDefaulter); ok {
6102 arg0 = v.setDefaults()
6103 }
6104 if param == nil {
6105 param = &ProxyLBUpdateRequest{}
6106 }
6107 var arg1 interface{} = param
6108 if v, ok := arg1.(argumentDefaulter); ok {
6109 arg1 = v.setDefaults()
6110 }
6111 args := &struct {
6112 Arg0 interface{}
6113 Arg1 interface{} `mapconv:"CommonServiceItem,recursive"`
6114 }{
6115 Arg0: arg0,
6116 Arg1: arg1,
6117 }
6118
6119 v := &proxyLBUpdateRequestEnvelope{}
6120 if err := mapconv.ConvertTo(args, v); err != nil {
6121 return nil, err
6122 }
6123 return v, nil
6124 }
6125
6126 func (o *ProxyLBOp) transformUpdateResults(data []byte) (*proxyLBUpdateResult, error) {
6127 nakedResponse := &proxyLBUpdateResponseEnvelope{}
6128 if err := json.Unmarshal(data, nakedResponse); err != nil {
6129 return nil, err
6130 }
6131
6132 results := &proxyLBUpdateResult{}
6133 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
6134 return nil, err
6135 }
6136 return results, nil
6137 }
6138
6139 func (o *ProxyLBOp) transformUpdateSettingsArgs(id types.ID, param *ProxyLBUpdateSettingsRequest) (*proxyLBUpdateSettingsRequestEnvelope, error) {
6140 if id == types.ID(int64(0)) {
6141 id = types.ID(int64(0))
6142 }
6143 var arg0 interface{} = id
6144 if v, ok := arg0.(argumentDefaulter); ok {
6145 arg0 = v.setDefaults()
6146 }
6147 if param == nil {
6148 param = &ProxyLBUpdateSettingsRequest{}
6149 }
6150 var arg1 interface{} = param
6151 if v, ok := arg1.(argumentDefaulter); ok {
6152 arg1 = v.setDefaults()
6153 }
6154 args := &struct {
6155 Arg0 interface{}
6156 Arg1 interface{} `mapconv:"CommonServiceItem,recursive"`
6157 }{
6158 Arg0: arg0,
6159 Arg1: arg1,
6160 }
6161
6162 v := &proxyLBUpdateSettingsRequestEnvelope{}
6163 if err := mapconv.ConvertTo(args, v); err != nil {
6164 return nil, err
6165 }
6166 return v, nil
6167 }
6168
6169 func (o *ProxyLBOp) transformUpdateSettingsResults(data []byte) (*proxyLBUpdateSettingsResult, error) {
6170 nakedResponse := &proxyLBUpdateSettingsResponseEnvelope{}
6171 if err := json.Unmarshal(data, nakedResponse); err != nil {
6172 return nil, err
6173 }
6174
6175 results := &proxyLBUpdateSettingsResult{}
6176 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
6177 return nil, err
6178 }
6179 return results, nil
6180 }
6181
6182 func (o *ProxyLBOp) transformChangePlanArgs(id types.ID, param *ProxyLBChangePlanRequest) (*proxyLBChangePlanRequestEnvelope, error) {
6183 if id == types.ID(int64(0)) {
6184 id = types.ID(int64(0))
6185 }
6186 var arg0 interface{} = id
6187 if v, ok := arg0.(argumentDefaulter); ok {
6188 arg0 = v.setDefaults()
6189 }
6190 if param == nil {
6191 param = &ProxyLBChangePlanRequest{}
6192 }
6193 var arg1 interface{} = param
6194 if v, ok := arg1.(argumentDefaulter); ok {
6195 arg1 = v.setDefaults()
6196 }
6197 args := &struct {
6198 Arg0 interface{}
6199 Arg1 interface{} `mapconv:"CommonServiceItem,recursive"`
6200 }{
6201 Arg0: arg0,
6202 Arg1: arg1,
6203 }
6204
6205 v := &proxyLBChangePlanRequestEnvelope{}
6206 if err := mapconv.ConvertTo(args, v); err != nil {
6207 return nil, err
6208 }
6209 return v, nil
6210 }
6211
6212 func (o *ProxyLBOp) transformChangePlanResults(data []byte) (*proxyLBChangePlanResult, error) {
6213 nakedResponse := &proxyLBChangePlanResponseEnvelope{}
6214 if err := json.Unmarshal(data, nakedResponse); err != nil {
6215 return nil, err
6216 }
6217
6218 results := &proxyLBChangePlanResult{}
6219 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
6220 return nil, err
6221 }
6222 return results, nil
6223 }
6224
6225 func (o *ProxyLBOp) transformGetCertificatesResults(data []byte) (*proxyLBGetCertificatesResult, error) {
6226 nakedResponse := &proxyLBGetCertificatesResponseEnvelope{}
6227 if err := json.Unmarshal(data, nakedResponse); err != nil {
6228 return nil, err
6229 }
6230
6231 results := &proxyLBGetCertificatesResult{}
6232 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
6233 return nil, err
6234 }
6235 return results, nil
6236 }
6237
6238 func (o *ProxyLBOp) transformSetCertificatesArgs(id types.ID, param *ProxyLBSetCertificatesRequest) (*proxyLBSetCertificatesRequestEnvelope, error) {
6239 if id == types.ID(int64(0)) {
6240 id = types.ID(int64(0))
6241 }
6242 var arg0 interface{} = id
6243 if v, ok := arg0.(argumentDefaulter); ok {
6244 arg0 = v.setDefaults()
6245 }
6246 if param == nil {
6247 param = &ProxyLBSetCertificatesRequest{}
6248 }
6249 var arg1 interface{} = param
6250 if v, ok := arg1.(argumentDefaulter); ok {
6251 arg1 = v.setDefaults()
6252 }
6253 args := &struct {
6254 Arg0 interface{}
6255 Arg1 interface{} `mapconv:"ProxyLB,recursive"`
6256 }{
6257 Arg0: arg0,
6258 Arg1: arg1,
6259 }
6260
6261 v := &proxyLBSetCertificatesRequestEnvelope{}
6262 if err := mapconv.ConvertTo(args, v); err != nil {
6263 return nil, err
6264 }
6265 return v, nil
6266 }
6267
6268 func (o *ProxyLBOp) transformSetCertificatesResults(data []byte) (*proxyLBSetCertificatesResult, error) {
6269 nakedResponse := &proxyLBSetCertificatesResponseEnvelope{}
6270 if err := json.Unmarshal(data, nakedResponse); err != nil {
6271 return nil, err
6272 }
6273
6274 results := &proxyLBSetCertificatesResult{}
6275 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
6276 return nil, err
6277 }
6278 return results, nil
6279 }
6280
6281 func (o *ProxyLBOp) transformHealthStatusResults(data []byte) (*proxyLBHealthStatusResult, error) {
6282 nakedResponse := &proxyLBHealthStatusResponseEnvelope{}
6283 if err := json.Unmarshal(data, nakedResponse); err != nil {
6284 return nil, err
6285 }
6286
6287 results := &proxyLBHealthStatusResult{}
6288 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
6289 return nil, err
6290 }
6291 return results, nil
6292 }
6293
6294 func (o *ProxyLBOp) transformMonitorConnectionArgs(id types.ID, condition *MonitorCondition) (*proxyLBMonitorConnectionRequestEnvelope, error) {
6295 if id == types.ID(int64(0)) {
6296 id = types.ID(int64(0))
6297 }
6298 var arg0 interface{} = id
6299 if v, ok := arg0.(argumentDefaulter); ok {
6300 arg0 = v.setDefaults()
6301 }
6302 if condition == nil {
6303 condition = &MonitorCondition{}
6304 }
6305 var arg1 interface{} = condition
6306 if v, ok := arg1.(argumentDefaulter); ok {
6307 arg1 = v.setDefaults()
6308 }
6309 args := &struct {
6310 Arg0 interface{}
6311 Arg1 interface{} `mapconv:",squash"`
6312 }{
6313 Arg0: arg0,
6314 Arg1: arg1,
6315 }
6316
6317 v := &proxyLBMonitorConnectionRequestEnvelope{}
6318 if err := mapconv.ConvertTo(args, v); err != nil {
6319 return nil, err
6320 }
6321 return v, nil
6322 }
6323
6324 func (o *ProxyLBOp) transformMonitorConnectionResults(data []byte) (*proxyLBMonitorConnectionResult, error) {
6325 nakedResponse := &proxyLBMonitorConnectionResponseEnvelope{}
6326 if err := json.Unmarshal(data, nakedResponse); err != nil {
6327 return nil, err
6328 }
6329
6330 results := &proxyLBMonitorConnectionResult{}
6331 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
6332 return nil, err
6333 }
6334 return results, nil
6335 }
6336
6337 func (o *RegionOp) transformFindArgs(conditions *FindCondition) (*regionFindRequestEnvelope, error) {
6338 if conditions == nil {
6339 conditions = &FindCondition{}
6340 }
6341 var arg0 interface{} = conditions
6342 if v, ok := arg0.(argumentDefaulter); ok {
6343 arg0 = v.setDefaults()
6344 }
6345 args := &struct {
6346 Arg0 interface{} `mapconv:",squash"`
6347 }{
6348 Arg0: arg0,
6349 }
6350
6351 v := ®ionFindRequestEnvelope{}
6352 if err := mapconv.ConvertTo(args, v); err != nil {
6353 return nil, err
6354 }
6355 return v, nil
6356 }
6357
6358 func (o *RegionOp) transformFindResults(data []byte) (*RegionFindResult, error) {
6359 nakedResponse := ®ionFindResponseEnvelope{}
6360 if err := json.Unmarshal(data, nakedResponse); err != nil {
6361 return nil, err
6362 }
6363
6364 results := &RegionFindResult{}
6365 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
6366 return nil, err
6367 }
6368 return results, nil
6369 }
6370
6371 func (o *RegionOp) transformReadResults(data []byte) (*regionReadResult, error) {
6372 nakedResponse := ®ionReadResponseEnvelope{}
6373 if err := json.Unmarshal(data, nakedResponse); err != nil {
6374 return nil, err
6375 }
6376
6377 results := ®ionReadResult{}
6378 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
6379 return nil, err
6380 }
6381 return results, nil
6382 }
6383
6384 func (o *ServerOp) transformFindArgs(conditions *FindCondition) (*serverFindRequestEnvelope, error) {
6385 if conditions == nil {
6386 conditions = &FindCondition{}
6387 }
6388 var arg0 interface{} = conditions
6389 if v, ok := arg0.(argumentDefaulter); ok {
6390 arg0 = v.setDefaults()
6391 }
6392 args := &struct {
6393 Arg0 interface{} `mapconv:",squash"`
6394 }{
6395 Arg0: arg0,
6396 }
6397
6398 v := &serverFindRequestEnvelope{}
6399 if err := mapconv.ConvertTo(args, v); err != nil {
6400 return nil, err
6401 }
6402 return v, nil
6403 }
6404
6405 func (o *ServerOp) transformFindResults(data []byte) (*ServerFindResult, error) {
6406 nakedResponse := &serverFindResponseEnvelope{}
6407 if err := json.Unmarshal(data, nakedResponse); err != nil {
6408 return nil, err
6409 }
6410
6411 results := &ServerFindResult{}
6412 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
6413 return nil, err
6414 }
6415 return results, nil
6416 }
6417
6418 func (o *ServerOp) transformCreateArgs(param *ServerCreateRequest) (*serverCreateRequestEnvelope, error) {
6419 if param == nil {
6420 param = &ServerCreateRequest{}
6421 }
6422 var arg0 interface{} = param
6423 if v, ok := arg0.(argumentDefaulter); ok {
6424 arg0 = v.setDefaults()
6425 }
6426 args := &struct {
6427 Arg0 interface{} `mapconv:"Server,recursive"`
6428 }{
6429 Arg0: arg0,
6430 }
6431
6432 v := &serverCreateRequestEnvelope{}
6433 if err := mapconv.ConvertTo(args, v); err != nil {
6434 return nil, err
6435 }
6436 return v, nil
6437 }
6438
6439 func (o *ServerOp) transformCreateResults(data []byte) (*serverCreateResult, error) {
6440 nakedResponse := &serverCreateResponseEnvelope{}
6441 if err := json.Unmarshal(data, nakedResponse); err != nil {
6442 return nil, err
6443 }
6444
6445 results := &serverCreateResult{}
6446 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
6447 return nil, err
6448 }
6449 return results, nil
6450 }
6451
6452 func (o *ServerOp) transformReadResults(data []byte) (*serverReadResult, error) {
6453 nakedResponse := &serverReadResponseEnvelope{}
6454 if err := json.Unmarshal(data, nakedResponse); err != nil {
6455 return nil, err
6456 }
6457
6458 results := &serverReadResult{}
6459 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
6460 return nil, err
6461 }
6462 return results, nil
6463 }
6464
6465 func (o *ServerOp) transformUpdateArgs(id types.ID, param *ServerUpdateRequest) (*serverUpdateRequestEnvelope, error) {
6466 if id == types.ID(int64(0)) {
6467 id = types.ID(int64(0))
6468 }
6469 var arg0 interface{} = id
6470 if v, ok := arg0.(argumentDefaulter); ok {
6471 arg0 = v.setDefaults()
6472 }
6473 if param == nil {
6474 param = &ServerUpdateRequest{}
6475 }
6476 var arg1 interface{} = param
6477 if v, ok := arg1.(argumentDefaulter); ok {
6478 arg1 = v.setDefaults()
6479 }
6480 args := &struct {
6481 Arg0 interface{}
6482 Arg1 interface{} `mapconv:"Server,recursive"`
6483 }{
6484 Arg0: arg0,
6485 Arg1: arg1,
6486 }
6487
6488 v := &serverUpdateRequestEnvelope{}
6489 if err := mapconv.ConvertTo(args, v); err != nil {
6490 return nil, err
6491 }
6492 return v, nil
6493 }
6494
6495 func (o *ServerOp) transformUpdateResults(data []byte) (*serverUpdateResult, error) {
6496 nakedResponse := &serverUpdateResponseEnvelope{}
6497 if err := json.Unmarshal(data, nakedResponse); err != nil {
6498 return nil, err
6499 }
6500
6501 results := &serverUpdateResult{}
6502 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
6503 return nil, err
6504 }
6505 return results, nil
6506 }
6507
6508 func (o *ServerOp) transformDeleteWithDisksArgs(id types.ID, disks *ServerDeleteWithDisksRequest) (*serverDeleteWithDisksRequestEnvelope, error) {
6509 if id == types.ID(int64(0)) {
6510 id = types.ID(int64(0))
6511 }
6512 var arg0 interface{} = id
6513 if v, ok := arg0.(argumentDefaulter); ok {
6514 arg0 = v.setDefaults()
6515 }
6516 if disks == nil {
6517 disks = &ServerDeleteWithDisksRequest{}
6518 }
6519 var arg1 interface{} = disks
6520 if v, ok := arg1.(argumentDefaulter); ok {
6521 arg1 = v.setDefaults()
6522 }
6523 args := &struct {
6524 Arg0 interface{}
6525 Arg1 interface{} `mapconv:",squash"`
6526 }{
6527 Arg0: arg0,
6528 Arg1: arg1,
6529 }
6530
6531 v := &serverDeleteWithDisksRequestEnvelope{}
6532 if err := mapconv.ConvertTo(args, v); err != nil {
6533 return nil, err
6534 }
6535 return v, nil
6536 }
6537
6538 func (o *ServerOp) transformChangePlanArgs(id types.ID, plan *ServerChangePlanRequest) (*serverChangePlanRequestEnvelope, error) {
6539 if id == types.ID(int64(0)) {
6540 id = types.ID(int64(0))
6541 }
6542 var arg0 interface{} = id
6543 if v, ok := arg0.(argumentDefaulter); ok {
6544 arg0 = v.setDefaults()
6545 }
6546 if plan == nil {
6547 plan = &ServerChangePlanRequest{}
6548 }
6549 var arg1 interface{} = plan
6550 if v, ok := arg1.(argumentDefaulter); ok {
6551 arg1 = v.setDefaults()
6552 }
6553 args := &struct {
6554 Arg0 interface{}
6555 Arg1 interface{} `mapconv:",squash"`
6556 }{
6557 Arg0: arg0,
6558 Arg1: arg1,
6559 }
6560
6561 v := &serverChangePlanRequestEnvelope{}
6562 if err := mapconv.ConvertTo(args, v); err != nil {
6563 return nil, err
6564 }
6565 return v, nil
6566 }
6567
6568 func (o *ServerOp) transformChangePlanResults(data []byte) (*serverChangePlanResult, error) {
6569 nakedResponse := &serverChangePlanResponseEnvelope{}
6570 if err := json.Unmarshal(data, nakedResponse); err != nil {
6571 return nil, err
6572 }
6573
6574 results := &serverChangePlanResult{}
6575 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
6576 return nil, err
6577 }
6578 return results, nil
6579 }
6580
6581 func (o *ServerOp) transformInsertCDROMArgs(id types.ID, insertParam *InsertCDROMRequest) (*serverInsertCDROMRequestEnvelope, error) {
6582 if id == types.ID(int64(0)) {
6583 id = types.ID(int64(0))
6584 }
6585 var arg0 interface{} = id
6586 if v, ok := arg0.(argumentDefaulter); ok {
6587 arg0 = v.setDefaults()
6588 }
6589 if insertParam == nil {
6590 insertParam = &InsertCDROMRequest{}
6591 }
6592 var arg1 interface{} = insertParam
6593 if v, ok := arg1.(argumentDefaulter); ok {
6594 arg1 = v.setDefaults()
6595 }
6596 args := &struct {
6597 Arg0 interface{}
6598 Arg1 interface{} `mapconv:"CDROM"`
6599 }{
6600 Arg0: arg0,
6601 Arg1: arg1,
6602 }
6603
6604 v := &serverInsertCDROMRequestEnvelope{}
6605 if err := mapconv.ConvertTo(args, v); err != nil {
6606 return nil, err
6607 }
6608 return v, nil
6609 }
6610
6611 func (o *ServerOp) transformEjectCDROMArgs(id types.ID, ejectParam *EjectCDROMRequest) (*serverEjectCDROMRequestEnvelope, error) {
6612 if id == types.ID(int64(0)) {
6613 id = types.ID(int64(0))
6614 }
6615 var arg0 interface{} = id
6616 if v, ok := arg0.(argumentDefaulter); ok {
6617 arg0 = v.setDefaults()
6618 }
6619 if ejectParam == nil {
6620 ejectParam = &EjectCDROMRequest{}
6621 }
6622 var arg1 interface{} = ejectParam
6623 if v, ok := arg1.(argumentDefaulter); ok {
6624 arg1 = v.setDefaults()
6625 }
6626 args := &struct {
6627 Arg0 interface{}
6628 Arg1 interface{} `mapconv:"CDROM"`
6629 }{
6630 Arg0: arg0,
6631 Arg1: arg1,
6632 }
6633
6634 v := &serverEjectCDROMRequestEnvelope{}
6635 if err := mapconv.ConvertTo(args, v); err != nil {
6636 return nil, err
6637 }
6638 return v, nil
6639 }
6640
6641 func (o *ServerOp) transformShutdownArgs(id types.ID, shutdownOption *ShutdownOption) (*serverShutdownRequestEnvelope, error) {
6642 if id == types.ID(int64(0)) {
6643 id = types.ID(int64(0))
6644 }
6645 var arg0 interface{} = id
6646 if v, ok := arg0.(argumentDefaulter); ok {
6647 arg0 = v.setDefaults()
6648 }
6649 if shutdownOption == nil {
6650 shutdownOption = &ShutdownOption{}
6651 }
6652 var arg1 interface{} = shutdownOption
6653 if v, ok := arg1.(argumentDefaulter); ok {
6654 arg1 = v.setDefaults()
6655 }
6656 args := &struct {
6657 Arg0 interface{}
6658 Arg1 interface{} `mapconv:",squash"`
6659 }{
6660 Arg0: arg0,
6661 Arg1: arg1,
6662 }
6663
6664 v := &serverShutdownRequestEnvelope{}
6665 if err := mapconv.ConvertTo(args, v); err != nil {
6666 return nil, err
6667 }
6668 return v, nil
6669 }
6670
6671 func (o *ServerOp) transformBootWithVariablesArgs(id types.ID, param *ServerBootVariables) (*serverBootWithVariablesRequestEnvelope, error) {
6672 if id == types.ID(int64(0)) {
6673 id = types.ID(int64(0))
6674 }
6675 var arg0 interface{} = id
6676 if v, ok := arg0.(argumentDefaulter); ok {
6677 arg0 = v.setDefaults()
6678 }
6679 if param == nil {
6680 param = &ServerBootVariables{}
6681 }
6682 var arg1 interface{} = param
6683 if v, ok := arg1.(argumentDefaulter); ok {
6684 arg1 = v.setDefaults()
6685 }
6686 args := &struct {
6687 Arg0 interface{}
6688 Arg1 interface{} `mapconv:"UserBootVariables,recursive"`
6689 }{
6690 Arg0: arg0,
6691 Arg1: arg1,
6692 }
6693
6694 v := &serverBootWithVariablesRequestEnvelope{}
6695 if err := mapconv.ConvertTo(args, v); err != nil {
6696 return nil, err
6697 }
6698 return v, nil
6699 }
6700
6701 func (o *ServerOp) transformSendKeyArgs(id types.ID, keyboardParam *SendKeyRequest) (*serverSendKeyRequestEnvelope, error) {
6702 if id == types.ID(int64(0)) {
6703 id = types.ID(int64(0))
6704 }
6705 var arg0 interface{} = id
6706 if v, ok := arg0.(argumentDefaulter); ok {
6707 arg0 = v.setDefaults()
6708 }
6709 if keyboardParam == nil {
6710 keyboardParam = &SendKeyRequest{}
6711 }
6712 var arg1 interface{} = keyboardParam
6713 if v, ok := arg1.(argumentDefaulter); ok {
6714 arg1 = v.setDefaults()
6715 }
6716 args := &struct {
6717 Arg0 interface{}
6718 Arg1 interface{} `mapconv:",squash"`
6719 }{
6720 Arg0: arg0,
6721 Arg1: arg1,
6722 }
6723
6724 v := &serverSendKeyRequestEnvelope{}
6725 if err := mapconv.ConvertTo(args, v); err != nil {
6726 return nil, err
6727 }
6728 return v, nil
6729 }
6730
6731 func (o *ServerOp) transformGetVNCProxyResults(data []byte) (*serverGetVNCProxyResult, error) {
6732 nakedResponse := &serverGetVNCProxyResponseEnvelope{}
6733 if err := json.Unmarshal(data, nakedResponse); err != nil {
6734 return nil, err
6735 }
6736
6737 results := &serverGetVNCProxyResult{}
6738 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
6739 return nil, err
6740 }
6741 return results, nil
6742 }
6743
6744 func (o *ServerOp) transformMonitorArgs(id types.ID, condition *MonitorCondition) (*serverMonitorRequestEnvelope, error) {
6745 if id == types.ID(int64(0)) {
6746 id = types.ID(int64(0))
6747 }
6748 var arg0 interface{} = id
6749 if v, ok := arg0.(argumentDefaulter); ok {
6750 arg0 = v.setDefaults()
6751 }
6752 if condition == nil {
6753 condition = &MonitorCondition{}
6754 }
6755 var arg1 interface{} = condition
6756 if v, ok := arg1.(argumentDefaulter); ok {
6757 arg1 = v.setDefaults()
6758 }
6759 args := &struct {
6760 Arg0 interface{}
6761 Arg1 interface{} `mapconv:",squash"`
6762 }{
6763 Arg0: arg0,
6764 Arg1: arg1,
6765 }
6766
6767 v := &serverMonitorRequestEnvelope{}
6768 if err := mapconv.ConvertTo(args, v); err != nil {
6769 return nil, err
6770 }
6771 return v, nil
6772 }
6773
6774 func (o *ServerOp) transformMonitorResults(data []byte) (*serverMonitorResult, error) {
6775 nakedResponse := &serverMonitorResponseEnvelope{}
6776 if err := json.Unmarshal(data, nakedResponse); err != nil {
6777 return nil, err
6778 }
6779
6780 results := &serverMonitorResult{}
6781 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
6782 return nil, err
6783 }
6784 return results, nil
6785 }
6786
6787 func (o *ServerOp) transformMonitorCPUArgs(id types.ID, condition *MonitorCondition) (*serverMonitorCPURequestEnvelope, error) {
6788 if id == types.ID(int64(0)) {
6789 id = types.ID(int64(0))
6790 }
6791 var arg0 interface{} = id
6792 if v, ok := arg0.(argumentDefaulter); ok {
6793 arg0 = v.setDefaults()
6794 }
6795 if condition == nil {
6796 condition = &MonitorCondition{}
6797 }
6798 var arg1 interface{} = condition
6799 if v, ok := arg1.(argumentDefaulter); ok {
6800 arg1 = v.setDefaults()
6801 }
6802 args := &struct {
6803 Arg0 interface{}
6804 Arg1 interface{} `mapconv:",squash"`
6805 }{
6806 Arg0: arg0,
6807 Arg1: arg1,
6808 }
6809
6810 v := &serverMonitorCPURequestEnvelope{}
6811 if err := mapconv.ConvertTo(args, v); err != nil {
6812 return nil, err
6813 }
6814 return v, nil
6815 }
6816
6817 func (o *ServerOp) transformMonitorCPUResults(data []byte) (*serverMonitorCPUResult, error) {
6818 nakedResponse := &serverMonitorCPUResponseEnvelope{}
6819 if err := json.Unmarshal(data, nakedResponse); err != nil {
6820 return nil, err
6821 }
6822
6823 results := &serverMonitorCPUResult{}
6824 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
6825 return nil, err
6826 }
6827 return results, nil
6828 }
6829
6830 func (o *ServerPlanOp) transformFindArgs(conditions *FindCondition) (*serverPlanFindRequestEnvelope, error) {
6831 if conditions == nil {
6832 conditions = &FindCondition{}
6833 }
6834 var arg0 interface{} = conditions
6835 if v, ok := arg0.(argumentDefaulter); ok {
6836 arg0 = v.setDefaults()
6837 }
6838 args := &struct {
6839 Arg0 interface{} `mapconv:",squash"`
6840 }{
6841 Arg0: arg0,
6842 }
6843
6844 v := &serverPlanFindRequestEnvelope{}
6845 if err := mapconv.ConvertTo(args, v); err != nil {
6846 return nil, err
6847 }
6848 return v, nil
6849 }
6850
6851 func (o *ServerPlanOp) transformFindResults(data []byte) (*ServerPlanFindResult, error) {
6852 nakedResponse := &serverPlanFindResponseEnvelope{}
6853 if err := json.Unmarshal(data, nakedResponse); err != nil {
6854 return nil, err
6855 }
6856
6857 results := &ServerPlanFindResult{}
6858 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
6859 return nil, err
6860 }
6861 return results, nil
6862 }
6863
6864 func (o *ServerPlanOp) transformReadResults(data []byte) (*serverPlanReadResult, error) {
6865 nakedResponse := &serverPlanReadResponseEnvelope{}
6866 if err := json.Unmarshal(data, nakedResponse); err != nil {
6867 return nil, err
6868 }
6869
6870 results := &serverPlanReadResult{}
6871 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
6872 return nil, err
6873 }
6874 return results, nil
6875 }
6876
6877 func (o *ServiceClassOp) transformFindArgs(conditions *FindCondition) (*serviceClassFindRequestEnvelope, error) {
6878 if conditions == nil {
6879 conditions = &FindCondition{}
6880 }
6881 var arg0 interface{} = conditions
6882 if v, ok := arg0.(argumentDefaulter); ok {
6883 arg0 = v.setDefaults()
6884 }
6885 args := &struct {
6886 Arg0 interface{} `mapconv:",squash"`
6887 }{
6888 Arg0: arg0,
6889 }
6890
6891 v := &serviceClassFindRequestEnvelope{}
6892 if err := mapconv.ConvertTo(args, v); err != nil {
6893 return nil, err
6894 }
6895 return v, nil
6896 }
6897
6898 func (o *ServiceClassOp) transformFindResults(data []byte) (*ServiceClassFindResult, error) {
6899 nakedResponse := &serviceClassFindResponseEnvelope{}
6900 if err := json.Unmarshal(data, nakedResponse); err != nil {
6901 return nil, err
6902 }
6903
6904 results := &ServiceClassFindResult{}
6905 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
6906 return nil, err
6907 }
6908 return results, nil
6909 }
6910
6911 func (o *SIMOp) transformFindArgs(conditions *FindCondition) (*sIMFindRequestEnvelope, error) {
6912 if conditions == nil {
6913 conditions = &FindCondition{}
6914 }
6915 var arg0 interface{} = conditions
6916 if v, ok := arg0.(argumentDefaulter); ok {
6917 arg0 = v.setDefaults()
6918 }
6919 args := &struct {
6920 Arg0 interface{} `mapconv:",squash"`
6921 }{
6922 Arg0: arg0,
6923 }
6924
6925 v := &sIMFindRequestEnvelope{}
6926 if err := mapconv.ConvertTo(args, v); err != nil {
6927 return nil, err
6928 }
6929 return v, nil
6930 }
6931
6932 func (o *SIMOp) transformFindResults(data []byte) (*SIMFindResult, error) {
6933 nakedResponse := &sIMFindResponseEnvelope{}
6934 if err := json.Unmarshal(data, nakedResponse); err != nil {
6935 return nil, err
6936 }
6937
6938 results := &SIMFindResult{}
6939 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
6940 return nil, err
6941 }
6942 return results, nil
6943 }
6944
6945 func (o *SIMOp) transformCreateArgs(param *SIMCreateRequest) (*sIMCreateRequestEnvelope, error) {
6946 if param == nil {
6947 param = &SIMCreateRequest{}
6948 }
6949 var arg0 interface{} = param
6950 if v, ok := arg0.(argumentDefaulter); ok {
6951 arg0 = v.setDefaults()
6952 }
6953 args := &struct {
6954 Arg0 interface{} `mapconv:"CommonServiceItem,recursive"`
6955 }{
6956 Arg0: arg0,
6957 }
6958
6959 v := &sIMCreateRequestEnvelope{}
6960 if err := mapconv.ConvertTo(args, v); err != nil {
6961 return nil, err
6962 }
6963 return v, nil
6964 }
6965
6966 func (o *SIMOp) transformCreateResults(data []byte) (*sIMCreateResult, error) {
6967 nakedResponse := &sIMCreateResponseEnvelope{}
6968 if err := json.Unmarshal(data, nakedResponse); err != nil {
6969 return nil, err
6970 }
6971
6972 results := &sIMCreateResult{}
6973 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
6974 return nil, err
6975 }
6976 return results, nil
6977 }
6978
6979 func (o *SIMOp) transformReadResults(data []byte) (*sIMReadResult, error) {
6980 nakedResponse := &sIMReadResponseEnvelope{}
6981 if err := json.Unmarshal(data, nakedResponse); err != nil {
6982 return nil, err
6983 }
6984
6985 results := &sIMReadResult{}
6986 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
6987 return nil, err
6988 }
6989 return results, nil
6990 }
6991
6992 func (o *SIMOp) transformUpdateArgs(id types.ID, param *SIMUpdateRequest) (*sIMUpdateRequestEnvelope, error) {
6993 if id == types.ID(int64(0)) {
6994 id = types.ID(int64(0))
6995 }
6996 var arg0 interface{} = id
6997 if v, ok := arg0.(argumentDefaulter); ok {
6998 arg0 = v.setDefaults()
6999 }
7000 if param == nil {
7001 param = &SIMUpdateRequest{}
7002 }
7003 var arg1 interface{} = param
7004 if v, ok := arg1.(argumentDefaulter); ok {
7005 arg1 = v.setDefaults()
7006 }
7007 args := &struct {
7008 Arg0 interface{}
7009 Arg1 interface{} `mapconv:"CommonServiceItem,recursive"`
7010 }{
7011 Arg0: arg0,
7012 Arg1: arg1,
7013 }
7014
7015 v := &sIMUpdateRequestEnvelope{}
7016 if err := mapconv.ConvertTo(args, v); err != nil {
7017 return nil, err
7018 }
7019 return v, nil
7020 }
7021
7022 func (o *SIMOp) transformUpdateResults(data []byte) (*sIMUpdateResult, error) {
7023 nakedResponse := &sIMUpdateResponseEnvelope{}
7024 if err := json.Unmarshal(data, nakedResponse); err != nil {
7025 return nil, err
7026 }
7027
7028 results := &sIMUpdateResult{}
7029 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7030 return nil, err
7031 }
7032 return results, nil
7033 }
7034
7035 func (o *SIMOp) transformAssignIPArgs(id types.ID, param *SIMAssignIPRequest) (*sIMAssignIPRequestEnvelope, error) {
7036 if id == types.ID(int64(0)) {
7037 id = types.ID(int64(0))
7038 }
7039 var arg0 interface{} = id
7040 if v, ok := arg0.(argumentDefaulter); ok {
7041 arg0 = v.setDefaults()
7042 }
7043 if param == nil {
7044 param = &SIMAssignIPRequest{}
7045 }
7046 var arg1 interface{} = param
7047 if v, ok := arg1.(argumentDefaulter); ok {
7048 arg1 = v.setDefaults()
7049 }
7050 args := &struct {
7051 Arg0 interface{}
7052 Arg1 interface{} `mapconv:"SIM,recursive"`
7053 }{
7054 Arg0: arg0,
7055 Arg1: arg1,
7056 }
7057
7058 v := &sIMAssignIPRequestEnvelope{}
7059 if err := mapconv.ConvertTo(args, v); err != nil {
7060 return nil, err
7061 }
7062 return v, nil
7063 }
7064
7065 func (o *SIMOp) transformIMEILockArgs(id types.ID, param *SIMIMEILockRequest) (*sIMIMEILockRequestEnvelope, error) {
7066 if id == types.ID(int64(0)) {
7067 id = types.ID(int64(0))
7068 }
7069 var arg0 interface{} = id
7070 if v, ok := arg0.(argumentDefaulter); ok {
7071 arg0 = v.setDefaults()
7072 }
7073 if param == nil {
7074 param = &SIMIMEILockRequest{}
7075 }
7076 var arg1 interface{} = param
7077 if v, ok := arg1.(argumentDefaulter); ok {
7078 arg1 = v.setDefaults()
7079 }
7080 args := &struct {
7081 Arg0 interface{}
7082 Arg1 interface{} `mapconv:"SIM,recursive"`
7083 }{
7084 Arg0: arg0,
7085 Arg1: arg1,
7086 }
7087
7088 v := &sIMIMEILockRequestEnvelope{}
7089 if err := mapconv.ConvertTo(args, v); err != nil {
7090 return nil, err
7091 }
7092 return v, nil
7093 }
7094
7095 func (o *SIMOp) transformLogsResults(data []byte) (*SIMLogsResult, error) {
7096 nakedResponse := &sIMLogsResponseEnvelope{}
7097 if err := json.Unmarshal(data, nakedResponse); err != nil {
7098 return nil, err
7099 }
7100
7101 results := &SIMLogsResult{}
7102 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7103 return nil, err
7104 }
7105 return results, nil
7106 }
7107
7108 func (o *SIMOp) transformGetNetworkOperatorResults(data []byte) (*sIMGetNetworkOperatorResult, error) {
7109 nakedResponse := &sIMGetNetworkOperatorResponseEnvelope{}
7110 if err := json.Unmarshal(data, nakedResponse); err != nil {
7111 return nil, err
7112 }
7113
7114 results := &sIMGetNetworkOperatorResult{}
7115 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7116 return nil, err
7117 }
7118 return results, nil
7119 }
7120
7121 func (o *SIMOp) transformSetNetworkOperatorArgs(id types.ID, configs []*SIMNetworkOperatorConfig) (*sIMSetNetworkOperatorRequestEnvelope, error) {
7122 if id == types.ID(int64(0)) {
7123 id = types.ID(int64(0))
7124 }
7125 var arg0 interface{} = id
7126 if v, ok := arg0.(argumentDefaulter); ok {
7127 arg0 = v.setDefaults()
7128 }
7129 if configs == nil {
7130 configs = []*SIMNetworkOperatorConfig{}
7131 }
7132 var arg1 interface{} = configs
7133 if v, ok := arg1.(argumentDefaulter); ok {
7134 arg1 = v.setDefaults()
7135 }
7136 args := &struct {
7137 Arg0 interface{}
7138 Arg1 interface{} `mapconv:"[]NetworkOperatorConfigs,recursive"`
7139 }{
7140 Arg0: arg0,
7141 Arg1: arg1,
7142 }
7143
7144 v := &sIMSetNetworkOperatorRequestEnvelope{}
7145 if err := mapconv.ConvertTo(args, v); err != nil {
7146 return nil, err
7147 }
7148 return v, nil
7149 }
7150
7151 func (o *SIMOp) transformMonitorSIMArgs(id types.ID, condition *MonitorCondition) (*sIMMonitorSIMRequestEnvelope, error) {
7152 if id == types.ID(int64(0)) {
7153 id = types.ID(int64(0))
7154 }
7155 var arg0 interface{} = id
7156 if v, ok := arg0.(argumentDefaulter); ok {
7157 arg0 = v.setDefaults()
7158 }
7159 if condition == nil {
7160 condition = &MonitorCondition{}
7161 }
7162 var arg1 interface{} = condition
7163 if v, ok := arg1.(argumentDefaulter); ok {
7164 arg1 = v.setDefaults()
7165 }
7166 args := &struct {
7167 Arg0 interface{}
7168 Arg1 interface{} `mapconv:",squash"`
7169 }{
7170 Arg0: arg0,
7171 Arg1: arg1,
7172 }
7173
7174 v := &sIMMonitorSIMRequestEnvelope{}
7175 if err := mapconv.ConvertTo(args, v); err != nil {
7176 return nil, err
7177 }
7178 return v, nil
7179 }
7180
7181 func (o *SIMOp) transformMonitorSIMResults(data []byte) (*sIMMonitorSIMResult, error) {
7182 nakedResponse := &sIMMonitorSIMResponseEnvelope{}
7183 if err := json.Unmarshal(data, nakedResponse); err != nil {
7184 return nil, err
7185 }
7186
7187 results := &sIMMonitorSIMResult{}
7188 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7189 return nil, err
7190 }
7191 return results, nil
7192 }
7193
7194 func (o *SIMOp) transformStatusResults(data []byte) (*sIMStatusResult, error) {
7195 nakedResponse := &sIMStatusResponseEnvelope{}
7196 if err := json.Unmarshal(data, nakedResponse); err != nil {
7197 return nil, err
7198 }
7199
7200 results := &sIMStatusResult{}
7201 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7202 return nil, err
7203 }
7204 return results, nil
7205 }
7206
7207 func (o *SimpleMonitorOp) transformFindArgs(conditions *FindCondition) (*simpleMonitorFindRequestEnvelope, error) {
7208 if conditions == nil {
7209 conditions = &FindCondition{}
7210 }
7211 var arg0 interface{} = conditions
7212 if v, ok := arg0.(argumentDefaulter); ok {
7213 arg0 = v.setDefaults()
7214 }
7215 args := &struct {
7216 Arg0 interface{} `mapconv:",squash"`
7217 }{
7218 Arg0: arg0,
7219 }
7220
7221 v := &simpleMonitorFindRequestEnvelope{}
7222 if err := mapconv.ConvertTo(args, v); err != nil {
7223 return nil, err
7224 }
7225 return v, nil
7226 }
7227
7228 func (o *SimpleMonitorOp) transformFindResults(data []byte) (*SimpleMonitorFindResult, error) {
7229 nakedResponse := &simpleMonitorFindResponseEnvelope{}
7230 if err := json.Unmarshal(data, nakedResponse); err != nil {
7231 return nil, err
7232 }
7233
7234 results := &SimpleMonitorFindResult{}
7235 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7236 return nil, err
7237 }
7238 return results, nil
7239 }
7240
7241 func (o *SimpleMonitorOp) transformCreateArgs(param *SimpleMonitorCreateRequest) (*simpleMonitorCreateRequestEnvelope, error) {
7242 if param == nil {
7243 param = &SimpleMonitorCreateRequest{}
7244 }
7245 var arg0 interface{} = param
7246 if v, ok := arg0.(argumentDefaulter); ok {
7247 arg0 = v.setDefaults()
7248 }
7249 args := &struct {
7250 Arg0 interface{} `mapconv:"CommonServiceItem,recursive"`
7251 }{
7252 Arg0: arg0,
7253 }
7254
7255 v := &simpleMonitorCreateRequestEnvelope{}
7256 if err := mapconv.ConvertTo(args, v); err != nil {
7257 return nil, err
7258 }
7259 return v, nil
7260 }
7261
7262 func (o *SimpleMonitorOp) transformCreateResults(data []byte) (*simpleMonitorCreateResult, error) {
7263 nakedResponse := &simpleMonitorCreateResponseEnvelope{}
7264 if err := json.Unmarshal(data, nakedResponse); err != nil {
7265 return nil, err
7266 }
7267
7268 results := &simpleMonitorCreateResult{}
7269 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7270 return nil, err
7271 }
7272 return results, nil
7273 }
7274
7275 func (o *SimpleMonitorOp) transformReadResults(data []byte) (*simpleMonitorReadResult, error) {
7276 nakedResponse := &simpleMonitorReadResponseEnvelope{}
7277 if err := json.Unmarshal(data, nakedResponse); err != nil {
7278 return nil, err
7279 }
7280
7281 results := &simpleMonitorReadResult{}
7282 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7283 return nil, err
7284 }
7285 return results, nil
7286 }
7287
7288 func (o *SimpleMonitorOp) transformUpdateArgs(id types.ID, param *SimpleMonitorUpdateRequest) (*simpleMonitorUpdateRequestEnvelope, error) {
7289 if id == types.ID(int64(0)) {
7290 id = types.ID(int64(0))
7291 }
7292 var arg0 interface{} = id
7293 if v, ok := arg0.(argumentDefaulter); ok {
7294 arg0 = v.setDefaults()
7295 }
7296 if param == nil {
7297 param = &SimpleMonitorUpdateRequest{}
7298 }
7299 var arg1 interface{} = param
7300 if v, ok := arg1.(argumentDefaulter); ok {
7301 arg1 = v.setDefaults()
7302 }
7303 args := &struct {
7304 Arg0 interface{}
7305 Arg1 interface{} `mapconv:"CommonServiceItem,recursive"`
7306 }{
7307 Arg0: arg0,
7308 Arg1: arg1,
7309 }
7310
7311 v := &simpleMonitorUpdateRequestEnvelope{}
7312 if err := mapconv.ConvertTo(args, v); err != nil {
7313 return nil, err
7314 }
7315 return v, nil
7316 }
7317
7318 func (o *SimpleMonitorOp) transformUpdateResults(data []byte) (*simpleMonitorUpdateResult, error) {
7319 nakedResponse := &simpleMonitorUpdateResponseEnvelope{}
7320 if err := json.Unmarshal(data, nakedResponse); err != nil {
7321 return nil, err
7322 }
7323
7324 results := &simpleMonitorUpdateResult{}
7325 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7326 return nil, err
7327 }
7328 return results, nil
7329 }
7330
7331 func (o *SimpleMonitorOp) transformUpdateSettingsArgs(id types.ID, param *SimpleMonitorUpdateSettingsRequest) (*simpleMonitorUpdateSettingsRequestEnvelope, error) {
7332 if id == types.ID(int64(0)) {
7333 id = types.ID(int64(0))
7334 }
7335 var arg0 interface{} = id
7336 if v, ok := arg0.(argumentDefaulter); ok {
7337 arg0 = v.setDefaults()
7338 }
7339 if param == nil {
7340 param = &SimpleMonitorUpdateSettingsRequest{}
7341 }
7342 var arg1 interface{} = param
7343 if v, ok := arg1.(argumentDefaulter); ok {
7344 arg1 = v.setDefaults()
7345 }
7346 args := &struct {
7347 Arg0 interface{}
7348 Arg1 interface{} `mapconv:"CommonServiceItem,recursive"`
7349 }{
7350 Arg0: arg0,
7351 Arg1: arg1,
7352 }
7353
7354 v := &simpleMonitorUpdateSettingsRequestEnvelope{}
7355 if err := mapconv.ConvertTo(args, v); err != nil {
7356 return nil, err
7357 }
7358 return v, nil
7359 }
7360
7361 func (o *SimpleMonitorOp) transformUpdateSettingsResults(data []byte) (*simpleMonitorUpdateSettingsResult, error) {
7362 nakedResponse := &simpleMonitorUpdateSettingsResponseEnvelope{}
7363 if err := json.Unmarshal(data, nakedResponse); err != nil {
7364 return nil, err
7365 }
7366
7367 results := &simpleMonitorUpdateSettingsResult{}
7368 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7369 return nil, err
7370 }
7371 return results, nil
7372 }
7373
7374 func (o *SimpleMonitorOp) transformMonitorResponseTimeArgs(id types.ID, condition *MonitorCondition) (*simpleMonitorMonitorResponseTimeRequestEnvelope, error) {
7375 if id == types.ID(int64(0)) {
7376 id = types.ID(int64(0))
7377 }
7378 var arg0 interface{} = id
7379 if v, ok := arg0.(argumentDefaulter); ok {
7380 arg0 = v.setDefaults()
7381 }
7382 if condition == nil {
7383 condition = &MonitorCondition{}
7384 }
7385 var arg1 interface{} = condition
7386 if v, ok := arg1.(argumentDefaulter); ok {
7387 arg1 = v.setDefaults()
7388 }
7389 args := &struct {
7390 Arg0 interface{}
7391 Arg1 interface{} `mapconv:",squash"`
7392 }{
7393 Arg0: arg0,
7394 Arg1: arg1,
7395 }
7396
7397 v := &simpleMonitorMonitorResponseTimeRequestEnvelope{}
7398 if err := mapconv.ConvertTo(args, v); err != nil {
7399 return nil, err
7400 }
7401 return v, nil
7402 }
7403
7404 func (o *SimpleMonitorOp) transformMonitorResponseTimeResults(data []byte) (*simpleMonitorMonitorResponseTimeResult, error) {
7405 nakedResponse := &simpleMonitorMonitorResponseTimeResponseEnvelope{}
7406 if err := json.Unmarshal(data, nakedResponse); err != nil {
7407 return nil, err
7408 }
7409
7410 results := &simpleMonitorMonitorResponseTimeResult{}
7411 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7412 return nil, err
7413 }
7414 return results, nil
7415 }
7416
7417 func (o *SimpleMonitorOp) transformHealthStatusResults(data []byte) (*simpleMonitorHealthStatusResult, error) {
7418 nakedResponse := &simpleMonitorHealthStatusResponseEnvelope{}
7419 if err := json.Unmarshal(data, nakedResponse); err != nil {
7420 return nil, err
7421 }
7422
7423 results := &simpleMonitorHealthStatusResult{}
7424 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7425 return nil, err
7426 }
7427 return results, nil
7428 }
7429
7430 func (o *SimpleNotificationDestinationOp) transformFindArgs(conditions *FindCondition) (*simpleNotificationDestinationFindRequestEnvelope, error) {
7431 if conditions == nil {
7432 conditions = &FindCondition{}
7433 }
7434 var arg0 interface{} = conditions
7435 if v, ok := arg0.(argumentDefaulter); ok {
7436 arg0 = v.setDefaults()
7437 }
7438 args := &struct {
7439 Arg0 interface{} `mapconv:",squash"`
7440 }{
7441 Arg0: arg0,
7442 }
7443
7444 v := &simpleNotificationDestinationFindRequestEnvelope{}
7445 if err := mapconv.ConvertTo(args, v); err != nil {
7446 return nil, err
7447 }
7448 return v, nil
7449 }
7450
7451 func (o *SimpleNotificationDestinationOp) transformFindResults(data []byte) (*SimpleNotificationDestinationFindResult, error) {
7452 nakedResponse := &simpleNotificationDestinationFindResponseEnvelope{}
7453 if err := json.Unmarshal(data, nakedResponse); err != nil {
7454 return nil, err
7455 }
7456
7457 results := &SimpleNotificationDestinationFindResult{}
7458 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7459 return nil, err
7460 }
7461 return results, nil
7462 }
7463
7464 func (o *SimpleNotificationDestinationOp) transformCreateArgs(param *SimpleNotificationDestinationCreateRequest) (*simpleNotificationDestinationCreateRequestEnvelope, error) {
7465 if param == nil {
7466 param = &SimpleNotificationDestinationCreateRequest{}
7467 }
7468 var arg0 interface{} = param
7469 if v, ok := arg0.(argumentDefaulter); ok {
7470 arg0 = v.setDefaults()
7471 }
7472 args := &struct {
7473 Arg0 interface{} `mapconv:"CommonServiceItem,recursive"`
7474 }{
7475 Arg0: arg0,
7476 }
7477
7478 v := &simpleNotificationDestinationCreateRequestEnvelope{}
7479 if err := mapconv.ConvertTo(args, v); err != nil {
7480 return nil, err
7481 }
7482 return v, nil
7483 }
7484
7485 func (o *SimpleNotificationDestinationOp) transformCreateResults(data []byte) (*simpleNotificationDestinationCreateResult, error) {
7486 nakedResponse := &simpleNotificationDestinationCreateResponseEnvelope{}
7487 if err := json.Unmarshal(data, nakedResponse); err != nil {
7488 return nil, err
7489 }
7490
7491 results := &simpleNotificationDestinationCreateResult{}
7492 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7493 return nil, err
7494 }
7495 return results, nil
7496 }
7497
7498 func (o *SimpleNotificationDestinationOp) transformReadResults(data []byte) (*simpleNotificationDestinationReadResult, error) {
7499 nakedResponse := &simpleNotificationDestinationReadResponseEnvelope{}
7500 if err := json.Unmarshal(data, nakedResponse); err != nil {
7501 return nil, err
7502 }
7503
7504 results := &simpleNotificationDestinationReadResult{}
7505 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7506 return nil, err
7507 }
7508 return results, nil
7509 }
7510
7511 func (o *SimpleNotificationDestinationOp) transformUpdateArgs(id types.ID, param *SimpleNotificationDestinationUpdateRequest) (*simpleNotificationDestinationUpdateRequestEnvelope, error) {
7512 if id == types.ID(int64(0)) {
7513 id = types.ID(int64(0))
7514 }
7515 var arg0 interface{} = id
7516 if v, ok := arg0.(argumentDefaulter); ok {
7517 arg0 = v.setDefaults()
7518 }
7519 if param == nil {
7520 param = &SimpleNotificationDestinationUpdateRequest{}
7521 }
7522 var arg1 interface{} = param
7523 if v, ok := arg1.(argumentDefaulter); ok {
7524 arg1 = v.setDefaults()
7525 }
7526 args := &struct {
7527 Arg0 interface{}
7528 Arg1 interface{} `mapconv:"CommonServiceItem,recursive"`
7529 }{
7530 Arg0: arg0,
7531 Arg1: arg1,
7532 }
7533
7534 v := &simpleNotificationDestinationUpdateRequestEnvelope{}
7535 if err := mapconv.ConvertTo(args, v); err != nil {
7536 return nil, err
7537 }
7538 return v, nil
7539 }
7540
7541 func (o *SimpleNotificationDestinationOp) transformUpdateResults(data []byte) (*simpleNotificationDestinationUpdateResult, error) {
7542 nakedResponse := &simpleNotificationDestinationUpdateResponseEnvelope{}
7543 if err := json.Unmarshal(data, nakedResponse); err != nil {
7544 return nil, err
7545 }
7546
7547 results := &simpleNotificationDestinationUpdateResult{}
7548 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7549 return nil, err
7550 }
7551 return results, nil
7552 }
7553
7554 func (o *SimpleNotificationDestinationOp) transformUpdateSettingsArgs(id types.ID, param *SimpleNotificationDestinationUpdateSettingsRequest) (*simpleNotificationDestinationUpdateSettingsRequestEnvelope, error) {
7555 if id == types.ID(int64(0)) {
7556 id = types.ID(int64(0))
7557 }
7558 var arg0 interface{} = id
7559 if v, ok := arg0.(argumentDefaulter); ok {
7560 arg0 = v.setDefaults()
7561 }
7562 if param == nil {
7563 param = &SimpleNotificationDestinationUpdateSettingsRequest{}
7564 }
7565 var arg1 interface{} = param
7566 if v, ok := arg1.(argumentDefaulter); ok {
7567 arg1 = v.setDefaults()
7568 }
7569 args := &struct {
7570 Arg0 interface{}
7571 Arg1 interface{} `mapconv:"CommonServiceItem,recursive"`
7572 }{
7573 Arg0: arg0,
7574 Arg1: arg1,
7575 }
7576
7577 v := &simpleNotificationDestinationUpdateSettingsRequestEnvelope{}
7578 if err := mapconv.ConvertTo(args, v); err != nil {
7579 return nil, err
7580 }
7581 return v, nil
7582 }
7583
7584 func (o *SimpleNotificationDestinationOp) transformUpdateSettingsResults(data []byte) (*simpleNotificationDestinationUpdateSettingsResult, error) {
7585 nakedResponse := &simpleNotificationDestinationUpdateSettingsResponseEnvelope{}
7586 if err := json.Unmarshal(data, nakedResponse); err != nil {
7587 return nil, err
7588 }
7589
7590 results := &simpleNotificationDestinationUpdateSettingsResult{}
7591 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7592 return nil, err
7593 }
7594 return results, nil
7595 }
7596
7597 func (o *SimpleNotificationDestinationOp) transformStatusResults(data []byte) (*simpleNotificationDestinationStatusResult, error) {
7598 nakedResponse := &simpleNotificationDestinationStatusResponseEnvelope{}
7599 if err := json.Unmarshal(data, nakedResponse); err != nil {
7600 return nil, err
7601 }
7602
7603 results := &simpleNotificationDestinationStatusResult{}
7604 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7605 return nil, err
7606 }
7607 return results, nil
7608 }
7609
7610 func (o *SimpleNotificationGroupOp) transformFindArgs(conditions *FindCondition) (*simpleNotificationGroupFindRequestEnvelope, error) {
7611 if conditions == nil {
7612 conditions = &FindCondition{}
7613 }
7614 var arg0 interface{} = conditions
7615 if v, ok := arg0.(argumentDefaulter); ok {
7616 arg0 = v.setDefaults()
7617 }
7618 args := &struct {
7619 Arg0 interface{} `mapconv:",squash"`
7620 }{
7621 Arg0: arg0,
7622 }
7623
7624 v := &simpleNotificationGroupFindRequestEnvelope{}
7625 if err := mapconv.ConvertTo(args, v); err != nil {
7626 return nil, err
7627 }
7628 return v, nil
7629 }
7630
7631 func (o *SimpleNotificationGroupOp) transformFindResults(data []byte) (*SimpleNotificationGroupFindResult, error) {
7632 nakedResponse := &simpleNotificationGroupFindResponseEnvelope{}
7633 if err := json.Unmarshal(data, nakedResponse); err != nil {
7634 return nil, err
7635 }
7636
7637 results := &SimpleNotificationGroupFindResult{}
7638 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7639 return nil, err
7640 }
7641 return results, nil
7642 }
7643
7644 func (o *SimpleNotificationGroupOp) transformCreateArgs(param *SimpleNotificationGroupCreateRequest) (*simpleNotificationGroupCreateRequestEnvelope, error) {
7645 if param == nil {
7646 param = &SimpleNotificationGroupCreateRequest{}
7647 }
7648 var arg0 interface{} = param
7649 if v, ok := arg0.(argumentDefaulter); ok {
7650 arg0 = v.setDefaults()
7651 }
7652 args := &struct {
7653 Arg0 interface{} `mapconv:"CommonServiceItem,recursive"`
7654 }{
7655 Arg0: arg0,
7656 }
7657
7658 v := &simpleNotificationGroupCreateRequestEnvelope{}
7659 if err := mapconv.ConvertTo(args, v); err != nil {
7660 return nil, err
7661 }
7662 return v, nil
7663 }
7664
7665 func (o *SimpleNotificationGroupOp) transformCreateResults(data []byte) (*simpleNotificationGroupCreateResult, error) {
7666 nakedResponse := &simpleNotificationGroupCreateResponseEnvelope{}
7667 if err := json.Unmarshal(data, nakedResponse); err != nil {
7668 return nil, err
7669 }
7670
7671 results := &simpleNotificationGroupCreateResult{}
7672 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7673 return nil, err
7674 }
7675 return results, nil
7676 }
7677
7678 func (o *SimpleNotificationGroupOp) transformReadResults(data []byte) (*simpleNotificationGroupReadResult, error) {
7679 nakedResponse := &simpleNotificationGroupReadResponseEnvelope{}
7680 if err := json.Unmarshal(data, nakedResponse); err != nil {
7681 return nil, err
7682 }
7683
7684 results := &simpleNotificationGroupReadResult{}
7685 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7686 return nil, err
7687 }
7688 return results, nil
7689 }
7690
7691 func (o *SimpleNotificationGroupOp) transformUpdateArgs(id types.ID, param *SimpleNotificationGroupUpdateRequest) (*simpleNotificationGroupUpdateRequestEnvelope, error) {
7692 if id == types.ID(int64(0)) {
7693 id = types.ID(int64(0))
7694 }
7695 var arg0 interface{} = id
7696 if v, ok := arg0.(argumentDefaulter); ok {
7697 arg0 = v.setDefaults()
7698 }
7699 if param == nil {
7700 param = &SimpleNotificationGroupUpdateRequest{}
7701 }
7702 var arg1 interface{} = param
7703 if v, ok := arg1.(argumentDefaulter); ok {
7704 arg1 = v.setDefaults()
7705 }
7706 args := &struct {
7707 Arg0 interface{}
7708 Arg1 interface{} `mapconv:"CommonServiceItem,recursive"`
7709 }{
7710 Arg0: arg0,
7711 Arg1: arg1,
7712 }
7713
7714 v := &simpleNotificationGroupUpdateRequestEnvelope{}
7715 if err := mapconv.ConvertTo(args, v); err != nil {
7716 return nil, err
7717 }
7718 return v, nil
7719 }
7720
7721 func (o *SimpleNotificationGroupOp) transformUpdateResults(data []byte) (*simpleNotificationGroupUpdateResult, error) {
7722 nakedResponse := &simpleNotificationGroupUpdateResponseEnvelope{}
7723 if err := json.Unmarshal(data, nakedResponse); err != nil {
7724 return nil, err
7725 }
7726
7727 results := &simpleNotificationGroupUpdateResult{}
7728 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7729 return nil, err
7730 }
7731 return results, nil
7732 }
7733
7734 func (o *SimpleNotificationGroupOp) transformUpdateSettingsArgs(id types.ID, param *SimpleNotificationGroupUpdateSettingsRequest) (*simpleNotificationGroupUpdateSettingsRequestEnvelope, error) {
7735 if id == types.ID(int64(0)) {
7736 id = types.ID(int64(0))
7737 }
7738 var arg0 interface{} = id
7739 if v, ok := arg0.(argumentDefaulter); ok {
7740 arg0 = v.setDefaults()
7741 }
7742 if param == nil {
7743 param = &SimpleNotificationGroupUpdateSettingsRequest{}
7744 }
7745 var arg1 interface{} = param
7746 if v, ok := arg1.(argumentDefaulter); ok {
7747 arg1 = v.setDefaults()
7748 }
7749 args := &struct {
7750 Arg0 interface{}
7751 Arg1 interface{} `mapconv:"CommonServiceItem,recursive"`
7752 }{
7753 Arg0: arg0,
7754 Arg1: arg1,
7755 }
7756
7757 v := &simpleNotificationGroupUpdateSettingsRequestEnvelope{}
7758 if err := mapconv.ConvertTo(args, v); err != nil {
7759 return nil, err
7760 }
7761 return v, nil
7762 }
7763
7764 func (o *SimpleNotificationGroupOp) transformUpdateSettingsResults(data []byte) (*simpleNotificationGroupUpdateSettingsResult, error) {
7765 nakedResponse := &simpleNotificationGroupUpdateSettingsResponseEnvelope{}
7766 if err := json.Unmarshal(data, nakedResponse); err != nil {
7767 return nil, err
7768 }
7769
7770 results := &simpleNotificationGroupUpdateSettingsResult{}
7771 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7772 return nil, err
7773 }
7774 return results, nil
7775 }
7776
7777 func (o *SimpleNotificationGroupOp) transformPostMessageArgs(id types.ID, message string) (*simpleNotificationGroupPostMessageRequestEnvelope, error) {
7778 if id == types.ID(int64(0)) {
7779 id = types.ID(int64(0))
7780 }
7781 var arg0 interface{} = id
7782 if v, ok := arg0.(argumentDefaulter); ok {
7783 arg0 = v.setDefaults()
7784 }
7785 if message == "" {
7786 message = ""
7787 }
7788 var arg1 interface{} = message
7789 if v, ok := arg1.(argumentDefaulter); ok {
7790 arg1 = v.setDefaults()
7791 }
7792 args := &struct {
7793 Arg0 interface{}
7794 Arg1 interface{} `mapconv:"Message"`
7795 }{
7796 Arg0: arg0,
7797 Arg1: arg1,
7798 }
7799
7800 v := &simpleNotificationGroupPostMessageRequestEnvelope{}
7801 if err := mapconv.ConvertTo(args, v); err != nil {
7802 return nil, err
7803 }
7804 return v, nil
7805 }
7806
7807 func (o *SimpleNotificationGroupOp) transformHistoryResults(data []byte) (*simpleNotificationGroupHistoryResult, error) {
7808 nakedResponse := &simpleNotificationGroupHistoryResponseEnvelope{}
7809 if err := json.Unmarshal(data, nakedResponse); err != nil {
7810 return nil, err
7811 }
7812
7813 results := &simpleNotificationGroupHistoryResult{}
7814 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7815 return nil, err
7816 }
7817 return results, nil
7818 }
7819
7820 func (o *SSHKeyOp) transformFindArgs(conditions *FindCondition) (*sSHKeyFindRequestEnvelope, error) {
7821 if conditions == nil {
7822 conditions = &FindCondition{}
7823 }
7824 var arg0 interface{} = conditions
7825 if v, ok := arg0.(argumentDefaulter); ok {
7826 arg0 = v.setDefaults()
7827 }
7828 args := &struct {
7829 Arg0 interface{} `mapconv:",squash"`
7830 }{
7831 Arg0: arg0,
7832 }
7833
7834 v := &sSHKeyFindRequestEnvelope{}
7835 if err := mapconv.ConvertTo(args, v); err != nil {
7836 return nil, err
7837 }
7838 return v, nil
7839 }
7840
7841 func (o *SSHKeyOp) transformFindResults(data []byte) (*SSHKeyFindResult, error) {
7842 nakedResponse := &sSHKeyFindResponseEnvelope{}
7843 if err := json.Unmarshal(data, nakedResponse); err != nil {
7844 return nil, err
7845 }
7846
7847 results := &SSHKeyFindResult{}
7848 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7849 return nil, err
7850 }
7851 return results, nil
7852 }
7853
7854 func (o *SSHKeyOp) transformCreateArgs(param *SSHKeyCreateRequest) (*sSHKeyCreateRequestEnvelope, error) {
7855 if param == nil {
7856 param = &SSHKeyCreateRequest{}
7857 }
7858 var arg0 interface{} = param
7859 if v, ok := arg0.(argumentDefaulter); ok {
7860 arg0 = v.setDefaults()
7861 }
7862 args := &struct {
7863 Arg0 interface{} `mapconv:"SSHKey,recursive"`
7864 }{
7865 Arg0: arg0,
7866 }
7867
7868 v := &sSHKeyCreateRequestEnvelope{}
7869 if err := mapconv.ConvertTo(args, v); err != nil {
7870 return nil, err
7871 }
7872 return v, nil
7873 }
7874
7875 func (o *SSHKeyOp) transformCreateResults(data []byte) (*sSHKeyCreateResult, error) {
7876 nakedResponse := &sSHKeyCreateResponseEnvelope{}
7877 if err := json.Unmarshal(data, nakedResponse); err != nil {
7878 return nil, err
7879 }
7880
7881 results := &sSHKeyCreateResult{}
7882 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7883 return nil, err
7884 }
7885 return results, nil
7886 }
7887
7888 func (o *SSHKeyOp) transformReadResults(data []byte) (*sSHKeyReadResult, error) {
7889 nakedResponse := &sSHKeyReadResponseEnvelope{}
7890 if err := json.Unmarshal(data, nakedResponse); err != nil {
7891 return nil, err
7892 }
7893
7894 results := &sSHKeyReadResult{}
7895 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7896 return nil, err
7897 }
7898 return results, nil
7899 }
7900
7901 func (o *SSHKeyOp) transformUpdateArgs(id types.ID, param *SSHKeyUpdateRequest) (*sSHKeyUpdateRequestEnvelope, error) {
7902 if id == types.ID(int64(0)) {
7903 id = types.ID(int64(0))
7904 }
7905 var arg0 interface{} = id
7906 if v, ok := arg0.(argumentDefaulter); ok {
7907 arg0 = v.setDefaults()
7908 }
7909 if param == nil {
7910 param = &SSHKeyUpdateRequest{}
7911 }
7912 var arg1 interface{} = param
7913 if v, ok := arg1.(argumentDefaulter); ok {
7914 arg1 = v.setDefaults()
7915 }
7916 args := &struct {
7917 Arg0 interface{}
7918 Arg1 interface{} `mapconv:"SSHKey,recursive"`
7919 }{
7920 Arg0: arg0,
7921 Arg1: arg1,
7922 }
7923
7924 v := &sSHKeyUpdateRequestEnvelope{}
7925 if err := mapconv.ConvertTo(args, v); err != nil {
7926 return nil, err
7927 }
7928 return v, nil
7929 }
7930
7931 func (o *SSHKeyOp) transformUpdateResults(data []byte) (*sSHKeyUpdateResult, error) {
7932 nakedResponse := &sSHKeyUpdateResponseEnvelope{}
7933 if err := json.Unmarshal(data, nakedResponse); err != nil {
7934 return nil, err
7935 }
7936
7937 results := &sSHKeyUpdateResult{}
7938 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7939 return nil, err
7940 }
7941 return results, nil
7942 }
7943
7944 func (o *SubnetOp) transformFindArgs(conditions *FindCondition) (*subnetFindRequestEnvelope, error) {
7945 if conditions == nil {
7946 conditions = &FindCondition{}
7947 }
7948 var arg0 interface{} = conditions
7949 if v, ok := arg0.(argumentDefaulter); ok {
7950 arg0 = v.setDefaults()
7951 }
7952 args := &struct {
7953 Arg0 interface{} `mapconv:",squash"`
7954 }{
7955 Arg0: arg0,
7956 }
7957
7958 v := &subnetFindRequestEnvelope{}
7959 if err := mapconv.ConvertTo(args, v); err != nil {
7960 return nil, err
7961 }
7962 return v, nil
7963 }
7964
7965 func (o *SubnetOp) transformFindResults(data []byte) (*SubnetFindResult, error) {
7966 nakedResponse := &subnetFindResponseEnvelope{}
7967 if err := json.Unmarshal(data, nakedResponse); err != nil {
7968 return nil, err
7969 }
7970
7971 results := &SubnetFindResult{}
7972 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7973 return nil, err
7974 }
7975 return results, nil
7976 }
7977
7978 func (o *SubnetOp) transformReadResults(data []byte) (*subnetReadResult, error) {
7979 nakedResponse := &subnetReadResponseEnvelope{}
7980 if err := json.Unmarshal(data, nakedResponse); err != nil {
7981 return nil, err
7982 }
7983
7984 results := &subnetReadResult{}
7985 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
7986 return nil, err
7987 }
7988 return results, nil
7989 }
7990
7991 func (o *SwitchOp) transformFindArgs(conditions *FindCondition) (*switchFindRequestEnvelope, error) {
7992 if conditions == nil {
7993 conditions = &FindCondition{}
7994 }
7995 var arg0 interface{} = conditions
7996 if v, ok := arg0.(argumentDefaulter); ok {
7997 arg0 = v.setDefaults()
7998 }
7999 args := &struct {
8000 Arg0 interface{} `mapconv:",squash"`
8001 }{
8002 Arg0: arg0,
8003 }
8004
8005 v := &switchFindRequestEnvelope{}
8006 if err := mapconv.ConvertTo(args, v); err != nil {
8007 return nil, err
8008 }
8009 return v, nil
8010 }
8011
8012 func (o *SwitchOp) transformFindResults(data []byte) (*SwitchFindResult, error) {
8013 nakedResponse := &switchFindResponseEnvelope{}
8014 if err := json.Unmarshal(data, nakedResponse); err != nil {
8015 return nil, err
8016 }
8017
8018 results := &SwitchFindResult{}
8019 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
8020 return nil, err
8021 }
8022 return results, nil
8023 }
8024
8025 func (o *SwitchOp) transformCreateArgs(param *SwitchCreateRequest) (*switchCreateRequestEnvelope, error) {
8026 if param == nil {
8027 param = &SwitchCreateRequest{}
8028 }
8029 var arg0 interface{} = param
8030 if v, ok := arg0.(argumentDefaulter); ok {
8031 arg0 = v.setDefaults()
8032 }
8033 args := &struct {
8034 Arg0 interface{} `mapconv:"Switch,recursive"`
8035 }{
8036 Arg0: arg0,
8037 }
8038
8039 v := &switchCreateRequestEnvelope{}
8040 if err := mapconv.ConvertTo(args, v); err != nil {
8041 return nil, err
8042 }
8043 return v, nil
8044 }
8045
8046 func (o *SwitchOp) transformCreateResults(data []byte) (*switchCreateResult, error) {
8047 nakedResponse := &switchCreateResponseEnvelope{}
8048 if err := json.Unmarshal(data, nakedResponse); err != nil {
8049 return nil, err
8050 }
8051
8052 results := &switchCreateResult{}
8053 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
8054 return nil, err
8055 }
8056 return results, nil
8057 }
8058
8059 func (o *SwitchOp) transformReadResults(data []byte) (*switchReadResult, error) {
8060 nakedResponse := &switchReadResponseEnvelope{}
8061 if err := json.Unmarshal(data, nakedResponse); err != nil {
8062 return nil, err
8063 }
8064
8065 results := &switchReadResult{}
8066 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
8067 return nil, err
8068 }
8069 return results, nil
8070 }
8071
8072 func (o *SwitchOp) transformUpdateArgs(id types.ID, param *SwitchUpdateRequest) (*switchUpdateRequestEnvelope, error) {
8073 if id == types.ID(int64(0)) {
8074 id = types.ID(int64(0))
8075 }
8076 var arg0 interface{} = id
8077 if v, ok := arg0.(argumentDefaulter); ok {
8078 arg0 = v.setDefaults()
8079 }
8080 if param == nil {
8081 param = &SwitchUpdateRequest{}
8082 }
8083 var arg1 interface{} = param
8084 if v, ok := arg1.(argumentDefaulter); ok {
8085 arg1 = v.setDefaults()
8086 }
8087 args := &struct {
8088 Arg0 interface{}
8089 Arg1 interface{} `mapconv:"Switch,recursive"`
8090 }{
8091 Arg0: arg0,
8092 Arg1: arg1,
8093 }
8094
8095 v := &switchUpdateRequestEnvelope{}
8096 if err := mapconv.ConvertTo(args, v); err != nil {
8097 return nil, err
8098 }
8099 return v, nil
8100 }
8101
8102 func (o *SwitchOp) transformUpdateResults(data []byte) (*switchUpdateResult, error) {
8103 nakedResponse := &switchUpdateResponseEnvelope{}
8104 if err := json.Unmarshal(data, nakedResponse); err != nil {
8105 return nil, err
8106 }
8107
8108 results := &switchUpdateResult{}
8109 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
8110 return nil, err
8111 }
8112 return results, nil
8113 }
8114
8115 func (o *SwitchOp) transformGetServersResults(data []byte) (*SwitchGetServersResult, error) {
8116 nakedResponse := &switchGetServersResponseEnvelope{}
8117 if err := json.Unmarshal(data, nakedResponse); err != nil {
8118 return nil, err
8119 }
8120
8121 results := &SwitchGetServersResult{}
8122 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
8123 return nil, err
8124 }
8125 return results, nil
8126 }
8127
8128 func (o *VPCRouterOp) transformFindArgs(conditions *FindCondition) (*vPCRouterFindRequestEnvelope, error) {
8129 if conditions == nil {
8130 conditions = &FindCondition{}
8131 }
8132 var arg0 interface{} = conditions
8133 if v, ok := arg0.(argumentDefaulter); ok {
8134 arg0 = v.setDefaults()
8135 }
8136 args := &struct {
8137 Arg0 interface{} `mapconv:",squash"`
8138 }{
8139 Arg0: arg0,
8140 }
8141
8142 v := &vPCRouterFindRequestEnvelope{}
8143 if err := mapconv.ConvertTo(args, v); err != nil {
8144 return nil, err
8145 }
8146 return v, nil
8147 }
8148
8149 func (o *VPCRouterOp) transformFindResults(data []byte) (*VPCRouterFindResult, error) {
8150 nakedResponse := &vPCRouterFindResponseEnvelope{}
8151 if err := json.Unmarshal(data, nakedResponse); err != nil {
8152 return nil, err
8153 }
8154
8155 results := &VPCRouterFindResult{}
8156 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
8157 return nil, err
8158 }
8159 return results, nil
8160 }
8161
8162 func (o *VPCRouterOp) transformCreateArgs(param *VPCRouterCreateRequest) (*vPCRouterCreateRequestEnvelope, error) {
8163 if param == nil {
8164 param = &VPCRouterCreateRequest{}
8165 }
8166 var arg0 interface{} = param
8167 if v, ok := arg0.(argumentDefaulter); ok {
8168 arg0 = v.setDefaults()
8169 }
8170 args := &struct {
8171 Arg0 interface{} `mapconv:"Appliance,recursive"`
8172 }{
8173 Arg0: arg0,
8174 }
8175
8176 v := &vPCRouterCreateRequestEnvelope{}
8177 if err := mapconv.ConvertTo(args, v); err != nil {
8178 return nil, err
8179 }
8180 return v, nil
8181 }
8182
8183 func (o *VPCRouterOp) transformCreateResults(data []byte) (*vPCRouterCreateResult, error) {
8184 nakedResponse := &vPCRouterCreateResponseEnvelope{}
8185 if err := json.Unmarshal(data, nakedResponse); err != nil {
8186 return nil, err
8187 }
8188
8189 results := &vPCRouterCreateResult{}
8190 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
8191 return nil, err
8192 }
8193 return results, nil
8194 }
8195
8196 func (o *VPCRouterOp) transformReadResults(data []byte) (*vPCRouterReadResult, error) {
8197 nakedResponse := &vPCRouterReadResponseEnvelope{}
8198 if err := json.Unmarshal(data, nakedResponse); err != nil {
8199 return nil, err
8200 }
8201
8202 results := &vPCRouterReadResult{}
8203 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
8204 return nil, err
8205 }
8206 return results, nil
8207 }
8208
8209 func (o *VPCRouterOp) transformUpdateArgs(id types.ID, param *VPCRouterUpdateRequest) (*vPCRouterUpdateRequestEnvelope, error) {
8210 if id == types.ID(int64(0)) {
8211 id = types.ID(int64(0))
8212 }
8213 var arg0 interface{} = id
8214 if v, ok := arg0.(argumentDefaulter); ok {
8215 arg0 = v.setDefaults()
8216 }
8217 if param == nil {
8218 param = &VPCRouterUpdateRequest{}
8219 }
8220 var arg1 interface{} = param
8221 if v, ok := arg1.(argumentDefaulter); ok {
8222 arg1 = v.setDefaults()
8223 }
8224 args := &struct {
8225 Arg0 interface{}
8226 Arg1 interface{} `mapconv:"Appliance,recursive"`
8227 }{
8228 Arg0: arg0,
8229 Arg1: arg1,
8230 }
8231
8232 v := &vPCRouterUpdateRequestEnvelope{}
8233 if err := mapconv.ConvertTo(args, v); err != nil {
8234 return nil, err
8235 }
8236 return v, nil
8237 }
8238
8239 func (o *VPCRouterOp) transformUpdateResults(data []byte) (*vPCRouterUpdateResult, error) {
8240 nakedResponse := &vPCRouterUpdateResponseEnvelope{}
8241 if err := json.Unmarshal(data, nakedResponse); err != nil {
8242 return nil, err
8243 }
8244
8245 results := &vPCRouterUpdateResult{}
8246 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
8247 return nil, err
8248 }
8249 return results, nil
8250 }
8251
8252 func (o *VPCRouterOp) transformUpdateSettingsArgs(id types.ID, param *VPCRouterUpdateSettingsRequest) (*vPCRouterUpdateSettingsRequestEnvelope, error) {
8253 if id == types.ID(int64(0)) {
8254 id = types.ID(int64(0))
8255 }
8256 var arg0 interface{} = id
8257 if v, ok := arg0.(argumentDefaulter); ok {
8258 arg0 = v.setDefaults()
8259 }
8260 if param == nil {
8261 param = &VPCRouterUpdateSettingsRequest{}
8262 }
8263 var arg1 interface{} = param
8264 if v, ok := arg1.(argumentDefaulter); ok {
8265 arg1 = v.setDefaults()
8266 }
8267 args := &struct {
8268 Arg0 interface{}
8269 Arg1 interface{} `mapconv:"Appliance,recursive"`
8270 }{
8271 Arg0: arg0,
8272 Arg1: arg1,
8273 }
8274
8275 v := &vPCRouterUpdateSettingsRequestEnvelope{}
8276 if err := mapconv.ConvertTo(args, v); err != nil {
8277 return nil, err
8278 }
8279 return v, nil
8280 }
8281
8282 func (o *VPCRouterOp) transformUpdateSettingsResults(data []byte) (*vPCRouterUpdateSettingsResult, error) {
8283 nakedResponse := &vPCRouterUpdateSettingsResponseEnvelope{}
8284 if err := json.Unmarshal(data, nakedResponse); err != nil {
8285 return nil, err
8286 }
8287
8288 results := &vPCRouterUpdateSettingsResult{}
8289 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
8290 return nil, err
8291 }
8292 return results, nil
8293 }
8294
8295 func (o *VPCRouterOp) transformShutdownArgs(id types.ID, shutdownOption *ShutdownOption) (*vPCRouterShutdownRequestEnvelope, error) {
8296 if id == types.ID(int64(0)) {
8297 id = types.ID(int64(0))
8298 }
8299 var arg0 interface{} = id
8300 if v, ok := arg0.(argumentDefaulter); ok {
8301 arg0 = v.setDefaults()
8302 }
8303 if shutdownOption == nil {
8304 shutdownOption = &ShutdownOption{}
8305 }
8306 var arg1 interface{} = shutdownOption
8307 if v, ok := arg1.(argumentDefaulter); ok {
8308 arg1 = v.setDefaults()
8309 }
8310 args := &struct {
8311 Arg0 interface{}
8312 Arg1 interface{} `mapconv:",squash"`
8313 }{
8314 Arg0: arg0,
8315 Arg1: arg1,
8316 }
8317
8318 v := &vPCRouterShutdownRequestEnvelope{}
8319 if err := mapconv.ConvertTo(args, v); err != nil {
8320 return nil, err
8321 }
8322 return v, nil
8323 }
8324
8325 func (o *VPCRouterOp) transformMonitorCPUArgs(id types.ID, condition *MonitorCondition) (*vPCRouterMonitorCPURequestEnvelope, error) {
8326 if id == types.ID(int64(0)) {
8327 id = types.ID(int64(0))
8328 }
8329 var arg0 interface{} = id
8330 if v, ok := arg0.(argumentDefaulter); ok {
8331 arg0 = v.setDefaults()
8332 }
8333 if condition == nil {
8334 condition = &MonitorCondition{}
8335 }
8336 var arg1 interface{} = condition
8337 if v, ok := arg1.(argumentDefaulter); ok {
8338 arg1 = v.setDefaults()
8339 }
8340 args := &struct {
8341 Arg0 interface{}
8342 Arg1 interface{} `mapconv:",squash"`
8343 }{
8344 Arg0: arg0,
8345 Arg1: arg1,
8346 }
8347
8348 v := &vPCRouterMonitorCPURequestEnvelope{}
8349 if err := mapconv.ConvertTo(args, v); err != nil {
8350 return nil, err
8351 }
8352 return v, nil
8353 }
8354
8355 func (o *VPCRouterOp) transformMonitorCPUResults(data []byte) (*vPCRouterMonitorCPUResult, error) {
8356 nakedResponse := &vPCRouterMonitorCPUResponseEnvelope{}
8357 if err := json.Unmarshal(data, nakedResponse); err != nil {
8358 return nil, err
8359 }
8360
8361 results := &vPCRouterMonitorCPUResult{}
8362 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
8363 return nil, err
8364 }
8365 return results, nil
8366 }
8367
8368 func (o *VPCRouterOp) transformMonitorInterfaceArgs(id types.ID, index int, condition *MonitorCondition) (*vPCRouterMonitorInterfaceRequestEnvelope, error) {
8369 if id == types.ID(int64(0)) {
8370 id = types.ID(int64(0))
8371 }
8372 var arg0 interface{} = id
8373 if v, ok := arg0.(argumentDefaulter); ok {
8374 arg0 = v.setDefaults()
8375 }
8376 if index == 0 {
8377 index = 0
8378 }
8379 var arg1 interface{} = index
8380 if v, ok := arg1.(argumentDefaulter); ok {
8381 arg1 = v.setDefaults()
8382 }
8383 if condition == nil {
8384 condition = &MonitorCondition{}
8385 }
8386 var arg2 interface{} = condition
8387 if v, ok := arg2.(argumentDefaulter); ok {
8388 arg2 = v.setDefaults()
8389 }
8390 args := &struct {
8391 Arg0 interface{}
8392 Arg1 interface{}
8393 Arg2 interface{} `mapconv:",squash"`
8394 }{
8395 Arg0: arg0,
8396 Arg1: arg1,
8397 Arg2: arg2,
8398 }
8399
8400 v := &vPCRouterMonitorInterfaceRequestEnvelope{}
8401 if err := mapconv.ConvertTo(args, v); err != nil {
8402 return nil, err
8403 }
8404 return v, nil
8405 }
8406
8407 func (o *VPCRouterOp) transformMonitorInterfaceResults(data []byte) (*vPCRouterMonitorInterfaceResult, error) {
8408 nakedResponse := &vPCRouterMonitorInterfaceResponseEnvelope{}
8409 if err := json.Unmarshal(data, nakedResponse); err != nil {
8410 return nil, err
8411 }
8412
8413 results := &vPCRouterMonitorInterfaceResult{}
8414 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
8415 return nil, err
8416 }
8417 return results, nil
8418 }
8419
8420 func (o *VPCRouterOp) transformStatusResults(data []byte) (*vPCRouterStatusResult, error) {
8421 nakedResponse := &vPCRouterStatusResponseEnvelope{}
8422 if err := json.Unmarshal(data, nakedResponse); err != nil {
8423 return nil, err
8424 }
8425
8426 results := &vPCRouterStatusResult{}
8427 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
8428 return nil, err
8429 }
8430 return results, nil
8431 }
8432
8433 func (o *VPCRouterOp) transformLogsResults(data []byte) (*vPCRouterLogsResult, error) {
8434 nakedResponse := &vPCRouterLogsResponseEnvelope{}
8435 if err := json.Unmarshal(data, nakedResponse); err != nil {
8436 return nil, err
8437 }
8438
8439 results := &vPCRouterLogsResult{}
8440 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
8441 return nil, err
8442 }
8443 return results, nil
8444 }
8445
8446 func (o *VPCRouterOp) transformPingResults(data []byte) (*vPCRouterPingResult, error) {
8447 nakedResponse := &vPCRouterPingResponseEnvelope{}
8448 if err := json.Unmarshal(data, nakedResponse); err != nil {
8449 return nil, err
8450 }
8451
8452 results := &vPCRouterPingResult{}
8453 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
8454 return nil, err
8455 }
8456 return results, nil
8457 }
8458
8459 func (o *ZoneOp) transformFindArgs(conditions *FindCondition) (*zoneFindRequestEnvelope, error) {
8460 if conditions == nil {
8461 conditions = &FindCondition{}
8462 }
8463 var arg0 interface{} = conditions
8464 if v, ok := arg0.(argumentDefaulter); ok {
8465 arg0 = v.setDefaults()
8466 }
8467 args := &struct {
8468 Arg0 interface{} `mapconv:",squash"`
8469 }{
8470 Arg0: arg0,
8471 }
8472
8473 v := &zoneFindRequestEnvelope{}
8474 if err := mapconv.ConvertTo(args, v); err != nil {
8475 return nil, err
8476 }
8477 return v, nil
8478 }
8479
8480 func (o *ZoneOp) transformFindResults(data []byte) (*ZoneFindResult, error) {
8481 nakedResponse := &zoneFindResponseEnvelope{}
8482 if err := json.Unmarshal(data, nakedResponse); err != nil {
8483 return nil, err
8484 }
8485
8486 results := &ZoneFindResult{}
8487 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
8488 return nil, err
8489 }
8490 return results, nil
8491 }
8492
8493 func (o *ZoneOp) transformReadResults(data []byte) (*zoneReadResult, error) {
8494 nakedResponse := &zoneReadResponseEnvelope{}
8495 if err := json.Unmarshal(data, nakedResponse); err != nil {
8496 return nil, err
8497 }
8498
8499 results := &zoneReadResult{}
8500 if err := mapconv.ConvertFrom(nakedResponse, results); err != nil {
8501 return nil, err
8502 }
8503 return results, nil
8504 }
8505