deserializers.go raw
1 // Code generated by smithy-go-codegen DO NOT EDIT.
2
3 package sts
4
5 import (
6 "bytes"
7 "context"
8 "encoding/xml"
9 "fmt"
10 awsmiddleware "github.com/aws/aws-sdk-go-v2/aws/middleware"
11 awsxml "github.com/aws/aws-sdk-go-v2/aws/protocol/xml"
12 "github.com/aws/aws-sdk-go-v2/service/sts/types"
13 smithy "github.com/aws/smithy-go"
14 smithyxml "github.com/aws/smithy-go/encoding/xml"
15 smithyio "github.com/aws/smithy-go/io"
16 "github.com/aws/smithy-go/middleware"
17 "github.com/aws/smithy-go/ptr"
18 smithytime "github.com/aws/smithy-go/time"
19 "github.com/aws/smithy-go/tracing"
20 smithyhttp "github.com/aws/smithy-go/transport/http"
21 "io"
22 "strconv"
23 "strings"
24 )
25
26 type awsAwsquery_deserializeOpAssumeRole struct {
27 }
28
29 func (*awsAwsquery_deserializeOpAssumeRole) ID() string {
30 return "OperationDeserializer"
31 }
32
33 func (m *awsAwsquery_deserializeOpAssumeRole) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
34 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
35 ) {
36 out, metadata, err = next.HandleDeserialize(ctx, in)
37 if err != nil {
38 return out, metadata, err
39 }
40
41 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
42 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
43 defer endTimer()
44 defer span.End()
45 response, ok := out.RawResponse.(*smithyhttp.Response)
46 if !ok {
47 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
48 }
49
50 if response.StatusCode < 200 || response.StatusCode >= 300 {
51 return out, metadata, awsAwsquery_deserializeOpErrorAssumeRole(response, &metadata)
52 }
53 output := &AssumeRoleOutput{}
54 out.Result = output
55
56 var buff [1024]byte
57 ringBuffer := smithyio.NewRingBuffer(buff[:])
58 body := io.TeeReader(response.Body, ringBuffer)
59 rootDecoder := xml.NewDecoder(body)
60 t, err := smithyxml.FetchRootElement(rootDecoder)
61 if err == io.EOF {
62 return out, metadata, nil
63 }
64 if err != nil {
65 var snapshot bytes.Buffer
66 io.Copy(&snapshot, ringBuffer)
67 return out, metadata, &smithy.DeserializationError{
68 Err: fmt.Errorf("failed to decode response body, %w", err),
69 Snapshot: snapshot.Bytes(),
70 }
71 }
72
73 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
74 t, err = decoder.GetElement("AssumeRoleResult")
75 if err != nil {
76 var snapshot bytes.Buffer
77 io.Copy(&snapshot, ringBuffer)
78 err = &smithy.DeserializationError{
79 Err: fmt.Errorf("failed to decode response body, %w", err),
80 Snapshot: snapshot.Bytes(),
81 }
82 return out, metadata, err
83 }
84
85 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
86 err = awsAwsquery_deserializeOpDocumentAssumeRoleOutput(&output, decoder)
87 if err != nil {
88 var snapshot bytes.Buffer
89 io.Copy(&snapshot, ringBuffer)
90 err = &smithy.DeserializationError{
91 Err: fmt.Errorf("failed to decode response body, %w", err),
92 Snapshot: snapshot.Bytes(),
93 }
94 return out, metadata, err
95 }
96
97 return out, metadata, err
98 }
99
100 func awsAwsquery_deserializeOpErrorAssumeRole(response *smithyhttp.Response, metadata *middleware.Metadata) error {
101 var errorBuffer bytes.Buffer
102 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
103 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
104 }
105 errorBody := bytes.NewReader(errorBuffer.Bytes())
106
107 errorCode := "UnknownError"
108 errorMessage := errorCode
109
110 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
111 if err != nil {
112 return err
113 }
114 if reqID := errorComponents.RequestID; len(reqID) != 0 {
115 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
116 }
117 if len(errorComponents.Code) != 0 {
118 errorCode = errorComponents.Code
119 }
120 if len(errorComponents.Message) != 0 {
121 errorMessage = errorComponents.Message
122 }
123 errorBody.Seek(0, io.SeekStart)
124 switch {
125 case strings.EqualFold("ExpiredTokenException", errorCode):
126 return awsAwsquery_deserializeErrorExpiredTokenException(response, errorBody)
127
128 case strings.EqualFold("MalformedPolicyDocument", errorCode):
129 return awsAwsquery_deserializeErrorMalformedPolicyDocumentException(response, errorBody)
130
131 case strings.EqualFold("PackedPolicyTooLarge", errorCode):
132 return awsAwsquery_deserializeErrorPackedPolicyTooLargeException(response, errorBody)
133
134 case strings.EqualFold("RegionDisabledException", errorCode):
135 return awsAwsquery_deserializeErrorRegionDisabledException(response, errorBody)
136
137 default:
138 genericError := &smithy.GenericAPIError{
139 Code: errorCode,
140 Message: errorMessage,
141 }
142 return genericError
143
144 }
145 }
146
147 type awsAwsquery_deserializeOpAssumeRoleWithSAML struct {
148 }
149
150 func (*awsAwsquery_deserializeOpAssumeRoleWithSAML) ID() string {
151 return "OperationDeserializer"
152 }
153
154 func (m *awsAwsquery_deserializeOpAssumeRoleWithSAML) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
155 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
156 ) {
157 out, metadata, err = next.HandleDeserialize(ctx, in)
158 if err != nil {
159 return out, metadata, err
160 }
161
162 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
163 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
164 defer endTimer()
165 defer span.End()
166 response, ok := out.RawResponse.(*smithyhttp.Response)
167 if !ok {
168 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
169 }
170
171 if response.StatusCode < 200 || response.StatusCode >= 300 {
172 return out, metadata, awsAwsquery_deserializeOpErrorAssumeRoleWithSAML(response, &metadata)
173 }
174 output := &AssumeRoleWithSAMLOutput{}
175 out.Result = output
176
177 var buff [1024]byte
178 ringBuffer := smithyio.NewRingBuffer(buff[:])
179 body := io.TeeReader(response.Body, ringBuffer)
180 rootDecoder := xml.NewDecoder(body)
181 t, err := smithyxml.FetchRootElement(rootDecoder)
182 if err == io.EOF {
183 return out, metadata, nil
184 }
185 if err != nil {
186 var snapshot bytes.Buffer
187 io.Copy(&snapshot, ringBuffer)
188 return out, metadata, &smithy.DeserializationError{
189 Err: fmt.Errorf("failed to decode response body, %w", err),
190 Snapshot: snapshot.Bytes(),
191 }
192 }
193
194 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
195 t, err = decoder.GetElement("AssumeRoleWithSAMLResult")
196 if err != nil {
197 var snapshot bytes.Buffer
198 io.Copy(&snapshot, ringBuffer)
199 err = &smithy.DeserializationError{
200 Err: fmt.Errorf("failed to decode response body, %w", err),
201 Snapshot: snapshot.Bytes(),
202 }
203 return out, metadata, err
204 }
205
206 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
207 err = awsAwsquery_deserializeOpDocumentAssumeRoleWithSAMLOutput(&output, decoder)
208 if err != nil {
209 var snapshot bytes.Buffer
210 io.Copy(&snapshot, ringBuffer)
211 err = &smithy.DeserializationError{
212 Err: fmt.Errorf("failed to decode response body, %w", err),
213 Snapshot: snapshot.Bytes(),
214 }
215 return out, metadata, err
216 }
217
218 return out, metadata, err
219 }
220
221 func awsAwsquery_deserializeOpErrorAssumeRoleWithSAML(response *smithyhttp.Response, metadata *middleware.Metadata) error {
222 var errorBuffer bytes.Buffer
223 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
224 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
225 }
226 errorBody := bytes.NewReader(errorBuffer.Bytes())
227
228 errorCode := "UnknownError"
229 errorMessage := errorCode
230
231 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
232 if err != nil {
233 return err
234 }
235 if reqID := errorComponents.RequestID; len(reqID) != 0 {
236 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
237 }
238 if len(errorComponents.Code) != 0 {
239 errorCode = errorComponents.Code
240 }
241 if len(errorComponents.Message) != 0 {
242 errorMessage = errorComponents.Message
243 }
244 errorBody.Seek(0, io.SeekStart)
245 switch {
246 case strings.EqualFold("ExpiredTokenException", errorCode):
247 return awsAwsquery_deserializeErrorExpiredTokenException(response, errorBody)
248
249 case strings.EqualFold("IDPRejectedClaim", errorCode):
250 return awsAwsquery_deserializeErrorIDPRejectedClaimException(response, errorBody)
251
252 case strings.EqualFold("InvalidIdentityToken", errorCode):
253 return awsAwsquery_deserializeErrorInvalidIdentityTokenException(response, errorBody)
254
255 case strings.EqualFold("MalformedPolicyDocument", errorCode):
256 return awsAwsquery_deserializeErrorMalformedPolicyDocumentException(response, errorBody)
257
258 case strings.EqualFold("PackedPolicyTooLarge", errorCode):
259 return awsAwsquery_deserializeErrorPackedPolicyTooLargeException(response, errorBody)
260
261 case strings.EqualFold("RegionDisabledException", errorCode):
262 return awsAwsquery_deserializeErrorRegionDisabledException(response, errorBody)
263
264 default:
265 genericError := &smithy.GenericAPIError{
266 Code: errorCode,
267 Message: errorMessage,
268 }
269 return genericError
270
271 }
272 }
273
274 type awsAwsquery_deserializeOpAssumeRoleWithWebIdentity struct {
275 }
276
277 func (*awsAwsquery_deserializeOpAssumeRoleWithWebIdentity) ID() string {
278 return "OperationDeserializer"
279 }
280
281 func (m *awsAwsquery_deserializeOpAssumeRoleWithWebIdentity) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
282 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
283 ) {
284 out, metadata, err = next.HandleDeserialize(ctx, in)
285 if err != nil {
286 return out, metadata, err
287 }
288
289 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
290 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
291 defer endTimer()
292 defer span.End()
293 response, ok := out.RawResponse.(*smithyhttp.Response)
294 if !ok {
295 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
296 }
297
298 if response.StatusCode < 200 || response.StatusCode >= 300 {
299 return out, metadata, awsAwsquery_deserializeOpErrorAssumeRoleWithWebIdentity(response, &metadata)
300 }
301 output := &AssumeRoleWithWebIdentityOutput{}
302 out.Result = output
303
304 var buff [1024]byte
305 ringBuffer := smithyio.NewRingBuffer(buff[:])
306 body := io.TeeReader(response.Body, ringBuffer)
307 rootDecoder := xml.NewDecoder(body)
308 t, err := smithyxml.FetchRootElement(rootDecoder)
309 if err == io.EOF {
310 return out, metadata, nil
311 }
312 if err != nil {
313 var snapshot bytes.Buffer
314 io.Copy(&snapshot, ringBuffer)
315 return out, metadata, &smithy.DeserializationError{
316 Err: fmt.Errorf("failed to decode response body, %w", err),
317 Snapshot: snapshot.Bytes(),
318 }
319 }
320
321 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
322 t, err = decoder.GetElement("AssumeRoleWithWebIdentityResult")
323 if err != nil {
324 var snapshot bytes.Buffer
325 io.Copy(&snapshot, ringBuffer)
326 err = &smithy.DeserializationError{
327 Err: fmt.Errorf("failed to decode response body, %w", err),
328 Snapshot: snapshot.Bytes(),
329 }
330 return out, metadata, err
331 }
332
333 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
334 err = awsAwsquery_deserializeOpDocumentAssumeRoleWithWebIdentityOutput(&output, decoder)
335 if err != nil {
336 var snapshot bytes.Buffer
337 io.Copy(&snapshot, ringBuffer)
338 err = &smithy.DeserializationError{
339 Err: fmt.Errorf("failed to decode response body, %w", err),
340 Snapshot: snapshot.Bytes(),
341 }
342 return out, metadata, err
343 }
344
345 return out, metadata, err
346 }
347
348 func awsAwsquery_deserializeOpErrorAssumeRoleWithWebIdentity(response *smithyhttp.Response, metadata *middleware.Metadata) error {
349 var errorBuffer bytes.Buffer
350 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
351 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
352 }
353 errorBody := bytes.NewReader(errorBuffer.Bytes())
354
355 errorCode := "UnknownError"
356 errorMessage := errorCode
357
358 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
359 if err != nil {
360 return err
361 }
362 if reqID := errorComponents.RequestID; len(reqID) != 0 {
363 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
364 }
365 if len(errorComponents.Code) != 0 {
366 errorCode = errorComponents.Code
367 }
368 if len(errorComponents.Message) != 0 {
369 errorMessage = errorComponents.Message
370 }
371 errorBody.Seek(0, io.SeekStart)
372 switch {
373 case strings.EqualFold("ExpiredTokenException", errorCode):
374 return awsAwsquery_deserializeErrorExpiredTokenException(response, errorBody)
375
376 case strings.EqualFold("IDPCommunicationError", errorCode):
377 return awsAwsquery_deserializeErrorIDPCommunicationErrorException(response, errorBody)
378
379 case strings.EqualFold("IDPRejectedClaim", errorCode):
380 return awsAwsquery_deserializeErrorIDPRejectedClaimException(response, errorBody)
381
382 case strings.EqualFold("InvalidIdentityToken", errorCode):
383 return awsAwsquery_deserializeErrorInvalidIdentityTokenException(response, errorBody)
384
385 case strings.EqualFold("MalformedPolicyDocument", errorCode):
386 return awsAwsquery_deserializeErrorMalformedPolicyDocumentException(response, errorBody)
387
388 case strings.EqualFold("PackedPolicyTooLarge", errorCode):
389 return awsAwsquery_deserializeErrorPackedPolicyTooLargeException(response, errorBody)
390
391 case strings.EqualFold("RegionDisabledException", errorCode):
392 return awsAwsquery_deserializeErrorRegionDisabledException(response, errorBody)
393
394 default:
395 genericError := &smithy.GenericAPIError{
396 Code: errorCode,
397 Message: errorMessage,
398 }
399 return genericError
400
401 }
402 }
403
404 type awsAwsquery_deserializeOpAssumeRoot struct {
405 }
406
407 func (*awsAwsquery_deserializeOpAssumeRoot) ID() string {
408 return "OperationDeserializer"
409 }
410
411 func (m *awsAwsquery_deserializeOpAssumeRoot) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
412 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
413 ) {
414 out, metadata, err = next.HandleDeserialize(ctx, in)
415 if err != nil {
416 return out, metadata, err
417 }
418
419 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
420 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
421 defer endTimer()
422 defer span.End()
423 response, ok := out.RawResponse.(*smithyhttp.Response)
424 if !ok {
425 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
426 }
427
428 if response.StatusCode < 200 || response.StatusCode >= 300 {
429 return out, metadata, awsAwsquery_deserializeOpErrorAssumeRoot(response, &metadata)
430 }
431 output := &AssumeRootOutput{}
432 out.Result = output
433
434 var buff [1024]byte
435 ringBuffer := smithyio.NewRingBuffer(buff[:])
436 body := io.TeeReader(response.Body, ringBuffer)
437 rootDecoder := xml.NewDecoder(body)
438 t, err := smithyxml.FetchRootElement(rootDecoder)
439 if err == io.EOF {
440 return out, metadata, nil
441 }
442 if err != nil {
443 var snapshot bytes.Buffer
444 io.Copy(&snapshot, ringBuffer)
445 return out, metadata, &smithy.DeserializationError{
446 Err: fmt.Errorf("failed to decode response body, %w", err),
447 Snapshot: snapshot.Bytes(),
448 }
449 }
450
451 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
452 t, err = decoder.GetElement("AssumeRootResult")
453 if err != nil {
454 var snapshot bytes.Buffer
455 io.Copy(&snapshot, ringBuffer)
456 err = &smithy.DeserializationError{
457 Err: fmt.Errorf("failed to decode response body, %w", err),
458 Snapshot: snapshot.Bytes(),
459 }
460 return out, metadata, err
461 }
462
463 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
464 err = awsAwsquery_deserializeOpDocumentAssumeRootOutput(&output, decoder)
465 if err != nil {
466 var snapshot bytes.Buffer
467 io.Copy(&snapshot, ringBuffer)
468 err = &smithy.DeserializationError{
469 Err: fmt.Errorf("failed to decode response body, %w", err),
470 Snapshot: snapshot.Bytes(),
471 }
472 return out, metadata, err
473 }
474
475 return out, metadata, err
476 }
477
478 func awsAwsquery_deserializeOpErrorAssumeRoot(response *smithyhttp.Response, metadata *middleware.Metadata) error {
479 var errorBuffer bytes.Buffer
480 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
481 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
482 }
483 errorBody := bytes.NewReader(errorBuffer.Bytes())
484
485 errorCode := "UnknownError"
486 errorMessage := errorCode
487
488 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
489 if err != nil {
490 return err
491 }
492 if reqID := errorComponents.RequestID; len(reqID) != 0 {
493 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
494 }
495 if len(errorComponents.Code) != 0 {
496 errorCode = errorComponents.Code
497 }
498 if len(errorComponents.Message) != 0 {
499 errorMessage = errorComponents.Message
500 }
501 errorBody.Seek(0, io.SeekStart)
502 switch {
503 case strings.EqualFold("ExpiredTokenException", errorCode):
504 return awsAwsquery_deserializeErrorExpiredTokenException(response, errorBody)
505
506 case strings.EqualFold("RegionDisabledException", errorCode):
507 return awsAwsquery_deserializeErrorRegionDisabledException(response, errorBody)
508
509 default:
510 genericError := &smithy.GenericAPIError{
511 Code: errorCode,
512 Message: errorMessage,
513 }
514 return genericError
515
516 }
517 }
518
519 type awsAwsquery_deserializeOpDecodeAuthorizationMessage struct {
520 }
521
522 func (*awsAwsquery_deserializeOpDecodeAuthorizationMessage) ID() string {
523 return "OperationDeserializer"
524 }
525
526 func (m *awsAwsquery_deserializeOpDecodeAuthorizationMessage) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
527 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
528 ) {
529 out, metadata, err = next.HandleDeserialize(ctx, in)
530 if err != nil {
531 return out, metadata, err
532 }
533
534 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
535 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
536 defer endTimer()
537 defer span.End()
538 response, ok := out.RawResponse.(*smithyhttp.Response)
539 if !ok {
540 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
541 }
542
543 if response.StatusCode < 200 || response.StatusCode >= 300 {
544 return out, metadata, awsAwsquery_deserializeOpErrorDecodeAuthorizationMessage(response, &metadata)
545 }
546 output := &DecodeAuthorizationMessageOutput{}
547 out.Result = output
548
549 var buff [1024]byte
550 ringBuffer := smithyio.NewRingBuffer(buff[:])
551 body := io.TeeReader(response.Body, ringBuffer)
552 rootDecoder := xml.NewDecoder(body)
553 t, err := smithyxml.FetchRootElement(rootDecoder)
554 if err == io.EOF {
555 return out, metadata, nil
556 }
557 if err != nil {
558 var snapshot bytes.Buffer
559 io.Copy(&snapshot, ringBuffer)
560 return out, metadata, &smithy.DeserializationError{
561 Err: fmt.Errorf("failed to decode response body, %w", err),
562 Snapshot: snapshot.Bytes(),
563 }
564 }
565
566 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
567 t, err = decoder.GetElement("DecodeAuthorizationMessageResult")
568 if err != nil {
569 var snapshot bytes.Buffer
570 io.Copy(&snapshot, ringBuffer)
571 err = &smithy.DeserializationError{
572 Err: fmt.Errorf("failed to decode response body, %w", err),
573 Snapshot: snapshot.Bytes(),
574 }
575 return out, metadata, err
576 }
577
578 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
579 err = awsAwsquery_deserializeOpDocumentDecodeAuthorizationMessageOutput(&output, 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 out, metadata, err
588 }
589
590 return out, metadata, err
591 }
592
593 func awsAwsquery_deserializeOpErrorDecodeAuthorizationMessage(response *smithyhttp.Response, metadata *middleware.Metadata) error {
594 var errorBuffer bytes.Buffer
595 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
596 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
597 }
598 errorBody := bytes.NewReader(errorBuffer.Bytes())
599
600 errorCode := "UnknownError"
601 errorMessage := errorCode
602
603 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
604 if err != nil {
605 return err
606 }
607 if reqID := errorComponents.RequestID; len(reqID) != 0 {
608 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
609 }
610 if len(errorComponents.Code) != 0 {
611 errorCode = errorComponents.Code
612 }
613 if len(errorComponents.Message) != 0 {
614 errorMessage = errorComponents.Message
615 }
616 errorBody.Seek(0, io.SeekStart)
617 switch {
618 case strings.EqualFold("InvalidAuthorizationMessageException", errorCode):
619 return awsAwsquery_deserializeErrorInvalidAuthorizationMessageException(response, errorBody)
620
621 default:
622 genericError := &smithy.GenericAPIError{
623 Code: errorCode,
624 Message: errorMessage,
625 }
626 return genericError
627
628 }
629 }
630
631 type awsAwsquery_deserializeOpGetAccessKeyInfo struct {
632 }
633
634 func (*awsAwsquery_deserializeOpGetAccessKeyInfo) ID() string {
635 return "OperationDeserializer"
636 }
637
638 func (m *awsAwsquery_deserializeOpGetAccessKeyInfo) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
639 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
640 ) {
641 out, metadata, err = next.HandleDeserialize(ctx, in)
642 if err != nil {
643 return out, metadata, err
644 }
645
646 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
647 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
648 defer endTimer()
649 defer span.End()
650 response, ok := out.RawResponse.(*smithyhttp.Response)
651 if !ok {
652 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
653 }
654
655 if response.StatusCode < 200 || response.StatusCode >= 300 {
656 return out, metadata, awsAwsquery_deserializeOpErrorGetAccessKeyInfo(response, &metadata)
657 }
658 output := &GetAccessKeyInfoOutput{}
659 out.Result = output
660
661 var buff [1024]byte
662 ringBuffer := smithyio.NewRingBuffer(buff[:])
663 body := io.TeeReader(response.Body, ringBuffer)
664 rootDecoder := xml.NewDecoder(body)
665 t, err := smithyxml.FetchRootElement(rootDecoder)
666 if err == io.EOF {
667 return out, metadata, nil
668 }
669 if err != nil {
670 var snapshot bytes.Buffer
671 io.Copy(&snapshot, ringBuffer)
672 return out, metadata, &smithy.DeserializationError{
673 Err: fmt.Errorf("failed to decode response body, %w", err),
674 Snapshot: snapshot.Bytes(),
675 }
676 }
677
678 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
679 t, err = decoder.GetElement("GetAccessKeyInfoResult")
680 if err != nil {
681 var snapshot bytes.Buffer
682 io.Copy(&snapshot, ringBuffer)
683 err = &smithy.DeserializationError{
684 Err: fmt.Errorf("failed to decode response body, %w", err),
685 Snapshot: snapshot.Bytes(),
686 }
687 return out, metadata, err
688 }
689
690 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
691 err = awsAwsquery_deserializeOpDocumentGetAccessKeyInfoOutput(&output, decoder)
692 if err != nil {
693 var snapshot bytes.Buffer
694 io.Copy(&snapshot, ringBuffer)
695 err = &smithy.DeserializationError{
696 Err: fmt.Errorf("failed to decode response body, %w", err),
697 Snapshot: snapshot.Bytes(),
698 }
699 return out, metadata, err
700 }
701
702 return out, metadata, err
703 }
704
705 func awsAwsquery_deserializeOpErrorGetAccessKeyInfo(response *smithyhttp.Response, metadata *middleware.Metadata) error {
706 var errorBuffer bytes.Buffer
707 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
708 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
709 }
710 errorBody := bytes.NewReader(errorBuffer.Bytes())
711
712 errorCode := "UnknownError"
713 errorMessage := errorCode
714
715 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
716 if err != nil {
717 return err
718 }
719 if reqID := errorComponents.RequestID; len(reqID) != 0 {
720 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
721 }
722 if len(errorComponents.Code) != 0 {
723 errorCode = errorComponents.Code
724 }
725 if len(errorComponents.Message) != 0 {
726 errorMessage = errorComponents.Message
727 }
728 errorBody.Seek(0, io.SeekStart)
729 switch {
730 default:
731 genericError := &smithy.GenericAPIError{
732 Code: errorCode,
733 Message: errorMessage,
734 }
735 return genericError
736
737 }
738 }
739
740 type awsAwsquery_deserializeOpGetCallerIdentity struct {
741 }
742
743 func (*awsAwsquery_deserializeOpGetCallerIdentity) ID() string {
744 return "OperationDeserializer"
745 }
746
747 func (m *awsAwsquery_deserializeOpGetCallerIdentity) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
748 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
749 ) {
750 out, metadata, err = next.HandleDeserialize(ctx, in)
751 if err != nil {
752 return out, metadata, err
753 }
754
755 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
756 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
757 defer endTimer()
758 defer span.End()
759 response, ok := out.RawResponse.(*smithyhttp.Response)
760 if !ok {
761 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
762 }
763
764 if response.StatusCode < 200 || response.StatusCode >= 300 {
765 return out, metadata, awsAwsquery_deserializeOpErrorGetCallerIdentity(response, &metadata)
766 }
767 output := &GetCallerIdentityOutput{}
768 out.Result = output
769
770 var buff [1024]byte
771 ringBuffer := smithyio.NewRingBuffer(buff[:])
772 body := io.TeeReader(response.Body, ringBuffer)
773 rootDecoder := xml.NewDecoder(body)
774 t, err := smithyxml.FetchRootElement(rootDecoder)
775 if err == io.EOF {
776 return out, metadata, nil
777 }
778 if err != nil {
779 var snapshot bytes.Buffer
780 io.Copy(&snapshot, ringBuffer)
781 return out, metadata, &smithy.DeserializationError{
782 Err: fmt.Errorf("failed to decode response body, %w", err),
783 Snapshot: snapshot.Bytes(),
784 }
785 }
786
787 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
788 t, err = decoder.GetElement("GetCallerIdentityResult")
789 if err != nil {
790 var snapshot bytes.Buffer
791 io.Copy(&snapshot, ringBuffer)
792 err = &smithy.DeserializationError{
793 Err: fmt.Errorf("failed to decode response body, %w", err),
794 Snapshot: snapshot.Bytes(),
795 }
796 return out, metadata, err
797 }
798
799 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
800 err = awsAwsquery_deserializeOpDocumentGetCallerIdentityOutput(&output, decoder)
801 if err != nil {
802 var snapshot bytes.Buffer
803 io.Copy(&snapshot, ringBuffer)
804 err = &smithy.DeserializationError{
805 Err: fmt.Errorf("failed to decode response body, %w", err),
806 Snapshot: snapshot.Bytes(),
807 }
808 return out, metadata, err
809 }
810
811 return out, metadata, err
812 }
813
814 func awsAwsquery_deserializeOpErrorGetCallerIdentity(response *smithyhttp.Response, metadata *middleware.Metadata) error {
815 var errorBuffer bytes.Buffer
816 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
817 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
818 }
819 errorBody := bytes.NewReader(errorBuffer.Bytes())
820
821 errorCode := "UnknownError"
822 errorMessage := errorCode
823
824 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
825 if err != nil {
826 return err
827 }
828 if reqID := errorComponents.RequestID; len(reqID) != 0 {
829 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
830 }
831 if len(errorComponents.Code) != 0 {
832 errorCode = errorComponents.Code
833 }
834 if len(errorComponents.Message) != 0 {
835 errorMessage = errorComponents.Message
836 }
837 errorBody.Seek(0, io.SeekStart)
838 switch {
839 default:
840 genericError := &smithy.GenericAPIError{
841 Code: errorCode,
842 Message: errorMessage,
843 }
844 return genericError
845
846 }
847 }
848
849 type awsAwsquery_deserializeOpGetDelegatedAccessToken struct {
850 }
851
852 func (*awsAwsquery_deserializeOpGetDelegatedAccessToken) ID() string {
853 return "OperationDeserializer"
854 }
855
856 func (m *awsAwsquery_deserializeOpGetDelegatedAccessToken) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
857 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
858 ) {
859 out, metadata, err = next.HandleDeserialize(ctx, in)
860 if err != nil {
861 return out, metadata, err
862 }
863
864 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
865 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
866 defer endTimer()
867 defer span.End()
868 response, ok := out.RawResponse.(*smithyhttp.Response)
869 if !ok {
870 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
871 }
872
873 if response.StatusCode < 200 || response.StatusCode >= 300 {
874 return out, metadata, awsAwsquery_deserializeOpErrorGetDelegatedAccessToken(response, &metadata)
875 }
876 output := &GetDelegatedAccessTokenOutput{}
877 out.Result = output
878
879 var buff [1024]byte
880 ringBuffer := smithyio.NewRingBuffer(buff[:])
881 body := io.TeeReader(response.Body, ringBuffer)
882 rootDecoder := xml.NewDecoder(body)
883 t, err := smithyxml.FetchRootElement(rootDecoder)
884 if err == io.EOF {
885 return out, metadata, nil
886 }
887 if err != nil {
888 var snapshot bytes.Buffer
889 io.Copy(&snapshot, ringBuffer)
890 return out, metadata, &smithy.DeserializationError{
891 Err: fmt.Errorf("failed to decode response body, %w", err),
892 Snapshot: snapshot.Bytes(),
893 }
894 }
895
896 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
897 t, err = decoder.GetElement("GetDelegatedAccessTokenResult")
898 if err != nil {
899 var snapshot bytes.Buffer
900 io.Copy(&snapshot, ringBuffer)
901 err = &smithy.DeserializationError{
902 Err: fmt.Errorf("failed to decode response body, %w", err),
903 Snapshot: snapshot.Bytes(),
904 }
905 return out, metadata, err
906 }
907
908 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
909 err = awsAwsquery_deserializeOpDocumentGetDelegatedAccessTokenOutput(&output, decoder)
910 if err != nil {
911 var snapshot bytes.Buffer
912 io.Copy(&snapshot, ringBuffer)
913 err = &smithy.DeserializationError{
914 Err: fmt.Errorf("failed to decode response body, %w", err),
915 Snapshot: snapshot.Bytes(),
916 }
917 return out, metadata, err
918 }
919
920 return out, metadata, err
921 }
922
923 func awsAwsquery_deserializeOpErrorGetDelegatedAccessToken(response *smithyhttp.Response, metadata *middleware.Metadata) error {
924 var errorBuffer bytes.Buffer
925 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
926 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
927 }
928 errorBody := bytes.NewReader(errorBuffer.Bytes())
929
930 errorCode := "UnknownError"
931 errorMessage := errorCode
932
933 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
934 if err != nil {
935 return err
936 }
937 if reqID := errorComponents.RequestID; len(reqID) != 0 {
938 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
939 }
940 if len(errorComponents.Code) != 0 {
941 errorCode = errorComponents.Code
942 }
943 if len(errorComponents.Message) != 0 {
944 errorMessage = errorComponents.Message
945 }
946 errorBody.Seek(0, io.SeekStart)
947 switch {
948 case strings.EqualFold("ExpiredTradeInTokenException", errorCode):
949 return awsAwsquery_deserializeErrorExpiredTradeInTokenException(response, errorBody)
950
951 case strings.EqualFold("PackedPolicyTooLarge", errorCode):
952 return awsAwsquery_deserializeErrorPackedPolicyTooLargeException(response, errorBody)
953
954 case strings.EqualFold("RegionDisabledException", errorCode):
955 return awsAwsquery_deserializeErrorRegionDisabledException(response, errorBody)
956
957 default:
958 genericError := &smithy.GenericAPIError{
959 Code: errorCode,
960 Message: errorMessage,
961 }
962 return genericError
963
964 }
965 }
966
967 type awsAwsquery_deserializeOpGetFederationToken struct {
968 }
969
970 func (*awsAwsquery_deserializeOpGetFederationToken) ID() string {
971 return "OperationDeserializer"
972 }
973
974 func (m *awsAwsquery_deserializeOpGetFederationToken) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
975 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
976 ) {
977 out, metadata, err = next.HandleDeserialize(ctx, in)
978 if err != nil {
979 return out, metadata, err
980 }
981
982 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
983 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
984 defer endTimer()
985 defer span.End()
986 response, ok := out.RawResponse.(*smithyhttp.Response)
987 if !ok {
988 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
989 }
990
991 if response.StatusCode < 200 || response.StatusCode >= 300 {
992 return out, metadata, awsAwsquery_deserializeOpErrorGetFederationToken(response, &metadata)
993 }
994 output := &GetFederationTokenOutput{}
995 out.Result = output
996
997 var buff [1024]byte
998 ringBuffer := smithyio.NewRingBuffer(buff[:])
999 body := io.TeeReader(response.Body, ringBuffer)
1000 rootDecoder := xml.NewDecoder(body)
1001 t, err := smithyxml.FetchRootElement(rootDecoder)
1002 if err == io.EOF {
1003 return out, metadata, nil
1004 }
1005 if err != nil {
1006 var snapshot bytes.Buffer
1007 io.Copy(&snapshot, ringBuffer)
1008 return out, metadata, &smithy.DeserializationError{
1009 Err: fmt.Errorf("failed to decode response body, %w", err),
1010 Snapshot: snapshot.Bytes(),
1011 }
1012 }
1013
1014 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
1015 t, err = decoder.GetElement("GetFederationTokenResult")
1016 if err != nil {
1017 var snapshot bytes.Buffer
1018 io.Copy(&snapshot, ringBuffer)
1019 err = &smithy.DeserializationError{
1020 Err: fmt.Errorf("failed to decode response body, %w", err),
1021 Snapshot: snapshot.Bytes(),
1022 }
1023 return out, metadata, err
1024 }
1025
1026 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1027 err = awsAwsquery_deserializeOpDocumentGetFederationTokenOutput(&output, decoder)
1028 if err != nil {
1029 var snapshot bytes.Buffer
1030 io.Copy(&snapshot, ringBuffer)
1031 err = &smithy.DeserializationError{
1032 Err: fmt.Errorf("failed to decode response body, %w", err),
1033 Snapshot: snapshot.Bytes(),
1034 }
1035 return out, metadata, err
1036 }
1037
1038 return out, metadata, err
1039 }
1040
1041 func awsAwsquery_deserializeOpErrorGetFederationToken(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1042 var errorBuffer bytes.Buffer
1043 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1044 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1045 }
1046 errorBody := bytes.NewReader(errorBuffer.Bytes())
1047
1048 errorCode := "UnknownError"
1049 errorMessage := errorCode
1050
1051 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
1052 if err != nil {
1053 return err
1054 }
1055 if reqID := errorComponents.RequestID; len(reqID) != 0 {
1056 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
1057 }
1058 if len(errorComponents.Code) != 0 {
1059 errorCode = errorComponents.Code
1060 }
1061 if len(errorComponents.Message) != 0 {
1062 errorMessage = errorComponents.Message
1063 }
1064 errorBody.Seek(0, io.SeekStart)
1065 switch {
1066 case strings.EqualFold("MalformedPolicyDocument", errorCode):
1067 return awsAwsquery_deserializeErrorMalformedPolicyDocumentException(response, errorBody)
1068
1069 case strings.EqualFold("PackedPolicyTooLarge", errorCode):
1070 return awsAwsquery_deserializeErrorPackedPolicyTooLargeException(response, errorBody)
1071
1072 case strings.EqualFold("RegionDisabledException", errorCode):
1073 return awsAwsquery_deserializeErrorRegionDisabledException(response, errorBody)
1074
1075 default:
1076 genericError := &smithy.GenericAPIError{
1077 Code: errorCode,
1078 Message: errorMessage,
1079 }
1080 return genericError
1081
1082 }
1083 }
1084
1085 type awsAwsquery_deserializeOpGetSessionToken struct {
1086 }
1087
1088 func (*awsAwsquery_deserializeOpGetSessionToken) ID() string {
1089 return "OperationDeserializer"
1090 }
1091
1092 func (m *awsAwsquery_deserializeOpGetSessionToken) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1093 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1094 ) {
1095 out, metadata, err = next.HandleDeserialize(ctx, in)
1096 if err != nil {
1097 return out, metadata, err
1098 }
1099
1100 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
1101 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
1102 defer endTimer()
1103 defer span.End()
1104 response, ok := out.RawResponse.(*smithyhttp.Response)
1105 if !ok {
1106 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1107 }
1108
1109 if response.StatusCode < 200 || response.StatusCode >= 300 {
1110 return out, metadata, awsAwsquery_deserializeOpErrorGetSessionToken(response, &metadata)
1111 }
1112 output := &GetSessionTokenOutput{}
1113 out.Result = output
1114
1115 var buff [1024]byte
1116 ringBuffer := smithyio.NewRingBuffer(buff[:])
1117 body := io.TeeReader(response.Body, ringBuffer)
1118 rootDecoder := xml.NewDecoder(body)
1119 t, err := smithyxml.FetchRootElement(rootDecoder)
1120 if err == io.EOF {
1121 return out, metadata, nil
1122 }
1123 if err != nil {
1124 var snapshot bytes.Buffer
1125 io.Copy(&snapshot, ringBuffer)
1126 return out, metadata, &smithy.DeserializationError{
1127 Err: fmt.Errorf("failed to decode response body, %w", err),
1128 Snapshot: snapshot.Bytes(),
1129 }
1130 }
1131
1132 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
1133 t, err = decoder.GetElement("GetSessionTokenResult")
1134 if err != nil {
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 out, metadata, err
1142 }
1143
1144 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1145 err = awsAwsquery_deserializeOpDocumentGetSessionTokenOutput(&output, decoder)
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 out, metadata, err
1154 }
1155
1156 return out, metadata, err
1157 }
1158
1159 func awsAwsquery_deserializeOpErrorGetSessionToken(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1160 var errorBuffer bytes.Buffer
1161 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1162 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1163 }
1164 errorBody := bytes.NewReader(errorBuffer.Bytes())
1165
1166 errorCode := "UnknownError"
1167 errorMessage := errorCode
1168
1169 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
1170 if err != nil {
1171 return err
1172 }
1173 if reqID := errorComponents.RequestID; len(reqID) != 0 {
1174 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
1175 }
1176 if len(errorComponents.Code) != 0 {
1177 errorCode = errorComponents.Code
1178 }
1179 if len(errorComponents.Message) != 0 {
1180 errorMessage = errorComponents.Message
1181 }
1182 errorBody.Seek(0, io.SeekStart)
1183 switch {
1184 case strings.EqualFold("RegionDisabledException", errorCode):
1185 return awsAwsquery_deserializeErrorRegionDisabledException(response, errorBody)
1186
1187 default:
1188 genericError := &smithy.GenericAPIError{
1189 Code: errorCode,
1190 Message: errorMessage,
1191 }
1192 return genericError
1193
1194 }
1195 }
1196
1197 type awsAwsquery_deserializeOpGetWebIdentityToken struct {
1198 }
1199
1200 func (*awsAwsquery_deserializeOpGetWebIdentityToken) ID() string {
1201 return "OperationDeserializer"
1202 }
1203
1204 func (m *awsAwsquery_deserializeOpGetWebIdentityToken) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1205 out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1206 ) {
1207 out, metadata, err = next.HandleDeserialize(ctx, in)
1208 if err != nil {
1209 return out, metadata, err
1210 }
1211
1212 _, span := tracing.StartSpan(ctx, "OperationDeserializer")
1213 endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
1214 defer endTimer()
1215 defer span.End()
1216 response, ok := out.RawResponse.(*smithyhttp.Response)
1217 if !ok {
1218 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1219 }
1220
1221 if response.StatusCode < 200 || response.StatusCode >= 300 {
1222 return out, metadata, awsAwsquery_deserializeOpErrorGetWebIdentityToken(response, &metadata)
1223 }
1224 output := &GetWebIdentityTokenOutput{}
1225 out.Result = output
1226
1227 var buff [1024]byte
1228 ringBuffer := smithyio.NewRingBuffer(buff[:])
1229 body := io.TeeReader(response.Body, ringBuffer)
1230 rootDecoder := xml.NewDecoder(body)
1231 t, err := smithyxml.FetchRootElement(rootDecoder)
1232 if err == io.EOF {
1233 return out, metadata, nil
1234 }
1235 if err != nil {
1236 var snapshot bytes.Buffer
1237 io.Copy(&snapshot, ringBuffer)
1238 return out, metadata, &smithy.DeserializationError{
1239 Err: fmt.Errorf("failed to decode response body, %w", err),
1240 Snapshot: snapshot.Bytes(),
1241 }
1242 }
1243
1244 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
1245 t, err = decoder.GetElement("GetWebIdentityTokenResult")
1246 if err != nil {
1247 var snapshot bytes.Buffer
1248 io.Copy(&snapshot, ringBuffer)
1249 err = &smithy.DeserializationError{
1250 Err: fmt.Errorf("failed to decode response body, %w", err),
1251 Snapshot: snapshot.Bytes(),
1252 }
1253 return out, metadata, err
1254 }
1255
1256 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1257 err = awsAwsquery_deserializeOpDocumentGetWebIdentityTokenOutput(&output, decoder)
1258 if err != nil {
1259 var snapshot bytes.Buffer
1260 io.Copy(&snapshot, ringBuffer)
1261 err = &smithy.DeserializationError{
1262 Err: fmt.Errorf("failed to decode response body, %w", err),
1263 Snapshot: snapshot.Bytes(),
1264 }
1265 return out, metadata, err
1266 }
1267
1268 return out, metadata, err
1269 }
1270
1271 func awsAwsquery_deserializeOpErrorGetWebIdentityToken(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1272 var errorBuffer bytes.Buffer
1273 if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1274 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1275 }
1276 errorBody := bytes.NewReader(errorBuffer.Bytes())
1277
1278 errorCode := "UnknownError"
1279 errorMessage := errorCode
1280
1281 errorComponents, err := awsxml.GetErrorResponseComponents(errorBody, false)
1282 if err != nil {
1283 return err
1284 }
1285 if reqID := errorComponents.RequestID; len(reqID) != 0 {
1286 awsmiddleware.SetRequestIDMetadata(metadata, reqID)
1287 }
1288 if len(errorComponents.Code) != 0 {
1289 errorCode = errorComponents.Code
1290 }
1291 if len(errorComponents.Message) != 0 {
1292 errorMessage = errorComponents.Message
1293 }
1294 errorBody.Seek(0, io.SeekStart)
1295 switch {
1296 case strings.EqualFold("JWTPayloadSizeExceededException", errorCode):
1297 return awsAwsquery_deserializeErrorJWTPayloadSizeExceededException(response, errorBody)
1298
1299 case strings.EqualFold("OutboundWebIdentityFederationDisabledException", errorCode):
1300 return awsAwsquery_deserializeErrorOutboundWebIdentityFederationDisabledException(response, errorBody)
1301
1302 case strings.EqualFold("SessionDurationEscalationException", errorCode):
1303 return awsAwsquery_deserializeErrorSessionDurationEscalationException(response, errorBody)
1304
1305 default:
1306 genericError := &smithy.GenericAPIError{
1307 Code: errorCode,
1308 Message: errorMessage,
1309 }
1310 return genericError
1311
1312 }
1313 }
1314
1315 func awsAwsquery_deserializeErrorExpiredTokenException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
1316 output := &types.ExpiredTokenException{}
1317 var buff [1024]byte
1318 ringBuffer := smithyio.NewRingBuffer(buff[:])
1319 body := io.TeeReader(errorBody, ringBuffer)
1320 rootDecoder := xml.NewDecoder(body)
1321 t, err := smithyxml.FetchRootElement(rootDecoder)
1322 if err == io.EOF {
1323 return output
1324 }
1325 if err != nil {
1326 var snapshot bytes.Buffer
1327 io.Copy(&snapshot, ringBuffer)
1328 return &smithy.DeserializationError{
1329 Err: fmt.Errorf("failed to decode response body, %w", err),
1330 Snapshot: snapshot.Bytes(),
1331 }
1332 }
1333
1334 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
1335 t, err = decoder.GetElement("Error")
1336 if err != nil {
1337 var snapshot bytes.Buffer
1338 io.Copy(&snapshot, ringBuffer)
1339 return &smithy.DeserializationError{
1340 Err: fmt.Errorf("failed to decode response body, %w", err),
1341 Snapshot: snapshot.Bytes(),
1342 }
1343 }
1344
1345 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1346 err = awsAwsquery_deserializeDocumentExpiredTokenException(&output, decoder)
1347 if err != nil {
1348 var snapshot bytes.Buffer
1349 io.Copy(&snapshot, ringBuffer)
1350 return &smithy.DeserializationError{
1351 Err: fmt.Errorf("failed to decode response body, %w", err),
1352 Snapshot: snapshot.Bytes(),
1353 }
1354 }
1355
1356 return output
1357 }
1358
1359 func awsAwsquery_deserializeErrorExpiredTradeInTokenException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
1360 output := &types.ExpiredTradeInTokenException{}
1361 var buff [1024]byte
1362 ringBuffer := smithyio.NewRingBuffer(buff[:])
1363 body := io.TeeReader(errorBody, ringBuffer)
1364 rootDecoder := xml.NewDecoder(body)
1365 t, err := smithyxml.FetchRootElement(rootDecoder)
1366 if err == io.EOF {
1367 return output
1368 }
1369 if err != nil {
1370 var snapshot bytes.Buffer
1371 io.Copy(&snapshot, ringBuffer)
1372 return &smithy.DeserializationError{
1373 Err: fmt.Errorf("failed to decode response body, %w", err),
1374 Snapshot: snapshot.Bytes(),
1375 }
1376 }
1377
1378 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
1379 t, err = decoder.GetElement("Error")
1380 if err != nil {
1381 var snapshot bytes.Buffer
1382 io.Copy(&snapshot, ringBuffer)
1383 return &smithy.DeserializationError{
1384 Err: fmt.Errorf("failed to decode response body, %w", err),
1385 Snapshot: snapshot.Bytes(),
1386 }
1387 }
1388
1389 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1390 err = awsAwsquery_deserializeDocumentExpiredTradeInTokenException(&output, decoder)
1391 if err != nil {
1392 var snapshot bytes.Buffer
1393 io.Copy(&snapshot, ringBuffer)
1394 return &smithy.DeserializationError{
1395 Err: fmt.Errorf("failed to decode response body, %w", err),
1396 Snapshot: snapshot.Bytes(),
1397 }
1398 }
1399
1400 return output
1401 }
1402
1403 func awsAwsquery_deserializeErrorIDPCommunicationErrorException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
1404 output := &types.IDPCommunicationErrorException{}
1405 var buff [1024]byte
1406 ringBuffer := smithyio.NewRingBuffer(buff[:])
1407 body := io.TeeReader(errorBody, ringBuffer)
1408 rootDecoder := xml.NewDecoder(body)
1409 t, err := smithyxml.FetchRootElement(rootDecoder)
1410 if err == io.EOF {
1411 return output
1412 }
1413 if err != nil {
1414 var snapshot bytes.Buffer
1415 io.Copy(&snapshot, ringBuffer)
1416 return &smithy.DeserializationError{
1417 Err: fmt.Errorf("failed to decode response body, %w", err),
1418 Snapshot: snapshot.Bytes(),
1419 }
1420 }
1421
1422 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
1423 t, err = decoder.GetElement("Error")
1424 if err != nil {
1425 var snapshot bytes.Buffer
1426 io.Copy(&snapshot, ringBuffer)
1427 return &smithy.DeserializationError{
1428 Err: fmt.Errorf("failed to decode response body, %w", err),
1429 Snapshot: snapshot.Bytes(),
1430 }
1431 }
1432
1433 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1434 err = awsAwsquery_deserializeDocumentIDPCommunicationErrorException(&output, decoder)
1435 if err != nil {
1436 var snapshot bytes.Buffer
1437 io.Copy(&snapshot, ringBuffer)
1438 return &smithy.DeserializationError{
1439 Err: fmt.Errorf("failed to decode response body, %w", err),
1440 Snapshot: snapshot.Bytes(),
1441 }
1442 }
1443
1444 return output
1445 }
1446
1447 func awsAwsquery_deserializeErrorIDPRejectedClaimException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
1448 output := &types.IDPRejectedClaimException{}
1449 var buff [1024]byte
1450 ringBuffer := smithyio.NewRingBuffer(buff[:])
1451 body := io.TeeReader(errorBody, ringBuffer)
1452 rootDecoder := xml.NewDecoder(body)
1453 t, err := smithyxml.FetchRootElement(rootDecoder)
1454 if err == io.EOF {
1455 return output
1456 }
1457 if err != nil {
1458 var snapshot bytes.Buffer
1459 io.Copy(&snapshot, ringBuffer)
1460 return &smithy.DeserializationError{
1461 Err: fmt.Errorf("failed to decode response body, %w", err),
1462 Snapshot: snapshot.Bytes(),
1463 }
1464 }
1465
1466 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
1467 t, err = decoder.GetElement("Error")
1468 if err != nil {
1469 var snapshot bytes.Buffer
1470 io.Copy(&snapshot, ringBuffer)
1471 return &smithy.DeserializationError{
1472 Err: fmt.Errorf("failed to decode response body, %w", err),
1473 Snapshot: snapshot.Bytes(),
1474 }
1475 }
1476
1477 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1478 err = awsAwsquery_deserializeDocumentIDPRejectedClaimException(&output, decoder)
1479 if err != nil {
1480 var snapshot bytes.Buffer
1481 io.Copy(&snapshot, ringBuffer)
1482 return &smithy.DeserializationError{
1483 Err: fmt.Errorf("failed to decode response body, %w", err),
1484 Snapshot: snapshot.Bytes(),
1485 }
1486 }
1487
1488 return output
1489 }
1490
1491 func awsAwsquery_deserializeErrorInvalidAuthorizationMessageException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
1492 output := &types.InvalidAuthorizationMessageException{}
1493 var buff [1024]byte
1494 ringBuffer := smithyio.NewRingBuffer(buff[:])
1495 body := io.TeeReader(errorBody, ringBuffer)
1496 rootDecoder := xml.NewDecoder(body)
1497 t, err := smithyxml.FetchRootElement(rootDecoder)
1498 if err == io.EOF {
1499 return output
1500 }
1501 if err != nil {
1502 var snapshot bytes.Buffer
1503 io.Copy(&snapshot, ringBuffer)
1504 return &smithy.DeserializationError{
1505 Err: fmt.Errorf("failed to decode response body, %w", err),
1506 Snapshot: snapshot.Bytes(),
1507 }
1508 }
1509
1510 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
1511 t, err = decoder.GetElement("Error")
1512 if err != nil {
1513 var snapshot bytes.Buffer
1514 io.Copy(&snapshot, ringBuffer)
1515 return &smithy.DeserializationError{
1516 Err: fmt.Errorf("failed to decode response body, %w", err),
1517 Snapshot: snapshot.Bytes(),
1518 }
1519 }
1520
1521 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1522 err = awsAwsquery_deserializeDocumentInvalidAuthorizationMessageException(&output, decoder)
1523 if err != nil {
1524 var snapshot bytes.Buffer
1525 io.Copy(&snapshot, ringBuffer)
1526 return &smithy.DeserializationError{
1527 Err: fmt.Errorf("failed to decode response body, %w", err),
1528 Snapshot: snapshot.Bytes(),
1529 }
1530 }
1531
1532 return output
1533 }
1534
1535 func awsAwsquery_deserializeErrorInvalidIdentityTokenException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
1536 output := &types.InvalidIdentityTokenException{}
1537 var buff [1024]byte
1538 ringBuffer := smithyio.NewRingBuffer(buff[:])
1539 body := io.TeeReader(errorBody, ringBuffer)
1540 rootDecoder := xml.NewDecoder(body)
1541 t, err := smithyxml.FetchRootElement(rootDecoder)
1542 if err == io.EOF {
1543 return output
1544 }
1545 if err != nil {
1546 var snapshot bytes.Buffer
1547 io.Copy(&snapshot, ringBuffer)
1548 return &smithy.DeserializationError{
1549 Err: fmt.Errorf("failed to decode response body, %w", err),
1550 Snapshot: snapshot.Bytes(),
1551 }
1552 }
1553
1554 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
1555 t, err = decoder.GetElement("Error")
1556 if err != nil {
1557 var snapshot bytes.Buffer
1558 io.Copy(&snapshot, ringBuffer)
1559 return &smithy.DeserializationError{
1560 Err: fmt.Errorf("failed to decode response body, %w", err),
1561 Snapshot: snapshot.Bytes(),
1562 }
1563 }
1564
1565 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1566 err = awsAwsquery_deserializeDocumentInvalidIdentityTokenException(&output, decoder)
1567 if err != nil {
1568 var snapshot bytes.Buffer
1569 io.Copy(&snapshot, ringBuffer)
1570 return &smithy.DeserializationError{
1571 Err: fmt.Errorf("failed to decode response body, %w", err),
1572 Snapshot: snapshot.Bytes(),
1573 }
1574 }
1575
1576 return output
1577 }
1578
1579 func awsAwsquery_deserializeErrorJWTPayloadSizeExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
1580 output := &types.JWTPayloadSizeExceededException{}
1581 var buff [1024]byte
1582 ringBuffer := smithyio.NewRingBuffer(buff[:])
1583 body := io.TeeReader(errorBody, ringBuffer)
1584 rootDecoder := xml.NewDecoder(body)
1585 t, err := smithyxml.FetchRootElement(rootDecoder)
1586 if err == io.EOF {
1587 return output
1588 }
1589 if err != nil {
1590 var snapshot bytes.Buffer
1591 io.Copy(&snapshot, ringBuffer)
1592 return &smithy.DeserializationError{
1593 Err: fmt.Errorf("failed to decode response body, %w", err),
1594 Snapshot: snapshot.Bytes(),
1595 }
1596 }
1597
1598 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
1599 t, err = decoder.GetElement("Error")
1600 if err != nil {
1601 var snapshot bytes.Buffer
1602 io.Copy(&snapshot, ringBuffer)
1603 return &smithy.DeserializationError{
1604 Err: fmt.Errorf("failed to decode response body, %w", err),
1605 Snapshot: snapshot.Bytes(),
1606 }
1607 }
1608
1609 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1610 err = awsAwsquery_deserializeDocumentJWTPayloadSizeExceededException(&output, decoder)
1611 if err != nil {
1612 var snapshot bytes.Buffer
1613 io.Copy(&snapshot, ringBuffer)
1614 return &smithy.DeserializationError{
1615 Err: fmt.Errorf("failed to decode response body, %w", err),
1616 Snapshot: snapshot.Bytes(),
1617 }
1618 }
1619
1620 return output
1621 }
1622
1623 func awsAwsquery_deserializeErrorMalformedPolicyDocumentException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
1624 output := &types.MalformedPolicyDocumentException{}
1625 var buff [1024]byte
1626 ringBuffer := smithyio.NewRingBuffer(buff[:])
1627 body := io.TeeReader(errorBody, ringBuffer)
1628 rootDecoder := xml.NewDecoder(body)
1629 t, err := smithyxml.FetchRootElement(rootDecoder)
1630 if err == io.EOF {
1631 return output
1632 }
1633 if err != nil {
1634 var snapshot bytes.Buffer
1635 io.Copy(&snapshot, ringBuffer)
1636 return &smithy.DeserializationError{
1637 Err: fmt.Errorf("failed to decode response body, %w", err),
1638 Snapshot: snapshot.Bytes(),
1639 }
1640 }
1641
1642 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
1643 t, err = decoder.GetElement("Error")
1644 if err != nil {
1645 var snapshot bytes.Buffer
1646 io.Copy(&snapshot, ringBuffer)
1647 return &smithy.DeserializationError{
1648 Err: fmt.Errorf("failed to decode response body, %w", err),
1649 Snapshot: snapshot.Bytes(),
1650 }
1651 }
1652
1653 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1654 err = awsAwsquery_deserializeDocumentMalformedPolicyDocumentException(&output, decoder)
1655 if err != nil {
1656 var snapshot bytes.Buffer
1657 io.Copy(&snapshot, ringBuffer)
1658 return &smithy.DeserializationError{
1659 Err: fmt.Errorf("failed to decode response body, %w", err),
1660 Snapshot: snapshot.Bytes(),
1661 }
1662 }
1663
1664 return output
1665 }
1666
1667 func awsAwsquery_deserializeErrorOutboundWebIdentityFederationDisabledException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
1668 output := &types.OutboundWebIdentityFederationDisabledException{}
1669 var buff [1024]byte
1670 ringBuffer := smithyio.NewRingBuffer(buff[:])
1671 body := io.TeeReader(errorBody, ringBuffer)
1672 rootDecoder := xml.NewDecoder(body)
1673 t, err := smithyxml.FetchRootElement(rootDecoder)
1674 if err == io.EOF {
1675 return output
1676 }
1677 if err != nil {
1678 var snapshot bytes.Buffer
1679 io.Copy(&snapshot, ringBuffer)
1680 return &smithy.DeserializationError{
1681 Err: fmt.Errorf("failed to decode response body, %w", err),
1682 Snapshot: snapshot.Bytes(),
1683 }
1684 }
1685
1686 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
1687 t, err = decoder.GetElement("Error")
1688 if err != nil {
1689 var snapshot bytes.Buffer
1690 io.Copy(&snapshot, ringBuffer)
1691 return &smithy.DeserializationError{
1692 Err: fmt.Errorf("failed to decode response body, %w", err),
1693 Snapshot: snapshot.Bytes(),
1694 }
1695 }
1696
1697 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1698 err = awsAwsquery_deserializeDocumentOutboundWebIdentityFederationDisabledException(&output, decoder)
1699 if err != nil {
1700 var snapshot bytes.Buffer
1701 io.Copy(&snapshot, ringBuffer)
1702 return &smithy.DeserializationError{
1703 Err: fmt.Errorf("failed to decode response body, %w", err),
1704 Snapshot: snapshot.Bytes(),
1705 }
1706 }
1707
1708 return output
1709 }
1710
1711 func awsAwsquery_deserializeErrorPackedPolicyTooLargeException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
1712 output := &types.PackedPolicyTooLargeException{}
1713 var buff [1024]byte
1714 ringBuffer := smithyio.NewRingBuffer(buff[:])
1715 body := io.TeeReader(errorBody, ringBuffer)
1716 rootDecoder := xml.NewDecoder(body)
1717 t, err := smithyxml.FetchRootElement(rootDecoder)
1718 if err == io.EOF {
1719 return output
1720 }
1721 if err != nil {
1722 var snapshot bytes.Buffer
1723 io.Copy(&snapshot, ringBuffer)
1724 return &smithy.DeserializationError{
1725 Err: fmt.Errorf("failed to decode response body, %w", err),
1726 Snapshot: snapshot.Bytes(),
1727 }
1728 }
1729
1730 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
1731 t, err = decoder.GetElement("Error")
1732 if err != nil {
1733 var snapshot bytes.Buffer
1734 io.Copy(&snapshot, ringBuffer)
1735 return &smithy.DeserializationError{
1736 Err: fmt.Errorf("failed to decode response body, %w", err),
1737 Snapshot: snapshot.Bytes(),
1738 }
1739 }
1740
1741 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1742 err = awsAwsquery_deserializeDocumentPackedPolicyTooLargeException(&output, decoder)
1743 if err != nil {
1744 var snapshot bytes.Buffer
1745 io.Copy(&snapshot, ringBuffer)
1746 return &smithy.DeserializationError{
1747 Err: fmt.Errorf("failed to decode response body, %w", err),
1748 Snapshot: snapshot.Bytes(),
1749 }
1750 }
1751
1752 return output
1753 }
1754
1755 func awsAwsquery_deserializeErrorRegionDisabledException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
1756 output := &types.RegionDisabledException{}
1757 var buff [1024]byte
1758 ringBuffer := smithyio.NewRingBuffer(buff[:])
1759 body := io.TeeReader(errorBody, ringBuffer)
1760 rootDecoder := xml.NewDecoder(body)
1761 t, err := smithyxml.FetchRootElement(rootDecoder)
1762 if err == io.EOF {
1763 return output
1764 }
1765 if err != nil {
1766 var snapshot bytes.Buffer
1767 io.Copy(&snapshot, ringBuffer)
1768 return &smithy.DeserializationError{
1769 Err: fmt.Errorf("failed to decode response body, %w", err),
1770 Snapshot: snapshot.Bytes(),
1771 }
1772 }
1773
1774 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
1775 t, err = decoder.GetElement("Error")
1776 if err != nil {
1777 var snapshot bytes.Buffer
1778 io.Copy(&snapshot, ringBuffer)
1779 return &smithy.DeserializationError{
1780 Err: fmt.Errorf("failed to decode response body, %w", err),
1781 Snapshot: snapshot.Bytes(),
1782 }
1783 }
1784
1785 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1786 err = awsAwsquery_deserializeDocumentRegionDisabledException(&output, decoder)
1787 if err != nil {
1788 var snapshot bytes.Buffer
1789 io.Copy(&snapshot, ringBuffer)
1790 return &smithy.DeserializationError{
1791 Err: fmt.Errorf("failed to decode response body, %w", err),
1792 Snapshot: snapshot.Bytes(),
1793 }
1794 }
1795
1796 return output
1797 }
1798
1799 func awsAwsquery_deserializeErrorSessionDurationEscalationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
1800 output := &types.SessionDurationEscalationException{}
1801 var buff [1024]byte
1802 ringBuffer := smithyio.NewRingBuffer(buff[:])
1803 body := io.TeeReader(errorBody, ringBuffer)
1804 rootDecoder := xml.NewDecoder(body)
1805 t, err := smithyxml.FetchRootElement(rootDecoder)
1806 if err == io.EOF {
1807 return output
1808 }
1809 if err != nil {
1810 var snapshot bytes.Buffer
1811 io.Copy(&snapshot, ringBuffer)
1812 return &smithy.DeserializationError{
1813 Err: fmt.Errorf("failed to decode response body, %w", err),
1814 Snapshot: snapshot.Bytes(),
1815 }
1816 }
1817
1818 decoder := smithyxml.WrapNodeDecoder(rootDecoder, t)
1819 t, err = decoder.GetElement("Error")
1820 if err != nil {
1821 var snapshot bytes.Buffer
1822 io.Copy(&snapshot, ringBuffer)
1823 return &smithy.DeserializationError{
1824 Err: fmt.Errorf("failed to decode response body, %w", err),
1825 Snapshot: snapshot.Bytes(),
1826 }
1827 }
1828
1829 decoder = smithyxml.WrapNodeDecoder(decoder.Decoder, t)
1830 err = awsAwsquery_deserializeDocumentSessionDurationEscalationException(&output, decoder)
1831 if err != nil {
1832 var snapshot bytes.Buffer
1833 io.Copy(&snapshot, ringBuffer)
1834 return &smithy.DeserializationError{
1835 Err: fmt.Errorf("failed to decode response body, %w", err),
1836 Snapshot: snapshot.Bytes(),
1837 }
1838 }
1839
1840 return output
1841 }
1842
1843 func awsAwsquery_deserializeDocumentAssumedRoleUser(v **types.AssumedRoleUser, decoder smithyxml.NodeDecoder) error {
1844 if v == nil {
1845 return fmt.Errorf("unexpected nil of type %T", v)
1846 }
1847 var sv *types.AssumedRoleUser
1848 if *v == nil {
1849 sv = &types.AssumedRoleUser{}
1850 } else {
1851 sv = *v
1852 }
1853
1854 for {
1855 t, done, err := decoder.Token()
1856 if err != nil {
1857 return err
1858 }
1859 if done {
1860 break
1861 }
1862 originalDecoder := decoder
1863 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
1864 switch {
1865 case strings.EqualFold("Arn", t.Name.Local):
1866 val, err := decoder.Value()
1867 if err != nil {
1868 return err
1869 }
1870 if val == nil {
1871 break
1872 }
1873 {
1874 xtv := string(val)
1875 sv.Arn = ptr.String(xtv)
1876 }
1877
1878 case strings.EqualFold("AssumedRoleId", t.Name.Local):
1879 val, err := decoder.Value()
1880 if err != nil {
1881 return err
1882 }
1883 if val == nil {
1884 break
1885 }
1886 {
1887 xtv := string(val)
1888 sv.AssumedRoleId = ptr.String(xtv)
1889 }
1890
1891 default:
1892 // Do nothing and ignore the unexpected tag element
1893 err = decoder.Decoder.Skip()
1894 if err != nil {
1895 return err
1896 }
1897
1898 }
1899 decoder = originalDecoder
1900 }
1901 *v = sv
1902 return nil
1903 }
1904
1905 func awsAwsquery_deserializeDocumentCredentials(v **types.Credentials, decoder smithyxml.NodeDecoder) error {
1906 if v == nil {
1907 return fmt.Errorf("unexpected nil of type %T", v)
1908 }
1909 var sv *types.Credentials
1910 if *v == nil {
1911 sv = &types.Credentials{}
1912 } else {
1913 sv = *v
1914 }
1915
1916 for {
1917 t, done, err := decoder.Token()
1918 if err != nil {
1919 return err
1920 }
1921 if done {
1922 break
1923 }
1924 originalDecoder := decoder
1925 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
1926 switch {
1927 case strings.EqualFold("AccessKeyId", t.Name.Local):
1928 val, err := decoder.Value()
1929 if err != nil {
1930 return err
1931 }
1932 if val == nil {
1933 break
1934 }
1935 {
1936 xtv := string(val)
1937 sv.AccessKeyId = ptr.String(xtv)
1938 }
1939
1940 case strings.EqualFold("Expiration", t.Name.Local):
1941 val, err := decoder.Value()
1942 if err != nil {
1943 return err
1944 }
1945 if val == nil {
1946 break
1947 }
1948 {
1949 xtv := string(val)
1950 t, err := smithytime.ParseDateTime(xtv)
1951 if err != nil {
1952 return err
1953 }
1954 sv.Expiration = ptr.Time(t)
1955 }
1956
1957 case strings.EqualFold("SecretAccessKey", t.Name.Local):
1958 val, err := decoder.Value()
1959 if err != nil {
1960 return err
1961 }
1962 if val == nil {
1963 break
1964 }
1965 {
1966 xtv := string(val)
1967 sv.SecretAccessKey = ptr.String(xtv)
1968 }
1969
1970 case strings.EqualFold("SessionToken", t.Name.Local):
1971 val, err := decoder.Value()
1972 if err != nil {
1973 return err
1974 }
1975 if val == nil {
1976 break
1977 }
1978 {
1979 xtv := string(val)
1980 sv.SessionToken = ptr.String(xtv)
1981 }
1982
1983 default:
1984 // Do nothing and ignore the unexpected tag element
1985 err = decoder.Decoder.Skip()
1986 if err != nil {
1987 return err
1988 }
1989
1990 }
1991 decoder = originalDecoder
1992 }
1993 *v = sv
1994 return nil
1995 }
1996
1997 func awsAwsquery_deserializeDocumentExpiredTokenException(v **types.ExpiredTokenException, decoder smithyxml.NodeDecoder) error {
1998 if v == nil {
1999 return fmt.Errorf("unexpected nil of type %T", v)
2000 }
2001 var sv *types.ExpiredTokenException
2002 if *v == nil {
2003 sv = &types.ExpiredTokenException{}
2004 } else {
2005 sv = *v
2006 }
2007
2008 for {
2009 t, done, err := decoder.Token()
2010 if err != nil {
2011 return err
2012 }
2013 if done {
2014 break
2015 }
2016 originalDecoder := decoder
2017 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
2018 switch {
2019 case strings.EqualFold("message", t.Name.Local):
2020 val, err := decoder.Value()
2021 if err != nil {
2022 return err
2023 }
2024 if val == nil {
2025 break
2026 }
2027 {
2028 xtv := string(val)
2029 sv.Message = ptr.String(xtv)
2030 }
2031
2032 default:
2033 // Do nothing and ignore the unexpected tag element
2034 err = decoder.Decoder.Skip()
2035 if err != nil {
2036 return err
2037 }
2038
2039 }
2040 decoder = originalDecoder
2041 }
2042 *v = sv
2043 return nil
2044 }
2045
2046 func awsAwsquery_deserializeDocumentExpiredTradeInTokenException(v **types.ExpiredTradeInTokenException, decoder smithyxml.NodeDecoder) error {
2047 if v == nil {
2048 return fmt.Errorf("unexpected nil of type %T", v)
2049 }
2050 var sv *types.ExpiredTradeInTokenException
2051 if *v == nil {
2052 sv = &types.ExpiredTradeInTokenException{}
2053 } else {
2054 sv = *v
2055 }
2056
2057 for {
2058 t, done, err := decoder.Token()
2059 if err != nil {
2060 return err
2061 }
2062 if done {
2063 break
2064 }
2065 originalDecoder := decoder
2066 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
2067 switch {
2068 case strings.EqualFold("message", t.Name.Local):
2069 val, err := decoder.Value()
2070 if err != nil {
2071 return err
2072 }
2073 if val == nil {
2074 break
2075 }
2076 {
2077 xtv := string(val)
2078 sv.Message = ptr.String(xtv)
2079 }
2080
2081 default:
2082 // Do nothing and ignore the unexpected tag element
2083 err = decoder.Decoder.Skip()
2084 if err != nil {
2085 return err
2086 }
2087
2088 }
2089 decoder = originalDecoder
2090 }
2091 *v = sv
2092 return nil
2093 }
2094
2095 func awsAwsquery_deserializeDocumentFederatedUser(v **types.FederatedUser, decoder smithyxml.NodeDecoder) error {
2096 if v == nil {
2097 return fmt.Errorf("unexpected nil of type %T", v)
2098 }
2099 var sv *types.FederatedUser
2100 if *v == nil {
2101 sv = &types.FederatedUser{}
2102 } else {
2103 sv = *v
2104 }
2105
2106 for {
2107 t, done, err := decoder.Token()
2108 if err != nil {
2109 return err
2110 }
2111 if done {
2112 break
2113 }
2114 originalDecoder := decoder
2115 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
2116 switch {
2117 case strings.EqualFold("Arn", t.Name.Local):
2118 val, err := decoder.Value()
2119 if err != nil {
2120 return err
2121 }
2122 if val == nil {
2123 break
2124 }
2125 {
2126 xtv := string(val)
2127 sv.Arn = ptr.String(xtv)
2128 }
2129
2130 case strings.EqualFold("FederatedUserId", t.Name.Local):
2131 val, err := decoder.Value()
2132 if err != nil {
2133 return err
2134 }
2135 if val == nil {
2136 break
2137 }
2138 {
2139 xtv := string(val)
2140 sv.FederatedUserId = ptr.String(xtv)
2141 }
2142
2143 default:
2144 // Do nothing and ignore the unexpected tag element
2145 err = decoder.Decoder.Skip()
2146 if err != nil {
2147 return err
2148 }
2149
2150 }
2151 decoder = originalDecoder
2152 }
2153 *v = sv
2154 return nil
2155 }
2156
2157 func awsAwsquery_deserializeDocumentIDPCommunicationErrorException(v **types.IDPCommunicationErrorException, decoder smithyxml.NodeDecoder) error {
2158 if v == nil {
2159 return fmt.Errorf("unexpected nil of type %T", v)
2160 }
2161 var sv *types.IDPCommunicationErrorException
2162 if *v == nil {
2163 sv = &types.IDPCommunicationErrorException{}
2164 } else {
2165 sv = *v
2166 }
2167
2168 for {
2169 t, done, err := decoder.Token()
2170 if err != nil {
2171 return err
2172 }
2173 if done {
2174 break
2175 }
2176 originalDecoder := decoder
2177 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
2178 switch {
2179 case strings.EqualFold("message", t.Name.Local):
2180 val, err := decoder.Value()
2181 if err != nil {
2182 return err
2183 }
2184 if val == nil {
2185 break
2186 }
2187 {
2188 xtv := string(val)
2189 sv.Message = ptr.String(xtv)
2190 }
2191
2192 default:
2193 // Do nothing and ignore the unexpected tag element
2194 err = decoder.Decoder.Skip()
2195 if err != nil {
2196 return err
2197 }
2198
2199 }
2200 decoder = originalDecoder
2201 }
2202 *v = sv
2203 return nil
2204 }
2205
2206 func awsAwsquery_deserializeDocumentIDPRejectedClaimException(v **types.IDPRejectedClaimException, decoder smithyxml.NodeDecoder) error {
2207 if v == nil {
2208 return fmt.Errorf("unexpected nil of type %T", v)
2209 }
2210 var sv *types.IDPRejectedClaimException
2211 if *v == nil {
2212 sv = &types.IDPRejectedClaimException{}
2213 } else {
2214 sv = *v
2215 }
2216
2217 for {
2218 t, done, err := decoder.Token()
2219 if err != nil {
2220 return err
2221 }
2222 if done {
2223 break
2224 }
2225 originalDecoder := decoder
2226 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
2227 switch {
2228 case strings.EqualFold("message", t.Name.Local):
2229 val, err := decoder.Value()
2230 if err != nil {
2231 return err
2232 }
2233 if val == nil {
2234 break
2235 }
2236 {
2237 xtv := string(val)
2238 sv.Message = ptr.String(xtv)
2239 }
2240
2241 default:
2242 // Do nothing and ignore the unexpected tag element
2243 err = decoder.Decoder.Skip()
2244 if err != nil {
2245 return err
2246 }
2247
2248 }
2249 decoder = originalDecoder
2250 }
2251 *v = sv
2252 return nil
2253 }
2254
2255 func awsAwsquery_deserializeDocumentInvalidAuthorizationMessageException(v **types.InvalidAuthorizationMessageException, decoder smithyxml.NodeDecoder) error {
2256 if v == nil {
2257 return fmt.Errorf("unexpected nil of type %T", v)
2258 }
2259 var sv *types.InvalidAuthorizationMessageException
2260 if *v == nil {
2261 sv = &types.InvalidAuthorizationMessageException{}
2262 } else {
2263 sv = *v
2264 }
2265
2266 for {
2267 t, done, err := decoder.Token()
2268 if err != nil {
2269 return err
2270 }
2271 if done {
2272 break
2273 }
2274 originalDecoder := decoder
2275 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
2276 switch {
2277 case strings.EqualFold("message", t.Name.Local):
2278 val, err := decoder.Value()
2279 if err != nil {
2280 return err
2281 }
2282 if val == nil {
2283 break
2284 }
2285 {
2286 xtv := string(val)
2287 sv.Message = ptr.String(xtv)
2288 }
2289
2290 default:
2291 // Do nothing and ignore the unexpected tag element
2292 err = decoder.Decoder.Skip()
2293 if err != nil {
2294 return err
2295 }
2296
2297 }
2298 decoder = originalDecoder
2299 }
2300 *v = sv
2301 return nil
2302 }
2303
2304 func awsAwsquery_deserializeDocumentInvalidIdentityTokenException(v **types.InvalidIdentityTokenException, decoder smithyxml.NodeDecoder) error {
2305 if v == nil {
2306 return fmt.Errorf("unexpected nil of type %T", v)
2307 }
2308 var sv *types.InvalidIdentityTokenException
2309 if *v == nil {
2310 sv = &types.InvalidIdentityTokenException{}
2311 } else {
2312 sv = *v
2313 }
2314
2315 for {
2316 t, done, err := decoder.Token()
2317 if err != nil {
2318 return err
2319 }
2320 if done {
2321 break
2322 }
2323 originalDecoder := decoder
2324 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
2325 switch {
2326 case strings.EqualFold("message", t.Name.Local):
2327 val, err := decoder.Value()
2328 if err != nil {
2329 return err
2330 }
2331 if val == nil {
2332 break
2333 }
2334 {
2335 xtv := string(val)
2336 sv.Message = ptr.String(xtv)
2337 }
2338
2339 default:
2340 // Do nothing and ignore the unexpected tag element
2341 err = decoder.Decoder.Skip()
2342 if err != nil {
2343 return err
2344 }
2345
2346 }
2347 decoder = originalDecoder
2348 }
2349 *v = sv
2350 return nil
2351 }
2352
2353 func awsAwsquery_deserializeDocumentJWTPayloadSizeExceededException(v **types.JWTPayloadSizeExceededException, decoder smithyxml.NodeDecoder) error {
2354 if v == nil {
2355 return fmt.Errorf("unexpected nil of type %T", v)
2356 }
2357 var sv *types.JWTPayloadSizeExceededException
2358 if *v == nil {
2359 sv = &types.JWTPayloadSizeExceededException{}
2360 } else {
2361 sv = *v
2362 }
2363
2364 for {
2365 t, done, err := decoder.Token()
2366 if err != nil {
2367 return err
2368 }
2369 if done {
2370 break
2371 }
2372 originalDecoder := decoder
2373 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
2374 switch {
2375 case strings.EqualFold("message", t.Name.Local):
2376 val, err := decoder.Value()
2377 if err != nil {
2378 return err
2379 }
2380 if val == nil {
2381 break
2382 }
2383 {
2384 xtv := string(val)
2385 sv.Message = ptr.String(xtv)
2386 }
2387
2388 default:
2389 // Do nothing and ignore the unexpected tag element
2390 err = decoder.Decoder.Skip()
2391 if err != nil {
2392 return err
2393 }
2394
2395 }
2396 decoder = originalDecoder
2397 }
2398 *v = sv
2399 return nil
2400 }
2401
2402 func awsAwsquery_deserializeDocumentMalformedPolicyDocumentException(v **types.MalformedPolicyDocumentException, decoder smithyxml.NodeDecoder) error {
2403 if v == nil {
2404 return fmt.Errorf("unexpected nil of type %T", v)
2405 }
2406 var sv *types.MalformedPolicyDocumentException
2407 if *v == nil {
2408 sv = &types.MalformedPolicyDocumentException{}
2409 } else {
2410 sv = *v
2411 }
2412
2413 for {
2414 t, done, err := decoder.Token()
2415 if err != nil {
2416 return err
2417 }
2418 if done {
2419 break
2420 }
2421 originalDecoder := decoder
2422 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
2423 switch {
2424 case strings.EqualFold("message", t.Name.Local):
2425 val, err := decoder.Value()
2426 if err != nil {
2427 return err
2428 }
2429 if val == nil {
2430 break
2431 }
2432 {
2433 xtv := string(val)
2434 sv.Message = ptr.String(xtv)
2435 }
2436
2437 default:
2438 // Do nothing and ignore the unexpected tag element
2439 err = decoder.Decoder.Skip()
2440 if err != nil {
2441 return err
2442 }
2443
2444 }
2445 decoder = originalDecoder
2446 }
2447 *v = sv
2448 return nil
2449 }
2450
2451 func awsAwsquery_deserializeDocumentOutboundWebIdentityFederationDisabledException(v **types.OutboundWebIdentityFederationDisabledException, decoder smithyxml.NodeDecoder) error {
2452 if v == nil {
2453 return fmt.Errorf("unexpected nil of type %T", v)
2454 }
2455 var sv *types.OutboundWebIdentityFederationDisabledException
2456 if *v == nil {
2457 sv = &types.OutboundWebIdentityFederationDisabledException{}
2458 } else {
2459 sv = *v
2460 }
2461
2462 for {
2463 t, done, err := decoder.Token()
2464 if err != nil {
2465 return err
2466 }
2467 if done {
2468 break
2469 }
2470 originalDecoder := decoder
2471 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
2472 switch {
2473 case strings.EqualFold("message", t.Name.Local):
2474 val, err := decoder.Value()
2475 if err != nil {
2476 return err
2477 }
2478 if val == nil {
2479 break
2480 }
2481 {
2482 xtv := string(val)
2483 sv.Message = ptr.String(xtv)
2484 }
2485
2486 default:
2487 // Do nothing and ignore the unexpected tag element
2488 err = decoder.Decoder.Skip()
2489 if err != nil {
2490 return err
2491 }
2492
2493 }
2494 decoder = originalDecoder
2495 }
2496 *v = sv
2497 return nil
2498 }
2499
2500 func awsAwsquery_deserializeDocumentPackedPolicyTooLargeException(v **types.PackedPolicyTooLargeException, decoder smithyxml.NodeDecoder) error {
2501 if v == nil {
2502 return fmt.Errorf("unexpected nil of type %T", v)
2503 }
2504 var sv *types.PackedPolicyTooLargeException
2505 if *v == nil {
2506 sv = &types.PackedPolicyTooLargeException{}
2507 } else {
2508 sv = *v
2509 }
2510
2511 for {
2512 t, done, err := decoder.Token()
2513 if err != nil {
2514 return err
2515 }
2516 if done {
2517 break
2518 }
2519 originalDecoder := decoder
2520 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
2521 switch {
2522 case strings.EqualFold("message", t.Name.Local):
2523 val, err := decoder.Value()
2524 if err != nil {
2525 return err
2526 }
2527 if val == nil {
2528 break
2529 }
2530 {
2531 xtv := string(val)
2532 sv.Message = ptr.String(xtv)
2533 }
2534
2535 default:
2536 // Do nothing and ignore the unexpected tag element
2537 err = decoder.Decoder.Skip()
2538 if err != nil {
2539 return err
2540 }
2541
2542 }
2543 decoder = originalDecoder
2544 }
2545 *v = sv
2546 return nil
2547 }
2548
2549 func awsAwsquery_deserializeDocumentRegionDisabledException(v **types.RegionDisabledException, decoder smithyxml.NodeDecoder) error {
2550 if v == nil {
2551 return fmt.Errorf("unexpected nil of type %T", v)
2552 }
2553 var sv *types.RegionDisabledException
2554 if *v == nil {
2555 sv = &types.RegionDisabledException{}
2556 } else {
2557 sv = *v
2558 }
2559
2560 for {
2561 t, done, err := decoder.Token()
2562 if err != nil {
2563 return err
2564 }
2565 if done {
2566 break
2567 }
2568 originalDecoder := decoder
2569 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
2570 switch {
2571 case strings.EqualFold("message", t.Name.Local):
2572 val, err := decoder.Value()
2573 if err != nil {
2574 return err
2575 }
2576 if val == nil {
2577 break
2578 }
2579 {
2580 xtv := string(val)
2581 sv.Message = ptr.String(xtv)
2582 }
2583
2584 default:
2585 // Do nothing and ignore the unexpected tag element
2586 err = decoder.Decoder.Skip()
2587 if err != nil {
2588 return err
2589 }
2590
2591 }
2592 decoder = originalDecoder
2593 }
2594 *v = sv
2595 return nil
2596 }
2597
2598 func awsAwsquery_deserializeDocumentSessionDurationEscalationException(v **types.SessionDurationEscalationException, decoder smithyxml.NodeDecoder) error {
2599 if v == nil {
2600 return fmt.Errorf("unexpected nil of type %T", v)
2601 }
2602 var sv *types.SessionDurationEscalationException
2603 if *v == nil {
2604 sv = &types.SessionDurationEscalationException{}
2605 } else {
2606 sv = *v
2607 }
2608
2609 for {
2610 t, done, err := decoder.Token()
2611 if err != nil {
2612 return err
2613 }
2614 if done {
2615 break
2616 }
2617 originalDecoder := decoder
2618 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
2619 switch {
2620 case strings.EqualFold("message", t.Name.Local):
2621 val, err := decoder.Value()
2622 if err != nil {
2623 return err
2624 }
2625 if val == nil {
2626 break
2627 }
2628 {
2629 xtv := string(val)
2630 sv.Message = ptr.String(xtv)
2631 }
2632
2633 default:
2634 // Do nothing and ignore the unexpected tag element
2635 err = decoder.Decoder.Skip()
2636 if err != nil {
2637 return err
2638 }
2639
2640 }
2641 decoder = originalDecoder
2642 }
2643 *v = sv
2644 return nil
2645 }
2646
2647 func awsAwsquery_deserializeOpDocumentAssumeRoleOutput(v **AssumeRoleOutput, decoder smithyxml.NodeDecoder) error {
2648 if v == nil {
2649 return fmt.Errorf("unexpected nil of type %T", v)
2650 }
2651 var sv *AssumeRoleOutput
2652 if *v == nil {
2653 sv = &AssumeRoleOutput{}
2654 } else {
2655 sv = *v
2656 }
2657
2658 for {
2659 t, done, err := decoder.Token()
2660 if err != nil {
2661 return err
2662 }
2663 if done {
2664 break
2665 }
2666 originalDecoder := decoder
2667 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
2668 switch {
2669 case strings.EqualFold("AssumedRoleUser", t.Name.Local):
2670 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
2671 if err := awsAwsquery_deserializeDocumentAssumedRoleUser(&sv.AssumedRoleUser, nodeDecoder); err != nil {
2672 return err
2673 }
2674
2675 case strings.EqualFold("Credentials", t.Name.Local):
2676 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
2677 if err := awsAwsquery_deserializeDocumentCredentials(&sv.Credentials, nodeDecoder); err != nil {
2678 return err
2679 }
2680
2681 case strings.EqualFold("PackedPolicySize", t.Name.Local):
2682 val, err := decoder.Value()
2683 if err != nil {
2684 return err
2685 }
2686 if val == nil {
2687 break
2688 }
2689 {
2690 xtv := string(val)
2691 i64, err := strconv.ParseInt(xtv, 10, 64)
2692 if err != nil {
2693 return err
2694 }
2695 sv.PackedPolicySize = ptr.Int32(int32(i64))
2696 }
2697
2698 case strings.EqualFold("SourceIdentity", t.Name.Local):
2699 val, err := decoder.Value()
2700 if err != nil {
2701 return err
2702 }
2703 if val == nil {
2704 break
2705 }
2706 {
2707 xtv := string(val)
2708 sv.SourceIdentity = ptr.String(xtv)
2709 }
2710
2711 default:
2712 // Do nothing and ignore the unexpected tag element
2713 err = decoder.Decoder.Skip()
2714 if err != nil {
2715 return err
2716 }
2717
2718 }
2719 decoder = originalDecoder
2720 }
2721 *v = sv
2722 return nil
2723 }
2724
2725 func awsAwsquery_deserializeOpDocumentAssumeRoleWithSAMLOutput(v **AssumeRoleWithSAMLOutput, decoder smithyxml.NodeDecoder) error {
2726 if v == nil {
2727 return fmt.Errorf("unexpected nil of type %T", v)
2728 }
2729 var sv *AssumeRoleWithSAMLOutput
2730 if *v == nil {
2731 sv = &AssumeRoleWithSAMLOutput{}
2732 } else {
2733 sv = *v
2734 }
2735
2736 for {
2737 t, done, err := decoder.Token()
2738 if err != nil {
2739 return err
2740 }
2741 if done {
2742 break
2743 }
2744 originalDecoder := decoder
2745 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
2746 switch {
2747 case strings.EqualFold("AssumedRoleUser", t.Name.Local):
2748 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
2749 if err := awsAwsquery_deserializeDocumentAssumedRoleUser(&sv.AssumedRoleUser, nodeDecoder); err != nil {
2750 return err
2751 }
2752
2753 case strings.EqualFold("Audience", t.Name.Local):
2754 val, err := decoder.Value()
2755 if err != nil {
2756 return err
2757 }
2758 if val == nil {
2759 break
2760 }
2761 {
2762 xtv := string(val)
2763 sv.Audience = ptr.String(xtv)
2764 }
2765
2766 case strings.EqualFold("Credentials", t.Name.Local):
2767 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
2768 if err := awsAwsquery_deserializeDocumentCredentials(&sv.Credentials, nodeDecoder); err != nil {
2769 return err
2770 }
2771
2772 case strings.EqualFold("Issuer", t.Name.Local):
2773 val, err := decoder.Value()
2774 if err != nil {
2775 return err
2776 }
2777 if val == nil {
2778 break
2779 }
2780 {
2781 xtv := string(val)
2782 sv.Issuer = ptr.String(xtv)
2783 }
2784
2785 case strings.EqualFold("NameQualifier", t.Name.Local):
2786 val, err := decoder.Value()
2787 if err != nil {
2788 return err
2789 }
2790 if val == nil {
2791 break
2792 }
2793 {
2794 xtv := string(val)
2795 sv.NameQualifier = ptr.String(xtv)
2796 }
2797
2798 case strings.EqualFold("PackedPolicySize", t.Name.Local):
2799 val, err := decoder.Value()
2800 if err != nil {
2801 return err
2802 }
2803 if val == nil {
2804 break
2805 }
2806 {
2807 xtv := string(val)
2808 i64, err := strconv.ParseInt(xtv, 10, 64)
2809 if err != nil {
2810 return err
2811 }
2812 sv.PackedPolicySize = ptr.Int32(int32(i64))
2813 }
2814
2815 case strings.EqualFold("SourceIdentity", t.Name.Local):
2816 val, err := decoder.Value()
2817 if err != nil {
2818 return err
2819 }
2820 if val == nil {
2821 break
2822 }
2823 {
2824 xtv := string(val)
2825 sv.SourceIdentity = ptr.String(xtv)
2826 }
2827
2828 case strings.EqualFold("Subject", t.Name.Local):
2829 val, err := decoder.Value()
2830 if err != nil {
2831 return err
2832 }
2833 if val == nil {
2834 break
2835 }
2836 {
2837 xtv := string(val)
2838 sv.Subject = ptr.String(xtv)
2839 }
2840
2841 case strings.EqualFold("SubjectType", t.Name.Local):
2842 val, err := decoder.Value()
2843 if err != nil {
2844 return err
2845 }
2846 if val == nil {
2847 break
2848 }
2849 {
2850 xtv := string(val)
2851 sv.SubjectType = ptr.String(xtv)
2852 }
2853
2854 default:
2855 // Do nothing and ignore the unexpected tag element
2856 err = decoder.Decoder.Skip()
2857 if err != nil {
2858 return err
2859 }
2860
2861 }
2862 decoder = originalDecoder
2863 }
2864 *v = sv
2865 return nil
2866 }
2867
2868 func awsAwsquery_deserializeOpDocumentAssumeRoleWithWebIdentityOutput(v **AssumeRoleWithWebIdentityOutput, decoder smithyxml.NodeDecoder) error {
2869 if v == nil {
2870 return fmt.Errorf("unexpected nil of type %T", v)
2871 }
2872 var sv *AssumeRoleWithWebIdentityOutput
2873 if *v == nil {
2874 sv = &AssumeRoleWithWebIdentityOutput{}
2875 } else {
2876 sv = *v
2877 }
2878
2879 for {
2880 t, done, err := decoder.Token()
2881 if err != nil {
2882 return err
2883 }
2884 if done {
2885 break
2886 }
2887 originalDecoder := decoder
2888 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
2889 switch {
2890 case strings.EqualFold("AssumedRoleUser", t.Name.Local):
2891 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
2892 if err := awsAwsquery_deserializeDocumentAssumedRoleUser(&sv.AssumedRoleUser, nodeDecoder); err != nil {
2893 return err
2894 }
2895
2896 case strings.EqualFold("Audience", t.Name.Local):
2897 val, err := decoder.Value()
2898 if err != nil {
2899 return err
2900 }
2901 if val == nil {
2902 break
2903 }
2904 {
2905 xtv := string(val)
2906 sv.Audience = ptr.String(xtv)
2907 }
2908
2909 case strings.EqualFold("Credentials", t.Name.Local):
2910 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
2911 if err := awsAwsquery_deserializeDocumentCredentials(&sv.Credentials, nodeDecoder); err != nil {
2912 return err
2913 }
2914
2915 case strings.EqualFold("PackedPolicySize", t.Name.Local):
2916 val, err := decoder.Value()
2917 if err != nil {
2918 return err
2919 }
2920 if val == nil {
2921 break
2922 }
2923 {
2924 xtv := string(val)
2925 i64, err := strconv.ParseInt(xtv, 10, 64)
2926 if err != nil {
2927 return err
2928 }
2929 sv.PackedPolicySize = ptr.Int32(int32(i64))
2930 }
2931
2932 case strings.EqualFold("Provider", t.Name.Local):
2933 val, err := decoder.Value()
2934 if err != nil {
2935 return err
2936 }
2937 if val == nil {
2938 break
2939 }
2940 {
2941 xtv := string(val)
2942 sv.Provider = ptr.String(xtv)
2943 }
2944
2945 case strings.EqualFold("SourceIdentity", t.Name.Local):
2946 val, err := decoder.Value()
2947 if err != nil {
2948 return err
2949 }
2950 if val == nil {
2951 break
2952 }
2953 {
2954 xtv := string(val)
2955 sv.SourceIdentity = ptr.String(xtv)
2956 }
2957
2958 case strings.EqualFold("SubjectFromWebIdentityToken", t.Name.Local):
2959 val, err := decoder.Value()
2960 if err != nil {
2961 return err
2962 }
2963 if val == nil {
2964 break
2965 }
2966 {
2967 xtv := string(val)
2968 sv.SubjectFromWebIdentityToken = ptr.String(xtv)
2969 }
2970
2971 default:
2972 // Do nothing and ignore the unexpected tag element
2973 err = decoder.Decoder.Skip()
2974 if err != nil {
2975 return err
2976 }
2977
2978 }
2979 decoder = originalDecoder
2980 }
2981 *v = sv
2982 return nil
2983 }
2984
2985 func awsAwsquery_deserializeOpDocumentAssumeRootOutput(v **AssumeRootOutput, decoder smithyxml.NodeDecoder) error {
2986 if v == nil {
2987 return fmt.Errorf("unexpected nil of type %T", v)
2988 }
2989 var sv *AssumeRootOutput
2990 if *v == nil {
2991 sv = &AssumeRootOutput{}
2992 } else {
2993 sv = *v
2994 }
2995
2996 for {
2997 t, done, err := decoder.Token()
2998 if err != nil {
2999 return err
3000 }
3001 if done {
3002 break
3003 }
3004 originalDecoder := decoder
3005 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
3006 switch {
3007 case strings.EqualFold("Credentials", t.Name.Local):
3008 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
3009 if err := awsAwsquery_deserializeDocumentCredentials(&sv.Credentials, nodeDecoder); err != nil {
3010 return err
3011 }
3012
3013 case strings.EqualFold("SourceIdentity", t.Name.Local):
3014 val, err := decoder.Value()
3015 if err != nil {
3016 return err
3017 }
3018 if val == nil {
3019 break
3020 }
3021 {
3022 xtv := string(val)
3023 sv.SourceIdentity = ptr.String(xtv)
3024 }
3025
3026 default:
3027 // Do nothing and ignore the unexpected tag element
3028 err = decoder.Decoder.Skip()
3029 if err != nil {
3030 return err
3031 }
3032
3033 }
3034 decoder = originalDecoder
3035 }
3036 *v = sv
3037 return nil
3038 }
3039
3040 func awsAwsquery_deserializeOpDocumentDecodeAuthorizationMessageOutput(v **DecodeAuthorizationMessageOutput, decoder smithyxml.NodeDecoder) error {
3041 if v == nil {
3042 return fmt.Errorf("unexpected nil of type %T", v)
3043 }
3044 var sv *DecodeAuthorizationMessageOutput
3045 if *v == nil {
3046 sv = &DecodeAuthorizationMessageOutput{}
3047 } else {
3048 sv = *v
3049 }
3050
3051 for {
3052 t, done, err := decoder.Token()
3053 if err != nil {
3054 return err
3055 }
3056 if done {
3057 break
3058 }
3059 originalDecoder := decoder
3060 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
3061 switch {
3062 case strings.EqualFold("DecodedMessage", t.Name.Local):
3063 val, err := decoder.Value()
3064 if err != nil {
3065 return err
3066 }
3067 if val == nil {
3068 break
3069 }
3070 {
3071 xtv := string(val)
3072 sv.DecodedMessage = ptr.String(xtv)
3073 }
3074
3075 default:
3076 // Do nothing and ignore the unexpected tag element
3077 err = decoder.Decoder.Skip()
3078 if err != nil {
3079 return err
3080 }
3081
3082 }
3083 decoder = originalDecoder
3084 }
3085 *v = sv
3086 return nil
3087 }
3088
3089 func awsAwsquery_deserializeOpDocumentGetAccessKeyInfoOutput(v **GetAccessKeyInfoOutput, decoder smithyxml.NodeDecoder) error {
3090 if v == nil {
3091 return fmt.Errorf("unexpected nil of type %T", v)
3092 }
3093 var sv *GetAccessKeyInfoOutput
3094 if *v == nil {
3095 sv = &GetAccessKeyInfoOutput{}
3096 } else {
3097 sv = *v
3098 }
3099
3100 for {
3101 t, done, err := decoder.Token()
3102 if err != nil {
3103 return err
3104 }
3105 if done {
3106 break
3107 }
3108 originalDecoder := decoder
3109 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
3110 switch {
3111 case strings.EqualFold("Account", t.Name.Local):
3112 val, err := decoder.Value()
3113 if err != nil {
3114 return err
3115 }
3116 if val == nil {
3117 break
3118 }
3119 {
3120 xtv := string(val)
3121 sv.Account = ptr.String(xtv)
3122 }
3123
3124 default:
3125 // Do nothing and ignore the unexpected tag element
3126 err = decoder.Decoder.Skip()
3127 if err != nil {
3128 return err
3129 }
3130
3131 }
3132 decoder = originalDecoder
3133 }
3134 *v = sv
3135 return nil
3136 }
3137
3138 func awsAwsquery_deserializeOpDocumentGetCallerIdentityOutput(v **GetCallerIdentityOutput, decoder smithyxml.NodeDecoder) error {
3139 if v == nil {
3140 return fmt.Errorf("unexpected nil of type %T", v)
3141 }
3142 var sv *GetCallerIdentityOutput
3143 if *v == nil {
3144 sv = &GetCallerIdentityOutput{}
3145 } else {
3146 sv = *v
3147 }
3148
3149 for {
3150 t, done, err := decoder.Token()
3151 if err != nil {
3152 return err
3153 }
3154 if done {
3155 break
3156 }
3157 originalDecoder := decoder
3158 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
3159 switch {
3160 case strings.EqualFold("Account", t.Name.Local):
3161 val, err := decoder.Value()
3162 if err != nil {
3163 return err
3164 }
3165 if val == nil {
3166 break
3167 }
3168 {
3169 xtv := string(val)
3170 sv.Account = ptr.String(xtv)
3171 }
3172
3173 case strings.EqualFold("Arn", t.Name.Local):
3174 val, err := decoder.Value()
3175 if err != nil {
3176 return err
3177 }
3178 if val == nil {
3179 break
3180 }
3181 {
3182 xtv := string(val)
3183 sv.Arn = ptr.String(xtv)
3184 }
3185
3186 case strings.EqualFold("UserId", t.Name.Local):
3187 val, err := decoder.Value()
3188 if err != nil {
3189 return err
3190 }
3191 if val == nil {
3192 break
3193 }
3194 {
3195 xtv := string(val)
3196 sv.UserId = ptr.String(xtv)
3197 }
3198
3199 default:
3200 // Do nothing and ignore the unexpected tag element
3201 err = decoder.Decoder.Skip()
3202 if err != nil {
3203 return err
3204 }
3205
3206 }
3207 decoder = originalDecoder
3208 }
3209 *v = sv
3210 return nil
3211 }
3212
3213 func awsAwsquery_deserializeOpDocumentGetDelegatedAccessTokenOutput(v **GetDelegatedAccessTokenOutput, decoder smithyxml.NodeDecoder) error {
3214 if v == nil {
3215 return fmt.Errorf("unexpected nil of type %T", v)
3216 }
3217 var sv *GetDelegatedAccessTokenOutput
3218 if *v == nil {
3219 sv = &GetDelegatedAccessTokenOutput{}
3220 } else {
3221 sv = *v
3222 }
3223
3224 for {
3225 t, done, err := decoder.Token()
3226 if err != nil {
3227 return err
3228 }
3229 if done {
3230 break
3231 }
3232 originalDecoder := decoder
3233 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
3234 switch {
3235 case strings.EqualFold("AssumedPrincipal", t.Name.Local):
3236 val, err := decoder.Value()
3237 if err != nil {
3238 return err
3239 }
3240 if val == nil {
3241 break
3242 }
3243 {
3244 xtv := string(val)
3245 sv.AssumedPrincipal = ptr.String(xtv)
3246 }
3247
3248 case strings.EqualFold("Credentials", t.Name.Local):
3249 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
3250 if err := awsAwsquery_deserializeDocumentCredentials(&sv.Credentials, nodeDecoder); err != nil {
3251 return err
3252 }
3253
3254 case strings.EqualFold("PackedPolicySize", t.Name.Local):
3255 val, err := decoder.Value()
3256 if err != nil {
3257 return err
3258 }
3259 if val == nil {
3260 break
3261 }
3262 {
3263 xtv := string(val)
3264 i64, err := strconv.ParseInt(xtv, 10, 64)
3265 if err != nil {
3266 return err
3267 }
3268 sv.PackedPolicySize = ptr.Int32(int32(i64))
3269 }
3270
3271 default:
3272 // Do nothing and ignore the unexpected tag element
3273 err = decoder.Decoder.Skip()
3274 if err != nil {
3275 return err
3276 }
3277
3278 }
3279 decoder = originalDecoder
3280 }
3281 *v = sv
3282 return nil
3283 }
3284
3285 func awsAwsquery_deserializeOpDocumentGetFederationTokenOutput(v **GetFederationTokenOutput, decoder smithyxml.NodeDecoder) error {
3286 if v == nil {
3287 return fmt.Errorf("unexpected nil of type %T", v)
3288 }
3289 var sv *GetFederationTokenOutput
3290 if *v == nil {
3291 sv = &GetFederationTokenOutput{}
3292 } else {
3293 sv = *v
3294 }
3295
3296 for {
3297 t, done, err := decoder.Token()
3298 if err != nil {
3299 return err
3300 }
3301 if done {
3302 break
3303 }
3304 originalDecoder := decoder
3305 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
3306 switch {
3307 case strings.EqualFold("Credentials", t.Name.Local):
3308 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
3309 if err := awsAwsquery_deserializeDocumentCredentials(&sv.Credentials, nodeDecoder); err != nil {
3310 return err
3311 }
3312
3313 case strings.EqualFold("FederatedUser", t.Name.Local):
3314 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
3315 if err := awsAwsquery_deserializeDocumentFederatedUser(&sv.FederatedUser, nodeDecoder); err != nil {
3316 return err
3317 }
3318
3319 case strings.EqualFold("PackedPolicySize", t.Name.Local):
3320 val, err := decoder.Value()
3321 if err != nil {
3322 return err
3323 }
3324 if val == nil {
3325 break
3326 }
3327 {
3328 xtv := string(val)
3329 i64, err := strconv.ParseInt(xtv, 10, 64)
3330 if err != nil {
3331 return err
3332 }
3333 sv.PackedPolicySize = ptr.Int32(int32(i64))
3334 }
3335
3336 default:
3337 // Do nothing and ignore the unexpected tag element
3338 err = decoder.Decoder.Skip()
3339 if err != nil {
3340 return err
3341 }
3342
3343 }
3344 decoder = originalDecoder
3345 }
3346 *v = sv
3347 return nil
3348 }
3349
3350 func awsAwsquery_deserializeOpDocumentGetSessionTokenOutput(v **GetSessionTokenOutput, decoder smithyxml.NodeDecoder) error {
3351 if v == nil {
3352 return fmt.Errorf("unexpected nil of type %T", v)
3353 }
3354 var sv *GetSessionTokenOutput
3355 if *v == nil {
3356 sv = &GetSessionTokenOutput{}
3357 } else {
3358 sv = *v
3359 }
3360
3361 for {
3362 t, done, err := decoder.Token()
3363 if err != nil {
3364 return err
3365 }
3366 if done {
3367 break
3368 }
3369 originalDecoder := decoder
3370 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
3371 switch {
3372 case strings.EqualFold("Credentials", t.Name.Local):
3373 nodeDecoder := smithyxml.WrapNodeDecoder(decoder.Decoder, t)
3374 if err := awsAwsquery_deserializeDocumentCredentials(&sv.Credentials, nodeDecoder); err != nil {
3375 return err
3376 }
3377
3378 default:
3379 // Do nothing and ignore the unexpected tag element
3380 err = decoder.Decoder.Skip()
3381 if err != nil {
3382 return err
3383 }
3384
3385 }
3386 decoder = originalDecoder
3387 }
3388 *v = sv
3389 return nil
3390 }
3391
3392 func awsAwsquery_deserializeOpDocumentGetWebIdentityTokenOutput(v **GetWebIdentityTokenOutput, decoder smithyxml.NodeDecoder) error {
3393 if v == nil {
3394 return fmt.Errorf("unexpected nil of type %T", v)
3395 }
3396 var sv *GetWebIdentityTokenOutput
3397 if *v == nil {
3398 sv = &GetWebIdentityTokenOutput{}
3399 } else {
3400 sv = *v
3401 }
3402
3403 for {
3404 t, done, err := decoder.Token()
3405 if err != nil {
3406 return err
3407 }
3408 if done {
3409 break
3410 }
3411 originalDecoder := decoder
3412 decoder = smithyxml.WrapNodeDecoder(originalDecoder.Decoder, t)
3413 switch {
3414 case strings.EqualFold("Expiration", t.Name.Local):
3415 val, err := decoder.Value()
3416 if err != nil {
3417 return err
3418 }
3419 if val == nil {
3420 break
3421 }
3422 {
3423 xtv := string(val)
3424 t, err := smithytime.ParseDateTime(xtv)
3425 if err != nil {
3426 return err
3427 }
3428 sv.Expiration = ptr.Time(t)
3429 }
3430
3431 case strings.EqualFold("WebIdentityToken", t.Name.Local):
3432 val, err := decoder.Value()
3433 if err != nil {
3434 return err
3435 }
3436 if val == nil {
3437 break
3438 }
3439 {
3440 xtv := string(val)
3441 sv.WebIdentityToken = ptr.String(xtv)
3442 }
3443
3444 default:
3445 // Do nothing and ignore the unexpected tag element
3446 err = decoder.Decoder.Skip()
3447 if err != nil {
3448 return err
3449 }
3450
3451 }
3452 decoder = originalDecoder
3453 }
3454 *v = sv
3455 return nil
3456 }
3457