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