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