src

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

deserializers.go (30096B)

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