src

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

deserializers.go (29284B)

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