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