deserializers.go raw
1 // Code generated by smithy-go-codegen DO NOT EDIT.
2
3 package sso
4
5 import (
6 "bytes"
7 "context"
8 "encoding/json"
9 "fmt"
10 "github.com/aws/aws-sdk-go-v2/aws/protocol/restjson"
11 "github.com/aws/aws-sdk-go-v2/service/sso/types"
12 smithy "github.com/aws/smithy-go"
13 smithyio "github.com/aws/smithy-go/io"
14 "github.com/aws/smithy-go/middleware"
15 "github.com/aws/smithy-go/ptr"
16 "github.com/aws/smithy-go/tracing"
17 smithyhttp "github.com/aws/smithy-go/transport/http"
18 "io"
19 "io/ioutil"
20 "strings"
21 )
22
23 type awsRestjson1_deserializeOpGetRoleCredentials struct {
24 }
25
26 func (*awsRestjson1_deserializeOpGetRoleCredentials) ID() string {
27 return "OperationDeserializer"
28 }
29
30 func (m *awsRestjson1_deserializeOpGetRoleCredentials) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
31 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
32 ) {
33 out, metadata, err = next.HandleDeserialize(ctx, in)
34 if err != nil {
35 return out, metadata, err
36 }
37
38 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
39 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
40 defer endTimer()
41 defer span.End()
42 response, ok := out.RawResponse.(*smithyhttp.Response)
43 if !ok {
44 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
45 }
46
47 if response.StatusCode < 200 || response.StatusCode >= 300 {
48 return out, metadata, awsRestjson1_deserializeOpErrorGetRoleCredentials(response, &metadata)
49 }
50 output := &GetRoleCredentialsOutput{}
51 out.Result = output
52
53 var buff [1024]byte
54 ringBuffer := smithyio.NewRingBuffer(buff[:])
55
56 body := io.TeeReader(response.Body, ringBuffer)
57
58 decoder := json.NewDecoder(body)
59 decoder.UseNumber()
60 var shape interface{}
61 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
62 var snapshot bytes.Buffer
63 io.Copy(&snapshot, ringBuffer)
64 err = &smithy.DeserializationError{
65 Err: fmt.Errorf("failed to decode response body, %w", err),
66 Snapshot: snapshot.Bytes(),
67 }
68 return out, metadata, err
69 }
70
71 err = awsRestjson1_deserializeOpDocumentGetRoleCredentialsOutput(&output, shape)
72 if err != nil {
73 var snapshot bytes.Buffer
74 io.Copy(&snapshot, ringBuffer)
75 return out, metadata, &smithy.DeserializationError{
76 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
77 Snapshot: snapshot.Bytes(),
78 }
79 }
80
81 span.End()
82 return out, metadata, err
83 }
84
85 func awsRestjson1_deserializeOpErrorGetRoleCredentials(response *smithyhttp.Response, metadata *middleware.Metadata) error {
86 var errorBuffer bytes.Buffer
87 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
88 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
89 }
90 errorBody := bytes.NewReader(errorBuffer.Bytes())
91
92 errorCode := "UnknownError"
93 errorMessage := errorCode
94
95 headerCode := response.Header.Get("X-Amzn-ErrorType")
96 if len(headerCode) != 0 {
97 errorCode = restjson.SanitizeErrorCode(headerCode)
98 }
99
100 var buff [1024]byte
101 ringBuffer := smithyio.NewRingBuffer(buff[:])
102
103 body := io.TeeReader(errorBody, ringBuffer)
104 decoder := json.NewDecoder(body)
105 decoder.UseNumber()
106 jsonCode, message, err := restjson.GetErrorInfo(decoder)
107 if err != nil {
108 var snapshot bytes.Buffer
109 io.Copy(&snapshot, ringBuffer)
110 err = &smithy.DeserializationError{
111 Err: fmt.Errorf("failed to decode response body, %w", err),
112 Snapshot: snapshot.Bytes(),
113 }
114 return err
115 }
116
117 errorBody.Seek(0, io.SeekStart)
118 if len(headerCode) == 0 && len(jsonCode) != 0 {
119 errorCode = restjson.SanitizeErrorCode(jsonCode)
120 }
121 if len(message) != 0 {
122 errorMessage = message
123 }
124
125 switch {
126 case strings.EqualFold("InvalidRequestException", errorCode):
127 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
128
129 case strings.EqualFold("ResourceNotFoundException", errorCode):
130 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
131
132 case strings.EqualFold("TooManyRequestsException", errorCode):
133 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody)
134
135 case strings.EqualFold("UnauthorizedException", errorCode):
136 return awsRestjson1_deserializeErrorUnauthorizedException(response, errorBody)
137
138 default:
139 genericError := &smithy.GenericAPIError{
140 Code: errorCode,
141 Message: errorMessage,
142 }
143 return genericError
144
145 }
146 }
147
148 func awsRestjson1_deserializeOpDocumentGetRoleCredentialsOutput(v **GetRoleCredentialsOutput, value interface{}) error {
149 if v == nil {
150 return fmt.Errorf("unexpected nil of type %T", v)
151 }
152 if value == nil {
153 return nil
154 }
155
156 shape, ok := value.(map[string]interface{})
157 if !ok {
158 return fmt.Errorf("unexpected JSON type %v", value)
159 }
160
161 var sv *GetRoleCredentialsOutput
162 if *v == nil {
163 sv = &GetRoleCredentialsOutput{}
164 } else {
165 sv = *v
166 }
167
168 for key, value := range shape {
169 switch key {
170 case "roleCredentials":
171 if err := awsRestjson1_deserializeDocumentRoleCredentials(&sv.RoleCredentials, value); err != nil {
172 return err
173 }
174
175 default:
176 _, _ = key, value
177
178 }
179 }
180 *v = sv
181 return nil
182 }
183
184 type awsRestjson1_deserializeOpListAccountRoles struct {
185 }
186
187 func (*awsRestjson1_deserializeOpListAccountRoles) ID() string {
188 return "OperationDeserializer"
189 }
190
191 func (m *awsRestjson1_deserializeOpListAccountRoles) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
192 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
193 ) {
194 out, metadata, err = next.HandleDeserialize(ctx, in)
195 if err != nil {
196 return out, metadata, err
197 }
198
199 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
200 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
201 defer endTimer()
202 defer span.End()
203 response, ok := out.RawResponse.(*smithyhttp.Response)
204 if !ok {
205 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
206 }
207
208 if response.StatusCode < 200 || response.StatusCode >= 300 {
209 return out, metadata, awsRestjson1_deserializeOpErrorListAccountRoles(response, &metadata)
210 }
211 output := &ListAccountRolesOutput{}
212 out.Result = output
213
214 var buff [1024]byte
215 ringBuffer := smithyio.NewRingBuffer(buff[:])
216
217 body := io.TeeReader(response.Body, ringBuffer)
218
219 decoder := json.NewDecoder(body)
220 decoder.UseNumber()
221 var shape interface{}
222 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
223 var snapshot bytes.Buffer
224 io.Copy(&snapshot, ringBuffer)
225 err = &smithy.DeserializationError{
226 Err: fmt.Errorf("failed to decode response body, %w", err),
227 Snapshot: snapshot.Bytes(),
228 }
229 return out, metadata, err
230 }
231
232 err = awsRestjson1_deserializeOpDocumentListAccountRolesOutput(&output, shape)
233 if err != nil {
234 var snapshot bytes.Buffer
235 io.Copy(&snapshot, ringBuffer)
236 return out, metadata, &smithy.DeserializationError{
237 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
238 Snapshot: snapshot.Bytes(),
239 }
240 }
241
242 span.End()
243 return out, metadata, err
244 }
245
246 func awsRestjson1_deserializeOpErrorListAccountRoles(response *smithyhttp.Response, metadata *middleware.Metadata) error {
247 var errorBuffer bytes.Buffer
248 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
249 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
250 }
251 errorBody := bytes.NewReader(errorBuffer.Bytes())
252
253 errorCode := "UnknownError"
254 errorMessage := errorCode
255
256 headerCode := response.Header.Get("X-Amzn-ErrorType")
257 if len(headerCode) != 0 {
258 errorCode = restjson.SanitizeErrorCode(headerCode)
259 }
260
261 var buff [1024]byte
262 ringBuffer := smithyio.NewRingBuffer(buff[:])
263
264 body := io.TeeReader(errorBody, ringBuffer)
265 decoder := json.NewDecoder(body)
266 decoder.UseNumber()
267 jsonCode, message, err := restjson.GetErrorInfo(decoder)
268 if err != nil {
269 var snapshot bytes.Buffer
270 io.Copy(&snapshot, ringBuffer)
271 err = &smithy.DeserializationError{
272 Err: fmt.Errorf("failed to decode response body, %w", err),
273 Snapshot: snapshot.Bytes(),
274 }
275 return err
276 }
277
278 errorBody.Seek(0, io.SeekStart)
279 if len(headerCode) == 0 && len(jsonCode) != 0 {
280 errorCode = restjson.SanitizeErrorCode(jsonCode)
281 }
282 if len(message) != 0 {
283 errorMessage = message
284 }
285
286 switch {
287 case strings.EqualFold("InvalidRequestException", errorCode):
288 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
289
290 case strings.EqualFold("ResourceNotFoundException", errorCode):
291 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
292
293 case strings.EqualFold("TooManyRequestsException", errorCode):
294 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody)
295
296 case strings.EqualFold("UnauthorizedException", errorCode):
297 return awsRestjson1_deserializeErrorUnauthorizedException(response, errorBody)
298
299 default:
300 genericError := &smithy.GenericAPIError{
301 Code: errorCode,
302 Message: errorMessage,
303 }
304 return genericError
305
306 }
307 }
308
309 func awsRestjson1_deserializeOpDocumentListAccountRolesOutput(v **ListAccountRolesOutput, value interface{}) error {
310 if v == nil {
311 return fmt.Errorf("unexpected nil of type %T", v)
312 }
313 if value == nil {
314 return nil
315 }
316
317 shape, ok := value.(map[string]interface{})
318 if !ok {
319 return fmt.Errorf("unexpected JSON type %v", value)
320 }
321
322 var sv *ListAccountRolesOutput
323 if *v == nil {
324 sv = &ListAccountRolesOutput{}
325 } else {
326 sv = *v
327 }
328
329 for key, value := range shape {
330 switch key {
331 case "nextToken":
332 if value != nil {
333 jtv, ok := value.(string)
334 if !ok {
335 return fmt.Errorf("expected NextTokenType to be of type string, got %T instead", value)
336 }
337 sv.NextToken = ptr.String(jtv)
338 }
339
340 case "roleList":
341 if err := awsRestjson1_deserializeDocumentRoleListType(&sv.RoleList, value); err != nil {
342 return err
343 }
344
345 default:
346 _, _ = key, value
347
348 }
349 }
350 *v = sv
351 return nil
352 }
353
354 type awsRestjson1_deserializeOpListAccounts struct {
355 }
356
357 func (*awsRestjson1_deserializeOpListAccounts) ID() string {
358 return "OperationDeserializer"
359 }
360
361 func (m *awsRestjson1_deserializeOpListAccounts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
362 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
363 ) {
364 out, metadata, err = next.HandleDeserialize(ctx, in)
365 if err != nil {
366 return out, metadata, err
367 }
368
369 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
370 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
371 defer endTimer()
372 defer span.End()
373 response, ok := out.RawResponse.(*smithyhttp.Response)
374 if !ok {
375 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
376 }
377
378 if response.StatusCode < 200 || response.StatusCode >= 300 {
379 return out, metadata, awsRestjson1_deserializeOpErrorListAccounts(response, &metadata)
380 }
381 output := &ListAccountsOutput{}
382 out.Result = output
383
384 var buff [1024]byte
385 ringBuffer := smithyio.NewRingBuffer(buff[:])
386
387 body := io.TeeReader(response.Body, ringBuffer)
388
389 decoder := json.NewDecoder(body)
390 decoder.UseNumber()
391 var shape interface{}
392 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
393 var snapshot bytes.Buffer
394 io.Copy(&snapshot, ringBuffer)
395 err = &smithy.DeserializationError{
396 Err: fmt.Errorf("failed to decode response body, %w", err),
397 Snapshot: snapshot.Bytes(),
398 }
399 return out, metadata, err
400 }
401
402 err = awsRestjson1_deserializeOpDocumentListAccountsOutput(&output, shape)
403 if err != nil {
404 var snapshot bytes.Buffer
405 io.Copy(&snapshot, ringBuffer)
406 return out, metadata, &smithy.DeserializationError{
407 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
408 Snapshot: snapshot.Bytes(),
409 }
410 }
411
412 span.End()
413 return out, metadata, err
414 }
415
416 func awsRestjson1_deserializeOpErrorListAccounts(response *smithyhttp.Response, metadata *middleware.Metadata) error {
417 var errorBuffer bytes.Buffer
418 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
419 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
420 }
421 errorBody := bytes.NewReader(errorBuffer.Bytes())
422
423 errorCode := "UnknownError"
424 errorMessage := errorCode
425
426 headerCode := response.Header.Get("X-Amzn-ErrorType")
427 if len(headerCode) != 0 {
428 errorCode = restjson.SanitizeErrorCode(headerCode)
429 }
430
431 var buff [1024]byte
432 ringBuffer := smithyio.NewRingBuffer(buff[:])
433
434 body := io.TeeReader(errorBody, ringBuffer)
435 decoder := json.NewDecoder(body)
436 decoder.UseNumber()
437 jsonCode, message, err := restjson.GetErrorInfo(decoder)
438 if err != nil {
439 var snapshot bytes.Buffer
440 io.Copy(&snapshot, ringBuffer)
441 err = &smithy.DeserializationError{
442 Err: fmt.Errorf("failed to decode response body, %w", err),
443 Snapshot: snapshot.Bytes(),
444 }
445 return err
446 }
447
448 errorBody.Seek(0, io.SeekStart)
449 if len(headerCode) == 0 && len(jsonCode) != 0 {
450 errorCode = restjson.SanitizeErrorCode(jsonCode)
451 }
452 if len(message) != 0 {
453 errorMessage = message
454 }
455
456 switch {
457 case strings.EqualFold("InvalidRequestException", errorCode):
458 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
459
460 case strings.EqualFold("ResourceNotFoundException", errorCode):
461 return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
462
463 case strings.EqualFold("TooManyRequestsException", errorCode):
464 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody)
465
466 case strings.EqualFold("UnauthorizedException", errorCode):
467 return awsRestjson1_deserializeErrorUnauthorizedException(response, errorBody)
468
469 default:
470 genericError := &smithy.GenericAPIError{
471 Code: errorCode,
472 Message: errorMessage,
473 }
474 return genericError
475
476 }
477 }
478
479 func awsRestjson1_deserializeOpDocumentListAccountsOutput(v **ListAccountsOutput, value interface{}) error {
480 if v == nil {
481 return fmt.Errorf("unexpected nil of type %T", v)
482 }
483 if value == nil {
484 return nil
485 }
486
487 shape, ok := value.(map[string]interface{})
488 if !ok {
489 return fmt.Errorf("unexpected JSON type %v", value)
490 }
491
492 var sv *ListAccountsOutput
493 if *v == nil {
494 sv = &ListAccountsOutput{}
495 } else {
496 sv = *v
497 }
498
499 for key, value := range shape {
500 switch key {
501 case "accountList":
502 if err := awsRestjson1_deserializeDocumentAccountListType(&sv.AccountList, value); err != nil {
503 return err
504 }
505
506 case "nextToken":
507 if value != nil {
508 jtv, ok := value.(string)
509 if !ok {
510 return fmt.Errorf("expected NextTokenType to be of type string, got %T instead", value)
511 }
512 sv.NextToken = ptr.String(jtv)
513 }
514
515 default:
516 _, _ = key, value
517
518 }
519 }
520 *v = sv
521 return nil
522 }
523
524 type awsRestjson1_deserializeOpLogout struct {
525 }
526
527 func (*awsRestjson1_deserializeOpLogout) ID() string {
528 return "OperationDeserializer"
529 }
530
531 func (m *awsRestjson1_deserializeOpLogout) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
532 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
533 ) {
534 out, metadata, err = next.HandleDeserialize(ctx, in)
535 if err != nil {
536 return out, metadata, err
537 }
538
539 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
540 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
541 defer endTimer()
542 defer span.End()
543 response, ok := out.RawResponse.(*smithyhttp.Response)
544 if !ok {
545 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
546 }
547
548 if response.StatusCode < 200 || response.StatusCode >= 300 {
549 return out, metadata, awsRestjson1_deserializeOpErrorLogout(response, &metadata)
550 }
551 output := &LogoutOutput{}
552 out.Result = output
553
554 if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
555 return out, metadata, &smithy.DeserializationError{
556 Err: fmt.Errorf("failed to discard response body, %w", err),
557 }
558 }
559
560 span.End()
561 return out, metadata, err
562 }
563
564 func awsRestjson1_deserializeOpErrorLogout(response *smithyhttp.Response, metadata *middleware.Metadata) error {
565 var errorBuffer bytes.Buffer
566 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
567 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
568 }
569 errorBody := bytes.NewReader(errorBuffer.Bytes())
570
571 errorCode := "UnknownError"
572 errorMessage := errorCode
573
574 headerCode := response.Header.Get("X-Amzn-ErrorType")
575 if len(headerCode) != 0 {
576 errorCode = restjson.SanitizeErrorCode(headerCode)
577 }
578
579 var buff [1024]byte
580 ringBuffer := smithyio.NewRingBuffer(buff[:])
581
582 body := io.TeeReader(errorBody, ringBuffer)
583 decoder := json.NewDecoder(body)
584 decoder.UseNumber()
585 jsonCode, message, err := restjson.GetErrorInfo(decoder)
586 if err != nil {
587 var snapshot bytes.Buffer
588 io.Copy(&snapshot, ringBuffer)
589 err = &smithy.DeserializationError{
590 Err: fmt.Errorf("failed to decode response body, %w", err),
591 Snapshot: snapshot.Bytes(),
592 }
593 return err
594 }
595
596 errorBody.Seek(0, io.SeekStart)
597 if len(headerCode) == 0 && len(jsonCode) != 0 {
598 errorCode = restjson.SanitizeErrorCode(jsonCode)
599 }
600 if len(message) != 0 {
601 errorMessage = message
602 }
603
604 switch {
605 case strings.EqualFold("InvalidRequestException", errorCode):
606 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
607
608 case strings.EqualFold("TooManyRequestsException", errorCode):
609 return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody)
610
611 case strings.EqualFold("UnauthorizedException", errorCode):
612 return awsRestjson1_deserializeErrorUnauthorizedException(response, errorBody)
613
614 default:
615 genericError := &smithy.GenericAPIError{
616 Code: errorCode,
617 Message: errorMessage,
618 }
619 return genericError
620
621 }
622 }
623
624 func awsRestjson1_deserializeErrorInvalidRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
625 output := &types.InvalidRequestException{}
626 var buff [1024]byte
627 ringBuffer := smithyio.NewRingBuffer(buff[:])
628
629 body := io.TeeReader(errorBody, ringBuffer)
630 decoder := json.NewDecoder(body)
631 decoder.UseNumber()
632 var shape interface{}
633 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
634 var snapshot bytes.Buffer
635 io.Copy(&snapshot, ringBuffer)
636 err = &smithy.DeserializationError{
637 Err: fmt.Errorf("failed to decode response body, %w", err),
638 Snapshot: snapshot.Bytes(),
639 }
640 return err
641 }
642
643 err := awsRestjson1_deserializeDocumentInvalidRequestException(&output, shape)
644
645 if err != nil {
646 var snapshot bytes.Buffer
647 io.Copy(&snapshot, ringBuffer)
648 err = &smithy.DeserializationError{
649 Err: fmt.Errorf("failed to decode response body, %w", err),
650 Snapshot: snapshot.Bytes(),
651 }
652 return err
653 }
654
655 errorBody.Seek(0, io.SeekStart)
656
657 return output
658 }
659
660 func awsRestjson1_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
661 output := &types.ResourceNotFoundException{}
662 var buff [1024]byte
663 ringBuffer := smithyio.NewRingBuffer(buff[:])
664
665 body := io.TeeReader(errorBody, ringBuffer)
666 decoder := json.NewDecoder(body)
667 decoder.UseNumber()
668 var shape interface{}
669 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
670 var snapshot bytes.Buffer
671 io.Copy(&snapshot, ringBuffer)
672 err = &smithy.DeserializationError{
673 Err: fmt.Errorf("failed to decode response body, %w", err),
674 Snapshot: snapshot.Bytes(),
675 }
676 return err
677 }
678
679 err := awsRestjson1_deserializeDocumentResourceNotFoundException(&output, shape)
680
681 if err != nil {
682 var snapshot bytes.Buffer
683 io.Copy(&snapshot, ringBuffer)
684 err = &smithy.DeserializationError{
685 Err: fmt.Errorf("failed to decode response body, %w", err),
686 Snapshot: snapshot.Bytes(),
687 }
688 return err
689 }
690
691 errorBody.Seek(0, io.SeekStart)
692
693 return output
694 }
695
696 func awsRestjson1_deserializeErrorTooManyRequestsException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
697 output := &types.TooManyRequestsException{}
698 var buff [1024]byte
699 ringBuffer := smithyio.NewRingBuffer(buff[:])
700
701 body := io.TeeReader(errorBody, ringBuffer)
702 decoder := json.NewDecoder(body)
703 decoder.UseNumber()
704 var shape interface{}
705 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
706 var snapshot bytes.Buffer
707 io.Copy(&snapshot, ringBuffer)
708 err = &smithy.DeserializationError{
709 Err: fmt.Errorf("failed to decode response body, %w", err),
710 Snapshot: snapshot.Bytes(),
711 }
712 return err
713 }
714
715 err := awsRestjson1_deserializeDocumentTooManyRequestsException(&output, shape)
716
717 if err != nil {
718 var snapshot bytes.Buffer
719 io.Copy(&snapshot, ringBuffer)
720 err = &smithy.DeserializationError{
721 Err: fmt.Errorf("failed to decode response body, %w", err),
722 Snapshot: snapshot.Bytes(),
723 }
724 return err
725 }
726
727 errorBody.Seek(0, io.SeekStart)
728
729 return output
730 }
731
732 func awsRestjson1_deserializeErrorUnauthorizedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
733 output := &types.UnauthorizedException{}
734 var buff [1024]byte
735 ringBuffer := smithyio.NewRingBuffer(buff[:])
736
737 body := io.TeeReader(errorBody, ringBuffer)
738 decoder := json.NewDecoder(body)
739 decoder.UseNumber()
740 var shape interface{}
741 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
742 var snapshot bytes.Buffer
743 io.Copy(&snapshot, ringBuffer)
744 err = &smithy.DeserializationError{
745 Err: fmt.Errorf("failed to decode response body, %w", err),
746 Snapshot: snapshot.Bytes(),
747 }
748 return err
749 }
750
751 err := awsRestjson1_deserializeDocumentUnauthorizedException(&output, shape)
752
753 if err != nil {
754 var snapshot bytes.Buffer
755 io.Copy(&snapshot, ringBuffer)
756 err = &smithy.DeserializationError{
757 Err: fmt.Errorf("failed to decode response body, %w", err),
758 Snapshot: snapshot.Bytes(),
759 }
760 return err
761 }
762
763 errorBody.Seek(0, io.SeekStart)
764
765 return output
766 }
767
768 func awsRestjson1_deserializeDocumentAccountInfo(v **types.AccountInfo, value interface{}) error {
769 if v == nil {
770 return fmt.Errorf("unexpected nil of type %T", v)
771 }
772 if value == nil {
773 return nil
774 }
775
776 shape, ok := value.(map[string]interface{})
777 if !ok {
778 return fmt.Errorf("unexpected JSON type %v", value)
779 }
780
781 var sv *types.AccountInfo
782 if *v == nil {
783 sv = &types.AccountInfo{}
784 } else {
785 sv = *v
786 }
787
788 for key, value := range shape {
789 switch key {
790 case "accountId":
791 if value != nil {
792 jtv, ok := value.(string)
793 if !ok {
794 return fmt.Errorf("expected AccountIdType to be of type string, got %T instead", value)
795 }
796 sv.AccountId = ptr.String(jtv)
797 }
798
799 case "accountName":
800 if value != nil {
801 jtv, ok := value.(string)
802 if !ok {
803 return fmt.Errorf("expected AccountNameType to be of type string, got %T instead", value)
804 }
805 sv.AccountName = ptr.String(jtv)
806 }
807
808 case "emailAddress":
809 if value != nil {
810 jtv, ok := value.(string)
811 if !ok {
812 return fmt.Errorf("expected EmailAddressType to be of type string, got %T instead", value)
813 }
814 sv.EmailAddress = ptr.String(jtv)
815 }
816
817 default:
818 _, _ = key, value
819
820 }
821 }
822 *v = sv
823 return nil
824 }
825
826 func awsRestjson1_deserializeDocumentAccountListType(v *[]types.AccountInfo, value interface{}) error {
827 if v == nil {
828 return fmt.Errorf("unexpected nil of type %T", v)
829 }
830 if value == nil {
831 return nil
832 }
833
834 shape, ok := value.([]interface{})
835 if !ok {
836 return fmt.Errorf("unexpected JSON type %v", value)
837 }
838
839 var cv []types.AccountInfo
840 if *v == nil {
841 cv = []types.AccountInfo{}
842 } else {
843 cv = *v
844 }
845
846 for _, value := range shape {
847 var col types.AccountInfo
848 destAddr := &col
849 if err := awsRestjson1_deserializeDocumentAccountInfo(&destAddr, value); err != nil {
850 return err
851 }
852 col = *destAddr
853 cv = append(cv, col)
854
855 }
856 *v = cv
857 return nil
858 }
859
860 func awsRestjson1_deserializeDocumentInvalidRequestException(v **types.InvalidRequestException, value interface{}) error {
861 if v == nil {
862 return fmt.Errorf("unexpected nil of type %T", v)
863 }
864 if value == nil {
865 return nil
866 }
867
868 shape, ok := value.(map[string]interface{})
869 if !ok {
870 return fmt.Errorf("unexpected JSON type %v", value)
871 }
872
873 var sv *types.InvalidRequestException
874 if *v == nil {
875 sv = &types.InvalidRequestException{}
876 } else {
877 sv = *v
878 }
879
880 for key, value := range shape {
881 switch key {
882 case "message", "Message":
883 if value != nil {
884 jtv, ok := value.(string)
885 if !ok {
886 return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
887 }
888 sv.Message = ptr.String(jtv)
889 }
890
891 default:
892 _, _ = key, value
893
894 }
895 }
896 *v = sv
897 return nil
898 }
899
900 func awsRestjson1_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error {
901 if v == nil {
902 return fmt.Errorf("unexpected nil of type %T", v)
903 }
904 if value == nil {
905 return nil
906 }
907
908 shape, ok := value.(map[string]interface{})
909 if !ok {
910 return fmt.Errorf("unexpected JSON type %v", value)
911 }
912
913 var sv *types.ResourceNotFoundException
914 if *v == nil {
915 sv = &types.ResourceNotFoundException{}
916 } else {
917 sv = *v
918 }
919
920 for key, value := range shape {
921 switch key {
922 case "message", "Message":
923 if value != nil {
924 jtv, ok := value.(string)
925 if !ok {
926 return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
927 }
928 sv.Message = ptr.String(jtv)
929 }
930
931 default:
932 _, _ = key, value
933
934 }
935 }
936 *v = sv
937 return nil
938 }
939
940 func awsRestjson1_deserializeDocumentRoleCredentials(v **types.RoleCredentials, value interface{}) error {
941 if v == nil {
942 return fmt.Errorf("unexpected nil of type %T", v)
943 }
944 if value == nil {
945 return nil
946 }
947
948 shape, ok := value.(map[string]interface{})
949 if !ok {
950 return fmt.Errorf("unexpected JSON type %v", value)
951 }
952
953 var sv *types.RoleCredentials
954 if *v == nil {
955 sv = &types.RoleCredentials{}
956 } else {
957 sv = *v
958 }
959
960 for key, value := range shape {
961 switch key {
962 case "accessKeyId":
963 if value != nil {
964 jtv, ok := value.(string)
965 if !ok {
966 return fmt.Errorf("expected AccessKeyType to be of type string, got %T instead", value)
967 }
968 sv.AccessKeyId = ptr.String(jtv)
969 }
970
971 case "expiration":
972 if value != nil {
973 jtv, ok := value.(json.Number)
974 if !ok {
975 return fmt.Errorf("expected ExpirationTimestampType to be json.Number, got %T instead", value)
976 }
977 i64, err := jtv.Int64()
978 if err != nil {
979 return err
980 }
981 sv.Expiration = i64
982 }
983
984 case "secretAccessKey":
985 if value != nil {
986 jtv, ok := value.(string)
987 if !ok {
988 return fmt.Errorf("expected SecretAccessKeyType to be of type string, got %T instead", value)
989 }
990 sv.SecretAccessKey = ptr.String(jtv)
991 }
992
993 case "sessionToken":
994 if value != nil {
995 jtv, ok := value.(string)
996 if !ok {
997 return fmt.Errorf("expected SessionTokenType to be of type string, got %T instead", value)
998 }
999 sv.SessionToken = ptr.String(jtv)
1000 }
1001
1002 default:
1003 _, _ = key, value
1004
1005 }
1006 }
1007 *v = sv
1008 return nil
1009 }
1010
1011 func awsRestjson1_deserializeDocumentRoleInfo(v **types.RoleInfo, value interface{}) error {
1012 if v == nil {
1013 return fmt.Errorf("unexpected nil of type %T", v)
1014 }
1015 if value == nil {
1016 return nil
1017 }
1018
1019 shape, ok := value.(map[string]interface{})
1020 if !ok {
1021 return fmt.Errorf("unexpected JSON type %v", value)
1022 }
1023
1024 var sv *types.RoleInfo
1025 if *v == nil {
1026 sv = &types.RoleInfo{}
1027 } else {
1028 sv = *v
1029 }
1030
1031 for key, value := range shape {
1032 switch key {
1033 case "accountId":
1034 if value != nil {
1035 jtv, ok := value.(string)
1036 if !ok {
1037 return fmt.Errorf("expected AccountIdType to be of type string, got %T instead", value)
1038 }
1039 sv.AccountId = ptr.String(jtv)
1040 }
1041
1042 case "roleName":
1043 if value != nil {
1044 jtv, ok := value.(string)
1045 if !ok {
1046 return fmt.Errorf("expected RoleNameType to be of type string, got %T instead", value)
1047 }
1048 sv.RoleName = ptr.String(jtv)
1049 }
1050
1051 default:
1052 _, _ = key, value
1053
1054 }
1055 }
1056 *v = sv
1057 return nil
1058 }
1059
1060 func awsRestjson1_deserializeDocumentRoleListType(v *[]types.RoleInfo, value interface{}) error {
1061 if v == nil {
1062 return fmt.Errorf("unexpected nil of type %T", v)
1063 }
1064 if value == nil {
1065 return nil
1066 }
1067
1068 shape, ok := value.([]interface{})
1069 if !ok {
1070 return fmt.Errorf("unexpected JSON type %v", value)
1071 }
1072
1073 var cv []types.RoleInfo
1074 if *v == nil {
1075 cv = []types.RoleInfo{}
1076 } else {
1077 cv = *v
1078 }
1079
1080 for _, value := range shape {
1081 var col types.RoleInfo
1082 destAddr := &col
1083 if err := awsRestjson1_deserializeDocumentRoleInfo(&destAddr, value); err != nil {
1084 return err
1085 }
1086 col = *destAddr
1087 cv = append(cv, col)
1088
1089 }
1090 *v = cv
1091 return nil
1092 }
1093
1094 func awsRestjson1_deserializeDocumentTooManyRequestsException(v **types.TooManyRequestsException, value interface{}) error {
1095 if v == nil {
1096 return fmt.Errorf("unexpected nil of type %T", v)
1097 }
1098 if value == nil {
1099 return nil
1100 }
1101
1102 shape, ok := value.(map[string]interface{})
1103 if !ok {
1104 return fmt.Errorf("unexpected JSON type %v", value)
1105 }
1106
1107 var sv *types.TooManyRequestsException
1108 if *v == nil {
1109 sv = &types.TooManyRequestsException{}
1110 } else {
1111 sv = *v
1112 }
1113
1114 for key, value := range shape {
1115 switch key {
1116 case "message", "Message":
1117 if value != nil {
1118 jtv, ok := value.(string)
1119 if !ok {
1120 return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
1121 }
1122 sv.Message = ptr.String(jtv)
1123 }
1124
1125 default:
1126 _, _ = key, value
1127
1128 }
1129 }
1130 *v = sv
1131 return nil
1132 }
1133
1134 func awsRestjson1_deserializeDocumentUnauthorizedException(v **types.UnauthorizedException, value interface{}) error {
1135 if v == nil {
1136 return fmt.Errorf("unexpected nil of type %T", v)
1137 }
1138 if value == nil {
1139 return nil
1140 }
1141
1142 shape, ok := value.(map[string]interface{})
1143 if !ok {
1144 return fmt.Errorf("unexpected JSON type %v", value)
1145 }
1146
1147 var sv *types.UnauthorizedException
1148 if *v == nil {
1149 sv = &types.UnauthorizedException{}
1150 } else {
1151 sv = *v
1152 }
1153
1154 for key, value := range shape {
1155 switch key {
1156 case "message", "Message":
1157 if value != nil {
1158 jtv, ok := value.(string)
1159 if !ok {
1160 return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
1161 }
1162 sv.Message = ptr.String(jtv)
1163 }
1164
1165 default:
1166 _, _ = key, value
1167
1168 }
1169 }
1170 *v = sv
1171 return nil
1172 }
1173