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