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