src

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

deserializers.go (70920B)

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