src

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

deserializers.go (58422B)

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