1
2
3 package ssooidc
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/ssooidc/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 smithyhttp "github.com/aws/smithy-go/transport/http"
17 "io"
18 "strings"
19 )
20
21 type awsRestjson1_deserializeOpCreateToken struct {
22 }
23
24 func (*awsRestjson1_deserializeOpCreateToken) ID() string {
25 return "OperationDeserializer"
26 }
27
28 func (m *awsRestjson1_deserializeOpCreateToken) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
29 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
30 ) {
31 out, metadata, err = next.HandleDeserialize(ctx, in)
32 if err != nil {
33 return out, metadata, err
34 }
35
36 response, ok := out.RawResponse.(*smithyhttp.Response)
37 if !ok {
38 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
39 }
40
41 if response.StatusCode < 200 || response.StatusCode >= 300 {
42 return out, metadata, awsRestjson1_deserializeOpErrorCreateToken(response, &metadata)
43 }
44 output := &CreateTokenOutput{}
45 out.Result = output
46
47 var buff [1024]byte
48 ringBuffer := smithyio.NewRingBuffer(buff[:])
49
50 body := io.TeeReader(response.Body, ringBuffer)
51
52 decoder := json.NewDecoder(body)
53 decoder.UseNumber()
54 var shape interface{}
55 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
56 var snapshot bytes.Buffer
57 io.Copy(&snapshot, ringBuffer)
58 err = &smithy.DeserializationError{
59 Err: fmt.Errorf("failed to decode response body, %w", err),
60 Snapshot: snapshot.Bytes(),
61 }
62 return out, metadata, err
63 }
64
65 err = awsRestjson1_deserializeOpDocumentCreateTokenOutput(&output, shape)
66 if err != nil {
67 var snapshot bytes.Buffer
68 io.Copy(&snapshot, ringBuffer)
69 return out, metadata, &smithy.DeserializationError{
70 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
71 Snapshot: snapshot.Bytes(),
72 }
73 }
74
75 return out, metadata, err
76 }
77
78 func awsRestjson1_deserializeOpErrorCreateToken(response *smithyhttp.Response, metadata *middleware.Metadata) error {
79 var errorBuffer bytes.Buffer
80 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
81 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
82 }
83 errorBody := bytes.NewReader(errorBuffer.Bytes())
84
85 errorCode := "UnknownError"
86 errorMessage := errorCode
87
88 headerCode := response.Header.Get("X-Amzn-ErrorType")
89 if len(headerCode) != 0 {
90 errorCode = restjson.SanitizeErrorCode(headerCode)
91 }
92
93 var buff [1024]byte
94 ringBuffer := smithyio.NewRingBuffer(buff[:])
95
96 body := io.TeeReader(errorBody, ringBuffer)
97 decoder := json.NewDecoder(body)
98 decoder.UseNumber()
99 jsonCode, message, err := restjson.GetErrorInfo(decoder)
100 if err != nil {
101 var snapshot bytes.Buffer
102 io.Copy(&snapshot, ringBuffer)
103 err = &smithy.DeserializationError{
104 Err: fmt.Errorf("failed to decode response body, %w", err),
105 Snapshot: snapshot.Bytes(),
106 }
107 return err
108 }
109
110 errorBody.Seek(0, io.SeekStart)
111 if len(headerCode) == 0 && len(jsonCode) != 0 {
112 errorCode = restjson.SanitizeErrorCode(jsonCode)
113 }
114 if len(message) != 0 {
115 errorMessage = message
116 }
117
118 switch {
119 case strings.EqualFold("AccessDeniedException", errorCode):
120 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
121
122 case strings.EqualFold("AuthorizationPendingException", errorCode):
123 return awsRestjson1_deserializeErrorAuthorizationPendingException(response, errorBody)
124
125 case strings.EqualFold("ExpiredTokenException", errorCode):
126 return awsRestjson1_deserializeErrorExpiredTokenException(response, errorBody)
127
128 case strings.EqualFold("InternalServerException", errorCode):
129 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
130
131 case strings.EqualFold("InvalidClientException", errorCode):
132 return awsRestjson1_deserializeErrorInvalidClientException(response, errorBody)
133
134 case strings.EqualFold("InvalidGrantException", errorCode):
135 return awsRestjson1_deserializeErrorInvalidGrantException(response, errorBody)
136
137 case strings.EqualFold("InvalidRequestException", errorCode):
138 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
139
140 case strings.EqualFold("InvalidScopeException", errorCode):
141 return awsRestjson1_deserializeErrorInvalidScopeException(response, errorBody)
142
143 case strings.EqualFold("SlowDownException", errorCode):
144 return awsRestjson1_deserializeErrorSlowDownException(response, errorBody)
145
146 case strings.EqualFold("UnauthorizedClientException", errorCode):
147 return awsRestjson1_deserializeErrorUnauthorizedClientException(response, errorBody)
148
149 case strings.EqualFold("UnsupportedGrantTypeException", errorCode):
150 return awsRestjson1_deserializeErrorUnsupportedGrantTypeException(response, errorBody)
151
152 default:
153 genericError := &smithy.GenericAPIError{
154 Code: errorCode,
155 Message: errorMessage,
156 }
157 return genericError
158
159 }
160 }
161
162 func awsRestjson1_deserializeOpDocumentCreateTokenOutput(v **CreateTokenOutput, value interface{}) error {
163 if v == nil {
164 return fmt.Errorf("unexpected nil of type %T", v)
165 }
166 if value == nil {
167 return nil
168 }
169
170 shape, ok := value.(map[string]interface{})
171 if !ok {
172 return fmt.Errorf("unexpected JSON type %v", value)
173 }
174
175 var sv *CreateTokenOutput
176 if *v == nil {
177 sv = &CreateTokenOutput{}
178 } else {
179 sv = *v
180 }
181
182 for key, value := range shape {
183 switch key {
184 case "accessToken":
185 if value != nil {
186 jtv, ok := value.(string)
187 if !ok {
188 return fmt.Errorf("expected AccessToken to be of type string, got %T instead", value)
189 }
190 sv.AccessToken = ptr.String(jtv)
191 }
192
193 case "expiresIn":
194 if value != nil {
195 jtv, ok := value.(json.Number)
196 if !ok {
197 return fmt.Errorf("expected ExpirationInSeconds to be json.Number, got %T instead", value)
198 }
199 i64, err := jtv.Int64()
200 if err != nil {
201 return err
202 }
203 sv.ExpiresIn = int32(i64)
204 }
205
206 case "idToken":
207 if value != nil {
208 jtv, ok := value.(string)
209 if !ok {
210 return fmt.Errorf("expected IdToken to be of type string, got %T instead", value)
211 }
212 sv.IdToken = ptr.String(jtv)
213 }
214
215 case "refreshToken":
216 if value != nil {
217 jtv, ok := value.(string)
218 if !ok {
219 return fmt.Errorf("expected RefreshToken to be of type string, got %T instead", value)
220 }
221 sv.RefreshToken = ptr.String(jtv)
222 }
223
224 case "tokenType":
225 if value != nil {
226 jtv, ok := value.(string)
227 if !ok {
228 return fmt.Errorf("expected TokenType to be of type string, got %T instead", value)
229 }
230 sv.TokenType = ptr.String(jtv)
231 }
232
233 default:
234 _, _ = key, value
235
236 }
237 }
238 *v = sv
239 return nil
240 }
241
242 type awsRestjson1_deserializeOpCreateTokenWithIAM struct {
243 }
244
245 func (*awsRestjson1_deserializeOpCreateTokenWithIAM) ID() string {
246 return "OperationDeserializer"
247 }
248
249 func (m *awsRestjson1_deserializeOpCreateTokenWithIAM) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
250 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
251 ) {
252 out, metadata, err = next.HandleDeserialize(ctx, in)
253 if err != nil {
254 return out, metadata, err
255 }
256
257 response, ok := out.RawResponse.(*smithyhttp.Response)
258 if !ok {
259 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
260 }
261
262 if response.StatusCode < 200 || response.StatusCode >= 300 {
263 return out, metadata, awsRestjson1_deserializeOpErrorCreateTokenWithIAM(response, &metadata)
264 }
265 output := &CreateTokenWithIAMOutput{}
266 out.Result = output
267
268 var buff [1024]byte
269 ringBuffer := smithyio.NewRingBuffer(buff[:])
270
271 body := io.TeeReader(response.Body, ringBuffer)
272
273 decoder := json.NewDecoder(body)
274 decoder.UseNumber()
275 var shape interface{}
276 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
277 var snapshot bytes.Buffer
278 io.Copy(&snapshot, ringBuffer)
279 err = &smithy.DeserializationError{
280 Err: fmt.Errorf("failed to decode response body, %w", err),
281 Snapshot: snapshot.Bytes(),
282 }
283 return out, metadata, err
284 }
285
286 err = awsRestjson1_deserializeOpDocumentCreateTokenWithIAMOutput(&output, shape)
287 if err != nil {
288 var snapshot bytes.Buffer
289 io.Copy(&snapshot, ringBuffer)
290 return out, metadata, &smithy.DeserializationError{
291 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
292 Snapshot: snapshot.Bytes(),
293 }
294 }
295
296 return out, metadata, err
297 }
298
299 func awsRestjson1_deserializeOpErrorCreateTokenWithIAM(response *smithyhttp.Response, metadata *middleware.Metadata) error {
300 var errorBuffer bytes.Buffer
301 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
302 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
303 }
304 errorBody := bytes.NewReader(errorBuffer.Bytes())
305
306 errorCode := "UnknownError"
307 errorMessage := errorCode
308
309 headerCode := response.Header.Get("X-Amzn-ErrorType")
310 if len(headerCode) != 0 {
311 errorCode = restjson.SanitizeErrorCode(headerCode)
312 }
313
314 var buff [1024]byte
315 ringBuffer := smithyio.NewRingBuffer(buff[:])
316
317 body := io.TeeReader(errorBody, ringBuffer)
318 decoder := json.NewDecoder(body)
319 decoder.UseNumber()
320 jsonCode, message, err := restjson.GetErrorInfo(decoder)
321 if err != nil {
322 var snapshot bytes.Buffer
323 io.Copy(&snapshot, ringBuffer)
324 err = &smithy.DeserializationError{
325 Err: fmt.Errorf("failed to decode response body, %w", err),
326 Snapshot: snapshot.Bytes(),
327 }
328 return err
329 }
330
331 errorBody.Seek(0, io.SeekStart)
332 if len(headerCode) == 0 && len(jsonCode) != 0 {
333 errorCode = restjson.SanitizeErrorCode(jsonCode)
334 }
335 if len(message) != 0 {
336 errorMessage = message
337 }
338
339 switch {
340 case strings.EqualFold("AccessDeniedException", errorCode):
341 return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
342
343 case strings.EqualFold("AuthorizationPendingException", errorCode):
344 return awsRestjson1_deserializeErrorAuthorizationPendingException(response, errorBody)
345
346 case strings.EqualFold("ExpiredTokenException", errorCode):
347 return awsRestjson1_deserializeErrorExpiredTokenException(response, errorBody)
348
349 case strings.EqualFold("InternalServerException", errorCode):
350 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
351
352 case strings.EqualFold("InvalidClientException", errorCode):
353 return awsRestjson1_deserializeErrorInvalidClientException(response, errorBody)
354
355 case strings.EqualFold("InvalidGrantException", errorCode):
356 return awsRestjson1_deserializeErrorInvalidGrantException(response, errorBody)
357
358 case strings.EqualFold("InvalidRequestException", errorCode):
359 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
360
361 case strings.EqualFold("InvalidRequestRegionException", errorCode):
362 return awsRestjson1_deserializeErrorInvalidRequestRegionException(response, errorBody)
363
364 case strings.EqualFold("InvalidScopeException", errorCode):
365 return awsRestjson1_deserializeErrorInvalidScopeException(response, errorBody)
366
367 case strings.EqualFold("SlowDownException", errorCode):
368 return awsRestjson1_deserializeErrorSlowDownException(response, errorBody)
369
370 case strings.EqualFold("UnauthorizedClientException", errorCode):
371 return awsRestjson1_deserializeErrorUnauthorizedClientException(response, errorBody)
372
373 case strings.EqualFold("UnsupportedGrantTypeException", errorCode):
374 return awsRestjson1_deserializeErrorUnsupportedGrantTypeException(response, errorBody)
375
376 default:
377 genericError := &smithy.GenericAPIError{
378 Code: errorCode,
379 Message: errorMessage,
380 }
381 return genericError
382
383 }
384 }
385
386 func awsRestjson1_deserializeOpDocumentCreateTokenWithIAMOutput(v **CreateTokenWithIAMOutput, value interface{}) error {
387 if v == nil {
388 return fmt.Errorf("unexpected nil of type %T", v)
389 }
390 if value == nil {
391 return nil
392 }
393
394 shape, ok := value.(map[string]interface{})
395 if !ok {
396 return fmt.Errorf("unexpected JSON type %v", value)
397 }
398
399 var sv *CreateTokenWithIAMOutput
400 if *v == nil {
401 sv = &CreateTokenWithIAMOutput{}
402 } else {
403 sv = *v
404 }
405
406 for key, value := range shape {
407 switch key {
408 case "accessToken":
409 if value != nil {
410 jtv, ok := value.(string)
411 if !ok {
412 return fmt.Errorf("expected AccessToken to be of type string, got %T instead", value)
413 }
414 sv.AccessToken = ptr.String(jtv)
415 }
416
417 case "expiresIn":
418 if value != nil {
419 jtv, ok := value.(json.Number)
420 if !ok {
421 return fmt.Errorf("expected ExpirationInSeconds to be json.Number, got %T instead", value)
422 }
423 i64, err := jtv.Int64()
424 if err != nil {
425 return err
426 }
427 sv.ExpiresIn = int32(i64)
428 }
429
430 case "idToken":
431 if value != nil {
432 jtv, ok := value.(string)
433 if !ok {
434 return fmt.Errorf("expected IdToken to be of type string, got %T instead", value)
435 }
436 sv.IdToken = ptr.String(jtv)
437 }
438
439 case "issuedTokenType":
440 if value != nil {
441 jtv, ok := value.(string)
442 if !ok {
443 return fmt.Errorf("expected TokenTypeURI to be of type string, got %T instead", value)
444 }
445 sv.IssuedTokenType = ptr.String(jtv)
446 }
447
448 case "refreshToken":
449 if value != nil {
450 jtv, ok := value.(string)
451 if !ok {
452 return fmt.Errorf("expected RefreshToken to be of type string, got %T instead", value)
453 }
454 sv.RefreshToken = ptr.String(jtv)
455 }
456
457 case "scope":
458 if err := awsRestjson1_deserializeDocumentScopes(&sv.Scope, value); err != nil {
459 return err
460 }
461
462 case "tokenType":
463 if value != nil {
464 jtv, ok := value.(string)
465 if !ok {
466 return fmt.Errorf("expected TokenType to be of type string, got %T instead", value)
467 }
468 sv.TokenType = ptr.String(jtv)
469 }
470
471 default:
472 _, _ = key, value
473
474 }
475 }
476 *v = sv
477 return nil
478 }
479
480 type awsRestjson1_deserializeOpRegisterClient struct {
481 }
482
483 func (*awsRestjson1_deserializeOpRegisterClient) ID() string {
484 return "OperationDeserializer"
485 }
486
487 func (m *awsRestjson1_deserializeOpRegisterClient) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
488 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
489 ) {
490 out, metadata, err = next.HandleDeserialize(ctx, in)
491 if err != nil {
492 return out, metadata, err
493 }
494
495 response, ok := out.RawResponse.(*smithyhttp.Response)
496 if !ok {
497 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
498 }
499
500 if response.StatusCode < 200 || response.StatusCode >= 300 {
501 return out, metadata, awsRestjson1_deserializeOpErrorRegisterClient(response, &metadata)
502 }
503 output := &RegisterClientOutput{}
504 out.Result = output
505
506 var buff [1024]byte
507 ringBuffer := smithyio.NewRingBuffer(buff[:])
508
509 body := io.TeeReader(response.Body, ringBuffer)
510
511 decoder := json.NewDecoder(body)
512 decoder.UseNumber()
513 var shape interface{}
514 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
515 var snapshot bytes.Buffer
516 io.Copy(&snapshot, ringBuffer)
517 err = &smithy.DeserializationError{
518 Err: fmt.Errorf("failed to decode response body, %w", err),
519 Snapshot: snapshot.Bytes(),
520 }
521 return out, metadata, err
522 }
523
524 err = awsRestjson1_deserializeOpDocumentRegisterClientOutput(&output, shape)
525 if err != nil {
526 var snapshot bytes.Buffer
527 io.Copy(&snapshot, ringBuffer)
528 return out, metadata, &smithy.DeserializationError{
529 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
530 Snapshot: snapshot.Bytes(),
531 }
532 }
533
534 return out, metadata, err
535 }
536
537 func awsRestjson1_deserializeOpErrorRegisterClient(response *smithyhttp.Response, metadata *middleware.Metadata) error {
538 var errorBuffer bytes.Buffer
539 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
540 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
541 }
542 errorBody := bytes.NewReader(errorBuffer.Bytes())
543
544 errorCode := "UnknownError"
545 errorMessage := errorCode
546
547 headerCode := response.Header.Get("X-Amzn-ErrorType")
548 if len(headerCode) != 0 {
549 errorCode = restjson.SanitizeErrorCode(headerCode)
550 }
551
552 var buff [1024]byte
553 ringBuffer := smithyio.NewRingBuffer(buff[:])
554
555 body := io.TeeReader(errorBody, ringBuffer)
556 decoder := json.NewDecoder(body)
557 decoder.UseNumber()
558 jsonCode, message, err := restjson.GetErrorInfo(decoder)
559 if err != nil {
560 var snapshot bytes.Buffer
561 io.Copy(&snapshot, ringBuffer)
562 err = &smithy.DeserializationError{
563 Err: fmt.Errorf("failed to decode response body, %w", err),
564 Snapshot: snapshot.Bytes(),
565 }
566 return err
567 }
568
569 errorBody.Seek(0, io.SeekStart)
570 if len(headerCode) == 0 && len(jsonCode) != 0 {
571 errorCode = restjson.SanitizeErrorCode(jsonCode)
572 }
573 if len(message) != 0 {
574 errorMessage = message
575 }
576
577 switch {
578 case strings.EqualFold("InternalServerException", errorCode):
579 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
580
581 case strings.EqualFold("InvalidClientMetadataException", errorCode):
582 return awsRestjson1_deserializeErrorInvalidClientMetadataException(response, errorBody)
583
584 case strings.EqualFold("InvalidRequestException", errorCode):
585 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
586
587 case strings.EqualFold("InvalidScopeException", errorCode):
588 return awsRestjson1_deserializeErrorInvalidScopeException(response, errorBody)
589
590 default:
591 genericError := &smithy.GenericAPIError{
592 Code: errorCode,
593 Message: errorMessage,
594 }
595 return genericError
596
597 }
598 }
599
600 func awsRestjson1_deserializeOpDocumentRegisterClientOutput(v **RegisterClientOutput, value interface{}) error {
601 if v == nil {
602 return fmt.Errorf("unexpected nil of type %T", v)
603 }
604 if value == nil {
605 return nil
606 }
607
608 shape, ok := value.(map[string]interface{})
609 if !ok {
610 return fmt.Errorf("unexpected JSON type %v", value)
611 }
612
613 var sv *RegisterClientOutput
614 if *v == nil {
615 sv = &RegisterClientOutput{}
616 } else {
617 sv = *v
618 }
619
620 for key, value := range shape {
621 switch key {
622 case "authorizationEndpoint":
623 if value != nil {
624 jtv, ok := value.(string)
625 if !ok {
626 return fmt.Errorf("expected URI to be of type string, got %T instead", value)
627 }
628 sv.AuthorizationEndpoint = ptr.String(jtv)
629 }
630
631 case "clientId":
632 if value != nil {
633 jtv, ok := value.(string)
634 if !ok {
635 return fmt.Errorf("expected ClientId to be of type string, got %T instead", value)
636 }
637 sv.ClientId = ptr.String(jtv)
638 }
639
640 case "clientIdIssuedAt":
641 if value != nil {
642 jtv, ok := value.(json.Number)
643 if !ok {
644 return fmt.Errorf("expected LongTimeStampType to be json.Number, got %T instead", value)
645 }
646 i64, err := jtv.Int64()
647 if err != nil {
648 return err
649 }
650 sv.ClientIdIssuedAt = i64
651 }
652
653 case "clientSecret":
654 if value != nil {
655 jtv, ok := value.(string)
656 if !ok {
657 return fmt.Errorf("expected ClientSecret to be of type string, got %T instead", value)
658 }
659 sv.ClientSecret = ptr.String(jtv)
660 }
661
662 case "clientSecretExpiresAt":
663 if value != nil {
664 jtv, ok := value.(json.Number)
665 if !ok {
666 return fmt.Errorf("expected LongTimeStampType to be json.Number, got %T instead", value)
667 }
668 i64, err := jtv.Int64()
669 if err != nil {
670 return err
671 }
672 sv.ClientSecretExpiresAt = i64
673 }
674
675 case "tokenEndpoint":
676 if value != nil {
677 jtv, ok := value.(string)
678 if !ok {
679 return fmt.Errorf("expected URI to be of type string, got %T instead", value)
680 }
681 sv.TokenEndpoint = ptr.String(jtv)
682 }
683
684 default:
685 _, _ = key, value
686
687 }
688 }
689 *v = sv
690 return nil
691 }
692
693 type awsRestjson1_deserializeOpStartDeviceAuthorization struct {
694 }
695
696 func (*awsRestjson1_deserializeOpStartDeviceAuthorization) ID() string {
697 return "OperationDeserializer"
698 }
699
700 func (m *awsRestjson1_deserializeOpStartDeviceAuthorization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
701 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
702 ) {
703 out, metadata, err = next.HandleDeserialize(ctx, in)
704 if err != nil {
705 return out, metadata, err
706 }
707
708 response, ok := out.RawResponse.(*smithyhttp.Response)
709 if !ok {
710 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
711 }
712
713 if response.StatusCode < 200 || response.StatusCode >= 300 {
714 return out, metadata, awsRestjson1_deserializeOpErrorStartDeviceAuthorization(response, &metadata)
715 }
716 output := &StartDeviceAuthorizationOutput{}
717 out.Result = output
718
719 var buff [1024]byte
720 ringBuffer := smithyio.NewRingBuffer(buff[:])
721
722 body := io.TeeReader(response.Body, ringBuffer)
723
724 decoder := json.NewDecoder(body)
725 decoder.UseNumber()
726 var shape interface{}
727 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
728 var snapshot bytes.Buffer
729 io.Copy(&snapshot, ringBuffer)
730 err = &smithy.DeserializationError{
731 Err: fmt.Errorf("failed to decode response body, %w", err),
732 Snapshot: snapshot.Bytes(),
733 }
734 return out, metadata, err
735 }
736
737 err = awsRestjson1_deserializeOpDocumentStartDeviceAuthorizationOutput(&output, shape)
738 if err != nil {
739 var snapshot bytes.Buffer
740 io.Copy(&snapshot, ringBuffer)
741 return out, metadata, &smithy.DeserializationError{
742 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
743 Snapshot: snapshot.Bytes(),
744 }
745 }
746
747 return out, metadata, err
748 }
749
750 func awsRestjson1_deserializeOpErrorStartDeviceAuthorization(response *smithyhttp.Response, metadata *middleware.Metadata) error {
751 var errorBuffer bytes.Buffer
752 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
753 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
754 }
755 errorBody := bytes.NewReader(errorBuffer.Bytes())
756
757 errorCode := "UnknownError"
758 errorMessage := errorCode
759
760 headerCode := response.Header.Get("X-Amzn-ErrorType")
761 if len(headerCode) != 0 {
762 errorCode = restjson.SanitizeErrorCode(headerCode)
763 }
764
765 var buff [1024]byte
766 ringBuffer := smithyio.NewRingBuffer(buff[:])
767
768 body := io.TeeReader(errorBody, ringBuffer)
769 decoder := json.NewDecoder(body)
770 decoder.UseNumber()
771 jsonCode, message, err := restjson.GetErrorInfo(decoder)
772 if err != nil {
773 var snapshot bytes.Buffer
774 io.Copy(&snapshot, ringBuffer)
775 err = &smithy.DeserializationError{
776 Err: fmt.Errorf("failed to decode response body, %w", err),
777 Snapshot: snapshot.Bytes(),
778 }
779 return err
780 }
781
782 errorBody.Seek(0, io.SeekStart)
783 if len(headerCode) == 0 && len(jsonCode) != 0 {
784 errorCode = restjson.SanitizeErrorCode(jsonCode)
785 }
786 if len(message) != 0 {
787 errorMessage = message
788 }
789
790 switch {
791 case strings.EqualFold("InternalServerException", errorCode):
792 return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
793
794 case strings.EqualFold("InvalidClientException", errorCode):
795 return awsRestjson1_deserializeErrorInvalidClientException(response, errorBody)
796
797 case strings.EqualFold("InvalidRequestException", errorCode):
798 return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
799
800 case strings.EqualFold("SlowDownException", errorCode):
801 return awsRestjson1_deserializeErrorSlowDownException(response, errorBody)
802
803 case strings.EqualFold("UnauthorizedClientException", errorCode):
804 return awsRestjson1_deserializeErrorUnauthorizedClientException(response, errorBody)
805
806 default:
807 genericError := &smithy.GenericAPIError{
808 Code: errorCode,
809 Message: errorMessage,
810 }
811 return genericError
812
813 }
814 }
815
816 func awsRestjson1_deserializeOpDocumentStartDeviceAuthorizationOutput(v **StartDeviceAuthorizationOutput, value interface{}) error {
817 if v == nil {
818 return fmt.Errorf("unexpected nil of type %T", v)
819 }
820 if value == nil {
821 return nil
822 }
823
824 shape, ok := value.(map[string]interface{})
825 if !ok {
826 return fmt.Errorf("unexpected JSON type %v", value)
827 }
828
829 var sv *StartDeviceAuthorizationOutput
830 if *v == nil {
831 sv = &StartDeviceAuthorizationOutput{}
832 } else {
833 sv = *v
834 }
835
836 for key, value := range shape {
837 switch key {
838 case "deviceCode":
839 if value != nil {
840 jtv, ok := value.(string)
841 if !ok {
842 return fmt.Errorf("expected DeviceCode to be of type string, got %T instead", value)
843 }
844 sv.DeviceCode = ptr.String(jtv)
845 }
846
847 case "expiresIn":
848 if value != nil {
849 jtv, ok := value.(json.Number)
850 if !ok {
851 return fmt.Errorf("expected ExpirationInSeconds to be json.Number, got %T instead", value)
852 }
853 i64, err := jtv.Int64()
854 if err != nil {
855 return err
856 }
857 sv.ExpiresIn = int32(i64)
858 }
859
860 case "interval":
861 if value != nil {
862 jtv, ok := value.(json.Number)
863 if !ok {
864 return fmt.Errorf("expected IntervalInSeconds to be json.Number, got %T instead", value)
865 }
866 i64, err := jtv.Int64()
867 if err != nil {
868 return err
869 }
870 sv.Interval = int32(i64)
871 }
872
873 case "userCode":
874 if value != nil {
875 jtv, ok := value.(string)
876 if !ok {
877 return fmt.Errorf("expected UserCode to be of type string, got %T instead", value)
878 }
879 sv.UserCode = ptr.String(jtv)
880 }
881
882 case "verificationUri":
883 if value != nil {
884 jtv, ok := value.(string)
885 if !ok {
886 return fmt.Errorf("expected URI to be of type string, got %T instead", value)
887 }
888 sv.VerificationUri = ptr.String(jtv)
889 }
890
891 case "verificationUriComplete":
892 if value != nil {
893 jtv, ok := value.(string)
894 if !ok {
895 return fmt.Errorf("expected URI to be of type string, got %T instead", value)
896 }
897 sv.VerificationUriComplete = ptr.String(jtv)
898 }
899
900 default:
901 _, _ = key, value
902
903 }
904 }
905 *v = sv
906 return nil
907 }
908
909 func awsRestjson1_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
910 output := &types.AccessDeniedException{}
911 var buff [1024]byte
912 ringBuffer := smithyio.NewRingBuffer(buff[:])
913
914 body := io.TeeReader(errorBody, ringBuffer)
915 decoder := json.NewDecoder(body)
916 decoder.UseNumber()
917 var shape interface{}
918 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
919 var snapshot bytes.Buffer
920 io.Copy(&snapshot, ringBuffer)
921 err = &smithy.DeserializationError{
922 Err: fmt.Errorf("failed to decode response body, %w", err),
923 Snapshot: snapshot.Bytes(),
924 }
925 return err
926 }
927
928 err := awsRestjson1_deserializeDocumentAccessDeniedException(&output, shape)
929
930 if err != nil {
931 var snapshot bytes.Buffer
932 io.Copy(&snapshot, ringBuffer)
933 err = &smithy.DeserializationError{
934 Err: fmt.Errorf("failed to decode response body, %w", err),
935 Snapshot: snapshot.Bytes(),
936 }
937 return err
938 }
939
940 errorBody.Seek(0, io.SeekStart)
941
942 return output
943 }
944
945 func awsRestjson1_deserializeErrorAuthorizationPendingException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
946 output := &types.AuthorizationPendingException{}
947 var buff [1024]byte
948 ringBuffer := smithyio.NewRingBuffer(buff[:])
949
950 body := io.TeeReader(errorBody, ringBuffer)
951 decoder := json.NewDecoder(body)
952 decoder.UseNumber()
953 var shape interface{}
954 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
955 var snapshot bytes.Buffer
956 io.Copy(&snapshot, ringBuffer)
957 err = &smithy.DeserializationError{
958 Err: fmt.Errorf("failed to decode response body, %w", err),
959 Snapshot: snapshot.Bytes(),
960 }
961 return err
962 }
963
964 err := awsRestjson1_deserializeDocumentAuthorizationPendingException(&output, shape)
965
966 if err != nil {
967 var snapshot bytes.Buffer
968 io.Copy(&snapshot, ringBuffer)
969 err = &smithy.DeserializationError{
970 Err: fmt.Errorf("failed to decode response body, %w", err),
971 Snapshot: snapshot.Bytes(),
972 }
973 return err
974 }
975
976 errorBody.Seek(0, io.SeekStart)
977
978 return output
979 }
980
981 func awsRestjson1_deserializeErrorExpiredTokenException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
982 output := &types.ExpiredTokenException{}
983 var buff [1024]byte
984 ringBuffer := smithyio.NewRingBuffer(buff[:])
985
986 body := io.TeeReader(errorBody, ringBuffer)
987 decoder := json.NewDecoder(body)
988 decoder.UseNumber()
989 var shape interface{}
990 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
991 var snapshot bytes.Buffer
992 io.Copy(&snapshot, ringBuffer)
993 err = &smithy.DeserializationError{
994 Err: fmt.Errorf("failed to decode response body, %w", err),
995 Snapshot: snapshot.Bytes(),
996 }
997 return err
998 }
999
1000 err := awsRestjson1_deserializeDocumentExpiredTokenException(&output, shape)
1001
1002 if err != nil {
1003 var snapshot bytes.Buffer
1004 io.Copy(&snapshot, ringBuffer)
1005 err = &smithy.DeserializationError{
1006 Err: fmt.Errorf("failed to decode response body, %w", err),
1007 Snapshot: snapshot.Bytes(),
1008 }
1009 return err
1010 }
1011
1012 errorBody.Seek(0, io.SeekStart)
1013
1014 return output
1015 }
1016
1017 func awsRestjson1_deserializeErrorInternalServerException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
1018 output := &types.InternalServerException{}
1019 var buff [1024]byte
1020 ringBuffer := smithyio.NewRingBuffer(buff[:])
1021
1022 body := io.TeeReader(errorBody, ringBuffer)
1023 decoder := json.NewDecoder(body)
1024 decoder.UseNumber()
1025 var shape interface{}
1026 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1027 var snapshot bytes.Buffer
1028 io.Copy(&snapshot, ringBuffer)
1029 err = &smithy.DeserializationError{
1030 Err: fmt.Errorf("failed to decode response body, %w", err),
1031 Snapshot: snapshot.Bytes(),
1032 }
1033 return err
1034 }
1035
1036 err := awsRestjson1_deserializeDocumentInternalServerException(&output, shape)
1037
1038 if err != nil {
1039 var snapshot bytes.Buffer
1040 io.Copy(&snapshot, ringBuffer)
1041 err = &smithy.DeserializationError{
1042 Err: fmt.Errorf("failed to decode response body, %w", err),
1043 Snapshot: snapshot.Bytes(),
1044 }
1045 return err
1046 }
1047
1048 errorBody.Seek(0, io.SeekStart)
1049
1050 return output
1051 }
1052
1053 func awsRestjson1_deserializeErrorInvalidClientException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
1054 output := &types.InvalidClientException{}
1055 var buff [1024]byte
1056 ringBuffer := smithyio.NewRingBuffer(buff[:])
1057
1058 body := io.TeeReader(errorBody, ringBuffer)
1059 decoder := json.NewDecoder(body)
1060 decoder.UseNumber()
1061 var shape interface{}
1062 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1063 var snapshot bytes.Buffer
1064 io.Copy(&snapshot, ringBuffer)
1065 err = &smithy.DeserializationError{
1066 Err: fmt.Errorf("failed to decode response body, %w", err),
1067 Snapshot: snapshot.Bytes(),
1068 }
1069 return err
1070 }
1071
1072 err := awsRestjson1_deserializeDocumentInvalidClientException(&output, shape)
1073
1074 if err != nil {
1075 var snapshot bytes.Buffer
1076 io.Copy(&snapshot, ringBuffer)
1077 err = &smithy.DeserializationError{
1078 Err: fmt.Errorf("failed to decode response body, %w", err),
1079 Snapshot: snapshot.Bytes(),
1080 }
1081 return err
1082 }
1083
1084 errorBody.Seek(0, io.SeekStart)
1085
1086 return output
1087 }
1088
1089 func awsRestjson1_deserializeErrorInvalidClientMetadataException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
1090 output := &types.InvalidClientMetadataException{}
1091 var buff [1024]byte
1092 ringBuffer := smithyio.NewRingBuffer(buff[:])
1093
1094 body := io.TeeReader(errorBody, ringBuffer)
1095 decoder := json.NewDecoder(body)
1096 decoder.UseNumber()
1097 var shape interface{}
1098 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1099 var snapshot bytes.Buffer
1100 io.Copy(&snapshot, ringBuffer)
1101 err = &smithy.DeserializationError{
1102 Err: fmt.Errorf("failed to decode response body, %w", err),
1103 Snapshot: snapshot.Bytes(),
1104 }
1105 return err
1106 }
1107
1108 err := awsRestjson1_deserializeDocumentInvalidClientMetadataException(&output, shape)
1109
1110 if err != nil {
1111 var snapshot bytes.Buffer
1112 io.Copy(&snapshot, ringBuffer)
1113 err = &smithy.DeserializationError{
1114 Err: fmt.Errorf("failed to decode response body, %w", err),
1115 Snapshot: snapshot.Bytes(),
1116 }
1117 return err
1118 }
1119
1120 errorBody.Seek(0, io.SeekStart)
1121
1122 return output
1123 }
1124
1125 func awsRestjson1_deserializeErrorInvalidGrantException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
1126 output := &types.InvalidGrantException{}
1127 var buff [1024]byte
1128 ringBuffer := smithyio.NewRingBuffer(buff[:])
1129
1130 body := io.TeeReader(errorBody, ringBuffer)
1131 decoder := json.NewDecoder(body)
1132 decoder.UseNumber()
1133 var shape interface{}
1134 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1135 var snapshot bytes.Buffer
1136 io.Copy(&snapshot, ringBuffer)
1137 err = &smithy.DeserializationError{
1138 Err: fmt.Errorf("failed to decode response body, %w", err),
1139 Snapshot: snapshot.Bytes(),
1140 }
1141 return err
1142 }
1143
1144 err := awsRestjson1_deserializeDocumentInvalidGrantException(&output, shape)
1145
1146 if err != nil {
1147 var snapshot bytes.Buffer
1148 io.Copy(&snapshot, ringBuffer)
1149 err = &smithy.DeserializationError{
1150 Err: fmt.Errorf("failed to decode response body, %w", err),
1151 Snapshot: snapshot.Bytes(),
1152 }
1153 return err
1154 }
1155
1156 errorBody.Seek(0, io.SeekStart)
1157
1158 return output
1159 }
1160
1161 func awsRestjson1_deserializeErrorInvalidRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
1162 output := &types.InvalidRequestException{}
1163 var buff [1024]byte
1164 ringBuffer := smithyio.NewRingBuffer(buff[:])
1165
1166 body := io.TeeReader(errorBody, ringBuffer)
1167 decoder := json.NewDecoder(body)
1168 decoder.UseNumber()
1169 var shape interface{}
1170 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1171 var snapshot bytes.Buffer
1172 io.Copy(&snapshot, ringBuffer)
1173 err = &smithy.DeserializationError{
1174 Err: fmt.Errorf("failed to decode response body, %w", err),
1175 Snapshot: snapshot.Bytes(),
1176 }
1177 return err
1178 }
1179
1180 err := awsRestjson1_deserializeDocumentInvalidRequestException(&output, shape)
1181
1182 if err != nil {
1183 var snapshot bytes.Buffer
1184 io.Copy(&snapshot, ringBuffer)
1185 err = &smithy.DeserializationError{
1186 Err: fmt.Errorf("failed to decode response body, %w", err),
1187 Snapshot: snapshot.Bytes(),
1188 }
1189 return err
1190 }
1191
1192 errorBody.Seek(0, io.SeekStart)
1193
1194 return output
1195 }
1196
1197 func awsRestjson1_deserializeErrorInvalidRequestRegionException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
1198 output := &types.InvalidRequestRegionException{}
1199 var buff [1024]byte
1200 ringBuffer := smithyio.NewRingBuffer(buff[:])
1201
1202 body := io.TeeReader(errorBody, ringBuffer)
1203 decoder := json.NewDecoder(body)
1204 decoder.UseNumber()
1205 var shape interface{}
1206 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1207 var snapshot bytes.Buffer
1208 io.Copy(&snapshot, ringBuffer)
1209 err = &smithy.DeserializationError{
1210 Err: fmt.Errorf("failed to decode response body, %w", err),
1211 Snapshot: snapshot.Bytes(),
1212 }
1213 return err
1214 }
1215
1216 err := awsRestjson1_deserializeDocumentInvalidRequestRegionException(&output, shape)
1217
1218 if err != nil {
1219 var snapshot bytes.Buffer
1220 io.Copy(&snapshot, ringBuffer)
1221 err = &smithy.DeserializationError{
1222 Err: fmt.Errorf("failed to decode response body, %w", err),
1223 Snapshot: snapshot.Bytes(),
1224 }
1225 return err
1226 }
1227
1228 errorBody.Seek(0, io.SeekStart)
1229
1230 return output
1231 }
1232
1233 func awsRestjson1_deserializeErrorInvalidScopeException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
1234 output := &types.InvalidScopeException{}
1235 var buff [1024]byte
1236 ringBuffer := smithyio.NewRingBuffer(buff[:])
1237
1238 body := io.TeeReader(errorBody, ringBuffer)
1239 decoder := json.NewDecoder(body)
1240 decoder.UseNumber()
1241 var shape interface{}
1242 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1243 var snapshot bytes.Buffer
1244 io.Copy(&snapshot, ringBuffer)
1245 err = &smithy.DeserializationError{
1246 Err: fmt.Errorf("failed to decode response body, %w", err),
1247 Snapshot: snapshot.Bytes(),
1248 }
1249 return err
1250 }
1251
1252 err := awsRestjson1_deserializeDocumentInvalidScopeException(&output, shape)
1253
1254 if err != nil {
1255 var snapshot bytes.Buffer
1256 io.Copy(&snapshot, ringBuffer)
1257 err = &smithy.DeserializationError{
1258 Err: fmt.Errorf("failed to decode response body, %w", err),
1259 Snapshot: snapshot.Bytes(),
1260 }
1261 return err
1262 }
1263
1264 errorBody.Seek(0, io.SeekStart)
1265
1266 return output
1267 }
1268
1269 func awsRestjson1_deserializeErrorSlowDownException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
1270 output := &types.SlowDownException{}
1271 var buff [1024]byte
1272 ringBuffer := smithyio.NewRingBuffer(buff[:])
1273
1274 body := io.TeeReader(errorBody, ringBuffer)
1275 decoder := json.NewDecoder(body)
1276 decoder.UseNumber()
1277 var shape interface{}
1278 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1279 var snapshot bytes.Buffer
1280 io.Copy(&snapshot, ringBuffer)
1281 err = &smithy.DeserializationError{
1282 Err: fmt.Errorf("failed to decode response body, %w", err),
1283 Snapshot: snapshot.Bytes(),
1284 }
1285 return err
1286 }
1287
1288 err := awsRestjson1_deserializeDocumentSlowDownException(&output, shape)
1289
1290 if err != nil {
1291 var snapshot bytes.Buffer
1292 io.Copy(&snapshot, ringBuffer)
1293 err = &smithy.DeserializationError{
1294 Err: fmt.Errorf("failed to decode response body, %w", err),
1295 Snapshot: snapshot.Bytes(),
1296 }
1297 return err
1298 }
1299
1300 errorBody.Seek(0, io.SeekStart)
1301
1302 return output
1303 }
1304
1305 func awsRestjson1_deserializeErrorUnauthorizedClientException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
1306 output := &types.UnauthorizedClientException{}
1307 var buff [1024]byte
1308 ringBuffer := smithyio.NewRingBuffer(buff[:])
1309
1310 body := io.TeeReader(errorBody, ringBuffer)
1311 decoder := json.NewDecoder(body)
1312 decoder.UseNumber()
1313 var shape interface{}
1314 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1315 var snapshot bytes.Buffer
1316 io.Copy(&snapshot, ringBuffer)
1317 err = &smithy.DeserializationError{
1318 Err: fmt.Errorf("failed to decode response body, %w", err),
1319 Snapshot: snapshot.Bytes(),
1320 }
1321 return err
1322 }
1323
1324 err := awsRestjson1_deserializeDocumentUnauthorizedClientException(&output, shape)
1325
1326 if err != nil {
1327 var snapshot bytes.Buffer
1328 io.Copy(&snapshot, ringBuffer)
1329 err = &smithy.DeserializationError{
1330 Err: fmt.Errorf("failed to decode response body, %w", err),
1331 Snapshot: snapshot.Bytes(),
1332 }
1333 return err
1334 }
1335
1336 errorBody.Seek(0, io.SeekStart)
1337
1338 return output
1339 }
1340
1341 func awsRestjson1_deserializeErrorUnsupportedGrantTypeException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
1342 output := &types.UnsupportedGrantTypeException{}
1343 var buff [1024]byte
1344 ringBuffer := smithyio.NewRingBuffer(buff[:])
1345
1346 body := io.TeeReader(errorBody, ringBuffer)
1347 decoder := json.NewDecoder(body)
1348 decoder.UseNumber()
1349 var shape interface{}
1350 if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1351 var snapshot bytes.Buffer
1352 io.Copy(&snapshot, ringBuffer)
1353 err = &smithy.DeserializationError{
1354 Err: fmt.Errorf("failed to decode response body, %w", err),
1355 Snapshot: snapshot.Bytes(),
1356 }
1357 return err
1358 }
1359
1360 err := awsRestjson1_deserializeDocumentUnsupportedGrantTypeException(&output, shape)
1361
1362 if err != nil {
1363 var snapshot bytes.Buffer
1364 io.Copy(&snapshot, ringBuffer)
1365 err = &smithy.DeserializationError{
1366 Err: fmt.Errorf("failed to decode response body, %w", err),
1367 Snapshot: snapshot.Bytes(),
1368 }
1369 return err
1370 }
1371
1372 errorBody.Seek(0, io.SeekStart)
1373
1374 return output
1375 }
1376
1377 func awsRestjson1_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error {
1378 if v == nil {
1379 return fmt.Errorf("unexpected nil of type %T", v)
1380 }
1381 if value == nil {
1382 return nil
1383 }
1384
1385 shape, ok := value.(map[string]interface{})
1386 if !ok {
1387 return fmt.Errorf("unexpected JSON type %v", value)
1388 }
1389
1390 var sv *types.AccessDeniedException
1391 if *v == nil {
1392 sv = &types.AccessDeniedException{}
1393 } else {
1394 sv = *v
1395 }
1396
1397 for key, value := range shape {
1398 switch key {
1399 case "error":
1400 if value != nil {
1401 jtv, ok := value.(string)
1402 if !ok {
1403 return fmt.Errorf("expected Error to be of type string, got %T instead", value)
1404 }
1405 sv.Error_ = ptr.String(jtv)
1406 }
1407
1408 case "error_description":
1409 if value != nil {
1410 jtv, ok := value.(string)
1411 if !ok {
1412 return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
1413 }
1414 sv.Error_description = ptr.String(jtv)
1415 }
1416
1417 default:
1418 _, _ = key, value
1419
1420 }
1421 }
1422 *v = sv
1423 return nil
1424 }
1425
1426 func awsRestjson1_deserializeDocumentAuthorizationPendingException(v **types.AuthorizationPendingException, value interface{}) error {
1427 if v == nil {
1428 return fmt.Errorf("unexpected nil of type %T", v)
1429 }
1430 if value == nil {
1431 return nil
1432 }
1433
1434 shape, ok := value.(map[string]interface{})
1435 if !ok {
1436 return fmt.Errorf("unexpected JSON type %v", value)
1437 }
1438
1439 var sv *types.AuthorizationPendingException
1440 if *v == nil {
1441 sv = &types.AuthorizationPendingException{}
1442 } else {
1443 sv = *v
1444 }
1445
1446 for key, value := range shape {
1447 switch key {
1448 case "error":
1449 if value != nil {
1450 jtv, ok := value.(string)
1451 if !ok {
1452 return fmt.Errorf("expected Error to be of type string, got %T instead", value)
1453 }
1454 sv.Error_ = ptr.String(jtv)
1455 }
1456
1457 case "error_description":
1458 if value != nil {
1459 jtv, ok := value.(string)
1460 if !ok {
1461 return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
1462 }
1463 sv.Error_description = ptr.String(jtv)
1464 }
1465
1466 default:
1467 _, _ = key, value
1468
1469 }
1470 }
1471 *v = sv
1472 return nil
1473 }
1474
1475 func awsRestjson1_deserializeDocumentExpiredTokenException(v **types.ExpiredTokenException, value interface{}) error {
1476 if v == nil {
1477 return fmt.Errorf("unexpected nil of type %T", v)
1478 }
1479 if value == nil {
1480 return nil
1481 }
1482
1483 shape, ok := value.(map[string]interface{})
1484 if !ok {
1485 return fmt.Errorf("unexpected JSON type %v", value)
1486 }
1487
1488 var sv *types.ExpiredTokenException
1489 if *v == nil {
1490 sv = &types.ExpiredTokenException{}
1491 } else {
1492 sv = *v
1493 }
1494
1495 for key, value := range shape {
1496 switch key {
1497 case "error":
1498 if value != nil {
1499 jtv, ok := value.(string)
1500 if !ok {
1501 return fmt.Errorf("expected Error to be of type string, got %T instead", value)
1502 }
1503 sv.Error_ = ptr.String(jtv)
1504 }
1505
1506 case "error_description":
1507 if value != nil {
1508 jtv, ok := value.(string)
1509 if !ok {
1510 return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
1511 }
1512 sv.Error_description = ptr.String(jtv)
1513 }
1514
1515 default:
1516 _, _ = key, value
1517
1518 }
1519 }
1520 *v = sv
1521 return nil
1522 }
1523
1524 func awsRestjson1_deserializeDocumentInternalServerException(v **types.InternalServerException, value interface{}) error {
1525 if v == nil {
1526 return fmt.Errorf("unexpected nil of type %T", v)
1527 }
1528 if value == nil {
1529 return nil
1530 }
1531
1532 shape, ok := value.(map[string]interface{})
1533 if !ok {
1534 return fmt.Errorf("unexpected JSON type %v", value)
1535 }
1536
1537 var sv *types.InternalServerException
1538 if *v == nil {
1539 sv = &types.InternalServerException{}
1540 } else {
1541 sv = *v
1542 }
1543
1544 for key, value := range shape {
1545 switch key {
1546 case "error":
1547 if value != nil {
1548 jtv, ok := value.(string)
1549 if !ok {
1550 return fmt.Errorf("expected Error to be of type string, got %T instead", value)
1551 }
1552 sv.Error_ = ptr.String(jtv)
1553 }
1554
1555 case "error_description":
1556 if value != nil {
1557 jtv, ok := value.(string)
1558 if !ok {
1559 return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
1560 }
1561 sv.Error_description = ptr.String(jtv)
1562 }
1563
1564 default:
1565 _, _ = key, value
1566
1567 }
1568 }
1569 *v = sv
1570 return nil
1571 }
1572
1573 func awsRestjson1_deserializeDocumentInvalidClientException(v **types.InvalidClientException, value interface{}) error {
1574 if v == nil {
1575 return fmt.Errorf("unexpected nil of type %T", v)
1576 }
1577 if value == nil {
1578 return nil
1579 }
1580
1581 shape, ok := value.(map[string]interface{})
1582 if !ok {
1583 return fmt.Errorf("unexpected JSON type %v", value)
1584 }
1585
1586 var sv *types.InvalidClientException
1587 if *v == nil {
1588 sv = &types.InvalidClientException{}
1589 } else {
1590 sv = *v
1591 }
1592
1593 for key, value := range shape {
1594 switch key {
1595 case "error":
1596 if value != nil {
1597 jtv, ok := value.(string)
1598 if !ok {
1599 return fmt.Errorf("expected Error to be of type string, got %T instead", value)
1600 }
1601 sv.Error_ = ptr.String(jtv)
1602 }
1603
1604 case "error_description":
1605 if value != nil {
1606 jtv, ok := value.(string)
1607 if !ok {
1608 return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
1609 }
1610 sv.Error_description = ptr.String(jtv)
1611 }
1612
1613 default:
1614 _, _ = key, value
1615
1616 }
1617 }
1618 *v = sv
1619 return nil
1620 }
1621
1622 func awsRestjson1_deserializeDocumentInvalidClientMetadataException(v **types.InvalidClientMetadataException, value interface{}) error {
1623 if v == nil {
1624 return fmt.Errorf("unexpected nil of type %T", v)
1625 }
1626 if value == nil {
1627 return nil
1628 }
1629
1630 shape, ok := value.(map[string]interface{})
1631 if !ok {
1632 return fmt.Errorf("unexpected JSON type %v", value)
1633 }
1634
1635 var sv *types.InvalidClientMetadataException
1636 if *v == nil {
1637 sv = &types.InvalidClientMetadataException{}
1638 } else {
1639 sv = *v
1640 }
1641
1642 for key, value := range shape {
1643 switch key {
1644 case "error":
1645 if value != nil {
1646 jtv, ok := value.(string)
1647 if !ok {
1648 return fmt.Errorf("expected Error to be of type string, got %T instead", value)
1649 }
1650 sv.Error_ = ptr.String(jtv)
1651 }
1652
1653 case "error_description":
1654 if value != nil {
1655 jtv, ok := value.(string)
1656 if !ok {
1657 return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
1658 }
1659 sv.Error_description = ptr.String(jtv)
1660 }
1661
1662 default:
1663 _, _ = key, value
1664
1665 }
1666 }
1667 *v = sv
1668 return nil
1669 }
1670
1671 func awsRestjson1_deserializeDocumentInvalidGrantException(v **types.InvalidGrantException, value interface{}) error {
1672 if v == nil {
1673 return fmt.Errorf("unexpected nil of type %T", v)
1674 }
1675 if value == nil {
1676 return nil
1677 }
1678
1679 shape, ok := value.(map[string]interface{})
1680 if !ok {
1681 return fmt.Errorf("unexpected JSON type %v", value)
1682 }
1683
1684 var sv *types.InvalidGrantException
1685 if *v == nil {
1686 sv = &types.InvalidGrantException{}
1687 } else {
1688 sv = *v
1689 }
1690
1691 for key, value := range shape {
1692 switch key {
1693 case "error":
1694 if value != nil {
1695 jtv, ok := value.(string)
1696 if !ok {
1697 return fmt.Errorf("expected Error to be of type string, got %T instead", value)
1698 }
1699 sv.Error_ = ptr.String(jtv)
1700 }
1701
1702 case "error_description":
1703 if value != nil {
1704 jtv, ok := value.(string)
1705 if !ok {
1706 return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
1707 }
1708 sv.Error_description = ptr.String(jtv)
1709 }
1710
1711 default:
1712 _, _ = key, value
1713
1714 }
1715 }
1716 *v = sv
1717 return nil
1718 }
1719
1720 func awsRestjson1_deserializeDocumentInvalidRequestException(v **types.InvalidRequestException, value interface{}) error {
1721 if v == nil {
1722 return fmt.Errorf("unexpected nil of type %T", v)
1723 }
1724 if value == nil {
1725 return nil
1726 }
1727
1728 shape, ok := value.(map[string]interface{})
1729 if !ok {
1730 return fmt.Errorf("unexpected JSON type %v", value)
1731 }
1732
1733 var sv *types.InvalidRequestException
1734 if *v == nil {
1735 sv = &types.InvalidRequestException{}
1736 } else {
1737 sv = *v
1738 }
1739
1740 for key, value := range shape {
1741 switch key {
1742 case "error":
1743 if value != nil {
1744 jtv, ok := value.(string)
1745 if !ok {
1746 return fmt.Errorf("expected Error to be of type string, got %T instead", value)
1747 }
1748 sv.Error_ = ptr.String(jtv)
1749 }
1750
1751 case "error_description":
1752 if value != nil {
1753 jtv, ok := value.(string)
1754 if !ok {
1755 return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
1756 }
1757 sv.Error_description = ptr.String(jtv)
1758 }
1759
1760 default:
1761 _, _ = key, value
1762
1763 }
1764 }
1765 *v = sv
1766 return nil
1767 }
1768
1769 func awsRestjson1_deserializeDocumentInvalidRequestRegionException(v **types.InvalidRequestRegionException, value interface{}) error {
1770 if v == nil {
1771 return fmt.Errorf("unexpected nil of type %T", v)
1772 }
1773 if value == nil {
1774 return nil
1775 }
1776
1777 shape, ok := value.(map[string]interface{})
1778 if !ok {
1779 return fmt.Errorf("unexpected JSON type %v", value)
1780 }
1781
1782 var sv *types.InvalidRequestRegionException
1783 if *v == nil {
1784 sv = &types.InvalidRequestRegionException{}
1785 } else {
1786 sv = *v
1787 }
1788
1789 for key, value := range shape {
1790 switch key {
1791 case "endpoint":
1792 if value != nil {
1793 jtv, ok := value.(string)
1794 if !ok {
1795 return fmt.Errorf("expected Location to be of type string, got %T instead", value)
1796 }
1797 sv.Endpoint = ptr.String(jtv)
1798 }
1799
1800 case "error":
1801 if value != nil {
1802 jtv, ok := value.(string)
1803 if !ok {
1804 return fmt.Errorf("expected Error to be of type string, got %T instead", value)
1805 }
1806 sv.Error_ = ptr.String(jtv)
1807 }
1808
1809 case "error_description":
1810 if value != nil {
1811 jtv, ok := value.(string)
1812 if !ok {
1813 return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
1814 }
1815 sv.Error_description = ptr.String(jtv)
1816 }
1817
1818 case "region":
1819 if value != nil {
1820 jtv, ok := value.(string)
1821 if !ok {
1822 return fmt.Errorf("expected Region to be of type string, got %T instead", value)
1823 }
1824 sv.Region = ptr.String(jtv)
1825 }
1826
1827 default:
1828 _, _ = key, value
1829
1830 }
1831 }
1832 *v = sv
1833 return nil
1834 }
1835
1836 func awsRestjson1_deserializeDocumentInvalidScopeException(v **types.InvalidScopeException, value interface{}) error {
1837 if v == nil {
1838 return fmt.Errorf("unexpected nil of type %T", v)
1839 }
1840 if value == nil {
1841 return nil
1842 }
1843
1844 shape, ok := value.(map[string]interface{})
1845 if !ok {
1846 return fmt.Errorf("unexpected JSON type %v", value)
1847 }
1848
1849 var sv *types.InvalidScopeException
1850 if *v == nil {
1851 sv = &types.InvalidScopeException{}
1852 } else {
1853 sv = *v
1854 }
1855
1856 for key, value := range shape {
1857 switch key {
1858 case "error":
1859 if value != nil {
1860 jtv, ok := value.(string)
1861 if !ok {
1862 return fmt.Errorf("expected Error to be of type string, got %T instead", value)
1863 }
1864 sv.Error_ = ptr.String(jtv)
1865 }
1866
1867 case "error_description":
1868 if value != nil {
1869 jtv, ok := value.(string)
1870 if !ok {
1871 return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
1872 }
1873 sv.Error_description = ptr.String(jtv)
1874 }
1875
1876 default:
1877 _, _ = key, value
1878
1879 }
1880 }
1881 *v = sv
1882 return nil
1883 }
1884
1885 func awsRestjson1_deserializeDocumentScopes(v *[]string, value interface{}) error {
1886 if v == nil {
1887 return fmt.Errorf("unexpected nil of type %T", v)
1888 }
1889 if value == nil {
1890 return nil
1891 }
1892
1893 shape, ok := value.([]interface{})
1894 if !ok {
1895 return fmt.Errorf("unexpected JSON type %v", value)
1896 }
1897
1898 var cv []string
1899 if *v == nil {
1900 cv = []string{}
1901 } else {
1902 cv = *v
1903 }
1904
1905 for _, value := range shape {
1906 var col string
1907 if value != nil {
1908 jtv, ok := value.(string)
1909 if !ok {
1910 return fmt.Errorf("expected Scope to be of type string, got %T instead", value)
1911 }
1912 col = jtv
1913 }
1914 cv = append(cv, col)
1915
1916 }
1917 *v = cv
1918 return nil
1919 }
1920
1921 func awsRestjson1_deserializeDocumentSlowDownException(v **types.SlowDownException, value interface{}) error {
1922 if v == nil {
1923 return fmt.Errorf("unexpected nil of type %T", v)
1924 }
1925 if value == nil {
1926 return nil
1927 }
1928
1929 shape, ok := value.(map[string]interface{})
1930 if !ok {
1931 return fmt.Errorf("unexpected JSON type %v", value)
1932 }
1933
1934 var sv *types.SlowDownException
1935 if *v == nil {
1936 sv = &types.SlowDownException{}
1937 } else {
1938 sv = *v
1939 }
1940
1941 for key, value := range shape {
1942 switch key {
1943 case "error":
1944 if value != nil {
1945 jtv, ok := value.(string)
1946 if !ok {
1947 return fmt.Errorf("expected Error to be of type string, got %T instead", value)
1948 }
1949 sv.Error_ = ptr.String(jtv)
1950 }
1951
1952 case "error_description":
1953 if value != nil {
1954 jtv, ok := value.(string)
1955 if !ok {
1956 return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
1957 }
1958 sv.Error_description = ptr.String(jtv)
1959 }
1960
1961 default:
1962 _, _ = key, value
1963
1964 }
1965 }
1966 *v = sv
1967 return nil
1968 }
1969
1970 func awsRestjson1_deserializeDocumentUnauthorizedClientException(v **types.UnauthorizedClientException, value interface{}) error {
1971 if v == nil {
1972 return fmt.Errorf("unexpected nil of type %T", v)
1973 }
1974 if value == nil {
1975 return nil
1976 }
1977
1978 shape, ok := value.(map[string]interface{})
1979 if !ok {
1980 return fmt.Errorf("unexpected JSON type %v", value)
1981 }
1982
1983 var sv *types.UnauthorizedClientException
1984 if *v == nil {
1985 sv = &types.UnauthorizedClientException{}
1986 } else {
1987 sv = *v
1988 }
1989
1990 for key, value := range shape {
1991 switch key {
1992 case "error":
1993 if value != nil {
1994 jtv, ok := value.(string)
1995 if !ok {
1996 return fmt.Errorf("expected Error to be of type string, got %T instead", value)
1997 }
1998 sv.Error_ = ptr.String(jtv)
1999 }
2000
2001 case "error_description":
2002 if value != nil {
2003 jtv, ok := value.(string)
2004 if !ok {
2005 return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
2006 }
2007 sv.Error_description = ptr.String(jtv)
2008 }
2009
2010 default:
2011 _, _ = key, value
2012
2013 }
2014 }
2015 *v = sv
2016 return nil
2017 }
2018
2019 func awsRestjson1_deserializeDocumentUnsupportedGrantTypeException(v **types.UnsupportedGrantTypeException, value interface{}) error {
2020 if v == nil {
2021 return fmt.Errorf("unexpected nil of type %T", v)
2022 }
2023 if value == nil {
2024 return nil
2025 }
2026
2027 shape, ok := value.(map[string]interface{})
2028 if !ok {
2029 return fmt.Errorf("unexpected JSON type %v", value)
2030 }
2031
2032 var sv *types.UnsupportedGrantTypeException
2033 if *v == nil {
2034 sv = &types.UnsupportedGrantTypeException{}
2035 } else {
2036 sv = *v
2037 }
2038
2039 for key, value := range shape {
2040 switch key {
2041 case "error":
2042 if value != nil {
2043 jtv, ok := value.(string)
2044 if !ok {
2045 return fmt.Errorf("expected Error to be of type string, got %T instead", value)
2046 }
2047 sv.Error_ = ptr.String(jtv)
2048 }
2049
2050 case "error_description":
2051 if value != nil {
2052 jtv, ok := value.(string)
2053 if !ok {
2054 return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
2055 }
2056 sv.Error_description = ptr.String(jtv)
2057 }
2058
2059 default:
2060 _, _ = key, value
2061
2062 }
2063 }
2064 *v = sv
2065 return nil
2066 }
2067
View as plain text