src

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

deserializers.go (30392B)

      1 // Code generated by smithy-go-codegen DO NOT EDIT.
      2 
      3 package sso
      4 
      5 import (
      6 	"bytes"
      7 	"context"
      8 	"encoding/json"
      9 	"fmt"
     10 	"io"
     11 	"strings"
     12 
     13 	"github.com/aws/aws-sdk-go-v2/aws/protocol/restjson"
     14 	"github.com/aws/aws-sdk-go-v2/service/sso/types"
     15 	smithy "github.com/aws/smithy-go"
     16 	smithyio "github.com/aws/smithy-go/io"
     17 	"github.com/aws/smithy-go/middleware"
     18 	"github.com/aws/smithy-go/ptr"
     19 	"github.com/aws/smithy-go/tracing"
     20 	smithyhttp "github.com/aws/smithy-go/transport/http"
     21 )
     22 
     23 type awsRestjson1_deserializeOpGetRoleCredentials struct {
     24 }
     25 
     26 func (*awsRestjson1_deserializeOpGetRoleCredentials) ID() string {
     27 	return "OperationDeserializer"
     28 }
     29 
     30 func (m *awsRestjson1_deserializeOpGetRoleCredentials) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
     31 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
     32 ) {
     33 	out, metadata, err = next.HandleDeserialize(ctx, in)
     34 	if err != nil {
     35 		return out, metadata, err
     36 	}
     37 
     38 	response, ok := out.RawResponse.(*smithyhttp.Response)
     39 	if !ok {
     40 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
     41 	}
     42 
     43 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
     44 
     45 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
     46 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
     47 	defer endTimer()
     48 	defer span.End()
     49 
     50 	if response.StatusCode < 200 || response.StatusCode >= 300 {
     51 		return out, metadata, awsRestjson1_deserializeOpErrorGetRoleCredentials(response, &metadata)
     52 	}
     53 	output := &GetRoleCredentialsOutput{}
     54 	out.Result = output
     55 
     56 	var buff [1024]byte
     57 	ringBuffer := smithyio.NewRingBuffer(buff[:])
     58 
     59 	body := io.TeeReader(response.Body, ringBuffer)
     60 
     61 	decoder := json.NewDecoder(body)
     62 	decoder.UseNumber()
     63 	var shape interface{}
     64 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
     65 		var snapshot bytes.Buffer
     66 		io.Copy(&snapshot, ringBuffer)
     67 		err = &smithy.DeserializationError{
     68 			Err:      fmt.Errorf("failed to decode response body, %w", err),
     69 			Snapshot: snapshot.Bytes(),
     70 		}
     71 		return out, metadata, err
     72 	}
     73 
     74 	err = awsRestjson1_deserializeOpDocumentGetRoleCredentialsOutput(&output, shape)
     75 	if err != nil {
     76 		var snapshot bytes.Buffer
     77 		io.Copy(&snapshot, ringBuffer)
     78 		return out, metadata, &smithy.DeserializationError{
     79 			Err:      fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
     80 			Snapshot: snapshot.Bytes(),
     81 		}
     82 	}
     83 
     84 	span.End()
     85 	return out, metadata, err
     86 }
     87 
     88 func awsRestjson1_deserializeOpErrorGetRoleCredentials(response *smithyhttp.Response, metadata *middleware.Metadata) error {
     89 	var errorBuffer bytes.Buffer
     90 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
     91 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
     92 	}
     93 	errorBody := bytes.NewReader(errorBuffer.Bytes())
     94 
     95 	errorCode := "UnknownError"
     96 	errorMessage := errorCode
     97 
     98 	headerCode := response.Header.Get("X-Amzn-ErrorType")
     99 	if len(headerCode) != 0 {
    100 		errorCode = restjson.SanitizeErrorCode(headerCode)
    101 	}
    102 
    103 	var buff [1024]byte
    104 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    105 
    106 	body := io.TeeReader(errorBody, ringBuffer)
    107 	decoder := json.NewDecoder(body)
    108 	decoder.UseNumber()
    109 	jsonCode, message, err := restjson.GetErrorInfo(decoder)
    110 	if err != nil {
    111 		var snapshot bytes.Buffer
    112 		io.Copy(&snapshot, ringBuffer)
    113 		err = &smithy.DeserializationError{
    114 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    115 			Snapshot: snapshot.Bytes(),
    116 		}
    117 		return err
    118 	}
    119 
    120 	errorBody.Seek(0, io.SeekStart)
    121 	if len(headerCode) == 0 && len(jsonCode) != 0 {
    122 		errorCode = restjson.SanitizeErrorCode(jsonCode)
    123 	}
    124 	if len(message) != 0 {
    125 		errorMessage = message
    126 	}
    127 
    128 	switch {
    129 	case strings.EqualFold("InvalidRequestException", errorCode):
    130 		return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
    131 
    132 	case strings.EqualFold("ResourceNotFoundException", errorCode):
    133 		return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
    134 
    135 	case strings.EqualFold("TooManyRequestsException", errorCode):
    136 		return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody)
    137 
    138 	case strings.EqualFold("UnauthorizedException", errorCode):
    139 		return awsRestjson1_deserializeErrorUnauthorizedException(response, errorBody)
    140 
    141 	default:
    142 		genericError := &smithy.GenericAPIError{
    143 			Code:    errorCode,
    144 			Message: errorMessage,
    145 		}
    146 		return genericError
    147 
    148 	}
    149 }
    150 
    151 func awsRestjson1_deserializeOpDocumentGetRoleCredentialsOutput(v **GetRoleCredentialsOutput, value interface{}) error {
    152 	if v == nil {
    153 		return fmt.Errorf("unexpected nil of type %T", v)
    154 	}
    155 	if value == nil {
    156 		return nil
    157 	}
    158 
    159 	shape, ok := value.(map[string]interface{})
    160 	if !ok {
    161 		return fmt.Errorf("unexpected JSON type %v", value)
    162 	}
    163 
    164 	var sv *GetRoleCredentialsOutput
    165 	if *v == nil {
    166 		sv = &GetRoleCredentialsOutput{}
    167 	} else {
    168 		sv = *v
    169 	}
    170 
    171 	for key, value := range shape {
    172 		switch key {
    173 		case "roleCredentials":
    174 			if err := awsRestjson1_deserializeDocumentRoleCredentials(&sv.RoleCredentials, value); err != nil {
    175 				return err
    176 			}
    177 
    178 		default:
    179 			_, _ = key, value
    180 
    181 		}
    182 	}
    183 	*v = sv
    184 	return nil
    185 }
    186 
    187 type awsRestjson1_deserializeOpListAccountRoles struct {
    188 }
    189 
    190 func (*awsRestjson1_deserializeOpListAccountRoles) ID() string {
    191 	return "OperationDeserializer"
    192 }
    193 
    194 func (m *awsRestjson1_deserializeOpListAccountRoles) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    195 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
    196 ) {
    197 	out, metadata, err = next.HandleDeserialize(ctx, in)
    198 	if err != nil {
    199 		return out, metadata, err
    200 	}
    201 
    202 	response, ok := out.RawResponse.(*smithyhttp.Response)
    203 	if !ok {
    204 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
    205 	}
    206 
    207 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
    208 
    209 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
    210 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
    211 	defer endTimer()
    212 	defer span.End()
    213 
    214 	if response.StatusCode < 200 || response.StatusCode >= 300 {
    215 		return out, metadata, awsRestjson1_deserializeOpErrorListAccountRoles(response, &metadata)
    216 	}
    217 	output := &ListAccountRolesOutput{}
    218 	out.Result = output
    219 
    220 	var buff [1024]byte
    221 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    222 
    223 	body := io.TeeReader(response.Body, ringBuffer)
    224 
    225 	decoder := json.NewDecoder(body)
    226 	decoder.UseNumber()
    227 	var shape interface{}
    228 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
    229 		var snapshot bytes.Buffer
    230 		io.Copy(&snapshot, ringBuffer)
    231 		err = &smithy.DeserializationError{
    232 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    233 			Snapshot: snapshot.Bytes(),
    234 		}
    235 		return out, metadata, err
    236 	}
    237 
    238 	err = awsRestjson1_deserializeOpDocumentListAccountRolesOutput(&output, shape)
    239 	if err != nil {
    240 		var snapshot bytes.Buffer
    241 		io.Copy(&snapshot, ringBuffer)
    242 		return out, metadata, &smithy.DeserializationError{
    243 			Err:      fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
    244 			Snapshot: snapshot.Bytes(),
    245 		}
    246 	}
    247 
    248 	span.End()
    249 	return out, metadata, err
    250 }
    251 
    252 func awsRestjson1_deserializeOpErrorListAccountRoles(response *smithyhttp.Response, metadata *middleware.Metadata) error {
    253 	var errorBuffer bytes.Buffer
    254 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
    255 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
    256 	}
    257 	errorBody := bytes.NewReader(errorBuffer.Bytes())
    258 
    259 	errorCode := "UnknownError"
    260 	errorMessage := errorCode
    261 
    262 	headerCode := response.Header.Get("X-Amzn-ErrorType")
    263 	if len(headerCode) != 0 {
    264 		errorCode = restjson.SanitizeErrorCode(headerCode)
    265 	}
    266 
    267 	var buff [1024]byte
    268 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    269 
    270 	body := io.TeeReader(errorBody, ringBuffer)
    271 	decoder := json.NewDecoder(body)
    272 	decoder.UseNumber()
    273 	jsonCode, message, err := restjson.GetErrorInfo(decoder)
    274 	if err != nil {
    275 		var snapshot bytes.Buffer
    276 		io.Copy(&snapshot, ringBuffer)
    277 		err = &smithy.DeserializationError{
    278 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    279 			Snapshot: snapshot.Bytes(),
    280 		}
    281 		return err
    282 	}
    283 
    284 	errorBody.Seek(0, io.SeekStart)
    285 	if len(headerCode) == 0 && len(jsonCode) != 0 {
    286 		errorCode = restjson.SanitizeErrorCode(jsonCode)
    287 	}
    288 	if len(message) != 0 {
    289 		errorMessage = message
    290 	}
    291 
    292 	switch {
    293 	case strings.EqualFold("InvalidRequestException", errorCode):
    294 		return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
    295 
    296 	case strings.EqualFold("ResourceNotFoundException", errorCode):
    297 		return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
    298 
    299 	case strings.EqualFold("TooManyRequestsException", errorCode):
    300 		return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody)
    301 
    302 	case strings.EqualFold("UnauthorizedException", errorCode):
    303 		return awsRestjson1_deserializeErrorUnauthorizedException(response, errorBody)
    304 
    305 	default:
    306 		genericError := &smithy.GenericAPIError{
    307 			Code:    errorCode,
    308 			Message: errorMessage,
    309 		}
    310 		return genericError
    311 
    312 	}
    313 }
    314 
    315 func awsRestjson1_deserializeOpDocumentListAccountRolesOutput(v **ListAccountRolesOutput, value interface{}) error {
    316 	if v == nil {
    317 		return fmt.Errorf("unexpected nil of type %T", v)
    318 	}
    319 	if value == nil {
    320 		return nil
    321 	}
    322 
    323 	shape, ok := value.(map[string]interface{})
    324 	if !ok {
    325 		return fmt.Errorf("unexpected JSON type %v", value)
    326 	}
    327 
    328 	var sv *ListAccountRolesOutput
    329 	if *v == nil {
    330 		sv = &ListAccountRolesOutput{}
    331 	} else {
    332 		sv = *v
    333 	}
    334 
    335 	for key, value := range shape {
    336 		switch key {
    337 		case "nextToken":
    338 			if value != nil {
    339 				jtv, ok := value.(string)
    340 				if !ok {
    341 					return fmt.Errorf("expected NextTokenType to be of type string, got %T instead", value)
    342 				}
    343 				sv.NextToken = ptr.String(jtv)
    344 			}
    345 
    346 		case "roleList":
    347 			if err := awsRestjson1_deserializeDocumentRoleListType(&sv.RoleList, value); err != nil {
    348 				return err
    349 			}
    350 
    351 		default:
    352 			_, _ = key, value
    353 
    354 		}
    355 	}
    356 	*v = sv
    357 	return nil
    358 }
    359 
    360 type awsRestjson1_deserializeOpListAccounts struct {
    361 }
    362 
    363 func (*awsRestjson1_deserializeOpListAccounts) ID() string {
    364 	return "OperationDeserializer"
    365 }
    366 
    367 func (m *awsRestjson1_deserializeOpListAccounts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    368 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
    369 ) {
    370 	out, metadata, err = next.HandleDeserialize(ctx, in)
    371 	if err != nil {
    372 		return out, metadata, err
    373 	}
    374 
    375 	response, ok := out.RawResponse.(*smithyhttp.Response)
    376 	if !ok {
    377 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
    378 	}
    379 
    380 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
    381 
    382 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
    383 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
    384 	defer endTimer()
    385 	defer span.End()
    386 
    387 	if response.StatusCode < 200 || response.StatusCode >= 300 {
    388 		return out, metadata, awsRestjson1_deserializeOpErrorListAccounts(response, &metadata)
    389 	}
    390 	output := &ListAccountsOutput{}
    391 	out.Result = output
    392 
    393 	var buff [1024]byte
    394 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    395 
    396 	body := io.TeeReader(response.Body, ringBuffer)
    397 
    398 	decoder := json.NewDecoder(body)
    399 	decoder.UseNumber()
    400 	var shape interface{}
    401 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
    402 		var snapshot bytes.Buffer
    403 		io.Copy(&snapshot, ringBuffer)
    404 		err = &smithy.DeserializationError{
    405 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    406 			Snapshot: snapshot.Bytes(),
    407 		}
    408 		return out, metadata, err
    409 	}
    410 
    411 	err = awsRestjson1_deserializeOpDocumentListAccountsOutput(&output, shape)
    412 	if err != nil {
    413 		var snapshot bytes.Buffer
    414 		io.Copy(&snapshot, ringBuffer)
    415 		return out, metadata, &smithy.DeserializationError{
    416 			Err:      fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
    417 			Snapshot: snapshot.Bytes(),
    418 		}
    419 	}
    420 
    421 	span.End()
    422 	return out, metadata, err
    423 }
    424 
    425 func awsRestjson1_deserializeOpErrorListAccounts(response *smithyhttp.Response, metadata *middleware.Metadata) error {
    426 	var errorBuffer bytes.Buffer
    427 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
    428 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
    429 	}
    430 	errorBody := bytes.NewReader(errorBuffer.Bytes())
    431 
    432 	errorCode := "UnknownError"
    433 	errorMessage := errorCode
    434 
    435 	headerCode := response.Header.Get("X-Amzn-ErrorType")
    436 	if len(headerCode) != 0 {
    437 		errorCode = restjson.SanitizeErrorCode(headerCode)
    438 	}
    439 
    440 	var buff [1024]byte
    441 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    442 
    443 	body := io.TeeReader(errorBody, ringBuffer)
    444 	decoder := json.NewDecoder(body)
    445 	decoder.UseNumber()
    446 	jsonCode, message, err := restjson.GetErrorInfo(decoder)
    447 	if err != nil {
    448 		var snapshot bytes.Buffer
    449 		io.Copy(&snapshot, ringBuffer)
    450 		err = &smithy.DeserializationError{
    451 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    452 			Snapshot: snapshot.Bytes(),
    453 		}
    454 		return err
    455 	}
    456 
    457 	errorBody.Seek(0, io.SeekStart)
    458 	if len(headerCode) == 0 && len(jsonCode) != 0 {
    459 		errorCode = restjson.SanitizeErrorCode(jsonCode)
    460 	}
    461 	if len(message) != 0 {
    462 		errorMessage = message
    463 	}
    464 
    465 	switch {
    466 	case strings.EqualFold("InvalidRequestException", errorCode):
    467 		return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
    468 
    469 	case strings.EqualFold("ResourceNotFoundException", errorCode):
    470 		return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
    471 
    472 	case strings.EqualFold("TooManyRequestsException", errorCode):
    473 		return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody)
    474 
    475 	case strings.EqualFold("UnauthorizedException", errorCode):
    476 		return awsRestjson1_deserializeErrorUnauthorizedException(response, errorBody)
    477 
    478 	default:
    479 		genericError := &smithy.GenericAPIError{
    480 			Code:    errorCode,
    481 			Message: errorMessage,
    482 		}
    483 		return genericError
    484 
    485 	}
    486 }
    487 
    488 func awsRestjson1_deserializeOpDocumentListAccountsOutput(v **ListAccountsOutput, value interface{}) error {
    489 	if v == nil {
    490 		return fmt.Errorf("unexpected nil of type %T", v)
    491 	}
    492 	if value == nil {
    493 		return nil
    494 	}
    495 
    496 	shape, ok := value.(map[string]interface{})
    497 	if !ok {
    498 		return fmt.Errorf("unexpected JSON type %v", value)
    499 	}
    500 
    501 	var sv *ListAccountsOutput
    502 	if *v == nil {
    503 		sv = &ListAccountsOutput{}
    504 	} else {
    505 		sv = *v
    506 	}
    507 
    508 	for key, value := range shape {
    509 		switch key {
    510 		case "accountList":
    511 			if err := awsRestjson1_deserializeDocumentAccountListType(&sv.AccountList, value); err != nil {
    512 				return err
    513 			}
    514 
    515 		case "nextToken":
    516 			if value != nil {
    517 				jtv, ok := value.(string)
    518 				if !ok {
    519 					return fmt.Errorf("expected NextTokenType to be of type string, got %T instead", value)
    520 				}
    521 				sv.NextToken = ptr.String(jtv)
    522 			}
    523 
    524 		default:
    525 			_, _ = key, value
    526 
    527 		}
    528 	}
    529 	*v = sv
    530 	return nil
    531 }
    532 
    533 type awsRestjson1_deserializeOpLogout struct {
    534 }
    535 
    536 func (*awsRestjson1_deserializeOpLogout) ID() string {
    537 	return "OperationDeserializer"
    538 }
    539 
    540 func (m *awsRestjson1_deserializeOpLogout) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    541 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
    542 ) {
    543 	out, metadata, err = next.HandleDeserialize(ctx, in)
    544 	if err != nil {
    545 		return out, metadata, err
    546 	}
    547 
    548 	response, ok := out.RawResponse.(*smithyhttp.Response)
    549 	if !ok {
    550 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
    551 	}
    552 
    553 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
    554 
    555 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
    556 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
    557 	defer endTimer()
    558 	defer span.End()
    559 
    560 	if response.StatusCode < 200 || response.StatusCode >= 300 {
    561 		return out, metadata, awsRestjson1_deserializeOpErrorLogout(response, &metadata)
    562 	}
    563 	output := &LogoutOutput{}
    564 	out.Result = output
    565 
    566 	if _, err = io.Copy(io.Discard, response.Body); err != nil {
    567 		return out, metadata, &smithy.DeserializationError{
    568 			Err: fmt.Errorf("failed to discard response body, %w", err),
    569 		}
    570 	}
    571 
    572 	span.End()
    573 	return out, metadata, err
    574 }
    575 
    576 func awsRestjson1_deserializeOpErrorLogout(response *smithyhttp.Response, metadata *middleware.Metadata) error {
    577 	var errorBuffer bytes.Buffer
    578 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
    579 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
    580 	}
    581 	errorBody := bytes.NewReader(errorBuffer.Bytes())
    582 
    583 	errorCode := "UnknownError"
    584 	errorMessage := errorCode
    585 
    586 	headerCode := response.Header.Get("X-Amzn-ErrorType")
    587 	if len(headerCode) != 0 {
    588 		errorCode = restjson.SanitizeErrorCode(headerCode)
    589 	}
    590 
    591 	var buff [1024]byte
    592 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    593 
    594 	body := io.TeeReader(errorBody, ringBuffer)
    595 	decoder := json.NewDecoder(body)
    596 	decoder.UseNumber()
    597 	jsonCode, message, err := restjson.GetErrorInfo(decoder)
    598 	if err != nil {
    599 		var snapshot bytes.Buffer
    600 		io.Copy(&snapshot, ringBuffer)
    601 		err = &smithy.DeserializationError{
    602 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    603 			Snapshot: snapshot.Bytes(),
    604 		}
    605 		return err
    606 	}
    607 
    608 	errorBody.Seek(0, io.SeekStart)
    609 	if len(headerCode) == 0 && len(jsonCode) != 0 {
    610 		errorCode = restjson.SanitizeErrorCode(jsonCode)
    611 	}
    612 	if len(message) != 0 {
    613 		errorMessage = message
    614 	}
    615 
    616 	switch {
    617 	case strings.EqualFold("InvalidRequestException", errorCode):
    618 		return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
    619 
    620 	case strings.EqualFold("TooManyRequestsException", errorCode):
    621 		return awsRestjson1_deserializeErrorTooManyRequestsException(response, errorBody)
    622 
    623 	case strings.EqualFold("UnauthorizedException", errorCode):
    624 		return awsRestjson1_deserializeErrorUnauthorizedException(response, errorBody)
    625 
    626 	default:
    627 		genericError := &smithy.GenericAPIError{
    628 			Code:    errorCode,
    629 			Message: errorMessage,
    630 		}
    631 		return genericError
    632 
    633 	}
    634 }
    635 
    636 func awsRestjson1_deserializeErrorInvalidRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
    637 	output := &types.InvalidRequestException{}
    638 	var buff [1024]byte
    639 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    640 
    641 	body := io.TeeReader(errorBody, ringBuffer)
    642 	decoder := json.NewDecoder(body)
    643 	decoder.UseNumber()
    644 	var shape interface{}
    645 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
    646 		var snapshot bytes.Buffer
    647 		io.Copy(&snapshot, ringBuffer)
    648 		err = &smithy.DeserializationError{
    649 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    650 			Snapshot: snapshot.Bytes(),
    651 		}
    652 		return err
    653 	}
    654 
    655 	err := awsRestjson1_deserializeDocumentInvalidRequestException(&output, shape)
    656 
    657 	if err != nil {
    658 		var snapshot bytes.Buffer
    659 		io.Copy(&snapshot, ringBuffer)
    660 		err = &smithy.DeserializationError{
    661 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    662 			Snapshot: snapshot.Bytes(),
    663 		}
    664 		return err
    665 	}
    666 
    667 	errorBody.Seek(0, io.SeekStart)
    668 
    669 	return output
    670 }
    671 
    672 func awsRestjson1_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
    673 	output := &types.ResourceNotFoundException{}
    674 	var buff [1024]byte
    675 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    676 
    677 	body := io.TeeReader(errorBody, ringBuffer)
    678 	decoder := json.NewDecoder(body)
    679 	decoder.UseNumber()
    680 	var shape interface{}
    681 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
    682 		var snapshot bytes.Buffer
    683 		io.Copy(&snapshot, ringBuffer)
    684 		err = &smithy.DeserializationError{
    685 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    686 			Snapshot: snapshot.Bytes(),
    687 		}
    688 		return err
    689 	}
    690 
    691 	err := awsRestjson1_deserializeDocumentResourceNotFoundException(&output, shape)
    692 
    693 	if err != nil {
    694 		var snapshot bytes.Buffer
    695 		io.Copy(&snapshot, ringBuffer)
    696 		err = &smithy.DeserializationError{
    697 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    698 			Snapshot: snapshot.Bytes(),
    699 		}
    700 		return err
    701 	}
    702 
    703 	errorBody.Seek(0, io.SeekStart)
    704 
    705 	return output
    706 }
    707 
    708 func awsRestjson1_deserializeErrorTooManyRequestsException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
    709 	output := &types.TooManyRequestsException{}
    710 	var buff [1024]byte
    711 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    712 
    713 	body := io.TeeReader(errorBody, ringBuffer)
    714 	decoder := json.NewDecoder(body)
    715 	decoder.UseNumber()
    716 	var shape interface{}
    717 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
    718 		var snapshot bytes.Buffer
    719 		io.Copy(&snapshot, ringBuffer)
    720 		err = &smithy.DeserializationError{
    721 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    722 			Snapshot: snapshot.Bytes(),
    723 		}
    724 		return err
    725 	}
    726 
    727 	err := awsRestjson1_deserializeDocumentTooManyRequestsException(&output, shape)
    728 
    729 	if err != nil {
    730 		var snapshot bytes.Buffer
    731 		io.Copy(&snapshot, ringBuffer)
    732 		err = &smithy.DeserializationError{
    733 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    734 			Snapshot: snapshot.Bytes(),
    735 		}
    736 		return err
    737 	}
    738 
    739 	errorBody.Seek(0, io.SeekStart)
    740 
    741 	return output
    742 }
    743 
    744 func awsRestjson1_deserializeErrorUnauthorizedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
    745 	output := &types.UnauthorizedException{}
    746 	var buff [1024]byte
    747 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    748 
    749 	body := io.TeeReader(errorBody, ringBuffer)
    750 	decoder := json.NewDecoder(body)
    751 	decoder.UseNumber()
    752 	var shape interface{}
    753 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
    754 		var snapshot bytes.Buffer
    755 		io.Copy(&snapshot, ringBuffer)
    756 		err = &smithy.DeserializationError{
    757 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    758 			Snapshot: snapshot.Bytes(),
    759 		}
    760 		return err
    761 	}
    762 
    763 	err := awsRestjson1_deserializeDocumentUnauthorizedException(&output, shape)
    764 
    765 	if err != nil {
    766 		var snapshot bytes.Buffer
    767 		io.Copy(&snapshot, ringBuffer)
    768 		err = &smithy.DeserializationError{
    769 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    770 			Snapshot: snapshot.Bytes(),
    771 		}
    772 		return err
    773 	}
    774 
    775 	errorBody.Seek(0, io.SeekStart)
    776 
    777 	return output
    778 }
    779 
    780 func awsRestjson1_deserializeDocumentAccountInfo(v **types.AccountInfo, value interface{}) error {
    781 	if v == nil {
    782 		return fmt.Errorf("unexpected nil of type %T", v)
    783 	}
    784 	if value == nil {
    785 		return nil
    786 	}
    787 
    788 	shape, ok := value.(map[string]interface{})
    789 	if !ok {
    790 		return fmt.Errorf("unexpected JSON type %v", value)
    791 	}
    792 
    793 	var sv *types.AccountInfo
    794 	if *v == nil {
    795 		sv = &types.AccountInfo{}
    796 	} else {
    797 		sv = *v
    798 	}
    799 
    800 	for key, value := range shape {
    801 		switch key {
    802 		case "accountId":
    803 			if value != nil {
    804 				jtv, ok := value.(string)
    805 				if !ok {
    806 					return fmt.Errorf("expected AccountIdType to be of type string, got %T instead", value)
    807 				}
    808 				sv.AccountId = ptr.String(jtv)
    809 			}
    810 
    811 		case "accountName":
    812 			if value != nil {
    813 				jtv, ok := value.(string)
    814 				if !ok {
    815 					return fmt.Errorf("expected AccountNameType to be of type string, got %T instead", value)
    816 				}
    817 				sv.AccountName = ptr.String(jtv)
    818 			}
    819 
    820 		case "emailAddress":
    821 			if value != nil {
    822 				jtv, ok := value.(string)
    823 				if !ok {
    824 					return fmt.Errorf("expected EmailAddressType to be of type string, got %T instead", value)
    825 				}
    826 				sv.EmailAddress = ptr.String(jtv)
    827 			}
    828 
    829 		default:
    830 			_, _ = key, value
    831 
    832 		}
    833 	}
    834 	*v = sv
    835 	return nil
    836 }
    837 
    838 func awsRestjson1_deserializeDocumentAccountListType(v *[]types.AccountInfo, value interface{}) error {
    839 	if v == nil {
    840 		return fmt.Errorf("unexpected nil of type %T", v)
    841 	}
    842 	if value == nil {
    843 		return nil
    844 	}
    845 
    846 	shape, ok := value.([]interface{})
    847 	if !ok {
    848 		return fmt.Errorf("unexpected JSON type %v", value)
    849 	}
    850 
    851 	var cv []types.AccountInfo
    852 	if *v == nil {
    853 		cv = []types.AccountInfo{}
    854 	} else {
    855 		cv = *v
    856 	}
    857 
    858 	for _, value := range shape {
    859 		var col types.AccountInfo
    860 		destAddr := &col
    861 		if err := awsRestjson1_deserializeDocumentAccountInfo(&destAddr, value); err != nil {
    862 			return err
    863 		}
    864 		col = *destAddr
    865 		cv = append(cv, col)
    866 
    867 	}
    868 	*v = cv
    869 	return nil
    870 }
    871 
    872 func awsRestjson1_deserializeDocumentInvalidRequestException(v **types.InvalidRequestException, value interface{}) error {
    873 	if v == nil {
    874 		return fmt.Errorf("unexpected nil of type %T", v)
    875 	}
    876 	if value == nil {
    877 		return nil
    878 	}
    879 
    880 	shape, ok := value.(map[string]interface{})
    881 	if !ok {
    882 		return fmt.Errorf("unexpected JSON type %v", value)
    883 	}
    884 
    885 	var sv *types.InvalidRequestException
    886 	if *v == nil {
    887 		sv = &types.InvalidRequestException{}
    888 	} else {
    889 		sv = *v
    890 	}
    891 
    892 	for key, value := range shape {
    893 		switch key {
    894 		case "message", "Message":
    895 			if value != nil {
    896 				jtv, ok := value.(string)
    897 				if !ok {
    898 					return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
    899 				}
    900 				sv.Message = ptr.String(jtv)
    901 			}
    902 
    903 		default:
    904 			_, _ = key, value
    905 
    906 		}
    907 	}
    908 	*v = sv
    909 	return nil
    910 }
    911 
    912 func awsRestjson1_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error {
    913 	if v == nil {
    914 		return fmt.Errorf("unexpected nil of type %T", v)
    915 	}
    916 	if value == nil {
    917 		return nil
    918 	}
    919 
    920 	shape, ok := value.(map[string]interface{})
    921 	if !ok {
    922 		return fmt.Errorf("unexpected JSON type %v", value)
    923 	}
    924 
    925 	var sv *types.ResourceNotFoundException
    926 	if *v == nil {
    927 		sv = &types.ResourceNotFoundException{}
    928 	} else {
    929 		sv = *v
    930 	}
    931 
    932 	for key, value := range shape {
    933 		switch key {
    934 		case "message", "Message":
    935 			if value != nil {
    936 				jtv, ok := value.(string)
    937 				if !ok {
    938 					return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
    939 				}
    940 				sv.Message = ptr.String(jtv)
    941 			}
    942 
    943 		default:
    944 			_, _ = key, value
    945 
    946 		}
    947 	}
    948 	*v = sv
    949 	return nil
    950 }
    951 
    952 func awsRestjson1_deserializeDocumentRoleCredentials(v **types.RoleCredentials, value interface{}) error {
    953 	if v == nil {
    954 		return fmt.Errorf("unexpected nil of type %T", v)
    955 	}
    956 	if value == nil {
    957 		return nil
    958 	}
    959 
    960 	shape, ok := value.(map[string]interface{})
    961 	if !ok {
    962 		return fmt.Errorf("unexpected JSON type %v", value)
    963 	}
    964 
    965 	var sv *types.RoleCredentials
    966 	if *v == nil {
    967 		sv = &types.RoleCredentials{}
    968 	} else {
    969 		sv = *v
    970 	}
    971 
    972 	for key, value := range shape {
    973 		switch key {
    974 		case "accessKeyId":
    975 			if value != nil {
    976 				jtv, ok := value.(string)
    977 				if !ok {
    978 					return fmt.Errorf("expected AccessKeyType to be of type string, got %T instead", value)
    979 				}
    980 				sv.AccessKeyId = ptr.String(jtv)
    981 			}
    982 
    983 		case "expiration":
    984 			if value != nil {
    985 				jtv, ok := value.(json.Number)
    986 				if !ok {
    987 					return fmt.Errorf("expected ExpirationTimestampType to be json.Number, got %T instead", value)
    988 				}
    989 				i64, err := jtv.Int64()
    990 				if err != nil {
    991 					return err
    992 				}
    993 				sv.Expiration = i64
    994 			}
    995 
    996 		case "secretAccessKey":
    997 			if value != nil {
    998 				jtv, ok := value.(string)
    999 				if !ok {
   1000 					return fmt.Errorf("expected SecretAccessKeyType to be of type string, got %T instead", value)
   1001 				}
   1002 				sv.SecretAccessKey = ptr.String(jtv)
   1003 			}
   1004 
   1005 		case "sessionToken":
   1006 			if value != nil {
   1007 				jtv, ok := value.(string)
   1008 				if !ok {
   1009 					return fmt.Errorf("expected SessionTokenType to be of type string, got %T instead", value)
   1010 				}
   1011 				sv.SessionToken = ptr.String(jtv)
   1012 			}
   1013 
   1014 		default:
   1015 			_, _ = key, value
   1016 
   1017 		}
   1018 	}
   1019 	*v = sv
   1020 	return nil
   1021 }
   1022 
   1023 func awsRestjson1_deserializeDocumentRoleInfo(v **types.RoleInfo, value interface{}) error {
   1024 	if v == nil {
   1025 		return fmt.Errorf("unexpected nil of type %T", v)
   1026 	}
   1027 	if value == nil {
   1028 		return nil
   1029 	}
   1030 
   1031 	shape, ok := value.(map[string]interface{})
   1032 	if !ok {
   1033 		return fmt.Errorf("unexpected JSON type %v", value)
   1034 	}
   1035 
   1036 	var sv *types.RoleInfo
   1037 	if *v == nil {
   1038 		sv = &types.RoleInfo{}
   1039 	} else {
   1040 		sv = *v
   1041 	}
   1042 
   1043 	for key, value := range shape {
   1044 		switch key {
   1045 		case "accountId":
   1046 			if value != nil {
   1047 				jtv, ok := value.(string)
   1048 				if !ok {
   1049 					return fmt.Errorf("expected AccountIdType to be of type string, got %T instead", value)
   1050 				}
   1051 				sv.AccountId = ptr.String(jtv)
   1052 			}
   1053 
   1054 		case "roleName":
   1055 			if value != nil {
   1056 				jtv, ok := value.(string)
   1057 				if !ok {
   1058 					return fmt.Errorf("expected RoleNameType to be of type string, got %T instead", value)
   1059 				}
   1060 				sv.RoleName = ptr.String(jtv)
   1061 			}
   1062 
   1063 		default:
   1064 			_, _ = key, value
   1065 
   1066 		}
   1067 	}
   1068 	*v = sv
   1069 	return nil
   1070 }
   1071 
   1072 func awsRestjson1_deserializeDocumentRoleListType(v *[]types.RoleInfo, value interface{}) error {
   1073 	if v == nil {
   1074 		return fmt.Errorf("unexpected nil of type %T", v)
   1075 	}
   1076 	if value == nil {
   1077 		return nil
   1078 	}
   1079 
   1080 	shape, ok := value.([]interface{})
   1081 	if !ok {
   1082 		return fmt.Errorf("unexpected JSON type %v", value)
   1083 	}
   1084 
   1085 	var cv []types.RoleInfo
   1086 	if *v == nil {
   1087 		cv = []types.RoleInfo{}
   1088 	} else {
   1089 		cv = *v
   1090 	}
   1091 
   1092 	for _, value := range shape {
   1093 		var col types.RoleInfo
   1094 		destAddr := &col
   1095 		if err := awsRestjson1_deserializeDocumentRoleInfo(&destAddr, value); err != nil {
   1096 			return err
   1097 		}
   1098 		col = *destAddr
   1099 		cv = append(cv, col)
   1100 
   1101 	}
   1102 	*v = cv
   1103 	return nil
   1104 }
   1105 
   1106 func awsRestjson1_deserializeDocumentTooManyRequestsException(v **types.TooManyRequestsException, value interface{}) error {
   1107 	if v == nil {
   1108 		return fmt.Errorf("unexpected nil of type %T", v)
   1109 	}
   1110 	if value == nil {
   1111 		return nil
   1112 	}
   1113 
   1114 	shape, ok := value.(map[string]interface{})
   1115 	if !ok {
   1116 		return fmt.Errorf("unexpected JSON type %v", value)
   1117 	}
   1118 
   1119 	var sv *types.TooManyRequestsException
   1120 	if *v == nil {
   1121 		sv = &types.TooManyRequestsException{}
   1122 	} else {
   1123 		sv = *v
   1124 	}
   1125 
   1126 	for key, value := range shape {
   1127 		switch key {
   1128 		case "message", "Message":
   1129 			if value != nil {
   1130 				jtv, ok := value.(string)
   1131 				if !ok {
   1132 					return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
   1133 				}
   1134 				sv.Message = ptr.String(jtv)
   1135 			}
   1136 
   1137 		default:
   1138 			_, _ = key, value
   1139 
   1140 		}
   1141 	}
   1142 	*v = sv
   1143 	return nil
   1144 }
   1145 
   1146 func awsRestjson1_deserializeDocumentUnauthorizedException(v **types.UnauthorizedException, value interface{}) error {
   1147 	if v == nil {
   1148 		return fmt.Errorf("unexpected nil of type %T", v)
   1149 	}
   1150 	if value == nil {
   1151 		return nil
   1152 	}
   1153 
   1154 	shape, ok := value.(map[string]interface{})
   1155 	if !ok {
   1156 		return fmt.Errorf("unexpected JSON type %v", value)
   1157 	}
   1158 
   1159 	var sv *types.UnauthorizedException
   1160 	if *v == nil {
   1161 		sv = &types.UnauthorizedException{}
   1162 	} else {
   1163 		sv = *v
   1164 	}
   1165 
   1166 	for key, value := range shape {
   1167 		switch key {
   1168 		case "message", "Message":
   1169 			if value != nil {
   1170 				jtv, ok := value.(string)
   1171 				if !ok {
   1172 					return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
   1173 				}
   1174 				sv.Message = ptr.String(jtv)
   1175 			}
   1176 
   1177 		default:
   1178 			_, _ = key, value
   1179 
   1180 		}
   1181 	}
   1182 	*v = sv
   1183 	return nil
   1184 }