deserializers.go - src - Go monorepo.

deserializers.go (82152B)
      1 // Code generated by smithy-go-codegen DO NOT EDIT.
      2 
      3 package signin
      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/signin/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_deserializeOpCreateOAuth2Token struct {
     24 }
     25 
     26 func (*awsRestjson1_deserializeOpCreateOAuth2Token) ID() string {
     27 	return "OperationDeserializer"
     28 }
     29 
     30 func (m *awsRestjson1_deserializeOpCreateOAuth2Token) 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_deserializeOpErrorCreateOAuth2Token(response, &metadata)
     52 	}
     53 	output := &CreateOAuth2TokenOutput{}
     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_deserializeDocumentCreateOAuth2TokenResponseBody(&output.TokenOutput, 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_deserializeOpErrorCreateOAuth2Token(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("InternalServerException", errorCode):
    133 		return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
    134 
    135 	case strings.EqualFold("TooManyRequestsError", errorCode):
    136 		return awsRestjson1_deserializeErrorTooManyRequestsError(response, errorBody)
    137 
    138 	case strings.EqualFold("ValidationException", errorCode):
    139 		return awsRestjson1_deserializeErrorValidationException(response, errorBody)
    140 
    141 	default:
    142 		genericError := &smithy.GenericAPIError{
    143 			Code:    errorCode,
    144 			Message: errorMessage,
    145 		}
    146 		return genericError
    147 
    148 	}
    149 }
    150 
    151 func awsRestjson1_deserializeOpDocumentCreateOAuth2TokenOutput(v **CreateOAuth2TokenOutput, value interface{}) error {
    152 	if v == nil {
    153 		return fmt.Errorf("unexpected nil of type %T", v)
    154 	}
    155 	if value == nil {
    156 		return nil
    157 	}
    158 
    159 	shape, ok := value.(map[string]interface{})
    160 	if !ok {
    161 		return fmt.Errorf("unexpected JSON type %v", value)
    162 	}
    163 
    164 	var sv *CreateOAuth2TokenOutput
    165 	if *v == nil {
    166 		sv = &CreateOAuth2TokenOutput{}
    167 	} else {
    168 		sv = *v
    169 	}
    170 
    171 	for key, value := range shape {
    172 		switch key {
    173 		case "tokenOutput":
    174 			if err := awsRestjson1_deserializeDocumentCreateOAuth2TokenResponseBody(&sv.TokenOutput, value); err != nil {
    175 				return err
    176 			}
    177 
    178 		default:
    179 			_, _ = key, value
    180 
    181 		}
    182 	}
    183 	*v = sv
    184 	return nil
    185 }
    186 
    187 type awsRestjson1_deserializeOpCreateOAuth2TokenWithIAM struct {
    188 }
    189 
    190 func (*awsRestjson1_deserializeOpCreateOAuth2TokenWithIAM) ID() string {
    191 	return "OperationDeserializer"
    192 }
    193 
    194 func (m *awsRestjson1_deserializeOpCreateOAuth2TokenWithIAM) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    195 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
    196 ) {
    197 	out, metadata, err = next.HandleDeserialize(ctx, in)
    198 	if err != nil {
    199 		return out, metadata, err
    200 	}
    201 
    202 	response, ok := out.RawResponse.(*smithyhttp.Response)
    203 	if !ok {
    204 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
    205 	}
    206 
    207 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
    208 
    209 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
    210 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
    211 	defer endTimer()
    212 	defer span.End()
    213 
    214 	if response.StatusCode < 200 || response.StatusCode >= 300 {
    215 		return out, metadata, awsRestjson1_deserializeOpErrorCreateOAuth2TokenWithIAM(response, &metadata)
    216 	}
    217 	output := &CreateOAuth2TokenWithIAMOutput{}
    218 	out.Result = output
    219 
    220 	var buff [1024]byte
    221 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    222 
    223 	body := io.TeeReader(response.Body, ringBuffer)
    224 
    225 	decoder := json.NewDecoder(body)
    226 	decoder.UseNumber()
    227 	var shape interface{}
    228 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
    229 		var snapshot bytes.Buffer
    230 		io.Copy(&snapshot, ringBuffer)
    231 		err = &smithy.DeserializationError{
    232 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    233 			Snapshot: snapshot.Bytes(),
    234 		}
    235 		return out, metadata, err
    236 	}
    237 
    238 	err = awsRestjson1_deserializeOpDocumentCreateOAuth2TokenWithIAMOutput(&output, shape)
    239 	if err != nil {
    240 		var snapshot bytes.Buffer
    241 		io.Copy(&snapshot, ringBuffer)
    242 		return out, metadata, &smithy.DeserializationError{
    243 			Err:      fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
    244 			Snapshot: snapshot.Bytes(),
    245 		}
    246 	}
    247 
    248 	span.End()
    249 	return out, metadata, err
    250 }
    251 
    252 func awsRestjson1_deserializeOpErrorCreateOAuth2TokenWithIAM(response *smithyhttp.Response, metadata *middleware.Metadata) error {
    253 	var errorBuffer bytes.Buffer
    254 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
    255 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
    256 	}
    257 	errorBody := bytes.NewReader(errorBuffer.Bytes())
    258 
    259 	errorCode := "UnknownError"
    260 	errorMessage := errorCode
    261 
    262 	headerCode := response.Header.Get("X-Amzn-ErrorType")
    263 	if len(headerCode) != 0 {
    264 		errorCode = restjson.SanitizeErrorCode(headerCode)
    265 	}
    266 
    267 	var buff [1024]byte
    268 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    269 
    270 	body := io.TeeReader(errorBody, ringBuffer)
    271 	decoder := json.NewDecoder(body)
    272 	decoder.UseNumber()
    273 	jsonCode, message, err := restjson.GetErrorInfo(decoder)
    274 	if err != nil {
    275 		var snapshot bytes.Buffer
    276 		io.Copy(&snapshot, ringBuffer)
    277 		err = &smithy.DeserializationError{
    278 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    279 			Snapshot: snapshot.Bytes(),
    280 		}
    281 		return err
    282 	}
    283 
    284 	errorBody.Seek(0, io.SeekStart)
    285 	if len(headerCode) == 0 && len(jsonCode) != 0 {
    286 		errorCode = restjson.SanitizeErrorCode(jsonCode)
    287 	}
    288 	if len(message) != 0 {
    289 		errorMessage = message
    290 	}
    291 
    292 	switch {
    293 	case strings.EqualFold("AccessDeniedException", errorCode):
    294 		return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
    295 
    296 	case strings.EqualFold("InternalServerException", errorCode):
    297 		return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
    298 
    299 	case strings.EqualFold("TooManyRequestsError", errorCode):
    300 		return awsRestjson1_deserializeErrorTooManyRequestsError(response, errorBody)
    301 
    302 	case strings.EqualFold("ValidationException", errorCode):
    303 		return awsRestjson1_deserializeErrorValidationException(response, errorBody)
    304 
    305 	default:
    306 		genericError := &smithy.GenericAPIError{
    307 			Code:    errorCode,
    308 			Message: errorMessage,
    309 		}
    310 		return genericError
    311 
    312 	}
    313 }
    314 
    315 func awsRestjson1_deserializeOpDocumentCreateOAuth2TokenWithIAMOutput(v **CreateOAuth2TokenWithIAMOutput, value interface{}) error {
    316 	if v == nil {
    317 		return fmt.Errorf("unexpected nil of type %T", v)
    318 	}
    319 	if value == nil {
    320 		return nil
    321 	}
    322 
    323 	shape, ok := value.(map[string]interface{})
    324 	if !ok {
    325 		return fmt.Errorf("unexpected JSON type %v", value)
    326 	}
    327 
    328 	var sv *CreateOAuth2TokenWithIAMOutput
    329 	if *v == nil {
    330 		sv = &CreateOAuth2TokenWithIAMOutput{}
    331 	} else {
    332 		sv = *v
    333 	}
    334 
    335 	for key, value := range shape {
    336 		switch key {
    337 		case "access_token":
    338 			if value != nil {
    339 				jtv, ok := value.(string)
    340 				if !ok {
    341 					return fmt.Errorf("expected OAuthAccessToken to be of type string, got %T instead", value)
    342 				}
    343 				sv.AccessToken = ptr.String(jtv)
    344 			}
    345 
    346 		case "expires_in":
    347 			if value != nil {
    348 				jtv, ok := value.(json.Number)
    349 				if !ok {
    350 					return fmt.Errorf("expected TokenExpiresIn to be json.Number, got %T instead", value)
    351 				}
    352 				i64, err := jtv.Int64()
    353 				if err != nil {
    354 					return err
    355 				}
    356 				sv.ExpiresIn = ptr.Int32(int32(i64))
    357 			}
    358 
    359 		case "token_type":
    360 			if value != nil {
    361 				jtv, ok := value.(string)
    362 				if !ok {
    363 					return fmt.Errorf("expected BearerTokenType to be of type string, got %T instead", value)
    364 				}
    365 				sv.TokenType = ptr.String(jtv)
    366 			}
    367 
    368 		default:
    369 			_, _ = key, value
    370 
    371 		}
    372 	}
    373 	*v = sv
    374 	return nil
    375 }
    376 
    377 type awsRestjson1_deserializeOpDeleteConsoleAuthorizationConfiguration struct {
    378 }
    379 
    380 func (*awsRestjson1_deserializeOpDeleteConsoleAuthorizationConfiguration) ID() string {
    381 	return "OperationDeserializer"
    382 }
    383 
    384 func (m *awsRestjson1_deserializeOpDeleteConsoleAuthorizationConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    385 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
    386 ) {
    387 	out, metadata, err = next.HandleDeserialize(ctx, in)
    388 	if err != nil {
    389 		return out, metadata, err
    390 	}
    391 
    392 	response, ok := out.RawResponse.(*smithyhttp.Response)
    393 	if !ok {
    394 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
    395 	}
    396 
    397 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
    398 
    399 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
    400 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
    401 	defer endTimer()
    402 	defer span.End()
    403 
    404 	if response.StatusCode < 200 || response.StatusCode >= 300 {
    405 		return out, metadata, awsRestjson1_deserializeOpErrorDeleteConsoleAuthorizationConfiguration(response, &metadata)
    406 	}
    407 	output := &DeleteConsoleAuthorizationConfigurationOutput{}
    408 	out.Result = output
    409 
    410 	var buff [1024]byte
    411 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    412 
    413 	body := io.TeeReader(response.Body, ringBuffer)
    414 
    415 	decoder := json.NewDecoder(body)
    416 	decoder.UseNumber()
    417 	var shape interface{}
    418 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
    419 		var snapshot bytes.Buffer
    420 		io.Copy(&snapshot, ringBuffer)
    421 		err = &smithy.DeserializationError{
    422 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    423 			Snapshot: snapshot.Bytes(),
    424 		}
    425 		return out, metadata, err
    426 	}
    427 
    428 	err = awsRestjson1_deserializeOpDocumentDeleteConsoleAuthorizationConfigurationOutput(&output, shape)
    429 	if err != nil {
    430 		var snapshot bytes.Buffer
    431 		io.Copy(&snapshot, ringBuffer)
    432 		return out, metadata, &smithy.DeserializationError{
    433 			Err:      fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
    434 			Snapshot: snapshot.Bytes(),
    435 		}
    436 	}
    437 
    438 	span.End()
    439 	return out, metadata, err
    440 }
    441 
    442 func awsRestjson1_deserializeOpErrorDeleteConsoleAuthorizationConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
    443 	var errorBuffer bytes.Buffer
    444 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
    445 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
    446 	}
    447 	errorBody := bytes.NewReader(errorBuffer.Bytes())
    448 
    449 	errorCode := "UnknownError"
    450 	errorMessage := errorCode
    451 
    452 	headerCode := response.Header.Get("X-Amzn-ErrorType")
    453 	if len(headerCode) != 0 {
    454 		errorCode = restjson.SanitizeErrorCode(headerCode)
    455 	}
    456 
    457 	var buff [1024]byte
    458 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    459 
    460 	body := io.TeeReader(errorBody, ringBuffer)
    461 	decoder := json.NewDecoder(body)
    462 	decoder.UseNumber()
    463 	jsonCode, message, err := restjson.GetErrorInfo(decoder)
    464 	if err != nil {
    465 		var snapshot bytes.Buffer
    466 		io.Copy(&snapshot, ringBuffer)
    467 		err = &smithy.DeserializationError{
    468 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    469 			Snapshot: snapshot.Bytes(),
    470 		}
    471 		return err
    472 	}
    473 
    474 	errorBody.Seek(0, io.SeekStart)
    475 	if len(headerCode) == 0 && len(jsonCode) != 0 {
    476 		errorCode = restjson.SanitizeErrorCode(jsonCode)
    477 	}
    478 	if len(message) != 0 {
    479 		errorMessage = message
    480 	}
    481 
    482 	switch {
    483 	case strings.EqualFold("AccessDeniedException", errorCode):
    484 		return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
    485 
    486 	case strings.EqualFold("InternalServerException", errorCode):
    487 		return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
    488 
    489 	case strings.EqualFold("ResourceNotFoundException", errorCode):
    490 		return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
    491 
    492 	case strings.EqualFold("TooManyRequestsError", errorCode):
    493 		return awsRestjson1_deserializeErrorTooManyRequestsError(response, errorBody)
    494 
    495 	case strings.EqualFold("ValidationException", errorCode):
    496 		return awsRestjson1_deserializeErrorValidationException(response, errorBody)
    497 
    498 	default:
    499 		genericError := &smithy.GenericAPIError{
    500 			Code:    errorCode,
    501 			Message: errorMessage,
    502 		}
    503 		return genericError
    504 
    505 	}
    506 }
    507 
    508 func awsRestjson1_deserializeOpDocumentDeleteConsoleAuthorizationConfigurationOutput(v **DeleteConsoleAuthorizationConfigurationOutput, value interface{}) error {
    509 	if v == nil {
    510 		return fmt.Errorf("unexpected nil of type %T", v)
    511 	}
    512 	if value == nil {
    513 		return nil
    514 	}
    515 
    516 	shape, ok := value.(map[string]interface{})
    517 	if !ok {
    518 		return fmt.Errorf("unexpected JSON type %v", value)
    519 	}
    520 
    521 	var sv *DeleteConsoleAuthorizationConfigurationOutput
    522 	if *v == nil {
    523 		sv = &DeleteConsoleAuthorizationConfigurationOutput{}
    524 	} else {
    525 		sv = *v
    526 	}
    527 
    528 	for key, value := range shape {
    529 		switch key {
    530 		case "consoleAuthorizationEnabled":
    531 			if value != nil {
    532 				jtv, ok := value.(bool)
    533 				if !ok {
    534 					return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
    535 				}
    536 				sv.ConsoleAuthorizationEnabled = ptr.Bool(jtv)
    537 			}
    538 
    539 		case "scope":
    540 			if value != nil {
    541 				jtv, ok := value.(string)
    542 				if !ok {
    543 					return fmt.Errorf("expected String to be of type string, got %T instead", value)
    544 				}
    545 				sv.Scope = ptr.String(jtv)
    546 			}
    547 
    548 		case "targetId":
    549 			if value != nil {
    550 				jtv, ok := value.(string)
    551 				if !ok {
    552 					return fmt.Errorf("expected TargetId to be of type string, got %T instead", value)
    553 				}
    554 				sv.TargetId = ptr.String(jtv)
    555 			}
    556 
    557 		default:
    558 			_, _ = key, value
    559 
    560 		}
    561 	}
    562 	*v = sv
    563 	return nil
    564 }
    565 
    566 type awsRestjson1_deserializeOpDeleteResourcePermissionStatement struct {
    567 }
    568 
    569 func (*awsRestjson1_deserializeOpDeleteResourcePermissionStatement) ID() string {
    570 	return "OperationDeserializer"
    571 }
    572 
    573 func (m *awsRestjson1_deserializeOpDeleteResourcePermissionStatement) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    574 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
    575 ) {
    576 	out, metadata, err = next.HandleDeserialize(ctx, in)
    577 	if err != nil {
    578 		return out, metadata, err
    579 	}
    580 
    581 	response, ok := out.RawResponse.(*smithyhttp.Response)
    582 	if !ok {
    583 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
    584 	}
    585 
    586 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
    587 
    588 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
    589 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
    590 	defer endTimer()
    591 	defer span.End()
    592 
    593 	if response.StatusCode < 200 || response.StatusCode >= 300 {
    594 		return out, metadata, awsRestjson1_deserializeOpErrorDeleteResourcePermissionStatement(response, &metadata)
    595 	}
    596 	output := &DeleteResourcePermissionStatementOutput{}
    597 	out.Result = output
    598 
    599 	span.End()
    600 	return out, metadata, err
    601 }
    602 
    603 func awsRestjson1_deserializeOpErrorDeleteResourcePermissionStatement(response *smithyhttp.Response, metadata *middleware.Metadata) error {
    604 	var errorBuffer bytes.Buffer
    605 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
    606 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
    607 	}
    608 	errorBody := bytes.NewReader(errorBuffer.Bytes())
    609 
    610 	errorCode := "UnknownError"
    611 	errorMessage := errorCode
    612 
    613 	headerCode := response.Header.Get("X-Amzn-ErrorType")
    614 	if len(headerCode) != 0 {
    615 		errorCode = restjson.SanitizeErrorCode(headerCode)
    616 	}
    617 
    618 	var buff [1024]byte
    619 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    620 
    621 	body := io.TeeReader(errorBody, ringBuffer)
    622 	decoder := json.NewDecoder(body)
    623 	decoder.UseNumber()
    624 	jsonCode, message, err := restjson.GetErrorInfo(decoder)
    625 	if err != nil {
    626 		var snapshot bytes.Buffer
    627 		io.Copy(&snapshot, ringBuffer)
    628 		err = &smithy.DeserializationError{
    629 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    630 			Snapshot: snapshot.Bytes(),
    631 		}
    632 		return err
    633 	}
    634 
    635 	errorBody.Seek(0, io.SeekStart)
    636 	if len(headerCode) == 0 && len(jsonCode) != 0 {
    637 		errorCode = restjson.SanitizeErrorCode(jsonCode)
    638 	}
    639 	if len(message) != 0 {
    640 		errorMessage = message
    641 	}
    642 
    643 	switch {
    644 	case strings.EqualFold("AccessDeniedException", errorCode):
    645 		return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
    646 
    647 	case strings.EqualFold("InternalServerException", errorCode):
    648 		return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
    649 
    650 	case strings.EqualFold("ResourceNotFoundException", errorCode):
    651 		return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
    652 
    653 	case strings.EqualFold("TooManyRequestsError", errorCode):
    654 		return awsRestjson1_deserializeErrorTooManyRequestsError(response, errorBody)
    655 
    656 	case strings.EqualFold("ValidationException", errorCode):
    657 		return awsRestjson1_deserializeErrorValidationException(response, errorBody)
    658 
    659 	default:
    660 		genericError := &smithy.GenericAPIError{
    661 			Code:    errorCode,
    662 			Message: errorMessage,
    663 		}
    664 		return genericError
    665 
    666 	}
    667 }
    668 
    669 type awsRestjson1_deserializeOpGetConsoleAuthorizationConfiguration struct {
    670 }
    671 
    672 func (*awsRestjson1_deserializeOpGetConsoleAuthorizationConfiguration) ID() string {
    673 	return "OperationDeserializer"
    674 }
    675 
    676 func (m *awsRestjson1_deserializeOpGetConsoleAuthorizationConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    677 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
    678 ) {
    679 	out, metadata, err = next.HandleDeserialize(ctx, in)
    680 	if err != nil {
    681 		return out, metadata, err
    682 	}
    683 
    684 	response, ok := out.RawResponse.(*smithyhttp.Response)
    685 	if !ok {
    686 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
    687 	}
    688 
    689 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
    690 
    691 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
    692 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
    693 	defer endTimer()
    694 	defer span.End()
    695 
    696 	if response.StatusCode < 200 || response.StatusCode >= 300 {
    697 		return out, metadata, awsRestjson1_deserializeOpErrorGetConsoleAuthorizationConfiguration(response, &metadata)
    698 	}
    699 	output := &GetConsoleAuthorizationConfigurationOutput{}
    700 	out.Result = output
    701 
    702 	var buff [1024]byte
    703 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    704 
    705 	body := io.TeeReader(response.Body, ringBuffer)
    706 
    707 	decoder := json.NewDecoder(body)
    708 	decoder.UseNumber()
    709 	var shape interface{}
    710 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
    711 		var snapshot bytes.Buffer
    712 		io.Copy(&snapshot, ringBuffer)
    713 		err = &smithy.DeserializationError{
    714 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    715 			Snapshot: snapshot.Bytes(),
    716 		}
    717 		return out, metadata, err
    718 	}
    719 
    720 	err = awsRestjson1_deserializeOpDocumentGetConsoleAuthorizationConfigurationOutput(&output, shape)
    721 	if err != nil {
    722 		var snapshot bytes.Buffer
    723 		io.Copy(&snapshot, ringBuffer)
    724 		return out, metadata, &smithy.DeserializationError{
    725 			Err:      fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
    726 			Snapshot: snapshot.Bytes(),
    727 		}
    728 	}
    729 
    730 	span.End()
    731 	return out, metadata, err
    732 }
    733 
    734 func awsRestjson1_deserializeOpErrorGetConsoleAuthorizationConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
    735 	var errorBuffer bytes.Buffer
    736 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
    737 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
    738 	}
    739 	errorBody := bytes.NewReader(errorBuffer.Bytes())
    740 
    741 	errorCode := "UnknownError"
    742 	errorMessage := errorCode
    743 
    744 	headerCode := response.Header.Get("X-Amzn-ErrorType")
    745 	if len(headerCode) != 0 {
    746 		errorCode = restjson.SanitizeErrorCode(headerCode)
    747 	}
    748 
    749 	var buff [1024]byte
    750 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    751 
    752 	body := io.TeeReader(errorBody, ringBuffer)
    753 	decoder := json.NewDecoder(body)
    754 	decoder.UseNumber()
    755 	jsonCode, message, err := restjson.GetErrorInfo(decoder)
    756 	if err != nil {
    757 		var snapshot bytes.Buffer
    758 		io.Copy(&snapshot, ringBuffer)
    759 		err = &smithy.DeserializationError{
    760 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    761 			Snapshot: snapshot.Bytes(),
    762 		}
    763 		return err
    764 	}
    765 
    766 	errorBody.Seek(0, io.SeekStart)
    767 	if len(headerCode) == 0 && len(jsonCode) != 0 {
    768 		errorCode = restjson.SanitizeErrorCode(jsonCode)
    769 	}
    770 	if len(message) != 0 {
    771 		errorMessage = message
    772 	}
    773 
    774 	switch {
    775 	case strings.EqualFold("AccessDeniedException", errorCode):
    776 		return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
    777 
    778 	case strings.EqualFold("InternalServerException", errorCode):
    779 		return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
    780 
    781 	case strings.EqualFold("ResourceNotFoundException", errorCode):
    782 		return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
    783 
    784 	case strings.EqualFold("TooManyRequestsError", errorCode):
    785 		return awsRestjson1_deserializeErrorTooManyRequestsError(response, errorBody)
    786 
    787 	case strings.EqualFold("ValidationException", errorCode):
    788 		return awsRestjson1_deserializeErrorValidationException(response, errorBody)
    789 
    790 	default:
    791 		genericError := &smithy.GenericAPIError{
    792 			Code:    errorCode,
    793 			Message: errorMessage,
    794 		}
    795 		return genericError
    796 
    797 	}
    798 }
    799 
    800 func awsRestjson1_deserializeOpDocumentGetConsoleAuthorizationConfigurationOutput(v **GetConsoleAuthorizationConfigurationOutput, value interface{}) error {
    801 	if v == nil {
    802 		return fmt.Errorf("unexpected nil of type %T", v)
    803 	}
    804 	if value == nil {
    805 		return nil
    806 	}
    807 
    808 	shape, ok := value.(map[string]interface{})
    809 	if !ok {
    810 		return fmt.Errorf("unexpected JSON type %v", value)
    811 	}
    812 
    813 	var sv *GetConsoleAuthorizationConfigurationOutput
    814 	if *v == nil {
    815 		sv = &GetConsoleAuthorizationConfigurationOutput{}
    816 	} else {
    817 		sv = *v
    818 	}
    819 
    820 	for key, value := range shape {
    821 		switch key {
    822 		case "consoleAuthorizationEnabled":
    823 			if value != nil {
    824 				jtv, ok := value.(bool)
    825 				if !ok {
    826 					return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
    827 				}
    828 				sv.ConsoleAuthorizationEnabled = ptr.Bool(jtv)
    829 			}
    830 
    831 		case "scope":
    832 			if value != nil {
    833 				jtv, ok := value.(string)
    834 				if !ok {
    835 					return fmt.Errorf("expected String to be of type string, got %T instead", value)
    836 				}
    837 				sv.Scope = ptr.String(jtv)
    838 			}
    839 
    840 		case "targetId":
    841 			if value != nil {
    842 				jtv, ok := value.(string)
    843 				if !ok {
    844 					return fmt.Errorf("expected TargetId to be of type string, got %T instead", value)
    845 				}
    846 				sv.TargetId = ptr.String(jtv)
    847 			}
    848 
    849 		default:
    850 			_, _ = key, value
    851 
    852 		}
    853 	}
    854 	*v = sv
    855 	return nil
    856 }
    857 
    858 type awsRestjson1_deserializeOpGetResourcePolicy struct {
    859 }
    860 
    861 func (*awsRestjson1_deserializeOpGetResourcePolicy) ID() string {
    862 	return "OperationDeserializer"
    863 }
    864 
    865 func (m *awsRestjson1_deserializeOpGetResourcePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
    866 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
    867 ) {
    868 	out, metadata, err = next.HandleDeserialize(ctx, in)
    869 	if err != nil {
    870 		return out, metadata, err
    871 	}
    872 
    873 	response, ok := out.RawResponse.(*smithyhttp.Response)
    874 	if !ok {
    875 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
    876 	}
    877 
    878 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
    879 
    880 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
    881 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
    882 	defer endTimer()
    883 	defer span.End()
    884 
    885 	if response.StatusCode < 200 || response.StatusCode >= 300 {
    886 		return out, metadata, awsRestjson1_deserializeOpErrorGetResourcePolicy(response, &metadata)
    887 	}
    888 	output := &GetResourcePolicyOutput{}
    889 	out.Result = output
    890 
    891 	var buff [1024]byte
    892 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    893 
    894 	body := io.TeeReader(response.Body, ringBuffer)
    895 
    896 	decoder := json.NewDecoder(body)
    897 	decoder.UseNumber()
    898 	var shape interface{}
    899 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
    900 		var snapshot bytes.Buffer
    901 		io.Copy(&snapshot, ringBuffer)
    902 		err = &smithy.DeserializationError{
    903 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    904 			Snapshot: snapshot.Bytes(),
    905 		}
    906 		return out, metadata, err
    907 	}
    908 
    909 	err = awsRestjson1_deserializeOpDocumentGetResourcePolicyOutput(&output, shape)
    910 	if err != nil {
    911 		var snapshot bytes.Buffer
    912 		io.Copy(&snapshot, ringBuffer)
    913 		return out, metadata, &smithy.DeserializationError{
    914 			Err:      fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
    915 			Snapshot: snapshot.Bytes(),
    916 		}
    917 	}
    918 
    919 	span.End()
    920 	return out, metadata, err
    921 }
    922 
    923 func awsRestjson1_deserializeOpErrorGetResourcePolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
    924 	var errorBuffer bytes.Buffer
    925 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
    926 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
    927 	}
    928 	errorBody := bytes.NewReader(errorBuffer.Bytes())
    929 
    930 	errorCode := "UnknownError"
    931 	errorMessage := errorCode
    932 
    933 	headerCode := response.Header.Get("X-Amzn-ErrorType")
    934 	if len(headerCode) != 0 {
    935 		errorCode = restjson.SanitizeErrorCode(headerCode)
    936 	}
    937 
    938 	var buff [1024]byte
    939 	ringBuffer := smithyio.NewRingBuffer(buff[:])
    940 
    941 	body := io.TeeReader(errorBody, ringBuffer)
    942 	decoder := json.NewDecoder(body)
    943 	decoder.UseNumber()
    944 	jsonCode, message, err := restjson.GetErrorInfo(decoder)
    945 	if err != nil {
    946 		var snapshot bytes.Buffer
    947 		io.Copy(&snapshot, ringBuffer)
    948 		err = &smithy.DeserializationError{
    949 			Err:      fmt.Errorf("failed to decode response body, %w", err),
    950 			Snapshot: snapshot.Bytes(),
    951 		}
    952 		return err
    953 	}
    954 
    955 	errorBody.Seek(0, io.SeekStart)
    956 	if len(headerCode) == 0 && len(jsonCode) != 0 {
    957 		errorCode = restjson.SanitizeErrorCode(jsonCode)
    958 	}
    959 	if len(message) != 0 {
    960 		errorMessage = message
    961 	}
    962 
    963 	switch {
    964 	case strings.EqualFold("AccessDeniedException", errorCode):
    965 		return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
    966 
    967 	case strings.EqualFold("InternalServerException", errorCode):
    968 		return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
    969 
    970 	case strings.EqualFold("ResourceNotFoundException", errorCode):
    971 		return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
    972 
    973 	case strings.EqualFold("TooManyRequestsError", errorCode):
    974 		return awsRestjson1_deserializeErrorTooManyRequestsError(response, errorBody)
    975 
    976 	default:
    977 		genericError := &smithy.GenericAPIError{
    978 			Code:    errorCode,
    979 			Message: errorMessage,
    980 		}
    981 		return genericError
    982 
    983 	}
    984 }
    985 
    986 func awsRestjson1_deserializeOpDocumentGetResourcePolicyOutput(v **GetResourcePolicyOutput, value interface{}) error {
    987 	if v == nil {
    988 		return fmt.Errorf("unexpected nil of type %T", v)
    989 	}
    990 	if value == nil {
    991 		return nil
    992 	}
    993 
    994 	shape, ok := value.(map[string]interface{})
    995 	if !ok {
    996 		return fmt.Errorf("unexpected JSON type %v", value)
    997 	}
    998 
    999 	var sv *GetResourcePolicyOutput
   1000 	if *v == nil {
   1001 		sv = &GetResourcePolicyOutput{}
   1002 	} else {
   1003 		sv = *v
   1004 	}
   1005 
   1006 	for key, value := range shape {
   1007 		switch key {
   1008 		case "signinResourceBasedPolicy":
   1009 			if err := awsRestjson1_deserializeDocumentSigninResourceBasedPolicy(&sv.SigninResourceBasedPolicy, value); err != nil {
   1010 				return err
   1011 			}
   1012 
   1013 		default:
   1014 			_, _ = key, value
   1015 
   1016 		}
   1017 	}
   1018 	*v = sv
   1019 	return nil
   1020 }
   1021 
   1022 type awsRestjson1_deserializeOpIntrospectOAuth2TokenWithIAM struct {
   1023 }
   1024 
   1025 func (*awsRestjson1_deserializeOpIntrospectOAuth2TokenWithIAM) ID() string {
   1026 	return "OperationDeserializer"
   1027 }
   1028 
   1029 func (m *awsRestjson1_deserializeOpIntrospectOAuth2TokenWithIAM) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   1030 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   1031 ) {
   1032 	out, metadata, err = next.HandleDeserialize(ctx, in)
   1033 	if err != nil {
   1034 		return out, metadata, err
   1035 	}
   1036 
   1037 	response, ok := out.RawResponse.(*smithyhttp.Response)
   1038 	if !ok {
   1039 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   1040 	}
   1041 
   1042 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   1043 
   1044 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   1045 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   1046 	defer endTimer()
   1047 	defer span.End()
   1048 
   1049 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   1050 		return out, metadata, awsRestjson1_deserializeOpErrorIntrospectOAuth2TokenWithIAM(response, &metadata)
   1051 	}
   1052 	output := &IntrospectOAuth2TokenWithIAMOutput{}
   1053 	out.Result = output
   1054 
   1055 	var buff [1024]byte
   1056 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1057 
   1058 	body := io.TeeReader(response.Body, ringBuffer)
   1059 
   1060 	decoder := json.NewDecoder(body)
   1061 	decoder.UseNumber()
   1062 	var shape interface{}
   1063 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
   1064 		var snapshot bytes.Buffer
   1065 		io.Copy(&snapshot, ringBuffer)
   1066 		err = &smithy.DeserializationError{
   1067 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1068 			Snapshot: snapshot.Bytes(),
   1069 		}
   1070 		return out, metadata, err
   1071 	}
   1072 
   1073 	err = awsRestjson1_deserializeOpDocumentIntrospectOAuth2TokenWithIAMOutput(&output, shape)
   1074 	if err != nil {
   1075 		var snapshot bytes.Buffer
   1076 		io.Copy(&snapshot, ringBuffer)
   1077 		return out, metadata, &smithy.DeserializationError{
   1078 			Err:      fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
   1079 			Snapshot: snapshot.Bytes(),
   1080 		}
   1081 	}
   1082 
   1083 	span.End()
   1084 	return out, metadata, err
   1085 }
   1086 
   1087 func awsRestjson1_deserializeOpErrorIntrospectOAuth2TokenWithIAM(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   1088 	var errorBuffer bytes.Buffer
   1089 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   1090 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   1091 	}
   1092 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   1093 
   1094 	errorCode := "UnknownError"
   1095 	errorMessage := errorCode
   1096 
   1097 	headerCode := response.Header.Get("X-Amzn-ErrorType")
   1098 	if len(headerCode) != 0 {
   1099 		errorCode = restjson.SanitizeErrorCode(headerCode)
   1100 	}
   1101 
   1102 	var buff [1024]byte
   1103 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1104 
   1105 	body := io.TeeReader(errorBody, ringBuffer)
   1106 	decoder := json.NewDecoder(body)
   1107 	decoder.UseNumber()
   1108 	jsonCode, message, err := restjson.GetErrorInfo(decoder)
   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 	if len(headerCode) == 0 && len(jsonCode) != 0 {
   1121 		errorCode = restjson.SanitizeErrorCode(jsonCode)
   1122 	}
   1123 	if len(message) != 0 {
   1124 		errorMessage = message
   1125 	}
   1126 
   1127 	switch {
   1128 	case strings.EqualFold("AccessDeniedException", errorCode):
   1129 		return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
   1130 
   1131 	case strings.EqualFold("InternalServerException", errorCode):
   1132 		return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
   1133 
   1134 	case strings.EqualFold("TooManyRequestsError", errorCode):
   1135 		return awsRestjson1_deserializeErrorTooManyRequestsError(response, errorBody)
   1136 
   1137 	case strings.EqualFold("ValidationException", errorCode):
   1138 		return awsRestjson1_deserializeErrorValidationException(response, errorBody)
   1139 
   1140 	default:
   1141 		genericError := &smithy.GenericAPIError{
   1142 			Code:    errorCode,
   1143 			Message: errorMessage,
   1144 		}
   1145 		return genericError
   1146 
   1147 	}
   1148 }
   1149 
   1150 func awsRestjson1_deserializeOpDocumentIntrospectOAuth2TokenWithIAMOutput(v **IntrospectOAuth2TokenWithIAMOutput, value interface{}) error {
   1151 	if v == nil {
   1152 		return fmt.Errorf("unexpected nil of type %T", v)
   1153 	}
   1154 	if value == nil {
   1155 		return nil
   1156 	}
   1157 
   1158 	shape, ok := value.(map[string]interface{})
   1159 	if !ok {
   1160 		return fmt.Errorf("unexpected JSON type %v", value)
   1161 	}
   1162 
   1163 	var sv *IntrospectOAuth2TokenWithIAMOutput
   1164 	if *v == nil {
   1165 		sv = &IntrospectOAuth2TokenWithIAMOutput{}
   1166 	} else {
   1167 		sv = *v
   1168 	}
   1169 
   1170 	for key, value := range shape {
   1171 		switch key {
   1172 		case "account_id":
   1173 			if value != nil {
   1174 				jtv, ok := value.(string)
   1175 				if !ok {
   1176 					return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
   1177 				}
   1178 				sv.AccountId = ptr.String(jtv)
   1179 			}
   1180 
   1181 		case "active":
   1182 			if value != nil {
   1183 				jtv, ok := value.(bool)
   1184 				if !ok {
   1185 					return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
   1186 				}
   1187 				sv.Active = ptr.Bool(jtv)
   1188 			}
   1189 
   1190 		case "aud":
   1191 			if value != nil {
   1192 				jtv, ok := value.(string)
   1193 				if !ok {
   1194 					return fmt.Errorf("expected String to be of type string, got %T instead", value)
   1195 				}
   1196 				sv.Aud = ptr.String(jtv)
   1197 			}
   1198 
   1199 		case "client_id":
   1200 			if value != nil {
   1201 				jtv, ok := value.(string)
   1202 				if !ok {
   1203 					return fmt.Errorf("expected String to be of type string, got %T instead", value)
   1204 				}
   1205 				sv.ClientId = ptr.String(jtv)
   1206 			}
   1207 
   1208 		case "exp":
   1209 			if value != nil {
   1210 				jtv, ok := value.(json.Number)
   1211 				if !ok {
   1212 					return fmt.Errorf("expected Long to be json.Number, got %T instead", value)
   1213 				}
   1214 				i64, err := jtv.Int64()
   1215 				if err != nil {
   1216 					return err
   1217 				}
   1218 				sv.Exp = ptr.Int64(i64)
   1219 			}
   1220 
   1221 		case "iat":
   1222 			if value != nil {
   1223 				jtv, ok := value.(json.Number)
   1224 				if !ok {
   1225 					return fmt.Errorf("expected Long to be json.Number, got %T instead", value)
   1226 				}
   1227 				i64, err := jtv.Int64()
   1228 				if err != nil {
   1229 					return err
   1230 				}
   1231 				sv.Iat = ptr.Int64(i64)
   1232 			}
   1233 
   1234 		case "iss":
   1235 			if value != nil {
   1236 				jtv, ok := value.(string)
   1237 				if !ok {
   1238 					return fmt.Errorf("expected String to be of type string, got %T instead", value)
   1239 				}
   1240 				sv.Iss = ptr.String(jtv)
   1241 			}
   1242 
   1243 		case "jti":
   1244 			if value != nil {
   1245 				jtv, ok := value.(string)
   1246 				if !ok {
   1247 					return fmt.Errorf("expected String to be of type string, got %T instead", value)
   1248 				}
   1249 				sv.Jti = ptr.String(jtv)
   1250 			}
   1251 
   1252 		case "nbf":
   1253 			if value != nil {
   1254 				jtv, ok := value.(json.Number)
   1255 				if !ok {
   1256 					return fmt.Errorf("expected Long to be json.Number, got %T instead", value)
   1257 				}
   1258 				i64, err := jtv.Int64()
   1259 				if err != nil {
   1260 					return err
   1261 				}
   1262 				sv.Nbf = ptr.Int64(i64)
   1263 			}
   1264 
   1265 		case "resource":
   1266 			if value != nil {
   1267 				jtv, ok := value.(string)
   1268 				if !ok {
   1269 					return fmt.Errorf("expected String to be of type string, got %T instead", value)
   1270 				}
   1271 				sv.Resource = ptr.String(jtv)
   1272 			}
   1273 
   1274 		case "signin_session":
   1275 			if value != nil {
   1276 				jtv, ok := value.(string)
   1277 				if !ok {
   1278 					return fmt.Errorf("expected String to be of type string, got %T instead", value)
   1279 				}
   1280 				sv.SigninSession = ptr.String(jtv)
   1281 			}
   1282 
   1283 		case "sub":
   1284 			if value != nil {
   1285 				jtv, ok := value.(string)
   1286 				if !ok {
   1287 					return fmt.Errorf("expected String to be of type string, got %T instead", value)
   1288 				}
   1289 				sv.Sub = ptr.String(jtv)
   1290 			}
   1291 
   1292 		case "token_type":
   1293 			if value != nil {
   1294 				jtv, ok := value.(string)
   1295 				if !ok {
   1296 					return fmt.Errorf("expected IntrospectedTokenType to be of type string, got %T instead", value)
   1297 				}
   1298 				sv.TokenType = ptr.String(jtv)
   1299 			}
   1300 
   1301 		case "user_id":
   1302 			if value != nil {
   1303 				jtv, ok := value.(string)
   1304 				if !ok {
   1305 					return fmt.Errorf("expected String to be of type string, got %T instead", value)
   1306 				}
   1307 				sv.UserId = ptr.String(jtv)
   1308 			}
   1309 
   1310 		default:
   1311 			_, _ = key, value
   1312 
   1313 		}
   1314 	}
   1315 	*v = sv
   1316 	return nil
   1317 }
   1318 
   1319 type awsRestjson1_deserializeOpListResourcePermissionStatements struct {
   1320 }
   1321 
   1322 func (*awsRestjson1_deserializeOpListResourcePermissionStatements) ID() string {
   1323 	return "OperationDeserializer"
   1324 }
   1325 
   1326 func (m *awsRestjson1_deserializeOpListResourcePermissionStatements) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   1327 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   1328 ) {
   1329 	out, metadata, err = next.HandleDeserialize(ctx, in)
   1330 	if err != nil {
   1331 		return out, metadata, err
   1332 	}
   1333 
   1334 	response, ok := out.RawResponse.(*smithyhttp.Response)
   1335 	if !ok {
   1336 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   1337 	}
   1338 
   1339 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   1340 
   1341 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   1342 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   1343 	defer endTimer()
   1344 	defer span.End()
   1345 
   1346 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   1347 		return out, metadata, awsRestjson1_deserializeOpErrorListResourcePermissionStatements(response, &metadata)
   1348 	}
   1349 	output := &ListResourcePermissionStatementsOutput{}
   1350 	out.Result = output
   1351 
   1352 	var buff [1024]byte
   1353 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1354 
   1355 	body := io.TeeReader(response.Body, ringBuffer)
   1356 
   1357 	decoder := json.NewDecoder(body)
   1358 	decoder.UseNumber()
   1359 	var shape interface{}
   1360 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
   1361 		var snapshot bytes.Buffer
   1362 		io.Copy(&snapshot, ringBuffer)
   1363 		err = &smithy.DeserializationError{
   1364 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1365 			Snapshot: snapshot.Bytes(),
   1366 		}
   1367 		return out, metadata, err
   1368 	}
   1369 
   1370 	err = awsRestjson1_deserializeOpDocumentListResourcePermissionStatementsOutput(&output, shape)
   1371 	if err != nil {
   1372 		var snapshot bytes.Buffer
   1373 		io.Copy(&snapshot, ringBuffer)
   1374 		return out, metadata, &smithy.DeserializationError{
   1375 			Err:      fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
   1376 			Snapshot: snapshot.Bytes(),
   1377 		}
   1378 	}
   1379 
   1380 	span.End()
   1381 	return out, metadata, err
   1382 }
   1383 
   1384 func awsRestjson1_deserializeOpErrorListResourcePermissionStatements(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   1385 	var errorBuffer bytes.Buffer
   1386 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   1387 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   1388 	}
   1389 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   1390 
   1391 	errorCode := "UnknownError"
   1392 	errorMessage := errorCode
   1393 
   1394 	headerCode := response.Header.Get("X-Amzn-ErrorType")
   1395 	if len(headerCode) != 0 {
   1396 		errorCode = restjson.SanitizeErrorCode(headerCode)
   1397 	}
   1398 
   1399 	var buff [1024]byte
   1400 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1401 
   1402 	body := io.TeeReader(errorBody, ringBuffer)
   1403 	decoder := json.NewDecoder(body)
   1404 	decoder.UseNumber()
   1405 	jsonCode, message, err := restjson.GetErrorInfo(decoder)
   1406 	if err != nil {
   1407 		var snapshot bytes.Buffer
   1408 		io.Copy(&snapshot, ringBuffer)
   1409 		err = &smithy.DeserializationError{
   1410 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1411 			Snapshot: snapshot.Bytes(),
   1412 		}
   1413 		return err
   1414 	}
   1415 
   1416 	errorBody.Seek(0, io.SeekStart)
   1417 	if len(headerCode) == 0 && len(jsonCode) != 0 {
   1418 		errorCode = restjson.SanitizeErrorCode(jsonCode)
   1419 	}
   1420 	if len(message) != 0 {
   1421 		errorMessage = message
   1422 	}
   1423 
   1424 	switch {
   1425 	case strings.EqualFold("AccessDeniedException", errorCode):
   1426 		return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
   1427 
   1428 	case strings.EqualFold("InternalServerException", errorCode):
   1429 		return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
   1430 
   1431 	case strings.EqualFold("ResourceNotFoundException", errorCode):
   1432 		return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
   1433 
   1434 	case strings.EqualFold("TooManyRequestsError", errorCode):
   1435 		return awsRestjson1_deserializeErrorTooManyRequestsError(response, errorBody)
   1436 
   1437 	case strings.EqualFold("ValidationException", errorCode):
   1438 		return awsRestjson1_deserializeErrorValidationException(response, errorBody)
   1439 
   1440 	default:
   1441 		genericError := &smithy.GenericAPIError{
   1442 			Code:    errorCode,
   1443 			Message: errorMessage,
   1444 		}
   1445 		return genericError
   1446 
   1447 	}
   1448 }
   1449 
   1450 func awsRestjson1_deserializeOpDocumentListResourcePermissionStatementsOutput(v **ListResourcePermissionStatementsOutput, value interface{}) error {
   1451 	if v == nil {
   1452 		return fmt.Errorf("unexpected nil of type %T", v)
   1453 	}
   1454 	if value == nil {
   1455 		return nil
   1456 	}
   1457 
   1458 	shape, ok := value.(map[string]interface{})
   1459 	if !ok {
   1460 		return fmt.Errorf("unexpected JSON type %v", value)
   1461 	}
   1462 
   1463 	var sv *ListResourcePermissionStatementsOutput
   1464 	if *v == nil {
   1465 		sv = &ListResourcePermissionStatementsOutput{}
   1466 	} else {
   1467 		sv = *v
   1468 	}
   1469 
   1470 	for key, value := range shape {
   1471 		switch key {
   1472 		case "nextToken":
   1473 			if value != nil {
   1474 				jtv, ok := value.(string)
   1475 				if !ok {
   1476 					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
   1477 				}
   1478 				sv.NextToken = ptr.String(jtv)
   1479 			}
   1480 
   1481 		case "permissionStatements":
   1482 			if err := awsRestjson1_deserializeDocumentPermissionStatementSummaries(&sv.PermissionStatements, value); err != nil {
   1483 				return err
   1484 			}
   1485 
   1486 		default:
   1487 			_, _ = key, value
   1488 
   1489 		}
   1490 	}
   1491 	*v = sv
   1492 	return nil
   1493 }
   1494 
   1495 type awsRestjson1_deserializeOpPutConsoleAuthorizationConfiguration struct {
   1496 }
   1497 
   1498 func (*awsRestjson1_deserializeOpPutConsoleAuthorizationConfiguration) ID() string {
   1499 	return "OperationDeserializer"
   1500 }
   1501 
   1502 func (m *awsRestjson1_deserializeOpPutConsoleAuthorizationConfiguration) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   1503 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   1504 ) {
   1505 	out, metadata, err = next.HandleDeserialize(ctx, in)
   1506 	if err != nil {
   1507 		return out, metadata, err
   1508 	}
   1509 
   1510 	response, ok := out.RawResponse.(*smithyhttp.Response)
   1511 	if !ok {
   1512 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   1513 	}
   1514 
   1515 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   1516 
   1517 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   1518 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   1519 	defer endTimer()
   1520 	defer span.End()
   1521 
   1522 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   1523 		return out, metadata, awsRestjson1_deserializeOpErrorPutConsoleAuthorizationConfiguration(response, &metadata)
   1524 	}
   1525 	output := &PutConsoleAuthorizationConfigurationOutput{}
   1526 	out.Result = output
   1527 
   1528 	var buff [1024]byte
   1529 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1530 
   1531 	body := io.TeeReader(response.Body, ringBuffer)
   1532 
   1533 	decoder := json.NewDecoder(body)
   1534 	decoder.UseNumber()
   1535 	var shape interface{}
   1536 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
   1537 		var snapshot bytes.Buffer
   1538 		io.Copy(&snapshot, ringBuffer)
   1539 		err = &smithy.DeserializationError{
   1540 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1541 			Snapshot: snapshot.Bytes(),
   1542 		}
   1543 		return out, metadata, err
   1544 	}
   1545 
   1546 	err = awsRestjson1_deserializeOpDocumentPutConsoleAuthorizationConfigurationOutput(&output, shape)
   1547 	if err != nil {
   1548 		var snapshot bytes.Buffer
   1549 		io.Copy(&snapshot, ringBuffer)
   1550 		return out, metadata, &smithy.DeserializationError{
   1551 			Err:      fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
   1552 			Snapshot: snapshot.Bytes(),
   1553 		}
   1554 	}
   1555 
   1556 	span.End()
   1557 	return out, metadata, err
   1558 }
   1559 
   1560 func awsRestjson1_deserializeOpErrorPutConsoleAuthorizationConfiguration(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   1561 	var errorBuffer bytes.Buffer
   1562 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   1563 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   1564 	}
   1565 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   1566 
   1567 	errorCode := "UnknownError"
   1568 	errorMessage := errorCode
   1569 
   1570 	headerCode := response.Header.Get("X-Amzn-ErrorType")
   1571 	if len(headerCode) != 0 {
   1572 		errorCode = restjson.SanitizeErrorCode(headerCode)
   1573 	}
   1574 
   1575 	var buff [1024]byte
   1576 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1577 
   1578 	body := io.TeeReader(errorBody, ringBuffer)
   1579 	decoder := json.NewDecoder(body)
   1580 	decoder.UseNumber()
   1581 	jsonCode, message, err := restjson.GetErrorInfo(decoder)
   1582 	if err != nil {
   1583 		var snapshot bytes.Buffer
   1584 		io.Copy(&snapshot, ringBuffer)
   1585 		err = &smithy.DeserializationError{
   1586 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1587 			Snapshot: snapshot.Bytes(),
   1588 		}
   1589 		return err
   1590 	}
   1591 
   1592 	errorBody.Seek(0, io.SeekStart)
   1593 	if len(headerCode) == 0 && len(jsonCode) != 0 {
   1594 		errorCode = restjson.SanitizeErrorCode(jsonCode)
   1595 	}
   1596 	if len(message) != 0 {
   1597 		errorMessage = message
   1598 	}
   1599 
   1600 	switch {
   1601 	case strings.EqualFold("AccessDeniedException", errorCode):
   1602 		return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
   1603 
   1604 	case strings.EqualFold("ConflictException", errorCode):
   1605 		return awsRestjson1_deserializeErrorConflictException(response, errorBody)
   1606 
   1607 	case strings.EqualFold("InternalServerException", errorCode):
   1608 		return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
   1609 
   1610 	case strings.EqualFold("ResourceNotFoundException", errorCode):
   1611 		return awsRestjson1_deserializeErrorResourceNotFoundException(response, errorBody)
   1612 
   1613 	case strings.EqualFold("TooManyRequestsError", errorCode):
   1614 		return awsRestjson1_deserializeErrorTooManyRequestsError(response, errorBody)
   1615 
   1616 	case strings.EqualFold("ValidationException", errorCode):
   1617 		return awsRestjson1_deserializeErrorValidationException(response, errorBody)
   1618 
   1619 	default:
   1620 		genericError := &smithy.GenericAPIError{
   1621 			Code:    errorCode,
   1622 			Message: errorMessage,
   1623 		}
   1624 		return genericError
   1625 
   1626 	}
   1627 }
   1628 
   1629 func awsRestjson1_deserializeOpDocumentPutConsoleAuthorizationConfigurationOutput(v **PutConsoleAuthorizationConfigurationOutput, value interface{}) error {
   1630 	if v == nil {
   1631 		return fmt.Errorf("unexpected nil of type %T", v)
   1632 	}
   1633 	if value == nil {
   1634 		return nil
   1635 	}
   1636 
   1637 	shape, ok := value.(map[string]interface{})
   1638 	if !ok {
   1639 		return fmt.Errorf("unexpected JSON type %v", value)
   1640 	}
   1641 
   1642 	var sv *PutConsoleAuthorizationConfigurationOutput
   1643 	if *v == nil {
   1644 		sv = &PutConsoleAuthorizationConfigurationOutput{}
   1645 	} else {
   1646 		sv = *v
   1647 	}
   1648 
   1649 	for key, value := range shape {
   1650 		switch key {
   1651 		case "consoleAuthorizationEnabled":
   1652 			if value != nil {
   1653 				jtv, ok := value.(bool)
   1654 				if !ok {
   1655 					return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
   1656 				}
   1657 				sv.ConsoleAuthorizationEnabled = ptr.Bool(jtv)
   1658 			}
   1659 
   1660 		case "scope":
   1661 			if value != nil {
   1662 				jtv, ok := value.(string)
   1663 				if !ok {
   1664 					return fmt.Errorf("expected String to be of type string, got %T instead", value)
   1665 				}
   1666 				sv.Scope = ptr.String(jtv)
   1667 			}
   1668 
   1669 		case "targetId":
   1670 			if value != nil {
   1671 				jtv, ok := value.(string)
   1672 				if !ok {
   1673 					return fmt.Errorf("expected TargetId to be of type string, got %T instead", value)
   1674 				}
   1675 				sv.TargetId = ptr.String(jtv)
   1676 			}
   1677 
   1678 		default:
   1679 			_, _ = key, value
   1680 
   1681 		}
   1682 	}
   1683 	*v = sv
   1684 	return nil
   1685 }
   1686 
   1687 type awsRestjson1_deserializeOpPutResourcePermissionStatement struct {
   1688 }
   1689 
   1690 func (*awsRestjson1_deserializeOpPutResourcePermissionStatement) ID() string {
   1691 	return "OperationDeserializer"
   1692 }
   1693 
   1694 func (m *awsRestjson1_deserializeOpPutResourcePermissionStatement) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   1695 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   1696 ) {
   1697 	out, metadata, err = next.HandleDeserialize(ctx, in)
   1698 	if err != nil {
   1699 		return out, metadata, err
   1700 	}
   1701 
   1702 	response, ok := out.RawResponse.(*smithyhttp.Response)
   1703 	if !ok {
   1704 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   1705 	}
   1706 
   1707 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   1708 
   1709 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   1710 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   1711 	defer endTimer()
   1712 	defer span.End()
   1713 
   1714 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   1715 		return out, metadata, awsRestjson1_deserializeOpErrorPutResourcePermissionStatement(response, &metadata)
   1716 	}
   1717 	output := &PutResourcePermissionStatementOutput{}
   1718 	out.Result = output
   1719 
   1720 	var buff [1024]byte
   1721 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1722 
   1723 	body := io.TeeReader(response.Body, ringBuffer)
   1724 
   1725 	decoder := json.NewDecoder(body)
   1726 	decoder.UseNumber()
   1727 	var shape interface{}
   1728 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
   1729 		var snapshot bytes.Buffer
   1730 		io.Copy(&snapshot, ringBuffer)
   1731 		err = &smithy.DeserializationError{
   1732 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1733 			Snapshot: snapshot.Bytes(),
   1734 		}
   1735 		return out, metadata, err
   1736 	}
   1737 
   1738 	err = awsRestjson1_deserializeOpDocumentPutResourcePermissionStatementOutput(&output, shape)
   1739 	if err != nil {
   1740 		var snapshot bytes.Buffer
   1741 		io.Copy(&snapshot, ringBuffer)
   1742 		return out, metadata, &smithy.DeserializationError{
   1743 			Err:      fmt.Errorf("failed to decode response body with invalid JSON, %w", err),
   1744 			Snapshot: snapshot.Bytes(),
   1745 		}
   1746 	}
   1747 
   1748 	span.End()
   1749 	return out, metadata, err
   1750 }
   1751 
   1752 func awsRestjson1_deserializeOpErrorPutResourcePermissionStatement(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   1753 	var errorBuffer bytes.Buffer
   1754 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   1755 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   1756 	}
   1757 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   1758 
   1759 	errorCode := "UnknownError"
   1760 	errorMessage := errorCode
   1761 
   1762 	headerCode := response.Header.Get("X-Amzn-ErrorType")
   1763 	if len(headerCode) != 0 {
   1764 		errorCode = restjson.SanitizeErrorCode(headerCode)
   1765 	}
   1766 
   1767 	var buff [1024]byte
   1768 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1769 
   1770 	body := io.TeeReader(errorBody, ringBuffer)
   1771 	decoder := json.NewDecoder(body)
   1772 	decoder.UseNumber()
   1773 	jsonCode, message, err := restjson.GetErrorInfo(decoder)
   1774 	if err != nil {
   1775 		var snapshot bytes.Buffer
   1776 		io.Copy(&snapshot, ringBuffer)
   1777 		err = &smithy.DeserializationError{
   1778 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1779 			Snapshot: snapshot.Bytes(),
   1780 		}
   1781 		return err
   1782 	}
   1783 
   1784 	errorBody.Seek(0, io.SeekStart)
   1785 	if len(headerCode) == 0 && len(jsonCode) != 0 {
   1786 		errorCode = restjson.SanitizeErrorCode(jsonCode)
   1787 	}
   1788 	if len(message) != 0 {
   1789 		errorMessage = message
   1790 	}
   1791 
   1792 	switch {
   1793 	case strings.EqualFold("AccessDeniedException", errorCode):
   1794 		return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
   1795 
   1796 	case strings.EqualFold("ConflictException", errorCode):
   1797 		return awsRestjson1_deserializeErrorConflictException(response, errorBody)
   1798 
   1799 	case strings.EqualFold("InternalServerException", errorCode):
   1800 		return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
   1801 
   1802 	case strings.EqualFold("ServiceQuotaExceededException", errorCode):
   1803 		return awsRestjson1_deserializeErrorServiceQuotaExceededException(response, errorBody)
   1804 
   1805 	case strings.EqualFold("TooManyRequestsError", errorCode):
   1806 		return awsRestjson1_deserializeErrorTooManyRequestsError(response, errorBody)
   1807 
   1808 	case strings.EqualFold("ValidationException", errorCode):
   1809 		return awsRestjson1_deserializeErrorValidationException(response, errorBody)
   1810 
   1811 	default:
   1812 		genericError := &smithy.GenericAPIError{
   1813 			Code:    errorCode,
   1814 			Message: errorMessage,
   1815 		}
   1816 		return genericError
   1817 
   1818 	}
   1819 }
   1820 
   1821 func awsRestjson1_deserializeOpDocumentPutResourcePermissionStatementOutput(v **PutResourcePermissionStatementOutput, value interface{}) error {
   1822 	if v == nil {
   1823 		return fmt.Errorf("unexpected nil of type %T", v)
   1824 	}
   1825 	if value == nil {
   1826 		return nil
   1827 	}
   1828 
   1829 	shape, ok := value.(map[string]interface{})
   1830 	if !ok {
   1831 		return fmt.Errorf("unexpected JSON type %v", value)
   1832 	}
   1833 
   1834 	var sv *PutResourcePermissionStatementOutput
   1835 	if *v == nil {
   1836 		sv = &PutResourcePermissionStatementOutput{}
   1837 	} else {
   1838 		sv = *v
   1839 	}
   1840 
   1841 	for key, value := range shape {
   1842 		switch key {
   1843 		case "statementId":
   1844 			if value != nil {
   1845 				jtv, ok := value.(string)
   1846 				if !ok {
   1847 					return fmt.Errorf("expected StatementId to be of type string, got %T instead", value)
   1848 				}
   1849 				sv.StatementId = ptr.String(jtv)
   1850 			}
   1851 
   1852 		default:
   1853 			_, _ = key, value
   1854 
   1855 		}
   1856 	}
   1857 	*v = sv
   1858 	return nil
   1859 }
   1860 
   1861 type awsRestjson1_deserializeOpRevokeOAuth2TokenWithIAM struct {
   1862 }
   1863 
   1864 func (*awsRestjson1_deserializeOpRevokeOAuth2TokenWithIAM) ID() string {
   1865 	return "OperationDeserializer"
   1866 }
   1867 
   1868 func (m *awsRestjson1_deserializeOpRevokeOAuth2TokenWithIAM) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
   1869 	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
   1870 ) {
   1871 	out, metadata, err = next.HandleDeserialize(ctx, in)
   1872 	if err != nil {
   1873 		return out, metadata, err
   1874 	}
   1875 
   1876 	response, ok := out.RawResponse.(*smithyhttp.Response)
   1877 	if !ok {
   1878 		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
   1879 	}
   1880 
   1881 	defer func() { smithyhttp.CloseResponseBody(ctx, response, false, err) }()
   1882 
   1883 	_, span := tracing.StartSpan(ctx, "OperationDeserializer")
   1884 	endTimer := startMetricTimer(ctx, "client.call.deserialization_duration")
   1885 	defer endTimer()
   1886 	defer span.End()
   1887 
   1888 	if response.StatusCode < 200 || response.StatusCode >= 300 {
   1889 		return out, metadata, awsRestjson1_deserializeOpErrorRevokeOAuth2TokenWithIAM(response, &metadata)
   1890 	}
   1891 	output := &RevokeOAuth2TokenWithIAMOutput{}
   1892 	out.Result = output
   1893 
   1894 	span.End()
   1895 	return out, metadata, err
   1896 }
   1897 
   1898 func awsRestjson1_deserializeOpErrorRevokeOAuth2TokenWithIAM(response *smithyhttp.Response, metadata *middleware.Metadata) error {
   1899 	var errorBuffer bytes.Buffer
   1900 	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
   1901 		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
   1902 	}
   1903 	errorBody := bytes.NewReader(errorBuffer.Bytes())
   1904 
   1905 	errorCode := "UnknownError"
   1906 	errorMessage := errorCode
   1907 
   1908 	headerCode := response.Header.Get("X-Amzn-ErrorType")
   1909 	if len(headerCode) != 0 {
   1910 		errorCode = restjson.SanitizeErrorCode(headerCode)
   1911 	}
   1912 
   1913 	var buff [1024]byte
   1914 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1915 
   1916 	body := io.TeeReader(errorBody, ringBuffer)
   1917 	decoder := json.NewDecoder(body)
   1918 	decoder.UseNumber()
   1919 	jsonCode, message, err := restjson.GetErrorInfo(decoder)
   1920 	if err != nil {
   1921 		var snapshot bytes.Buffer
   1922 		io.Copy(&snapshot, ringBuffer)
   1923 		err = &smithy.DeserializationError{
   1924 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1925 			Snapshot: snapshot.Bytes(),
   1926 		}
   1927 		return err
   1928 	}
   1929 
   1930 	errorBody.Seek(0, io.SeekStart)
   1931 	if len(headerCode) == 0 && len(jsonCode) != 0 {
   1932 		errorCode = restjson.SanitizeErrorCode(jsonCode)
   1933 	}
   1934 	if len(message) != 0 {
   1935 		errorMessage = message
   1936 	}
   1937 
   1938 	switch {
   1939 	case strings.EqualFold("AccessDeniedException", errorCode):
   1940 		return awsRestjson1_deserializeErrorAccessDeniedException(response, errorBody)
   1941 
   1942 	case strings.EqualFold("InternalServerException", errorCode):
   1943 		return awsRestjson1_deserializeErrorInternalServerException(response, errorBody)
   1944 
   1945 	case strings.EqualFold("TooManyRequestsError", errorCode):
   1946 		return awsRestjson1_deserializeErrorTooManyRequestsError(response, errorBody)
   1947 
   1948 	case strings.EqualFold("ValidationException", errorCode):
   1949 		return awsRestjson1_deserializeErrorValidationException(response, errorBody)
   1950 
   1951 	default:
   1952 		genericError := &smithy.GenericAPIError{
   1953 			Code:    errorCode,
   1954 			Message: errorMessage,
   1955 		}
   1956 		return genericError
   1957 
   1958 	}
   1959 }
   1960 
   1961 func awsRestjson1_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
   1962 	output := &types.AccessDeniedException{}
   1963 	var buff [1024]byte
   1964 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   1965 
   1966 	body := io.TeeReader(errorBody, ringBuffer)
   1967 	decoder := json.NewDecoder(body)
   1968 	decoder.UseNumber()
   1969 	var shape interface{}
   1970 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
   1971 		var snapshot bytes.Buffer
   1972 		io.Copy(&snapshot, ringBuffer)
   1973 		err = &smithy.DeserializationError{
   1974 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1975 			Snapshot: snapshot.Bytes(),
   1976 		}
   1977 		return err
   1978 	}
   1979 
   1980 	err := awsRestjson1_deserializeDocumentAccessDeniedException(&output, shape)
   1981 
   1982 	if err != nil {
   1983 		var snapshot bytes.Buffer
   1984 		io.Copy(&snapshot, ringBuffer)
   1985 		err = &smithy.DeserializationError{
   1986 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   1987 			Snapshot: snapshot.Bytes(),
   1988 		}
   1989 		return err
   1990 	}
   1991 
   1992 	errorBody.Seek(0, io.SeekStart)
   1993 
   1994 	return output
   1995 }
   1996 
   1997 func awsRestjson1_deserializeErrorConflictException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
   1998 	output := &types.ConflictException{}
   1999 	var buff [1024]byte
   2000 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   2001 
   2002 	body := io.TeeReader(errorBody, ringBuffer)
   2003 	decoder := json.NewDecoder(body)
   2004 	decoder.UseNumber()
   2005 	var shape interface{}
   2006 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
   2007 		var snapshot bytes.Buffer
   2008 		io.Copy(&snapshot, ringBuffer)
   2009 		err = &smithy.DeserializationError{
   2010 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2011 			Snapshot: snapshot.Bytes(),
   2012 		}
   2013 		return err
   2014 	}
   2015 
   2016 	err := awsRestjson1_deserializeDocumentConflictException(&output, shape)
   2017 
   2018 	if err != nil {
   2019 		var snapshot bytes.Buffer
   2020 		io.Copy(&snapshot, ringBuffer)
   2021 		err = &smithy.DeserializationError{
   2022 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2023 			Snapshot: snapshot.Bytes(),
   2024 		}
   2025 		return err
   2026 	}
   2027 
   2028 	errorBody.Seek(0, io.SeekStart)
   2029 
   2030 	return output
   2031 }
   2032 
   2033 func awsRestjson1_deserializeErrorInternalServerException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
   2034 	output := &types.InternalServerException{}
   2035 	var buff [1024]byte
   2036 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   2037 
   2038 	body := io.TeeReader(errorBody, ringBuffer)
   2039 	decoder := json.NewDecoder(body)
   2040 	decoder.UseNumber()
   2041 	var shape interface{}
   2042 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
   2043 		var snapshot bytes.Buffer
   2044 		io.Copy(&snapshot, ringBuffer)
   2045 		err = &smithy.DeserializationError{
   2046 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2047 			Snapshot: snapshot.Bytes(),
   2048 		}
   2049 		return err
   2050 	}
   2051 
   2052 	err := awsRestjson1_deserializeDocumentInternalServerException(&output, shape)
   2053 
   2054 	if err != nil {
   2055 		var snapshot bytes.Buffer
   2056 		io.Copy(&snapshot, ringBuffer)
   2057 		err = &smithy.DeserializationError{
   2058 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2059 			Snapshot: snapshot.Bytes(),
   2060 		}
   2061 		return err
   2062 	}
   2063 
   2064 	errorBody.Seek(0, io.SeekStart)
   2065 
   2066 	return output
   2067 }
   2068 
   2069 func awsRestjson1_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
   2070 	output := &types.ResourceNotFoundException{}
   2071 	var buff [1024]byte
   2072 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   2073 
   2074 	body := io.TeeReader(errorBody, ringBuffer)
   2075 	decoder := json.NewDecoder(body)
   2076 	decoder.UseNumber()
   2077 	var shape interface{}
   2078 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
   2079 		var snapshot bytes.Buffer
   2080 		io.Copy(&snapshot, ringBuffer)
   2081 		err = &smithy.DeserializationError{
   2082 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2083 			Snapshot: snapshot.Bytes(),
   2084 		}
   2085 		return err
   2086 	}
   2087 
   2088 	err := awsRestjson1_deserializeDocumentResourceNotFoundException(&output, shape)
   2089 
   2090 	if err != nil {
   2091 		var snapshot bytes.Buffer
   2092 		io.Copy(&snapshot, ringBuffer)
   2093 		err = &smithy.DeserializationError{
   2094 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2095 			Snapshot: snapshot.Bytes(),
   2096 		}
   2097 		return err
   2098 	}
   2099 
   2100 	errorBody.Seek(0, io.SeekStart)
   2101 
   2102 	return output
   2103 }
   2104 
   2105 func awsRestjson1_deserializeErrorServiceQuotaExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
   2106 	output := &types.ServiceQuotaExceededException{}
   2107 	var buff [1024]byte
   2108 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   2109 
   2110 	body := io.TeeReader(errorBody, ringBuffer)
   2111 	decoder := json.NewDecoder(body)
   2112 	decoder.UseNumber()
   2113 	var shape interface{}
   2114 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
   2115 		var snapshot bytes.Buffer
   2116 		io.Copy(&snapshot, ringBuffer)
   2117 		err = &smithy.DeserializationError{
   2118 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2119 			Snapshot: snapshot.Bytes(),
   2120 		}
   2121 		return err
   2122 	}
   2123 
   2124 	err := awsRestjson1_deserializeDocumentServiceQuotaExceededException(&output, shape)
   2125 
   2126 	if err != nil {
   2127 		var snapshot bytes.Buffer
   2128 		io.Copy(&snapshot, ringBuffer)
   2129 		err = &smithy.DeserializationError{
   2130 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2131 			Snapshot: snapshot.Bytes(),
   2132 		}
   2133 		return err
   2134 	}
   2135 
   2136 	errorBody.Seek(0, io.SeekStart)
   2137 
   2138 	return output
   2139 }
   2140 
   2141 func awsRestjson1_deserializeErrorTooManyRequestsError(response *smithyhttp.Response, errorBody *bytes.Reader) error {
   2142 	output := &types.TooManyRequestsError{}
   2143 	var buff [1024]byte
   2144 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   2145 
   2146 	body := io.TeeReader(errorBody, ringBuffer)
   2147 	decoder := json.NewDecoder(body)
   2148 	decoder.UseNumber()
   2149 	var shape interface{}
   2150 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
   2151 		var snapshot bytes.Buffer
   2152 		io.Copy(&snapshot, ringBuffer)
   2153 		err = &smithy.DeserializationError{
   2154 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2155 			Snapshot: snapshot.Bytes(),
   2156 		}
   2157 		return err
   2158 	}
   2159 
   2160 	err := awsRestjson1_deserializeDocumentTooManyRequestsError(&output, shape)
   2161 
   2162 	if err != nil {
   2163 		var snapshot bytes.Buffer
   2164 		io.Copy(&snapshot, ringBuffer)
   2165 		err = &smithy.DeserializationError{
   2166 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2167 			Snapshot: snapshot.Bytes(),
   2168 		}
   2169 		return err
   2170 	}
   2171 
   2172 	errorBody.Seek(0, io.SeekStart)
   2173 
   2174 	return output
   2175 }
   2176 
   2177 func awsRestjson1_deserializeErrorValidationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
   2178 	output := &types.ValidationException{}
   2179 	var buff [1024]byte
   2180 	ringBuffer := smithyio.NewRingBuffer(buff[:])
   2181 
   2182 	body := io.TeeReader(errorBody, ringBuffer)
   2183 	decoder := json.NewDecoder(body)
   2184 	decoder.UseNumber()
   2185 	var shape interface{}
   2186 	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
   2187 		var snapshot bytes.Buffer
   2188 		io.Copy(&snapshot, ringBuffer)
   2189 		err = &smithy.DeserializationError{
   2190 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2191 			Snapshot: snapshot.Bytes(),
   2192 		}
   2193 		return err
   2194 	}
   2195 
   2196 	err := awsRestjson1_deserializeDocumentValidationException(&output, shape)
   2197 
   2198 	if err != nil {
   2199 		var snapshot bytes.Buffer
   2200 		io.Copy(&snapshot, ringBuffer)
   2201 		err = &smithy.DeserializationError{
   2202 			Err:      fmt.Errorf("failed to decode response body, %w", err),
   2203 			Snapshot: snapshot.Bytes(),
   2204 		}
   2205 		return err
   2206 	}
   2207 
   2208 	errorBody.Seek(0, io.SeekStart)
   2209 
   2210 	return output
   2211 }
   2212 
   2213 func awsRestjson1_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error {
   2214 	if v == nil {
   2215 		return fmt.Errorf("unexpected nil of type %T", v)
   2216 	}
   2217 	if value == nil {
   2218 		return nil
   2219 	}
   2220 
   2221 	shape, ok := value.(map[string]interface{})
   2222 	if !ok {
   2223 		return fmt.Errorf("unexpected JSON type %v", value)
   2224 	}
   2225 
   2226 	var sv *types.AccessDeniedException
   2227 	if *v == nil {
   2228 		sv = &types.AccessDeniedException{}
   2229 	} else {
   2230 		sv = *v
   2231 	}
   2232 
   2233 	for key, value := range shape {
   2234 		switch key {
   2235 		case "error":
   2236 			if value != nil {
   2237 				jtv, ok := value.(string)
   2238 				if !ok {
   2239 					return fmt.Errorf("expected OAuth2ErrorCode to be of type string, got %T instead", value)
   2240 				}
   2241 				sv.Error_ = types.OAuth2ErrorCode(jtv)
   2242 			}
   2243 
   2244 		case "message", "Message":
   2245 			if value != nil {
   2246 				jtv, ok := value.(string)
   2247 				if !ok {
   2248 					return fmt.Errorf("expected String to be of type string, got %T instead", value)
   2249 				}
   2250 				sv.Message = ptr.String(jtv)
   2251 			}
   2252 
   2253 		default:
   2254 			_, _ = key, value
   2255 
   2256 		}
   2257 	}
   2258 	*v = sv
   2259 	return nil
   2260 }
   2261 
   2262 func awsRestjson1_deserializeDocumentAccessToken(v **types.AccessToken, value interface{}) error {
   2263 	if v == nil {
   2264 		return fmt.Errorf("unexpected nil of type %T", v)
   2265 	}
   2266 	if value == nil {
   2267 		return nil
   2268 	}
   2269 
   2270 	shape, ok := value.(map[string]interface{})
   2271 	if !ok {
   2272 		return fmt.Errorf("unexpected JSON type %v", value)
   2273 	}
   2274 
   2275 	var sv *types.AccessToken
   2276 	if *v == nil {
   2277 		sv = &types.AccessToken{}
   2278 	} else {
   2279 		sv = *v
   2280 	}
   2281 
   2282 	for key, value := range shape {
   2283 		switch key {
   2284 		case "accessKeyId":
   2285 			if value != nil {
   2286 				jtv, ok := value.(string)
   2287 				if !ok {
   2288 					return fmt.Errorf("expected String to be of type string, got %T instead", value)
   2289 				}
   2290 				sv.AccessKeyId = ptr.String(jtv)
   2291 			}
   2292 
   2293 		case "secretAccessKey":
   2294 			if value != nil {
   2295 				jtv, ok := value.(string)
   2296 				if !ok {
   2297 					return fmt.Errorf("expected String to be of type string, got %T instead", value)
   2298 				}
   2299 				sv.SecretAccessKey = ptr.String(jtv)
   2300 			}
   2301 
   2302 		case "sessionToken":
   2303 			if value != nil {
   2304 				jtv, ok := value.(string)
   2305 				if !ok {
   2306 					return fmt.Errorf("expected String to be of type string, got %T instead", value)
   2307 				}
   2308 				sv.SessionToken = ptr.String(jtv)
   2309 			}
   2310 
   2311 		default:
   2312 			_, _ = key, value
   2313 
   2314 		}
   2315 	}
   2316 	*v = sv
   2317 	return nil
   2318 }
   2319 
   2320 func awsRestjson1_deserializeDocumentCondition(v *map[string][]string, value interface{}) error {
   2321 	if v == nil {
   2322 		return fmt.Errorf("unexpected nil of type %T", v)
   2323 	}
   2324 	if value == nil {
   2325 		return nil
   2326 	}
   2327 
   2328 	shape, ok := value.(map[string]interface{})
   2329 	if !ok {
   2330 		return fmt.Errorf("unexpected JSON type %v", value)
   2331 	}
   2332 
   2333 	var mv map[string][]string
   2334 	if *v == nil {
   2335 		mv = map[string][]string{}
   2336 	} else {
   2337 		mv = *v
   2338 	}
   2339 
   2340 	for key, value := range shape {
   2341 		var parsedVal []string
   2342 		mapVar := parsedVal
   2343 		if err := awsRestjson1_deserializeDocumentConditionValues(&mapVar, value); err != nil {
   2344 			return err
   2345 		}
   2346 		parsedVal = mapVar
   2347 		mv[key] = parsedVal
   2348 
   2349 	}
   2350 	*v = mv
   2351 	return nil
   2352 }
   2353 
   2354 func awsRestjson1_deserializeDocumentConditionBlock(v *map[string]map[string][]string, value interface{}) error {
   2355 	if v == nil {
   2356 		return fmt.Errorf("unexpected nil of type %T", v)
   2357 	}
   2358 	if value == nil {
   2359 		return nil
   2360 	}
   2361 
   2362 	shape, ok := value.(map[string]interface{})
   2363 	if !ok {
   2364 		return fmt.Errorf("unexpected JSON type %v", value)
   2365 	}
   2366 
   2367 	var mv map[string]map[string][]string
   2368 	if *v == nil {
   2369 		mv = map[string]map[string][]string{}
   2370 	} else {
   2371 		mv = *v
   2372 	}
   2373 
   2374 	for key, value := range shape {
   2375 		var parsedVal map[string][]string
   2376 		mapVar := parsedVal
   2377 		if err := awsRestjson1_deserializeDocumentCondition(&mapVar, value); err != nil {
   2378 			return err
   2379 		}
   2380 		parsedVal = mapVar
   2381 		mv[key] = parsedVal
   2382 
   2383 	}
   2384 	*v = mv
   2385 	return nil
   2386 }
   2387 
   2388 func awsRestjson1_deserializeDocumentConditionValues(v *[]string, value interface{}) error {
   2389 	if v == nil {
   2390 		return fmt.Errorf("unexpected nil of type %T", v)
   2391 	}
   2392 	if value == nil {
   2393 		return nil
   2394 	}
   2395 
   2396 	shape, ok := value.([]interface{})
   2397 	if !ok {
   2398 		return fmt.Errorf("unexpected JSON type %v", value)
   2399 	}
   2400 
   2401 	var cv []string
   2402 	if *v == nil {
   2403 		cv = []string{}
   2404 	} else {
   2405 		cv = *v
   2406 	}
   2407 
   2408 	for _, value := range shape {
   2409 		var col string
   2410 		if value != nil {
   2411 			jtv, ok := value.(string)
   2412 			if !ok {
   2413 				return fmt.Errorf("expected String to be of type string, got %T instead", value)
   2414 			}
   2415 			col = jtv
   2416 		}
   2417 		cv = append(cv, col)
   2418 
   2419 	}
   2420 	*v = cv
   2421 	return nil
   2422 }
   2423 
   2424 func awsRestjson1_deserializeDocumentConflictException(v **types.ConflictException, value interface{}) error {
   2425 	if v == nil {
   2426 		return fmt.Errorf("unexpected nil of type %T", v)
   2427 	}
   2428 	if value == nil {
   2429 		return nil
   2430 	}
   2431 
   2432 	shape, ok := value.(map[string]interface{})
   2433 	if !ok {
   2434 		return fmt.Errorf("unexpected JSON type %v", value)
   2435 	}
   2436 
   2437 	var sv *types.ConflictException
   2438 	if *v == nil {
   2439 		sv = &types.ConflictException{}
   2440 	} else {
   2441 		sv = *v
   2442 	}
   2443 
   2444 	for key, value := range shape {
   2445 		switch key {
   2446 		case "error":
   2447 			if value != nil {
   2448 				jtv, ok := value.(string)
   2449 				if !ok {
   2450 					return fmt.Errorf("expected OAuth2ErrorCode to be of type string, got %T instead", value)
   2451 				}
   2452 				sv.Error_ = types.OAuth2ErrorCode(jtv)
   2453 			}
   2454 
   2455 		case "message", "Message":
   2456 			if value != nil {
   2457 				jtv, ok := value.(string)
   2458 				if !ok {
   2459 					return fmt.Errorf("expected String to be of type string, got %T instead", value)
   2460 				}
   2461 				sv.Message = ptr.String(jtv)
   2462 			}
   2463 
   2464 		default:
   2465 			_, _ = key, value
   2466 
   2467 		}
   2468 	}
   2469 	*v = sv
   2470 	return nil
   2471 }
   2472 
   2473 func awsRestjson1_deserializeDocumentCreateOAuth2TokenResponseBody(v **types.CreateOAuth2TokenResponseBody, value interface{}) error {
   2474 	if v == nil {
   2475 		return fmt.Errorf("unexpected nil of type %T", v)
   2476 	}
   2477 	if value == nil {
   2478 		return nil
   2479 	}
   2480 
   2481 	shape, ok := value.(map[string]interface{})
   2482 	if !ok {
   2483 		return fmt.Errorf("unexpected JSON type %v", value)
   2484 	}
   2485 
   2486 	var sv *types.CreateOAuth2TokenResponseBody
   2487 	if *v == nil {
   2488 		sv = &types.CreateOAuth2TokenResponseBody{}
   2489 	} else {
   2490 		sv = *v
   2491 	}
   2492 
   2493 	for key, value := range shape {
   2494 		switch key {
   2495 		case "accessToken":
   2496 			if err := awsRestjson1_deserializeDocumentAccessToken(&sv.AccessToken, value); err != nil {
   2497 				return err
   2498 			}
   2499 
   2500 		case "expiresIn":
   2501 			if value != nil {
   2502 				jtv, ok := value.(json.Number)
   2503 				if !ok {
   2504 					return fmt.Errorf("expected ExpiresIn to be json.Number, got %T instead", value)
   2505 				}
   2506 				i64, err := jtv.Int64()
   2507 				if err != nil {
   2508 					return err
   2509 				}
   2510 				sv.ExpiresIn = ptr.Int32(int32(i64))
   2511 			}
   2512 
   2513 		case "idToken":
   2514 			if value != nil {
   2515 				jtv, ok := value.(string)
   2516 				if !ok {
   2517 					return fmt.Errorf("expected IdToken to be of type string, got %T instead", value)
   2518 				}
   2519 				sv.IdToken = ptr.String(jtv)
   2520 			}
   2521 
   2522 		case "refreshToken":
   2523 			if value != nil {
   2524 				jtv, ok := value.(string)
   2525 				if !ok {
   2526 					return fmt.Errorf("expected RefreshToken to be of type string, got %T instead", value)
   2527 				}
   2528 				sv.RefreshToken = ptr.String(jtv)
   2529 			}
   2530 
   2531 		case "tokenType":
   2532 			if value != nil {
   2533 				jtv, ok := value.(string)
   2534 				if !ok {
   2535 					return fmt.Errorf("expected TokenType to be of type string, got %T instead", value)
   2536 				}
   2537 				sv.TokenType = ptr.String(jtv)
   2538 			}
   2539 
   2540 		default:
   2541 			_, _ = key, value
   2542 
   2543 		}
   2544 	}
   2545 	*v = sv
   2546 	return nil
   2547 }
   2548 
   2549 func awsRestjson1_deserializeDocumentInternalServerException(v **types.InternalServerException, value interface{}) error {
   2550 	if v == nil {
   2551 		return fmt.Errorf("unexpected nil of type %T", v)
   2552 	}
   2553 	if value == nil {
   2554 		return nil
   2555 	}
   2556 
   2557 	shape, ok := value.(map[string]interface{})
   2558 	if !ok {
   2559 		return fmt.Errorf("unexpected JSON type %v", value)
   2560 	}
   2561 
   2562 	var sv *types.InternalServerException
   2563 	if *v == nil {
   2564 		sv = &types.InternalServerException{}
   2565 	} else {
   2566 		sv = *v
   2567 	}
   2568 
   2569 	for key, value := range shape {
   2570 		switch key {
   2571 		case "error":
   2572 			if value != nil {
   2573 				jtv, ok := value.(string)
   2574 				if !ok {
   2575 					return fmt.Errorf("expected OAuth2ErrorCode to be of type string, got %T instead", value)
   2576 				}
   2577 				sv.Error_ = types.OAuth2ErrorCode(jtv)
   2578 			}
   2579 
   2580 		case "message", "Message":
   2581 			if value != nil {
   2582 				jtv, ok := value.(string)
   2583 				if !ok {
   2584 					return fmt.Errorf("expected String to be of type string, got %T instead", value)
   2585 				}
   2586 				sv.Message = ptr.String(jtv)
   2587 			}
   2588 
   2589 		default:
   2590 			_, _ = key, value
   2591 
   2592 		}
   2593 	}
   2594 	*v = sv
   2595 	return nil
   2596 }
   2597 
   2598 func awsRestjson1_deserializeDocumentPermissionStatementSummaries(v *[]types.PermissionStatementSummary, value interface{}) error {
   2599 	if v == nil {
   2600 		return fmt.Errorf("unexpected nil of type %T", v)
   2601 	}
   2602 	if value == nil {
   2603 		return nil
   2604 	}
   2605 
   2606 	shape, ok := value.([]interface{})
   2607 	if !ok {
   2608 		return fmt.Errorf("unexpected JSON type %v", value)
   2609 	}
   2610 
   2611 	var cv []types.PermissionStatementSummary
   2612 	if *v == nil {
   2613 		cv = []types.PermissionStatementSummary{}
   2614 	} else {
   2615 		cv = *v
   2616 	}
   2617 
   2618 	for _, value := range shape {
   2619 		var col types.PermissionStatementSummary
   2620 		destAddr := &col
   2621 		if err := awsRestjson1_deserializeDocumentPermissionStatementSummary(&destAddr, value); err != nil {
   2622 			return err
   2623 		}
   2624 		col = *destAddr
   2625 		cv = append(cv, col)
   2626 
   2627 	}
   2628 	*v = cv
   2629 	return nil
   2630 }
   2631 
   2632 func awsRestjson1_deserializeDocumentPermissionStatementSummary(v **types.PermissionStatementSummary, value interface{}) error {
   2633 	if v == nil {
   2634 		return fmt.Errorf("unexpected nil of type %T", v)
   2635 	}
   2636 	if value == nil {
   2637 		return nil
   2638 	}
   2639 
   2640 	shape, ok := value.(map[string]interface{})
   2641 	if !ok {
   2642 		return fmt.Errorf("unexpected JSON type %v", value)
   2643 	}
   2644 
   2645 	var sv *types.PermissionStatementSummary
   2646 	if *v == nil {
   2647 		sv = &types.PermissionStatementSummary{}
   2648 	} else {
   2649 		sv = *v
   2650 	}
   2651 
   2652 	for key, value := range shape {
   2653 		switch key {
   2654 		case "condition":
   2655 			if err := awsRestjson1_deserializeDocumentConditionBlock(&sv.Condition, value); err != nil {
   2656 				return err
   2657 			}
   2658 
   2659 		case "sid":
   2660 			if value != nil {
   2661 				jtv, ok := value.(string)
   2662 				if !ok {
   2663 					return fmt.Errorf("expected StatementId to be of type string, got %T instead", value)
   2664 				}
   2665 				sv.Sid = ptr.String(jtv)
   2666 			}
   2667 
   2668 		default:
   2669 			_, _ = key, value
   2670 
   2671 		}
   2672 	}
   2673 	*v = sv
   2674 	return nil
   2675 }
   2676 
   2677 func awsRestjson1_deserializeDocumentPolicyActions(v *[]string, value interface{}) error {
   2678 	if v == nil {
   2679 		return fmt.Errorf("unexpected nil of type %T", v)
   2680 	}
   2681 	if value == nil {
   2682 		return nil
   2683 	}
   2684 
   2685 	shape, ok := value.([]interface{})
   2686 	if !ok {
   2687 		return fmt.Errorf("unexpected JSON type %v", value)
   2688 	}
   2689 
   2690 	var cv []string
   2691 	if *v == nil {
   2692 		cv = []string{}
   2693 	} else {
   2694 		cv = *v
   2695 	}
   2696 
   2697 	for _, value := range shape {
   2698 		var col string
   2699 		if value != nil {
   2700 			jtv, ok := value.(string)
   2701 			if !ok {
   2702 				return fmt.Errorf("expected String to be of type string, got %T instead", value)
   2703 			}
   2704 			col = jtv
   2705 		}
   2706 		cv = append(cv, col)
   2707 
   2708 	}
   2709 	*v = cv
   2710 	return nil
   2711 }
   2712 
   2713 func awsRestjson1_deserializeDocumentPolicyStatement(v **types.PolicyStatement, value interface{}) error {
   2714 	if v == nil {
   2715 		return fmt.Errorf("unexpected nil of type %T", v)
   2716 	}
   2717 	if value == nil {
   2718 		return nil
   2719 	}
   2720 
   2721 	shape, ok := value.(map[string]interface{})
   2722 	if !ok {
   2723 		return fmt.Errorf("unexpected JSON type %v", value)
   2724 	}
   2725 
   2726 	var sv *types.PolicyStatement
   2727 	if *v == nil {
   2728 		sv = &types.PolicyStatement{}
   2729 	} else {
   2730 		sv = *v
   2731 	}
   2732 
   2733 	for key, value := range shape {
   2734 		switch key {
   2735 		case "Action":
   2736 			if err := awsRestjson1_deserializeDocumentPolicyActions(&sv.Action, value); err != nil {
   2737 				return err
   2738 			}
   2739 
   2740 		case "Condition":
   2741 			if err := awsRestjson1_deserializeDocumentConditionBlock(&sv.Condition, value); err != nil {
   2742 				return err
   2743 			}
   2744 
   2745 		case "Effect":
   2746 			if value != nil {
   2747 				jtv, ok := value.(string)
   2748 				if !ok {
   2749 					return fmt.Errorf("expected String to be of type string, got %T instead", value)
   2750 				}
   2751 				sv.Effect = ptr.String(jtv)
   2752 			}
   2753 
   2754 		case "Principal":
   2755 			if err := awsRestjson1_deserializeDocumentPrincipal(&sv.Principal, value); err != nil {
   2756 				return err
   2757 			}
   2758 
   2759 		case "Resource":
   2760 			if value != nil {
   2761 				jtv, ok := value.(string)
   2762 				if !ok {
   2763 					return fmt.Errorf("expected String to be of type string, got %T instead", value)
   2764 				}
   2765 				sv.Resource = ptr.String(jtv)
   2766 			}
   2767 
   2768 		default:
   2769 			_, _ = key, value
   2770 
   2771 		}
   2772 	}
   2773 	*v = sv
   2774 	return nil
   2775 }
   2776 
   2777 func awsRestjson1_deserializeDocumentPolicyStatements(v *[]types.PolicyStatement, value interface{}) error {
   2778 	if v == nil {
   2779 		return fmt.Errorf("unexpected nil of type %T", v)
   2780 	}
   2781 	if value == nil {
   2782 		return nil
   2783 	}
   2784 
   2785 	shape, ok := value.([]interface{})
   2786 	if !ok {
   2787 		return fmt.Errorf("unexpected JSON type %v", value)
   2788 	}
   2789 
   2790 	var cv []types.PolicyStatement
   2791 	if *v == nil {
   2792 		cv = []types.PolicyStatement{}
   2793 	} else {
   2794 		cv = *v
   2795 	}
   2796 
   2797 	for _, value := range shape {
   2798 		var col types.PolicyStatement
   2799 		destAddr := &col
   2800 		if err := awsRestjson1_deserializeDocumentPolicyStatement(&destAddr, value); err != nil {
   2801 			return err
   2802 		}
   2803 		col = *destAddr
   2804 		cv = append(cv, col)
   2805 
   2806 	}
   2807 	*v = cv
   2808 	return nil
   2809 }
   2810 
   2811 func awsRestjson1_deserializeDocumentPrincipal(v *map[string]string, value interface{}) error {
   2812 	if v == nil {
   2813 		return fmt.Errorf("unexpected nil of type %T", v)
   2814 	}
   2815 	if value == nil {
   2816 		return nil
   2817 	}
   2818 
   2819 	shape, ok := value.(map[string]interface{})
   2820 	if !ok {
   2821 		return fmt.Errorf("unexpected JSON type %v", value)
   2822 	}
   2823 
   2824 	var mv map[string]string
   2825 	if *v == nil {
   2826 		mv = map[string]string{}
   2827 	} else {
   2828 		mv = *v
   2829 	}
   2830 
   2831 	for key, value := range shape {
   2832 		var parsedVal string
   2833 		if value != nil {
   2834 			jtv, ok := value.(string)
   2835 			if !ok {
   2836 				return fmt.Errorf("expected String to be of type string, got %T instead", value)
   2837 			}
   2838 			parsedVal = jtv
   2839 		}
   2840 		mv[key] = parsedVal
   2841 
   2842 	}
   2843 	*v = mv
   2844 	return nil
   2845 }
   2846 
   2847 func awsRestjson1_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error {
   2848 	if v == nil {
   2849 		return fmt.Errorf("unexpected nil of type %T", v)
   2850 	}
   2851 	if value == nil {
   2852 		return nil
   2853 	}
   2854 
   2855 	shape, ok := value.(map[string]interface{})
   2856 	if !ok {
   2857 		return fmt.Errorf("unexpected JSON type %v", value)
   2858 	}
   2859 
   2860 	var sv *types.ResourceNotFoundException
   2861 	if *v == nil {
   2862 		sv = &types.ResourceNotFoundException{}
   2863 	} else {
   2864 		sv = *v
   2865 	}
   2866 
   2867 	for key, value := range shape {
   2868 		switch key {
   2869 		case "error":
   2870 			if value != nil {
   2871 				jtv, ok := value.(string)
   2872 				if !ok {
   2873 					return fmt.Errorf("expected OAuth2ErrorCode to be of type string, got %T instead", value)
   2874 				}
   2875 				sv.Error_ = types.OAuth2ErrorCode(jtv)
   2876 			}
   2877 
   2878 		case "message", "Message":
   2879 			if value != nil {
   2880 				jtv, ok := value.(string)
   2881 				if !ok {
   2882 					return fmt.Errorf("expected String to be of type string, got %T instead", value)
   2883 				}
   2884 				sv.Message = ptr.String(jtv)
   2885 			}
   2886 
   2887 		default:
   2888 			_, _ = key, value
   2889 
   2890 		}
   2891 	}
   2892 	*v = sv
   2893 	return nil
   2894 }
   2895 
   2896 func awsRestjson1_deserializeDocumentServiceQuotaExceededException(v **types.ServiceQuotaExceededException, value interface{}) error {
   2897 	if v == nil {
   2898 		return fmt.Errorf("unexpected nil of type %T", v)
   2899 	}
   2900 	if value == nil {
   2901 		return nil
   2902 	}
   2903 
   2904 	shape, ok := value.(map[string]interface{})
   2905 	if !ok {
   2906 		return fmt.Errorf("unexpected JSON type %v", value)
   2907 	}
   2908 
   2909 	var sv *types.ServiceQuotaExceededException
   2910 	if *v == nil {
   2911 		sv = &types.ServiceQuotaExceededException{}
   2912 	} else {
   2913 		sv = *v
   2914 	}
   2915 
   2916 	for key, value := range shape {
   2917 		switch key {
   2918 		case "error":
   2919 			if value != nil {
   2920 				jtv, ok := value.(string)
   2921 				if !ok {
   2922 					return fmt.Errorf("expected OAuth2ErrorCode to be of type string, got %T instead", value)
   2923 				}
   2924 				sv.Error_ = types.OAuth2ErrorCode(jtv)
   2925 			}
   2926 
   2927 		case "message", "Message":
   2928 			if value != nil {
   2929 				jtv, ok := value.(string)
   2930 				if !ok {
   2931 					return fmt.Errorf("expected String to be of type string, got %T instead", value)
   2932 				}
   2933 				sv.Message = ptr.String(jtv)
   2934 			}
   2935 
   2936 		default:
   2937 			_, _ = key, value
   2938 
   2939 		}
   2940 	}
   2941 	*v = sv
   2942 	return nil
   2943 }
   2944 
   2945 func awsRestjson1_deserializeDocumentSigninResourceBasedPolicy(v **types.SigninResourceBasedPolicy, value interface{}) error {
   2946 	if v == nil {
   2947 		return fmt.Errorf("unexpected nil of type %T", v)
   2948 	}
   2949 	if value == nil {
   2950 		return nil
   2951 	}
   2952 
   2953 	shape, ok := value.(map[string]interface{})
   2954 	if !ok {
   2955 		return fmt.Errorf("unexpected JSON type %v", value)
   2956 	}
   2957 
   2958 	var sv *types.SigninResourceBasedPolicy
   2959 	if *v == nil {
   2960 		sv = &types.SigninResourceBasedPolicy{}
   2961 	} else {
   2962 		sv = *v
   2963 	}
   2964 
   2965 	for key, value := range shape {
   2966 		switch key {
   2967 		case "Statement":
   2968 			if err := awsRestjson1_deserializeDocumentPolicyStatements(&sv.Statement, value); err != nil {
   2969 				return err
   2970 			}
   2971 
   2972 		case "Version":
   2973 			if value != nil {
   2974 				jtv, ok := value.(string)
   2975 				if !ok {
   2976 					return fmt.Errorf("expected String to be of type string, got %T instead", value)
   2977 				}
   2978 				sv.Version = ptr.String(jtv)
   2979 			}
   2980 
   2981 		default:
   2982 			_, _ = key, value
   2983 
   2984 		}
   2985 	}
   2986 	*v = sv
   2987 	return nil
   2988 }
   2989 
   2990 func awsRestjson1_deserializeDocumentTooManyRequestsError(v **types.TooManyRequestsError, value interface{}) error {
   2991 	if v == nil {
   2992 		return fmt.Errorf("unexpected nil of type %T", v)
   2993 	}
   2994 	if value == nil {
   2995 		return nil
   2996 	}
   2997 
   2998 	shape, ok := value.(map[string]interface{})
   2999 	if !ok {
   3000 		return fmt.Errorf("unexpected JSON type %v", value)
   3001 	}
   3002 
   3003 	var sv *types.TooManyRequestsError
   3004 	if *v == nil {
   3005 		sv = &types.TooManyRequestsError{}
   3006 	} else {
   3007 		sv = *v
   3008 	}
   3009 
   3010 	for key, value := range shape {
   3011 		switch key {
   3012 		case "error":
   3013 			if value != nil {
   3014 				jtv, ok := value.(string)
   3015 				if !ok {
   3016 					return fmt.Errorf("expected OAuth2ErrorCode to be of type string, got %T instead", value)
   3017 				}
   3018 				sv.Error_ = types.OAuth2ErrorCode(jtv)
   3019 			}
   3020 
   3021 		case "message", "Message":
   3022 			if value != nil {
   3023 				jtv, ok := value.(string)
   3024 				if !ok {
   3025 					return fmt.Errorf("expected String to be of type string, got %T instead", value)
   3026 				}
   3027 				sv.Message = ptr.String(jtv)
   3028 			}
   3029 
   3030 		default:
   3031 			_, _ = key, value
   3032 
   3033 		}
   3034 	}
   3035 	*v = sv
   3036 	return nil
   3037 }
   3038 
   3039 func awsRestjson1_deserializeDocumentValidationException(v **types.ValidationException, value interface{}) error {
   3040 	if v == nil {
   3041 		return fmt.Errorf("unexpected nil of type %T", v)
   3042 	}
   3043 	if value == nil {
   3044 		return nil
   3045 	}
   3046 
   3047 	shape, ok := value.(map[string]interface{})
   3048 	if !ok {
   3049 		return fmt.Errorf("unexpected JSON type %v", value)
   3050 	}
   3051 
   3052 	var sv *types.ValidationException
   3053 	if *v == nil {
   3054 		sv = &types.ValidationException{}
   3055 	} else {
   3056 		sv = *v
   3057 	}
   3058 
   3059 	for key, value := range shape {
   3060 		switch key {
   3061 		case "error":
   3062 			if value != nil {
   3063 				jtv, ok := value.(string)
   3064 				if !ok {
   3065 					return fmt.Errorf("expected OAuth2ErrorCode to be of type string, got %T instead", value)
   3066 				}
   3067 				sv.Error_ = types.OAuth2ErrorCode(jtv)
   3068 			}
   3069 
   3070 		case "message", "Message":
   3071 			if value != nil {
   3072 				jtv, ok := value.(string)
   3073 				if !ok {
   3074 					return fmt.Errorf("expected String to be of type string, got %T instead", value)
   3075 				}
   3076 				sv.Message = ptr.String(jtv)
   3077 			}
   3078 
   3079 		default:
   3080 			_, _ = key, value
   3081 
   3082 		}
   3083 	}
   3084 	*v = sv
   3085 	return nil
   3086 }
	src Go monorepo.
	git clone git://code.dwrz.net/src
	Log \| Files \| Refs