src

Go monorepo.
git clone git://code.dwrz.net/src
Log | Files | Refs

deserializers.go (91761B)

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