src

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

deserializers.go (58109B)

      1 // Code generated by smithy-go-codegen DO NOT EDIT.
      2 
      3 package ssooidc
      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/ssooidc/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 	"strings"
     20 )
     21 
     22 type awsRestjson1_deserializeOpCreateToken struct {
     23 }
     24 
     25 func (*awsRestjson1_deserializeOpCreateToken) ID() string {
     26 	return "OperationDeserializer"
     27 }
     28 
     29 func (m *awsRestjson1_deserializeOpCreateToken) 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 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
     38 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
     39 	defer endTimer()
     40 	defer span.End()
     41 	response, ok := out.RawResponse.(*smithyhttp.Response)
     42 	if !ok {
     43 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
     44 	}
     45 
     46 	if response.StatusCode < 200 || response.StatusCode >= 300 {
     47 		return out, metadata, awsRestjson1_deserializeOpErrorCreateToken(response, &metadata)
     48 	}
     49 	output := &CreateTokenOutput{}
     50 	out.Result = output
     51 
     52 	var buff [1024]byte
     53 	ringBuffer := smithyio.NewRingBuffer(buff[:])
     54 
     55 	body := io.TeeReader(response.Body, ringBuffer)
     56 
     57 	decoder := json.NewDecoder(body)
     58 	decoder.UseNumber()
     59 	var shape interface{}
     60 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
     61 		var snapshot bytes.Buffer
     62 		io.Copy(&snapshot, ringBuffer)
     63 		err = &smithy.DeserializationError{
     64 			Err:      fmt.Errorf("failed to decode response body, %w", err),
     65 			Snapshot: snapshot.Bytes(),
     66 		}
     67 		return out, metadata, err
     68 	}
     69 
     70 	err = awsRestjson1_deserializeOpDocumentCreateTokenOutput(&output, shape)
     71 	if err != nil {
     72 		var snapshot bytes.Buffer
     73 		io.Copy(&snapshot, ringBuffer)
     74 		return out, metadata, &smithy.DeserializationError{
     75 			Err:      fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
     76 			Snapshot: snapshot.Bytes(),
     77 		}
     78 	}
     79 
     80 	span.End()
     81 	return out, metadata, err
     82 }
     83 
     84 func awsRestjson1_deserializeOpErrorCreateToken(response *smithyhttp.Response, metadata *middleware.Metadata) error {
     85 	var errorBuffer bytes.Buffer
     86 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
     87 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
     88 	}
     89 	errorBody := bytes.NewReader(errorBuffer.Bytes())
     90 
     91 	errorCode := "UnknownError"
     92 	errorMessage := errorCode
     93 
     94 	headerCode := response.Header.Get("X-Amzn-ErrorType")
     95 	if len(headerCode) != 0 {
     96 		errorCode = restjson.SanitizeErrorCode(headerCode)
     97 	}
     98 
     99 	var buff [1024]byte
    100 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    101 
    102 	body := io.TeeReader(errorBody, ringBuffer)
    103 	decoder := json.NewDecoder(body)
    104 	decoder.UseNumber()
    105 	jsonCode, message, err := restjson.GetErrorInfo(decoder)
    106 	if err != nil {
    107 		var snapshot bytes.Buffer
    108 		io.Copy(&snapshot, ringBuffer)
    109 		err = &smithy.DeserializationError{
    110 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    111 			Snapshot: snapshot.Bytes(),
    112 		}
    113 		return err
    114 	}
    115 
    116 	errorBody.Seek(0, io.SeekStart)
    117 	if len(headerCode) == 0 && len(jsonCode) != 0 {
    118 		errorCode = restjson.SanitizeErrorCode(jsonCode)
    119 	}
    120 	if len(message) != 0 {
    121 		errorMessage = message
    122 	}
    123 
    124 	switch {
    125 	case strings.EqualFold("AccessDeniedException", errorCode):
    126 		return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
    127 
    128 	case strings.EqualFold("AuthorizationPendingException", errorCode):
    129 		return awsRestjson1_deserializeErrorAuthorizationPendingException(response, errorBody)
    130 
    131 	case strings.EqualFold("ExpiredTokenException", errorCode):
    132 		return awsRestjson1_deserializeErrorExpiredTokenException(response, errorBody)
    133 
    134 	case strings.EqualFold("InternalServerException", errorCode):
    135 		return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
    136 
    137 	case strings.EqualFold("InvalidClientException", errorCode):
    138 		return awsRestjson1_deserializeErrorInvalidClientException(response, errorBody)
    139 
    140 	case strings.EqualFold("InvalidGrantException", errorCode):
    141 		return awsRestjson1_deserializeErrorInvalidGrantException(response, errorBody)
    142 
    143 	case strings.EqualFold("InvalidRequestException", errorCode):
    144 		return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
    145 
    146 	case strings.EqualFold("InvalidScopeException", errorCode):
    147 		return awsRestjson1_deserializeErrorInvalidScopeException(response, errorBody)
    148 
    149 	case strings.EqualFold("SlowDownException", errorCode):
    150 		return awsRestjson1_deserializeErrorSlowDownException(response, errorBody)
    151 
    152 	case strings.EqualFold("UnauthorizedClientException", errorCode):
    153 		return awsRestjson1_deserializeErrorUnauthorizedClientException(response, errorBody)
    154 
    155 	case strings.EqualFold("UnsupportedGrantTypeException", errorCode):
    156 		return awsRestjson1_deserializeErrorUnsupportedGrantTypeException(response, errorBody)
    157 
    158 	default:
    159 		genericError := &smithy.GenericAPIError{
    160 			Code:    errorCode,
    161 			Message: errorMessage,
    162 		}
    163 		return genericError
    164 
    165 	}
    166 }
    167 
    168 func awsRestjson1_deserializeOpDocumentCreateTokenOutput(v **CreateTokenOutput, value interface{}) error {
    169 	if v == nil {
    170 		return fmt.Errorf("unexpected nil of type %T", v)
    171 	}
    172 	if value == nil {
    173 		return nil
    174 	}
    175 
    176 	shape, ok := value.(map[string]interface{})
    177 	if !ok {
    178 		return fmt.Errorf("unexpected JSON type %v", value)
    179 	}
    180 
    181 	var sv *CreateTokenOutput
    182 	if *v == nil {
    183 		sv = &CreateTokenOutput{}
    184 	} else {
    185 		sv = *v
    186 	}
    187 
    188 	for key, value := range shape {
    189 		switch key {
    190 		case "accessToken":
    191 			if value != nil {
    192 				jtv, ok := value.(string)
    193 				if !ok {
    194 					return fmt.Errorf("expected AccessToken to be of type string, got %T instead", value)
    195 				}
    196 				sv.AccessToken = ptr.String(jtv)
    197 			}
    198 
    199 		case "expiresIn":
    200 			if value != nil {
    201 				jtv, ok := value.(json.Number)
    202 				if !ok {
    203 					return fmt.Errorf("expected ExpirationInSeconds to be json.Number, got %T instead", value)
    204 				}
    205 				i64, err := jtv.Int64()
    206 				if err != nil {
    207 					return err
    208 				}
    209 				sv.ExpiresIn = int32(i64)
    210 			}
    211 
    212 		case "idToken":
    213 			if value != nil {
    214 				jtv, ok := value.(string)
    215 				if !ok {
    216 					return fmt.Errorf("expected IdToken to be of type string, got %T instead", value)
    217 				}
    218 				sv.IdToken = ptr.String(jtv)
    219 			}
    220 
    221 		case "refreshToken":
    222 			if value != nil {
    223 				jtv, ok := value.(string)
    224 				if !ok {
    225 					return fmt.Errorf("expected RefreshToken to be of type string, got %T instead", value)
    226 				}
    227 				sv.RefreshToken = ptr.String(jtv)
    228 			}
    229 
    230 		case "tokenType":
    231 			if value != nil {
    232 				jtv, ok := value.(string)
    233 				if !ok {
    234 					return fmt.Errorf("expected TokenType to be of type string, got %T instead", value)
    235 				}
    236 				sv.TokenType = ptr.String(jtv)
    237 			}
    238 
    239 		default:
    240 			_, _ = key, value
    241 
    242 		}
    243 	}
    244 	*v = sv
    245 	return nil
    246 }
    247 
    248 type awsRestjson1_deserializeOpCreateTokenWithIAM struct {
    249 }
    250 
    251 func (*awsRestjson1_deserializeOpCreateTokenWithIAM) ID() string {
    252 	return "OperationDeserializer"
    253 }
    254 
    255 func (m *awsRestjson1_deserializeOpCreateTokenWithIAM) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    256 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
    257 ) {
    258 	out, metadata, err = next.HandleDeserialize(ctx, in)
    259 	if err != nil {
    260 		return out, metadata, err
    261 	}
    262 
    263 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
    264 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
    265 	defer endTimer()
    266 	defer span.End()
    267 	response, ok := out.RawResponse.(*smithyhttp.Response)
    268 	if !ok {
    269 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
    270 	}
    271 
    272 	if response.StatusCode < 200 || response.StatusCode >= 300 {
    273 		return out, metadata, awsRestjson1_deserializeOpErrorCreateTokenWithIAM(response, &metadata)
    274 	}
    275 	output := &CreateTokenWithIAMOutput{}
    276 	out.Result = output
    277 
    278 	var buff [1024]byte
    279 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    280 
    281 	body := io.TeeReader(response.Body, ringBuffer)
    282 
    283 	decoder := json.NewDecoder(body)
    284 	decoder.UseNumber()
    285 	var shape interface{}
    286 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
    287 		var snapshot bytes.Buffer
    288 		io.Copy(&snapshot, ringBuffer)
    289 		err = &smithy.DeserializationError{
    290 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    291 			Snapshot: snapshot.Bytes(),
    292 		}
    293 		return out, metadata, err
    294 	}
    295 
    296 	err = awsRestjson1_deserializeOpDocumentCreateTokenWithIAMOutput(&output, shape)
    297 	if err != nil {
    298 		var snapshot bytes.Buffer
    299 		io.Copy(&snapshot, ringBuffer)
    300 		return out, metadata, &smithy.DeserializationError{
    301 			Err:      fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
    302 			Snapshot: snapshot.Bytes(),
    303 		}
    304 	}
    305 
    306 	span.End()
    307 	return out, metadata, err
    308 }
    309 
    310 func awsRestjson1_deserializeOpErrorCreateTokenWithIAM(response *smithyhttp.Response, metadata *middleware.Metadata) error {
    311 	var errorBuffer bytes.Buffer
    312 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
    313 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
    314 	}
    315 	errorBody := bytes.NewReader(errorBuffer.Bytes())
    316 
    317 	errorCode := "UnknownError"
    318 	errorMessage := errorCode
    319 
    320 	headerCode := response.Header.Get("X-Amzn-ErrorType")
    321 	if len(headerCode) != 0 {
    322 		errorCode = restjson.SanitizeErrorCode(headerCode)
    323 	}
    324 
    325 	var buff [1024]byte
    326 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    327 
    328 	body := io.TeeReader(errorBody, ringBuffer)
    329 	decoder := json.NewDecoder(body)
    330 	decoder.UseNumber()
    331 	jsonCode, message, err := restjson.GetErrorInfo(decoder)
    332 	if err != nil {
    333 		var snapshot bytes.Buffer
    334 		io.Copy(&snapshot, ringBuffer)
    335 		err = &smithy.DeserializationError{
    336 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    337 			Snapshot: snapshot.Bytes(),
    338 		}
    339 		return err
    340 	}
    341 
    342 	errorBody.Seek(0, io.SeekStart)
    343 	if len(headerCode) == 0 && len(jsonCode) != 0 {
    344 		errorCode = restjson.SanitizeErrorCode(jsonCode)
    345 	}
    346 	if len(message) != 0 {
    347 		errorMessage = message
    348 	}
    349 
    350 	switch {
    351 	case strings.EqualFold("AccessDeniedException", errorCode):
    352 		return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
    353 
    354 	case strings.EqualFold("AuthorizationPendingException", errorCode):
    355 		return awsRestjson1_deserializeErrorAuthorizationPendingException(response, errorBody)
    356 
    357 	case strings.EqualFold("ExpiredTokenException", errorCode):
    358 		return awsRestjson1_deserializeErrorExpiredTokenException(response, errorBody)
    359 
    360 	case strings.EqualFold("InternalServerException", errorCode):
    361 		return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
    362 
    363 	case strings.EqualFold("InvalidClientException", errorCode):
    364 		return awsRestjson1_deserializeErrorInvalidClientException(response, errorBody)
    365 
    366 	case strings.EqualFold("InvalidGrantException", errorCode):
    367 		return awsRestjson1_deserializeErrorInvalidGrantException(response, errorBody)
    368 
    369 	case strings.EqualFold("InvalidRequestException", errorCode):
    370 		return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
    371 
    372 	case strings.EqualFold("InvalidRequestRegionException", errorCode):
    373 		return awsRestjson1_deserializeErrorInvalidRequestRegionException(response, errorBody)
    374 
    375 	case strings.EqualFold("InvalidScopeException", errorCode):
    376 		return awsRestjson1_deserializeErrorInvalidScopeException(response, errorBody)
    377 
    378 	case strings.EqualFold("SlowDownException", errorCode):
    379 		return awsRestjson1_deserializeErrorSlowDownException(response, errorBody)
    380 
    381 	case strings.EqualFold("UnauthorizedClientException", errorCode):
    382 		return awsRestjson1_deserializeErrorUnauthorizedClientException(response, errorBody)
    383 
    384 	case strings.EqualFold("UnsupportedGrantTypeException", errorCode):
    385 		return awsRestjson1_deserializeErrorUnsupportedGrantTypeException(response, errorBody)
    386 
    387 	default:
    388 		genericError := &smithy.GenericAPIError{
    389 			Code:    errorCode,
    390 			Message: errorMessage,
    391 		}
    392 		return genericError
    393 
    394 	}
    395 }
    396 
    397 func awsRestjson1_deserializeOpDocumentCreateTokenWithIAMOutput(v **CreateTokenWithIAMOutput, value interface{}) error {
    398 	if v == nil {
    399 		return fmt.Errorf("unexpected nil of type %T", v)
    400 	}
    401 	if value == nil {
    402 		return nil
    403 	}
    404 
    405 	shape, ok := value.(map[string]interface{})
    406 	if !ok {
    407 		return fmt.Errorf("unexpected JSON type %v", value)
    408 	}
    409 
    410 	var sv *CreateTokenWithIAMOutput
    411 	if *v == nil {
    412 		sv = &CreateTokenWithIAMOutput{}
    413 	} else {
    414 		sv = *v
    415 	}
    416 
    417 	for key, value := range shape {
    418 		switch key {
    419 		case "accessToken":
    420 			if value != nil {
    421 				jtv, ok := value.(string)
    422 				if !ok {
    423 					return fmt.Errorf("expected AccessToken to be of type string, got %T instead", value)
    424 				}
    425 				sv.AccessToken = ptr.String(jtv)
    426 			}
    427 
    428 		case "awsAdditionalDetails":
    429 			if err := awsRestjson1_deserializeDocumentAwsAdditionalDetails(&sv.AwsAdditionalDetails, value); err != nil {
    430 				return err
    431 			}
    432 
    433 		case "expiresIn":
    434 			if value != nil {
    435 				jtv, ok := value.(json.Number)
    436 				if !ok {
    437 					return fmt.Errorf("expected ExpirationInSeconds to be json.Number, got %T instead", value)
    438 				}
    439 				i64, err := jtv.Int64()
    440 				if err != nil {
    441 					return err
    442 				}
    443 				sv.ExpiresIn = int32(i64)
    444 			}
    445 
    446 		case "idToken":
    447 			if value != nil {
    448 				jtv, ok := value.(string)
    449 				if !ok {
    450 					return fmt.Errorf("expected IdToken to be of type string, got %T instead", value)
    451 				}
    452 				sv.IdToken = ptr.String(jtv)
    453 			}
    454 
    455 		case "issuedTokenType":
    456 			if value != nil {
    457 				jtv, ok := value.(string)
    458 				if !ok {
    459 					return fmt.Errorf("expected TokenTypeURI to be of type string, got %T instead", value)
    460 				}
    461 				sv.IssuedTokenType = ptr.String(jtv)
    462 			}
    463 
    464 		case "refreshToken":
    465 			if value != nil {
    466 				jtv, ok := value.(string)
    467 				if !ok {
    468 					return fmt.Errorf("expected RefreshToken to be of type string, got %T instead", value)
    469 				}
    470 				sv.RefreshToken = ptr.String(jtv)
    471 			}
    472 
    473 		case "scope":
    474 			if err := awsRestjson1_deserializeDocumentScopes(&sv.Scope, value); err != nil {
    475 				return err
    476 			}
    477 
    478 		case "tokenType":
    479 			if value != nil {
    480 				jtv, ok := value.(string)
    481 				if !ok {
    482 					return fmt.Errorf("expected TokenType to be of type string, got %T instead", value)
    483 				}
    484 				sv.TokenType = ptr.String(jtv)
    485 			}
    486 
    487 		default:
    488 			_, _ = key, value
    489 
    490 		}
    491 	}
    492 	*v = sv
    493 	return nil
    494 }
    495 
    496 type awsRestjson1_deserializeOpRegisterClient struct {
    497 }
    498 
    499 func (*awsRestjson1_deserializeOpRegisterClient) ID() string {
    500 	return "OperationDeserializer"
    501 }
    502 
    503 func (m *awsRestjson1_deserializeOpRegisterClient) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    504 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
    505 ) {
    506 	out, metadata, err = next.HandleDeserialize(ctx, in)
    507 	if err != nil {
    508 		return out, metadata, err
    509 	}
    510 
    511 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
    512 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
    513 	defer endTimer()
    514 	defer span.End()
    515 	response, ok := out.RawResponse.(*smithyhttp.Response)
    516 	if !ok {
    517 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
    518 	}
    519 
    520 	if response.StatusCode < 200 || response.StatusCode >= 300 {
    521 		return out, metadata, awsRestjson1_deserializeOpErrorRegisterClient(response, &metadata)
    522 	}
    523 	output := &RegisterClientOutput{}
    524 	out.Result = output
    525 
    526 	var buff [1024]byte
    527 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    528 
    529 	body := io.TeeReader(response.Body, ringBuffer)
    530 
    531 	decoder := json.NewDecoder(body)
    532 	decoder.UseNumber()
    533 	var shape interface{}
    534 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
    535 		var snapshot bytes.Buffer
    536 		io.Copy(&snapshot, ringBuffer)
    537 		err = &smithy.DeserializationError{
    538 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    539 			Snapshot: snapshot.Bytes(),
    540 		}
    541 		return out, metadata, err
    542 	}
    543 
    544 	err = awsRestjson1_deserializeOpDocumentRegisterClientOutput(&output, shape)
    545 	if err != nil {
    546 		var snapshot bytes.Buffer
    547 		io.Copy(&snapshot, ringBuffer)
    548 		return out, metadata, &smithy.DeserializationError{
    549 			Err:      fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
    550 			Snapshot: snapshot.Bytes(),
    551 		}
    552 	}
    553 
    554 	span.End()
    555 	return out, metadata, err
    556 }
    557 
    558 func awsRestjson1_deserializeOpErrorRegisterClient(response *smithyhttp.Response, metadata *middleware.Metadata) error {
    559 	var errorBuffer bytes.Buffer
    560 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
    561 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
    562 	}
    563 	errorBody := bytes.NewReader(errorBuffer.Bytes())
    564 
    565 	errorCode := "UnknownError"
    566 	errorMessage := errorCode
    567 
    568 	headerCode := response.Header.Get("X-Amzn-ErrorType")
    569 	if len(headerCode) != 0 {
    570 		errorCode = restjson.SanitizeErrorCode(headerCode)
    571 	}
    572 
    573 	var buff [1024]byte
    574 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    575 
    576 	body := io.TeeReader(errorBody, ringBuffer)
    577 	decoder := json.NewDecoder(body)
    578 	decoder.UseNumber()
    579 	jsonCode, message, err := restjson.GetErrorInfo(decoder)
    580 	if err != nil {
    581 		var snapshot bytes.Buffer
    582 		io.Copy(&snapshot, ringBuffer)
    583 		err = &smithy.DeserializationError{
    584 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    585 			Snapshot: snapshot.Bytes(),
    586 		}
    587 		return err
    588 	}
    589 
    590 	errorBody.Seek(0, io.SeekStart)
    591 	if len(headerCode) == 0 && len(jsonCode) != 0 {
    592 		errorCode = restjson.SanitizeErrorCode(jsonCode)
    593 	}
    594 	if len(message) != 0 {
    595 		errorMessage = message
    596 	}
    597 
    598 	switch {
    599 	case strings.EqualFold("InternalServerException", errorCode):
    600 		return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
    601 
    602 	case strings.EqualFold("InvalidClientMetadataException", errorCode):
    603 		return awsRestjson1_deserializeErrorInvalidClientMetadataException(response, errorBody)
    604 
    605 	case strings.EqualFold("InvalidRedirectUriException", errorCode):
    606 		return awsRestjson1_deserializeErrorInvalidRedirectUriException(response, errorBody)
    607 
    608 	case strings.EqualFold("InvalidRequestException", errorCode):
    609 		return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
    610 
    611 	case strings.EqualFold("InvalidScopeException", errorCode):
    612 		return awsRestjson1_deserializeErrorInvalidScopeException(response, errorBody)
    613 
    614 	case strings.EqualFold("SlowDownException", errorCode):
    615 		return awsRestjson1_deserializeErrorSlowDownException(response, errorBody)
    616 
    617 	case strings.EqualFold("UnsupportedGrantTypeException", errorCode):
    618 		return awsRestjson1_deserializeErrorUnsupportedGrantTypeException(response, errorBody)
    619 
    620 	default:
    621 		genericError := &smithy.GenericAPIError{
    622 			Code:    errorCode,
    623 			Message: errorMessage,
    624 		}
    625 		return genericError
    626 
    627 	}
    628 }
    629 
    630 func awsRestjson1_deserializeOpDocumentRegisterClientOutput(v **RegisterClientOutput, value interface{}) error {
    631 	if v == nil {
    632 		return fmt.Errorf("unexpected nil of type %T", v)
    633 	}
    634 	if value == nil {
    635 		return nil
    636 	}
    637 
    638 	shape, ok := value.(map[string]interface{})
    639 	if !ok {
    640 		return fmt.Errorf("unexpected JSON type %v", value)
    641 	}
    642 
    643 	var sv *RegisterClientOutput
    644 	if *v == nil {
    645 		sv = &RegisterClientOutput{}
    646 	} else {
    647 		sv = *v
    648 	}
    649 
    650 	for key, value := range shape {
    651 		switch key {
    652 		case "authorizationEndpoint":
    653 			if value != nil {
    654 				jtv, ok := value.(string)
    655 				if !ok {
    656 					return fmt.Errorf("expected URI to be of type string, got %T instead", value)
    657 				}
    658 				sv.AuthorizationEndpoint = ptr.String(jtv)
    659 			}
    660 
    661 		case "clientId":
    662 			if value != nil {
    663 				jtv, ok := value.(string)
    664 				if !ok {
    665 					return fmt.Errorf("expected ClientId to be of type string, got %T instead", value)
    666 				}
    667 				sv.ClientId = ptr.String(jtv)
    668 			}
    669 
    670 		case "clientIdIssuedAt":
    671 			if value != nil {
    672 				jtv, ok := value.(json.Number)
    673 				if !ok {
    674 					return fmt.Errorf("expected LongTimeStampType to be json.Number, got %T instead", value)
    675 				}
    676 				i64, err := jtv.Int64()
    677 				if err != nil {
    678 					return err
    679 				}
    680 				sv.ClientIdIssuedAt = i64
    681 			}
    682 
    683 		case "clientSecret":
    684 			if value != nil {
    685 				jtv, ok := value.(string)
    686 				if !ok {
    687 					return fmt.Errorf("expected ClientSecret to be of type string, got %T instead", value)
    688 				}
    689 				sv.ClientSecret = ptr.String(jtv)
    690 			}
    691 
    692 		case "clientSecretExpiresAt":
    693 			if value != nil {
    694 				jtv, ok := value.(json.Number)
    695 				if !ok {
    696 					return fmt.Errorf("expected LongTimeStampType to be json.Number, got %T instead", value)
    697 				}
    698 				i64, err := jtv.Int64()
    699 				if err != nil {
    700 					return err
    701 				}
    702 				sv.ClientSecretExpiresAt = i64
    703 			}
    704 
    705 		case "tokenEndpoint":
    706 			if value != nil {
    707 				jtv, ok := value.(string)
    708 				if !ok {
    709 					return fmt.Errorf("expected URI to be of type string, got %T instead", value)
    710 				}
    711 				sv.TokenEndpoint = ptr.String(jtv)
    712 			}
    713 
    714 		default:
    715 			_, _ = key, value
    716 
    717 		}
    718 	}
    719 	*v = sv
    720 	return nil
    721 }
    722 
    723 type awsRestjson1_deserializeOpStartDeviceAuthorization struct {
    724 }
    725 
    726 func (*awsRestjson1_deserializeOpStartDeviceAuthorization) ID() string {
    727 	return "OperationDeserializer"
    728 }
    729 
    730 func (m *awsRestjson1_deserializeOpStartDeviceAuthorization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    731 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
    732 ) {
    733 	out, metadata, err = next.HandleDeserialize(ctx, in)
    734 	if err != nil {
    735 		return out, metadata, err
    736 	}
    737 
    738 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
    739 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
    740 	defer endTimer()
    741 	defer span.End()
    742 	response, ok := out.RawResponse.(*smithyhttp.Response)
    743 	if !ok {
    744 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
    745 	}
    746 
    747 	if response.StatusCode < 200 || response.StatusCode >= 300 {
    748 		return out, metadata, awsRestjson1_deserializeOpErrorStartDeviceAuthorization(response, &metadata)
    749 	}
    750 	output := &StartDeviceAuthorizationOutput{}
    751 	out.Result = output
    752 
    753 	var buff [1024]byte
    754 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    755 
    756 	body := io.TeeReader(response.Body, ringBuffer)
    757 
    758 	decoder := json.NewDecoder(body)
    759 	decoder.UseNumber()
    760 	var shape interface{}
    761 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
    762 		var snapshot bytes.Buffer
    763 		io.Copy(&snapshot, ringBuffer)
    764 		err = &smithy.DeserializationError{
    765 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    766 			Snapshot: snapshot.Bytes(),
    767 		}
    768 		return out, metadata, err
    769 	}
    770 
    771 	err = awsRestjson1_deserializeOpDocumentStartDeviceAuthorizationOutput(&output, shape)
    772 	if err != nil {
    773 		var snapshot bytes.Buffer
    774 		io.Copy(&snapshot, ringBuffer)
    775 		return out, metadata, &smithy.DeserializationError{
    776 			Err:      fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
    777 			Snapshot: snapshot.Bytes(),
    778 		}
    779 	}
    780 
    781 	span.End()
    782 	return out, metadata, err
    783 }
    784 
    785 func awsRestjson1_deserializeOpErrorStartDeviceAuthorization(response *smithyhttp.Response, metadata *middleware.Metadata) error {
    786 	var errorBuffer bytes.Buffer
    787 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
    788 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
    789 	}
    790 	errorBody := bytes.NewReader(errorBuffer.Bytes())
    791 
    792 	errorCode := "UnknownError"
    793 	errorMessage := errorCode
    794 
    795 	headerCode := response.Header.Get("X-Amzn-ErrorType")
    796 	if len(headerCode) != 0 {
    797 		errorCode = restjson.SanitizeErrorCode(headerCode)
    798 	}
    799 
    800 	var buff [1024]byte
    801 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    802 
    803 	body := io.TeeReader(errorBody, ringBuffer)
    804 	decoder := json.NewDecoder(body)
    805 	decoder.UseNumber()
    806 	jsonCode, message, err := restjson.GetErrorInfo(decoder)
    807 	if err != nil {
    808 		var snapshot bytes.Buffer
    809 		io.Copy(&snapshot, ringBuffer)
    810 		err = &smithy.DeserializationError{
    811 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    812 			Snapshot: snapshot.Bytes(),
    813 		}
    814 		return err
    815 	}
    816 
    817 	errorBody.Seek(0, io.SeekStart)
    818 	if len(headerCode) == 0 && len(jsonCode) != 0 {
    819 		errorCode = restjson.SanitizeErrorCode(jsonCode)
    820 	}
    821 	if len(message) != 0 {
    822 		errorMessage = message
    823 	}
    824 
    825 	switch {
    826 	case strings.EqualFold("InternalServerException", errorCode):
    827 		return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
    828 
    829 	case strings.EqualFold("InvalidClientException", errorCode):
    830 		return awsRestjson1_deserializeErrorInvalidClientException(response, errorBody)
    831 
    832 	case strings.EqualFold("InvalidRequestException", errorCode):
    833 		return awsRestjson1_deserializeErrorInvalidRequestException(response, errorBody)
    834 
    835 	case strings.EqualFold("SlowDownException", errorCode):
    836 		return awsRestjson1_deserializeErrorSlowDownException(response, errorBody)
    837 
    838 	case strings.EqualFold("UnauthorizedClientException", errorCode):
    839 		return awsRestjson1_deserializeErrorUnauthorizedClientException(response, errorBody)
    840 
    841 	default:
    842 		genericError := &smithy.GenericAPIError{
    843 			Code:    errorCode,
    844 			Message: errorMessage,
    845 		}
    846 		return genericError
    847 
    848 	}
    849 }
    850 
    851 func awsRestjson1_deserializeOpDocumentStartDeviceAuthorizationOutput(v **StartDeviceAuthorizationOutput, value interface{}) error {
    852 	if v == nil {
    853 		return fmt.Errorf("unexpected nil of type %T", v)
    854 	}
    855 	if value == nil {
    856 		return nil
    857 	}
    858 
    859 	shape, ok := value.(map[string]interface{})
    860 	if !ok {
    861 		return fmt.Errorf("unexpected JSON type %v", value)
    862 	}
    863 
    864 	var sv *StartDeviceAuthorizationOutput
    865 	if *v == nil {
    866 		sv = &StartDeviceAuthorizationOutput{}
    867 	} else {
    868 		sv = *v
    869 	}
    870 
    871 	for key, value := range shape {
    872 		switch key {
    873 		case "deviceCode":
    874 			if value != nil {
    875 				jtv, ok := value.(string)
    876 				if !ok {
    877 					return fmt.Errorf("expected DeviceCode to be of type string, got %T instead", value)
    878 				}
    879 				sv.DeviceCode = ptr.String(jtv)
    880 			}
    881 
    882 		case "expiresIn":
    883 			if value != nil {
    884 				jtv, ok := value.(json.Number)
    885 				if !ok {
    886 					return fmt.Errorf("expected ExpirationInSeconds to be json.Number, got %T instead", value)
    887 				}
    888 				i64, err := jtv.Int64()
    889 				if err != nil {
    890 					return err
    891 				}
    892 				sv.ExpiresIn = int32(i64)
    893 			}
    894 
    895 		case "interval":
    896 			if value != nil {
    897 				jtv, ok := value.(json.Number)
    898 				if !ok {
    899 					return fmt.Errorf("expected IntervalInSeconds to be json.Number, got %T instead", value)
    900 				}
    901 				i64, err := jtv.Int64()
    902 				if err != nil {
    903 					return err
    904 				}
    905 				sv.Interval = int32(i64)
    906 			}
    907 
    908 		case "userCode":
    909 			if value != nil {
    910 				jtv, ok := value.(string)
    911 				if !ok {
    912 					return fmt.Errorf("expected UserCode to be of type string, got %T instead", value)
    913 				}
    914 				sv.UserCode = ptr.String(jtv)
    915 			}
    916 
    917 		case "verificationUri":
    918 			if value != nil {
    919 				jtv, ok := value.(string)
    920 				if !ok {
    921 					return fmt.Errorf("expected URI to be of type string, got %T instead", value)
    922 				}
    923 				sv.VerificationUri = ptr.String(jtv)
    924 			}
    925 
    926 		case "verificationUriComplete":
    927 			if value != nil {
    928 				jtv, ok := value.(string)
    929 				if !ok {
    930 					return fmt.Errorf("expected URI to be of type string, got %T instead", value)
    931 				}
    932 				sv.VerificationUriComplete = ptr.String(jtv)
    933 			}
    934 
    935 		default:
    936 			_, _ = key, value
    937 
    938 		}
    939 	}
    940 	*v = sv
    941 	return nil
    942 }
    943 
    944 func awsRestjson1_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
    945 	output := &types.AccessDeniedException{}
    946 	var buff [1024]byte
    947 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    948 
    949 	body := io.TeeReader(errorBody, ringBuffer)
    950 	decoder := json.NewDecoder(body)
    951 	decoder.UseNumber()
    952 	var shape interface{}
    953 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
    954 		var snapshot bytes.Buffer
    955 		io.Copy(&snapshot, ringBuffer)
    956 		err = &smithy.DeserializationError{
    957 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    958 			Snapshot: snapshot.Bytes(),
    959 		}
    960 		return err
    961 	}
    962 
    963 	err := awsRestjson1_deserializeDocumentAccessDeniedException(&output, shape)
    964 
    965 	if err != nil {
    966 		var snapshot bytes.Buffer
    967 		io.Copy(&snapshot, ringBuffer)
    968 		err = &smithy.DeserializationError{
    969 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    970 			Snapshot: snapshot.Bytes(),
    971 		}
    972 		return err
    973 	}
    974 
    975 	errorBody.Seek(0, io.SeekStart)
    976 
    977 	return output
    978 }
    979 
    980 func awsRestjson1_deserializeErrorAuthorizationPendingException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
    981 	output := &types.AuthorizationPendingException{}
    982 	var buff [1024]byte
    983 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    984 
    985 	body := io.TeeReader(errorBody, ringBuffer)
    986 	decoder := json.NewDecoder(body)
    987 	decoder.UseNumber()
    988 	var shape interface{}
    989 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
    990 		var snapshot bytes.Buffer
    991 		io.Copy(&snapshot, ringBuffer)
    992 		err = &smithy.DeserializationError{
    993 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    994 			Snapshot: snapshot.Bytes(),
    995 		}
    996 		return err
    997 	}
    998 
    999 	err := awsRestjson1_deserializeDocumentAuthorizationPendingException(&output, shape)
   1000 
   1001 	if err != nil {
   1002 		var snapshot bytes.Buffer
   1003 		io.Copy(&snapshot, ringBuffer)
   1004 		err = &smithy.DeserializationError{
   1005 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1006 			Snapshot: snapshot.Bytes(),
   1007 		}
   1008 		return err
   1009 	}
   1010 
   1011 	errorBody.Seek(0, io.SeekStart)
   1012 
   1013 	return output
   1014 }
   1015 
   1016 func awsRestjson1_deserializeErrorExpiredTokenException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
   1017 	output := &types.ExpiredTokenException{}
   1018 	var buff [1024]byte
   1019 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1020 
   1021 	body := io.TeeReader(errorBody, ringBuffer)
   1022 	decoder := json.NewDecoder(body)
   1023 	decoder.UseNumber()
   1024 	var shape interface{}
   1025 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
   1026 		var snapshot bytes.Buffer
   1027 		io.Copy(&snapshot, ringBuffer)
   1028 		err = &smithy.DeserializationError{
   1029 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1030 			Snapshot: snapshot.Bytes(),
   1031 		}
   1032 		return err
   1033 	}
   1034 
   1035 	err := awsRestjson1_deserializeDocumentExpiredTokenException(&output, shape)
   1036 
   1037 	if err != nil {
   1038 		var snapshot bytes.Buffer
   1039 		io.Copy(&snapshot, ringBuffer)
   1040 		err = &smithy.DeserializationError{
   1041 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1042 			Snapshot: snapshot.Bytes(),
   1043 		}
   1044 		return err
   1045 	}
   1046 
   1047 	errorBody.Seek(0, io.SeekStart)
   1048 
   1049 	return output
   1050 }
   1051 
   1052 func awsRestjson1_deserializeErrorInternalServerException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
   1053 	output := &types.InternalServerException{}
   1054 	var buff [1024]byte
   1055 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1056 
   1057 	body := io.TeeReader(errorBody, ringBuffer)
   1058 	decoder := json.NewDecoder(body)
   1059 	decoder.UseNumber()
   1060 	var shape interface{}
   1061 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
   1062 		var snapshot bytes.Buffer
   1063 		io.Copy(&snapshot, ringBuffer)
   1064 		err = &smithy.DeserializationError{
   1065 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1066 			Snapshot: snapshot.Bytes(),
   1067 		}
   1068 		return err
   1069 	}
   1070 
   1071 	err := awsRestjson1_deserializeDocumentInternalServerException(&output, shape)
   1072 
   1073 	if err != nil {
   1074 		var snapshot bytes.Buffer
   1075 		io.Copy(&snapshot, ringBuffer)
   1076 		err = &smithy.DeserializationError{
   1077 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1078 			Snapshot: snapshot.Bytes(),
   1079 		}
   1080 		return err
   1081 	}
   1082 
   1083 	errorBody.Seek(0, io.SeekStart)
   1084 
   1085 	return output
   1086 }
   1087 
   1088 func awsRestjson1_deserializeErrorInvalidClientException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
   1089 	output := &types.InvalidClientException{}
   1090 	var buff [1024]byte
   1091 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1092 
   1093 	body := io.TeeReader(errorBody, ringBuffer)
   1094 	decoder := json.NewDecoder(body)
   1095 	decoder.UseNumber()
   1096 	var shape interface{}
   1097 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
   1098 		var snapshot bytes.Buffer
   1099 		io.Copy(&snapshot, ringBuffer)
   1100 		err = &smithy.DeserializationError{
   1101 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1102 			Snapshot: snapshot.Bytes(),
   1103 		}
   1104 		return err
   1105 	}
   1106 
   1107 	err := awsRestjson1_deserializeDocumentInvalidClientException(&output, shape)
   1108 
   1109 	if err != nil {
   1110 		var snapshot bytes.Buffer
   1111 		io.Copy(&snapshot, ringBuffer)
   1112 		err = &smithy.DeserializationError{
   1113 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1114 			Snapshot: snapshot.Bytes(),
   1115 		}
   1116 		return err
   1117 	}
   1118 
   1119 	errorBody.Seek(0, io.SeekStart)
   1120 
   1121 	return output
   1122 }
   1123 
   1124 func awsRestjson1_deserializeErrorInvalidClientMetadataException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
   1125 	output := &types.InvalidClientMetadataException{}
   1126 	var buff [1024]byte
   1127 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1128 
   1129 	body := io.TeeReader(errorBody, ringBuffer)
   1130 	decoder := json.NewDecoder(body)
   1131 	decoder.UseNumber()
   1132 	var shape interface{}
   1133 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
   1134 		var snapshot bytes.Buffer
   1135 		io.Copy(&snapshot, ringBuffer)
   1136 		err = &smithy.DeserializationError{
   1137 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1138 			Snapshot: snapshot.Bytes(),
   1139 		}
   1140 		return err
   1141 	}
   1142 
   1143 	err := awsRestjson1_deserializeDocumentInvalidClientMetadataException(&output, shape)
   1144 
   1145 	if err != nil {
   1146 		var snapshot bytes.Buffer
   1147 		io.Copy(&snapshot, ringBuffer)
   1148 		err = &smithy.DeserializationError{
   1149 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1150 			Snapshot: snapshot.Bytes(),
   1151 		}
   1152 		return err
   1153 	}
   1154 
   1155 	errorBody.Seek(0, io.SeekStart)
   1156 
   1157 	return output
   1158 }
   1159 
   1160 func awsRestjson1_deserializeErrorInvalidGrantException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
   1161 	output := &types.InvalidGrantException{}
   1162 	var buff [1024]byte
   1163 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1164 
   1165 	body := io.TeeReader(errorBody, ringBuffer)
   1166 	decoder := json.NewDecoder(body)
   1167 	decoder.UseNumber()
   1168 	var shape interface{}
   1169 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
   1170 		var snapshot bytes.Buffer
   1171 		io.Copy(&snapshot, ringBuffer)
   1172 		err = &smithy.DeserializationError{
   1173 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1174 			Snapshot: snapshot.Bytes(),
   1175 		}
   1176 		return err
   1177 	}
   1178 
   1179 	err := awsRestjson1_deserializeDocumentInvalidGrantException(&output, shape)
   1180 
   1181 	if err != nil {
   1182 		var snapshot bytes.Buffer
   1183 		io.Copy(&snapshot, ringBuffer)
   1184 		err = &smithy.DeserializationError{
   1185 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1186 			Snapshot: snapshot.Bytes(),
   1187 		}
   1188 		return err
   1189 	}
   1190 
   1191 	errorBody.Seek(0, io.SeekStart)
   1192 
   1193 	return output
   1194 }
   1195 
   1196 func awsRestjson1_deserializeErrorInvalidRedirectUriException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
   1197 	output := &types.InvalidRedirectUriException{}
   1198 	var buff [1024]byte
   1199 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1200 
   1201 	body := io.TeeReader(errorBody, ringBuffer)
   1202 	decoder := json.NewDecoder(body)
   1203 	decoder.UseNumber()
   1204 	var shape interface{}
   1205 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
   1206 		var snapshot bytes.Buffer
   1207 		io.Copy(&snapshot, ringBuffer)
   1208 		err = &smithy.DeserializationError{
   1209 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1210 			Snapshot: snapshot.Bytes(),
   1211 		}
   1212 		return err
   1213 	}
   1214 
   1215 	err := awsRestjson1_deserializeDocumentInvalidRedirectUriException(&output, shape)
   1216 
   1217 	if err != nil {
   1218 		var snapshot bytes.Buffer
   1219 		io.Copy(&snapshot, ringBuffer)
   1220 		err = &smithy.DeserializationError{
   1221 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1222 			Snapshot: snapshot.Bytes(),
   1223 		}
   1224 		return err
   1225 	}
   1226 
   1227 	errorBody.Seek(0, io.SeekStart)
   1228 
   1229 	return output
   1230 }
   1231 
   1232 func awsRestjson1_deserializeErrorInvalidRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
   1233 	output := &types.InvalidRequestException{}
   1234 	var buff [1024]byte
   1235 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1236 
   1237 	body := io.TeeReader(errorBody, ringBuffer)
   1238 	decoder := json.NewDecoder(body)
   1239 	decoder.UseNumber()
   1240 	var shape interface{}
   1241 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
   1242 		var snapshot bytes.Buffer
   1243 		io.Copy(&snapshot, ringBuffer)
   1244 		err = &smithy.DeserializationError{
   1245 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1246 			Snapshot: snapshot.Bytes(),
   1247 		}
   1248 		return err
   1249 	}
   1250 
   1251 	err := awsRestjson1_deserializeDocumentInvalidRequestException(&output, shape)
   1252 
   1253 	if err != nil {
   1254 		var snapshot bytes.Buffer
   1255 		io.Copy(&snapshot, ringBuffer)
   1256 		err = &smithy.DeserializationError{
   1257 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1258 			Snapshot: snapshot.Bytes(),
   1259 		}
   1260 		return err
   1261 	}
   1262 
   1263 	errorBody.Seek(0, io.SeekStart)
   1264 
   1265 	return output
   1266 }
   1267 
   1268 func awsRestjson1_deserializeErrorInvalidRequestRegionException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
   1269 	output := &types.InvalidRequestRegionException{}
   1270 	var buff [1024]byte
   1271 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1272 
   1273 	body := io.TeeReader(errorBody, ringBuffer)
   1274 	decoder := json.NewDecoder(body)
   1275 	decoder.UseNumber()
   1276 	var shape interface{}
   1277 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
   1278 		var snapshot bytes.Buffer
   1279 		io.Copy(&snapshot, ringBuffer)
   1280 		err = &smithy.DeserializationError{
   1281 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1282 			Snapshot: snapshot.Bytes(),
   1283 		}
   1284 		return err
   1285 	}
   1286 
   1287 	err := awsRestjson1_deserializeDocumentInvalidRequestRegionException(&output, shape)
   1288 
   1289 	if err != nil {
   1290 		var snapshot bytes.Buffer
   1291 		io.Copy(&snapshot, ringBuffer)
   1292 		err = &smithy.DeserializationError{
   1293 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1294 			Snapshot: snapshot.Bytes(),
   1295 		}
   1296 		return err
   1297 	}
   1298 
   1299 	errorBody.Seek(0, io.SeekStart)
   1300 
   1301 	return output
   1302 }
   1303 
   1304 func awsRestjson1_deserializeErrorInvalidScopeException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
   1305 	output := &types.InvalidScopeException{}
   1306 	var buff [1024]byte
   1307 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1308 
   1309 	body := io.TeeReader(errorBody, ringBuffer)
   1310 	decoder := json.NewDecoder(body)
   1311 	decoder.UseNumber()
   1312 	var shape interface{}
   1313 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
   1314 		var snapshot bytes.Buffer
   1315 		io.Copy(&snapshot, ringBuffer)
   1316 		err = &smithy.DeserializationError{
   1317 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1318 			Snapshot: snapshot.Bytes(),
   1319 		}
   1320 		return err
   1321 	}
   1322 
   1323 	err := awsRestjson1_deserializeDocumentInvalidScopeException(&output, shape)
   1324 
   1325 	if err != nil {
   1326 		var snapshot bytes.Buffer
   1327 		io.Copy(&snapshot, ringBuffer)
   1328 		err = &smithy.DeserializationError{
   1329 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1330 			Snapshot: snapshot.Bytes(),
   1331 		}
   1332 		return err
   1333 	}
   1334 
   1335 	errorBody.Seek(0, io.SeekStart)
   1336 
   1337 	return output
   1338 }
   1339 
   1340 func awsRestjson1_deserializeErrorSlowDownException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
   1341 	output := &types.SlowDownException{}
   1342 	var buff [1024]byte
   1343 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1344 
   1345 	body := io.TeeReader(errorBody, ringBuffer)
   1346 	decoder := json.NewDecoder(body)
   1347 	decoder.UseNumber()
   1348 	var shape interface{}
   1349 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
   1350 		var snapshot bytes.Buffer
   1351 		io.Copy(&snapshot, ringBuffer)
   1352 		err = &smithy.DeserializationError{
   1353 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1354 			Snapshot: snapshot.Bytes(),
   1355 		}
   1356 		return err
   1357 	}
   1358 
   1359 	err := awsRestjson1_deserializeDocumentSlowDownException(&output, shape)
   1360 
   1361 	if err != nil {
   1362 		var snapshot bytes.Buffer
   1363 		io.Copy(&snapshot, ringBuffer)
   1364 		err = &smithy.DeserializationError{
   1365 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1366 			Snapshot: snapshot.Bytes(),
   1367 		}
   1368 		return err
   1369 	}
   1370 
   1371 	errorBody.Seek(0, io.SeekStart)
   1372 
   1373 	return output
   1374 }
   1375 
   1376 func awsRestjson1_deserializeErrorUnauthorizedClientException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
   1377 	output := &types.UnauthorizedClientException{}
   1378 	var buff [1024]byte
   1379 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1380 
   1381 	body := io.TeeReader(errorBody, ringBuffer)
   1382 	decoder := json.NewDecoder(body)
   1383 	decoder.UseNumber()
   1384 	var shape interface{}
   1385 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
   1386 		var snapshot bytes.Buffer
   1387 		io.Copy(&snapshot, ringBuffer)
   1388 		err = &smithy.DeserializationError{
   1389 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1390 			Snapshot: snapshot.Bytes(),
   1391 		}
   1392 		return err
   1393 	}
   1394 
   1395 	err := awsRestjson1_deserializeDocumentUnauthorizedClientException(&output, shape)
   1396 
   1397 	if err != nil {
   1398 		var snapshot bytes.Buffer
   1399 		io.Copy(&snapshot, ringBuffer)
   1400 		err = &smithy.DeserializationError{
   1401 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1402 			Snapshot: snapshot.Bytes(),
   1403 		}
   1404 		return err
   1405 	}
   1406 
   1407 	errorBody.Seek(0, io.SeekStart)
   1408 
   1409 	return output
   1410 }
   1411 
   1412 func awsRestjson1_deserializeErrorUnsupportedGrantTypeException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
   1413 	output := &types.UnsupportedGrantTypeException{}
   1414 	var buff [1024]byte
   1415 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1416 
   1417 	body := io.TeeReader(errorBody, ringBuffer)
   1418 	decoder := json.NewDecoder(body)
   1419 	decoder.UseNumber()
   1420 	var shape interface{}
   1421 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
   1422 		var snapshot bytes.Buffer
   1423 		io.Copy(&snapshot, ringBuffer)
   1424 		err = &smithy.DeserializationError{
   1425 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1426 			Snapshot: snapshot.Bytes(),
   1427 		}
   1428 		return err
   1429 	}
   1430 
   1431 	err := awsRestjson1_deserializeDocumentUnsupportedGrantTypeException(&output, shape)
   1432 
   1433 	if err != nil {
   1434 		var snapshot bytes.Buffer
   1435 		io.Copy(&snapshot, ringBuffer)
   1436 		err = &smithy.DeserializationError{
   1437 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1438 			Snapshot: snapshot.Bytes(),
   1439 		}
   1440 		return err
   1441 	}
   1442 
   1443 	errorBody.Seek(0, io.SeekStart)
   1444 
   1445 	return output
   1446 }
   1447 
   1448 func awsRestjson1_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error {
   1449 	if v == nil {
   1450 		return fmt.Errorf("unexpected nil of type %T", v)
   1451 	}
   1452 	if value == nil {
   1453 		return nil
   1454 	}
   1455 
   1456 	shape, ok := value.(map[string]interface{})
   1457 	if !ok {
   1458 		return fmt.Errorf("unexpected JSON type %v", value)
   1459 	}
   1460 
   1461 	var sv *types.AccessDeniedException
   1462 	if *v == nil {
   1463 		sv = &types.AccessDeniedException{}
   1464 	} else {
   1465 		sv = *v
   1466 	}
   1467 
   1468 	for key, value := range shape {
   1469 		switch key {
   1470 		case "error":
   1471 			if value != nil {
   1472 				jtv, ok := value.(string)
   1473 				if !ok {
   1474 					return fmt.Errorf("expected Error to be of type string, got %T instead", value)
   1475 				}
   1476 				sv.Error_ = ptr.String(jtv)
   1477 			}
   1478 
   1479 		case "error_description":
   1480 			if value != nil {
   1481 				jtv, ok := value.(string)
   1482 				if !ok {
   1483 					return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
   1484 				}
   1485 				sv.Error_description = ptr.String(jtv)
   1486 			}
   1487 
   1488 		case "reason":
   1489 			if value != nil {
   1490 				jtv, ok := value.(string)
   1491 				if !ok {
   1492 					return fmt.Errorf("expected AccessDeniedExceptionReason to be of type string, got %T instead", value)
   1493 				}
   1494 				sv.Reason = types.AccessDeniedExceptionReason(jtv)
   1495 			}
   1496 
   1497 		default:
   1498 			_, _ = key, value
   1499 
   1500 		}
   1501 	}
   1502 	*v = sv
   1503 	return nil
   1504 }
   1505 
   1506 func awsRestjson1_deserializeDocumentAuthorizationPendingException(v **types.AuthorizationPendingException, value interface{}) error {
   1507 	if v == nil {
   1508 		return fmt.Errorf("unexpected nil of type %T", v)
   1509 	}
   1510 	if value == nil {
   1511 		return nil
   1512 	}
   1513 
   1514 	shape, ok := value.(map[string]interface{})
   1515 	if !ok {
   1516 		return fmt.Errorf("unexpected JSON type %v", value)
   1517 	}
   1518 
   1519 	var sv *types.AuthorizationPendingException
   1520 	if *v == nil {
   1521 		sv = &types.AuthorizationPendingException{}
   1522 	} else {
   1523 		sv = *v
   1524 	}
   1525 
   1526 	for key, value := range shape {
   1527 		switch key {
   1528 		case "error":
   1529 			if value != nil {
   1530 				jtv, ok := value.(string)
   1531 				if !ok {
   1532 					return fmt.Errorf("expected Error to be of type string, got %T instead", value)
   1533 				}
   1534 				sv.Error_ = ptr.String(jtv)
   1535 			}
   1536 
   1537 		case "error_description":
   1538 			if value != nil {
   1539 				jtv, ok := value.(string)
   1540 				if !ok {
   1541 					return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
   1542 				}
   1543 				sv.Error_description = ptr.String(jtv)
   1544 			}
   1545 
   1546 		default:
   1547 			_, _ = key, value
   1548 
   1549 		}
   1550 	}
   1551 	*v = sv
   1552 	return nil
   1553 }
   1554 
   1555 func awsRestjson1_deserializeDocumentAwsAdditionalDetails(v **types.AwsAdditionalDetails, value interface{}) error {
   1556 	if v == nil {
   1557 		return fmt.Errorf("unexpected nil of type %T", v)
   1558 	}
   1559 	if value == nil {
   1560 		return nil
   1561 	}
   1562 
   1563 	shape, ok := value.(map[string]interface{})
   1564 	if !ok {
   1565 		return fmt.Errorf("unexpected JSON type %v", value)
   1566 	}
   1567 
   1568 	var sv *types.AwsAdditionalDetails
   1569 	if *v == nil {
   1570 		sv = &types.AwsAdditionalDetails{}
   1571 	} else {
   1572 		sv = *v
   1573 	}
   1574 
   1575 	for key, value := range shape {
   1576 		switch key {
   1577 		case "identityContext":
   1578 			if value != nil {
   1579 				jtv, ok := value.(string)
   1580 				if !ok {
   1581 					return fmt.Errorf("expected IdentityContext to be of type string, got %T instead", value)
   1582 				}
   1583 				sv.IdentityContext = ptr.String(jtv)
   1584 			}
   1585 
   1586 		default:
   1587 			_, _ = key, value
   1588 
   1589 		}
   1590 	}
   1591 	*v = sv
   1592 	return nil
   1593 }
   1594 
   1595 func awsRestjson1_deserializeDocumentExpiredTokenException(v **types.ExpiredTokenException, value interface{}) error {
   1596 	if v == nil {
   1597 		return fmt.Errorf("unexpected nil of type %T", v)
   1598 	}
   1599 	if value == nil {
   1600 		return nil
   1601 	}
   1602 
   1603 	shape, ok := value.(map[string]interface{})
   1604 	if !ok {
   1605 		return fmt.Errorf("unexpected JSON type %v", value)
   1606 	}
   1607 
   1608 	var sv *types.ExpiredTokenException
   1609 	if *v == nil {
   1610 		sv = &types.ExpiredTokenException{}
   1611 	} else {
   1612 		sv = *v
   1613 	}
   1614 
   1615 	for key, value := range shape {
   1616 		switch key {
   1617 		case "error":
   1618 			if value != nil {
   1619 				jtv, ok := value.(string)
   1620 				if !ok {
   1621 					return fmt.Errorf("expected Error to be of type string, got %T instead", value)
   1622 				}
   1623 				sv.Error_ = ptr.String(jtv)
   1624 			}
   1625 
   1626 		case "error_description":
   1627 			if value != nil {
   1628 				jtv, ok := value.(string)
   1629 				if !ok {
   1630 					return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
   1631 				}
   1632 				sv.Error_description = ptr.String(jtv)
   1633 			}
   1634 
   1635 		default:
   1636 			_, _ = key, value
   1637 
   1638 		}
   1639 	}
   1640 	*v = sv
   1641 	return nil
   1642 }
   1643 
   1644 func awsRestjson1_deserializeDocumentInternalServerException(v **types.InternalServerException, value interface{}) error {
   1645 	if v == nil {
   1646 		return fmt.Errorf("unexpected nil of type %T", v)
   1647 	}
   1648 	if value == nil {
   1649 		return nil
   1650 	}
   1651 
   1652 	shape, ok := value.(map[string]interface{})
   1653 	if !ok {
   1654 		return fmt.Errorf("unexpected JSON type %v", value)
   1655 	}
   1656 
   1657 	var sv *types.InternalServerException
   1658 	if *v == nil {
   1659 		sv = &types.InternalServerException{}
   1660 	} else {
   1661 		sv = *v
   1662 	}
   1663 
   1664 	for key, value := range shape {
   1665 		switch key {
   1666 		case "error":
   1667 			if value != nil {
   1668 				jtv, ok := value.(string)
   1669 				if !ok {
   1670 					return fmt.Errorf("expected Error to be of type string, got %T instead", value)
   1671 				}
   1672 				sv.Error_ = ptr.String(jtv)
   1673 			}
   1674 
   1675 		case "error_description":
   1676 			if value != nil {
   1677 				jtv, ok := value.(string)
   1678 				if !ok {
   1679 					return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
   1680 				}
   1681 				sv.Error_description = ptr.String(jtv)
   1682 			}
   1683 
   1684 		default:
   1685 			_, _ = key, value
   1686 
   1687 		}
   1688 	}
   1689 	*v = sv
   1690 	return nil
   1691 }
   1692 
   1693 func awsRestjson1_deserializeDocumentInvalidClientException(v **types.InvalidClientException, value interface{}) error {
   1694 	if v == nil {
   1695 		return fmt.Errorf("unexpected nil of type %T", v)
   1696 	}
   1697 	if value == nil {
   1698 		return nil
   1699 	}
   1700 
   1701 	shape, ok := value.(map[string]interface{})
   1702 	if !ok {
   1703 		return fmt.Errorf("unexpected JSON type %v", value)
   1704 	}
   1705 
   1706 	var sv *types.InvalidClientException
   1707 	if *v == nil {
   1708 		sv = &types.InvalidClientException{}
   1709 	} else {
   1710 		sv = *v
   1711 	}
   1712 
   1713 	for key, value := range shape {
   1714 		switch key {
   1715 		case "error":
   1716 			if value != nil {
   1717 				jtv, ok := value.(string)
   1718 				if !ok {
   1719 					return fmt.Errorf("expected Error to be of type string, got %T instead", value)
   1720 				}
   1721 				sv.Error_ = ptr.String(jtv)
   1722 			}
   1723 
   1724 		case "error_description":
   1725 			if value != nil {
   1726 				jtv, ok := value.(string)
   1727 				if !ok {
   1728 					return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
   1729 				}
   1730 				sv.Error_description = ptr.String(jtv)
   1731 			}
   1732 
   1733 		default:
   1734 			_, _ = key, value
   1735 
   1736 		}
   1737 	}
   1738 	*v = sv
   1739 	return nil
   1740 }
   1741 
   1742 func awsRestjson1_deserializeDocumentInvalidClientMetadataException(v **types.InvalidClientMetadataException, value interface{}) error {
   1743 	if v == nil {
   1744 		return fmt.Errorf("unexpected nil of type %T", v)
   1745 	}
   1746 	if value == nil {
   1747 		return nil
   1748 	}
   1749 
   1750 	shape, ok := value.(map[string]interface{})
   1751 	if !ok {
   1752 		return fmt.Errorf("unexpected JSON type %v", value)
   1753 	}
   1754 
   1755 	var sv *types.InvalidClientMetadataException
   1756 	if *v == nil {
   1757 		sv = &types.InvalidClientMetadataException{}
   1758 	} else {
   1759 		sv = *v
   1760 	}
   1761 
   1762 	for key, value := range shape {
   1763 		switch key {
   1764 		case "error":
   1765 			if value != nil {
   1766 				jtv, ok := value.(string)
   1767 				if !ok {
   1768 					return fmt.Errorf("expected Error to be of type string, got %T instead", value)
   1769 				}
   1770 				sv.Error_ = ptr.String(jtv)
   1771 			}
   1772 
   1773 		case "error_description":
   1774 			if value != nil {
   1775 				jtv, ok := value.(string)
   1776 				if !ok {
   1777 					return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
   1778 				}
   1779 				sv.Error_description = ptr.String(jtv)
   1780 			}
   1781 
   1782 		default:
   1783 			_, _ = key, value
   1784 
   1785 		}
   1786 	}
   1787 	*v = sv
   1788 	return nil
   1789 }
   1790 
   1791 func awsRestjson1_deserializeDocumentInvalidGrantException(v **types.InvalidGrantException, value interface{}) error {
   1792 	if v == nil {
   1793 		return fmt.Errorf("unexpected nil of type %T", v)
   1794 	}
   1795 	if value == nil {
   1796 		return nil
   1797 	}
   1798 
   1799 	shape, ok := value.(map[string]interface{})
   1800 	if !ok {
   1801 		return fmt.Errorf("unexpected JSON type %v", value)
   1802 	}
   1803 
   1804 	var sv *types.InvalidGrantException
   1805 	if *v == nil {
   1806 		sv = &types.InvalidGrantException{}
   1807 	} else {
   1808 		sv = *v
   1809 	}
   1810 
   1811 	for key, value := range shape {
   1812 		switch key {
   1813 		case "error":
   1814 			if value != nil {
   1815 				jtv, ok := value.(string)
   1816 				if !ok {
   1817 					return fmt.Errorf("expected Error to be of type string, got %T instead", value)
   1818 				}
   1819 				sv.Error_ = ptr.String(jtv)
   1820 			}
   1821 
   1822 		case "error_description":
   1823 			if value != nil {
   1824 				jtv, ok := value.(string)
   1825 				if !ok {
   1826 					return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
   1827 				}
   1828 				sv.Error_description = ptr.String(jtv)
   1829 			}
   1830 
   1831 		default:
   1832 			_, _ = key, value
   1833 
   1834 		}
   1835 	}
   1836 	*v = sv
   1837 	return nil
   1838 }
   1839 
   1840 func awsRestjson1_deserializeDocumentInvalidRedirectUriException(v **types.InvalidRedirectUriException, value interface{}) error {
   1841 	if v == nil {
   1842 		return fmt.Errorf("unexpected nil of type %T", v)
   1843 	}
   1844 	if value == nil {
   1845 		return nil
   1846 	}
   1847 
   1848 	shape, ok := value.(map[string]interface{})
   1849 	if !ok {
   1850 		return fmt.Errorf("unexpected JSON type %v", value)
   1851 	}
   1852 
   1853 	var sv *types.InvalidRedirectUriException
   1854 	if *v == nil {
   1855 		sv = &types.InvalidRedirectUriException{}
   1856 	} else {
   1857 		sv = *v
   1858 	}
   1859 
   1860 	for key, value := range shape {
   1861 		switch key {
   1862 		case "error":
   1863 			if value != nil {
   1864 				jtv, ok := value.(string)
   1865 				if !ok {
   1866 					return fmt.Errorf("expected Error to be of type string, got %T instead", value)
   1867 				}
   1868 				sv.Error_ = ptr.String(jtv)
   1869 			}
   1870 
   1871 		case "error_description":
   1872 			if value != nil {
   1873 				jtv, ok := value.(string)
   1874 				if !ok {
   1875 					return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
   1876 				}
   1877 				sv.Error_description = ptr.String(jtv)
   1878 			}
   1879 
   1880 		default:
   1881 			_, _ = key, value
   1882 
   1883 		}
   1884 	}
   1885 	*v = sv
   1886 	return nil
   1887 }
   1888 
   1889 func awsRestjson1_deserializeDocumentInvalidRequestException(v **types.InvalidRequestException, value interface{}) error {
   1890 	if v == nil {
   1891 		return fmt.Errorf("unexpected nil of type %T", v)
   1892 	}
   1893 	if value == nil {
   1894 		return nil
   1895 	}
   1896 
   1897 	shape, ok := value.(map[string]interface{})
   1898 	if !ok {
   1899 		return fmt.Errorf("unexpected JSON type %v", value)
   1900 	}
   1901 
   1902 	var sv *types.InvalidRequestException
   1903 	if *v == nil {
   1904 		sv = &types.InvalidRequestException{}
   1905 	} else {
   1906 		sv = *v
   1907 	}
   1908 
   1909 	for key, value := range shape {
   1910 		switch key {
   1911 		case "error":
   1912 			if value != nil {
   1913 				jtv, ok := value.(string)
   1914 				if !ok {
   1915 					return fmt.Errorf("expected Error to be of type string, got %T instead", value)
   1916 				}
   1917 				sv.Error_ = ptr.String(jtv)
   1918 			}
   1919 
   1920 		case "error_description":
   1921 			if value != nil {
   1922 				jtv, ok := value.(string)
   1923 				if !ok {
   1924 					return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
   1925 				}
   1926 				sv.Error_description = ptr.String(jtv)
   1927 			}
   1928 
   1929 		case "reason":
   1930 			if value != nil {
   1931 				jtv, ok := value.(string)
   1932 				if !ok {
   1933 					return fmt.Errorf("expected InvalidRequestExceptionReason to be of type string, got %T instead", value)
   1934 				}
   1935 				sv.Reason = types.InvalidRequestExceptionReason(jtv)
   1936 			}
   1937 
   1938 		default:
   1939 			_, _ = key, value
   1940 
   1941 		}
   1942 	}
   1943 	*v = sv
   1944 	return nil
   1945 }
   1946 
   1947 func awsRestjson1_deserializeDocumentInvalidRequestRegionException(v **types.InvalidRequestRegionException, value interface{}) error {
   1948 	if v == nil {
   1949 		return fmt.Errorf("unexpected nil of type %T", v)
   1950 	}
   1951 	if value == nil {
   1952 		return nil
   1953 	}
   1954 
   1955 	shape, ok := value.(map[string]interface{})
   1956 	if !ok {
   1957 		return fmt.Errorf("unexpected JSON type %v", value)
   1958 	}
   1959 
   1960 	var sv *types.InvalidRequestRegionException
   1961 	if *v == nil {
   1962 		sv = &types.InvalidRequestRegionException{}
   1963 	} else {
   1964 		sv = *v
   1965 	}
   1966 
   1967 	for key, value := range shape {
   1968 		switch key {
   1969 		case "endpoint":
   1970 			if value != nil {
   1971 				jtv, ok := value.(string)
   1972 				if !ok {
   1973 					return fmt.Errorf("expected Location to be of type string, got %T instead", value)
   1974 				}
   1975 				sv.Endpoint = ptr.String(jtv)
   1976 			}
   1977 
   1978 		case "error":
   1979 			if value != nil {
   1980 				jtv, ok := value.(string)
   1981 				if !ok {
   1982 					return fmt.Errorf("expected Error to be of type string, got %T instead", value)
   1983 				}
   1984 				sv.Error_ = ptr.String(jtv)
   1985 			}
   1986 
   1987 		case "error_description":
   1988 			if value != nil {
   1989 				jtv, ok := value.(string)
   1990 				if !ok {
   1991 					return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
   1992 				}
   1993 				sv.Error_description = ptr.String(jtv)
   1994 			}
   1995 
   1996 		case "region":
   1997 			if value != nil {
   1998 				jtv, ok := value.(string)
   1999 				if !ok {
   2000 					return fmt.Errorf("expected Region to be of type string, got %T instead", value)
   2001 				}
   2002 				sv.Region = ptr.String(jtv)
   2003 			}
   2004 
   2005 		default:
   2006 			_, _ = key, value
   2007 
   2008 		}
   2009 	}
   2010 	*v = sv
   2011 	return nil
   2012 }
   2013 
   2014 func awsRestjson1_deserializeDocumentInvalidScopeException(v **types.InvalidScopeException, value interface{}) error {
   2015 	if v == nil {
   2016 		return fmt.Errorf("unexpected nil of type %T", v)
   2017 	}
   2018 	if value == nil {
   2019 		return nil
   2020 	}
   2021 
   2022 	shape, ok := value.(map[string]interface{})
   2023 	if !ok {
   2024 		return fmt.Errorf("unexpected JSON type %v", value)
   2025 	}
   2026 
   2027 	var sv *types.InvalidScopeException
   2028 	if *v == nil {
   2029 		sv = &types.InvalidScopeException{}
   2030 	} else {
   2031 		sv = *v
   2032 	}
   2033 
   2034 	for key, value := range shape {
   2035 		switch key {
   2036 		case "error":
   2037 			if value != nil {
   2038 				jtv, ok := value.(string)
   2039 				if !ok {
   2040 					return fmt.Errorf("expected Error to be of type string, got %T instead", value)
   2041 				}
   2042 				sv.Error_ = ptr.String(jtv)
   2043 			}
   2044 
   2045 		case "error_description":
   2046 			if value != nil {
   2047 				jtv, ok := value.(string)
   2048 				if !ok {
   2049 					return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
   2050 				}
   2051 				sv.Error_description = ptr.String(jtv)
   2052 			}
   2053 
   2054 		default:
   2055 			_, _ = key, value
   2056 
   2057 		}
   2058 	}
   2059 	*v = sv
   2060 	return nil
   2061 }
   2062 
   2063 func awsRestjson1_deserializeDocumentScopes(v *[]string, value interface{}) error {
   2064 	if v == nil {
   2065 		return fmt.Errorf("unexpected nil of type %T", v)
   2066 	}
   2067 	if value == nil {
   2068 		return nil
   2069 	}
   2070 
   2071 	shape, ok := value.([]interface{})
   2072 	if !ok {
   2073 		return fmt.Errorf("unexpected JSON type %v", value)
   2074 	}
   2075 
   2076 	var cv []string
   2077 	if *v == nil {
   2078 		cv = []string{}
   2079 	} else {
   2080 		cv = *v
   2081 	}
   2082 
   2083 	for _, value := range shape {
   2084 		var col string
   2085 		if value != nil {
   2086 			jtv, ok := value.(string)
   2087 			if !ok {
   2088 				return fmt.Errorf("expected Scope to be of type string, got %T instead", value)
   2089 			}
   2090 			col = jtv
   2091 		}
   2092 		cv = append(cv, col)
   2093 
   2094 	}
   2095 	*v = cv
   2096 	return nil
   2097 }
   2098 
   2099 func awsRestjson1_deserializeDocumentSlowDownException(v **types.SlowDownException, value interface{}) error {
   2100 	if v == nil {
   2101 		return fmt.Errorf("unexpected nil of type %T", v)
   2102 	}
   2103 	if value == nil {
   2104 		return nil
   2105 	}
   2106 
   2107 	shape, ok := value.(map[string]interface{})
   2108 	if !ok {
   2109 		return fmt.Errorf("unexpected JSON type %v", value)
   2110 	}
   2111 
   2112 	var sv *types.SlowDownException
   2113 	if *v == nil {
   2114 		sv = &types.SlowDownException{}
   2115 	} else {
   2116 		sv = *v
   2117 	}
   2118 
   2119 	for key, value := range shape {
   2120 		switch key {
   2121 		case "error":
   2122 			if value != nil {
   2123 				jtv, ok := value.(string)
   2124 				if !ok {
   2125 					return fmt.Errorf("expected Error to be of type string, got %T instead", value)
   2126 				}
   2127 				sv.Error_ = ptr.String(jtv)
   2128 			}
   2129 
   2130 		case "error_description":
   2131 			if value != nil {
   2132 				jtv, ok := value.(string)
   2133 				if !ok {
   2134 					return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
   2135 				}
   2136 				sv.Error_description = ptr.String(jtv)
   2137 			}
   2138 
   2139 		default:
   2140 			_, _ = key, value
   2141 
   2142 		}
   2143 	}
   2144 	*v = sv
   2145 	return nil
   2146 }
   2147 
   2148 func awsRestjson1_deserializeDocumentUnauthorizedClientException(v **types.UnauthorizedClientException, value interface{}) error {
   2149 	if v == nil {
   2150 		return fmt.Errorf("unexpected nil of type %T", v)
   2151 	}
   2152 	if value == nil {
   2153 		return nil
   2154 	}
   2155 
   2156 	shape, ok := value.(map[string]interface{})
   2157 	if !ok {
   2158 		return fmt.Errorf("unexpected JSON type %v", value)
   2159 	}
   2160 
   2161 	var sv *types.UnauthorizedClientException
   2162 	if *v == nil {
   2163 		sv = &types.UnauthorizedClientException{}
   2164 	} else {
   2165 		sv = *v
   2166 	}
   2167 
   2168 	for key, value := range shape {
   2169 		switch key {
   2170 		case "error":
   2171 			if value != nil {
   2172 				jtv, ok := value.(string)
   2173 				if !ok {
   2174 					return fmt.Errorf("expected Error to be of type string, got %T instead", value)
   2175 				}
   2176 				sv.Error_ = ptr.String(jtv)
   2177 			}
   2178 
   2179 		case "error_description":
   2180 			if value != nil {
   2181 				jtv, ok := value.(string)
   2182 				if !ok {
   2183 					return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
   2184 				}
   2185 				sv.Error_description = ptr.String(jtv)
   2186 			}
   2187 
   2188 		default:
   2189 			_, _ = key, value
   2190 
   2191 		}
   2192 	}
   2193 	*v = sv
   2194 	return nil
   2195 }
   2196 
   2197 func awsRestjson1_deserializeDocumentUnsupportedGrantTypeException(v **types.UnsupportedGrantTypeException, value interface{}) error {
   2198 	if v == nil {
   2199 		return fmt.Errorf("unexpected nil of type %T", v)
   2200 	}
   2201 	if value == nil {
   2202 		return nil
   2203 	}
   2204 
   2205 	shape, ok := value.(map[string]interface{})
   2206 	if !ok {
   2207 		return fmt.Errorf("unexpected JSON type %v", value)
   2208 	}
   2209 
   2210 	var sv *types.UnsupportedGrantTypeException
   2211 	if *v == nil {
   2212 		sv = &types.UnsupportedGrantTypeException{}
   2213 	} else {
   2214 		sv = *v
   2215 	}
   2216 
   2217 	for key, value := range shape {
   2218 		switch key {
   2219 		case "error":
   2220 			if value != nil {
   2221 				jtv, ok := value.(string)
   2222 				if !ok {
   2223 					return fmt.Errorf("expected Error to be of type string, got %T instead", value)
   2224 				}
   2225 				sv.Error_ = ptr.String(jtv)
   2226 			}
   2227 
   2228 		case "error_description":
   2229 			if value != nil {
   2230 				jtv, ok := value.(string)
   2231 				if !ok {
   2232 					return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
   2233 				}
   2234 				sv.Error_description = ptr.String(jtv)
   2235 			}
   2236 
   2237 		default:
   2238 			_, _ = key, value
   2239 
   2240 		}
   2241 	}
   2242 	*v = sv
   2243 	return nil
   2244 }