1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package organizations
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/organizations/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)
22
23type awsAwsjson11_deserializeOpAcceptHandshake struct {
24}
25
26func (*awsAwsjson11_deserializeOpAcceptHandshake) ID() string {
27	return "OperationDeserializer"
28}
29
30func (m *awsAwsjson11_deserializeOpAcceptHandshake) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
31	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
32) {
33	out, metadata, err = next.HandleDeserialize(ctx, in)
34	if err != nil {
35		return out, metadata, err
36	}
37
38	response, ok := out.RawResponse.(*smithyhttp.Response)
39	if !ok {
40		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
41	}
42
43	if response.StatusCode < 200 || response.StatusCode >= 300 {
44		return out, metadata, awsAwsjson11_deserializeOpErrorAcceptHandshake(response, &metadata)
45	}
46	output := &AcceptHandshakeOutput{}
47	out.Result = output
48
49	var buff [1024]byte
50	ringBuffer := smithyio.NewRingBuffer(buff[:])
51
52	body := io.TeeReader(response.Body, ringBuffer)
53	decoder := json.NewDecoder(body)
54	decoder.UseNumber()
55	var shape interface{}
56	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
57		var snapshot bytes.Buffer
58		io.Copy(&snapshot, ringBuffer)
59		err = &smithy.DeserializationError{
60			Err:      fmt.Errorf("failed to decode response body, %w", err),
61			Snapshot: snapshot.Bytes(),
62		}
63		return out, metadata, err
64	}
65
66	err = awsAwsjson11_deserializeOpDocumentAcceptHandshakeOutput(&output, shape)
67	if err != nil {
68		var snapshot bytes.Buffer
69		io.Copy(&snapshot, ringBuffer)
70		err = &smithy.DeserializationError{
71			Err:      fmt.Errorf("failed to decode response body, %w", err),
72			Snapshot: snapshot.Bytes(),
73		}
74		return out, metadata, err
75	}
76
77	return out, metadata, err
78}
79
80func awsAwsjson11_deserializeOpErrorAcceptHandshake(response *smithyhttp.Response, metadata *middleware.Metadata) error {
81	var errorBuffer bytes.Buffer
82	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
83		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
84	}
85	errorBody := bytes.NewReader(errorBuffer.Bytes())
86
87	errorCode := "UnknownError"
88	errorMessage := errorCode
89
90	code := response.Header.Get("X-Amzn-ErrorType")
91	if len(code) != 0 {
92		errorCode = restjson.SanitizeErrorCode(code)
93	}
94
95	var buff [1024]byte
96	ringBuffer := smithyio.NewRingBuffer(buff[:])
97
98	body := io.TeeReader(errorBody, ringBuffer)
99	decoder := json.NewDecoder(body)
100	decoder.UseNumber()
101	code, message, err := restjson.GetErrorInfo(decoder)
102	if err != nil {
103		var snapshot bytes.Buffer
104		io.Copy(&snapshot, ringBuffer)
105		err = &smithy.DeserializationError{
106			Err:      fmt.Errorf("failed to decode response body, %w", err),
107			Snapshot: snapshot.Bytes(),
108		}
109		return err
110	}
111
112	errorBody.Seek(0, io.SeekStart)
113	if len(code) != 0 {
114		errorCode = restjson.SanitizeErrorCode(code)
115	}
116	if len(message) != 0 {
117		errorMessage = message
118	}
119
120	switch {
121	case strings.EqualFold("AccessDeniedException", errorCode):
122		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
123
124	case strings.EqualFold("AccessDeniedForDependencyException", errorCode):
125		return awsAwsjson11_deserializeErrorAccessDeniedForDependencyException(response, errorBody)
126
127	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
128		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
129
130	case strings.EqualFold("ConcurrentModificationException", errorCode):
131		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
132
133	case strings.EqualFold("HandshakeAlreadyInStateException", errorCode):
134		return awsAwsjson11_deserializeErrorHandshakeAlreadyInStateException(response, errorBody)
135
136	case strings.EqualFold("HandshakeConstraintViolationException", errorCode):
137		return awsAwsjson11_deserializeErrorHandshakeConstraintViolationException(response, errorBody)
138
139	case strings.EqualFold("HandshakeNotFoundException", errorCode):
140		return awsAwsjson11_deserializeErrorHandshakeNotFoundException(response, errorBody)
141
142	case strings.EqualFold("InvalidHandshakeTransitionException", errorCode):
143		return awsAwsjson11_deserializeErrorInvalidHandshakeTransitionException(response, errorBody)
144
145	case strings.EqualFold("InvalidInputException", errorCode):
146		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
147
148	case strings.EqualFold("ServiceException", errorCode):
149		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
150
151	case strings.EqualFold("TooManyRequestsException", errorCode):
152		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
153
154	default:
155		genericError := &smithy.GenericAPIError{
156			Code:    errorCode,
157			Message: errorMessage,
158		}
159		return genericError
160
161	}
162}
163
164type awsAwsjson11_deserializeOpAttachPolicy struct {
165}
166
167func (*awsAwsjson11_deserializeOpAttachPolicy) ID() string {
168	return "OperationDeserializer"
169}
170
171func (m *awsAwsjson11_deserializeOpAttachPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
172	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
173) {
174	out, metadata, err = next.HandleDeserialize(ctx, in)
175	if err != nil {
176		return out, metadata, err
177	}
178
179	response, ok := out.RawResponse.(*smithyhttp.Response)
180	if !ok {
181		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
182	}
183
184	if response.StatusCode < 200 || response.StatusCode >= 300 {
185		return out, metadata, awsAwsjson11_deserializeOpErrorAttachPolicy(response, &metadata)
186	}
187	output := &AttachPolicyOutput{}
188	out.Result = output
189
190	if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
191		return out, metadata, &smithy.DeserializationError{
192			Err: fmt.Errorf("failed to discard response body, %w", err),
193		}
194	}
195
196	return out, metadata, err
197}
198
199func awsAwsjson11_deserializeOpErrorAttachPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
200	var errorBuffer bytes.Buffer
201	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
202		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
203	}
204	errorBody := bytes.NewReader(errorBuffer.Bytes())
205
206	errorCode := "UnknownError"
207	errorMessage := errorCode
208
209	code := response.Header.Get("X-Amzn-ErrorType")
210	if len(code) != 0 {
211		errorCode = restjson.SanitizeErrorCode(code)
212	}
213
214	var buff [1024]byte
215	ringBuffer := smithyio.NewRingBuffer(buff[:])
216
217	body := io.TeeReader(errorBody, ringBuffer)
218	decoder := json.NewDecoder(body)
219	decoder.UseNumber()
220	code, message, err := restjson.GetErrorInfo(decoder)
221	if err != nil {
222		var snapshot bytes.Buffer
223		io.Copy(&snapshot, ringBuffer)
224		err = &smithy.DeserializationError{
225			Err:      fmt.Errorf("failed to decode response body, %w", err),
226			Snapshot: snapshot.Bytes(),
227		}
228		return err
229	}
230
231	errorBody.Seek(0, io.SeekStart)
232	if len(code) != 0 {
233		errorCode = restjson.SanitizeErrorCode(code)
234	}
235	if len(message) != 0 {
236		errorMessage = message
237	}
238
239	switch {
240	case strings.EqualFold("AccessDeniedException", errorCode):
241		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
242
243	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
244		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
245
246	case strings.EqualFold("ConcurrentModificationException", errorCode):
247		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
248
249	case strings.EqualFold("ConstraintViolationException", errorCode):
250		return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody)
251
252	case strings.EqualFold("DuplicatePolicyAttachmentException", errorCode):
253		return awsAwsjson11_deserializeErrorDuplicatePolicyAttachmentException(response, errorBody)
254
255	case strings.EqualFold("InvalidInputException", errorCode):
256		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
257
258	case strings.EqualFold("PolicyChangesInProgressException", errorCode):
259		return awsAwsjson11_deserializeErrorPolicyChangesInProgressException(response, errorBody)
260
261	case strings.EqualFold("PolicyNotFoundException", errorCode):
262		return awsAwsjson11_deserializeErrorPolicyNotFoundException(response, errorBody)
263
264	case strings.EqualFold("PolicyTypeNotEnabledException", errorCode):
265		return awsAwsjson11_deserializeErrorPolicyTypeNotEnabledException(response, errorBody)
266
267	case strings.EqualFold("ServiceException", errorCode):
268		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
269
270	case strings.EqualFold("TargetNotFoundException", errorCode):
271		return awsAwsjson11_deserializeErrorTargetNotFoundException(response, errorBody)
272
273	case strings.EqualFold("TooManyRequestsException", errorCode):
274		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
275
276	case strings.EqualFold("UnsupportedAPIEndpointException", errorCode):
277		return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody)
278
279	default:
280		genericError := &smithy.GenericAPIError{
281			Code:    errorCode,
282			Message: errorMessage,
283		}
284		return genericError
285
286	}
287}
288
289type awsAwsjson11_deserializeOpCancelHandshake struct {
290}
291
292func (*awsAwsjson11_deserializeOpCancelHandshake) ID() string {
293	return "OperationDeserializer"
294}
295
296func (m *awsAwsjson11_deserializeOpCancelHandshake) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
297	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
298) {
299	out, metadata, err = next.HandleDeserialize(ctx, in)
300	if err != nil {
301		return out, metadata, err
302	}
303
304	response, ok := out.RawResponse.(*smithyhttp.Response)
305	if !ok {
306		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
307	}
308
309	if response.StatusCode < 200 || response.StatusCode >= 300 {
310		return out, metadata, awsAwsjson11_deserializeOpErrorCancelHandshake(response, &metadata)
311	}
312	output := &CancelHandshakeOutput{}
313	out.Result = output
314
315	var buff [1024]byte
316	ringBuffer := smithyio.NewRingBuffer(buff[:])
317
318	body := io.TeeReader(response.Body, ringBuffer)
319	decoder := json.NewDecoder(body)
320	decoder.UseNumber()
321	var shape interface{}
322	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
323		var snapshot bytes.Buffer
324		io.Copy(&snapshot, ringBuffer)
325		err = &smithy.DeserializationError{
326			Err:      fmt.Errorf("failed to decode response body, %w", err),
327			Snapshot: snapshot.Bytes(),
328		}
329		return out, metadata, err
330	}
331
332	err = awsAwsjson11_deserializeOpDocumentCancelHandshakeOutput(&output, shape)
333	if err != nil {
334		var snapshot bytes.Buffer
335		io.Copy(&snapshot, ringBuffer)
336		err = &smithy.DeserializationError{
337			Err:      fmt.Errorf("failed to decode response body, %w", err),
338			Snapshot: snapshot.Bytes(),
339		}
340		return out, metadata, err
341	}
342
343	return out, metadata, err
344}
345
346func awsAwsjson11_deserializeOpErrorCancelHandshake(response *smithyhttp.Response, metadata *middleware.Metadata) error {
347	var errorBuffer bytes.Buffer
348	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
349		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
350	}
351	errorBody := bytes.NewReader(errorBuffer.Bytes())
352
353	errorCode := "UnknownError"
354	errorMessage := errorCode
355
356	code := response.Header.Get("X-Amzn-ErrorType")
357	if len(code) != 0 {
358		errorCode = restjson.SanitizeErrorCode(code)
359	}
360
361	var buff [1024]byte
362	ringBuffer := smithyio.NewRingBuffer(buff[:])
363
364	body := io.TeeReader(errorBody, ringBuffer)
365	decoder := json.NewDecoder(body)
366	decoder.UseNumber()
367	code, message, err := restjson.GetErrorInfo(decoder)
368	if err != nil {
369		var snapshot bytes.Buffer
370		io.Copy(&snapshot, ringBuffer)
371		err = &smithy.DeserializationError{
372			Err:      fmt.Errorf("failed to decode response body, %w", err),
373			Snapshot: snapshot.Bytes(),
374		}
375		return err
376	}
377
378	errorBody.Seek(0, io.SeekStart)
379	if len(code) != 0 {
380		errorCode = restjson.SanitizeErrorCode(code)
381	}
382	if len(message) != 0 {
383		errorMessage = message
384	}
385
386	switch {
387	case strings.EqualFold("AccessDeniedException", errorCode):
388		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
389
390	case strings.EqualFold("ConcurrentModificationException", errorCode):
391		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
392
393	case strings.EqualFold("HandshakeAlreadyInStateException", errorCode):
394		return awsAwsjson11_deserializeErrorHandshakeAlreadyInStateException(response, errorBody)
395
396	case strings.EqualFold("HandshakeNotFoundException", errorCode):
397		return awsAwsjson11_deserializeErrorHandshakeNotFoundException(response, errorBody)
398
399	case strings.EqualFold("InvalidHandshakeTransitionException", errorCode):
400		return awsAwsjson11_deserializeErrorInvalidHandshakeTransitionException(response, errorBody)
401
402	case strings.EqualFold("InvalidInputException", errorCode):
403		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
404
405	case strings.EqualFold("ServiceException", errorCode):
406		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
407
408	case strings.EqualFold("TooManyRequestsException", errorCode):
409		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
410
411	default:
412		genericError := &smithy.GenericAPIError{
413			Code:    errorCode,
414			Message: errorMessage,
415		}
416		return genericError
417
418	}
419}
420
421type awsAwsjson11_deserializeOpCreateAccount struct {
422}
423
424func (*awsAwsjson11_deserializeOpCreateAccount) ID() string {
425	return "OperationDeserializer"
426}
427
428func (m *awsAwsjson11_deserializeOpCreateAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
429	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
430) {
431	out, metadata, err = next.HandleDeserialize(ctx, in)
432	if err != nil {
433		return out, metadata, err
434	}
435
436	response, ok := out.RawResponse.(*smithyhttp.Response)
437	if !ok {
438		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
439	}
440
441	if response.StatusCode < 200 || response.StatusCode >= 300 {
442		return out, metadata, awsAwsjson11_deserializeOpErrorCreateAccount(response, &metadata)
443	}
444	output := &CreateAccountOutput{}
445	out.Result = output
446
447	var buff [1024]byte
448	ringBuffer := smithyio.NewRingBuffer(buff[:])
449
450	body := io.TeeReader(response.Body, ringBuffer)
451	decoder := json.NewDecoder(body)
452	decoder.UseNumber()
453	var shape interface{}
454	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
455		var snapshot bytes.Buffer
456		io.Copy(&snapshot, ringBuffer)
457		err = &smithy.DeserializationError{
458			Err:      fmt.Errorf("failed to decode response body, %w", err),
459			Snapshot: snapshot.Bytes(),
460		}
461		return out, metadata, err
462	}
463
464	err = awsAwsjson11_deserializeOpDocumentCreateAccountOutput(&output, shape)
465	if err != nil {
466		var snapshot bytes.Buffer
467		io.Copy(&snapshot, ringBuffer)
468		err = &smithy.DeserializationError{
469			Err:      fmt.Errorf("failed to decode response body, %w", err),
470			Snapshot: snapshot.Bytes(),
471		}
472		return out, metadata, err
473	}
474
475	return out, metadata, err
476}
477
478func awsAwsjson11_deserializeOpErrorCreateAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error {
479	var errorBuffer bytes.Buffer
480	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
481		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
482	}
483	errorBody := bytes.NewReader(errorBuffer.Bytes())
484
485	errorCode := "UnknownError"
486	errorMessage := errorCode
487
488	code := response.Header.Get("X-Amzn-ErrorType")
489	if len(code) != 0 {
490		errorCode = restjson.SanitizeErrorCode(code)
491	}
492
493	var buff [1024]byte
494	ringBuffer := smithyio.NewRingBuffer(buff[:])
495
496	body := io.TeeReader(errorBody, ringBuffer)
497	decoder := json.NewDecoder(body)
498	decoder.UseNumber()
499	code, message, err := restjson.GetErrorInfo(decoder)
500	if err != nil {
501		var snapshot bytes.Buffer
502		io.Copy(&snapshot, ringBuffer)
503		err = &smithy.DeserializationError{
504			Err:      fmt.Errorf("failed to decode response body, %w", err),
505			Snapshot: snapshot.Bytes(),
506		}
507		return err
508	}
509
510	errorBody.Seek(0, io.SeekStart)
511	if len(code) != 0 {
512		errorCode = restjson.SanitizeErrorCode(code)
513	}
514	if len(message) != 0 {
515		errorMessage = message
516	}
517
518	switch {
519	case strings.EqualFold("AccessDeniedException", errorCode):
520		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
521
522	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
523		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
524
525	case strings.EqualFold("ConcurrentModificationException", errorCode):
526		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
527
528	case strings.EqualFold("ConstraintViolationException", errorCode):
529		return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody)
530
531	case strings.EqualFold("FinalizingOrganizationException", errorCode):
532		return awsAwsjson11_deserializeErrorFinalizingOrganizationException(response, errorBody)
533
534	case strings.EqualFold("InvalidInputException", errorCode):
535		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
536
537	case strings.EqualFold("ServiceException", errorCode):
538		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
539
540	case strings.EqualFold("TooManyRequestsException", errorCode):
541		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
542
543	case strings.EqualFold("UnsupportedAPIEndpointException", errorCode):
544		return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody)
545
546	default:
547		genericError := &smithy.GenericAPIError{
548			Code:    errorCode,
549			Message: errorMessage,
550		}
551		return genericError
552
553	}
554}
555
556type awsAwsjson11_deserializeOpCreateGovCloudAccount struct {
557}
558
559func (*awsAwsjson11_deserializeOpCreateGovCloudAccount) ID() string {
560	return "OperationDeserializer"
561}
562
563func (m *awsAwsjson11_deserializeOpCreateGovCloudAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
564	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
565) {
566	out, metadata, err = next.HandleDeserialize(ctx, in)
567	if err != nil {
568		return out, metadata, err
569	}
570
571	response, ok := out.RawResponse.(*smithyhttp.Response)
572	if !ok {
573		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
574	}
575
576	if response.StatusCode < 200 || response.StatusCode >= 300 {
577		return out, metadata, awsAwsjson11_deserializeOpErrorCreateGovCloudAccount(response, &metadata)
578	}
579	output := &CreateGovCloudAccountOutput{}
580	out.Result = output
581
582	var buff [1024]byte
583	ringBuffer := smithyio.NewRingBuffer(buff[:])
584
585	body := io.TeeReader(response.Body, ringBuffer)
586	decoder := json.NewDecoder(body)
587	decoder.UseNumber()
588	var shape interface{}
589	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
590		var snapshot bytes.Buffer
591		io.Copy(&snapshot, ringBuffer)
592		err = &smithy.DeserializationError{
593			Err:      fmt.Errorf("failed to decode response body, %w", err),
594			Snapshot: snapshot.Bytes(),
595		}
596		return out, metadata, err
597	}
598
599	err = awsAwsjson11_deserializeOpDocumentCreateGovCloudAccountOutput(&output, shape)
600	if err != nil {
601		var snapshot bytes.Buffer
602		io.Copy(&snapshot, ringBuffer)
603		err = &smithy.DeserializationError{
604			Err:      fmt.Errorf("failed to decode response body, %w", err),
605			Snapshot: snapshot.Bytes(),
606		}
607		return out, metadata, err
608	}
609
610	return out, metadata, err
611}
612
613func awsAwsjson11_deserializeOpErrorCreateGovCloudAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error {
614	var errorBuffer bytes.Buffer
615	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
616		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
617	}
618	errorBody := bytes.NewReader(errorBuffer.Bytes())
619
620	errorCode := "UnknownError"
621	errorMessage := errorCode
622
623	code := response.Header.Get("X-Amzn-ErrorType")
624	if len(code) != 0 {
625		errorCode = restjson.SanitizeErrorCode(code)
626	}
627
628	var buff [1024]byte
629	ringBuffer := smithyio.NewRingBuffer(buff[:])
630
631	body := io.TeeReader(errorBody, ringBuffer)
632	decoder := json.NewDecoder(body)
633	decoder.UseNumber()
634	code, message, err := restjson.GetErrorInfo(decoder)
635	if err != nil {
636		var snapshot bytes.Buffer
637		io.Copy(&snapshot, ringBuffer)
638		err = &smithy.DeserializationError{
639			Err:      fmt.Errorf("failed to decode response body, %w", err),
640			Snapshot: snapshot.Bytes(),
641		}
642		return err
643	}
644
645	errorBody.Seek(0, io.SeekStart)
646	if len(code) != 0 {
647		errorCode = restjson.SanitizeErrorCode(code)
648	}
649	if len(message) != 0 {
650		errorMessage = message
651	}
652
653	switch {
654	case strings.EqualFold("AccessDeniedException", errorCode):
655		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
656
657	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
658		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
659
660	case strings.EqualFold("ConcurrentModificationException", errorCode):
661		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
662
663	case strings.EqualFold("ConstraintViolationException", errorCode):
664		return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody)
665
666	case strings.EqualFold("FinalizingOrganizationException", errorCode):
667		return awsAwsjson11_deserializeErrorFinalizingOrganizationException(response, errorBody)
668
669	case strings.EqualFold("InvalidInputException", errorCode):
670		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
671
672	case strings.EqualFold("ServiceException", errorCode):
673		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
674
675	case strings.EqualFold("TooManyRequestsException", errorCode):
676		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
677
678	case strings.EqualFold("UnsupportedAPIEndpointException", errorCode):
679		return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody)
680
681	default:
682		genericError := &smithy.GenericAPIError{
683			Code:    errorCode,
684			Message: errorMessage,
685		}
686		return genericError
687
688	}
689}
690
691type awsAwsjson11_deserializeOpCreateOrganization struct {
692}
693
694func (*awsAwsjson11_deserializeOpCreateOrganization) ID() string {
695	return "OperationDeserializer"
696}
697
698func (m *awsAwsjson11_deserializeOpCreateOrganization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
699	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
700) {
701	out, metadata, err = next.HandleDeserialize(ctx, in)
702	if err != nil {
703		return out, metadata, err
704	}
705
706	response, ok := out.RawResponse.(*smithyhttp.Response)
707	if !ok {
708		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
709	}
710
711	if response.StatusCode < 200 || response.StatusCode >= 300 {
712		return out, metadata, awsAwsjson11_deserializeOpErrorCreateOrganization(response, &metadata)
713	}
714	output := &CreateOrganizationOutput{}
715	out.Result = output
716
717	var buff [1024]byte
718	ringBuffer := smithyio.NewRingBuffer(buff[:])
719
720	body := io.TeeReader(response.Body, ringBuffer)
721	decoder := json.NewDecoder(body)
722	decoder.UseNumber()
723	var shape interface{}
724	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
725		var snapshot bytes.Buffer
726		io.Copy(&snapshot, ringBuffer)
727		err = &smithy.DeserializationError{
728			Err:      fmt.Errorf("failed to decode response body, %w", err),
729			Snapshot: snapshot.Bytes(),
730		}
731		return out, metadata, err
732	}
733
734	err = awsAwsjson11_deserializeOpDocumentCreateOrganizationOutput(&output, shape)
735	if err != nil {
736		var snapshot bytes.Buffer
737		io.Copy(&snapshot, ringBuffer)
738		err = &smithy.DeserializationError{
739			Err:      fmt.Errorf("failed to decode response body, %w", err),
740			Snapshot: snapshot.Bytes(),
741		}
742		return out, metadata, err
743	}
744
745	return out, metadata, err
746}
747
748func awsAwsjson11_deserializeOpErrorCreateOrganization(response *smithyhttp.Response, metadata *middleware.Metadata) error {
749	var errorBuffer bytes.Buffer
750	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
751		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
752	}
753	errorBody := bytes.NewReader(errorBuffer.Bytes())
754
755	errorCode := "UnknownError"
756	errorMessage := errorCode
757
758	code := response.Header.Get("X-Amzn-ErrorType")
759	if len(code) != 0 {
760		errorCode = restjson.SanitizeErrorCode(code)
761	}
762
763	var buff [1024]byte
764	ringBuffer := smithyio.NewRingBuffer(buff[:])
765
766	body := io.TeeReader(errorBody, ringBuffer)
767	decoder := json.NewDecoder(body)
768	decoder.UseNumber()
769	code, message, err := restjson.GetErrorInfo(decoder)
770	if err != nil {
771		var snapshot bytes.Buffer
772		io.Copy(&snapshot, ringBuffer)
773		err = &smithy.DeserializationError{
774			Err:      fmt.Errorf("failed to decode response body, %w", err),
775			Snapshot: snapshot.Bytes(),
776		}
777		return err
778	}
779
780	errorBody.Seek(0, io.SeekStart)
781	if len(code) != 0 {
782		errorCode = restjson.SanitizeErrorCode(code)
783	}
784	if len(message) != 0 {
785		errorMessage = message
786	}
787
788	switch {
789	case strings.EqualFold("AccessDeniedException", errorCode):
790		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
791
792	case strings.EqualFold("AccessDeniedForDependencyException", errorCode):
793		return awsAwsjson11_deserializeErrorAccessDeniedForDependencyException(response, errorBody)
794
795	case strings.EqualFold("AlreadyInOrganizationException", errorCode):
796		return awsAwsjson11_deserializeErrorAlreadyInOrganizationException(response, errorBody)
797
798	case strings.EqualFold("ConcurrentModificationException", errorCode):
799		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
800
801	case strings.EqualFold("ConstraintViolationException", errorCode):
802		return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody)
803
804	case strings.EqualFold("InvalidInputException", errorCode):
805		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
806
807	case strings.EqualFold("ServiceException", errorCode):
808		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
809
810	case strings.EqualFold("TooManyRequestsException", errorCode):
811		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
812
813	default:
814		genericError := &smithy.GenericAPIError{
815			Code:    errorCode,
816			Message: errorMessage,
817		}
818		return genericError
819
820	}
821}
822
823type awsAwsjson11_deserializeOpCreateOrganizationalUnit struct {
824}
825
826func (*awsAwsjson11_deserializeOpCreateOrganizationalUnit) ID() string {
827	return "OperationDeserializer"
828}
829
830func (m *awsAwsjson11_deserializeOpCreateOrganizationalUnit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
831	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
832) {
833	out, metadata, err = next.HandleDeserialize(ctx, in)
834	if err != nil {
835		return out, metadata, err
836	}
837
838	response, ok := out.RawResponse.(*smithyhttp.Response)
839	if !ok {
840		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
841	}
842
843	if response.StatusCode < 200 || response.StatusCode >= 300 {
844		return out, metadata, awsAwsjson11_deserializeOpErrorCreateOrganizationalUnit(response, &metadata)
845	}
846	output := &CreateOrganizationalUnitOutput{}
847	out.Result = output
848
849	var buff [1024]byte
850	ringBuffer := smithyio.NewRingBuffer(buff[:])
851
852	body := io.TeeReader(response.Body, ringBuffer)
853	decoder := json.NewDecoder(body)
854	decoder.UseNumber()
855	var shape interface{}
856	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
857		var snapshot bytes.Buffer
858		io.Copy(&snapshot, ringBuffer)
859		err = &smithy.DeserializationError{
860			Err:      fmt.Errorf("failed to decode response body, %w", err),
861			Snapshot: snapshot.Bytes(),
862		}
863		return out, metadata, err
864	}
865
866	err = awsAwsjson11_deserializeOpDocumentCreateOrganizationalUnitOutput(&output, shape)
867	if err != nil {
868		var snapshot bytes.Buffer
869		io.Copy(&snapshot, ringBuffer)
870		err = &smithy.DeserializationError{
871			Err:      fmt.Errorf("failed to decode response body, %w", err),
872			Snapshot: snapshot.Bytes(),
873		}
874		return out, metadata, err
875	}
876
877	return out, metadata, err
878}
879
880func awsAwsjson11_deserializeOpErrorCreateOrganizationalUnit(response *smithyhttp.Response, metadata *middleware.Metadata) error {
881	var errorBuffer bytes.Buffer
882	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
883		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
884	}
885	errorBody := bytes.NewReader(errorBuffer.Bytes())
886
887	errorCode := "UnknownError"
888	errorMessage := errorCode
889
890	code := response.Header.Get("X-Amzn-ErrorType")
891	if len(code) != 0 {
892		errorCode = restjson.SanitizeErrorCode(code)
893	}
894
895	var buff [1024]byte
896	ringBuffer := smithyio.NewRingBuffer(buff[:])
897
898	body := io.TeeReader(errorBody, ringBuffer)
899	decoder := json.NewDecoder(body)
900	decoder.UseNumber()
901	code, message, err := restjson.GetErrorInfo(decoder)
902	if err != nil {
903		var snapshot bytes.Buffer
904		io.Copy(&snapshot, ringBuffer)
905		err = &smithy.DeserializationError{
906			Err:      fmt.Errorf("failed to decode response body, %w", err),
907			Snapshot: snapshot.Bytes(),
908		}
909		return err
910	}
911
912	errorBody.Seek(0, io.SeekStart)
913	if len(code) != 0 {
914		errorCode = restjson.SanitizeErrorCode(code)
915	}
916	if len(message) != 0 {
917		errorMessage = message
918	}
919
920	switch {
921	case strings.EqualFold("AccessDeniedException", errorCode):
922		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
923
924	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
925		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
926
927	case strings.EqualFold("ConcurrentModificationException", errorCode):
928		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
929
930	case strings.EqualFold("ConstraintViolationException", errorCode):
931		return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody)
932
933	case strings.EqualFold("DuplicateOrganizationalUnitException", errorCode):
934		return awsAwsjson11_deserializeErrorDuplicateOrganizationalUnitException(response, errorBody)
935
936	case strings.EqualFold("InvalidInputException", errorCode):
937		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
938
939	case strings.EqualFold("ParentNotFoundException", errorCode):
940		return awsAwsjson11_deserializeErrorParentNotFoundException(response, errorBody)
941
942	case strings.EqualFold("ServiceException", errorCode):
943		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
944
945	case strings.EqualFold("TooManyRequestsException", errorCode):
946		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
947
948	default:
949		genericError := &smithy.GenericAPIError{
950			Code:    errorCode,
951			Message: errorMessage,
952		}
953		return genericError
954
955	}
956}
957
958type awsAwsjson11_deserializeOpCreatePolicy struct {
959}
960
961func (*awsAwsjson11_deserializeOpCreatePolicy) ID() string {
962	return "OperationDeserializer"
963}
964
965func (m *awsAwsjson11_deserializeOpCreatePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
966	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
967) {
968	out, metadata, err = next.HandleDeserialize(ctx, in)
969	if err != nil {
970		return out, metadata, err
971	}
972
973	response, ok := out.RawResponse.(*smithyhttp.Response)
974	if !ok {
975		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
976	}
977
978	if response.StatusCode < 200 || response.StatusCode >= 300 {
979		return out, metadata, awsAwsjson11_deserializeOpErrorCreatePolicy(response, &metadata)
980	}
981	output := &CreatePolicyOutput{}
982	out.Result = output
983
984	var buff [1024]byte
985	ringBuffer := smithyio.NewRingBuffer(buff[:])
986
987	body := io.TeeReader(response.Body, ringBuffer)
988	decoder := json.NewDecoder(body)
989	decoder.UseNumber()
990	var shape interface{}
991	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
992		var snapshot bytes.Buffer
993		io.Copy(&snapshot, ringBuffer)
994		err = &smithy.DeserializationError{
995			Err:      fmt.Errorf("failed to decode response body, %w", err),
996			Snapshot: snapshot.Bytes(),
997		}
998		return out, metadata, err
999	}
1000
1001	err = awsAwsjson11_deserializeOpDocumentCreatePolicyOutput(&output, shape)
1002	if err != nil {
1003		var snapshot bytes.Buffer
1004		io.Copy(&snapshot, ringBuffer)
1005		err = &smithy.DeserializationError{
1006			Err:      fmt.Errorf("failed to decode response body, %w", err),
1007			Snapshot: snapshot.Bytes(),
1008		}
1009		return out, metadata, err
1010	}
1011
1012	return out, metadata, err
1013}
1014
1015func awsAwsjson11_deserializeOpErrorCreatePolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1016	var errorBuffer bytes.Buffer
1017	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1018		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1019	}
1020	errorBody := bytes.NewReader(errorBuffer.Bytes())
1021
1022	errorCode := "UnknownError"
1023	errorMessage := errorCode
1024
1025	code := response.Header.Get("X-Amzn-ErrorType")
1026	if len(code) != 0 {
1027		errorCode = restjson.SanitizeErrorCode(code)
1028	}
1029
1030	var buff [1024]byte
1031	ringBuffer := smithyio.NewRingBuffer(buff[:])
1032
1033	body := io.TeeReader(errorBody, ringBuffer)
1034	decoder := json.NewDecoder(body)
1035	decoder.UseNumber()
1036	code, message, err := restjson.GetErrorInfo(decoder)
1037	if err != nil {
1038		var snapshot bytes.Buffer
1039		io.Copy(&snapshot, ringBuffer)
1040		err = &smithy.DeserializationError{
1041			Err:      fmt.Errorf("failed to decode response body, %w", err),
1042			Snapshot: snapshot.Bytes(),
1043		}
1044		return err
1045	}
1046
1047	errorBody.Seek(0, io.SeekStart)
1048	if len(code) != 0 {
1049		errorCode = restjson.SanitizeErrorCode(code)
1050	}
1051	if len(message) != 0 {
1052		errorMessage = message
1053	}
1054
1055	switch {
1056	case strings.EqualFold("AccessDeniedException", errorCode):
1057		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1058
1059	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
1060		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
1061
1062	case strings.EqualFold("ConcurrentModificationException", errorCode):
1063		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
1064
1065	case strings.EqualFold("ConstraintViolationException", errorCode):
1066		return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody)
1067
1068	case strings.EqualFold("DuplicatePolicyException", errorCode):
1069		return awsAwsjson11_deserializeErrorDuplicatePolicyException(response, errorBody)
1070
1071	case strings.EqualFold("InvalidInputException", errorCode):
1072		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1073
1074	case strings.EqualFold("MalformedPolicyDocumentException", errorCode):
1075		return awsAwsjson11_deserializeErrorMalformedPolicyDocumentException(response, errorBody)
1076
1077	case strings.EqualFold("PolicyTypeNotAvailableForOrganizationException", errorCode):
1078		return awsAwsjson11_deserializeErrorPolicyTypeNotAvailableForOrganizationException(response, errorBody)
1079
1080	case strings.EqualFold("ServiceException", errorCode):
1081		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1082
1083	case strings.EqualFold("TooManyRequestsException", errorCode):
1084		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
1085
1086	case strings.EqualFold("UnsupportedAPIEndpointException", errorCode):
1087		return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody)
1088
1089	default:
1090		genericError := &smithy.GenericAPIError{
1091			Code:    errorCode,
1092			Message: errorMessage,
1093		}
1094		return genericError
1095
1096	}
1097}
1098
1099type awsAwsjson11_deserializeOpDeclineHandshake struct {
1100}
1101
1102func (*awsAwsjson11_deserializeOpDeclineHandshake) ID() string {
1103	return "OperationDeserializer"
1104}
1105
1106func (m *awsAwsjson11_deserializeOpDeclineHandshake) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1107	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1108) {
1109	out, metadata, err = next.HandleDeserialize(ctx, in)
1110	if err != nil {
1111		return out, metadata, err
1112	}
1113
1114	response, ok := out.RawResponse.(*smithyhttp.Response)
1115	if !ok {
1116		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1117	}
1118
1119	if response.StatusCode < 200 || response.StatusCode >= 300 {
1120		return out, metadata, awsAwsjson11_deserializeOpErrorDeclineHandshake(response, &metadata)
1121	}
1122	output := &DeclineHandshakeOutput{}
1123	out.Result = output
1124
1125	var buff [1024]byte
1126	ringBuffer := smithyio.NewRingBuffer(buff[:])
1127
1128	body := io.TeeReader(response.Body, ringBuffer)
1129	decoder := json.NewDecoder(body)
1130	decoder.UseNumber()
1131	var shape interface{}
1132	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1133		var snapshot bytes.Buffer
1134		io.Copy(&snapshot, ringBuffer)
1135		err = &smithy.DeserializationError{
1136			Err:      fmt.Errorf("failed to decode response body, %w", err),
1137			Snapshot: snapshot.Bytes(),
1138		}
1139		return out, metadata, err
1140	}
1141
1142	err = awsAwsjson11_deserializeOpDocumentDeclineHandshakeOutput(&output, shape)
1143	if err != nil {
1144		var snapshot bytes.Buffer
1145		io.Copy(&snapshot, ringBuffer)
1146		err = &smithy.DeserializationError{
1147			Err:      fmt.Errorf("failed to decode response body, %w", err),
1148			Snapshot: snapshot.Bytes(),
1149		}
1150		return out, metadata, err
1151	}
1152
1153	return out, metadata, err
1154}
1155
1156func awsAwsjson11_deserializeOpErrorDeclineHandshake(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1157	var errorBuffer bytes.Buffer
1158	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1159		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1160	}
1161	errorBody := bytes.NewReader(errorBuffer.Bytes())
1162
1163	errorCode := "UnknownError"
1164	errorMessage := errorCode
1165
1166	code := response.Header.Get("X-Amzn-ErrorType")
1167	if len(code) != 0 {
1168		errorCode = restjson.SanitizeErrorCode(code)
1169	}
1170
1171	var buff [1024]byte
1172	ringBuffer := smithyio.NewRingBuffer(buff[:])
1173
1174	body := io.TeeReader(errorBody, ringBuffer)
1175	decoder := json.NewDecoder(body)
1176	decoder.UseNumber()
1177	code, message, err := restjson.GetErrorInfo(decoder)
1178	if err != nil {
1179		var snapshot bytes.Buffer
1180		io.Copy(&snapshot, ringBuffer)
1181		err = &smithy.DeserializationError{
1182			Err:      fmt.Errorf("failed to decode response body, %w", err),
1183			Snapshot: snapshot.Bytes(),
1184		}
1185		return err
1186	}
1187
1188	errorBody.Seek(0, io.SeekStart)
1189	if len(code) != 0 {
1190		errorCode = restjson.SanitizeErrorCode(code)
1191	}
1192	if len(message) != 0 {
1193		errorMessage = message
1194	}
1195
1196	switch {
1197	case strings.EqualFold("AccessDeniedException", errorCode):
1198		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1199
1200	case strings.EqualFold("ConcurrentModificationException", errorCode):
1201		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
1202
1203	case strings.EqualFold("HandshakeAlreadyInStateException", errorCode):
1204		return awsAwsjson11_deserializeErrorHandshakeAlreadyInStateException(response, errorBody)
1205
1206	case strings.EqualFold("HandshakeNotFoundException", errorCode):
1207		return awsAwsjson11_deserializeErrorHandshakeNotFoundException(response, errorBody)
1208
1209	case strings.EqualFold("InvalidHandshakeTransitionException", errorCode):
1210		return awsAwsjson11_deserializeErrorInvalidHandshakeTransitionException(response, errorBody)
1211
1212	case strings.EqualFold("InvalidInputException", errorCode):
1213		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1214
1215	case strings.EqualFold("ServiceException", errorCode):
1216		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1217
1218	case strings.EqualFold("TooManyRequestsException", errorCode):
1219		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
1220
1221	default:
1222		genericError := &smithy.GenericAPIError{
1223			Code:    errorCode,
1224			Message: errorMessage,
1225		}
1226		return genericError
1227
1228	}
1229}
1230
1231type awsAwsjson11_deserializeOpDeleteOrganization struct {
1232}
1233
1234func (*awsAwsjson11_deserializeOpDeleteOrganization) ID() string {
1235	return "OperationDeserializer"
1236}
1237
1238func (m *awsAwsjson11_deserializeOpDeleteOrganization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1239	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1240) {
1241	out, metadata, err = next.HandleDeserialize(ctx, in)
1242	if err != nil {
1243		return out, metadata, err
1244	}
1245
1246	response, ok := out.RawResponse.(*smithyhttp.Response)
1247	if !ok {
1248		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1249	}
1250
1251	if response.StatusCode < 200 || response.StatusCode >= 300 {
1252		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteOrganization(response, &metadata)
1253	}
1254	output := &DeleteOrganizationOutput{}
1255	out.Result = output
1256
1257	if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
1258		return out, metadata, &smithy.DeserializationError{
1259			Err: fmt.Errorf("failed to discard response body, %w", err),
1260		}
1261	}
1262
1263	return out, metadata, err
1264}
1265
1266func awsAwsjson11_deserializeOpErrorDeleteOrganization(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1267	var errorBuffer bytes.Buffer
1268	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1269		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1270	}
1271	errorBody := bytes.NewReader(errorBuffer.Bytes())
1272
1273	errorCode := "UnknownError"
1274	errorMessage := errorCode
1275
1276	code := response.Header.Get("X-Amzn-ErrorType")
1277	if len(code) != 0 {
1278		errorCode = restjson.SanitizeErrorCode(code)
1279	}
1280
1281	var buff [1024]byte
1282	ringBuffer := smithyio.NewRingBuffer(buff[:])
1283
1284	body := io.TeeReader(errorBody, ringBuffer)
1285	decoder := json.NewDecoder(body)
1286	decoder.UseNumber()
1287	code, message, err := restjson.GetErrorInfo(decoder)
1288	if err != nil {
1289		var snapshot bytes.Buffer
1290		io.Copy(&snapshot, ringBuffer)
1291		err = &smithy.DeserializationError{
1292			Err:      fmt.Errorf("failed to decode response body, %w", err),
1293			Snapshot: snapshot.Bytes(),
1294		}
1295		return err
1296	}
1297
1298	errorBody.Seek(0, io.SeekStart)
1299	if len(code) != 0 {
1300		errorCode = restjson.SanitizeErrorCode(code)
1301	}
1302	if len(message) != 0 {
1303		errorMessage = message
1304	}
1305
1306	switch {
1307	case strings.EqualFold("AccessDeniedException", errorCode):
1308		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1309
1310	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
1311		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
1312
1313	case strings.EqualFold("ConcurrentModificationException", errorCode):
1314		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
1315
1316	case strings.EqualFold("InvalidInputException", errorCode):
1317		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1318
1319	case strings.EqualFold("OrganizationNotEmptyException", errorCode):
1320		return awsAwsjson11_deserializeErrorOrganizationNotEmptyException(response, errorBody)
1321
1322	case strings.EqualFold("ServiceException", errorCode):
1323		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1324
1325	case strings.EqualFold("TooManyRequestsException", errorCode):
1326		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
1327
1328	default:
1329		genericError := &smithy.GenericAPIError{
1330			Code:    errorCode,
1331			Message: errorMessage,
1332		}
1333		return genericError
1334
1335	}
1336}
1337
1338type awsAwsjson11_deserializeOpDeleteOrganizationalUnit struct {
1339}
1340
1341func (*awsAwsjson11_deserializeOpDeleteOrganizationalUnit) ID() string {
1342	return "OperationDeserializer"
1343}
1344
1345func (m *awsAwsjson11_deserializeOpDeleteOrganizationalUnit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1346	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1347) {
1348	out, metadata, err = next.HandleDeserialize(ctx, in)
1349	if err != nil {
1350		return out, metadata, err
1351	}
1352
1353	response, ok := out.RawResponse.(*smithyhttp.Response)
1354	if !ok {
1355		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1356	}
1357
1358	if response.StatusCode < 200 || response.StatusCode >= 300 {
1359		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteOrganizationalUnit(response, &metadata)
1360	}
1361	output := &DeleteOrganizationalUnitOutput{}
1362	out.Result = output
1363
1364	if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
1365		return out, metadata, &smithy.DeserializationError{
1366			Err: fmt.Errorf("failed to discard response body, %w", err),
1367		}
1368	}
1369
1370	return out, metadata, err
1371}
1372
1373func awsAwsjson11_deserializeOpErrorDeleteOrganizationalUnit(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1374	var errorBuffer bytes.Buffer
1375	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1376		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1377	}
1378	errorBody := bytes.NewReader(errorBuffer.Bytes())
1379
1380	errorCode := "UnknownError"
1381	errorMessage := errorCode
1382
1383	code := response.Header.Get("X-Amzn-ErrorType")
1384	if len(code) != 0 {
1385		errorCode = restjson.SanitizeErrorCode(code)
1386	}
1387
1388	var buff [1024]byte
1389	ringBuffer := smithyio.NewRingBuffer(buff[:])
1390
1391	body := io.TeeReader(errorBody, ringBuffer)
1392	decoder := json.NewDecoder(body)
1393	decoder.UseNumber()
1394	code, message, err := restjson.GetErrorInfo(decoder)
1395	if err != nil {
1396		var snapshot bytes.Buffer
1397		io.Copy(&snapshot, ringBuffer)
1398		err = &smithy.DeserializationError{
1399			Err:      fmt.Errorf("failed to decode response body, %w", err),
1400			Snapshot: snapshot.Bytes(),
1401		}
1402		return err
1403	}
1404
1405	errorBody.Seek(0, io.SeekStart)
1406	if len(code) != 0 {
1407		errorCode = restjson.SanitizeErrorCode(code)
1408	}
1409	if len(message) != 0 {
1410		errorMessage = message
1411	}
1412
1413	switch {
1414	case strings.EqualFold("AccessDeniedException", errorCode):
1415		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1416
1417	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
1418		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
1419
1420	case strings.EqualFold("ConcurrentModificationException", errorCode):
1421		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
1422
1423	case strings.EqualFold("InvalidInputException", errorCode):
1424		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1425
1426	case strings.EqualFold("OrganizationalUnitNotEmptyException", errorCode):
1427		return awsAwsjson11_deserializeErrorOrganizationalUnitNotEmptyException(response, errorBody)
1428
1429	case strings.EqualFold("OrganizationalUnitNotFoundException", errorCode):
1430		return awsAwsjson11_deserializeErrorOrganizationalUnitNotFoundException(response, errorBody)
1431
1432	case strings.EqualFold("ServiceException", errorCode):
1433		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1434
1435	case strings.EqualFold("TooManyRequestsException", errorCode):
1436		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
1437
1438	default:
1439		genericError := &smithy.GenericAPIError{
1440			Code:    errorCode,
1441			Message: errorMessage,
1442		}
1443		return genericError
1444
1445	}
1446}
1447
1448type awsAwsjson11_deserializeOpDeletePolicy struct {
1449}
1450
1451func (*awsAwsjson11_deserializeOpDeletePolicy) ID() string {
1452	return "OperationDeserializer"
1453}
1454
1455func (m *awsAwsjson11_deserializeOpDeletePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1456	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1457) {
1458	out, metadata, err = next.HandleDeserialize(ctx, in)
1459	if err != nil {
1460		return out, metadata, err
1461	}
1462
1463	response, ok := out.RawResponse.(*smithyhttp.Response)
1464	if !ok {
1465		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1466	}
1467
1468	if response.StatusCode < 200 || response.StatusCode >= 300 {
1469		return out, metadata, awsAwsjson11_deserializeOpErrorDeletePolicy(response, &metadata)
1470	}
1471	output := &DeletePolicyOutput{}
1472	out.Result = output
1473
1474	if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
1475		return out, metadata, &smithy.DeserializationError{
1476			Err: fmt.Errorf("failed to discard response body, %w", err),
1477		}
1478	}
1479
1480	return out, metadata, err
1481}
1482
1483func awsAwsjson11_deserializeOpErrorDeletePolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1484	var errorBuffer bytes.Buffer
1485	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1486		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1487	}
1488	errorBody := bytes.NewReader(errorBuffer.Bytes())
1489
1490	errorCode := "UnknownError"
1491	errorMessage := errorCode
1492
1493	code := response.Header.Get("X-Amzn-ErrorType")
1494	if len(code) != 0 {
1495		errorCode = restjson.SanitizeErrorCode(code)
1496	}
1497
1498	var buff [1024]byte
1499	ringBuffer := smithyio.NewRingBuffer(buff[:])
1500
1501	body := io.TeeReader(errorBody, ringBuffer)
1502	decoder := json.NewDecoder(body)
1503	decoder.UseNumber()
1504	code, message, err := restjson.GetErrorInfo(decoder)
1505	if err != nil {
1506		var snapshot bytes.Buffer
1507		io.Copy(&snapshot, ringBuffer)
1508		err = &smithy.DeserializationError{
1509			Err:      fmt.Errorf("failed to decode response body, %w", err),
1510			Snapshot: snapshot.Bytes(),
1511		}
1512		return err
1513	}
1514
1515	errorBody.Seek(0, io.SeekStart)
1516	if len(code) != 0 {
1517		errorCode = restjson.SanitizeErrorCode(code)
1518	}
1519	if len(message) != 0 {
1520		errorMessage = message
1521	}
1522
1523	switch {
1524	case strings.EqualFold("AccessDeniedException", errorCode):
1525		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1526
1527	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
1528		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
1529
1530	case strings.EqualFold("ConcurrentModificationException", errorCode):
1531		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
1532
1533	case strings.EqualFold("InvalidInputException", errorCode):
1534		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1535
1536	case strings.EqualFold("PolicyInUseException", errorCode):
1537		return awsAwsjson11_deserializeErrorPolicyInUseException(response, errorBody)
1538
1539	case strings.EqualFold("PolicyNotFoundException", errorCode):
1540		return awsAwsjson11_deserializeErrorPolicyNotFoundException(response, errorBody)
1541
1542	case strings.EqualFold("ServiceException", errorCode):
1543		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1544
1545	case strings.EqualFold("TooManyRequestsException", errorCode):
1546		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
1547
1548	case strings.EqualFold("UnsupportedAPIEndpointException", errorCode):
1549		return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody)
1550
1551	default:
1552		genericError := &smithy.GenericAPIError{
1553			Code:    errorCode,
1554			Message: errorMessage,
1555		}
1556		return genericError
1557
1558	}
1559}
1560
1561type awsAwsjson11_deserializeOpDeregisterDelegatedAdministrator struct {
1562}
1563
1564func (*awsAwsjson11_deserializeOpDeregisterDelegatedAdministrator) ID() string {
1565	return "OperationDeserializer"
1566}
1567
1568func (m *awsAwsjson11_deserializeOpDeregisterDelegatedAdministrator) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1569	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1570) {
1571	out, metadata, err = next.HandleDeserialize(ctx, in)
1572	if err != nil {
1573		return out, metadata, err
1574	}
1575
1576	response, ok := out.RawResponse.(*smithyhttp.Response)
1577	if !ok {
1578		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1579	}
1580
1581	if response.StatusCode < 200 || response.StatusCode >= 300 {
1582		return out, metadata, awsAwsjson11_deserializeOpErrorDeregisterDelegatedAdministrator(response, &metadata)
1583	}
1584	output := &DeregisterDelegatedAdministratorOutput{}
1585	out.Result = output
1586
1587	if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
1588		return out, metadata, &smithy.DeserializationError{
1589			Err: fmt.Errorf("failed to discard response body, %w", err),
1590		}
1591	}
1592
1593	return out, metadata, err
1594}
1595
1596func awsAwsjson11_deserializeOpErrorDeregisterDelegatedAdministrator(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1597	var errorBuffer bytes.Buffer
1598	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1599		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1600	}
1601	errorBody := bytes.NewReader(errorBuffer.Bytes())
1602
1603	errorCode := "UnknownError"
1604	errorMessage := errorCode
1605
1606	code := response.Header.Get("X-Amzn-ErrorType")
1607	if len(code) != 0 {
1608		errorCode = restjson.SanitizeErrorCode(code)
1609	}
1610
1611	var buff [1024]byte
1612	ringBuffer := smithyio.NewRingBuffer(buff[:])
1613
1614	body := io.TeeReader(errorBody, ringBuffer)
1615	decoder := json.NewDecoder(body)
1616	decoder.UseNumber()
1617	code, message, err := restjson.GetErrorInfo(decoder)
1618	if err != nil {
1619		var snapshot bytes.Buffer
1620		io.Copy(&snapshot, ringBuffer)
1621		err = &smithy.DeserializationError{
1622			Err:      fmt.Errorf("failed to decode response body, %w", err),
1623			Snapshot: snapshot.Bytes(),
1624		}
1625		return err
1626	}
1627
1628	errorBody.Seek(0, io.SeekStart)
1629	if len(code) != 0 {
1630		errorCode = restjson.SanitizeErrorCode(code)
1631	}
1632	if len(message) != 0 {
1633		errorMessage = message
1634	}
1635
1636	switch {
1637	case strings.EqualFold("AccessDeniedException", errorCode):
1638		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1639
1640	case strings.EqualFold("AccountNotFoundException", errorCode):
1641		return awsAwsjson11_deserializeErrorAccountNotFoundException(response, errorBody)
1642
1643	case strings.EqualFold("AccountNotRegisteredException", errorCode):
1644		return awsAwsjson11_deserializeErrorAccountNotRegisteredException(response, errorBody)
1645
1646	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
1647		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
1648
1649	case strings.EqualFold("ConcurrentModificationException", errorCode):
1650		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
1651
1652	case strings.EqualFold("ConstraintViolationException", errorCode):
1653		return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody)
1654
1655	case strings.EqualFold("InvalidInputException", errorCode):
1656		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1657
1658	case strings.EqualFold("ServiceException", errorCode):
1659		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1660
1661	case strings.EqualFold("TooManyRequestsException", errorCode):
1662		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
1663
1664	case strings.EqualFold("UnsupportedAPIEndpointException", errorCode):
1665		return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody)
1666
1667	default:
1668		genericError := &smithy.GenericAPIError{
1669			Code:    errorCode,
1670			Message: errorMessage,
1671		}
1672		return genericError
1673
1674	}
1675}
1676
1677type awsAwsjson11_deserializeOpDescribeAccount struct {
1678}
1679
1680func (*awsAwsjson11_deserializeOpDescribeAccount) ID() string {
1681	return "OperationDeserializer"
1682}
1683
1684func (m *awsAwsjson11_deserializeOpDescribeAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1685	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1686) {
1687	out, metadata, err = next.HandleDeserialize(ctx, in)
1688	if err != nil {
1689		return out, metadata, err
1690	}
1691
1692	response, ok := out.RawResponse.(*smithyhttp.Response)
1693	if !ok {
1694		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1695	}
1696
1697	if response.StatusCode < 200 || response.StatusCode >= 300 {
1698		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeAccount(response, &metadata)
1699	}
1700	output := &DescribeAccountOutput{}
1701	out.Result = output
1702
1703	var buff [1024]byte
1704	ringBuffer := smithyio.NewRingBuffer(buff[:])
1705
1706	body := io.TeeReader(response.Body, ringBuffer)
1707	decoder := json.NewDecoder(body)
1708	decoder.UseNumber()
1709	var shape interface{}
1710	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1711		var snapshot bytes.Buffer
1712		io.Copy(&snapshot, ringBuffer)
1713		err = &smithy.DeserializationError{
1714			Err:      fmt.Errorf("failed to decode response body, %w", err),
1715			Snapshot: snapshot.Bytes(),
1716		}
1717		return out, metadata, err
1718	}
1719
1720	err = awsAwsjson11_deserializeOpDocumentDescribeAccountOutput(&output, shape)
1721	if err != nil {
1722		var snapshot bytes.Buffer
1723		io.Copy(&snapshot, ringBuffer)
1724		err = &smithy.DeserializationError{
1725			Err:      fmt.Errorf("failed to decode response body, %w", err),
1726			Snapshot: snapshot.Bytes(),
1727		}
1728		return out, metadata, err
1729	}
1730
1731	return out, metadata, err
1732}
1733
1734func awsAwsjson11_deserializeOpErrorDescribeAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1735	var errorBuffer bytes.Buffer
1736	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1737		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1738	}
1739	errorBody := bytes.NewReader(errorBuffer.Bytes())
1740
1741	errorCode := "UnknownError"
1742	errorMessage := errorCode
1743
1744	code := response.Header.Get("X-Amzn-ErrorType")
1745	if len(code) != 0 {
1746		errorCode = restjson.SanitizeErrorCode(code)
1747	}
1748
1749	var buff [1024]byte
1750	ringBuffer := smithyio.NewRingBuffer(buff[:])
1751
1752	body := io.TeeReader(errorBody, ringBuffer)
1753	decoder := json.NewDecoder(body)
1754	decoder.UseNumber()
1755	code, message, err := restjson.GetErrorInfo(decoder)
1756	if err != nil {
1757		var snapshot bytes.Buffer
1758		io.Copy(&snapshot, ringBuffer)
1759		err = &smithy.DeserializationError{
1760			Err:      fmt.Errorf("failed to decode response body, %w", err),
1761			Snapshot: snapshot.Bytes(),
1762		}
1763		return err
1764	}
1765
1766	errorBody.Seek(0, io.SeekStart)
1767	if len(code) != 0 {
1768		errorCode = restjson.SanitizeErrorCode(code)
1769	}
1770	if len(message) != 0 {
1771		errorMessage = message
1772	}
1773
1774	switch {
1775	case strings.EqualFold("AccessDeniedException", errorCode):
1776		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1777
1778	case strings.EqualFold("AccountNotFoundException", errorCode):
1779		return awsAwsjson11_deserializeErrorAccountNotFoundException(response, errorBody)
1780
1781	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
1782		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
1783
1784	case strings.EqualFold("InvalidInputException", errorCode):
1785		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1786
1787	case strings.EqualFold("ServiceException", errorCode):
1788		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1789
1790	case strings.EqualFold("TooManyRequestsException", errorCode):
1791		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
1792
1793	default:
1794		genericError := &smithy.GenericAPIError{
1795			Code:    errorCode,
1796			Message: errorMessage,
1797		}
1798		return genericError
1799
1800	}
1801}
1802
1803type awsAwsjson11_deserializeOpDescribeCreateAccountStatus struct {
1804}
1805
1806func (*awsAwsjson11_deserializeOpDescribeCreateAccountStatus) ID() string {
1807	return "OperationDeserializer"
1808}
1809
1810func (m *awsAwsjson11_deserializeOpDescribeCreateAccountStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1811	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1812) {
1813	out, metadata, err = next.HandleDeserialize(ctx, in)
1814	if err != nil {
1815		return out, metadata, err
1816	}
1817
1818	response, ok := out.RawResponse.(*smithyhttp.Response)
1819	if !ok {
1820		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1821	}
1822
1823	if response.StatusCode < 200 || response.StatusCode >= 300 {
1824		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeCreateAccountStatus(response, &metadata)
1825	}
1826	output := &DescribeCreateAccountStatusOutput{}
1827	out.Result = output
1828
1829	var buff [1024]byte
1830	ringBuffer := smithyio.NewRingBuffer(buff[:])
1831
1832	body := io.TeeReader(response.Body, ringBuffer)
1833	decoder := json.NewDecoder(body)
1834	decoder.UseNumber()
1835	var shape interface{}
1836	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1837		var snapshot bytes.Buffer
1838		io.Copy(&snapshot, ringBuffer)
1839		err = &smithy.DeserializationError{
1840			Err:      fmt.Errorf("failed to decode response body, %w", err),
1841			Snapshot: snapshot.Bytes(),
1842		}
1843		return out, metadata, err
1844	}
1845
1846	err = awsAwsjson11_deserializeOpDocumentDescribeCreateAccountStatusOutput(&output, shape)
1847	if err != nil {
1848		var snapshot bytes.Buffer
1849		io.Copy(&snapshot, ringBuffer)
1850		err = &smithy.DeserializationError{
1851			Err:      fmt.Errorf("failed to decode response body, %w", err),
1852			Snapshot: snapshot.Bytes(),
1853		}
1854		return out, metadata, err
1855	}
1856
1857	return out, metadata, err
1858}
1859
1860func awsAwsjson11_deserializeOpErrorDescribeCreateAccountStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1861	var errorBuffer bytes.Buffer
1862	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1863		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1864	}
1865	errorBody := bytes.NewReader(errorBuffer.Bytes())
1866
1867	errorCode := "UnknownError"
1868	errorMessage := errorCode
1869
1870	code := response.Header.Get("X-Amzn-ErrorType")
1871	if len(code) != 0 {
1872		errorCode = restjson.SanitizeErrorCode(code)
1873	}
1874
1875	var buff [1024]byte
1876	ringBuffer := smithyio.NewRingBuffer(buff[:])
1877
1878	body := io.TeeReader(errorBody, ringBuffer)
1879	decoder := json.NewDecoder(body)
1880	decoder.UseNumber()
1881	code, message, err := restjson.GetErrorInfo(decoder)
1882	if err != nil {
1883		var snapshot bytes.Buffer
1884		io.Copy(&snapshot, ringBuffer)
1885		err = &smithy.DeserializationError{
1886			Err:      fmt.Errorf("failed to decode response body, %w", err),
1887			Snapshot: snapshot.Bytes(),
1888		}
1889		return err
1890	}
1891
1892	errorBody.Seek(0, io.SeekStart)
1893	if len(code) != 0 {
1894		errorCode = restjson.SanitizeErrorCode(code)
1895	}
1896	if len(message) != 0 {
1897		errorMessage = message
1898	}
1899
1900	switch {
1901	case strings.EqualFold("AccessDeniedException", errorCode):
1902		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
1903
1904	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
1905		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
1906
1907	case strings.EqualFold("CreateAccountStatusNotFoundException", errorCode):
1908		return awsAwsjson11_deserializeErrorCreateAccountStatusNotFoundException(response, errorBody)
1909
1910	case strings.EqualFold("InvalidInputException", errorCode):
1911		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
1912
1913	case strings.EqualFold("ServiceException", errorCode):
1914		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
1915
1916	case strings.EqualFold("TooManyRequestsException", errorCode):
1917		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
1918
1919	case strings.EqualFold("UnsupportedAPIEndpointException", errorCode):
1920		return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody)
1921
1922	default:
1923		genericError := &smithy.GenericAPIError{
1924			Code:    errorCode,
1925			Message: errorMessage,
1926		}
1927		return genericError
1928
1929	}
1930}
1931
1932type awsAwsjson11_deserializeOpDescribeEffectivePolicy struct {
1933}
1934
1935func (*awsAwsjson11_deserializeOpDescribeEffectivePolicy) ID() string {
1936	return "OperationDeserializer"
1937}
1938
1939func (m *awsAwsjson11_deserializeOpDescribeEffectivePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1940	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1941) {
1942	out, metadata, err = next.HandleDeserialize(ctx, in)
1943	if err != nil {
1944		return out, metadata, err
1945	}
1946
1947	response, ok := out.RawResponse.(*smithyhttp.Response)
1948	if !ok {
1949		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1950	}
1951
1952	if response.StatusCode < 200 || response.StatusCode >= 300 {
1953		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeEffectivePolicy(response, &metadata)
1954	}
1955	output := &DescribeEffectivePolicyOutput{}
1956	out.Result = output
1957
1958	var buff [1024]byte
1959	ringBuffer := smithyio.NewRingBuffer(buff[:])
1960
1961	body := io.TeeReader(response.Body, ringBuffer)
1962	decoder := json.NewDecoder(body)
1963	decoder.UseNumber()
1964	var shape interface{}
1965	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1966		var snapshot bytes.Buffer
1967		io.Copy(&snapshot, ringBuffer)
1968		err = &smithy.DeserializationError{
1969			Err:      fmt.Errorf("failed to decode response body, %w", err),
1970			Snapshot: snapshot.Bytes(),
1971		}
1972		return out, metadata, err
1973	}
1974
1975	err = awsAwsjson11_deserializeOpDocumentDescribeEffectivePolicyOutput(&output, shape)
1976	if err != nil {
1977		var snapshot bytes.Buffer
1978		io.Copy(&snapshot, ringBuffer)
1979		err = &smithy.DeserializationError{
1980			Err:      fmt.Errorf("failed to decode response body, %w", err),
1981			Snapshot: snapshot.Bytes(),
1982		}
1983		return out, metadata, err
1984	}
1985
1986	return out, metadata, err
1987}
1988
1989func awsAwsjson11_deserializeOpErrorDescribeEffectivePolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1990	var errorBuffer bytes.Buffer
1991	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1992		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1993	}
1994	errorBody := bytes.NewReader(errorBuffer.Bytes())
1995
1996	errorCode := "UnknownError"
1997	errorMessage := errorCode
1998
1999	code := response.Header.Get("X-Amzn-ErrorType")
2000	if len(code) != 0 {
2001		errorCode = restjson.SanitizeErrorCode(code)
2002	}
2003
2004	var buff [1024]byte
2005	ringBuffer := smithyio.NewRingBuffer(buff[:])
2006
2007	body := io.TeeReader(errorBody, ringBuffer)
2008	decoder := json.NewDecoder(body)
2009	decoder.UseNumber()
2010	code, message, err := restjson.GetErrorInfo(decoder)
2011	if err != nil {
2012		var snapshot bytes.Buffer
2013		io.Copy(&snapshot, ringBuffer)
2014		err = &smithy.DeserializationError{
2015			Err:      fmt.Errorf("failed to decode response body, %w", err),
2016			Snapshot: snapshot.Bytes(),
2017		}
2018		return err
2019	}
2020
2021	errorBody.Seek(0, io.SeekStart)
2022	if len(code) != 0 {
2023		errorCode = restjson.SanitizeErrorCode(code)
2024	}
2025	if len(message) != 0 {
2026		errorMessage = message
2027	}
2028
2029	switch {
2030	case strings.EqualFold("AccessDeniedException", errorCode):
2031		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2032
2033	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
2034		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
2035
2036	case strings.EqualFold("ConstraintViolationException", errorCode):
2037		return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody)
2038
2039	case strings.EqualFold("EffectivePolicyNotFoundException", errorCode):
2040		return awsAwsjson11_deserializeErrorEffectivePolicyNotFoundException(response, errorBody)
2041
2042	case strings.EqualFold("InvalidInputException", errorCode):
2043		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2044
2045	case strings.EqualFold("ServiceException", errorCode):
2046		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2047
2048	case strings.EqualFold("TargetNotFoundException", errorCode):
2049		return awsAwsjson11_deserializeErrorTargetNotFoundException(response, errorBody)
2050
2051	case strings.EqualFold("TooManyRequestsException", errorCode):
2052		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
2053
2054	case strings.EqualFold("UnsupportedAPIEndpointException", errorCode):
2055		return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody)
2056
2057	default:
2058		genericError := &smithy.GenericAPIError{
2059			Code:    errorCode,
2060			Message: errorMessage,
2061		}
2062		return genericError
2063
2064	}
2065}
2066
2067type awsAwsjson11_deserializeOpDescribeHandshake struct {
2068}
2069
2070func (*awsAwsjson11_deserializeOpDescribeHandshake) ID() string {
2071	return "OperationDeserializer"
2072}
2073
2074func (m *awsAwsjson11_deserializeOpDescribeHandshake) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2075	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2076) {
2077	out, metadata, err = next.HandleDeserialize(ctx, in)
2078	if err != nil {
2079		return out, metadata, err
2080	}
2081
2082	response, ok := out.RawResponse.(*smithyhttp.Response)
2083	if !ok {
2084		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2085	}
2086
2087	if response.StatusCode < 200 || response.StatusCode >= 300 {
2088		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeHandshake(response, &metadata)
2089	}
2090	output := &DescribeHandshakeOutput{}
2091	out.Result = output
2092
2093	var buff [1024]byte
2094	ringBuffer := smithyio.NewRingBuffer(buff[:])
2095
2096	body := io.TeeReader(response.Body, ringBuffer)
2097	decoder := json.NewDecoder(body)
2098	decoder.UseNumber()
2099	var shape interface{}
2100	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2101		var snapshot bytes.Buffer
2102		io.Copy(&snapshot, ringBuffer)
2103		err = &smithy.DeserializationError{
2104			Err:      fmt.Errorf("failed to decode response body, %w", err),
2105			Snapshot: snapshot.Bytes(),
2106		}
2107		return out, metadata, err
2108	}
2109
2110	err = awsAwsjson11_deserializeOpDocumentDescribeHandshakeOutput(&output, shape)
2111	if err != nil {
2112		var snapshot bytes.Buffer
2113		io.Copy(&snapshot, ringBuffer)
2114		err = &smithy.DeserializationError{
2115			Err:      fmt.Errorf("failed to decode response body, %w", err),
2116			Snapshot: snapshot.Bytes(),
2117		}
2118		return out, metadata, err
2119	}
2120
2121	return out, metadata, err
2122}
2123
2124func awsAwsjson11_deserializeOpErrorDescribeHandshake(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2125	var errorBuffer bytes.Buffer
2126	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2127		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2128	}
2129	errorBody := bytes.NewReader(errorBuffer.Bytes())
2130
2131	errorCode := "UnknownError"
2132	errorMessage := errorCode
2133
2134	code := response.Header.Get("X-Amzn-ErrorType")
2135	if len(code) != 0 {
2136		errorCode = restjson.SanitizeErrorCode(code)
2137	}
2138
2139	var buff [1024]byte
2140	ringBuffer := smithyio.NewRingBuffer(buff[:])
2141
2142	body := io.TeeReader(errorBody, ringBuffer)
2143	decoder := json.NewDecoder(body)
2144	decoder.UseNumber()
2145	code, message, err := restjson.GetErrorInfo(decoder)
2146	if err != nil {
2147		var snapshot bytes.Buffer
2148		io.Copy(&snapshot, ringBuffer)
2149		err = &smithy.DeserializationError{
2150			Err:      fmt.Errorf("failed to decode response body, %w", err),
2151			Snapshot: snapshot.Bytes(),
2152		}
2153		return err
2154	}
2155
2156	errorBody.Seek(0, io.SeekStart)
2157	if len(code) != 0 {
2158		errorCode = restjson.SanitizeErrorCode(code)
2159	}
2160	if len(message) != 0 {
2161		errorMessage = message
2162	}
2163
2164	switch {
2165	case strings.EqualFold("AccessDeniedException", errorCode):
2166		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2167
2168	case strings.EqualFold("ConcurrentModificationException", errorCode):
2169		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
2170
2171	case strings.EqualFold("HandshakeNotFoundException", errorCode):
2172		return awsAwsjson11_deserializeErrorHandshakeNotFoundException(response, errorBody)
2173
2174	case strings.EqualFold("InvalidInputException", errorCode):
2175		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2176
2177	case strings.EqualFold("ServiceException", errorCode):
2178		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2179
2180	case strings.EqualFold("TooManyRequestsException", errorCode):
2181		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
2182
2183	default:
2184		genericError := &smithy.GenericAPIError{
2185			Code:    errorCode,
2186			Message: errorMessage,
2187		}
2188		return genericError
2189
2190	}
2191}
2192
2193type awsAwsjson11_deserializeOpDescribeOrganization struct {
2194}
2195
2196func (*awsAwsjson11_deserializeOpDescribeOrganization) ID() string {
2197	return "OperationDeserializer"
2198}
2199
2200func (m *awsAwsjson11_deserializeOpDescribeOrganization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2201	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2202) {
2203	out, metadata, err = next.HandleDeserialize(ctx, in)
2204	if err != nil {
2205		return out, metadata, err
2206	}
2207
2208	response, ok := out.RawResponse.(*smithyhttp.Response)
2209	if !ok {
2210		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2211	}
2212
2213	if response.StatusCode < 200 || response.StatusCode >= 300 {
2214		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeOrganization(response, &metadata)
2215	}
2216	output := &DescribeOrganizationOutput{}
2217	out.Result = output
2218
2219	var buff [1024]byte
2220	ringBuffer := smithyio.NewRingBuffer(buff[:])
2221
2222	body := io.TeeReader(response.Body, ringBuffer)
2223	decoder := json.NewDecoder(body)
2224	decoder.UseNumber()
2225	var shape interface{}
2226	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2227		var snapshot bytes.Buffer
2228		io.Copy(&snapshot, ringBuffer)
2229		err = &smithy.DeserializationError{
2230			Err:      fmt.Errorf("failed to decode response body, %w", err),
2231			Snapshot: snapshot.Bytes(),
2232		}
2233		return out, metadata, err
2234	}
2235
2236	err = awsAwsjson11_deserializeOpDocumentDescribeOrganizationOutput(&output, shape)
2237	if err != nil {
2238		var snapshot bytes.Buffer
2239		io.Copy(&snapshot, ringBuffer)
2240		err = &smithy.DeserializationError{
2241			Err:      fmt.Errorf("failed to decode response body, %w", err),
2242			Snapshot: snapshot.Bytes(),
2243		}
2244		return out, metadata, err
2245	}
2246
2247	return out, metadata, err
2248}
2249
2250func awsAwsjson11_deserializeOpErrorDescribeOrganization(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2251	var errorBuffer bytes.Buffer
2252	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2253		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2254	}
2255	errorBody := bytes.NewReader(errorBuffer.Bytes())
2256
2257	errorCode := "UnknownError"
2258	errorMessage := errorCode
2259
2260	code := response.Header.Get("X-Amzn-ErrorType")
2261	if len(code) != 0 {
2262		errorCode = restjson.SanitizeErrorCode(code)
2263	}
2264
2265	var buff [1024]byte
2266	ringBuffer := smithyio.NewRingBuffer(buff[:])
2267
2268	body := io.TeeReader(errorBody, ringBuffer)
2269	decoder := json.NewDecoder(body)
2270	decoder.UseNumber()
2271	code, message, err := restjson.GetErrorInfo(decoder)
2272	if err != nil {
2273		var snapshot bytes.Buffer
2274		io.Copy(&snapshot, ringBuffer)
2275		err = &smithy.DeserializationError{
2276			Err:      fmt.Errorf("failed to decode response body, %w", err),
2277			Snapshot: snapshot.Bytes(),
2278		}
2279		return err
2280	}
2281
2282	errorBody.Seek(0, io.SeekStart)
2283	if len(code) != 0 {
2284		errorCode = restjson.SanitizeErrorCode(code)
2285	}
2286	if len(message) != 0 {
2287		errorMessage = message
2288	}
2289
2290	switch {
2291	case strings.EqualFold("AccessDeniedException", errorCode):
2292		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2293
2294	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
2295		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
2296
2297	case strings.EqualFold("ConcurrentModificationException", errorCode):
2298		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
2299
2300	case strings.EqualFold("ServiceException", errorCode):
2301		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2302
2303	case strings.EqualFold("TooManyRequestsException", errorCode):
2304		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
2305
2306	default:
2307		genericError := &smithy.GenericAPIError{
2308			Code:    errorCode,
2309			Message: errorMessage,
2310		}
2311		return genericError
2312
2313	}
2314}
2315
2316type awsAwsjson11_deserializeOpDescribeOrganizationalUnit struct {
2317}
2318
2319func (*awsAwsjson11_deserializeOpDescribeOrganizationalUnit) ID() string {
2320	return "OperationDeserializer"
2321}
2322
2323func (m *awsAwsjson11_deserializeOpDescribeOrganizationalUnit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2324	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2325) {
2326	out, metadata, err = next.HandleDeserialize(ctx, in)
2327	if err != nil {
2328		return out, metadata, err
2329	}
2330
2331	response, ok := out.RawResponse.(*smithyhttp.Response)
2332	if !ok {
2333		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2334	}
2335
2336	if response.StatusCode < 200 || response.StatusCode >= 300 {
2337		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeOrganizationalUnit(response, &metadata)
2338	}
2339	output := &DescribeOrganizationalUnitOutput{}
2340	out.Result = output
2341
2342	var buff [1024]byte
2343	ringBuffer := smithyio.NewRingBuffer(buff[:])
2344
2345	body := io.TeeReader(response.Body, ringBuffer)
2346	decoder := json.NewDecoder(body)
2347	decoder.UseNumber()
2348	var shape interface{}
2349	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2350		var snapshot bytes.Buffer
2351		io.Copy(&snapshot, ringBuffer)
2352		err = &smithy.DeserializationError{
2353			Err:      fmt.Errorf("failed to decode response body, %w", err),
2354			Snapshot: snapshot.Bytes(),
2355		}
2356		return out, metadata, err
2357	}
2358
2359	err = awsAwsjson11_deserializeOpDocumentDescribeOrganizationalUnitOutput(&output, shape)
2360	if err != nil {
2361		var snapshot bytes.Buffer
2362		io.Copy(&snapshot, ringBuffer)
2363		err = &smithy.DeserializationError{
2364			Err:      fmt.Errorf("failed to decode response body, %w", err),
2365			Snapshot: snapshot.Bytes(),
2366		}
2367		return out, metadata, err
2368	}
2369
2370	return out, metadata, err
2371}
2372
2373func awsAwsjson11_deserializeOpErrorDescribeOrganizationalUnit(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2374	var errorBuffer bytes.Buffer
2375	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2376		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2377	}
2378	errorBody := bytes.NewReader(errorBuffer.Bytes())
2379
2380	errorCode := "UnknownError"
2381	errorMessage := errorCode
2382
2383	code := response.Header.Get("X-Amzn-ErrorType")
2384	if len(code) != 0 {
2385		errorCode = restjson.SanitizeErrorCode(code)
2386	}
2387
2388	var buff [1024]byte
2389	ringBuffer := smithyio.NewRingBuffer(buff[:])
2390
2391	body := io.TeeReader(errorBody, ringBuffer)
2392	decoder := json.NewDecoder(body)
2393	decoder.UseNumber()
2394	code, message, err := restjson.GetErrorInfo(decoder)
2395	if err != nil {
2396		var snapshot bytes.Buffer
2397		io.Copy(&snapshot, ringBuffer)
2398		err = &smithy.DeserializationError{
2399			Err:      fmt.Errorf("failed to decode response body, %w", err),
2400			Snapshot: snapshot.Bytes(),
2401		}
2402		return err
2403	}
2404
2405	errorBody.Seek(0, io.SeekStart)
2406	if len(code) != 0 {
2407		errorCode = restjson.SanitizeErrorCode(code)
2408	}
2409	if len(message) != 0 {
2410		errorMessage = message
2411	}
2412
2413	switch {
2414	case strings.EqualFold("AccessDeniedException", errorCode):
2415		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2416
2417	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
2418		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
2419
2420	case strings.EqualFold("InvalidInputException", errorCode):
2421		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2422
2423	case strings.EqualFold("OrganizationalUnitNotFoundException", errorCode):
2424		return awsAwsjson11_deserializeErrorOrganizationalUnitNotFoundException(response, errorBody)
2425
2426	case strings.EqualFold("ServiceException", errorCode):
2427		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2428
2429	case strings.EqualFold("TooManyRequestsException", errorCode):
2430		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
2431
2432	default:
2433		genericError := &smithy.GenericAPIError{
2434			Code:    errorCode,
2435			Message: errorMessage,
2436		}
2437		return genericError
2438
2439	}
2440}
2441
2442type awsAwsjson11_deserializeOpDescribePolicy struct {
2443}
2444
2445func (*awsAwsjson11_deserializeOpDescribePolicy) ID() string {
2446	return "OperationDeserializer"
2447}
2448
2449func (m *awsAwsjson11_deserializeOpDescribePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2450	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2451) {
2452	out, metadata, err = next.HandleDeserialize(ctx, in)
2453	if err != nil {
2454		return out, metadata, err
2455	}
2456
2457	response, ok := out.RawResponse.(*smithyhttp.Response)
2458	if !ok {
2459		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2460	}
2461
2462	if response.StatusCode < 200 || response.StatusCode >= 300 {
2463		return out, metadata, awsAwsjson11_deserializeOpErrorDescribePolicy(response, &metadata)
2464	}
2465	output := &DescribePolicyOutput{}
2466	out.Result = output
2467
2468	var buff [1024]byte
2469	ringBuffer := smithyio.NewRingBuffer(buff[:])
2470
2471	body := io.TeeReader(response.Body, ringBuffer)
2472	decoder := json.NewDecoder(body)
2473	decoder.UseNumber()
2474	var shape interface{}
2475	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2476		var snapshot bytes.Buffer
2477		io.Copy(&snapshot, ringBuffer)
2478		err = &smithy.DeserializationError{
2479			Err:      fmt.Errorf("failed to decode response body, %w", err),
2480			Snapshot: snapshot.Bytes(),
2481		}
2482		return out, metadata, err
2483	}
2484
2485	err = awsAwsjson11_deserializeOpDocumentDescribePolicyOutput(&output, shape)
2486	if err != nil {
2487		var snapshot bytes.Buffer
2488		io.Copy(&snapshot, ringBuffer)
2489		err = &smithy.DeserializationError{
2490			Err:      fmt.Errorf("failed to decode response body, %w", err),
2491			Snapshot: snapshot.Bytes(),
2492		}
2493		return out, metadata, err
2494	}
2495
2496	return out, metadata, err
2497}
2498
2499func awsAwsjson11_deserializeOpErrorDescribePolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2500	var errorBuffer bytes.Buffer
2501	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2502		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2503	}
2504	errorBody := bytes.NewReader(errorBuffer.Bytes())
2505
2506	errorCode := "UnknownError"
2507	errorMessage := errorCode
2508
2509	code := response.Header.Get("X-Amzn-ErrorType")
2510	if len(code) != 0 {
2511		errorCode = restjson.SanitizeErrorCode(code)
2512	}
2513
2514	var buff [1024]byte
2515	ringBuffer := smithyio.NewRingBuffer(buff[:])
2516
2517	body := io.TeeReader(errorBody, ringBuffer)
2518	decoder := json.NewDecoder(body)
2519	decoder.UseNumber()
2520	code, message, err := restjson.GetErrorInfo(decoder)
2521	if err != nil {
2522		var snapshot bytes.Buffer
2523		io.Copy(&snapshot, ringBuffer)
2524		err = &smithy.DeserializationError{
2525			Err:      fmt.Errorf("failed to decode response body, %w", err),
2526			Snapshot: snapshot.Bytes(),
2527		}
2528		return err
2529	}
2530
2531	errorBody.Seek(0, io.SeekStart)
2532	if len(code) != 0 {
2533		errorCode = restjson.SanitizeErrorCode(code)
2534	}
2535	if len(message) != 0 {
2536		errorMessage = message
2537	}
2538
2539	switch {
2540	case strings.EqualFold("AccessDeniedException", errorCode):
2541		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2542
2543	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
2544		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
2545
2546	case strings.EqualFold("InvalidInputException", errorCode):
2547		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2548
2549	case strings.EqualFold("PolicyNotFoundException", errorCode):
2550		return awsAwsjson11_deserializeErrorPolicyNotFoundException(response, errorBody)
2551
2552	case strings.EqualFold("ServiceException", errorCode):
2553		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2554
2555	case strings.EqualFold("TooManyRequestsException", errorCode):
2556		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
2557
2558	case strings.EqualFold("UnsupportedAPIEndpointException", errorCode):
2559		return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody)
2560
2561	default:
2562		genericError := &smithy.GenericAPIError{
2563			Code:    errorCode,
2564			Message: errorMessage,
2565		}
2566		return genericError
2567
2568	}
2569}
2570
2571type awsAwsjson11_deserializeOpDetachPolicy struct {
2572}
2573
2574func (*awsAwsjson11_deserializeOpDetachPolicy) ID() string {
2575	return "OperationDeserializer"
2576}
2577
2578func (m *awsAwsjson11_deserializeOpDetachPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2579	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2580) {
2581	out, metadata, err = next.HandleDeserialize(ctx, in)
2582	if err != nil {
2583		return out, metadata, err
2584	}
2585
2586	response, ok := out.RawResponse.(*smithyhttp.Response)
2587	if !ok {
2588		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2589	}
2590
2591	if response.StatusCode < 200 || response.StatusCode >= 300 {
2592		return out, metadata, awsAwsjson11_deserializeOpErrorDetachPolicy(response, &metadata)
2593	}
2594	output := &DetachPolicyOutput{}
2595	out.Result = output
2596
2597	if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
2598		return out, metadata, &smithy.DeserializationError{
2599			Err: fmt.Errorf("failed to discard response body, %w", err),
2600		}
2601	}
2602
2603	return out, metadata, err
2604}
2605
2606func awsAwsjson11_deserializeOpErrorDetachPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2607	var errorBuffer bytes.Buffer
2608	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2609		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2610	}
2611	errorBody := bytes.NewReader(errorBuffer.Bytes())
2612
2613	errorCode := "UnknownError"
2614	errorMessage := errorCode
2615
2616	code := response.Header.Get("X-Amzn-ErrorType")
2617	if len(code) != 0 {
2618		errorCode = restjson.SanitizeErrorCode(code)
2619	}
2620
2621	var buff [1024]byte
2622	ringBuffer := smithyio.NewRingBuffer(buff[:])
2623
2624	body := io.TeeReader(errorBody, ringBuffer)
2625	decoder := json.NewDecoder(body)
2626	decoder.UseNumber()
2627	code, message, err := restjson.GetErrorInfo(decoder)
2628	if err != nil {
2629		var snapshot bytes.Buffer
2630		io.Copy(&snapshot, ringBuffer)
2631		err = &smithy.DeserializationError{
2632			Err:      fmt.Errorf("failed to decode response body, %w", err),
2633			Snapshot: snapshot.Bytes(),
2634		}
2635		return err
2636	}
2637
2638	errorBody.Seek(0, io.SeekStart)
2639	if len(code) != 0 {
2640		errorCode = restjson.SanitizeErrorCode(code)
2641	}
2642	if len(message) != 0 {
2643		errorMessage = message
2644	}
2645
2646	switch {
2647	case strings.EqualFold("AccessDeniedException", errorCode):
2648		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2649
2650	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
2651		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
2652
2653	case strings.EqualFold("ConcurrentModificationException", errorCode):
2654		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
2655
2656	case strings.EqualFold("ConstraintViolationException", errorCode):
2657		return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody)
2658
2659	case strings.EqualFold("InvalidInputException", errorCode):
2660		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2661
2662	case strings.EqualFold("PolicyChangesInProgressException", errorCode):
2663		return awsAwsjson11_deserializeErrorPolicyChangesInProgressException(response, errorBody)
2664
2665	case strings.EqualFold("PolicyNotAttachedException", errorCode):
2666		return awsAwsjson11_deserializeErrorPolicyNotAttachedException(response, errorBody)
2667
2668	case strings.EqualFold("PolicyNotFoundException", errorCode):
2669		return awsAwsjson11_deserializeErrorPolicyNotFoundException(response, errorBody)
2670
2671	case strings.EqualFold("ServiceException", errorCode):
2672		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2673
2674	case strings.EqualFold("TargetNotFoundException", errorCode):
2675		return awsAwsjson11_deserializeErrorTargetNotFoundException(response, errorBody)
2676
2677	case strings.EqualFold("TooManyRequestsException", errorCode):
2678		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
2679
2680	case strings.EqualFold("UnsupportedAPIEndpointException", errorCode):
2681		return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody)
2682
2683	default:
2684		genericError := &smithy.GenericAPIError{
2685			Code:    errorCode,
2686			Message: errorMessage,
2687		}
2688		return genericError
2689
2690	}
2691}
2692
2693type awsAwsjson11_deserializeOpDisableAWSServiceAccess struct {
2694}
2695
2696func (*awsAwsjson11_deserializeOpDisableAWSServiceAccess) ID() string {
2697	return "OperationDeserializer"
2698}
2699
2700func (m *awsAwsjson11_deserializeOpDisableAWSServiceAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2701	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2702) {
2703	out, metadata, err = next.HandleDeserialize(ctx, in)
2704	if err != nil {
2705		return out, metadata, err
2706	}
2707
2708	response, ok := out.RawResponse.(*smithyhttp.Response)
2709	if !ok {
2710		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2711	}
2712
2713	if response.StatusCode < 200 || response.StatusCode >= 300 {
2714		return out, metadata, awsAwsjson11_deserializeOpErrorDisableAWSServiceAccess(response, &metadata)
2715	}
2716	output := &DisableAWSServiceAccessOutput{}
2717	out.Result = output
2718
2719	if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
2720		return out, metadata, &smithy.DeserializationError{
2721			Err: fmt.Errorf("failed to discard response body, %w", err),
2722		}
2723	}
2724
2725	return out, metadata, err
2726}
2727
2728func awsAwsjson11_deserializeOpErrorDisableAWSServiceAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2729	var errorBuffer bytes.Buffer
2730	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2731		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2732	}
2733	errorBody := bytes.NewReader(errorBuffer.Bytes())
2734
2735	errorCode := "UnknownError"
2736	errorMessage := errorCode
2737
2738	code := response.Header.Get("X-Amzn-ErrorType")
2739	if len(code) != 0 {
2740		errorCode = restjson.SanitizeErrorCode(code)
2741	}
2742
2743	var buff [1024]byte
2744	ringBuffer := smithyio.NewRingBuffer(buff[:])
2745
2746	body := io.TeeReader(errorBody, ringBuffer)
2747	decoder := json.NewDecoder(body)
2748	decoder.UseNumber()
2749	code, message, err := restjson.GetErrorInfo(decoder)
2750	if err != nil {
2751		var snapshot bytes.Buffer
2752		io.Copy(&snapshot, ringBuffer)
2753		err = &smithy.DeserializationError{
2754			Err:      fmt.Errorf("failed to decode response body, %w", err),
2755			Snapshot: snapshot.Bytes(),
2756		}
2757		return err
2758	}
2759
2760	errorBody.Seek(0, io.SeekStart)
2761	if len(code) != 0 {
2762		errorCode = restjson.SanitizeErrorCode(code)
2763	}
2764	if len(message) != 0 {
2765		errorMessage = message
2766	}
2767
2768	switch {
2769	case strings.EqualFold("AccessDeniedException", errorCode):
2770		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2771
2772	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
2773		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
2774
2775	case strings.EqualFold("ConcurrentModificationException", errorCode):
2776		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
2777
2778	case strings.EqualFold("ConstraintViolationException", errorCode):
2779		return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody)
2780
2781	case strings.EqualFold("InvalidInputException", errorCode):
2782		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2783
2784	case strings.EqualFold("ServiceException", errorCode):
2785		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2786
2787	case strings.EqualFold("TooManyRequestsException", errorCode):
2788		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
2789
2790	case strings.EqualFold("UnsupportedAPIEndpointException", errorCode):
2791		return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody)
2792
2793	default:
2794		genericError := &smithy.GenericAPIError{
2795			Code:    errorCode,
2796			Message: errorMessage,
2797		}
2798		return genericError
2799
2800	}
2801}
2802
2803type awsAwsjson11_deserializeOpDisablePolicyType struct {
2804}
2805
2806func (*awsAwsjson11_deserializeOpDisablePolicyType) ID() string {
2807	return "OperationDeserializer"
2808}
2809
2810func (m *awsAwsjson11_deserializeOpDisablePolicyType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2811	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2812) {
2813	out, metadata, err = next.HandleDeserialize(ctx, in)
2814	if err != nil {
2815		return out, metadata, err
2816	}
2817
2818	response, ok := out.RawResponse.(*smithyhttp.Response)
2819	if !ok {
2820		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2821	}
2822
2823	if response.StatusCode < 200 || response.StatusCode >= 300 {
2824		return out, metadata, awsAwsjson11_deserializeOpErrorDisablePolicyType(response, &metadata)
2825	}
2826	output := &DisablePolicyTypeOutput{}
2827	out.Result = output
2828
2829	var buff [1024]byte
2830	ringBuffer := smithyio.NewRingBuffer(buff[:])
2831
2832	body := io.TeeReader(response.Body, ringBuffer)
2833	decoder := json.NewDecoder(body)
2834	decoder.UseNumber()
2835	var shape interface{}
2836	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2837		var snapshot bytes.Buffer
2838		io.Copy(&snapshot, ringBuffer)
2839		err = &smithy.DeserializationError{
2840			Err:      fmt.Errorf("failed to decode response body, %w", err),
2841			Snapshot: snapshot.Bytes(),
2842		}
2843		return out, metadata, err
2844	}
2845
2846	err = awsAwsjson11_deserializeOpDocumentDisablePolicyTypeOutput(&output, shape)
2847	if err != nil {
2848		var snapshot bytes.Buffer
2849		io.Copy(&snapshot, ringBuffer)
2850		err = &smithy.DeserializationError{
2851			Err:      fmt.Errorf("failed to decode response body, %w", err),
2852			Snapshot: snapshot.Bytes(),
2853		}
2854		return out, metadata, err
2855	}
2856
2857	return out, metadata, err
2858}
2859
2860func awsAwsjson11_deserializeOpErrorDisablePolicyType(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2861	var errorBuffer bytes.Buffer
2862	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2863		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2864	}
2865	errorBody := bytes.NewReader(errorBuffer.Bytes())
2866
2867	errorCode := "UnknownError"
2868	errorMessage := errorCode
2869
2870	code := response.Header.Get("X-Amzn-ErrorType")
2871	if len(code) != 0 {
2872		errorCode = restjson.SanitizeErrorCode(code)
2873	}
2874
2875	var buff [1024]byte
2876	ringBuffer := smithyio.NewRingBuffer(buff[:])
2877
2878	body := io.TeeReader(errorBody, ringBuffer)
2879	decoder := json.NewDecoder(body)
2880	decoder.UseNumber()
2881	code, message, err := restjson.GetErrorInfo(decoder)
2882	if err != nil {
2883		var snapshot bytes.Buffer
2884		io.Copy(&snapshot, ringBuffer)
2885		err = &smithy.DeserializationError{
2886			Err:      fmt.Errorf("failed to decode response body, %w", err),
2887			Snapshot: snapshot.Bytes(),
2888		}
2889		return err
2890	}
2891
2892	errorBody.Seek(0, io.SeekStart)
2893	if len(code) != 0 {
2894		errorCode = restjson.SanitizeErrorCode(code)
2895	}
2896	if len(message) != 0 {
2897		errorMessage = message
2898	}
2899
2900	switch {
2901	case strings.EqualFold("AccessDeniedException", errorCode):
2902		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
2903
2904	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
2905		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
2906
2907	case strings.EqualFold("ConcurrentModificationException", errorCode):
2908		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
2909
2910	case strings.EqualFold("ConstraintViolationException", errorCode):
2911		return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody)
2912
2913	case strings.EqualFold("InvalidInputException", errorCode):
2914		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
2915
2916	case strings.EqualFold("PolicyChangesInProgressException", errorCode):
2917		return awsAwsjson11_deserializeErrorPolicyChangesInProgressException(response, errorBody)
2918
2919	case strings.EqualFold("PolicyTypeNotEnabledException", errorCode):
2920		return awsAwsjson11_deserializeErrorPolicyTypeNotEnabledException(response, errorBody)
2921
2922	case strings.EqualFold("RootNotFoundException", errorCode):
2923		return awsAwsjson11_deserializeErrorRootNotFoundException(response, errorBody)
2924
2925	case strings.EqualFold("ServiceException", errorCode):
2926		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
2927
2928	case strings.EqualFold("TooManyRequestsException", errorCode):
2929		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
2930
2931	case strings.EqualFold("UnsupportedAPIEndpointException", errorCode):
2932		return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody)
2933
2934	default:
2935		genericError := &smithy.GenericAPIError{
2936			Code:    errorCode,
2937			Message: errorMessage,
2938		}
2939		return genericError
2940
2941	}
2942}
2943
2944type awsAwsjson11_deserializeOpEnableAllFeatures struct {
2945}
2946
2947func (*awsAwsjson11_deserializeOpEnableAllFeatures) ID() string {
2948	return "OperationDeserializer"
2949}
2950
2951func (m *awsAwsjson11_deserializeOpEnableAllFeatures) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2952	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2953) {
2954	out, metadata, err = next.HandleDeserialize(ctx, in)
2955	if err != nil {
2956		return out, metadata, err
2957	}
2958
2959	response, ok := out.RawResponse.(*smithyhttp.Response)
2960	if !ok {
2961		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2962	}
2963
2964	if response.StatusCode < 200 || response.StatusCode >= 300 {
2965		return out, metadata, awsAwsjson11_deserializeOpErrorEnableAllFeatures(response, &metadata)
2966	}
2967	output := &EnableAllFeaturesOutput{}
2968	out.Result = output
2969
2970	var buff [1024]byte
2971	ringBuffer := smithyio.NewRingBuffer(buff[:])
2972
2973	body := io.TeeReader(response.Body, ringBuffer)
2974	decoder := json.NewDecoder(body)
2975	decoder.UseNumber()
2976	var shape interface{}
2977	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2978		var snapshot bytes.Buffer
2979		io.Copy(&snapshot, ringBuffer)
2980		err = &smithy.DeserializationError{
2981			Err:      fmt.Errorf("failed to decode response body, %w", err),
2982			Snapshot: snapshot.Bytes(),
2983		}
2984		return out, metadata, err
2985	}
2986
2987	err = awsAwsjson11_deserializeOpDocumentEnableAllFeaturesOutput(&output, shape)
2988	if err != nil {
2989		var snapshot bytes.Buffer
2990		io.Copy(&snapshot, ringBuffer)
2991		err = &smithy.DeserializationError{
2992			Err:      fmt.Errorf("failed to decode response body, %w", err),
2993			Snapshot: snapshot.Bytes(),
2994		}
2995		return out, metadata, err
2996	}
2997
2998	return out, metadata, err
2999}
3000
3001func awsAwsjson11_deserializeOpErrorEnableAllFeatures(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3002	var errorBuffer bytes.Buffer
3003	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3004		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3005	}
3006	errorBody := bytes.NewReader(errorBuffer.Bytes())
3007
3008	errorCode := "UnknownError"
3009	errorMessage := errorCode
3010
3011	code := response.Header.Get("X-Amzn-ErrorType")
3012	if len(code) != 0 {
3013		errorCode = restjson.SanitizeErrorCode(code)
3014	}
3015
3016	var buff [1024]byte
3017	ringBuffer := smithyio.NewRingBuffer(buff[:])
3018
3019	body := io.TeeReader(errorBody, ringBuffer)
3020	decoder := json.NewDecoder(body)
3021	decoder.UseNumber()
3022	code, message, err := restjson.GetErrorInfo(decoder)
3023	if err != nil {
3024		var snapshot bytes.Buffer
3025		io.Copy(&snapshot, ringBuffer)
3026		err = &smithy.DeserializationError{
3027			Err:      fmt.Errorf("failed to decode response body, %w", err),
3028			Snapshot: snapshot.Bytes(),
3029		}
3030		return err
3031	}
3032
3033	errorBody.Seek(0, io.SeekStart)
3034	if len(code) != 0 {
3035		errorCode = restjson.SanitizeErrorCode(code)
3036	}
3037	if len(message) != 0 {
3038		errorMessage = message
3039	}
3040
3041	switch {
3042	case strings.EqualFold("AccessDeniedException", errorCode):
3043		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3044
3045	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
3046		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
3047
3048	case strings.EqualFold("ConcurrentModificationException", errorCode):
3049		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
3050
3051	case strings.EqualFold("HandshakeConstraintViolationException", errorCode):
3052		return awsAwsjson11_deserializeErrorHandshakeConstraintViolationException(response, errorBody)
3053
3054	case strings.EqualFold("InvalidInputException", errorCode):
3055		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3056
3057	case strings.EqualFold("ServiceException", errorCode):
3058		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3059
3060	case strings.EqualFold("TooManyRequestsException", errorCode):
3061		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
3062
3063	default:
3064		genericError := &smithy.GenericAPIError{
3065			Code:    errorCode,
3066			Message: errorMessage,
3067		}
3068		return genericError
3069
3070	}
3071}
3072
3073type awsAwsjson11_deserializeOpEnableAWSServiceAccess struct {
3074}
3075
3076func (*awsAwsjson11_deserializeOpEnableAWSServiceAccess) ID() string {
3077	return "OperationDeserializer"
3078}
3079
3080func (m *awsAwsjson11_deserializeOpEnableAWSServiceAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3081	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3082) {
3083	out, metadata, err = next.HandleDeserialize(ctx, in)
3084	if err != nil {
3085		return out, metadata, err
3086	}
3087
3088	response, ok := out.RawResponse.(*smithyhttp.Response)
3089	if !ok {
3090		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3091	}
3092
3093	if response.StatusCode < 200 || response.StatusCode >= 300 {
3094		return out, metadata, awsAwsjson11_deserializeOpErrorEnableAWSServiceAccess(response, &metadata)
3095	}
3096	output := &EnableAWSServiceAccessOutput{}
3097	out.Result = output
3098
3099	if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
3100		return out, metadata, &smithy.DeserializationError{
3101			Err: fmt.Errorf("failed to discard response body, %w", err),
3102		}
3103	}
3104
3105	return out, metadata, err
3106}
3107
3108func awsAwsjson11_deserializeOpErrorEnableAWSServiceAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3109	var errorBuffer bytes.Buffer
3110	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3111		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3112	}
3113	errorBody := bytes.NewReader(errorBuffer.Bytes())
3114
3115	errorCode := "UnknownError"
3116	errorMessage := errorCode
3117
3118	code := response.Header.Get("X-Amzn-ErrorType")
3119	if len(code) != 0 {
3120		errorCode = restjson.SanitizeErrorCode(code)
3121	}
3122
3123	var buff [1024]byte
3124	ringBuffer := smithyio.NewRingBuffer(buff[:])
3125
3126	body := io.TeeReader(errorBody, ringBuffer)
3127	decoder := json.NewDecoder(body)
3128	decoder.UseNumber()
3129	code, message, err := restjson.GetErrorInfo(decoder)
3130	if err != nil {
3131		var snapshot bytes.Buffer
3132		io.Copy(&snapshot, ringBuffer)
3133		err = &smithy.DeserializationError{
3134			Err:      fmt.Errorf("failed to decode response body, %w", err),
3135			Snapshot: snapshot.Bytes(),
3136		}
3137		return err
3138	}
3139
3140	errorBody.Seek(0, io.SeekStart)
3141	if len(code) != 0 {
3142		errorCode = restjson.SanitizeErrorCode(code)
3143	}
3144	if len(message) != 0 {
3145		errorMessage = message
3146	}
3147
3148	switch {
3149	case strings.EqualFold("AccessDeniedException", errorCode):
3150		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3151
3152	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
3153		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
3154
3155	case strings.EqualFold("ConcurrentModificationException", errorCode):
3156		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
3157
3158	case strings.EqualFold("ConstraintViolationException", errorCode):
3159		return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody)
3160
3161	case strings.EqualFold("InvalidInputException", errorCode):
3162		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3163
3164	case strings.EqualFold("ServiceException", errorCode):
3165		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3166
3167	case strings.EqualFold("TooManyRequestsException", errorCode):
3168		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
3169
3170	case strings.EqualFold("UnsupportedAPIEndpointException", errorCode):
3171		return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody)
3172
3173	default:
3174		genericError := &smithy.GenericAPIError{
3175			Code:    errorCode,
3176			Message: errorMessage,
3177		}
3178		return genericError
3179
3180	}
3181}
3182
3183type awsAwsjson11_deserializeOpEnablePolicyType struct {
3184}
3185
3186func (*awsAwsjson11_deserializeOpEnablePolicyType) ID() string {
3187	return "OperationDeserializer"
3188}
3189
3190func (m *awsAwsjson11_deserializeOpEnablePolicyType) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3191	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3192) {
3193	out, metadata, err = next.HandleDeserialize(ctx, in)
3194	if err != nil {
3195		return out, metadata, err
3196	}
3197
3198	response, ok := out.RawResponse.(*smithyhttp.Response)
3199	if !ok {
3200		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3201	}
3202
3203	if response.StatusCode < 200 || response.StatusCode >= 300 {
3204		return out, metadata, awsAwsjson11_deserializeOpErrorEnablePolicyType(response, &metadata)
3205	}
3206	output := &EnablePolicyTypeOutput{}
3207	out.Result = output
3208
3209	var buff [1024]byte
3210	ringBuffer := smithyio.NewRingBuffer(buff[:])
3211
3212	body := io.TeeReader(response.Body, ringBuffer)
3213	decoder := json.NewDecoder(body)
3214	decoder.UseNumber()
3215	var shape interface{}
3216	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3217		var snapshot bytes.Buffer
3218		io.Copy(&snapshot, ringBuffer)
3219		err = &smithy.DeserializationError{
3220			Err:      fmt.Errorf("failed to decode response body, %w", err),
3221			Snapshot: snapshot.Bytes(),
3222		}
3223		return out, metadata, err
3224	}
3225
3226	err = awsAwsjson11_deserializeOpDocumentEnablePolicyTypeOutput(&output, shape)
3227	if err != nil {
3228		var snapshot bytes.Buffer
3229		io.Copy(&snapshot, ringBuffer)
3230		err = &smithy.DeserializationError{
3231			Err:      fmt.Errorf("failed to decode response body, %w", err),
3232			Snapshot: snapshot.Bytes(),
3233		}
3234		return out, metadata, err
3235	}
3236
3237	return out, metadata, err
3238}
3239
3240func awsAwsjson11_deserializeOpErrorEnablePolicyType(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3241	var errorBuffer bytes.Buffer
3242	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3243		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3244	}
3245	errorBody := bytes.NewReader(errorBuffer.Bytes())
3246
3247	errorCode := "UnknownError"
3248	errorMessage := errorCode
3249
3250	code := response.Header.Get("X-Amzn-ErrorType")
3251	if len(code) != 0 {
3252		errorCode = restjson.SanitizeErrorCode(code)
3253	}
3254
3255	var buff [1024]byte
3256	ringBuffer := smithyio.NewRingBuffer(buff[:])
3257
3258	body := io.TeeReader(errorBody, ringBuffer)
3259	decoder := json.NewDecoder(body)
3260	decoder.UseNumber()
3261	code, message, err := restjson.GetErrorInfo(decoder)
3262	if err != nil {
3263		var snapshot bytes.Buffer
3264		io.Copy(&snapshot, ringBuffer)
3265		err = &smithy.DeserializationError{
3266			Err:      fmt.Errorf("failed to decode response body, %w", err),
3267			Snapshot: snapshot.Bytes(),
3268		}
3269		return err
3270	}
3271
3272	errorBody.Seek(0, io.SeekStart)
3273	if len(code) != 0 {
3274		errorCode = restjson.SanitizeErrorCode(code)
3275	}
3276	if len(message) != 0 {
3277		errorMessage = message
3278	}
3279
3280	switch {
3281	case strings.EqualFold("AccessDeniedException", errorCode):
3282		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3283
3284	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
3285		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
3286
3287	case strings.EqualFold("ConcurrentModificationException", errorCode):
3288		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
3289
3290	case strings.EqualFold("ConstraintViolationException", errorCode):
3291		return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody)
3292
3293	case strings.EqualFold("InvalidInputException", errorCode):
3294		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3295
3296	case strings.EqualFold("PolicyChangesInProgressException", errorCode):
3297		return awsAwsjson11_deserializeErrorPolicyChangesInProgressException(response, errorBody)
3298
3299	case strings.EqualFold("PolicyTypeAlreadyEnabledException", errorCode):
3300		return awsAwsjson11_deserializeErrorPolicyTypeAlreadyEnabledException(response, errorBody)
3301
3302	case strings.EqualFold("PolicyTypeNotAvailableForOrganizationException", errorCode):
3303		return awsAwsjson11_deserializeErrorPolicyTypeNotAvailableForOrganizationException(response, errorBody)
3304
3305	case strings.EqualFold("RootNotFoundException", errorCode):
3306		return awsAwsjson11_deserializeErrorRootNotFoundException(response, errorBody)
3307
3308	case strings.EqualFold("ServiceException", errorCode):
3309		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3310
3311	case strings.EqualFold("TooManyRequestsException", errorCode):
3312		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
3313
3314	case strings.EqualFold("UnsupportedAPIEndpointException", errorCode):
3315		return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody)
3316
3317	default:
3318		genericError := &smithy.GenericAPIError{
3319			Code:    errorCode,
3320			Message: errorMessage,
3321		}
3322		return genericError
3323
3324	}
3325}
3326
3327type awsAwsjson11_deserializeOpInviteAccountToOrganization struct {
3328}
3329
3330func (*awsAwsjson11_deserializeOpInviteAccountToOrganization) ID() string {
3331	return "OperationDeserializer"
3332}
3333
3334func (m *awsAwsjson11_deserializeOpInviteAccountToOrganization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3335	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3336) {
3337	out, metadata, err = next.HandleDeserialize(ctx, in)
3338	if err != nil {
3339		return out, metadata, err
3340	}
3341
3342	response, ok := out.RawResponse.(*smithyhttp.Response)
3343	if !ok {
3344		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3345	}
3346
3347	if response.StatusCode < 200 || response.StatusCode >= 300 {
3348		return out, metadata, awsAwsjson11_deserializeOpErrorInviteAccountToOrganization(response, &metadata)
3349	}
3350	output := &InviteAccountToOrganizationOutput{}
3351	out.Result = output
3352
3353	var buff [1024]byte
3354	ringBuffer := smithyio.NewRingBuffer(buff[:])
3355
3356	body := io.TeeReader(response.Body, ringBuffer)
3357	decoder := json.NewDecoder(body)
3358	decoder.UseNumber()
3359	var shape interface{}
3360	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3361		var snapshot bytes.Buffer
3362		io.Copy(&snapshot, ringBuffer)
3363		err = &smithy.DeserializationError{
3364			Err:      fmt.Errorf("failed to decode response body, %w", err),
3365			Snapshot: snapshot.Bytes(),
3366		}
3367		return out, metadata, err
3368	}
3369
3370	err = awsAwsjson11_deserializeOpDocumentInviteAccountToOrganizationOutput(&output, shape)
3371	if err != nil {
3372		var snapshot bytes.Buffer
3373		io.Copy(&snapshot, ringBuffer)
3374		err = &smithy.DeserializationError{
3375			Err:      fmt.Errorf("failed to decode response body, %w", err),
3376			Snapshot: snapshot.Bytes(),
3377		}
3378		return out, metadata, err
3379	}
3380
3381	return out, metadata, err
3382}
3383
3384func awsAwsjson11_deserializeOpErrorInviteAccountToOrganization(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3385	var errorBuffer bytes.Buffer
3386	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3387		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3388	}
3389	errorBody := bytes.NewReader(errorBuffer.Bytes())
3390
3391	errorCode := "UnknownError"
3392	errorMessage := errorCode
3393
3394	code := response.Header.Get("X-Amzn-ErrorType")
3395	if len(code) != 0 {
3396		errorCode = restjson.SanitizeErrorCode(code)
3397	}
3398
3399	var buff [1024]byte
3400	ringBuffer := smithyio.NewRingBuffer(buff[:])
3401
3402	body := io.TeeReader(errorBody, ringBuffer)
3403	decoder := json.NewDecoder(body)
3404	decoder.UseNumber()
3405	code, message, err := restjson.GetErrorInfo(decoder)
3406	if err != nil {
3407		var snapshot bytes.Buffer
3408		io.Copy(&snapshot, ringBuffer)
3409		err = &smithy.DeserializationError{
3410			Err:      fmt.Errorf("failed to decode response body, %w", err),
3411			Snapshot: snapshot.Bytes(),
3412		}
3413		return err
3414	}
3415
3416	errorBody.Seek(0, io.SeekStart)
3417	if len(code) != 0 {
3418		errorCode = restjson.SanitizeErrorCode(code)
3419	}
3420	if len(message) != 0 {
3421		errorMessage = message
3422	}
3423
3424	switch {
3425	case strings.EqualFold("AccessDeniedException", errorCode):
3426		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3427
3428	case strings.EqualFold("AccountOwnerNotVerifiedException", errorCode):
3429		return awsAwsjson11_deserializeErrorAccountOwnerNotVerifiedException(response, errorBody)
3430
3431	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
3432		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
3433
3434	case strings.EqualFold("ConcurrentModificationException", errorCode):
3435		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
3436
3437	case strings.EqualFold("ConstraintViolationException", errorCode):
3438		return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody)
3439
3440	case strings.EqualFold("DuplicateHandshakeException", errorCode):
3441		return awsAwsjson11_deserializeErrorDuplicateHandshakeException(response, errorBody)
3442
3443	case strings.EqualFold("FinalizingOrganizationException", errorCode):
3444		return awsAwsjson11_deserializeErrorFinalizingOrganizationException(response, errorBody)
3445
3446	case strings.EqualFold("HandshakeConstraintViolationException", errorCode):
3447		return awsAwsjson11_deserializeErrorHandshakeConstraintViolationException(response, errorBody)
3448
3449	case strings.EqualFold("InvalidInputException", errorCode):
3450		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3451
3452	case strings.EqualFold("ServiceException", errorCode):
3453		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3454
3455	case strings.EqualFold("TooManyRequestsException", errorCode):
3456		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
3457
3458	default:
3459		genericError := &smithy.GenericAPIError{
3460			Code:    errorCode,
3461			Message: errorMessage,
3462		}
3463		return genericError
3464
3465	}
3466}
3467
3468type awsAwsjson11_deserializeOpLeaveOrganization struct {
3469}
3470
3471func (*awsAwsjson11_deserializeOpLeaveOrganization) ID() string {
3472	return "OperationDeserializer"
3473}
3474
3475func (m *awsAwsjson11_deserializeOpLeaveOrganization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3476	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3477) {
3478	out, metadata, err = next.HandleDeserialize(ctx, in)
3479	if err != nil {
3480		return out, metadata, err
3481	}
3482
3483	response, ok := out.RawResponse.(*smithyhttp.Response)
3484	if !ok {
3485		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3486	}
3487
3488	if response.StatusCode < 200 || response.StatusCode >= 300 {
3489		return out, metadata, awsAwsjson11_deserializeOpErrorLeaveOrganization(response, &metadata)
3490	}
3491	output := &LeaveOrganizationOutput{}
3492	out.Result = output
3493
3494	if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
3495		return out, metadata, &smithy.DeserializationError{
3496			Err: fmt.Errorf("failed to discard response body, %w", err),
3497		}
3498	}
3499
3500	return out, metadata, err
3501}
3502
3503func awsAwsjson11_deserializeOpErrorLeaveOrganization(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3504	var errorBuffer bytes.Buffer
3505	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3506		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3507	}
3508	errorBody := bytes.NewReader(errorBuffer.Bytes())
3509
3510	errorCode := "UnknownError"
3511	errorMessage := errorCode
3512
3513	code := response.Header.Get("X-Amzn-ErrorType")
3514	if len(code) != 0 {
3515		errorCode = restjson.SanitizeErrorCode(code)
3516	}
3517
3518	var buff [1024]byte
3519	ringBuffer := smithyio.NewRingBuffer(buff[:])
3520
3521	body := io.TeeReader(errorBody, ringBuffer)
3522	decoder := json.NewDecoder(body)
3523	decoder.UseNumber()
3524	code, message, err := restjson.GetErrorInfo(decoder)
3525	if err != nil {
3526		var snapshot bytes.Buffer
3527		io.Copy(&snapshot, ringBuffer)
3528		err = &smithy.DeserializationError{
3529			Err:      fmt.Errorf("failed to decode response body, %w", err),
3530			Snapshot: snapshot.Bytes(),
3531		}
3532		return err
3533	}
3534
3535	errorBody.Seek(0, io.SeekStart)
3536	if len(code) != 0 {
3537		errorCode = restjson.SanitizeErrorCode(code)
3538	}
3539	if len(message) != 0 {
3540		errorMessage = message
3541	}
3542
3543	switch {
3544	case strings.EqualFold("AccessDeniedException", errorCode):
3545		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3546
3547	case strings.EqualFold("AccountNotFoundException", errorCode):
3548		return awsAwsjson11_deserializeErrorAccountNotFoundException(response, errorBody)
3549
3550	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
3551		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
3552
3553	case strings.EqualFold("ConcurrentModificationException", errorCode):
3554		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
3555
3556	case strings.EqualFold("ConstraintViolationException", errorCode):
3557		return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody)
3558
3559	case strings.EqualFold("InvalidInputException", errorCode):
3560		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3561
3562	case strings.EqualFold("MasterCannotLeaveOrganizationException", errorCode):
3563		return awsAwsjson11_deserializeErrorMasterCannotLeaveOrganizationException(response, errorBody)
3564
3565	case strings.EqualFold("ServiceException", errorCode):
3566		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3567
3568	case strings.EqualFold("TooManyRequestsException", errorCode):
3569		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
3570
3571	default:
3572		genericError := &smithy.GenericAPIError{
3573			Code:    errorCode,
3574			Message: errorMessage,
3575		}
3576		return genericError
3577
3578	}
3579}
3580
3581type awsAwsjson11_deserializeOpListAccounts struct {
3582}
3583
3584func (*awsAwsjson11_deserializeOpListAccounts) ID() string {
3585	return "OperationDeserializer"
3586}
3587
3588func (m *awsAwsjson11_deserializeOpListAccounts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3589	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3590) {
3591	out, metadata, err = next.HandleDeserialize(ctx, in)
3592	if err != nil {
3593		return out, metadata, err
3594	}
3595
3596	response, ok := out.RawResponse.(*smithyhttp.Response)
3597	if !ok {
3598		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3599	}
3600
3601	if response.StatusCode < 200 || response.StatusCode >= 300 {
3602		return out, metadata, awsAwsjson11_deserializeOpErrorListAccounts(response, &metadata)
3603	}
3604	output := &ListAccountsOutput{}
3605	out.Result = output
3606
3607	var buff [1024]byte
3608	ringBuffer := smithyio.NewRingBuffer(buff[:])
3609
3610	body := io.TeeReader(response.Body, ringBuffer)
3611	decoder := json.NewDecoder(body)
3612	decoder.UseNumber()
3613	var shape interface{}
3614	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3615		var snapshot bytes.Buffer
3616		io.Copy(&snapshot, ringBuffer)
3617		err = &smithy.DeserializationError{
3618			Err:      fmt.Errorf("failed to decode response body, %w", err),
3619			Snapshot: snapshot.Bytes(),
3620		}
3621		return out, metadata, err
3622	}
3623
3624	err = awsAwsjson11_deserializeOpDocumentListAccountsOutput(&output, shape)
3625	if err != nil {
3626		var snapshot bytes.Buffer
3627		io.Copy(&snapshot, ringBuffer)
3628		err = &smithy.DeserializationError{
3629			Err:      fmt.Errorf("failed to decode response body, %w", err),
3630			Snapshot: snapshot.Bytes(),
3631		}
3632		return out, metadata, err
3633	}
3634
3635	return out, metadata, err
3636}
3637
3638func awsAwsjson11_deserializeOpErrorListAccounts(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3639	var errorBuffer bytes.Buffer
3640	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3641		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3642	}
3643	errorBody := bytes.NewReader(errorBuffer.Bytes())
3644
3645	errorCode := "UnknownError"
3646	errorMessage := errorCode
3647
3648	code := response.Header.Get("X-Amzn-ErrorType")
3649	if len(code) != 0 {
3650		errorCode = restjson.SanitizeErrorCode(code)
3651	}
3652
3653	var buff [1024]byte
3654	ringBuffer := smithyio.NewRingBuffer(buff[:])
3655
3656	body := io.TeeReader(errorBody, ringBuffer)
3657	decoder := json.NewDecoder(body)
3658	decoder.UseNumber()
3659	code, message, err := restjson.GetErrorInfo(decoder)
3660	if err != nil {
3661		var snapshot bytes.Buffer
3662		io.Copy(&snapshot, ringBuffer)
3663		err = &smithy.DeserializationError{
3664			Err:      fmt.Errorf("failed to decode response body, %w", err),
3665			Snapshot: snapshot.Bytes(),
3666		}
3667		return err
3668	}
3669
3670	errorBody.Seek(0, io.SeekStart)
3671	if len(code) != 0 {
3672		errorCode = restjson.SanitizeErrorCode(code)
3673	}
3674	if len(message) != 0 {
3675		errorMessage = message
3676	}
3677
3678	switch {
3679	case strings.EqualFold("AccessDeniedException", errorCode):
3680		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3681
3682	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
3683		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
3684
3685	case strings.EqualFold("InvalidInputException", errorCode):
3686		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3687
3688	case strings.EqualFold("ServiceException", errorCode):
3689		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3690
3691	case strings.EqualFold("TooManyRequestsException", errorCode):
3692		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
3693
3694	default:
3695		genericError := &smithy.GenericAPIError{
3696			Code:    errorCode,
3697			Message: errorMessage,
3698		}
3699		return genericError
3700
3701	}
3702}
3703
3704type awsAwsjson11_deserializeOpListAccountsForParent struct {
3705}
3706
3707func (*awsAwsjson11_deserializeOpListAccountsForParent) ID() string {
3708	return "OperationDeserializer"
3709}
3710
3711func (m *awsAwsjson11_deserializeOpListAccountsForParent) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3712	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3713) {
3714	out, metadata, err = next.HandleDeserialize(ctx, in)
3715	if err != nil {
3716		return out, metadata, err
3717	}
3718
3719	response, ok := out.RawResponse.(*smithyhttp.Response)
3720	if !ok {
3721		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3722	}
3723
3724	if response.StatusCode < 200 || response.StatusCode >= 300 {
3725		return out, metadata, awsAwsjson11_deserializeOpErrorListAccountsForParent(response, &metadata)
3726	}
3727	output := &ListAccountsForParentOutput{}
3728	out.Result = output
3729
3730	var buff [1024]byte
3731	ringBuffer := smithyio.NewRingBuffer(buff[:])
3732
3733	body := io.TeeReader(response.Body, ringBuffer)
3734	decoder := json.NewDecoder(body)
3735	decoder.UseNumber()
3736	var shape interface{}
3737	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3738		var snapshot bytes.Buffer
3739		io.Copy(&snapshot, ringBuffer)
3740		err = &smithy.DeserializationError{
3741			Err:      fmt.Errorf("failed to decode response body, %w", err),
3742			Snapshot: snapshot.Bytes(),
3743		}
3744		return out, metadata, err
3745	}
3746
3747	err = awsAwsjson11_deserializeOpDocumentListAccountsForParentOutput(&output, shape)
3748	if err != nil {
3749		var snapshot bytes.Buffer
3750		io.Copy(&snapshot, ringBuffer)
3751		err = &smithy.DeserializationError{
3752			Err:      fmt.Errorf("failed to decode response body, %w", err),
3753			Snapshot: snapshot.Bytes(),
3754		}
3755		return out, metadata, err
3756	}
3757
3758	return out, metadata, err
3759}
3760
3761func awsAwsjson11_deserializeOpErrorListAccountsForParent(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3762	var errorBuffer bytes.Buffer
3763	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3764		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3765	}
3766	errorBody := bytes.NewReader(errorBuffer.Bytes())
3767
3768	errorCode := "UnknownError"
3769	errorMessage := errorCode
3770
3771	code := response.Header.Get("X-Amzn-ErrorType")
3772	if len(code) != 0 {
3773		errorCode = restjson.SanitizeErrorCode(code)
3774	}
3775
3776	var buff [1024]byte
3777	ringBuffer := smithyio.NewRingBuffer(buff[:])
3778
3779	body := io.TeeReader(errorBody, ringBuffer)
3780	decoder := json.NewDecoder(body)
3781	decoder.UseNumber()
3782	code, message, err := restjson.GetErrorInfo(decoder)
3783	if err != nil {
3784		var snapshot bytes.Buffer
3785		io.Copy(&snapshot, ringBuffer)
3786		err = &smithy.DeserializationError{
3787			Err:      fmt.Errorf("failed to decode response body, %w", err),
3788			Snapshot: snapshot.Bytes(),
3789		}
3790		return err
3791	}
3792
3793	errorBody.Seek(0, io.SeekStart)
3794	if len(code) != 0 {
3795		errorCode = restjson.SanitizeErrorCode(code)
3796	}
3797	if len(message) != 0 {
3798		errorMessage = message
3799	}
3800
3801	switch {
3802	case strings.EqualFold("AccessDeniedException", errorCode):
3803		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3804
3805	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
3806		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
3807
3808	case strings.EqualFold("InvalidInputException", errorCode):
3809		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3810
3811	case strings.EqualFold("ParentNotFoundException", errorCode):
3812		return awsAwsjson11_deserializeErrorParentNotFoundException(response, errorBody)
3813
3814	case strings.EqualFold("ServiceException", errorCode):
3815		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3816
3817	case strings.EqualFold("TooManyRequestsException", errorCode):
3818		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
3819
3820	default:
3821		genericError := &smithy.GenericAPIError{
3822			Code:    errorCode,
3823			Message: errorMessage,
3824		}
3825		return genericError
3826
3827	}
3828}
3829
3830type awsAwsjson11_deserializeOpListAWSServiceAccessForOrganization struct {
3831}
3832
3833func (*awsAwsjson11_deserializeOpListAWSServiceAccessForOrganization) ID() string {
3834	return "OperationDeserializer"
3835}
3836
3837func (m *awsAwsjson11_deserializeOpListAWSServiceAccessForOrganization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3838	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3839) {
3840	out, metadata, err = next.HandleDeserialize(ctx, in)
3841	if err != nil {
3842		return out, metadata, err
3843	}
3844
3845	response, ok := out.RawResponse.(*smithyhttp.Response)
3846	if !ok {
3847		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3848	}
3849
3850	if response.StatusCode < 200 || response.StatusCode >= 300 {
3851		return out, metadata, awsAwsjson11_deserializeOpErrorListAWSServiceAccessForOrganization(response, &metadata)
3852	}
3853	output := &ListAWSServiceAccessForOrganizationOutput{}
3854	out.Result = output
3855
3856	var buff [1024]byte
3857	ringBuffer := smithyio.NewRingBuffer(buff[:])
3858
3859	body := io.TeeReader(response.Body, ringBuffer)
3860	decoder := json.NewDecoder(body)
3861	decoder.UseNumber()
3862	var shape interface{}
3863	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3864		var snapshot bytes.Buffer
3865		io.Copy(&snapshot, ringBuffer)
3866		err = &smithy.DeserializationError{
3867			Err:      fmt.Errorf("failed to decode response body, %w", err),
3868			Snapshot: snapshot.Bytes(),
3869		}
3870		return out, metadata, err
3871	}
3872
3873	err = awsAwsjson11_deserializeOpDocumentListAWSServiceAccessForOrganizationOutput(&output, shape)
3874	if err != nil {
3875		var snapshot bytes.Buffer
3876		io.Copy(&snapshot, ringBuffer)
3877		err = &smithy.DeserializationError{
3878			Err:      fmt.Errorf("failed to decode response body, %w", err),
3879			Snapshot: snapshot.Bytes(),
3880		}
3881		return out, metadata, err
3882	}
3883
3884	return out, metadata, err
3885}
3886
3887func awsAwsjson11_deserializeOpErrorListAWSServiceAccessForOrganization(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3888	var errorBuffer bytes.Buffer
3889	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3890		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3891	}
3892	errorBody := bytes.NewReader(errorBuffer.Bytes())
3893
3894	errorCode := "UnknownError"
3895	errorMessage := errorCode
3896
3897	code := response.Header.Get("X-Amzn-ErrorType")
3898	if len(code) != 0 {
3899		errorCode = restjson.SanitizeErrorCode(code)
3900	}
3901
3902	var buff [1024]byte
3903	ringBuffer := smithyio.NewRingBuffer(buff[:])
3904
3905	body := io.TeeReader(errorBody, ringBuffer)
3906	decoder := json.NewDecoder(body)
3907	decoder.UseNumber()
3908	code, message, err := restjson.GetErrorInfo(decoder)
3909	if err != nil {
3910		var snapshot bytes.Buffer
3911		io.Copy(&snapshot, ringBuffer)
3912		err = &smithy.DeserializationError{
3913			Err:      fmt.Errorf("failed to decode response body, %w", err),
3914			Snapshot: snapshot.Bytes(),
3915		}
3916		return err
3917	}
3918
3919	errorBody.Seek(0, io.SeekStart)
3920	if len(code) != 0 {
3921		errorCode = restjson.SanitizeErrorCode(code)
3922	}
3923	if len(message) != 0 {
3924		errorMessage = message
3925	}
3926
3927	switch {
3928	case strings.EqualFold("AccessDeniedException", errorCode):
3929		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
3930
3931	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
3932		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
3933
3934	case strings.EqualFold("ConstraintViolationException", errorCode):
3935		return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody)
3936
3937	case strings.EqualFold("InvalidInputException", errorCode):
3938		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
3939
3940	case strings.EqualFold("ServiceException", errorCode):
3941		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
3942
3943	case strings.EqualFold("TooManyRequestsException", errorCode):
3944		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
3945
3946	case strings.EqualFold("UnsupportedAPIEndpointException", errorCode):
3947		return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody)
3948
3949	default:
3950		genericError := &smithy.GenericAPIError{
3951			Code:    errorCode,
3952			Message: errorMessage,
3953		}
3954		return genericError
3955
3956	}
3957}
3958
3959type awsAwsjson11_deserializeOpListChildren struct {
3960}
3961
3962func (*awsAwsjson11_deserializeOpListChildren) ID() string {
3963	return "OperationDeserializer"
3964}
3965
3966func (m *awsAwsjson11_deserializeOpListChildren) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3967	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3968) {
3969	out, metadata, err = next.HandleDeserialize(ctx, in)
3970	if err != nil {
3971		return out, metadata, err
3972	}
3973
3974	response, ok := out.RawResponse.(*smithyhttp.Response)
3975	if !ok {
3976		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3977	}
3978
3979	if response.StatusCode < 200 || response.StatusCode >= 300 {
3980		return out, metadata, awsAwsjson11_deserializeOpErrorListChildren(response, &metadata)
3981	}
3982	output := &ListChildrenOutput{}
3983	out.Result = output
3984
3985	var buff [1024]byte
3986	ringBuffer := smithyio.NewRingBuffer(buff[:])
3987
3988	body := io.TeeReader(response.Body, ringBuffer)
3989	decoder := json.NewDecoder(body)
3990	decoder.UseNumber()
3991	var shape interface{}
3992	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3993		var snapshot bytes.Buffer
3994		io.Copy(&snapshot, ringBuffer)
3995		err = &smithy.DeserializationError{
3996			Err:      fmt.Errorf("failed to decode response body, %w", err),
3997			Snapshot: snapshot.Bytes(),
3998		}
3999		return out, metadata, err
4000	}
4001
4002	err = awsAwsjson11_deserializeOpDocumentListChildrenOutput(&output, shape)
4003	if err != nil {
4004		var snapshot bytes.Buffer
4005		io.Copy(&snapshot, ringBuffer)
4006		err = &smithy.DeserializationError{
4007			Err:      fmt.Errorf("failed to decode response body, %w", err),
4008			Snapshot: snapshot.Bytes(),
4009		}
4010		return out, metadata, err
4011	}
4012
4013	return out, metadata, err
4014}
4015
4016func awsAwsjson11_deserializeOpErrorListChildren(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4017	var errorBuffer bytes.Buffer
4018	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4019		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4020	}
4021	errorBody := bytes.NewReader(errorBuffer.Bytes())
4022
4023	errorCode := "UnknownError"
4024	errorMessage := errorCode
4025
4026	code := response.Header.Get("X-Amzn-ErrorType")
4027	if len(code) != 0 {
4028		errorCode = restjson.SanitizeErrorCode(code)
4029	}
4030
4031	var buff [1024]byte
4032	ringBuffer := smithyio.NewRingBuffer(buff[:])
4033
4034	body := io.TeeReader(errorBody, ringBuffer)
4035	decoder := json.NewDecoder(body)
4036	decoder.UseNumber()
4037	code, message, err := restjson.GetErrorInfo(decoder)
4038	if err != nil {
4039		var snapshot bytes.Buffer
4040		io.Copy(&snapshot, ringBuffer)
4041		err = &smithy.DeserializationError{
4042			Err:      fmt.Errorf("failed to decode response body, %w", err),
4043			Snapshot: snapshot.Bytes(),
4044		}
4045		return err
4046	}
4047
4048	errorBody.Seek(0, io.SeekStart)
4049	if len(code) != 0 {
4050		errorCode = restjson.SanitizeErrorCode(code)
4051	}
4052	if len(message) != 0 {
4053		errorMessage = message
4054	}
4055
4056	switch {
4057	case strings.EqualFold("AccessDeniedException", errorCode):
4058		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4059
4060	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
4061		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
4062
4063	case strings.EqualFold("InvalidInputException", errorCode):
4064		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4065
4066	case strings.EqualFold("ParentNotFoundException", errorCode):
4067		return awsAwsjson11_deserializeErrorParentNotFoundException(response, errorBody)
4068
4069	case strings.EqualFold("ServiceException", errorCode):
4070		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4071
4072	case strings.EqualFold("TooManyRequestsException", errorCode):
4073		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
4074
4075	default:
4076		genericError := &smithy.GenericAPIError{
4077			Code:    errorCode,
4078			Message: errorMessage,
4079		}
4080		return genericError
4081
4082	}
4083}
4084
4085type awsAwsjson11_deserializeOpListCreateAccountStatus struct {
4086}
4087
4088func (*awsAwsjson11_deserializeOpListCreateAccountStatus) ID() string {
4089	return "OperationDeserializer"
4090}
4091
4092func (m *awsAwsjson11_deserializeOpListCreateAccountStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4093	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4094) {
4095	out, metadata, err = next.HandleDeserialize(ctx, in)
4096	if err != nil {
4097		return out, metadata, err
4098	}
4099
4100	response, ok := out.RawResponse.(*smithyhttp.Response)
4101	if !ok {
4102		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4103	}
4104
4105	if response.StatusCode < 200 || response.StatusCode >= 300 {
4106		return out, metadata, awsAwsjson11_deserializeOpErrorListCreateAccountStatus(response, &metadata)
4107	}
4108	output := &ListCreateAccountStatusOutput{}
4109	out.Result = output
4110
4111	var buff [1024]byte
4112	ringBuffer := smithyio.NewRingBuffer(buff[:])
4113
4114	body := io.TeeReader(response.Body, ringBuffer)
4115	decoder := json.NewDecoder(body)
4116	decoder.UseNumber()
4117	var shape interface{}
4118	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4119		var snapshot bytes.Buffer
4120		io.Copy(&snapshot, ringBuffer)
4121		err = &smithy.DeserializationError{
4122			Err:      fmt.Errorf("failed to decode response body, %w", err),
4123			Snapshot: snapshot.Bytes(),
4124		}
4125		return out, metadata, err
4126	}
4127
4128	err = awsAwsjson11_deserializeOpDocumentListCreateAccountStatusOutput(&output, shape)
4129	if err != nil {
4130		var snapshot bytes.Buffer
4131		io.Copy(&snapshot, ringBuffer)
4132		err = &smithy.DeserializationError{
4133			Err:      fmt.Errorf("failed to decode response body, %w", err),
4134			Snapshot: snapshot.Bytes(),
4135		}
4136		return out, metadata, err
4137	}
4138
4139	return out, metadata, err
4140}
4141
4142func awsAwsjson11_deserializeOpErrorListCreateAccountStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4143	var errorBuffer bytes.Buffer
4144	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4145		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4146	}
4147	errorBody := bytes.NewReader(errorBuffer.Bytes())
4148
4149	errorCode := "UnknownError"
4150	errorMessage := errorCode
4151
4152	code := response.Header.Get("X-Amzn-ErrorType")
4153	if len(code) != 0 {
4154		errorCode = restjson.SanitizeErrorCode(code)
4155	}
4156
4157	var buff [1024]byte
4158	ringBuffer := smithyio.NewRingBuffer(buff[:])
4159
4160	body := io.TeeReader(errorBody, ringBuffer)
4161	decoder := json.NewDecoder(body)
4162	decoder.UseNumber()
4163	code, message, err := restjson.GetErrorInfo(decoder)
4164	if err != nil {
4165		var snapshot bytes.Buffer
4166		io.Copy(&snapshot, ringBuffer)
4167		err = &smithy.DeserializationError{
4168			Err:      fmt.Errorf("failed to decode response body, %w", err),
4169			Snapshot: snapshot.Bytes(),
4170		}
4171		return err
4172	}
4173
4174	errorBody.Seek(0, io.SeekStart)
4175	if len(code) != 0 {
4176		errorCode = restjson.SanitizeErrorCode(code)
4177	}
4178	if len(message) != 0 {
4179		errorMessage = message
4180	}
4181
4182	switch {
4183	case strings.EqualFold("AccessDeniedException", errorCode):
4184		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4185
4186	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
4187		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
4188
4189	case strings.EqualFold("InvalidInputException", errorCode):
4190		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4191
4192	case strings.EqualFold("ServiceException", errorCode):
4193		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4194
4195	case strings.EqualFold("TooManyRequestsException", errorCode):
4196		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
4197
4198	case strings.EqualFold("UnsupportedAPIEndpointException", errorCode):
4199		return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody)
4200
4201	default:
4202		genericError := &smithy.GenericAPIError{
4203			Code:    errorCode,
4204			Message: errorMessage,
4205		}
4206		return genericError
4207
4208	}
4209}
4210
4211type awsAwsjson11_deserializeOpListDelegatedAdministrators struct {
4212}
4213
4214func (*awsAwsjson11_deserializeOpListDelegatedAdministrators) ID() string {
4215	return "OperationDeserializer"
4216}
4217
4218func (m *awsAwsjson11_deserializeOpListDelegatedAdministrators) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4219	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4220) {
4221	out, metadata, err = next.HandleDeserialize(ctx, in)
4222	if err != nil {
4223		return out, metadata, err
4224	}
4225
4226	response, ok := out.RawResponse.(*smithyhttp.Response)
4227	if !ok {
4228		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4229	}
4230
4231	if response.StatusCode < 200 || response.StatusCode >= 300 {
4232		return out, metadata, awsAwsjson11_deserializeOpErrorListDelegatedAdministrators(response, &metadata)
4233	}
4234	output := &ListDelegatedAdministratorsOutput{}
4235	out.Result = output
4236
4237	var buff [1024]byte
4238	ringBuffer := smithyio.NewRingBuffer(buff[:])
4239
4240	body := io.TeeReader(response.Body, ringBuffer)
4241	decoder := json.NewDecoder(body)
4242	decoder.UseNumber()
4243	var shape interface{}
4244	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4245		var snapshot bytes.Buffer
4246		io.Copy(&snapshot, ringBuffer)
4247		err = &smithy.DeserializationError{
4248			Err:      fmt.Errorf("failed to decode response body, %w", err),
4249			Snapshot: snapshot.Bytes(),
4250		}
4251		return out, metadata, err
4252	}
4253
4254	err = awsAwsjson11_deserializeOpDocumentListDelegatedAdministratorsOutput(&output, shape)
4255	if err != nil {
4256		var snapshot bytes.Buffer
4257		io.Copy(&snapshot, ringBuffer)
4258		err = &smithy.DeserializationError{
4259			Err:      fmt.Errorf("failed to decode response body, %w", err),
4260			Snapshot: snapshot.Bytes(),
4261		}
4262		return out, metadata, err
4263	}
4264
4265	return out, metadata, err
4266}
4267
4268func awsAwsjson11_deserializeOpErrorListDelegatedAdministrators(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4269	var errorBuffer bytes.Buffer
4270	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4271		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4272	}
4273	errorBody := bytes.NewReader(errorBuffer.Bytes())
4274
4275	errorCode := "UnknownError"
4276	errorMessage := errorCode
4277
4278	code := response.Header.Get("X-Amzn-ErrorType")
4279	if len(code) != 0 {
4280		errorCode = restjson.SanitizeErrorCode(code)
4281	}
4282
4283	var buff [1024]byte
4284	ringBuffer := smithyio.NewRingBuffer(buff[:])
4285
4286	body := io.TeeReader(errorBody, ringBuffer)
4287	decoder := json.NewDecoder(body)
4288	decoder.UseNumber()
4289	code, message, err := restjson.GetErrorInfo(decoder)
4290	if err != nil {
4291		var snapshot bytes.Buffer
4292		io.Copy(&snapshot, ringBuffer)
4293		err = &smithy.DeserializationError{
4294			Err:      fmt.Errorf("failed to decode response body, %w", err),
4295			Snapshot: snapshot.Bytes(),
4296		}
4297		return err
4298	}
4299
4300	errorBody.Seek(0, io.SeekStart)
4301	if len(code) != 0 {
4302		errorCode = restjson.SanitizeErrorCode(code)
4303	}
4304	if len(message) != 0 {
4305		errorMessage = message
4306	}
4307
4308	switch {
4309	case strings.EqualFold("AccessDeniedException", errorCode):
4310		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4311
4312	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
4313		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
4314
4315	case strings.EqualFold("ConstraintViolationException", errorCode):
4316		return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody)
4317
4318	case strings.EqualFold("InvalidInputException", errorCode):
4319		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4320
4321	case strings.EqualFold("ServiceException", errorCode):
4322		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4323
4324	case strings.EqualFold("TooManyRequestsException", errorCode):
4325		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
4326
4327	case strings.EqualFold("UnsupportedAPIEndpointException", errorCode):
4328		return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody)
4329
4330	default:
4331		genericError := &smithy.GenericAPIError{
4332			Code:    errorCode,
4333			Message: errorMessage,
4334		}
4335		return genericError
4336
4337	}
4338}
4339
4340type awsAwsjson11_deserializeOpListDelegatedServicesForAccount struct {
4341}
4342
4343func (*awsAwsjson11_deserializeOpListDelegatedServicesForAccount) ID() string {
4344	return "OperationDeserializer"
4345}
4346
4347func (m *awsAwsjson11_deserializeOpListDelegatedServicesForAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4348	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4349) {
4350	out, metadata, err = next.HandleDeserialize(ctx, in)
4351	if err != nil {
4352		return out, metadata, err
4353	}
4354
4355	response, ok := out.RawResponse.(*smithyhttp.Response)
4356	if !ok {
4357		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4358	}
4359
4360	if response.StatusCode < 200 || response.StatusCode >= 300 {
4361		return out, metadata, awsAwsjson11_deserializeOpErrorListDelegatedServicesForAccount(response, &metadata)
4362	}
4363	output := &ListDelegatedServicesForAccountOutput{}
4364	out.Result = output
4365
4366	var buff [1024]byte
4367	ringBuffer := smithyio.NewRingBuffer(buff[:])
4368
4369	body := io.TeeReader(response.Body, ringBuffer)
4370	decoder := json.NewDecoder(body)
4371	decoder.UseNumber()
4372	var shape interface{}
4373	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4374		var snapshot bytes.Buffer
4375		io.Copy(&snapshot, ringBuffer)
4376		err = &smithy.DeserializationError{
4377			Err:      fmt.Errorf("failed to decode response body, %w", err),
4378			Snapshot: snapshot.Bytes(),
4379		}
4380		return out, metadata, err
4381	}
4382
4383	err = awsAwsjson11_deserializeOpDocumentListDelegatedServicesForAccountOutput(&output, shape)
4384	if err != nil {
4385		var snapshot bytes.Buffer
4386		io.Copy(&snapshot, ringBuffer)
4387		err = &smithy.DeserializationError{
4388			Err:      fmt.Errorf("failed to decode response body, %w", err),
4389			Snapshot: snapshot.Bytes(),
4390		}
4391		return out, metadata, err
4392	}
4393
4394	return out, metadata, err
4395}
4396
4397func awsAwsjson11_deserializeOpErrorListDelegatedServicesForAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4398	var errorBuffer bytes.Buffer
4399	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4400		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4401	}
4402	errorBody := bytes.NewReader(errorBuffer.Bytes())
4403
4404	errorCode := "UnknownError"
4405	errorMessage := errorCode
4406
4407	code := response.Header.Get("X-Amzn-ErrorType")
4408	if len(code) != 0 {
4409		errorCode = restjson.SanitizeErrorCode(code)
4410	}
4411
4412	var buff [1024]byte
4413	ringBuffer := smithyio.NewRingBuffer(buff[:])
4414
4415	body := io.TeeReader(errorBody, ringBuffer)
4416	decoder := json.NewDecoder(body)
4417	decoder.UseNumber()
4418	code, message, err := restjson.GetErrorInfo(decoder)
4419	if err != nil {
4420		var snapshot bytes.Buffer
4421		io.Copy(&snapshot, ringBuffer)
4422		err = &smithy.DeserializationError{
4423			Err:      fmt.Errorf("failed to decode response body, %w", err),
4424			Snapshot: snapshot.Bytes(),
4425		}
4426		return err
4427	}
4428
4429	errorBody.Seek(0, io.SeekStart)
4430	if len(code) != 0 {
4431		errorCode = restjson.SanitizeErrorCode(code)
4432	}
4433	if len(message) != 0 {
4434		errorMessage = message
4435	}
4436
4437	switch {
4438	case strings.EqualFold("AccessDeniedException", errorCode):
4439		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4440
4441	case strings.EqualFold("AccountNotFoundException", errorCode):
4442		return awsAwsjson11_deserializeErrorAccountNotFoundException(response, errorBody)
4443
4444	case strings.EqualFold("AccountNotRegisteredException", errorCode):
4445		return awsAwsjson11_deserializeErrorAccountNotRegisteredException(response, errorBody)
4446
4447	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
4448		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
4449
4450	case strings.EqualFold("ConstraintViolationException", errorCode):
4451		return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody)
4452
4453	case strings.EqualFold("InvalidInputException", errorCode):
4454		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4455
4456	case strings.EqualFold("ServiceException", errorCode):
4457		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4458
4459	case strings.EqualFold("TooManyRequestsException", errorCode):
4460		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
4461
4462	case strings.EqualFold("UnsupportedAPIEndpointException", errorCode):
4463		return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody)
4464
4465	default:
4466		genericError := &smithy.GenericAPIError{
4467			Code:    errorCode,
4468			Message: errorMessage,
4469		}
4470		return genericError
4471
4472	}
4473}
4474
4475type awsAwsjson11_deserializeOpListHandshakesForAccount struct {
4476}
4477
4478func (*awsAwsjson11_deserializeOpListHandshakesForAccount) ID() string {
4479	return "OperationDeserializer"
4480}
4481
4482func (m *awsAwsjson11_deserializeOpListHandshakesForAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4483	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4484) {
4485	out, metadata, err = next.HandleDeserialize(ctx, in)
4486	if err != nil {
4487		return out, metadata, err
4488	}
4489
4490	response, ok := out.RawResponse.(*smithyhttp.Response)
4491	if !ok {
4492		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4493	}
4494
4495	if response.StatusCode < 200 || response.StatusCode >= 300 {
4496		return out, metadata, awsAwsjson11_deserializeOpErrorListHandshakesForAccount(response, &metadata)
4497	}
4498	output := &ListHandshakesForAccountOutput{}
4499	out.Result = output
4500
4501	var buff [1024]byte
4502	ringBuffer := smithyio.NewRingBuffer(buff[:])
4503
4504	body := io.TeeReader(response.Body, ringBuffer)
4505	decoder := json.NewDecoder(body)
4506	decoder.UseNumber()
4507	var shape interface{}
4508	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4509		var snapshot bytes.Buffer
4510		io.Copy(&snapshot, ringBuffer)
4511		err = &smithy.DeserializationError{
4512			Err:      fmt.Errorf("failed to decode response body, %w", err),
4513			Snapshot: snapshot.Bytes(),
4514		}
4515		return out, metadata, err
4516	}
4517
4518	err = awsAwsjson11_deserializeOpDocumentListHandshakesForAccountOutput(&output, shape)
4519	if err != nil {
4520		var snapshot bytes.Buffer
4521		io.Copy(&snapshot, ringBuffer)
4522		err = &smithy.DeserializationError{
4523			Err:      fmt.Errorf("failed to decode response body, %w", err),
4524			Snapshot: snapshot.Bytes(),
4525		}
4526		return out, metadata, err
4527	}
4528
4529	return out, metadata, err
4530}
4531
4532func awsAwsjson11_deserializeOpErrorListHandshakesForAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4533	var errorBuffer bytes.Buffer
4534	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4535		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4536	}
4537	errorBody := bytes.NewReader(errorBuffer.Bytes())
4538
4539	errorCode := "UnknownError"
4540	errorMessage := errorCode
4541
4542	code := response.Header.Get("X-Amzn-ErrorType")
4543	if len(code) != 0 {
4544		errorCode = restjson.SanitizeErrorCode(code)
4545	}
4546
4547	var buff [1024]byte
4548	ringBuffer := smithyio.NewRingBuffer(buff[:])
4549
4550	body := io.TeeReader(errorBody, ringBuffer)
4551	decoder := json.NewDecoder(body)
4552	decoder.UseNumber()
4553	code, message, err := restjson.GetErrorInfo(decoder)
4554	if err != nil {
4555		var snapshot bytes.Buffer
4556		io.Copy(&snapshot, ringBuffer)
4557		err = &smithy.DeserializationError{
4558			Err:      fmt.Errorf("failed to decode response body, %w", err),
4559			Snapshot: snapshot.Bytes(),
4560		}
4561		return err
4562	}
4563
4564	errorBody.Seek(0, io.SeekStart)
4565	if len(code) != 0 {
4566		errorCode = restjson.SanitizeErrorCode(code)
4567	}
4568	if len(message) != 0 {
4569		errorMessage = message
4570	}
4571
4572	switch {
4573	case strings.EqualFold("AccessDeniedException", errorCode):
4574		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4575
4576	case strings.EqualFold("ConcurrentModificationException", errorCode):
4577		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
4578
4579	case strings.EqualFold("InvalidInputException", errorCode):
4580		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4581
4582	case strings.EqualFold("ServiceException", errorCode):
4583		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4584
4585	case strings.EqualFold("TooManyRequestsException", errorCode):
4586		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
4587
4588	default:
4589		genericError := &smithy.GenericAPIError{
4590			Code:    errorCode,
4591			Message: errorMessage,
4592		}
4593		return genericError
4594
4595	}
4596}
4597
4598type awsAwsjson11_deserializeOpListHandshakesForOrganization struct {
4599}
4600
4601func (*awsAwsjson11_deserializeOpListHandshakesForOrganization) ID() string {
4602	return "OperationDeserializer"
4603}
4604
4605func (m *awsAwsjson11_deserializeOpListHandshakesForOrganization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4606	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4607) {
4608	out, metadata, err = next.HandleDeserialize(ctx, in)
4609	if err != nil {
4610		return out, metadata, err
4611	}
4612
4613	response, ok := out.RawResponse.(*smithyhttp.Response)
4614	if !ok {
4615		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4616	}
4617
4618	if response.StatusCode < 200 || response.StatusCode >= 300 {
4619		return out, metadata, awsAwsjson11_deserializeOpErrorListHandshakesForOrganization(response, &metadata)
4620	}
4621	output := &ListHandshakesForOrganizationOutput{}
4622	out.Result = output
4623
4624	var buff [1024]byte
4625	ringBuffer := smithyio.NewRingBuffer(buff[:])
4626
4627	body := io.TeeReader(response.Body, ringBuffer)
4628	decoder := json.NewDecoder(body)
4629	decoder.UseNumber()
4630	var shape interface{}
4631	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4632		var snapshot bytes.Buffer
4633		io.Copy(&snapshot, ringBuffer)
4634		err = &smithy.DeserializationError{
4635			Err:      fmt.Errorf("failed to decode response body, %w", err),
4636			Snapshot: snapshot.Bytes(),
4637		}
4638		return out, metadata, err
4639	}
4640
4641	err = awsAwsjson11_deserializeOpDocumentListHandshakesForOrganizationOutput(&output, shape)
4642	if err != nil {
4643		var snapshot bytes.Buffer
4644		io.Copy(&snapshot, ringBuffer)
4645		err = &smithy.DeserializationError{
4646			Err:      fmt.Errorf("failed to decode response body, %w", err),
4647			Snapshot: snapshot.Bytes(),
4648		}
4649		return out, metadata, err
4650	}
4651
4652	return out, metadata, err
4653}
4654
4655func awsAwsjson11_deserializeOpErrorListHandshakesForOrganization(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4656	var errorBuffer bytes.Buffer
4657	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4658		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4659	}
4660	errorBody := bytes.NewReader(errorBuffer.Bytes())
4661
4662	errorCode := "UnknownError"
4663	errorMessage := errorCode
4664
4665	code := response.Header.Get("X-Amzn-ErrorType")
4666	if len(code) != 0 {
4667		errorCode = restjson.SanitizeErrorCode(code)
4668	}
4669
4670	var buff [1024]byte
4671	ringBuffer := smithyio.NewRingBuffer(buff[:])
4672
4673	body := io.TeeReader(errorBody, ringBuffer)
4674	decoder := json.NewDecoder(body)
4675	decoder.UseNumber()
4676	code, message, err := restjson.GetErrorInfo(decoder)
4677	if err != nil {
4678		var snapshot bytes.Buffer
4679		io.Copy(&snapshot, ringBuffer)
4680		err = &smithy.DeserializationError{
4681			Err:      fmt.Errorf("failed to decode response body, %w", err),
4682			Snapshot: snapshot.Bytes(),
4683		}
4684		return err
4685	}
4686
4687	errorBody.Seek(0, io.SeekStart)
4688	if len(code) != 0 {
4689		errorCode = restjson.SanitizeErrorCode(code)
4690	}
4691	if len(message) != 0 {
4692		errorMessage = message
4693	}
4694
4695	switch {
4696	case strings.EqualFold("AccessDeniedException", errorCode):
4697		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4698
4699	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
4700		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
4701
4702	case strings.EqualFold("ConcurrentModificationException", errorCode):
4703		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
4704
4705	case strings.EqualFold("InvalidInputException", errorCode):
4706		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4707
4708	case strings.EqualFold("ServiceException", errorCode):
4709		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4710
4711	case strings.EqualFold("TooManyRequestsException", errorCode):
4712		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
4713
4714	default:
4715		genericError := &smithy.GenericAPIError{
4716			Code:    errorCode,
4717			Message: errorMessage,
4718		}
4719		return genericError
4720
4721	}
4722}
4723
4724type awsAwsjson11_deserializeOpListOrganizationalUnitsForParent struct {
4725}
4726
4727func (*awsAwsjson11_deserializeOpListOrganizationalUnitsForParent) ID() string {
4728	return "OperationDeserializer"
4729}
4730
4731func (m *awsAwsjson11_deserializeOpListOrganizationalUnitsForParent) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4732	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4733) {
4734	out, metadata, err = next.HandleDeserialize(ctx, in)
4735	if err != nil {
4736		return out, metadata, err
4737	}
4738
4739	response, ok := out.RawResponse.(*smithyhttp.Response)
4740	if !ok {
4741		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4742	}
4743
4744	if response.StatusCode < 200 || response.StatusCode >= 300 {
4745		return out, metadata, awsAwsjson11_deserializeOpErrorListOrganizationalUnitsForParent(response, &metadata)
4746	}
4747	output := &ListOrganizationalUnitsForParentOutput{}
4748	out.Result = output
4749
4750	var buff [1024]byte
4751	ringBuffer := smithyio.NewRingBuffer(buff[:])
4752
4753	body := io.TeeReader(response.Body, ringBuffer)
4754	decoder := json.NewDecoder(body)
4755	decoder.UseNumber()
4756	var shape interface{}
4757	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4758		var snapshot bytes.Buffer
4759		io.Copy(&snapshot, ringBuffer)
4760		err = &smithy.DeserializationError{
4761			Err:      fmt.Errorf("failed to decode response body, %w", err),
4762			Snapshot: snapshot.Bytes(),
4763		}
4764		return out, metadata, err
4765	}
4766
4767	err = awsAwsjson11_deserializeOpDocumentListOrganizationalUnitsForParentOutput(&output, shape)
4768	if err != nil {
4769		var snapshot bytes.Buffer
4770		io.Copy(&snapshot, ringBuffer)
4771		err = &smithy.DeserializationError{
4772			Err:      fmt.Errorf("failed to decode response body, %w", err),
4773			Snapshot: snapshot.Bytes(),
4774		}
4775		return out, metadata, err
4776	}
4777
4778	return out, metadata, err
4779}
4780
4781func awsAwsjson11_deserializeOpErrorListOrganizationalUnitsForParent(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4782	var errorBuffer bytes.Buffer
4783	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4784		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4785	}
4786	errorBody := bytes.NewReader(errorBuffer.Bytes())
4787
4788	errorCode := "UnknownError"
4789	errorMessage := errorCode
4790
4791	code := response.Header.Get("X-Amzn-ErrorType")
4792	if len(code) != 0 {
4793		errorCode = restjson.SanitizeErrorCode(code)
4794	}
4795
4796	var buff [1024]byte
4797	ringBuffer := smithyio.NewRingBuffer(buff[:])
4798
4799	body := io.TeeReader(errorBody, ringBuffer)
4800	decoder := json.NewDecoder(body)
4801	decoder.UseNumber()
4802	code, message, err := restjson.GetErrorInfo(decoder)
4803	if err != nil {
4804		var snapshot bytes.Buffer
4805		io.Copy(&snapshot, ringBuffer)
4806		err = &smithy.DeserializationError{
4807			Err:      fmt.Errorf("failed to decode response body, %w", err),
4808			Snapshot: snapshot.Bytes(),
4809		}
4810		return err
4811	}
4812
4813	errorBody.Seek(0, io.SeekStart)
4814	if len(code) != 0 {
4815		errorCode = restjson.SanitizeErrorCode(code)
4816	}
4817	if len(message) != 0 {
4818		errorMessage = message
4819	}
4820
4821	switch {
4822	case strings.EqualFold("AccessDeniedException", errorCode):
4823		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4824
4825	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
4826		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
4827
4828	case strings.EqualFold("InvalidInputException", errorCode):
4829		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4830
4831	case strings.EqualFold("ParentNotFoundException", errorCode):
4832		return awsAwsjson11_deserializeErrorParentNotFoundException(response, errorBody)
4833
4834	case strings.EqualFold("ServiceException", errorCode):
4835		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4836
4837	case strings.EqualFold("TooManyRequestsException", errorCode):
4838		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
4839
4840	default:
4841		genericError := &smithy.GenericAPIError{
4842			Code:    errorCode,
4843			Message: errorMessage,
4844		}
4845		return genericError
4846
4847	}
4848}
4849
4850type awsAwsjson11_deserializeOpListParents struct {
4851}
4852
4853func (*awsAwsjson11_deserializeOpListParents) ID() string {
4854	return "OperationDeserializer"
4855}
4856
4857func (m *awsAwsjson11_deserializeOpListParents) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4858	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4859) {
4860	out, metadata, err = next.HandleDeserialize(ctx, in)
4861	if err != nil {
4862		return out, metadata, err
4863	}
4864
4865	response, ok := out.RawResponse.(*smithyhttp.Response)
4866	if !ok {
4867		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4868	}
4869
4870	if response.StatusCode < 200 || response.StatusCode >= 300 {
4871		return out, metadata, awsAwsjson11_deserializeOpErrorListParents(response, &metadata)
4872	}
4873	output := &ListParentsOutput{}
4874	out.Result = output
4875
4876	var buff [1024]byte
4877	ringBuffer := smithyio.NewRingBuffer(buff[:])
4878
4879	body := io.TeeReader(response.Body, ringBuffer)
4880	decoder := json.NewDecoder(body)
4881	decoder.UseNumber()
4882	var shape interface{}
4883	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4884		var snapshot bytes.Buffer
4885		io.Copy(&snapshot, ringBuffer)
4886		err = &smithy.DeserializationError{
4887			Err:      fmt.Errorf("failed to decode response body, %w", err),
4888			Snapshot: snapshot.Bytes(),
4889		}
4890		return out, metadata, err
4891	}
4892
4893	err = awsAwsjson11_deserializeOpDocumentListParentsOutput(&output, shape)
4894	if err != nil {
4895		var snapshot bytes.Buffer
4896		io.Copy(&snapshot, ringBuffer)
4897		err = &smithy.DeserializationError{
4898			Err:      fmt.Errorf("failed to decode response body, %w", err),
4899			Snapshot: snapshot.Bytes(),
4900		}
4901		return out, metadata, err
4902	}
4903
4904	return out, metadata, err
4905}
4906
4907func awsAwsjson11_deserializeOpErrorListParents(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4908	var errorBuffer bytes.Buffer
4909	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4910		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4911	}
4912	errorBody := bytes.NewReader(errorBuffer.Bytes())
4913
4914	errorCode := "UnknownError"
4915	errorMessage := errorCode
4916
4917	code := response.Header.Get("X-Amzn-ErrorType")
4918	if len(code) != 0 {
4919		errorCode = restjson.SanitizeErrorCode(code)
4920	}
4921
4922	var buff [1024]byte
4923	ringBuffer := smithyio.NewRingBuffer(buff[:])
4924
4925	body := io.TeeReader(errorBody, ringBuffer)
4926	decoder := json.NewDecoder(body)
4927	decoder.UseNumber()
4928	code, message, err := restjson.GetErrorInfo(decoder)
4929	if err != nil {
4930		var snapshot bytes.Buffer
4931		io.Copy(&snapshot, ringBuffer)
4932		err = &smithy.DeserializationError{
4933			Err:      fmt.Errorf("failed to decode response body, %w", err),
4934			Snapshot: snapshot.Bytes(),
4935		}
4936		return err
4937	}
4938
4939	errorBody.Seek(0, io.SeekStart)
4940	if len(code) != 0 {
4941		errorCode = restjson.SanitizeErrorCode(code)
4942	}
4943	if len(message) != 0 {
4944		errorMessage = message
4945	}
4946
4947	switch {
4948	case strings.EqualFold("AccessDeniedException", errorCode):
4949		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
4950
4951	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
4952		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
4953
4954	case strings.EqualFold("ChildNotFoundException", errorCode):
4955		return awsAwsjson11_deserializeErrorChildNotFoundException(response, errorBody)
4956
4957	case strings.EqualFold("InvalidInputException", errorCode):
4958		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
4959
4960	case strings.EqualFold("ServiceException", errorCode):
4961		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
4962
4963	case strings.EqualFold("TooManyRequestsException", errorCode):
4964		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
4965
4966	default:
4967		genericError := &smithy.GenericAPIError{
4968			Code:    errorCode,
4969			Message: errorMessage,
4970		}
4971		return genericError
4972
4973	}
4974}
4975
4976type awsAwsjson11_deserializeOpListPolicies struct {
4977}
4978
4979func (*awsAwsjson11_deserializeOpListPolicies) ID() string {
4980	return "OperationDeserializer"
4981}
4982
4983func (m *awsAwsjson11_deserializeOpListPolicies) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4984	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4985) {
4986	out, metadata, err = next.HandleDeserialize(ctx, in)
4987	if err != nil {
4988		return out, metadata, err
4989	}
4990
4991	response, ok := out.RawResponse.(*smithyhttp.Response)
4992	if !ok {
4993		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4994	}
4995
4996	if response.StatusCode < 200 || response.StatusCode >= 300 {
4997		return out, metadata, awsAwsjson11_deserializeOpErrorListPolicies(response, &metadata)
4998	}
4999	output := &ListPoliciesOutput{}
5000	out.Result = output
5001
5002	var buff [1024]byte
5003	ringBuffer := smithyio.NewRingBuffer(buff[:])
5004
5005	body := io.TeeReader(response.Body, ringBuffer)
5006	decoder := json.NewDecoder(body)
5007	decoder.UseNumber()
5008	var shape interface{}
5009	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5010		var snapshot bytes.Buffer
5011		io.Copy(&snapshot, ringBuffer)
5012		err = &smithy.DeserializationError{
5013			Err:      fmt.Errorf("failed to decode response body, %w", err),
5014			Snapshot: snapshot.Bytes(),
5015		}
5016		return out, metadata, err
5017	}
5018
5019	err = awsAwsjson11_deserializeOpDocumentListPoliciesOutput(&output, shape)
5020	if err != nil {
5021		var snapshot bytes.Buffer
5022		io.Copy(&snapshot, ringBuffer)
5023		err = &smithy.DeserializationError{
5024			Err:      fmt.Errorf("failed to decode response body, %w", err),
5025			Snapshot: snapshot.Bytes(),
5026		}
5027		return out, metadata, err
5028	}
5029
5030	return out, metadata, err
5031}
5032
5033func awsAwsjson11_deserializeOpErrorListPolicies(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5034	var errorBuffer bytes.Buffer
5035	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5036		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5037	}
5038	errorBody := bytes.NewReader(errorBuffer.Bytes())
5039
5040	errorCode := "UnknownError"
5041	errorMessage := errorCode
5042
5043	code := response.Header.Get("X-Amzn-ErrorType")
5044	if len(code) != 0 {
5045		errorCode = restjson.SanitizeErrorCode(code)
5046	}
5047
5048	var buff [1024]byte
5049	ringBuffer := smithyio.NewRingBuffer(buff[:])
5050
5051	body := io.TeeReader(errorBody, ringBuffer)
5052	decoder := json.NewDecoder(body)
5053	decoder.UseNumber()
5054	code, message, err := restjson.GetErrorInfo(decoder)
5055	if err != nil {
5056		var snapshot bytes.Buffer
5057		io.Copy(&snapshot, ringBuffer)
5058		err = &smithy.DeserializationError{
5059			Err:      fmt.Errorf("failed to decode response body, %w", err),
5060			Snapshot: snapshot.Bytes(),
5061		}
5062		return err
5063	}
5064
5065	errorBody.Seek(0, io.SeekStart)
5066	if len(code) != 0 {
5067		errorCode = restjson.SanitizeErrorCode(code)
5068	}
5069	if len(message) != 0 {
5070		errorMessage = message
5071	}
5072
5073	switch {
5074	case strings.EqualFold("AccessDeniedException", errorCode):
5075		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5076
5077	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
5078		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
5079
5080	case strings.EqualFold("InvalidInputException", errorCode):
5081		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5082
5083	case strings.EqualFold("ServiceException", errorCode):
5084		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5085
5086	case strings.EqualFold("TooManyRequestsException", errorCode):
5087		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
5088
5089	case strings.EqualFold("UnsupportedAPIEndpointException", errorCode):
5090		return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody)
5091
5092	default:
5093		genericError := &smithy.GenericAPIError{
5094			Code:    errorCode,
5095			Message: errorMessage,
5096		}
5097		return genericError
5098
5099	}
5100}
5101
5102type awsAwsjson11_deserializeOpListPoliciesForTarget struct {
5103}
5104
5105func (*awsAwsjson11_deserializeOpListPoliciesForTarget) ID() string {
5106	return "OperationDeserializer"
5107}
5108
5109func (m *awsAwsjson11_deserializeOpListPoliciesForTarget) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5110	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5111) {
5112	out, metadata, err = next.HandleDeserialize(ctx, in)
5113	if err != nil {
5114		return out, metadata, err
5115	}
5116
5117	response, ok := out.RawResponse.(*smithyhttp.Response)
5118	if !ok {
5119		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5120	}
5121
5122	if response.StatusCode < 200 || response.StatusCode >= 300 {
5123		return out, metadata, awsAwsjson11_deserializeOpErrorListPoliciesForTarget(response, &metadata)
5124	}
5125	output := &ListPoliciesForTargetOutput{}
5126	out.Result = output
5127
5128	var buff [1024]byte
5129	ringBuffer := smithyio.NewRingBuffer(buff[:])
5130
5131	body := io.TeeReader(response.Body, ringBuffer)
5132	decoder := json.NewDecoder(body)
5133	decoder.UseNumber()
5134	var shape interface{}
5135	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5136		var snapshot bytes.Buffer
5137		io.Copy(&snapshot, ringBuffer)
5138		err = &smithy.DeserializationError{
5139			Err:      fmt.Errorf("failed to decode response body, %w", err),
5140			Snapshot: snapshot.Bytes(),
5141		}
5142		return out, metadata, err
5143	}
5144
5145	err = awsAwsjson11_deserializeOpDocumentListPoliciesForTargetOutput(&output, shape)
5146	if err != nil {
5147		var snapshot bytes.Buffer
5148		io.Copy(&snapshot, ringBuffer)
5149		err = &smithy.DeserializationError{
5150			Err:      fmt.Errorf("failed to decode response body, %w", err),
5151			Snapshot: snapshot.Bytes(),
5152		}
5153		return out, metadata, err
5154	}
5155
5156	return out, metadata, err
5157}
5158
5159func awsAwsjson11_deserializeOpErrorListPoliciesForTarget(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5160	var errorBuffer bytes.Buffer
5161	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5162		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5163	}
5164	errorBody := bytes.NewReader(errorBuffer.Bytes())
5165
5166	errorCode := "UnknownError"
5167	errorMessage := errorCode
5168
5169	code := response.Header.Get("X-Amzn-ErrorType")
5170	if len(code) != 0 {
5171		errorCode = restjson.SanitizeErrorCode(code)
5172	}
5173
5174	var buff [1024]byte
5175	ringBuffer := smithyio.NewRingBuffer(buff[:])
5176
5177	body := io.TeeReader(errorBody, ringBuffer)
5178	decoder := json.NewDecoder(body)
5179	decoder.UseNumber()
5180	code, message, err := restjson.GetErrorInfo(decoder)
5181	if err != nil {
5182		var snapshot bytes.Buffer
5183		io.Copy(&snapshot, ringBuffer)
5184		err = &smithy.DeserializationError{
5185			Err:      fmt.Errorf("failed to decode response body, %w", err),
5186			Snapshot: snapshot.Bytes(),
5187		}
5188		return err
5189	}
5190
5191	errorBody.Seek(0, io.SeekStart)
5192	if len(code) != 0 {
5193		errorCode = restjson.SanitizeErrorCode(code)
5194	}
5195	if len(message) != 0 {
5196		errorMessage = message
5197	}
5198
5199	switch {
5200	case strings.EqualFold("AccessDeniedException", errorCode):
5201		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5202
5203	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
5204		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
5205
5206	case strings.EqualFold("InvalidInputException", errorCode):
5207		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5208
5209	case strings.EqualFold("ServiceException", errorCode):
5210		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5211
5212	case strings.EqualFold("TargetNotFoundException", errorCode):
5213		return awsAwsjson11_deserializeErrorTargetNotFoundException(response, errorBody)
5214
5215	case strings.EqualFold("TooManyRequestsException", errorCode):
5216		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
5217
5218	case strings.EqualFold("UnsupportedAPIEndpointException", errorCode):
5219		return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody)
5220
5221	default:
5222		genericError := &smithy.GenericAPIError{
5223			Code:    errorCode,
5224			Message: errorMessage,
5225		}
5226		return genericError
5227
5228	}
5229}
5230
5231type awsAwsjson11_deserializeOpListRoots struct {
5232}
5233
5234func (*awsAwsjson11_deserializeOpListRoots) ID() string {
5235	return "OperationDeserializer"
5236}
5237
5238func (m *awsAwsjson11_deserializeOpListRoots) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5239	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5240) {
5241	out, metadata, err = next.HandleDeserialize(ctx, in)
5242	if err != nil {
5243		return out, metadata, err
5244	}
5245
5246	response, ok := out.RawResponse.(*smithyhttp.Response)
5247	if !ok {
5248		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5249	}
5250
5251	if response.StatusCode < 200 || response.StatusCode >= 300 {
5252		return out, metadata, awsAwsjson11_deserializeOpErrorListRoots(response, &metadata)
5253	}
5254	output := &ListRootsOutput{}
5255	out.Result = output
5256
5257	var buff [1024]byte
5258	ringBuffer := smithyio.NewRingBuffer(buff[:])
5259
5260	body := io.TeeReader(response.Body, ringBuffer)
5261	decoder := json.NewDecoder(body)
5262	decoder.UseNumber()
5263	var shape interface{}
5264	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5265		var snapshot bytes.Buffer
5266		io.Copy(&snapshot, ringBuffer)
5267		err = &smithy.DeserializationError{
5268			Err:      fmt.Errorf("failed to decode response body, %w", err),
5269			Snapshot: snapshot.Bytes(),
5270		}
5271		return out, metadata, err
5272	}
5273
5274	err = awsAwsjson11_deserializeOpDocumentListRootsOutput(&output, shape)
5275	if err != nil {
5276		var snapshot bytes.Buffer
5277		io.Copy(&snapshot, ringBuffer)
5278		err = &smithy.DeserializationError{
5279			Err:      fmt.Errorf("failed to decode response body, %w", err),
5280			Snapshot: snapshot.Bytes(),
5281		}
5282		return out, metadata, err
5283	}
5284
5285	return out, metadata, err
5286}
5287
5288func awsAwsjson11_deserializeOpErrorListRoots(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5289	var errorBuffer bytes.Buffer
5290	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5291		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5292	}
5293	errorBody := bytes.NewReader(errorBuffer.Bytes())
5294
5295	errorCode := "UnknownError"
5296	errorMessage := errorCode
5297
5298	code := response.Header.Get("X-Amzn-ErrorType")
5299	if len(code) != 0 {
5300		errorCode = restjson.SanitizeErrorCode(code)
5301	}
5302
5303	var buff [1024]byte
5304	ringBuffer := smithyio.NewRingBuffer(buff[:])
5305
5306	body := io.TeeReader(errorBody, ringBuffer)
5307	decoder := json.NewDecoder(body)
5308	decoder.UseNumber()
5309	code, message, err := restjson.GetErrorInfo(decoder)
5310	if err != nil {
5311		var snapshot bytes.Buffer
5312		io.Copy(&snapshot, ringBuffer)
5313		err = &smithy.DeserializationError{
5314			Err:      fmt.Errorf("failed to decode response body, %w", err),
5315			Snapshot: snapshot.Bytes(),
5316		}
5317		return err
5318	}
5319
5320	errorBody.Seek(0, io.SeekStart)
5321	if len(code) != 0 {
5322		errorCode = restjson.SanitizeErrorCode(code)
5323	}
5324	if len(message) != 0 {
5325		errorMessage = message
5326	}
5327
5328	switch {
5329	case strings.EqualFold("AccessDeniedException", errorCode):
5330		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5331
5332	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
5333		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
5334
5335	case strings.EqualFold("InvalidInputException", errorCode):
5336		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5337
5338	case strings.EqualFold("ServiceException", errorCode):
5339		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5340
5341	case strings.EqualFold("TooManyRequestsException", errorCode):
5342		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
5343
5344	default:
5345		genericError := &smithy.GenericAPIError{
5346			Code:    errorCode,
5347			Message: errorMessage,
5348		}
5349		return genericError
5350
5351	}
5352}
5353
5354type awsAwsjson11_deserializeOpListTagsForResource struct {
5355}
5356
5357func (*awsAwsjson11_deserializeOpListTagsForResource) ID() string {
5358	return "OperationDeserializer"
5359}
5360
5361func (m *awsAwsjson11_deserializeOpListTagsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5362	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5363) {
5364	out, metadata, err = next.HandleDeserialize(ctx, in)
5365	if err != nil {
5366		return out, metadata, err
5367	}
5368
5369	response, ok := out.RawResponse.(*smithyhttp.Response)
5370	if !ok {
5371		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5372	}
5373
5374	if response.StatusCode < 200 || response.StatusCode >= 300 {
5375		return out, metadata, awsAwsjson11_deserializeOpErrorListTagsForResource(response, &metadata)
5376	}
5377	output := &ListTagsForResourceOutput{}
5378	out.Result = output
5379
5380	var buff [1024]byte
5381	ringBuffer := smithyio.NewRingBuffer(buff[:])
5382
5383	body := io.TeeReader(response.Body, ringBuffer)
5384	decoder := json.NewDecoder(body)
5385	decoder.UseNumber()
5386	var shape interface{}
5387	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5388		var snapshot bytes.Buffer
5389		io.Copy(&snapshot, ringBuffer)
5390		err = &smithy.DeserializationError{
5391			Err:      fmt.Errorf("failed to decode response body, %w", err),
5392			Snapshot: snapshot.Bytes(),
5393		}
5394		return out, metadata, err
5395	}
5396
5397	err = awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(&output, shape)
5398	if err != nil {
5399		var snapshot bytes.Buffer
5400		io.Copy(&snapshot, ringBuffer)
5401		err = &smithy.DeserializationError{
5402			Err:      fmt.Errorf("failed to decode response body, %w", err),
5403			Snapshot: snapshot.Bytes(),
5404		}
5405		return out, metadata, err
5406	}
5407
5408	return out, metadata, err
5409}
5410
5411func awsAwsjson11_deserializeOpErrorListTagsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5412	var errorBuffer bytes.Buffer
5413	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5414		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5415	}
5416	errorBody := bytes.NewReader(errorBuffer.Bytes())
5417
5418	errorCode := "UnknownError"
5419	errorMessage := errorCode
5420
5421	code := response.Header.Get("X-Amzn-ErrorType")
5422	if len(code) != 0 {
5423		errorCode = restjson.SanitizeErrorCode(code)
5424	}
5425
5426	var buff [1024]byte
5427	ringBuffer := smithyio.NewRingBuffer(buff[:])
5428
5429	body := io.TeeReader(errorBody, ringBuffer)
5430	decoder := json.NewDecoder(body)
5431	decoder.UseNumber()
5432	code, message, err := restjson.GetErrorInfo(decoder)
5433	if err != nil {
5434		var snapshot bytes.Buffer
5435		io.Copy(&snapshot, ringBuffer)
5436		err = &smithy.DeserializationError{
5437			Err:      fmt.Errorf("failed to decode response body, %w", err),
5438			Snapshot: snapshot.Bytes(),
5439		}
5440		return err
5441	}
5442
5443	errorBody.Seek(0, io.SeekStart)
5444	if len(code) != 0 {
5445		errorCode = restjson.SanitizeErrorCode(code)
5446	}
5447	if len(message) != 0 {
5448		errorMessage = message
5449	}
5450
5451	switch {
5452	case strings.EqualFold("AccessDeniedException", errorCode):
5453		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5454
5455	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
5456		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
5457
5458	case strings.EqualFold("InvalidInputException", errorCode):
5459		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5460
5461	case strings.EqualFold("ServiceException", errorCode):
5462		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5463
5464	case strings.EqualFold("TargetNotFoundException", errorCode):
5465		return awsAwsjson11_deserializeErrorTargetNotFoundException(response, errorBody)
5466
5467	case strings.EqualFold("TooManyRequestsException", errorCode):
5468		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
5469
5470	default:
5471		genericError := &smithy.GenericAPIError{
5472			Code:    errorCode,
5473			Message: errorMessage,
5474		}
5475		return genericError
5476
5477	}
5478}
5479
5480type awsAwsjson11_deserializeOpListTargetsForPolicy struct {
5481}
5482
5483func (*awsAwsjson11_deserializeOpListTargetsForPolicy) ID() string {
5484	return "OperationDeserializer"
5485}
5486
5487func (m *awsAwsjson11_deserializeOpListTargetsForPolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5488	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5489) {
5490	out, metadata, err = next.HandleDeserialize(ctx, in)
5491	if err != nil {
5492		return out, metadata, err
5493	}
5494
5495	response, ok := out.RawResponse.(*smithyhttp.Response)
5496	if !ok {
5497		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5498	}
5499
5500	if response.StatusCode < 200 || response.StatusCode >= 300 {
5501		return out, metadata, awsAwsjson11_deserializeOpErrorListTargetsForPolicy(response, &metadata)
5502	}
5503	output := &ListTargetsForPolicyOutput{}
5504	out.Result = output
5505
5506	var buff [1024]byte
5507	ringBuffer := smithyio.NewRingBuffer(buff[:])
5508
5509	body := io.TeeReader(response.Body, ringBuffer)
5510	decoder := json.NewDecoder(body)
5511	decoder.UseNumber()
5512	var shape interface{}
5513	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5514		var snapshot bytes.Buffer
5515		io.Copy(&snapshot, ringBuffer)
5516		err = &smithy.DeserializationError{
5517			Err:      fmt.Errorf("failed to decode response body, %w", err),
5518			Snapshot: snapshot.Bytes(),
5519		}
5520		return out, metadata, err
5521	}
5522
5523	err = awsAwsjson11_deserializeOpDocumentListTargetsForPolicyOutput(&output, shape)
5524	if err != nil {
5525		var snapshot bytes.Buffer
5526		io.Copy(&snapshot, ringBuffer)
5527		err = &smithy.DeserializationError{
5528			Err:      fmt.Errorf("failed to decode response body, %w", err),
5529			Snapshot: snapshot.Bytes(),
5530		}
5531		return out, metadata, err
5532	}
5533
5534	return out, metadata, err
5535}
5536
5537func awsAwsjson11_deserializeOpErrorListTargetsForPolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5538	var errorBuffer bytes.Buffer
5539	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5540		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5541	}
5542	errorBody := bytes.NewReader(errorBuffer.Bytes())
5543
5544	errorCode := "UnknownError"
5545	errorMessage := errorCode
5546
5547	code := response.Header.Get("X-Amzn-ErrorType")
5548	if len(code) != 0 {
5549		errorCode = restjson.SanitizeErrorCode(code)
5550	}
5551
5552	var buff [1024]byte
5553	ringBuffer := smithyio.NewRingBuffer(buff[:])
5554
5555	body := io.TeeReader(errorBody, ringBuffer)
5556	decoder := json.NewDecoder(body)
5557	decoder.UseNumber()
5558	code, message, err := restjson.GetErrorInfo(decoder)
5559	if err != nil {
5560		var snapshot bytes.Buffer
5561		io.Copy(&snapshot, ringBuffer)
5562		err = &smithy.DeserializationError{
5563			Err:      fmt.Errorf("failed to decode response body, %w", err),
5564			Snapshot: snapshot.Bytes(),
5565		}
5566		return err
5567	}
5568
5569	errorBody.Seek(0, io.SeekStart)
5570	if len(code) != 0 {
5571		errorCode = restjson.SanitizeErrorCode(code)
5572	}
5573	if len(message) != 0 {
5574		errorMessage = message
5575	}
5576
5577	switch {
5578	case strings.EqualFold("AccessDeniedException", errorCode):
5579		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5580
5581	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
5582		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
5583
5584	case strings.EqualFold("InvalidInputException", errorCode):
5585		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5586
5587	case strings.EqualFold("PolicyNotFoundException", errorCode):
5588		return awsAwsjson11_deserializeErrorPolicyNotFoundException(response, errorBody)
5589
5590	case strings.EqualFold("ServiceException", errorCode):
5591		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5592
5593	case strings.EqualFold("TooManyRequestsException", errorCode):
5594		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
5595
5596	case strings.EqualFold("UnsupportedAPIEndpointException", errorCode):
5597		return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody)
5598
5599	default:
5600		genericError := &smithy.GenericAPIError{
5601			Code:    errorCode,
5602			Message: errorMessage,
5603		}
5604		return genericError
5605
5606	}
5607}
5608
5609type awsAwsjson11_deserializeOpMoveAccount struct {
5610}
5611
5612func (*awsAwsjson11_deserializeOpMoveAccount) ID() string {
5613	return "OperationDeserializer"
5614}
5615
5616func (m *awsAwsjson11_deserializeOpMoveAccount) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5617	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5618) {
5619	out, metadata, err = next.HandleDeserialize(ctx, in)
5620	if err != nil {
5621		return out, metadata, err
5622	}
5623
5624	response, ok := out.RawResponse.(*smithyhttp.Response)
5625	if !ok {
5626		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5627	}
5628
5629	if response.StatusCode < 200 || response.StatusCode >= 300 {
5630		return out, metadata, awsAwsjson11_deserializeOpErrorMoveAccount(response, &metadata)
5631	}
5632	output := &MoveAccountOutput{}
5633	out.Result = output
5634
5635	if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
5636		return out, metadata, &smithy.DeserializationError{
5637			Err: fmt.Errorf("failed to discard response body, %w", err),
5638		}
5639	}
5640
5641	return out, metadata, err
5642}
5643
5644func awsAwsjson11_deserializeOpErrorMoveAccount(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5645	var errorBuffer bytes.Buffer
5646	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5647		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5648	}
5649	errorBody := bytes.NewReader(errorBuffer.Bytes())
5650
5651	errorCode := "UnknownError"
5652	errorMessage := errorCode
5653
5654	code := response.Header.Get("X-Amzn-ErrorType")
5655	if len(code) != 0 {
5656		errorCode = restjson.SanitizeErrorCode(code)
5657	}
5658
5659	var buff [1024]byte
5660	ringBuffer := smithyio.NewRingBuffer(buff[:])
5661
5662	body := io.TeeReader(errorBody, ringBuffer)
5663	decoder := json.NewDecoder(body)
5664	decoder.UseNumber()
5665	code, message, err := restjson.GetErrorInfo(decoder)
5666	if err != nil {
5667		var snapshot bytes.Buffer
5668		io.Copy(&snapshot, ringBuffer)
5669		err = &smithy.DeserializationError{
5670			Err:      fmt.Errorf("failed to decode response body, %w", err),
5671			Snapshot: snapshot.Bytes(),
5672		}
5673		return err
5674	}
5675
5676	errorBody.Seek(0, io.SeekStart)
5677	if len(code) != 0 {
5678		errorCode = restjson.SanitizeErrorCode(code)
5679	}
5680	if len(message) != 0 {
5681		errorMessage = message
5682	}
5683
5684	switch {
5685	case strings.EqualFold("AccessDeniedException", errorCode):
5686		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5687
5688	case strings.EqualFold("AccountNotFoundException", errorCode):
5689		return awsAwsjson11_deserializeErrorAccountNotFoundException(response, errorBody)
5690
5691	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
5692		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
5693
5694	case strings.EqualFold("ConcurrentModificationException", errorCode):
5695		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
5696
5697	case strings.EqualFold("DestinationParentNotFoundException", errorCode):
5698		return awsAwsjson11_deserializeErrorDestinationParentNotFoundException(response, errorBody)
5699
5700	case strings.EqualFold("DuplicateAccountException", errorCode):
5701		return awsAwsjson11_deserializeErrorDuplicateAccountException(response, errorBody)
5702
5703	case strings.EqualFold("InvalidInputException", errorCode):
5704		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5705
5706	case strings.EqualFold("ServiceException", errorCode):
5707		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5708
5709	case strings.EqualFold("SourceParentNotFoundException", errorCode):
5710		return awsAwsjson11_deserializeErrorSourceParentNotFoundException(response, errorBody)
5711
5712	case strings.EqualFold("TooManyRequestsException", errorCode):
5713		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
5714
5715	default:
5716		genericError := &smithy.GenericAPIError{
5717			Code:    errorCode,
5718			Message: errorMessage,
5719		}
5720		return genericError
5721
5722	}
5723}
5724
5725type awsAwsjson11_deserializeOpRegisterDelegatedAdministrator struct {
5726}
5727
5728func (*awsAwsjson11_deserializeOpRegisterDelegatedAdministrator) ID() string {
5729	return "OperationDeserializer"
5730}
5731
5732func (m *awsAwsjson11_deserializeOpRegisterDelegatedAdministrator) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5733	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5734) {
5735	out, metadata, err = next.HandleDeserialize(ctx, in)
5736	if err != nil {
5737		return out, metadata, err
5738	}
5739
5740	response, ok := out.RawResponse.(*smithyhttp.Response)
5741	if !ok {
5742		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5743	}
5744
5745	if response.StatusCode < 200 || response.StatusCode >= 300 {
5746		return out, metadata, awsAwsjson11_deserializeOpErrorRegisterDelegatedAdministrator(response, &metadata)
5747	}
5748	output := &RegisterDelegatedAdministratorOutput{}
5749	out.Result = output
5750
5751	if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
5752		return out, metadata, &smithy.DeserializationError{
5753			Err: fmt.Errorf("failed to discard response body, %w", err),
5754		}
5755	}
5756
5757	return out, metadata, err
5758}
5759
5760func awsAwsjson11_deserializeOpErrorRegisterDelegatedAdministrator(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5761	var errorBuffer bytes.Buffer
5762	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5763		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5764	}
5765	errorBody := bytes.NewReader(errorBuffer.Bytes())
5766
5767	errorCode := "UnknownError"
5768	errorMessage := errorCode
5769
5770	code := response.Header.Get("X-Amzn-ErrorType")
5771	if len(code) != 0 {
5772		errorCode = restjson.SanitizeErrorCode(code)
5773	}
5774
5775	var buff [1024]byte
5776	ringBuffer := smithyio.NewRingBuffer(buff[:])
5777
5778	body := io.TeeReader(errorBody, ringBuffer)
5779	decoder := json.NewDecoder(body)
5780	decoder.UseNumber()
5781	code, message, err := restjson.GetErrorInfo(decoder)
5782	if err != nil {
5783		var snapshot bytes.Buffer
5784		io.Copy(&snapshot, ringBuffer)
5785		err = &smithy.DeserializationError{
5786			Err:      fmt.Errorf("failed to decode response body, %w", err),
5787			Snapshot: snapshot.Bytes(),
5788		}
5789		return err
5790	}
5791
5792	errorBody.Seek(0, io.SeekStart)
5793	if len(code) != 0 {
5794		errorCode = restjson.SanitizeErrorCode(code)
5795	}
5796	if len(message) != 0 {
5797		errorMessage = message
5798	}
5799
5800	switch {
5801	case strings.EqualFold("AccessDeniedException", errorCode):
5802		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5803
5804	case strings.EqualFold("AccountAlreadyRegisteredException", errorCode):
5805		return awsAwsjson11_deserializeErrorAccountAlreadyRegisteredException(response, errorBody)
5806
5807	case strings.EqualFold("AccountNotFoundException", errorCode):
5808		return awsAwsjson11_deserializeErrorAccountNotFoundException(response, errorBody)
5809
5810	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
5811		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
5812
5813	case strings.EqualFold("ConcurrentModificationException", errorCode):
5814		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
5815
5816	case strings.EqualFold("ConstraintViolationException", errorCode):
5817		return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody)
5818
5819	case strings.EqualFold("InvalidInputException", errorCode):
5820		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5821
5822	case strings.EqualFold("ServiceException", errorCode):
5823		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5824
5825	case strings.EqualFold("TooManyRequestsException", errorCode):
5826		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
5827
5828	case strings.EqualFold("UnsupportedAPIEndpointException", errorCode):
5829		return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody)
5830
5831	default:
5832		genericError := &smithy.GenericAPIError{
5833			Code:    errorCode,
5834			Message: errorMessage,
5835		}
5836		return genericError
5837
5838	}
5839}
5840
5841type awsAwsjson11_deserializeOpRemoveAccountFromOrganization struct {
5842}
5843
5844func (*awsAwsjson11_deserializeOpRemoveAccountFromOrganization) ID() string {
5845	return "OperationDeserializer"
5846}
5847
5848func (m *awsAwsjson11_deserializeOpRemoveAccountFromOrganization) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5849	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5850) {
5851	out, metadata, err = next.HandleDeserialize(ctx, in)
5852	if err != nil {
5853		return out, metadata, err
5854	}
5855
5856	response, ok := out.RawResponse.(*smithyhttp.Response)
5857	if !ok {
5858		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5859	}
5860
5861	if response.StatusCode < 200 || response.StatusCode >= 300 {
5862		return out, metadata, awsAwsjson11_deserializeOpErrorRemoveAccountFromOrganization(response, &metadata)
5863	}
5864	output := &RemoveAccountFromOrganizationOutput{}
5865	out.Result = output
5866
5867	if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
5868		return out, metadata, &smithy.DeserializationError{
5869			Err: fmt.Errorf("failed to discard response body, %w", err),
5870		}
5871	}
5872
5873	return out, metadata, err
5874}
5875
5876func awsAwsjson11_deserializeOpErrorRemoveAccountFromOrganization(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5877	var errorBuffer bytes.Buffer
5878	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5879		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5880	}
5881	errorBody := bytes.NewReader(errorBuffer.Bytes())
5882
5883	errorCode := "UnknownError"
5884	errorMessage := errorCode
5885
5886	code := response.Header.Get("X-Amzn-ErrorType")
5887	if len(code) != 0 {
5888		errorCode = restjson.SanitizeErrorCode(code)
5889	}
5890
5891	var buff [1024]byte
5892	ringBuffer := smithyio.NewRingBuffer(buff[:])
5893
5894	body := io.TeeReader(errorBody, ringBuffer)
5895	decoder := json.NewDecoder(body)
5896	decoder.UseNumber()
5897	code, message, err := restjson.GetErrorInfo(decoder)
5898	if err != nil {
5899		var snapshot bytes.Buffer
5900		io.Copy(&snapshot, ringBuffer)
5901		err = &smithy.DeserializationError{
5902			Err:      fmt.Errorf("failed to decode response body, %w", err),
5903			Snapshot: snapshot.Bytes(),
5904		}
5905		return err
5906	}
5907
5908	errorBody.Seek(0, io.SeekStart)
5909	if len(code) != 0 {
5910		errorCode = restjson.SanitizeErrorCode(code)
5911	}
5912	if len(message) != 0 {
5913		errorMessage = message
5914	}
5915
5916	switch {
5917	case strings.EqualFold("AccessDeniedException", errorCode):
5918		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
5919
5920	case strings.EqualFold("AccountNotFoundException", errorCode):
5921		return awsAwsjson11_deserializeErrorAccountNotFoundException(response, errorBody)
5922
5923	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
5924		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
5925
5926	case strings.EqualFold("ConcurrentModificationException", errorCode):
5927		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
5928
5929	case strings.EqualFold("ConstraintViolationException", errorCode):
5930		return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody)
5931
5932	case strings.EqualFold("InvalidInputException", errorCode):
5933		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
5934
5935	case strings.EqualFold("MasterCannotLeaveOrganizationException", errorCode):
5936		return awsAwsjson11_deserializeErrorMasterCannotLeaveOrganizationException(response, errorBody)
5937
5938	case strings.EqualFold("ServiceException", errorCode):
5939		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
5940
5941	case strings.EqualFold("TooManyRequestsException", errorCode):
5942		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
5943
5944	default:
5945		genericError := &smithy.GenericAPIError{
5946			Code:    errorCode,
5947			Message: errorMessage,
5948		}
5949		return genericError
5950
5951	}
5952}
5953
5954type awsAwsjson11_deserializeOpTagResource struct {
5955}
5956
5957func (*awsAwsjson11_deserializeOpTagResource) ID() string {
5958	return "OperationDeserializer"
5959}
5960
5961func (m *awsAwsjson11_deserializeOpTagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5962	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5963) {
5964	out, metadata, err = next.HandleDeserialize(ctx, in)
5965	if err != nil {
5966		return out, metadata, err
5967	}
5968
5969	response, ok := out.RawResponse.(*smithyhttp.Response)
5970	if !ok {
5971		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5972	}
5973
5974	if response.StatusCode < 200 || response.StatusCode >= 300 {
5975		return out, metadata, awsAwsjson11_deserializeOpErrorTagResource(response, &metadata)
5976	}
5977	output := &TagResourceOutput{}
5978	out.Result = output
5979
5980	if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
5981		return out, metadata, &smithy.DeserializationError{
5982			Err: fmt.Errorf("failed to discard response body, %w", err),
5983		}
5984	}
5985
5986	return out, metadata, err
5987}
5988
5989func awsAwsjson11_deserializeOpErrorTagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5990	var errorBuffer bytes.Buffer
5991	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5992		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5993	}
5994	errorBody := bytes.NewReader(errorBuffer.Bytes())
5995
5996	errorCode := "UnknownError"
5997	errorMessage := errorCode
5998
5999	code := response.Header.Get("X-Amzn-ErrorType")
6000	if len(code) != 0 {
6001		errorCode = restjson.SanitizeErrorCode(code)
6002	}
6003
6004	var buff [1024]byte
6005	ringBuffer := smithyio.NewRingBuffer(buff[:])
6006
6007	body := io.TeeReader(errorBody, ringBuffer)
6008	decoder := json.NewDecoder(body)
6009	decoder.UseNumber()
6010	code, message, err := restjson.GetErrorInfo(decoder)
6011	if err != nil {
6012		var snapshot bytes.Buffer
6013		io.Copy(&snapshot, ringBuffer)
6014		err = &smithy.DeserializationError{
6015			Err:      fmt.Errorf("failed to decode response body, %w", err),
6016			Snapshot: snapshot.Bytes(),
6017		}
6018		return err
6019	}
6020
6021	errorBody.Seek(0, io.SeekStart)
6022	if len(code) != 0 {
6023		errorCode = restjson.SanitizeErrorCode(code)
6024	}
6025	if len(message) != 0 {
6026		errorMessage = message
6027	}
6028
6029	switch {
6030	case strings.EqualFold("AccessDeniedException", errorCode):
6031		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6032
6033	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
6034		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
6035
6036	case strings.EqualFold("ConcurrentModificationException", errorCode):
6037		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
6038
6039	case strings.EqualFold("ConstraintViolationException", errorCode):
6040		return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody)
6041
6042	case strings.EqualFold("InvalidInputException", errorCode):
6043		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
6044
6045	case strings.EqualFold("ServiceException", errorCode):
6046		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
6047
6048	case strings.EqualFold("TargetNotFoundException", errorCode):
6049		return awsAwsjson11_deserializeErrorTargetNotFoundException(response, errorBody)
6050
6051	case strings.EqualFold("TooManyRequestsException", errorCode):
6052		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
6053
6054	default:
6055		genericError := &smithy.GenericAPIError{
6056			Code:    errorCode,
6057			Message: errorMessage,
6058		}
6059		return genericError
6060
6061	}
6062}
6063
6064type awsAwsjson11_deserializeOpUntagResource struct {
6065}
6066
6067func (*awsAwsjson11_deserializeOpUntagResource) ID() string {
6068	return "OperationDeserializer"
6069}
6070
6071func (m *awsAwsjson11_deserializeOpUntagResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6072	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6073) {
6074	out, metadata, err = next.HandleDeserialize(ctx, in)
6075	if err != nil {
6076		return out, metadata, err
6077	}
6078
6079	response, ok := out.RawResponse.(*smithyhttp.Response)
6080	if !ok {
6081		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6082	}
6083
6084	if response.StatusCode < 200 || response.StatusCode >= 300 {
6085		return out, metadata, awsAwsjson11_deserializeOpErrorUntagResource(response, &metadata)
6086	}
6087	output := &UntagResourceOutput{}
6088	out.Result = output
6089
6090	if _, err = io.Copy(ioutil.Discard, response.Body); err != nil {
6091		return out, metadata, &smithy.DeserializationError{
6092			Err: fmt.Errorf("failed to discard response body, %w", err),
6093		}
6094	}
6095
6096	return out, metadata, err
6097}
6098
6099func awsAwsjson11_deserializeOpErrorUntagResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6100	var errorBuffer bytes.Buffer
6101	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6102		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6103	}
6104	errorBody := bytes.NewReader(errorBuffer.Bytes())
6105
6106	errorCode := "UnknownError"
6107	errorMessage := errorCode
6108
6109	code := response.Header.Get("X-Amzn-ErrorType")
6110	if len(code) != 0 {
6111		errorCode = restjson.SanitizeErrorCode(code)
6112	}
6113
6114	var buff [1024]byte
6115	ringBuffer := smithyio.NewRingBuffer(buff[:])
6116
6117	body := io.TeeReader(errorBody, ringBuffer)
6118	decoder := json.NewDecoder(body)
6119	decoder.UseNumber()
6120	code, message, err := restjson.GetErrorInfo(decoder)
6121	if err != nil {
6122		var snapshot bytes.Buffer
6123		io.Copy(&snapshot, ringBuffer)
6124		err = &smithy.DeserializationError{
6125			Err:      fmt.Errorf("failed to decode response body, %w", err),
6126			Snapshot: snapshot.Bytes(),
6127		}
6128		return err
6129	}
6130
6131	errorBody.Seek(0, io.SeekStart)
6132	if len(code) != 0 {
6133		errorCode = restjson.SanitizeErrorCode(code)
6134	}
6135	if len(message) != 0 {
6136		errorMessage = message
6137	}
6138
6139	switch {
6140	case strings.EqualFold("AccessDeniedException", errorCode):
6141		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6142
6143	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
6144		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
6145
6146	case strings.EqualFold("ConcurrentModificationException", errorCode):
6147		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
6148
6149	case strings.EqualFold("ConstraintViolationException", errorCode):
6150		return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody)
6151
6152	case strings.EqualFold("InvalidInputException", errorCode):
6153		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
6154
6155	case strings.EqualFold("ServiceException", errorCode):
6156		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
6157
6158	case strings.EqualFold("TargetNotFoundException", errorCode):
6159		return awsAwsjson11_deserializeErrorTargetNotFoundException(response, errorBody)
6160
6161	case strings.EqualFold("TooManyRequestsException", errorCode):
6162		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
6163
6164	default:
6165		genericError := &smithy.GenericAPIError{
6166			Code:    errorCode,
6167			Message: errorMessage,
6168		}
6169		return genericError
6170
6171	}
6172}
6173
6174type awsAwsjson11_deserializeOpUpdateOrganizationalUnit struct {
6175}
6176
6177func (*awsAwsjson11_deserializeOpUpdateOrganizationalUnit) ID() string {
6178	return "OperationDeserializer"
6179}
6180
6181func (m *awsAwsjson11_deserializeOpUpdateOrganizationalUnit) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6182	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6183) {
6184	out, metadata, err = next.HandleDeserialize(ctx, in)
6185	if err != nil {
6186		return out, metadata, err
6187	}
6188
6189	response, ok := out.RawResponse.(*smithyhttp.Response)
6190	if !ok {
6191		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6192	}
6193
6194	if response.StatusCode < 200 || response.StatusCode >= 300 {
6195		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateOrganizationalUnit(response, &metadata)
6196	}
6197	output := &UpdateOrganizationalUnitOutput{}
6198	out.Result = output
6199
6200	var buff [1024]byte
6201	ringBuffer := smithyio.NewRingBuffer(buff[:])
6202
6203	body := io.TeeReader(response.Body, ringBuffer)
6204	decoder := json.NewDecoder(body)
6205	decoder.UseNumber()
6206	var shape interface{}
6207	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6208		var snapshot bytes.Buffer
6209		io.Copy(&snapshot, ringBuffer)
6210		err = &smithy.DeserializationError{
6211			Err:      fmt.Errorf("failed to decode response body, %w", err),
6212			Snapshot: snapshot.Bytes(),
6213		}
6214		return out, metadata, err
6215	}
6216
6217	err = awsAwsjson11_deserializeOpDocumentUpdateOrganizationalUnitOutput(&output, shape)
6218	if err != nil {
6219		var snapshot bytes.Buffer
6220		io.Copy(&snapshot, ringBuffer)
6221		err = &smithy.DeserializationError{
6222			Err:      fmt.Errorf("failed to decode response body, %w", err),
6223			Snapshot: snapshot.Bytes(),
6224		}
6225		return out, metadata, err
6226	}
6227
6228	return out, metadata, err
6229}
6230
6231func awsAwsjson11_deserializeOpErrorUpdateOrganizationalUnit(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6232	var errorBuffer bytes.Buffer
6233	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6234		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6235	}
6236	errorBody := bytes.NewReader(errorBuffer.Bytes())
6237
6238	errorCode := "UnknownError"
6239	errorMessage := errorCode
6240
6241	code := response.Header.Get("X-Amzn-ErrorType")
6242	if len(code) != 0 {
6243		errorCode = restjson.SanitizeErrorCode(code)
6244	}
6245
6246	var buff [1024]byte
6247	ringBuffer := smithyio.NewRingBuffer(buff[:])
6248
6249	body := io.TeeReader(errorBody, ringBuffer)
6250	decoder := json.NewDecoder(body)
6251	decoder.UseNumber()
6252	code, message, err := restjson.GetErrorInfo(decoder)
6253	if err != nil {
6254		var snapshot bytes.Buffer
6255		io.Copy(&snapshot, ringBuffer)
6256		err = &smithy.DeserializationError{
6257			Err:      fmt.Errorf("failed to decode response body, %w", err),
6258			Snapshot: snapshot.Bytes(),
6259		}
6260		return err
6261	}
6262
6263	errorBody.Seek(0, io.SeekStart)
6264	if len(code) != 0 {
6265		errorCode = restjson.SanitizeErrorCode(code)
6266	}
6267	if len(message) != 0 {
6268		errorMessage = message
6269	}
6270
6271	switch {
6272	case strings.EqualFold("AccessDeniedException", errorCode):
6273		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6274
6275	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
6276		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
6277
6278	case strings.EqualFold("ConcurrentModificationException", errorCode):
6279		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
6280
6281	case strings.EqualFold("DuplicateOrganizationalUnitException", errorCode):
6282		return awsAwsjson11_deserializeErrorDuplicateOrganizationalUnitException(response, errorBody)
6283
6284	case strings.EqualFold("InvalidInputException", errorCode):
6285		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
6286
6287	case strings.EqualFold("OrganizationalUnitNotFoundException", errorCode):
6288		return awsAwsjson11_deserializeErrorOrganizationalUnitNotFoundException(response, errorBody)
6289
6290	case strings.EqualFold("ServiceException", errorCode):
6291		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
6292
6293	case strings.EqualFold("TooManyRequestsException", errorCode):
6294		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
6295
6296	default:
6297		genericError := &smithy.GenericAPIError{
6298			Code:    errorCode,
6299			Message: errorMessage,
6300		}
6301		return genericError
6302
6303	}
6304}
6305
6306type awsAwsjson11_deserializeOpUpdatePolicy struct {
6307}
6308
6309func (*awsAwsjson11_deserializeOpUpdatePolicy) ID() string {
6310	return "OperationDeserializer"
6311}
6312
6313func (m *awsAwsjson11_deserializeOpUpdatePolicy) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6314	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6315) {
6316	out, metadata, err = next.HandleDeserialize(ctx, in)
6317	if err != nil {
6318		return out, metadata, err
6319	}
6320
6321	response, ok := out.RawResponse.(*smithyhttp.Response)
6322	if !ok {
6323		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6324	}
6325
6326	if response.StatusCode < 200 || response.StatusCode >= 300 {
6327		return out, metadata, awsAwsjson11_deserializeOpErrorUpdatePolicy(response, &metadata)
6328	}
6329	output := &UpdatePolicyOutput{}
6330	out.Result = output
6331
6332	var buff [1024]byte
6333	ringBuffer := smithyio.NewRingBuffer(buff[:])
6334
6335	body := io.TeeReader(response.Body, ringBuffer)
6336	decoder := json.NewDecoder(body)
6337	decoder.UseNumber()
6338	var shape interface{}
6339	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6340		var snapshot bytes.Buffer
6341		io.Copy(&snapshot, ringBuffer)
6342		err = &smithy.DeserializationError{
6343			Err:      fmt.Errorf("failed to decode response body, %w", err),
6344			Snapshot: snapshot.Bytes(),
6345		}
6346		return out, metadata, err
6347	}
6348
6349	err = awsAwsjson11_deserializeOpDocumentUpdatePolicyOutput(&output, shape)
6350	if err != nil {
6351		var snapshot bytes.Buffer
6352		io.Copy(&snapshot, ringBuffer)
6353		err = &smithy.DeserializationError{
6354			Err:      fmt.Errorf("failed to decode response body, %w", err),
6355			Snapshot: snapshot.Bytes(),
6356		}
6357		return out, metadata, err
6358	}
6359
6360	return out, metadata, err
6361}
6362
6363func awsAwsjson11_deserializeOpErrorUpdatePolicy(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6364	var errorBuffer bytes.Buffer
6365	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6366		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6367	}
6368	errorBody := bytes.NewReader(errorBuffer.Bytes())
6369
6370	errorCode := "UnknownError"
6371	errorMessage := errorCode
6372
6373	code := response.Header.Get("X-Amzn-ErrorType")
6374	if len(code) != 0 {
6375		errorCode = restjson.SanitizeErrorCode(code)
6376	}
6377
6378	var buff [1024]byte
6379	ringBuffer := smithyio.NewRingBuffer(buff[:])
6380
6381	body := io.TeeReader(errorBody, ringBuffer)
6382	decoder := json.NewDecoder(body)
6383	decoder.UseNumber()
6384	code, message, err := restjson.GetErrorInfo(decoder)
6385	if err != nil {
6386		var snapshot bytes.Buffer
6387		io.Copy(&snapshot, ringBuffer)
6388		err = &smithy.DeserializationError{
6389			Err:      fmt.Errorf("failed to decode response body, %w", err),
6390			Snapshot: snapshot.Bytes(),
6391		}
6392		return err
6393	}
6394
6395	errorBody.Seek(0, io.SeekStart)
6396	if len(code) != 0 {
6397		errorCode = restjson.SanitizeErrorCode(code)
6398	}
6399	if len(message) != 0 {
6400		errorMessage = message
6401	}
6402
6403	switch {
6404	case strings.EqualFold("AccessDeniedException", errorCode):
6405		return awsAwsjson11_deserializeErrorAccessDeniedException(response, errorBody)
6406
6407	case strings.EqualFold("AWSOrganizationsNotInUseException", errorCode):
6408		return awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response, errorBody)
6409
6410	case strings.EqualFold("ConcurrentModificationException", errorCode):
6411		return awsAwsjson11_deserializeErrorConcurrentModificationException(response, errorBody)
6412
6413	case strings.EqualFold("ConstraintViolationException", errorCode):
6414		return awsAwsjson11_deserializeErrorConstraintViolationException(response, errorBody)
6415
6416	case strings.EqualFold("DuplicatePolicyException", errorCode):
6417		return awsAwsjson11_deserializeErrorDuplicatePolicyException(response, errorBody)
6418
6419	case strings.EqualFold("InvalidInputException", errorCode):
6420		return awsAwsjson11_deserializeErrorInvalidInputException(response, errorBody)
6421
6422	case strings.EqualFold("MalformedPolicyDocumentException", errorCode):
6423		return awsAwsjson11_deserializeErrorMalformedPolicyDocumentException(response, errorBody)
6424
6425	case strings.EqualFold("PolicyChangesInProgressException", errorCode):
6426		return awsAwsjson11_deserializeErrorPolicyChangesInProgressException(response, errorBody)
6427
6428	case strings.EqualFold("PolicyNotFoundException", errorCode):
6429		return awsAwsjson11_deserializeErrorPolicyNotFoundException(response, errorBody)
6430
6431	case strings.EqualFold("ServiceException", errorCode):
6432		return awsAwsjson11_deserializeErrorServiceException(response, errorBody)
6433
6434	case strings.EqualFold("TooManyRequestsException", errorCode):
6435		return awsAwsjson11_deserializeErrorTooManyRequestsException(response, errorBody)
6436
6437	case strings.EqualFold("UnsupportedAPIEndpointException", errorCode):
6438		return awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response, errorBody)
6439
6440	default:
6441		genericError := &smithy.GenericAPIError{
6442			Code:    errorCode,
6443			Message: errorMessage,
6444		}
6445		return genericError
6446
6447	}
6448}
6449
6450func awsAwsjson11_deserializeErrorAccessDeniedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6451	var buff [1024]byte
6452	ringBuffer := smithyio.NewRingBuffer(buff[:])
6453
6454	body := io.TeeReader(errorBody, ringBuffer)
6455	decoder := json.NewDecoder(body)
6456	decoder.UseNumber()
6457	var shape interface{}
6458	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6459		var snapshot bytes.Buffer
6460		io.Copy(&snapshot, ringBuffer)
6461		err = &smithy.DeserializationError{
6462			Err:      fmt.Errorf("failed to decode response body, %w", err),
6463			Snapshot: snapshot.Bytes(),
6464		}
6465		return err
6466	}
6467
6468	output := &types.AccessDeniedException{}
6469	err := awsAwsjson11_deserializeDocumentAccessDeniedException(&output, shape)
6470
6471	if err != nil {
6472		var snapshot bytes.Buffer
6473		io.Copy(&snapshot, ringBuffer)
6474		err = &smithy.DeserializationError{
6475			Err:      fmt.Errorf("failed to decode response body, %w", err),
6476			Snapshot: snapshot.Bytes(),
6477		}
6478		return err
6479	}
6480
6481	errorBody.Seek(0, io.SeekStart)
6482	return output
6483}
6484
6485func awsAwsjson11_deserializeErrorAccessDeniedForDependencyException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6486	var buff [1024]byte
6487	ringBuffer := smithyio.NewRingBuffer(buff[:])
6488
6489	body := io.TeeReader(errorBody, ringBuffer)
6490	decoder := json.NewDecoder(body)
6491	decoder.UseNumber()
6492	var shape interface{}
6493	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6494		var snapshot bytes.Buffer
6495		io.Copy(&snapshot, ringBuffer)
6496		err = &smithy.DeserializationError{
6497			Err:      fmt.Errorf("failed to decode response body, %w", err),
6498			Snapshot: snapshot.Bytes(),
6499		}
6500		return err
6501	}
6502
6503	output := &types.AccessDeniedForDependencyException{}
6504	err := awsAwsjson11_deserializeDocumentAccessDeniedForDependencyException(&output, shape)
6505
6506	if err != nil {
6507		var snapshot bytes.Buffer
6508		io.Copy(&snapshot, ringBuffer)
6509		err = &smithy.DeserializationError{
6510			Err:      fmt.Errorf("failed to decode response body, %w", err),
6511			Snapshot: snapshot.Bytes(),
6512		}
6513		return err
6514	}
6515
6516	errorBody.Seek(0, io.SeekStart)
6517	return output
6518}
6519
6520func awsAwsjson11_deserializeErrorAccountAlreadyRegisteredException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6521	var buff [1024]byte
6522	ringBuffer := smithyio.NewRingBuffer(buff[:])
6523
6524	body := io.TeeReader(errorBody, ringBuffer)
6525	decoder := json.NewDecoder(body)
6526	decoder.UseNumber()
6527	var shape interface{}
6528	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6529		var snapshot bytes.Buffer
6530		io.Copy(&snapshot, ringBuffer)
6531		err = &smithy.DeserializationError{
6532			Err:      fmt.Errorf("failed to decode response body, %w", err),
6533			Snapshot: snapshot.Bytes(),
6534		}
6535		return err
6536	}
6537
6538	output := &types.AccountAlreadyRegisteredException{}
6539	err := awsAwsjson11_deserializeDocumentAccountAlreadyRegisteredException(&output, shape)
6540
6541	if err != nil {
6542		var snapshot bytes.Buffer
6543		io.Copy(&snapshot, ringBuffer)
6544		err = &smithy.DeserializationError{
6545			Err:      fmt.Errorf("failed to decode response body, %w", err),
6546			Snapshot: snapshot.Bytes(),
6547		}
6548		return err
6549	}
6550
6551	errorBody.Seek(0, io.SeekStart)
6552	return output
6553}
6554
6555func awsAwsjson11_deserializeErrorAccountNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6556	var buff [1024]byte
6557	ringBuffer := smithyio.NewRingBuffer(buff[:])
6558
6559	body := io.TeeReader(errorBody, ringBuffer)
6560	decoder := json.NewDecoder(body)
6561	decoder.UseNumber()
6562	var shape interface{}
6563	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6564		var snapshot bytes.Buffer
6565		io.Copy(&snapshot, ringBuffer)
6566		err = &smithy.DeserializationError{
6567			Err:      fmt.Errorf("failed to decode response body, %w", err),
6568			Snapshot: snapshot.Bytes(),
6569		}
6570		return err
6571	}
6572
6573	output := &types.AccountNotFoundException{}
6574	err := awsAwsjson11_deserializeDocumentAccountNotFoundException(&output, shape)
6575
6576	if err != nil {
6577		var snapshot bytes.Buffer
6578		io.Copy(&snapshot, ringBuffer)
6579		err = &smithy.DeserializationError{
6580			Err:      fmt.Errorf("failed to decode response body, %w", err),
6581			Snapshot: snapshot.Bytes(),
6582		}
6583		return err
6584	}
6585
6586	errorBody.Seek(0, io.SeekStart)
6587	return output
6588}
6589
6590func awsAwsjson11_deserializeErrorAccountNotRegisteredException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6591	var buff [1024]byte
6592	ringBuffer := smithyio.NewRingBuffer(buff[:])
6593
6594	body := io.TeeReader(errorBody, ringBuffer)
6595	decoder := json.NewDecoder(body)
6596	decoder.UseNumber()
6597	var shape interface{}
6598	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6599		var snapshot bytes.Buffer
6600		io.Copy(&snapshot, ringBuffer)
6601		err = &smithy.DeserializationError{
6602			Err:      fmt.Errorf("failed to decode response body, %w", err),
6603			Snapshot: snapshot.Bytes(),
6604		}
6605		return err
6606	}
6607
6608	output := &types.AccountNotRegisteredException{}
6609	err := awsAwsjson11_deserializeDocumentAccountNotRegisteredException(&output, shape)
6610
6611	if err != nil {
6612		var snapshot bytes.Buffer
6613		io.Copy(&snapshot, ringBuffer)
6614		err = &smithy.DeserializationError{
6615			Err:      fmt.Errorf("failed to decode response body, %w", err),
6616			Snapshot: snapshot.Bytes(),
6617		}
6618		return err
6619	}
6620
6621	errorBody.Seek(0, io.SeekStart)
6622	return output
6623}
6624
6625func awsAwsjson11_deserializeErrorAccountOwnerNotVerifiedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6626	var buff [1024]byte
6627	ringBuffer := smithyio.NewRingBuffer(buff[:])
6628
6629	body := io.TeeReader(errorBody, ringBuffer)
6630	decoder := json.NewDecoder(body)
6631	decoder.UseNumber()
6632	var shape interface{}
6633	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6634		var snapshot bytes.Buffer
6635		io.Copy(&snapshot, ringBuffer)
6636		err = &smithy.DeserializationError{
6637			Err:      fmt.Errorf("failed to decode response body, %w", err),
6638			Snapshot: snapshot.Bytes(),
6639		}
6640		return err
6641	}
6642
6643	output := &types.AccountOwnerNotVerifiedException{}
6644	err := awsAwsjson11_deserializeDocumentAccountOwnerNotVerifiedException(&output, shape)
6645
6646	if err != nil {
6647		var snapshot bytes.Buffer
6648		io.Copy(&snapshot, ringBuffer)
6649		err = &smithy.DeserializationError{
6650			Err:      fmt.Errorf("failed to decode response body, %w", err),
6651			Snapshot: snapshot.Bytes(),
6652		}
6653		return err
6654	}
6655
6656	errorBody.Seek(0, io.SeekStart)
6657	return output
6658}
6659
6660func awsAwsjson11_deserializeErrorAlreadyInOrganizationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6661	var buff [1024]byte
6662	ringBuffer := smithyio.NewRingBuffer(buff[:])
6663
6664	body := io.TeeReader(errorBody, ringBuffer)
6665	decoder := json.NewDecoder(body)
6666	decoder.UseNumber()
6667	var shape interface{}
6668	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6669		var snapshot bytes.Buffer
6670		io.Copy(&snapshot, ringBuffer)
6671		err = &smithy.DeserializationError{
6672			Err:      fmt.Errorf("failed to decode response body, %w", err),
6673			Snapshot: snapshot.Bytes(),
6674		}
6675		return err
6676	}
6677
6678	output := &types.AlreadyInOrganizationException{}
6679	err := awsAwsjson11_deserializeDocumentAlreadyInOrganizationException(&output, shape)
6680
6681	if err != nil {
6682		var snapshot bytes.Buffer
6683		io.Copy(&snapshot, ringBuffer)
6684		err = &smithy.DeserializationError{
6685			Err:      fmt.Errorf("failed to decode response body, %w", err),
6686			Snapshot: snapshot.Bytes(),
6687		}
6688		return err
6689	}
6690
6691	errorBody.Seek(0, io.SeekStart)
6692	return output
6693}
6694
6695func awsAwsjson11_deserializeErrorAWSOrganizationsNotInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6696	var buff [1024]byte
6697	ringBuffer := smithyio.NewRingBuffer(buff[:])
6698
6699	body := io.TeeReader(errorBody, ringBuffer)
6700	decoder := json.NewDecoder(body)
6701	decoder.UseNumber()
6702	var shape interface{}
6703	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6704		var snapshot bytes.Buffer
6705		io.Copy(&snapshot, ringBuffer)
6706		err = &smithy.DeserializationError{
6707			Err:      fmt.Errorf("failed to decode response body, %w", err),
6708			Snapshot: snapshot.Bytes(),
6709		}
6710		return err
6711	}
6712
6713	output := &types.AWSOrganizationsNotInUseException{}
6714	err := awsAwsjson11_deserializeDocumentAWSOrganizationsNotInUseException(&output, shape)
6715
6716	if err != nil {
6717		var snapshot bytes.Buffer
6718		io.Copy(&snapshot, ringBuffer)
6719		err = &smithy.DeserializationError{
6720			Err:      fmt.Errorf("failed to decode response body, %w", err),
6721			Snapshot: snapshot.Bytes(),
6722		}
6723		return err
6724	}
6725
6726	errorBody.Seek(0, io.SeekStart)
6727	return output
6728}
6729
6730func awsAwsjson11_deserializeErrorChildNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6731	var buff [1024]byte
6732	ringBuffer := smithyio.NewRingBuffer(buff[:])
6733
6734	body := io.TeeReader(errorBody, ringBuffer)
6735	decoder := json.NewDecoder(body)
6736	decoder.UseNumber()
6737	var shape interface{}
6738	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6739		var snapshot bytes.Buffer
6740		io.Copy(&snapshot, ringBuffer)
6741		err = &smithy.DeserializationError{
6742			Err:      fmt.Errorf("failed to decode response body, %w", err),
6743			Snapshot: snapshot.Bytes(),
6744		}
6745		return err
6746	}
6747
6748	output := &types.ChildNotFoundException{}
6749	err := awsAwsjson11_deserializeDocumentChildNotFoundException(&output, shape)
6750
6751	if err != nil {
6752		var snapshot bytes.Buffer
6753		io.Copy(&snapshot, ringBuffer)
6754		err = &smithy.DeserializationError{
6755			Err:      fmt.Errorf("failed to decode response body, %w", err),
6756			Snapshot: snapshot.Bytes(),
6757		}
6758		return err
6759	}
6760
6761	errorBody.Seek(0, io.SeekStart)
6762	return output
6763}
6764
6765func awsAwsjson11_deserializeErrorConcurrentModificationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6766	var buff [1024]byte
6767	ringBuffer := smithyio.NewRingBuffer(buff[:])
6768
6769	body := io.TeeReader(errorBody, ringBuffer)
6770	decoder := json.NewDecoder(body)
6771	decoder.UseNumber()
6772	var shape interface{}
6773	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6774		var snapshot bytes.Buffer
6775		io.Copy(&snapshot, ringBuffer)
6776		err = &smithy.DeserializationError{
6777			Err:      fmt.Errorf("failed to decode response body, %w", err),
6778			Snapshot: snapshot.Bytes(),
6779		}
6780		return err
6781	}
6782
6783	output := &types.ConcurrentModificationException{}
6784	err := awsAwsjson11_deserializeDocumentConcurrentModificationException(&output, shape)
6785
6786	if err != nil {
6787		var snapshot bytes.Buffer
6788		io.Copy(&snapshot, ringBuffer)
6789		err = &smithy.DeserializationError{
6790			Err:      fmt.Errorf("failed to decode response body, %w", err),
6791			Snapshot: snapshot.Bytes(),
6792		}
6793		return err
6794	}
6795
6796	errorBody.Seek(0, io.SeekStart)
6797	return output
6798}
6799
6800func awsAwsjson11_deserializeErrorConstraintViolationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6801	var buff [1024]byte
6802	ringBuffer := smithyio.NewRingBuffer(buff[:])
6803
6804	body := io.TeeReader(errorBody, ringBuffer)
6805	decoder := json.NewDecoder(body)
6806	decoder.UseNumber()
6807	var shape interface{}
6808	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6809		var snapshot bytes.Buffer
6810		io.Copy(&snapshot, ringBuffer)
6811		err = &smithy.DeserializationError{
6812			Err:      fmt.Errorf("failed to decode response body, %w", err),
6813			Snapshot: snapshot.Bytes(),
6814		}
6815		return err
6816	}
6817
6818	output := &types.ConstraintViolationException{}
6819	err := awsAwsjson11_deserializeDocumentConstraintViolationException(&output, shape)
6820
6821	if err != nil {
6822		var snapshot bytes.Buffer
6823		io.Copy(&snapshot, ringBuffer)
6824		err = &smithy.DeserializationError{
6825			Err:      fmt.Errorf("failed to decode response body, %w", err),
6826			Snapshot: snapshot.Bytes(),
6827		}
6828		return err
6829	}
6830
6831	errorBody.Seek(0, io.SeekStart)
6832	return output
6833}
6834
6835func awsAwsjson11_deserializeErrorCreateAccountStatusNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6836	var buff [1024]byte
6837	ringBuffer := smithyio.NewRingBuffer(buff[:])
6838
6839	body := io.TeeReader(errorBody, ringBuffer)
6840	decoder := json.NewDecoder(body)
6841	decoder.UseNumber()
6842	var shape interface{}
6843	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6844		var snapshot bytes.Buffer
6845		io.Copy(&snapshot, ringBuffer)
6846		err = &smithy.DeserializationError{
6847			Err:      fmt.Errorf("failed to decode response body, %w", err),
6848			Snapshot: snapshot.Bytes(),
6849		}
6850		return err
6851	}
6852
6853	output := &types.CreateAccountStatusNotFoundException{}
6854	err := awsAwsjson11_deserializeDocumentCreateAccountStatusNotFoundException(&output, shape)
6855
6856	if err != nil {
6857		var snapshot bytes.Buffer
6858		io.Copy(&snapshot, ringBuffer)
6859		err = &smithy.DeserializationError{
6860			Err:      fmt.Errorf("failed to decode response body, %w", err),
6861			Snapshot: snapshot.Bytes(),
6862		}
6863		return err
6864	}
6865
6866	errorBody.Seek(0, io.SeekStart)
6867	return output
6868}
6869
6870func awsAwsjson11_deserializeErrorDestinationParentNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6871	var buff [1024]byte
6872	ringBuffer := smithyio.NewRingBuffer(buff[:])
6873
6874	body := io.TeeReader(errorBody, ringBuffer)
6875	decoder := json.NewDecoder(body)
6876	decoder.UseNumber()
6877	var shape interface{}
6878	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6879		var snapshot bytes.Buffer
6880		io.Copy(&snapshot, ringBuffer)
6881		err = &smithy.DeserializationError{
6882			Err:      fmt.Errorf("failed to decode response body, %w", err),
6883			Snapshot: snapshot.Bytes(),
6884		}
6885		return err
6886	}
6887
6888	output := &types.DestinationParentNotFoundException{}
6889	err := awsAwsjson11_deserializeDocumentDestinationParentNotFoundException(&output, shape)
6890
6891	if err != nil {
6892		var snapshot bytes.Buffer
6893		io.Copy(&snapshot, ringBuffer)
6894		err = &smithy.DeserializationError{
6895			Err:      fmt.Errorf("failed to decode response body, %w", err),
6896			Snapshot: snapshot.Bytes(),
6897		}
6898		return err
6899	}
6900
6901	errorBody.Seek(0, io.SeekStart)
6902	return output
6903}
6904
6905func awsAwsjson11_deserializeErrorDuplicateAccountException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6906	var buff [1024]byte
6907	ringBuffer := smithyio.NewRingBuffer(buff[:])
6908
6909	body := io.TeeReader(errorBody, ringBuffer)
6910	decoder := json.NewDecoder(body)
6911	decoder.UseNumber()
6912	var shape interface{}
6913	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6914		var snapshot bytes.Buffer
6915		io.Copy(&snapshot, ringBuffer)
6916		err = &smithy.DeserializationError{
6917			Err:      fmt.Errorf("failed to decode response body, %w", err),
6918			Snapshot: snapshot.Bytes(),
6919		}
6920		return err
6921	}
6922
6923	output := &types.DuplicateAccountException{}
6924	err := awsAwsjson11_deserializeDocumentDuplicateAccountException(&output, shape)
6925
6926	if err != nil {
6927		var snapshot bytes.Buffer
6928		io.Copy(&snapshot, ringBuffer)
6929		err = &smithy.DeserializationError{
6930			Err:      fmt.Errorf("failed to decode response body, %w", err),
6931			Snapshot: snapshot.Bytes(),
6932		}
6933		return err
6934	}
6935
6936	errorBody.Seek(0, io.SeekStart)
6937	return output
6938}
6939
6940func awsAwsjson11_deserializeErrorDuplicateHandshakeException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6941	var buff [1024]byte
6942	ringBuffer := smithyio.NewRingBuffer(buff[:])
6943
6944	body := io.TeeReader(errorBody, ringBuffer)
6945	decoder := json.NewDecoder(body)
6946	decoder.UseNumber()
6947	var shape interface{}
6948	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6949		var snapshot bytes.Buffer
6950		io.Copy(&snapshot, ringBuffer)
6951		err = &smithy.DeserializationError{
6952			Err:      fmt.Errorf("failed to decode response body, %w", err),
6953			Snapshot: snapshot.Bytes(),
6954		}
6955		return err
6956	}
6957
6958	output := &types.DuplicateHandshakeException{}
6959	err := awsAwsjson11_deserializeDocumentDuplicateHandshakeException(&output, shape)
6960
6961	if err != nil {
6962		var snapshot bytes.Buffer
6963		io.Copy(&snapshot, ringBuffer)
6964		err = &smithy.DeserializationError{
6965			Err:      fmt.Errorf("failed to decode response body, %w", err),
6966			Snapshot: snapshot.Bytes(),
6967		}
6968		return err
6969	}
6970
6971	errorBody.Seek(0, io.SeekStart)
6972	return output
6973}
6974
6975func awsAwsjson11_deserializeErrorDuplicateOrganizationalUnitException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
6976	var buff [1024]byte
6977	ringBuffer := smithyio.NewRingBuffer(buff[:])
6978
6979	body := io.TeeReader(errorBody, ringBuffer)
6980	decoder := json.NewDecoder(body)
6981	decoder.UseNumber()
6982	var shape interface{}
6983	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6984		var snapshot bytes.Buffer
6985		io.Copy(&snapshot, ringBuffer)
6986		err = &smithy.DeserializationError{
6987			Err:      fmt.Errorf("failed to decode response body, %w", err),
6988			Snapshot: snapshot.Bytes(),
6989		}
6990		return err
6991	}
6992
6993	output := &types.DuplicateOrganizationalUnitException{}
6994	err := awsAwsjson11_deserializeDocumentDuplicateOrganizationalUnitException(&output, shape)
6995
6996	if err != nil {
6997		var snapshot bytes.Buffer
6998		io.Copy(&snapshot, ringBuffer)
6999		err = &smithy.DeserializationError{
7000			Err:      fmt.Errorf("failed to decode response body, %w", err),
7001			Snapshot: snapshot.Bytes(),
7002		}
7003		return err
7004	}
7005
7006	errorBody.Seek(0, io.SeekStart)
7007	return output
7008}
7009
7010func awsAwsjson11_deserializeErrorDuplicatePolicyAttachmentException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7011	var buff [1024]byte
7012	ringBuffer := smithyio.NewRingBuffer(buff[:])
7013
7014	body := io.TeeReader(errorBody, ringBuffer)
7015	decoder := json.NewDecoder(body)
7016	decoder.UseNumber()
7017	var shape interface{}
7018	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7019		var snapshot bytes.Buffer
7020		io.Copy(&snapshot, ringBuffer)
7021		err = &smithy.DeserializationError{
7022			Err:      fmt.Errorf("failed to decode response body, %w", err),
7023			Snapshot: snapshot.Bytes(),
7024		}
7025		return err
7026	}
7027
7028	output := &types.DuplicatePolicyAttachmentException{}
7029	err := awsAwsjson11_deserializeDocumentDuplicatePolicyAttachmentException(&output, shape)
7030
7031	if err != nil {
7032		var snapshot bytes.Buffer
7033		io.Copy(&snapshot, ringBuffer)
7034		err = &smithy.DeserializationError{
7035			Err:      fmt.Errorf("failed to decode response body, %w", err),
7036			Snapshot: snapshot.Bytes(),
7037		}
7038		return err
7039	}
7040
7041	errorBody.Seek(0, io.SeekStart)
7042	return output
7043}
7044
7045func awsAwsjson11_deserializeErrorDuplicatePolicyException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7046	var buff [1024]byte
7047	ringBuffer := smithyio.NewRingBuffer(buff[:])
7048
7049	body := io.TeeReader(errorBody, ringBuffer)
7050	decoder := json.NewDecoder(body)
7051	decoder.UseNumber()
7052	var shape interface{}
7053	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7054		var snapshot bytes.Buffer
7055		io.Copy(&snapshot, ringBuffer)
7056		err = &smithy.DeserializationError{
7057			Err:      fmt.Errorf("failed to decode response body, %w", err),
7058			Snapshot: snapshot.Bytes(),
7059		}
7060		return err
7061	}
7062
7063	output := &types.DuplicatePolicyException{}
7064	err := awsAwsjson11_deserializeDocumentDuplicatePolicyException(&output, shape)
7065
7066	if err != nil {
7067		var snapshot bytes.Buffer
7068		io.Copy(&snapshot, ringBuffer)
7069		err = &smithy.DeserializationError{
7070			Err:      fmt.Errorf("failed to decode response body, %w", err),
7071			Snapshot: snapshot.Bytes(),
7072		}
7073		return err
7074	}
7075
7076	errorBody.Seek(0, io.SeekStart)
7077	return output
7078}
7079
7080func awsAwsjson11_deserializeErrorEffectivePolicyNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7081	var buff [1024]byte
7082	ringBuffer := smithyio.NewRingBuffer(buff[:])
7083
7084	body := io.TeeReader(errorBody, ringBuffer)
7085	decoder := json.NewDecoder(body)
7086	decoder.UseNumber()
7087	var shape interface{}
7088	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7089		var snapshot bytes.Buffer
7090		io.Copy(&snapshot, ringBuffer)
7091		err = &smithy.DeserializationError{
7092			Err:      fmt.Errorf("failed to decode response body, %w", err),
7093			Snapshot: snapshot.Bytes(),
7094		}
7095		return err
7096	}
7097
7098	output := &types.EffectivePolicyNotFoundException{}
7099	err := awsAwsjson11_deserializeDocumentEffectivePolicyNotFoundException(&output, shape)
7100
7101	if err != nil {
7102		var snapshot bytes.Buffer
7103		io.Copy(&snapshot, ringBuffer)
7104		err = &smithy.DeserializationError{
7105			Err:      fmt.Errorf("failed to decode response body, %w", err),
7106			Snapshot: snapshot.Bytes(),
7107		}
7108		return err
7109	}
7110
7111	errorBody.Seek(0, io.SeekStart)
7112	return output
7113}
7114
7115func awsAwsjson11_deserializeErrorFinalizingOrganizationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7116	var buff [1024]byte
7117	ringBuffer := smithyio.NewRingBuffer(buff[:])
7118
7119	body := io.TeeReader(errorBody, ringBuffer)
7120	decoder := json.NewDecoder(body)
7121	decoder.UseNumber()
7122	var shape interface{}
7123	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7124		var snapshot bytes.Buffer
7125		io.Copy(&snapshot, ringBuffer)
7126		err = &smithy.DeserializationError{
7127			Err:      fmt.Errorf("failed to decode response body, %w", err),
7128			Snapshot: snapshot.Bytes(),
7129		}
7130		return err
7131	}
7132
7133	output := &types.FinalizingOrganizationException{}
7134	err := awsAwsjson11_deserializeDocumentFinalizingOrganizationException(&output, shape)
7135
7136	if err != nil {
7137		var snapshot bytes.Buffer
7138		io.Copy(&snapshot, ringBuffer)
7139		err = &smithy.DeserializationError{
7140			Err:      fmt.Errorf("failed to decode response body, %w", err),
7141			Snapshot: snapshot.Bytes(),
7142		}
7143		return err
7144	}
7145
7146	errorBody.Seek(0, io.SeekStart)
7147	return output
7148}
7149
7150func awsAwsjson11_deserializeErrorHandshakeAlreadyInStateException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7151	var buff [1024]byte
7152	ringBuffer := smithyio.NewRingBuffer(buff[:])
7153
7154	body := io.TeeReader(errorBody, ringBuffer)
7155	decoder := json.NewDecoder(body)
7156	decoder.UseNumber()
7157	var shape interface{}
7158	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7159		var snapshot bytes.Buffer
7160		io.Copy(&snapshot, ringBuffer)
7161		err = &smithy.DeserializationError{
7162			Err:      fmt.Errorf("failed to decode response body, %w", err),
7163			Snapshot: snapshot.Bytes(),
7164		}
7165		return err
7166	}
7167
7168	output := &types.HandshakeAlreadyInStateException{}
7169	err := awsAwsjson11_deserializeDocumentHandshakeAlreadyInStateException(&output, shape)
7170
7171	if err != nil {
7172		var snapshot bytes.Buffer
7173		io.Copy(&snapshot, ringBuffer)
7174		err = &smithy.DeserializationError{
7175			Err:      fmt.Errorf("failed to decode response body, %w", err),
7176			Snapshot: snapshot.Bytes(),
7177		}
7178		return err
7179	}
7180
7181	errorBody.Seek(0, io.SeekStart)
7182	return output
7183}
7184
7185func awsAwsjson11_deserializeErrorHandshakeConstraintViolationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7186	var buff [1024]byte
7187	ringBuffer := smithyio.NewRingBuffer(buff[:])
7188
7189	body := io.TeeReader(errorBody, ringBuffer)
7190	decoder := json.NewDecoder(body)
7191	decoder.UseNumber()
7192	var shape interface{}
7193	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7194		var snapshot bytes.Buffer
7195		io.Copy(&snapshot, ringBuffer)
7196		err = &smithy.DeserializationError{
7197			Err:      fmt.Errorf("failed to decode response body, %w", err),
7198			Snapshot: snapshot.Bytes(),
7199		}
7200		return err
7201	}
7202
7203	output := &types.HandshakeConstraintViolationException{}
7204	err := awsAwsjson11_deserializeDocumentHandshakeConstraintViolationException(&output, shape)
7205
7206	if err != nil {
7207		var snapshot bytes.Buffer
7208		io.Copy(&snapshot, ringBuffer)
7209		err = &smithy.DeserializationError{
7210			Err:      fmt.Errorf("failed to decode response body, %w", err),
7211			Snapshot: snapshot.Bytes(),
7212		}
7213		return err
7214	}
7215
7216	errorBody.Seek(0, io.SeekStart)
7217	return output
7218}
7219
7220func awsAwsjson11_deserializeErrorHandshakeNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7221	var buff [1024]byte
7222	ringBuffer := smithyio.NewRingBuffer(buff[:])
7223
7224	body := io.TeeReader(errorBody, ringBuffer)
7225	decoder := json.NewDecoder(body)
7226	decoder.UseNumber()
7227	var shape interface{}
7228	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7229		var snapshot bytes.Buffer
7230		io.Copy(&snapshot, ringBuffer)
7231		err = &smithy.DeserializationError{
7232			Err:      fmt.Errorf("failed to decode response body, %w", err),
7233			Snapshot: snapshot.Bytes(),
7234		}
7235		return err
7236	}
7237
7238	output := &types.HandshakeNotFoundException{}
7239	err := awsAwsjson11_deserializeDocumentHandshakeNotFoundException(&output, shape)
7240
7241	if err != nil {
7242		var snapshot bytes.Buffer
7243		io.Copy(&snapshot, ringBuffer)
7244		err = &smithy.DeserializationError{
7245			Err:      fmt.Errorf("failed to decode response body, %w", err),
7246			Snapshot: snapshot.Bytes(),
7247		}
7248		return err
7249	}
7250
7251	errorBody.Seek(0, io.SeekStart)
7252	return output
7253}
7254
7255func awsAwsjson11_deserializeErrorInvalidHandshakeTransitionException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7256	var buff [1024]byte
7257	ringBuffer := smithyio.NewRingBuffer(buff[:])
7258
7259	body := io.TeeReader(errorBody, ringBuffer)
7260	decoder := json.NewDecoder(body)
7261	decoder.UseNumber()
7262	var shape interface{}
7263	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7264		var snapshot bytes.Buffer
7265		io.Copy(&snapshot, ringBuffer)
7266		err = &smithy.DeserializationError{
7267			Err:      fmt.Errorf("failed to decode response body, %w", err),
7268			Snapshot: snapshot.Bytes(),
7269		}
7270		return err
7271	}
7272
7273	output := &types.InvalidHandshakeTransitionException{}
7274	err := awsAwsjson11_deserializeDocumentInvalidHandshakeTransitionException(&output, shape)
7275
7276	if err != nil {
7277		var snapshot bytes.Buffer
7278		io.Copy(&snapshot, ringBuffer)
7279		err = &smithy.DeserializationError{
7280			Err:      fmt.Errorf("failed to decode response body, %w", err),
7281			Snapshot: snapshot.Bytes(),
7282		}
7283		return err
7284	}
7285
7286	errorBody.Seek(0, io.SeekStart)
7287	return output
7288}
7289
7290func awsAwsjson11_deserializeErrorInvalidInputException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7291	var buff [1024]byte
7292	ringBuffer := smithyio.NewRingBuffer(buff[:])
7293
7294	body := io.TeeReader(errorBody, ringBuffer)
7295	decoder := json.NewDecoder(body)
7296	decoder.UseNumber()
7297	var shape interface{}
7298	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7299		var snapshot bytes.Buffer
7300		io.Copy(&snapshot, ringBuffer)
7301		err = &smithy.DeserializationError{
7302			Err:      fmt.Errorf("failed to decode response body, %w", err),
7303			Snapshot: snapshot.Bytes(),
7304		}
7305		return err
7306	}
7307
7308	output := &types.InvalidInputException{}
7309	err := awsAwsjson11_deserializeDocumentInvalidInputException(&output, shape)
7310
7311	if err != nil {
7312		var snapshot bytes.Buffer
7313		io.Copy(&snapshot, ringBuffer)
7314		err = &smithy.DeserializationError{
7315			Err:      fmt.Errorf("failed to decode response body, %w", err),
7316			Snapshot: snapshot.Bytes(),
7317		}
7318		return err
7319	}
7320
7321	errorBody.Seek(0, io.SeekStart)
7322	return output
7323}
7324
7325func awsAwsjson11_deserializeErrorMalformedPolicyDocumentException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7326	var buff [1024]byte
7327	ringBuffer := smithyio.NewRingBuffer(buff[:])
7328
7329	body := io.TeeReader(errorBody, ringBuffer)
7330	decoder := json.NewDecoder(body)
7331	decoder.UseNumber()
7332	var shape interface{}
7333	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7334		var snapshot bytes.Buffer
7335		io.Copy(&snapshot, ringBuffer)
7336		err = &smithy.DeserializationError{
7337			Err:      fmt.Errorf("failed to decode response body, %w", err),
7338			Snapshot: snapshot.Bytes(),
7339		}
7340		return err
7341	}
7342
7343	output := &types.MalformedPolicyDocumentException{}
7344	err := awsAwsjson11_deserializeDocumentMalformedPolicyDocumentException(&output, shape)
7345
7346	if err != nil {
7347		var snapshot bytes.Buffer
7348		io.Copy(&snapshot, ringBuffer)
7349		err = &smithy.DeserializationError{
7350			Err:      fmt.Errorf("failed to decode response body, %w", err),
7351			Snapshot: snapshot.Bytes(),
7352		}
7353		return err
7354	}
7355
7356	errorBody.Seek(0, io.SeekStart)
7357	return output
7358}
7359
7360func awsAwsjson11_deserializeErrorMasterCannotLeaveOrganizationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7361	var buff [1024]byte
7362	ringBuffer := smithyio.NewRingBuffer(buff[:])
7363
7364	body := io.TeeReader(errorBody, ringBuffer)
7365	decoder := json.NewDecoder(body)
7366	decoder.UseNumber()
7367	var shape interface{}
7368	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7369		var snapshot bytes.Buffer
7370		io.Copy(&snapshot, ringBuffer)
7371		err = &smithy.DeserializationError{
7372			Err:      fmt.Errorf("failed to decode response body, %w", err),
7373			Snapshot: snapshot.Bytes(),
7374		}
7375		return err
7376	}
7377
7378	output := &types.MasterCannotLeaveOrganizationException{}
7379	err := awsAwsjson11_deserializeDocumentMasterCannotLeaveOrganizationException(&output, shape)
7380
7381	if err != nil {
7382		var snapshot bytes.Buffer
7383		io.Copy(&snapshot, ringBuffer)
7384		err = &smithy.DeserializationError{
7385			Err:      fmt.Errorf("failed to decode response body, %w", err),
7386			Snapshot: snapshot.Bytes(),
7387		}
7388		return err
7389	}
7390
7391	errorBody.Seek(0, io.SeekStart)
7392	return output
7393}
7394
7395func awsAwsjson11_deserializeErrorOrganizationalUnitNotEmptyException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7396	var buff [1024]byte
7397	ringBuffer := smithyio.NewRingBuffer(buff[:])
7398
7399	body := io.TeeReader(errorBody, ringBuffer)
7400	decoder := json.NewDecoder(body)
7401	decoder.UseNumber()
7402	var shape interface{}
7403	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7404		var snapshot bytes.Buffer
7405		io.Copy(&snapshot, ringBuffer)
7406		err = &smithy.DeserializationError{
7407			Err:      fmt.Errorf("failed to decode response body, %w", err),
7408			Snapshot: snapshot.Bytes(),
7409		}
7410		return err
7411	}
7412
7413	output := &types.OrganizationalUnitNotEmptyException{}
7414	err := awsAwsjson11_deserializeDocumentOrganizationalUnitNotEmptyException(&output, shape)
7415
7416	if err != nil {
7417		var snapshot bytes.Buffer
7418		io.Copy(&snapshot, ringBuffer)
7419		err = &smithy.DeserializationError{
7420			Err:      fmt.Errorf("failed to decode response body, %w", err),
7421			Snapshot: snapshot.Bytes(),
7422		}
7423		return err
7424	}
7425
7426	errorBody.Seek(0, io.SeekStart)
7427	return output
7428}
7429
7430func awsAwsjson11_deserializeErrorOrganizationalUnitNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7431	var buff [1024]byte
7432	ringBuffer := smithyio.NewRingBuffer(buff[:])
7433
7434	body := io.TeeReader(errorBody, ringBuffer)
7435	decoder := json.NewDecoder(body)
7436	decoder.UseNumber()
7437	var shape interface{}
7438	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7439		var snapshot bytes.Buffer
7440		io.Copy(&snapshot, ringBuffer)
7441		err = &smithy.DeserializationError{
7442			Err:      fmt.Errorf("failed to decode response body, %w", err),
7443			Snapshot: snapshot.Bytes(),
7444		}
7445		return err
7446	}
7447
7448	output := &types.OrganizationalUnitNotFoundException{}
7449	err := awsAwsjson11_deserializeDocumentOrganizationalUnitNotFoundException(&output, shape)
7450
7451	if err != nil {
7452		var snapshot bytes.Buffer
7453		io.Copy(&snapshot, ringBuffer)
7454		err = &smithy.DeserializationError{
7455			Err:      fmt.Errorf("failed to decode response body, %w", err),
7456			Snapshot: snapshot.Bytes(),
7457		}
7458		return err
7459	}
7460
7461	errorBody.Seek(0, io.SeekStart)
7462	return output
7463}
7464
7465func awsAwsjson11_deserializeErrorOrganizationNotEmptyException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7466	var buff [1024]byte
7467	ringBuffer := smithyio.NewRingBuffer(buff[:])
7468
7469	body := io.TeeReader(errorBody, ringBuffer)
7470	decoder := json.NewDecoder(body)
7471	decoder.UseNumber()
7472	var shape interface{}
7473	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7474		var snapshot bytes.Buffer
7475		io.Copy(&snapshot, ringBuffer)
7476		err = &smithy.DeserializationError{
7477			Err:      fmt.Errorf("failed to decode response body, %w", err),
7478			Snapshot: snapshot.Bytes(),
7479		}
7480		return err
7481	}
7482
7483	output := &types.OrganizationNotEmptyException{}
7484	err := awsAwsjson11_deserializeDocumentOrganizationNotEmptyException(&output, shape)
7485
7486	if err != nil {
7487		var snapshot bytes.Buffer
7488		io.Copy(&snapshot, ringBuffer)
7489		err = &smithy.DeserializationError{
7490			Err:      fmt.Errorf("failed to decode response body, %w", err),
7491			Snapshot: snapshot.Bytes(),
7492		}
7493		return err
7494	}
7495
7496	errorBody.Seek(0, io.SeekStart)
7497	return output
7498}
7499
7500func awsAwsjson11_deserializeErrorParentNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7501	var buff [1024]byte
7502	ringBuffer := smithyio.NewRingBuffer(buff[:])
7503
7504	body := io.TeeReader(errorBody, ringBuffer)
7505	decoder := json.NewDecoder(body)
7506	decoder.UseNumber()
7507	var shape interface{}
7508	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7509		var snapshot bytes.Buffer
7510		io.Copy(&snapshot, ringBuffer)
7511		err = &smithy.DeserializationError{
7512			Err:      fmt.Errorf("failed to decode response body, %w", err),
7513			Snapshot: snapshot.Bytes(),
7514		}
7515		return err
7516	}
7517
7518	output := &types.ParentNotFoundException{}
7519	err := awsAwsjson11_deserializeDocumentParentNotFoundException(&output, shape)
7520
7521	if err != nil {
7522		var snapshot bytes.Buffer
7523		io.Copy(&snapshot, ringBuffer)
7524		err = &smithy.DeserializationError{
7525			Err:      fmt.Errorf("failed to decode response body, %w", err),
7526			Snapshot: snapshot.Bytes(),
7527		}
7528		return err
7529	}
7530
7531	errorBody.Seek(0, io.SeekStart)
7532	return output
7533}
7534
7535func awsAwsjson11_deserializeErrorPolicyChangesInProgressException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7536	var buff [1024]byte
7537	ringBuffer := smithyio.NewRingBuffer(buff[:])
7538
7539	body := io.TeeReader(errorBody, ringBuffer)
7540	decoder := json.NewDecoder(body)
7541	decoder.UseNumber()
7542	var shape interface{}
7543	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7544		var snapshot bytes.Buffer
7545		io.Copy(&snapshot, ringBuffer)
7546		err = &smithy.DeserializationError{
7547			Err:      fmt.Errorf("failed to decode response body, %w", err),
7548			Snapshot: snapshot.Bytes(),
7549		}
7550		return err
7551	}
7552
7553	output := &types.PolicyChangesInProgressException{}
7554	err := awsAwsjson11_deserializeDocumentPolicyChangesInProgressException(&output, shape)
7555
7556	if err != nil {
7557		var snapshot bytes.Buffer
7558		io.Copy(&snapshot, ringBuffer)
7559		err = &smithy.DeserializationError{
7560			Err:      fmt.Errorf("failed to decode response body, %w", err),
7561			Snapshot: snapshot.Bytes(),
7562		}
7563		return err
7564	}
7565
7566	errorBody.Seek(0, io.SeekStart)
7567	return output
7568}
7569
7570func awsAwsjson11_deserializeErrorPolicyInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7571	var buff [1024]byte
7572	ringBuffer := smithyio.NewRingBuffer(buff[:])
7573
7574	body := io.TeeReader(errorBody, ringBuffer)
7575	decoder := json.NewDecoder(body)
7576	decoder.UseNumber()
7577	var shape interface{}
7578	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7579		var snapshot bytes.Buffer
7580		io.Copy(&snapshot, ringBuffer)
7581		err = &smithy.DeserializationError{
7582			Err:      fmt.Errorf("failed to decode response body, %w", err),
7583			Snapshot: snapshot.Bytes(),
7584		}
7585		return err
7586	}
7587
7588	output := &types.PolicyInUseException{}
7589	err := awsAwsjson11_deserializeDocumentPolicyInUseException(&output, shape)
7590
7591	if err != nil {
7592		var snapshot bytes.Buffer
7593		io.Copy(&snapshot, ringBuffer)
7594		err = &smithy.DeserializationError{
7595			Err:      fmt.Errorf("failed to decode response body, %w", err),
7596			Snapshot: snapshot.Bytes(),
7597		}
7598		return err
7599	}
7600
7601	errorBody.Seek(0, io.SeekStart)
7602	return output
7603}
7604
7605func awsAwsjson11_deserializeErrorPolicyNotAttachedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7606	var buff [1024]byte
7607	ringBuffer := smithyio.NewRingBuffer(buff[:])
7608
7609	body := io.TeeReader(errorBody, ringBuffer)
7610	decoder := json.NewDecoder(body)
7611	decoder.UseNumber()
7612	var shape interface{}
7613	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7614		var snapshot bytes.Buffer
7615		io.Copy(&snapshot, ringBuffer)
7616		err = &smithy.DeserializationError{
7617			Err:      fmt.Errorf("failed to decode response body, %w", err),
7618			Snapshot: snapshot.Bytes(),
7619		}
7620		return err
7621	}
7622
7623	output := &types.PolicyNotAttachedException{}
7624	err := awsAwsjson11_deserializeDocumentPolicyNotAttachedException(&output, shape)
7625
7626	if err != nil {
7627		var snapshot bytes.Buffer
7628		io.Copy(&snapshot, ringBuffer)
7629		err = &smithy.DeserializationError{
7630			Err:      fmt.Errorf("failed to decode response body, %w", err),
7631			Snapshot: snapshot.Bytes(),
7632		}
7633		return err
7634	}
7635
7636	errorBody.Seek(0, io.SeekStart)
7637	return output
7638}
7639
7640func awsAwsjson11_deserializeErrorPolicyNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7641	var buff [1024]byte
7642	ringBuffer := smithyio.NewRingBuffer(buff[:])
7643
7644	body := io.TeeReader(errorBody, ringBuffer)
7645	decoder := json.NewDecoder(body)
7646	decoder.UseNumber()
7647	var shape interface{}
7648	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7649		var snapshot bytes.Buffer
7650		io.Copy(&snapshot, ringBuffer)
7651		err = &smithy.DeserializationError{
7652			Err:      fmt.Errorf("failed to decode response body, %w", err),
7653			Snapshot: snapshot.Bytes(),
7654		}
7655		return err
7656	}
7657
7658	output := &types.PolicyNotFoundException{}
7659	err := awsAwsjson11_deserializeDocumentPolicyNotFoundException(&output, shape)
7660
7661	if err != nil {
7662		var snapshot bytes.Buffer
7663		io.Copy(&snapshot, ringBuffer)
7664		err = &smithy.DeserializationError{
7665			Err:      fmt.Errorf("failed to decode response body, %w", err),
7666			Snapshot: snapshot.Bytes(),
7667		}
7668		return err
7669	}
7670
7671	errorBody.Seek(0, io.SeekStart)
7672	return output
7673}
7674
7675func awsAwsjson11_deserializeErrorPolicyTypeAlreadyEnabledException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7676	var buff [1024]byte
7677	ringBuffer := smithyio.NewRingBuffer(buff[:])
7678
7679	body := io.TeeReader(errorBody, ringBuffer)
7680	decoder := json.NewDecoder(body)
7681	decoder.UseNumber()
7682	var shape interface{}
7683	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7684		var snapshot bytes.Buffer
7685		io.Copy(&snapshot, ringBuffer)
7686		err = &smithy.DeserializationError{
7687			Err:      fmt.Errorf("failed to decode response body, %w", err),
7688			Snapshot: snapshot.Bytes(),
7689		}
7690		return err
7691	}
7692
7693	output := &types.PolicyTypeAlreadyEnabledException{}
7694	err := awsAwsjson11_deserializeDocumentPolicyTypeAlreadyEnabledException(&output, shape)
7695
7696	if err != nil {
7697		var snapshot bytes.Buffer
7698		io.Copy(&snapshot, ringBuffer)
7699		err = &smithy.DeserializationError{
7700			Err:      fmt.Errorf("failed to decode response body, %w", err),
7701			Snapshot: snapshot.Bytes(),
7702		}
7703		return err
7704	}
7705
7706	errorBody.Seek(0, io.SeekStart)
7707	return output
7708}
7709
7710func awsAwsjson11_deserializeErrorPolicyTypeNotAvailableForOrganizationException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7711	var buff [1024]byte
7712	ringBuffer := smithyio.NewRingBuffer(buff[:])
7713
7714	body := io.TeeReader(errorBody, ringBuffer)
7715	decoder := json.NewDecoder(body)
7716	decoder.UseNumber()
7717	var shape interface{}
7718	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7719		var snapshot bytes.Buffer
7720		io.Copy(&snapshot, ringBuffer)
7721		err = &smithy.DeserializationError{
7722			Err:      fmt.Errorf("failed to decode response body, %w", err),
7723			Snapshot: snapshot.Bytes(),
7724		}
7725		return err
7726	}
7727
7728	output := &types.PolicyTypeNotAvailableForOrganizationException{}
7729	err := awsAwsjson11_deserializeDocumentPolicyTypeNotAvailableForOrganizationException(&output, shape)
7730
7731	if err != nil {
7732		var snapshot bytes.Buffer
7733		io.Copy(&snapshot, ringBuffer)
7734		err = &smithy.DeserializationError{
7735			Err:      fmt.Errorf("failed to decode response body, %w", err),
7736			Snapshot: snapshot.Bytes(),
7737		}
7738		return err
7739	}
7740
7741	errorBody.Seek(0, io.SeekStart)
7742	return output
7743}
7744
7745func awsAwsjson11_deserializeErrorPolicyTypeNotEnabledException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7746	var buff [1024]byte
7747	ringBuffer := smithyio.NewRingBuffer(buff[:])
7748
7749	body := io.TeeReader(errorBody, ringBuffer)
7750	decoder := json.NewDecoder(body)
7751	decoder.UseNumber()
7752	var shape interface{}
7753	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7754		var snapshot bytes.Buffer
7755		io.Copy(&snapshot, ringBuffer)
7756		err = &smithy.DeserializationError{
7757			Err:      fmt.Errorf("failed to decode response body, %w", err),
7758			Snapshot: snapshot.Bytes(),
7759		}
7760		return err
7761	}
7762
7763	output := &types.PolicyTypeNotEnabledException{}
7764	err := awsAwsjson11_deserializeDocumentPolicyTypeNotEnabledException(&output, shape)
7765
7766	if err != nil {
7767		var snapshot bytes.Buffer
7768		io.Copy(&snapshot, ringBuffer)
7769		err = &smithy.DeserializationError{
7770			Err:      fmt.Errorf("failed to decode response body, %w", err),
7771			Snapshot: snapshot.Bytes(),
7772		}
7773		return err
7774	}
7775
7776	errorBody.Seek(0, io.SeekStart)
7777	return output
7778}
7779
7780func awsAwsjson11_deserializeErrorRootNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7781	var buff [1024]byte
7782	ringBuffer := smithyio.NewRingBuffer(buff[:])
7783
7784	body := io.TeeReader(errorBody, ringBuffer)
7785	decoder := json.NewDecoder(body)
7786	decoder.UseNumber()
7787	var shape interface{}
7788	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7789		var snapshot bytes.Buffer
7790		io.Copy(&snapshot, ringBuffer)
7791		err = &smithy.DeserializationError{
7792			Err:      fmt.Errorf("failed to decode response body, %w", err),
7793			Snapshot: snapshot.Bytes(),
7794		}
7795		return err
7796	}
7797
7798	output := &types.RootNotFoundException{}
7799	err := awsAwsjson11_deserializeDocumentRootNotFoundException(&output, shape)
7800
7801	if err != nil {
7802		var snapshot bytes.Buffer
7803		io.Copy(&snapshot, ringBuffer)
7804		err = &smithy.DeserializationError{
7805			Err:      fmt.Errorf("failed to decode response body, %w", err),
7806			Snapshot: snapshot.Bytes(),
7807		}
7808		return err
7809	}
7810
7811	errorBody.Seek(0, io.SeekStart)
7812	return output
7813}
7814
7815func awsAwsjson11_deserializeErrorServiceException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7816	var buff [1024]byte
7817	ringBuffer := smithyio.NewRingBuffer(buff[:])
7818
7819	body := io.TeeReader(errorBody, ringBuffer)
7820	decoder := json.NewDecoder(body)
7821	decoder.UseNumber()
7822	var shape interface{}
7823	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7824		var snapshot bytes.Buffer
7825		io.Copy(&snapshot, ringBuffer)
7826		err = &smithy.DeserializationError{
7827			Err:      fmt.Errorf("failed to decode response body, %w", err),
7828			Snapshot: snapshot.Bytes(),
7829		}
7830		return err
7831	}
7832
7833	output := &types.ServiceException{}
7834	err := awsAwsjson11_deserializeDocumentServiceException(&output, shape)
7835
7836	if err != nil {
7837		var snapshot bytes.Buffer
7838		io.Copy(&snapshot, ringBuffer)
7839		err = &smithy.DeserializationError{
7840			Err:      fmt.Errorf("failed to decode response body, %w", err),
7841			Snapshot: snapshot.Bytes(),
7842		}
7843		return err
7844	}
7845
7846	errorBody.Seek(0, io.SeekStart)
7847	return output
7848}
7849
7850func awsAwsjson11_deserializeErrorSourceParentNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7851	var buff [1024]byte
7852	ringBuffer := smithyio.NewRingBuffer(buff[:])
7853
7854	body := io.TeeReader(errorBody, ringBuffer)
7855	decoder := json.NewDecoder(body)
7856	decoder.UseNumber()
7857	var shape interface{}
7858	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7859		var snapshot bytes.Buffer
7860		io.Copy(&snapshot, ringBuffer)
7861		err = &smithy.DeserializationError{
7862			Err:      fmt.Errorf("failed to decode response body, %w", err),
7863			Snapshot: snapshot.Bytes(),
7864		}
7865		return err
7866	}
7867
7868	output := &types.SourceParentNotFoundException{}
7869	err := awsAwsjson11_deserializeDocumentSourceParentNotFoundException(&output, shape)
7870
7871	if err != nil {
7872		var snapshot bytes.Buffer
7873		io.Copy(&snapshot, ringBuffer)
7874		err = &smithy.DeserializationError{
7875			Err:      fmt.Errorf("failed to decode response body, %w", err),
7876			Snapshot: snapshot.Bytes(),
7877		}
7878		return err
7879	}
7880
7881	errorBody.Seek(0, io.SeekStart)
7882	return output
7883}
7884
7885func awsAwsjson11_deserializeErrorTargetNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7886	var buff [1024]byte
7887	ringBuffer := smithyio.NewRingBuffer(buff[:])
7888
7889	body := io.TeeReader(errorBody, ringBuffer)
7890	decoder := json.NewDecoder(body)
7891	decoder.UseNumber()
7892	var shape interface{}
7893	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7894		var snapshot bytes.Buffer
7895		io.Copy(&snapshot, ringBuffer)
7896		err = &smithy.DeserializationError{
7897			Err:      fmt.Errorf("failed to decode response body, %w", err),
7898			Snapshot: snapshot.Bytes(),
7899		}
7900		return err
7901	}
7902
7903	output := &types.TargetNotFoundException{}
7904	err := awsAwsjson11_deserializeDocumentTargetNotFoundException(&output, shape)
7905
7906	if err != nil {
7907		var snapshot bytes.Buffer
7908		io.Copy(&snapshot, ringBuffer)
7909		err = &smithy.DeserializationError{
7910			Err:      fmt.Errorf("failed to decode response body, %w", err),
7911			Snapshot: snapshot.Bytes(),
7912		}
7913		return err
7914	}
7915
7916	errorBody.Seek(0, io.SeekStart)
7917	return output
7918}
7919
7920func awsAwsjson11_deserializeErrorTooManyRequestsException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7921	var buff [1024]byte
7922	ringBuffer := smithyio.NewRingBuffer(buff[:])
7923
7924	body := io.TeeReader(errorBody, ringBuffer)
7925	decoder := json.NewDecoder(body)
7926	decoder.UseNumber()
7927	var shape interface{}
7928	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7929		var snapshot bytes.Buffer
7930		io.Copy(&snapshot, ringBuffer)
7931		err = &smithy.DeserializationError{
7932			Err:      fmt.Errorf("failed to decode response body, %w", err),
7933			Snapshot: snapshot.Bytes(),
7934		}
7935		return err
7936	}
7937
7938	output := &types.TooManyRequestsException{}
7939	err := awsAwsjson11_deserializeDocumentTooManyRequestsException(&output, shape)
7940
7941	if err != nil {
7942		var snapshot bytes.Buffer
7943		io.Copy(&snapshot, ringBuffer)
7944		err = &smithy.DeserializationError{
7945			Err:      fmt.Errorf("failed to decode response body, %w", err),
7946			Snapshot: snapshot.Bytes(),
7947		}
7948		return err
7949	}
7950
7951	errorBody.Seek(0, io.SeekStart)
7952	return output
7953}
7954
7955func awsAwsjson11_deserializeErrorUnsupportedAPIEndpointException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
7956	var buff [1024]byte
7957	ringBuffer := smithyio.NewRingBuffer(buff[:])
7958
7959	body := io.TeeReader(errorBody, ringBuffer)
7960	decoder := json.NewDecoder(body)
7961	decoder.UseNumber()
7962	var shape interface{}
7963	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7964		var snapshot bytes.Buffer
7965		io.Copy(&snapshot, ringBuffer)
7966		err = &smithy.DeserializationError{
7967			Err:      fmt.Errorf("failed to decode response body, %w", err),
7968			Snapshot: snapshot.Bytes(),
7969		}
7970		return err
7971	}
7972
7973	output := &types.UnsupportedAPIEndpointException{}
7974	err := awsAwsjson11_deserializeDocumentUnsupportedAPIEndpointException(&output, shape)
7975
7976	if err != nil {
7977		var snapshot bytes.Buffer
7978		io.Copy(&snapshot, ringBuffer)
7979		err = &smithy.DeserializationError{
7980			Err:      fmt.Errorf("failed to decode response body, %w", err),
7981			Snapshot: snapshot.Bytes(),
7982		}
7983		return err
7984	}
7985
7986	errorBody.Seek(0, io.SeekStart)
7987	return output
7988}
7989
7990func awsAwsjson11_deserializeDocumentAccessDeniedException(v **types.AccessDeniedException, value interface{}) error {
7991	if v == nil {
7992		return fmt.Errorf("unexpected nil of type %T", v)
7993	}
7994	if value == nil {
7995		return nil
7996	}
7997
7998	shape, ok := value.(map[string]interface{})
7999	if !ok {
8000		return fmt.Errorf("unexpected JSON type %v", value)
8001	}
8002
8003	var sv *types.AccessDeniedException
8004	if *v == nil {
8005		sv = &types.AccessDeniedException{}
8006	} else {
8007		sv = *v
8008	}
8009
8010	for key, value := range shape {
8011		switch key {
8012		case "Message":
8013			if value != nil {
8014				jtv, ok := value.(string)
8015				if !ok {
8016					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
8017				}
8018				sv.Message = ptr.String(jtv)
8019			}
8020
8021		default:
8022			_, _ = key, value
8023
8024		}
8025	}
8026	*v = sv
8027	return nil
8028}
8029
8030func awsAwsjson11_deserializeDocumentAccessDeniedForDependencyException(v **types.AccessDeniedForDependencyException, value interface{}) error {
8031	if v == nil {
8032		return fmt.Errorf("unexpected nil of type %T", v)
8033	}
8034	if value == nil {
8035		return nil
8036	}
8037
8038	shape, ok := value.(map[string]interface{})
8039	if !ok {
8040		return fmt.Errorf("unexpected JSON type %v", value)
8041	}
8042
8043	var sv *types.AccessDeniedForDependencyException
8044	if *v == nil {
8045		sv = &types.AccessDeniedForDependencyException{}
8046	} else {
8047		sv = *v
8048	}
8049
8050	for key, value := range shape {
8051		switch key {
8052		case "Message":
8053			if value != nil {
8054				jtv, ok := value.(string)
8055				if !ok {
8056					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
8057				}
8058				sv.Message = ptr.String(jtv)
8059			}
8060
8061		case "Reason":
8062			if value != nil {
8063				jtv, ok := value.(string)
8064				if !ok {
8065					return fmt.Errorf("expected AccessDeniedForDependencyExceptionReason to be of type string, got %T instead", value)
8066				}
8067				sv.Reason = types.AccessDeniedForDependencyExceptionReason(jtv)
8068			}
8069
8070		default:
8071			_, _ = key, value
8072
8073		}
8074	}
8075	*v = sv
8076	return nil
8077}
8078
8079func awsAwsjson11_deserializeDocumentAccount(v **types.Account, value interface{}) error {
8080	if v == nil {
8081		return fmt.Errorf("unexpected nil of type %T", v)
8082	}
8083	if value == nil {
8084		return nil
8085	}
8086
8087	shape, ok := value.(map[string]interface{})
8088	if !ok {
8089		return fmt.Errorf("unexpected JSON type %v", value)
8090	}
8091
8092	var sv *types.Account
8093	if *v == nil {
8094		sv = &types.Account{}
8095	} else {
8096		sv = *v
8097	}
8098
8099	for key, value := range shape {
8100		switch key {
8101		case "Arn":
8102			if value != nil {
8103				jtv, ok := value.(string)
8104				if !ok {
8105					return fmt.Errorf("expected AccountArn to be of type string, got %T instead", value)
8106				}
8107				sv.Arn = ptr.String(jtv)
8108			}
8109
8110		case "Email":
8111			if value != nil {
8112				jtv, ok := value.(string)
8113				if !ok {
8114					return fmt.Errorf("expected Email to be of type string, got %T instead", value)
8115				}
8116				sv.Email = ptr.String(jtv)
8117			}
8118
8119		case "Id":
8120			if value != nil {
8121				jtv, ok := value.(string)
8122				if !ok {
8123					return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
8124				}
8125				sv.Id = ptr.String(jtv)
8126			}
8127
8128		case "JoinedMethod":
8129			if value != nil {
8130				jtv, ok := value.(string)
8131				if !ok {
8132					return fmt.Errorf("expected AccountJoinedMethod to be of type string, got %T instead", value)
8133				}
8134				sv.JoinedMethod = types.AccountJoinedMethod(jtv)
8135			}
8136
8137		case "JoinedTimestamp":
8138			if value != nil {
8139				jtv, ok := value.(json.Number)
8140				if !ok {
8141					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
8142				}
8143				f64, err := jtv.Float64()
8144				if err != nil {
8145					return err
8146				}
8147				sv.JoinedTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64))
8148			}
8149
8150		case "Name":
8151			if value != nil {
8152				jtv, ok := value.(string)
8153				if !ok {
8154					return fmt.Errorf("expected AccountName to be of type string, got %T instead", value)
8155				}
8156				sv.Name = ptr.String(jtv)
8157			}
8158
8159		case "Status":
8160			if value != nil {
8161				jtv, ok := value.(string)
8162				if !ok {
8163					return fmt.Errorf("expected AccountStatus to be of type string, got %T instead", value)
8164				}
8165				sv.Status = types.AccountStatus(jtv)
8166			}
8167
8168		default:
8169			_, _ = key, value
8170
8171		}
8172	}
8173	*v = sv
8174	return nil
8175}
8176
8177func awsAwsjson11_deserializeDocumentAccountAlreadyRegisteredException(v **types.AccountAlreadyRegisteredException, value interface{}) error {
8178	if v == nil {
8179		return fmt.Errorf("unexpected nil of type %T", v)
8180	}
8181	if value == nil {
8182		return nil
8183	}
8184
8185	shape, ok := value.(map[string]interface{})
8186	if !ok {
8187		return fmt.Errorf("unexpected JSON type %v", value)
8188	}
8189
8190	var sv *types.AccountAlreadyRegisteredException
8191	if *v == nil {
8192		sv = &types.AccountAlreadyRegisteredException{}
8193	} else {
8194		sv = *v
8195	}
8196
8197	for key, value := range shape {
8198		switch key {
8199		case "Message":
8200			if value != nil {
8201				jtv, ok := value.(string)
8202				if !ok {
8203					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
8204				}
8205				sv.Message = ptr.String(jtv)
8206			}
8207
8208		default:
8209			_, _ = key, value
8210
8211		}
8212	}
8213	*v = sv
8214	return nil
8215}
8216
8217func awsAwsjson11_deserializeDocumentAccountNotFoundException(v **types.AccountNotFoundException, value interface{}) error {
8218	if v == nil {
8219		return fmt.Errorf("unexpected nil of type %T", v)
8220	}
8221	if value == nil {
8222		return nil
8223	}
8224
8225	shape, ok := value.(map[string]interface{})
8226	if !ok {
8227		return fmt.Errorf("unexpected JSON type %v", value)
8228	}
8229
8230	var sv *types.AccountNotFoundException
8231	if *v == nil {
8232		sv = &types.AccountNotFoundException{}
8233	} else {
8234		sv = *v
8235	}
8236
8237	for key, value := range shape {
8238		switch key {
8239		case "Message":
8240			if value != nil {
8241				jtv, ok := value.(string)
8242				if !ok {
8243					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
8244				}
8245				sv.Message = ptr.String(jtv)
8246			}
8247
8248		default:
8249			_, _ = key, value
8250
8251		}
8252	}
8253	*v = sv
8254	return nil
8255}
8256
8257func awsAwsjson11_deserializeDocumentAccountNotRegisteredException(v **types.AccountNotRegisteredException, value interface{}) error {
8258	if v == nil {
8259		return fmt.Errorf("unexpected nil of type %T", v)
8260	}
8261	if value == nil {
8262		return nil
8263	}
8264
8265	shape, ok := value.(map[string]interface{})
8266	if !ok {
8267		return fmt.Errorf("unexpected JSON type %v", value)
8268	}
8269
8270	var sv *types.AccountNotRegisteredException
8271	if *v == nil {
8272		sv = &types.AccountNotRegisteredException{}
8273	} else {
8274		sv = *v
8275	}
8276
8277	for key, value := range shape {
8278		switch key {
8279		case "Message":
8280			if value != nil {
8281				jtv, ok := value.(string)
8282				if !ok {
8283					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
8284				}
8285				sv.Message = ptr.String(jtv)
8286			}
8287
8288		default:
8289			_, _ = key, value
8290
8291		}
8292	}
8293	*v = sv
8294	return nil
8295}
8296
8297func awsAwsjson11_deserializeDocumentAccountOwnerNotVerifiedException(v **types.AccountOwnerNotVerifiedException, value interface{}) error {
8298	if v == nil {
8299		return fmt.Errorf("unexpected nil of type %T", v)
8300	}
8301	if value == nil {
8302		return nil
8303	}
8304
8305	shape, ok := value.(map[string]interface{})
8306	if !ok {
8307		return fmt.Errorf("unexpected JSON type %v", value)
8308	}
8309
8310	var sv *types.AccountOwnerNotVerifiedException
8311	if *v == nil {
8312		sv = &types.AccountOwnerNotVerifiedException{}
8313	} else {
8314		sv = *v
8315	}
8316
8317	for key, value := range shape {
8318		switch key {
8319		case "Message":
8320			if value != nil {
8321				jtv, ok := value.(string)
8322				if !ok {
8323					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
8324				}
8325				sv.Message = ptr.String(jtv)
8326			}
8327
8328		default:
8329			_, _ = key, value
8330
8331		}
8332	}
8333	*v = sv
8334	return nil
8335}
8336
8337func awsAwsjson11_deserializeDocumentAccounts(v *[]types.Account, value interface{}) error {
8338	if v == nil {
8339		return fmt.Errorf("unexpected nil of type %T", v)
8340	}
8341	if value == nil {
8342		return nil
8343	}
8344
8345	shape, ok := value.([]interface{})
8346	if !ok {
8347		return fmt.Errorf("unexpected JSON type %v", value)
8348	}
8349
8350	var cv []types.Account
8351	if *v == nil {
8352		cv = []types.Account{}
8353	} else {
8354		cv = *v
8355	}
8356
8357	for _, value := range shape {
8358		var col types.Account
8359		destAddr := &col
8360		if err := awsAwsjson11_deserializeDocumentAccount(&destAddr, value); err != nil {
8361			return err
8362		}
8363		col = *destAddr
8364		cv = append(cv, col)
8365
8366	}
8367	*v = cv
8368	return nil
8369}
8370
8371func awsAwsjson11_deserializeDocumentAlreadyInOrganizationException(v **types.AlreadyInOrganizationException, value interface{}) error {
8372	if v == nil {
8373		return fmt.Errorf("unexpected nil of type %T", v)
8374	}
8375	if value == nil {
8376		return nil
8377	}
8378
8379	shape, ok := value.(map[string]interface{})
8380	if !ok {
8381		return fmt.Errorf("unexpected JSON type %v", value)
8382	}
8383
8384	var sv *types.AlreadyInOrganizationException
8385	if *v == nil {
8386		sv = &types.AlreadyInOrganizationException{}
8387	} else {
8388		sv = *v
8389	}
8390
8391	for key, value := range shape {
8392		switch key {
8393		case "Message":
8394			if value != nil {
8395				jtv, ok := value.(string)
8396				if !ok {
8397					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
8398				}
8399				sv.Message = ptr.String(jtv)
8400			}
8401
8402		default:
8403			_, _ = key, value
8404
8405		}
8406	}
8407	*v = sv
8408	return nil
8409}
8410
8411func awsAwsjson11_deserializeDocumentAWSOrganizationsNotInUseException(v **types.AWSOrganizationsNotInUseException, value interface{}) error {
8412	if v == nil {
8413		return fmt.Errorf("unexpected nil of type %T", v)
8414	}
8415	if value == nil {
8416		return nil
8417	}
8418
8419	shape, ok := value.(map[string]interface{})
8420	if !ok {
8421		return fmt.Errorf("unexpected JSON type %v", value)
8422	}
8423
8424	var sv *types.AWSOrganizationsNotInUseException
8425	if *v == nil {
8426		sv = &types.AWSOrganizationsNotInUseException{}
8427	} else {
8428		sv = *v
8429	}
8430
8431	for key, value := range shape {
8432		switch key {
8433		case "Message":
8434			if value != nil {
8435				jtv, ok := value.(string)
8436				if !ok {
8437					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
8438				}
8439				sv.Message = ptr.String(jtv)
8440			}
8441
8442		default:
8443			_, _ = key, value
8444
8445		}
8446	}
8447	*v = sv
8448	return nil
8449}
8450
8451func awsAwsjson11_deserializeDocumentChild(v **types.Child, value interface{}) error {
8452	if v == nil {
8453		return fmt.Errorf("unexpected nil of type %T", v)
8454	}
8455	if value == nil {
8456		return nil
8457	}
8458
8459	shape, ok := value.(map[string]interface{})
8460	if !ok {
8461		return fmt.Errorf("unexpected JSON type %v", value)
8462	}
8463
8464	var sv *types.Child
8465	if *v == nil {
8466		sv = &types.Child{}
8467	} else {
8468		sv = *v
8469	}
8470
8471	for key, value := range shape {
8472		switch key {
8473		case "Id":
8474			if value != nil {
8475				jtv, ok := value.(string)
8476				if !ok {
8477					return fmt.Errorf("expected ChildId to be of type string, got %T instead", value)
8478				}
8479				sv.Id = ptr.String(jtv)
8480			}
8481
8482		case "Type":
8483			if value != nil {
8484				jtv, ok := value.(string)
8485				if !ok {
8486					return fmt.Errorf("expected ChildType to be of type string, got %T instead", value)
8487				}
8488				sv.Type = types.ChildType(jtv)
8489			}
8490
8491		default:
8492			_, _ = key, value
8493
8494		}
8495	}
8496	*v = sv
8497	return nil
8498}
8499
8500func awsAwsjson11_deserializeDocumentChildNotFoundException(v **types.ChildNotFoundException, value interface{}) error {
8501	if v == nil {
8502		return fmt.Errorf("unexpected nil of type %T", v)
8503	}
8504	if value == nil {
8505		return nil
8506	}
8507
8508	shape, ok := value.(map[string]interface{})
8509	if !ok {
8510		return fmt.Errorf("unexpected JSON type %v", value)
8511	}
8512
8513	var sv *types.ChildNotFoundException
8514	if *v == nil {
8515		sv = &types.ChildNotFoundException{}
8516	} else {
8517		sv = *v
8518	}
8519
8520	for key, value := range shape {
8521		switch key {
8522		case "Message":
8523			if value != nil {
8524				jtv, ok := value.(string)
8525				if !ok {
8526					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
8527				}
8528				sv.Message = ptr.String(jtv)
8529			}
8530
8531		default:
8532			_, _ = key, value
8533
8534		}
8535	}
8536	*v = sv
8537	return nil
8538}
8539
8540func awsAwsjson11_deserializeDocumentChildren(v *[]types.Child, value interface{}) error {
8541	if v == nil {
8542		return fmt.Errorf("unexpected nil of type %T", v)
8543	}
8544	if value == nil {
8545		return nil
8546	}
8547
8548	shape, ok := value.([]interface{})
8549	if !ok {
8550		return fmt.Errorf("unexpected JSON type %v", value)
8551	}
8552
8553	var cv []types.Child
8554	if *v == nil {
8555		cv = []types.Child{}
8556	} else {
8557		cv = *v
8558	}
8559
8560	for _, value := range shape {
8561		var col types.Child
8562		destAddr := &col
8563		if err := awsAwsjson11_deserializeDocumentChild(&destAddr, value); err != nil {
8564			return err
8565		}
8566		col = *destAddr
8567		cv = append(cv, col)
8568
8569	}
8570	*v = cv
8571	return nil
8572}
8573
8574func awsAwsjson11_deserializeDocumentConcurrentModificationException(v **types.ConcurrentModificationException, value interface{}) error {
8575	if v == nil {
8576		return fmt.Errorf("unexpected nil of type %T", v)
8577	}
8578	if value == nil {
8579		return nil
8580	}
8581
8582	shape, ok := value.(map[string]interface{})
8583	if !ok {
8584		return fmt.Errorf("unexpected JSON type %v", value)
8585	}
8586
8587	var sv *types.ConcurrentModificationException
8588	if *v == nil {
8589		sv = &types.ConcurrentModificationException{}
8590	} else {
8591		sv = *v
8592	}
8593
8594	for key, value := range shape {
8595		switch key {
8596		case "Message":
8597			if value != nil {
8598				jtv, ok := value.(string)
8599				if !ok {
8600					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
8601				}
8602				sv.Message = ptr.String(jtv)
8603			}
8604
8605		default:
8606			_, _ = key, value
8607
8608		}
8609	}
8610	*v = sv
8611	return nil
8612}
8613
8614func awsAwsjson11_deserializeDocumentConstraintViolationException(v **types.ConstraintViolationException, value interface{}) error {
8615	if v == nil {
8616		return fmt.Errorf("unexpected nil of type %T", v)
8617	}
8618	if value == nil {
8619		return nil
8620	}
8621
8622	shape, ok := value.(map[string]interface{})
8623	if !ok {
8624		return fmt.Errorf("unexpected JSON type %v", value)
8625	}
8626
8627	var sv *types.ConstraintViolationException
8628	if *v == nil {
8629		sv = &types.ConstraintViolationException{}
8630	} else {
8631		sv = *v
8632	}
8633
8634	for key, value := range shape {
8635		switch key {
8636		case "Message":
8637			if value != nil {
8638				jtv, ok := value.(string)
8639				if !ok {
8640					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
8641				}
8642				sv.Message = ptr.String(jtv)
8643			}
8644
8645		case "Reason":
8646			if value != nil {
8647				jtv, ok := value.(string)
8648				if !ok {
8649					return fmt.Errorf("expected ConstraintViolationExceptionReason to be of type string, got %T instead", value)
8650				}
8651				sv.Reason = types.ConstraintViolationExceptionReason(jtv)
8652			}
8653
8654		default:
8655			_, _ = key, value
8656
8657		}
8658	}
8659	*v = sv
8660	return nil
8661}
8662
8663func awsAwsjson11_deserializeDocumentCreateAccountStatus(v **types.CreateAccountStatus, value interface{}) error {
8664	if v == nil {
8665		return fmt.Errorf("unexpected nil of type %T", v)
8666	}
8667	if value == nil {
8668		return nil
8669	}
8670
8671	shape, ok := value.(map[string]interface{})
8672	if !ok {
8673		return fmt.Errorf("unexpected JSON type %v", value)
8674	}
8675
8676	var sv *types.CreateAccountStatus
8677	if *v == nil {
8678		sv = &types.CreateAccountStatus{}
8679	} else {
8680		sv = *v
8681	}
8682
8683	for key, value := range shape {
8684		switch key {
8685		case "AccountId":
8686			if value != nil {
8687				jtv, ok := value.(string)
8688				if !ok {
8689					return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
8690				}
8691				sv.AccountId = ptr.String(jtv)
8692			}
8693
8694		case "AccountName":
8695			if value != nil {
8696				jtv, ok := value.(string)
8697				if !ok {
8698					return fmt.Errorf("expected AccountName to be of type string, got %T instead", value)
8699				}
8700				sv.AccountName = ptr.String(jtv)
8701			}
8702
8703		case "CompletedTimestamp":
8704			if value != nil {
8705				jtv, ok := value.(json.Number)
8706				if !ok {
8707					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
8708				}
8709				f64, err := jtv.Float64()
8710				if err != nil {
8711					return err
8712				}
8713				sv.CompletedTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64))
8714			}
8715
8716		case "FailureReason":
8717			if value != nil {
8718				jtv, ok := value.(string)
8719				if !ok {
8720					return fmt.Errorf("expected CreateAccountFailureReason to be of type string, got %T instead", value)
8721				}
8722				sv.FailureReason = types.CreateAccountFailureReason(jtv)
8723			}
8724
8725		case "GovCloudAccountId":
8726			if value != nil {
8727				jtv, ok := value.(string)
8728				if !ok {
8729					return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
8730				}
8731				sv.GovCloudAccountId = ptr.String(jtv)
8732			}
8733
8734		case "Id":
8735			if value != nil {
8736				jtv, ok := value.(string)
8737				if !ok {
8738					return fmt.Errorf("expected CreateAccountRequestId to be of type string, got %T instead", value)
8739				}
8740				sv.Id = ptr.String(jtv)
8741			}
8742
8743		case "RequestedTimestamp":
8744			if value != nil {
8745				jtv, ok := value.(json.Number)
8746				if !ok {
8747					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
8748				}
8749				f64, err := jtv.Float64()
8750				if err != nil {
8751					return err
8752				}
8753				sv.RequestedTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64))
8754			}
8755
8756		case "State":
8757			if value != nil {
8758				jtv, ok := value.(string)
8759				if !ok {
8760					return fmt.Errorf("expected CreateAccountState to be of type string, got %T instead", value)
8761				}
8762				sv.State = types.CreateAccountState(jtv)
8763			}
8764
8765		default:
8766			_, _ = key, value
8767
8768		}
8769	}
8770	*v = sv
8771	return nil
8772}
8773
8774func awsAwsjson11_deserializeDocumentCreateAccountStatuses(v *[]types.CreateAccountStatus, value interface{}) error {
8775	if v == nil {
8776		return fmt.Errorf("unexpected nil of type %T", v)
8777	}
8778	if value == nil {
8779		return nil
8780	}
8781
8782	shape, ok := value.([]interface{})
8783	if !ok {
8784		return fmt.Errorf("unexpected JSON type %v", value)
8785	}
8786
8787	var cv []types.CreateAccountStatus
8788	if *v == nil {
8789		cv = []types.CreateAccountStatus{}
8790	} else {
8791		cv = *v
8792	}
8793
8794	for _, value := range shape {
8795		var col types.CreateAccountStatus
8796		destAddr := &col
8797		if err := awsAwsjson11_deserializeDocumentCreateAccountStatus(&destAddr, value); err != nil {
8798			return err
8799		}
8800		col = *destAddr
8801		cv = append(cv, col)
8802
8803	}
8804	*v = cv
8805	return nil
8806}
8807
8808func awsAwsjson11_deserializeDocumentCreateAccountStatusNotFoundException(v **types.CreateAccountStatusNotFoundException, value interface{}) error {
8809	if v == nil {
8810		return fmt.Errorf("unexpected nil of type %T", v)
8811	}
8812	if value == nil {
8813		return nil
8814	}
8815
8816	shape, ok := value.(map[string]interface{})
8817	if !ok {
8818		return fmt.Errorf("unexpected JSON type %v", value)
8819	}
8820
8821	var sv *types.CreateAccountStatusNotFoundException
8822	if *v == nil {
8823		sv = &types.CreateAccountStatusNotFoundException{}
8824	} else {
8825		sv = *v
8826	}
8827
8828	for key, value := range shape {
8829		switch key {
8830		case "Message":
8831			if value != nil {
8832				jtv, ok := value.(string)
8833				if !ok {
8834					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
8835				}
8836				sv.Message = ptr.String(jtv)
8837			}
8838
8839		default:
8840			_, _ = key, value
8841
8842		}
8843	}
8844	*v = sv
8845	return nil
8846}
8847
8848func awsAwsjson11_deserializeDocumentDelegatedAdministrator(v **types.DelegatedAdministrator, value interface{}) error {
8849	if v == nil {
8850		return fmt.Errorf("unexpected nil of type %T", v)
8851	}
8852	if value == nil {
8853		return nil
8854	}
8855
8856	shape, ok := value.(map[string]interface{})
8857	if !ok {
8858		return fmt.Errorf("unexpected JSON type %v", value)
8859	}
8860
8861	var sv *types.DelegatedAdministrator
8862	if *v == nil {
8863		sv = &types.DelegatedAdministrator{}
8864	} else {
8865		sv = *v
8866	}
8867
8868	for key, value := range shape {
8869		switch key {
8870		case "Arn":
8871			if value != nil {
8872				jtv, ok := value.(string)
8873				if !ok {
8874					return fmt.Errorf("expected AccountArn to be of type string, got %T instead", value)
8875				}
8876				sv.Arn = ptr.String(jtv)
8877			}
8878
8879		case "DelegationEnabledDate":
8880			if value != nil {
8881				jtv, ok := value.(json.Number)
8882				if !ok {
8883					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
8884				}
8885				f64, err := jtv.Float64()
8886				if err != nil {
8887					return err
8888				}
8889				sv.DelegationEnabledDate = ptr.Time(smithytime.ParseEpochSeconds(f64))
8890			}
8891
8892		case "Email":
8893			if value != nil {
8894				jtv, ok := value.(string)
8895				if !ok {
8896					return fmt.Errorf("expected Email to be of type string, got %T instead", value)
8897				}
8898				sv.Email = ptr.String(jtv)
8899			}
8900
8901		case "Id":
8902			if value != nil {
8903				jtv, ok := value.(string)
8904				if !ok {
8905					return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
8906				}
8907				sv.Id = ptr.String(jtv)
8908			}
8909
8910		case "JoinedMethod":
8911			if value != nil {
8912				jtv, ok := value.(string)
8913				if !ok {
8914					return fmt.Errorf("expected AccountJoinedMethod to be of type string, got %T instead", value)
8915				}
8916				sv.JoinedMethod = types.AccountJoinedMethod(jtv)
8917			}
8918
8919		case "JoinedTimestamp":
8920			if value != nil {
8921				jtv, ok := value.(json.Number)
8922				if !ok {
8923					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
8924				}
8925				f64, err := jtv.Float64()
8926				if err != nil {
8927					return err
8928				}
8929				sv.JoinedTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64))
8930			}
8931
8932		case "Name":
8933			if value != nil {
8934				jtv, ok := value.(string)
8935				if !ok {
8936					return fmt.Errorf("expected AccountName to be of type string, got %T instead", value)
8937				}
8938				sv.Name = ptr.String(jtv)
8939			}
8940
8941		case "Status":
8942			if value != nil {
8943				jtv, ok := value.(string)
8944				if !ok {
8945					return fmt.Errorf("expected AccountStatus to be of type string, got %T instead", value)
8946				}
8947				sv.Status = types.AccountStatus(jtv)
8948			}
8949
8950		default:
8951			_, _ = key, value
8952
8953		}
8954	}
8955	*v = sv
8956	return nil
8957}
8958
8959func awsAwsjson11_deserializeDocumentDelegatedAdministrators(v *[]types.DelegatedAdministrator, value interface{}) error {
8960	if v == nil {
8961		return fmt.Errorf("unexpected nil of type %T", v)
8962	}
8963	if value == nil {
8964		return nil
8965	}
8966
8967	shape, ok := value.([]interface{})
8968	if !ok {
8969		return fmt.Errorf("unexpected JSON type %v", value)
8970	}
8971
8972	var cv []types.DelegatedAdministrator
8973	if *v == nil {
8974		cv = []types.DelegatedAdministrator{}
8975	} else {
8976		cv = *v
8977	}
8978
8979	for _, value := range shape {
8980		var col types.DelegatedAdministrator
8981		destAddr := &col
8982		if err := awsAwsjson11_deserializeDocumentDelegatedAdministrator(&destAddr, value); err != nil {
8983			return err
8984		}
8985		col = *destAddr
8986		cv = append(cv, col)
8987
8988	}
8989	*v = cv
8990	return nil
8991}
8992
8993func awsAwsjson11_deserializeDocumentDelegatedService(v **types.DelegatedService, value interface{}) error {
8994	if v == nil {
8995		return fmt.Errorf("unexpected nil of type %T", v)
8996	}
8997	if value == nil {
8998		return nil
8999	}
9000
9001	shape, ok := value.(map[string]interface{})
9002	if !ok {
9003		return fmt.Errorf("unexpected JSON type %v", value)
9004	}
9005
9006	var sv *types.DelegatedService
9007	if *v == nil {
9008		sv = &types.DelegatedService{}
9009	} else {
9010		sv = *v
9011	}
9012
9013	for key, value := range shape {
9014		switch key {
9015		case "DelegationEnabledDate":
9016			if value != nil {
9017				jtv, ok := value.(json.Number)
9018				if !ok {
9019					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
9020				}
9021				f64, err := jtv.Float64()
9022				if err != nil {
9023					return err
9024				}
9025				sv.DelegationEnabledDate = ptr.Time(smithytime.ParseEpochSeconds(f64))
9026			}
9027
9028		case "ServicePrincipal":
9029			if value != nil {
9030				jtv, ok := value.(string)
9031				if !ok {
9032					return fmt.Errorf("expected ServicePrincipal to be of type string, got %T instead", value)
9033				}
9034				sv.ServicePrincipal = ptr.String(jtv)
9035			}
9036
9037		default:
9038			_, _ = key, value
9039
9040		}
9041	}
9042	*v = sv
9043	return nil
9044}
9045
9046func awsAwsjson11_deserializeDocumentDelegatedServices(v *[]types.DelegatedService, value interface{}) error {
9047	if v == nil {
9048		return fmt.Errorf("unexpected nil of type %T", v)
9049	}
9050	if value == nil {
9051		return nil
9052	}
9053
9054	shape, ok := value.([]interface{})
9055	if !ok {
9056		return fmt.Errorf("unexpected JSON type %v", value)
9057	}
9058
9059	var cv []types.DelegatedService
9060	if *v == nil {
9061		cv = []types.DelegatedService{}
9062	} else {
9063		cv = *v
9064	}
9065
9066	for _, value := range shape {
9067		var col types.DelegatedService
9068		destAddr := &col
9069		if err := awsAwsjson11_deserializeDocumentDelegatedService(&destAddr, value); err != nil {
9070			return err
9071		}
9072		col = *destAddr
9073		cv = append(cv, col)
9074
9075	}
9076	*v = cv
9077	return nil
9078}
9079
9080func awsAwsjson11_deserializeDocumentDestinationParentNotFoundException(v **types.DestinationParentNotFoundException, value interface{}) error {
9081	if v == nil {
9082		return fmt.Errorf("unexpected nil of type %T", v)
9083	}
9084	if value == nil {
9085		return nil
9086	}
9087
9088	shape, ok := value.(map[string]interface{})
9089	if !ok {
9090		return fmt.Errorf("unexpected JSON type %v", value)
9091	}
9092
9093	var sv *types.DestinationParentNotFoundException
9094	if *v == nil {
9095		sv = &types.DestinationParentNotFoundException{}
9096	} else {
9097		sv = *v
9098	}
9099
9100	for key, value := range shape {
9101		switch key {
9102		case "Message":
9103			if value != nil {
9104				jtv, ok := value.(string)
9105				if !ok {
9106					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
9107				}
9108				sv.Message = ptr.String(jtv)
9109			}
9110
9111		default:
9112			_, _ = key, value
9113
9114		}
9115	}
9116	*v = sv
9117	return nil
9118}
9119
9120func awsAwsjson11_deserializeDocumentDuplicateAccountException(v **types.DuplicateAccountException, value interface{}) error {
9121	if v == nil {
9122		return fmt.Errorf("unexpected nil of type %T", v)
9123	}
9124	if value == nil {
9125		return nil
9126	}
9127
9128	shape, ok := value.(map[string]interface{})
9129	if !ok {
9130		return fmt.Errorf("unexpected JSON type %v", value)
9131	}
9132
9133	var sv *types.DuplicateAccountException
9134	if *v == nil {
9135		sv = &types.DuplicateAccountException{}
9136	} else {
9137		sv = *v
9138	}
9139
9140	for key, value := range shape {
9141		switch key {
9142		case "Message":
9143			if value != nil {
9144				jtv, ok := value.(string)
9145				if !ok {
9146					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
9147				}
9148				sv.Message = ptr.String(jtv)
9149			}
9150
9151		default:
9152			_, _ = key, value
9153
9154		}
9155	}
9156	*v = sv
9157	return nil
9158}
9159
9160func awsAwsjson11_deserializeDocumentDuplicateHandshakeException(v **types.DuplicateHandshakeException, value interface{}) error {
9161	if v == nil {
9162		return fmt.Errorf("unexpected nil of type %T", v)
9163	}
9164	if value == nil {
9165		return nil
9166	}
9167
9168	shape, ok := value.(map[string]interface{})
9169	if !ok {
9170		return fmt.Errorf("unexpected JSON type %v", value)
9171	}
9172
9173	var sv *types.DuplicateHandshakeException
9174	if *v == nil {
9175		sv = &types.DuplicateHandshakeException{}
9176	} else {
9177		sv = *v
9178	}
9179
9180	for key, value := range shape {
9181		switch key {
9182		case "Message":
9183			if value != nil {
9184				jtv, ok := value.(string)
9185				if !ok {
9186					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
9187				}
9188				sv.Message = ptr.String(jtv)
9189			}
9190
9191		default:
9192			_, _ = key, value
9193
9194		}
9195	}
9196	*v = sv
9197	return nil
9198}
9199
9200func awsAwsjson11_deserializeDocumentDuplicateOrganizationalUnitException(v **types.DuplicateOrganizationalUnitException, value interface{}) error {
9201	if v == nil {
9202		return fmt.Errorf("unexpected nil of type %T", v)
9203	}
9204	if value == nil {
9205		return nil
9206	}
9207
9208	shape, ok := value.(map[string]interface{})
9209	if !ok {
9210		return fmt.Errorf("unexpected JSON type %v", value)
9211	}
9212
9213	var sv *types.DuplicateOrganizationalUnitException
9214	if *v == nil {
9215		sv = &types.DuplicateOrganizationalUnitException{}
9216	} else {
9217		sv = *v
9218	}
9219
9220	for key, value := range shape {
9221		switch key {
9222		case "Message":
9223			if value != nil {
9224				jtv, ok := value.(string)
9225				if !ok {
9226					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
9227				}
9228				sv.Message = ptr.String(jtv)
9229			}
9230
9231		default:
9232			_, _ = key, value
9233
9234		}
9235	}
9236	*v = sv
9237	return nil
9238}
9239
9240func awsAwsjson11_deserializeDocumentDuplicatePolicyAttachmentException(v **types.DuplicatePolicyAttachmentException, value interface{}) error {
9241	if v == nil {
9242		return fmt.Errorf("unexpected nil of type %T", v)
9243	}
9244	if value == nil {
9245		return nil
9246	}
9247
9248	shape, ok := value.(map[string]interface{})
9249	if !ok {
9250		return fmt.Errorf("unexpected JSON type %v", value)
9251	}
9252
9253	var sv *types.DuplicatePolicyAttachmentException
9254	if *v == nil {
9255		sv = &types.DuplicatePolicyAttachmentException{}
9256	} else {
9257		sv = *v
9258	}
9259
9260	for key, value := range shape {
9261		switch key {
9262		case "Message":
9263			if value != nil {
9264				jtv, ok := value.(string)
9265				if !ok {
9266					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
9267				}
9268				sv.Message = ptr.String(jtv)
9269			}
9270
9271		default:
9272			_, _ = key, value
9273
9274		}
9275	}
9276	*v = sv
9277	return nil
9278}
9279
9280func awsAwsjson11_deserializeDocumentDuplicatePolicyException(v **types.DuplicatePolicyException, value interface{}) error {
9281	if v == nil {
9282		return fmt.Errorf("unexpected nil of type %T", v)
9283	}
9284	if value == nil {
9285		return nil
9286	}
9287
9288	shape, ok := value.(map[string]interface{})
9289	if !ok {
9290		return fmt.Errorf("unexpected JSON type %v", value)
9291	}
9292
9293	var sv *types.DuplicatePolicyException
9294	if *v == nil {
9295		sv = &types.DuplicatePolicyException{}
9296	} else {
9297		sv = *v
9298	}
9299
9300	for key, value := range shape {
9301		switch key {
9302		case "Message":
9303			if value != nil {
9304				jtv, ok := value.(string)
9305				if !ok {
9306					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
9307				}
9308				sv.Message = ptr.String(jtv)
9309			}
9310
9311		default:
9312			_, _ = key, value
9313
9314		}
9315	}
9316	*v = sv
9317	return nil
9318}
9319
9320func awsAwsjson11_deserializeDocumentEffectivePolicy(v **types.EffectivePolicy, value interface{}) error {
9321	if v == nil {
9322		return fmt.Errorf("unexpected nil of type %T", v)
9323	}
9324	if value == nil {
9325		return nil
9326	}
9327
9328	shape, ok := value.(map[string]interface{})
9329	if !ok {
9330		return fmt.Errorf("unexpected JSON type %v", value)
9331	}
9332
9333	var sv *types.EffectivePolicy
9334	if *v == nil {
9335		sv = &types.EffectivePolicy{}
9336	} else {
9337		sv = *v
9338	}
9339
9340	for key, value := range shape {
9341		switch key {
9342		case "LastUpdatedTimestamp":
9343			if value != nil {
9344				jtv, ok := value.(json.Number)
9345				if !ok {
9346					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
9347				}
9348				f64, err := jtv.Float64()
9349				if err != nil {
9350					return err
9351				}
9352				sv.LastUpdatedTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64))
9353			}
9354
9355		case "PolicyContent":
9356			if value != nil {
9357				jtv, ok := value.(string)
9358				if !ok {
9359					return fmt.Errorf("expected PolicyContent to be of type string, got %T instead", value)
9360				}
9361				sv.PolicyContent = ptr.String(jtv)
9362			}
9363
9364		case "PolicyType":
9365			if value != nil {
9366				jtv, ok := value.(string)
9367				if !ok {
9368					return fmt.Errorf("expected EffectivePolicyType to be of type string, got %T instead", value)
9369				}
9370				sv.PolicyType = types.EffectivePolicyType(jtv)
9371			}
9372
9373		case "TargetId":
9374			if value != nil {
9375				jtv, ok := value.(string)
9376				if !ok {
9377					return fmt.Errorf("expected PolicyTargetId to be of type string, got %T instead", value)
9378				}
9379				sv.TargetId = ptr.String(jtv)
9380			}
9381
9382		default:
9383			_, _ = key, value
9384
9385		}
9386	}
9387	*v = sv
9388	return nil
9389}
9390
9391func awsAwsjson11_deserializeDocumentEffectivePolicyNotFoundException(v **types.EffectivePolicyNotFoundException, value interface{}) error {
9392	if v == nil {
9393		return fmt.Errorf("unexpected nil of type %T", v)
9394	}
9395	if value == nil {
9396		return nil
9397	}
9398
9399	shape, ok := value.(map[string]interface{})
9400	if !ok {
9401		return fmt.Errorf("unexpected JSON type %v", value)
9402	}
9403
9404	var sv *types.EffectivePolicyNotFoundException
9405	if *v == nil {
9406		sv = &types.EffectivePolicyNotFoundException{}
9407	} else {
9408		sv = *v
9409	}
9410
9411	for key, value := range shape {
9412		switch key {
9413		case "Message":
9414			if value != nil {
9415				jtv, ok := value.(string)
9416				if !ok {
9417					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
9418				}
9419				sv.Message = ptr.String(jtv)
9420			}
9421
9422		default:
9423			_, _ = key, value
9424
9425		}
9426	}
9427	*v = sv
9428	return nil
9429}
9430
9431func awsAwsjson11_deserializeDocumentEnabledServicePrincipal(v **types.EnabledServicePrincipal, value interface{}) error {
9432	if v == nil {
9433		return fmt.Errorf("unexpected nil of type %T", v)
9434	}
9435	if value == nil {
9436		return nil
9437	}
9438
9439	shape, ok := value.(map[string]interface{})
9440	if !ok {
9441		return fmt.Errorf("unexpected JSON type %v", value)
9442	}
9443
9444	var sv *types.EnabledServicePrincipal
9445	if *v == nil {
9446		sv = &types.EnabledServicePrincipal{}
9447	} else {
9448		sv = *v
9449	}
9450
9451	for key, value := range shape {
9452		switch key {
9453		case "DateEnabled":
9454			if value != nil {
9455				jtv, ok := value.(json.Number)
9456				if !ok {
9457					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
9458				}
9459				f64, err := jtv.Float64()
9460				if err != nil {
9461					return err
9462				}
9463				sv.DateEnabled = ptr.Time(smithytime.ParseEpochSeconds(f64))
9464			}
9465
9466		case "ServicePrincipal":
9467			if value != nil {
9468				jtv, ok := value.(string)
9469				if !ok {
9470					return fmt.Errorf("expected ServicePrincipal to be of type string, got %T instead", value)
9471				}
9472				sv.ServicePrincipal = ptr.String(jtv)
9473			}
9474
9475		default:
9476			_, _ = key, value
9477
9478		}
9479	}
9480	*v = sv
9481	return nil
9482}
9483
9484func awsAwsjson11_deserializeDocumentEnabledServicePrincipals(v *[]types.EnabledServicePrincipal, value interface{}) error {
9485	if v == nil {
9486		return fmt.Errorf("unexpected nil of type %T", v)
9487	}
9488	if value == nil {
9489		return nil
9490	}
9491
9492	shape, ok := value.([]interface{})
9493	if !ok {
9494		return fmt.Errorf("unexpected JSON type %v", value)
9495	}
9496
9497	var cv []types.EnabledServicePrincipal
9498	if *v == nil {
9499		cv = []types.EnabledServicePrincipal{}
9500	} else {
9501		cv = *v
9502	}
9503
9504	for _, value := range shape {
9505		var col types.EnabledServicePrincipal
9506		destAddr := &col
9507		if err := awsAwsjson11_deserializeDocumentEnabledServicePrincipal(&destAddr, value); err != nil {
9508			return err
9509		}
9510		col = *destAddr
9511		cv = append(cv, col)
9512
9513	}
9514	*v = cv
9515	return nil
9516}
9517
9518func awsAwsjson11_deserializeDocumentFinalizingOrganizationException(v **types.FinalizingOrganizationException, value interface{}) error {
9519	if v == nil {
9520		return fmt.Errorf("unexpected nil of type %T", v)
9521	}
9522	if value == nil {
9523		return nil
9524	}
9525
9526	shape, ok := value.(map[string]interface{})
9527	if !ok {
9528		return fmt.Errorf("unexpected JSON type %v", value)
9529	}
9530
9531	var sv *types.FinalizingOrganizationException
9532	if *v == nil {
9533		sv = &types.FinalizingOrganizationException{}
9534	} else {
9535		sv = *v
9536	}
9537
9538	for key, value := range shape {
9539		switch key {
9540		case "Message":
9541			if value != nil {
9542				jtv, ok := value.(string)
9543				if !ok {
9544					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
9545				}
9546				sv.Message = ptr.String(jtv)
9547			}
9548
9549		default:
9550			_, _ = key, value
9551
9552		}
9553	}
9554	*v = sv
9555	return nil
9556}
9557
9558func awsAwsjson11_deserializeDocumentHandshake(v **types.Handshake, value interface{}) error {
9559	if v == nil {
9560		return fmt.Errorf("unexpected nil of type %T", v)
9561	}
9562	if value == nil {
9563		return nil
9564	}
9565
9566	shape, ok := value.(map[string]interface{})
9567	if !ok {
9568		return fmt.Errorf("unexpected JSON type %v", value)
9569	}
9570
9571	var sv *types.Handshake
9572	if *v == nil {
9573		sv = &types.Handshake{}
9574	} else {
9575		sv = *v
9576	}
9577
9578	for key, value := range shape {
9579		switch key {
9580		case "Action":
9581			if value != nil {
9582				jtv, ok := value.(string)
9583				if !ok {
9584					return fmt.Errorf("expected ActionType to be of type string, got %T instead", value)
9585				}
9586				sv.Action = types.ActionType(jtv)
9587			}
9588
9589		case "Arn":
9590			if value != nil {
9591				jtv, ok := value.(string)
9592				if !ok {
9593					return fmt.Errorf("expected HandshakeArn to be of type string, got %T instead", value)
9594				}
9595				sv.Arn = ptr.String(jtv)
9596			}
9597
9598		case "ExpirationTimestamp":
9599			if value != nil {
9600				jtv, ok := value.(json.Number)
9601				if !ok {
9602					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
9603				}
9604				f64, err := jtv.Float64()
9605				if err != nil {
9606					return err
9607				}
9608				sv.ExpirationTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64))
9609			}
9610
9611		case "Id":
9612			if value != nil {
9613				jtv, ok := value.(string)
9614				if !ok {
9615					return fmt.Errorf("expected HandshakeId to be of type string, got %T instead", value)
9616				}
9617				sv.Id = ptr.String(jtv)
9618			}
9619
9620		case "Parties":
9621			if err := awsAwsjson11_deserializeDocumentHandshakeParties(&sv.Parties, value); err != nil {
9622				return err
9623			}
9624
9625		case "RequestedTimestamp":
9626			if value != nil {
9627				jtv, ok := value.(json.Number)
9628				if !ok {
9629					return fmt.Errorf("expected Timestamp to be json.Number, got %T instead", value)
9630				}
9631				f64, err := jtv.Float64()
9632				if err != nil {
9633					return err
9634				}
9635				sv.RequestedTimestamp = ptr.Time(smithytime.ParseEpochSeconds(f64))
9636			}
9637
9638		case "Resources":
9639			if err := awsAwsjson11_deserializeDocumentHandshakeResources(&sv.Resources, value); err != nil {
9640				return err
9641			}
9642
9643		case "State":
9644			if value != nil {
9645				jtv, ok := value.(string)
9646				if !ok {
9647					return fmt.Errorf("expected HandshakeState to be of type string, got %T instead", value)
9648				}
9649				sv.State = types.HandshakeState(jtv)
9650			}
9651
9652		default:
9653			_, _ = key, value
9654
9655		}
9656	}
9657	*v = sv
9658	return nil
9659}
9660
9661func awsAwsjson11_deserializeDocumentHandshakeAlreadyInStateException(v **types.HandshakeAlreadyInStateException, value interface{}) error {
9662	if v == nil {
9663		return fmt.Errorf("unexpected nil of type %T", v)
9664	}
9665	if value == nil {
9666		return nil
9667	}
9668
9669	shape, ok := value.(map[string]interface{})
9670	if !ok {
9671		return fmt.Errorf("unexpected JSON type %v", value)
9672	}
9673
9674	var sv *types.HandshakeAlreadyInStateException
9675	if *v == nil {
9676		sv = &types.HandshakeAlreadyInStateException{}
9677	} else {
9678		sv = *v
9679	}
9680
9681	for key, value := range shape {
9682		switch key {
9683		case "Message":
9684			if value != nil {
9685				jtv, ok := value.(string)
9686				if !ok {
9687					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
9688				}
9689				sv.Message = ptr.String(jtv)
9690			}
9691
9692		default:
9693			_, _ = key, value
9694
9695		}
9696	}
9697	*v = sv
9698	return nil
9699}
9700
9701func awsAwsjson11_deserializeDocumentHandshakeConstraintViolationException(v **types.HandshakeConstraintViolationException, value interface{}) error {
9702	if v == nil {
9703		return fmt.Errorf("unexpected nil of type %T", v)
9704	}
9705	if value == nil {
9706		return nil
9707	}
9708
9709	shape, ok := value.(map[string]interface{})
9710	if !ok {
9711		return fmt.Errorf("unexpected JSON type %v", value)
9712	}
9713
9714	var sv *types.HandshakeConstraintViolationException
9715	if *v == nil {
9716		sv = &types.HandshakeConstraintViolationException{}
9717	} else {
9718		sv = *v
9719	}
9720
9721	for key, value := range shape {
9722		switch key {
9723		case "Message":
9724			if value != nil {
9725				jtv, ok := value.(string)
9726				if !ok {
9727					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
9728				}
9729				sv.Message = ptr.String(jtv)
9730			}
9731
9732		case "Reason":
9733			if value != nil {
9734				jtv, ok := value.(string)
9735				if !ok {
9736					return fmt.Errorf("expected HandshakeConstraintViolationExceptionReason to be of type string, got %T instead", value)
9737				}
9738				sv.Reason = types.HandshakeConstraintViolationExceptionReason(jtv)
9739			}
9740
9741		default:
9742			_, _ = key, value
9743
9744		}
9745	}
9746	*v = sv
9747	return nil
9748}
9749
9750func awsAwsjson11_deserializeDocumentHandshakeNotFoundException(v **types.HandshakeNotFoundException, value interface{}) error {
9751	if v == nil {
9752		return fmt.Errorf("unexpected nil of type %T", v)
9753	}
9754	if value == nil {
9755		return nil
9756	}
9757
9758	shape, ok := value.(map[string]interface{})
9759	if !ok {
9760		return fmt.Errorf("unexpected JSON type %v", value)
9761	}
9762
9763	var sv *types.HandshakeNotFoundException
9764	if *v == nil {
9765		sv = &types.HandshakeNotFoundException{}
9766	} else {
9767		sv = *v
9768	}
9769
9770	for key, value := range shape {
9771		switch key {
9772		case "Message":
9773			if value != nil {
9774				jtv, ok := value.(string)
9775				if !ok {
9776					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
9777				}
9778				sv.Message = ptr.String(jtv)
9779			}
9780
9781		default:
9782			_, _ = key, value
9783
9784		}
9785	}
9786	*v = sv
9787	return nil
9788}
9789
9790func awsAwsjson11_deserializeDocumentHandshakeParties(v *[]types.HandshakeParty, value interface{}) error {
9791	if v == nil {
9792		return fmt.Errorf("unexpected nil of type %T", v)
9793	}
9794	if value == nil {
9795		return nil
9796	}
9797
9798	shape, ok := value.([]interface{})
9799	if !ok {
9800		return fmt.Errorf("unexpected JSON type %v", value)
9801	}
9802
9803	var cv []types.HandshakeParty
9804	if *v == nil {
9805		cv = []types.HandshakeParty{}
9806	} else {
9807		cv = *v
9808	}
9809
9810	for _, value := range shape {
9811		var col types.HandshakeParty
9812		destAddr := &col
9813		if err := awsAwsjson11_deserializeDocumentHandshakeParty(&destAddr, value); err != nil {
9814			return err
9815		}
9816		col = *destAddr
9817		cv = append(cv, col)
9818
9819	}
9820	*v = cv
9821	return nil
9822}
9823
9824func awsAwsjson11_deserializeDocumentHandshakeParty(v **types.HandshakeParty, value interface{}) error {
9825	if v == nil {
9826		return fmt.Errorf("unexpected nil of type %T", v)
9827	}
9828	if value == nil {
9829		return nil
9830	}
9831
9832	shape, ok := value.(map[string]interface{})
9833	if !ok {
9834		return fmt.Errorf("unexpected JSON type %v", value)
9835	}
9836
9837	var sv *types.HandshakeParty
9838	if *v == nil {
9839		sv = &types.HandshakeParty{}
9840	} else {
9841		sv = *v
9842	}
9843
9844	for key, value := range shape {
9845		switch key {
9846		case "Id":
9847			if value != nil {
9848				jtv, ok := value.(string)
9849				if !ok {
9850					return fmt.Errorf("expected HandshakePartyId to be of type string, got %T instead", value)
9851				}
9852				sv.Id = ptr.String(jtv)
9853			}
9854
9855		case "Type":
9856			if value != nil {
9857				jtv, ok := value.(string)
9858				if !ok {
9859					return fmt.Errorf("expected HandshakePartyType to be of type string, got %T instead", value)
9860				}
9861				sv.Type = types.HandshakePartyType(jtv)
9862			}
9863
9864		default:
9865			_, _ = key, value
9866
9867		}
9868	}
9869	*v = sv
9870	return nil
9871}
9872
9873func awsAwsjson11_deserializeDocumentHandshakeResource(v **types.HandshakeResource, value interface{}) error {
9874	if v == nil {
9875		return fmt.Errorf("unexpected nil of type %T", v)
9876	}
9877	if value == nil {
9878		return nil
9879	}
9880
9881	shape, ok := value.(map[string]interface{})
9882	if !ok {
9883		return fmt.Errorf("unexpected JSON type %v", value)
9884	}
9885
9886	var sv *types.HandshakeResource
9887	if *v == nil {
9888		sv = &types.HandshakeResource{}
9889	} else {
9890		sv = *v
9891	}
9892
9893	for key, value := range shape {
9894		switch key {
9895		case "Resources":
9896			if err := awsAwsjson11_deserializeDocumentHandshakeResources(&sv.Resources, value); err != nil {
9897				return err
9898			}
9899
9900		case "Type":
9901			if value != nil {
9902				jtv, ok := value.(string)
9903				if !ok {
9904					return fmt.Errorf("expected HandshakeResourceType to be of type string, got %T instead", value)
9905				}
9906				sv.Type = types.HandshakeResourceType(jtv)
9907			}
9908
9909		case "Value":
9910			if value != nil {
9911				jtv, ok := value.(string)
9912				if !ok {
9913					return fmt.Errorf("expected HandshakeResourceValue to be of type string, got %T instead", value)
9914				}
9915				sv.Value = ptr.String(jtv)
9916			}
9917
9918		default:
9919			_, _ = key, value
9920
9921		}
9922	}
9923	*v = sv
9924	return nil
9925}
9926
9927func awsAwsjson11_deserializeDocumentHandshakeResources(v *[]types.HandshakeResource, value interface{}) error {
9928	if v == nil {
9929		return fmt.Errorf("unexpected nil of type %T", v)
9930	}
9931	if value == nil {
9932		return nil
9933	}
9934
9935	shape, ok := value.([]interface{})
9936	if !ok {
9937		return fmt.Errorf("unexpected JSON type %v", value)
9938	}
9939
9940	var cv []types.HandshakeResource
9941	if *v == nil {
9942		cv = []types.HandshakeResource{}
9943	} else {
9944		cv = *v
9945	}
9946
9947	for _, value := range shape {
9948		var col types.HandshakeResource
9949		destAddr := &col
9950		if err := awsAwsjson11_deserializeDocumentHandshakeResource(&destAddr, value); err != nil {
9951			return err
9952		}
9953		col = *destAddr
9954		cv = append(cv, col)
9955
9956	}
9957	*v = cv
9958	return nil
9959}
9960
9961func awsAwsjson11_deserializeDocumentHandshakes(v *[]types.Handshake, value interface{}) error {
9962	if v == nil {
9963		return fmt.Errorf("unexpected nil of type %T", v)
9964	}
9965	if value == nil {
9966		return nil
9967	}
9968
9969	shape, ok := value.([]interface{})
9970	if !ok {
9971		return fmt.Errorf("unexpected JSON type %v", value)
9972	}
9973
9974	var cv []types.Handshake
9975	if *v == nil {
9976		cv = []types.Handshake{}
9977	} else {
9978		cv = *v
9979	}
9980
9981	for _, value := range shape {
9982		var col types.Handshake
9983		destAddr := &col
9984		if err := awsAwsjson11_deserializeDocumentHandshake(&destAddr, value); err != nil {
9985			return err
9986		}
9987		col = *destAddr
9988		cv = append(cv, col)
9989
9990	}
9991	*v = cv
9992	return nil
9993}
9994
9995func awsAwsjson11_deserializeDocumentInvalidHandshakeTransitionException(v **types.InvalidHandshakeTransitionException, value interface{}) error {
9996	if v == nil {
9997		return fmt.Errorf("unexpected nil of type %T", v)
9998	}
9999	if value == nil {
10000		return nil
10001	}
10002
10003	shape, ok := value.(map[string]interface{})
10004	if !ok {
10005		return fmt.Errorf("unexpected JSON type %v", value)
10006	}
10007
10008	var sv *types.InvalidHandshakeTransitionException
10009	if *v == nil {
10010		sv = &types.InvalidHandshakeTransitionException{}
10011	} else {
10012		sv = *v
10013	}
10014
10015	for key, value := range shape {
10016		switch key {
10017		case "Message":
10018			if value != nil {
10019				jtv, ok := value.(string)
10020				if !ok {
10021					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
10022				}
10023				sv.Message = ptr.String(jtv)
10024			}
10025
10026		default:
10027			_, _ = key, value
10028
10029		}
10030	}
10031	*v = sv
10032	return nil
10033}
10034
10035func awsAwsjson11_deserializeDocumentInvalidInputException(v **types.InvalidInputException, value interface{}) error {
10036	if v == nil {
10037		return fmt.Errorf("unexpected nil of type %T", v)
10038	}
10039	if value == nil {
10040		return nil
10041	}
10042
10043	shape, ok := value.(map[string]interface{})
10044	if !ok {
10045		return fmt.Errorf("unexpected JSON type %v", value)
10046	}
10047
10048	var sv *types.InvalidInputException
10049	if *v == nil {
10050		sv = &types.InvalidInputException{}
10051	} else {
10052		sv = *v
10053	}
10054
10055	for key, value := range shape {
10056		switch key {
10057		case "Message":
10058			if value != nil {
10059				jtv, ok := value.(string)
10060				if !ok {
10061					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
10062				}
10063				sv.Message = ptr.String(jtv)
10064			}
10065
10066		case "Reason":
10067			if value != nil {
10068				jtv, ok := value.(string)
10069				if !ok {
10070					return fmt.Errorf("expected InvalidInputExceptionReason to be of type string, got %T instead", value)
10071				}
10072				sv.Reason = types.InvalidInputExceptionReason(jtv)
10073			}
10074
10075		default:
10076			_, _ = key, value
10077
10078		}
10079	}
10080	*v = sv
10081	return nil
10082}
10083
10084func awsAwsjson11_deserializeDocumentMalformedPolicyDocumentException(v **types.MalformedPolicyDocumentException, value interface{}) error {
10085	if v == nil {
10086		return fmt.Errorf("unexpected nil of type %T", v)
10087	}
10088	if value == nil {
10089		return nil
10090	}
10091
10092	shape, ok := value.(map[string]interface{})
10093	if !ok {
10094		return fmt.Errorf("unexpected JSON type %v", value)
10095	}
10096
10097	var sv *types.MalformedPolicyDocumentException
10098	if *v == nil {
10099		sv = &types.MalformedPolicyDocumentException{}
10100	} else {
10101		sv = *v
10102	}
10103
10104	for key, value := range shape {
10105		switch key {
10106		case "Message":
10107			if value != nil {
10108				jtv, ok := value.(string)
10109				if !ok {
10110					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
10111				}
10112				sv.Message = ptr.String(jtv)
10113			}
10114
10115		default:
10116			_, _ = key, value
10117
10118		}
10119	}
10120	*v = sv
10121	return nil
10122}
10123
10124func awsAwsjson11_deserializeDocumentMasterCannotLeaveOrganizationException(v **types.MasterCannotLeaveOrganizationException, value interface{}) error {
10125	if v == nil {
10126		return fmt.Errorf("unexpected nil of type %T", v)
10127	}
10128	if value == nil {
10129		return nil
10130	}
10131
10132	shape, ok := value.(map[string]interface{})
10133	if !ok {
10134		return fmt.Errorf("unexpected JSON type %v", value)
10135	}
10136
10137	var sv *types.MasterCannotLeaveOrganizationException
10138	if *v == nil {
10139		sv = &types.MasterCannotLeaveOrganizationException{}
10140	} else {
10141		sv = *v
10142	}
10143
10144	for key, value := range shape {
10145		switch key {
10146		case "Message":
10147			if value != nil {
10148				jtv, ok := value.(string)
10149				if !ok {
10150					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
10151				}
10152				sv.Message = ptr.String(jtv)
10153			}
10154
10155		default:
10156			_, _ = key, value
10157
10158		}
10159	}
10160	*v = sv
10161	return nil
10162}
10163
10164func awsAwsjson11_deserializeDocumentOrganization(v **types.Organization, value interface{}) error {
10165	if v == nil {
10166		return fmt.Errorf("unexpected nil of type %T", v)
10167	}
10168	if value == nil {
10169		return nil
10170	}
10171
10172	shape, ok := value.(map[string]interface{})
10173	if !ok {
10174		return fmt.Errorf("unexpected JSON type %v", value)
10175	}
10176
10177	var sv *types.Organization
10178	if *v == nil {
10179		sv = &types.Organization{}
10180	} else {
10181		sv = *v
10182	}
10183
10184	for key, value := range shape {
10185		switch key {
10186		case "Arn":
10187			if value != nil {
10188				jtv, ok := value.(string)
10189				if !ok {
10190					return fmt.Errorf("expected OrganizationArn to be of type string, got %T instead", value)
10191				}
10192				sv.Arn = ptr.String(jtv)
10193			}
10194
10195		case "AvailablePolicyTypes":
10196			if err := awsAwsjson11_deserializeDocumentPolicyTypes(&sv.AvailablePolicyTypes, value); err != nil {
10197				return err
10198			}
10199
10200		case "FeatureSet":
10201			if value != nil {
10202				jtv, ok := value.(string)
10203				if !ok {
10204					return fmt.Errorf("expected OrganizationFeatureSet to be of type string, got %T instead", value)
10205				}
10206				sv.FeatureSet = types.OrganizationFeatureSet(jtv)
10207			}
10208
10209		case "Id":
10210			if value != nil {
10211				jtv, ok := value.(string)
10212				if !ok {
10213					return fmt.Errorf("expected OrganizationId to be of type string, got %T instead", value)
10214				}
10215				sv.Id = ptr.String(jtv)
10216			}
10217
10218		case "MasterAccountArn":
10219			if value != nil {
10220				jtv, ok := value.(string)
10221				if !ok {
10222					return fmt.Errorf("expected AccountArn to be of type string, got %T instead", value)
10223				}
10224				sv.MasterAccountArn = ptr.String(jtv)
10225			}
10226
10227		case "MasterAccountEmail":
10228			if value != nil {
10229				jtv, ok := value.(string)
10230				if !ok {
10231					return fmt.Errorf("expected Email to be of type string, got %T instead", value)
10232				}
10233				sv.MasterAccountEmail = ptr.String(jtv)
10234			}
10235
10236		case "MasterAccountId":
10237			if value != nil {
10238				jtv, ok := value.(string)
10239				if !ok {
10240					return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
10241				}
10242				sv.MasterAccountId = ptr.String(jtv)
10243			}
10244
10245		default:
10246			_, _ = key, value
10247
10248		}
10249	}
10250	*v = sv
10251	return nil
10252}
10253
10254func awsAwsjson11_deserializeDocumentOrganizationalUnit(v **types.OrganizationalUnit, value interface{}) error {
10255	if v == nil {
10256		return fmt.Errorf("unexpected nil of type %T", v)
10257	}
10258	if value == nil {
10259		return nil
10260	}
10261
10262	shape, ok := value.(map[string]interface{})
10263	if !ok {
10264		return fmt.Errorf("unexpected JSON type %v", value)
10265	}
10266
10267	var sv *types.OrganizationalUnit
10268	if *v == nil {
10269		sv = &types.OrganizationalUnit{}
10270	} else {
10271		sv = *v
10272	}
10273
10274	for key, value := range shape {
10275		switch key {
10276		case "Arn":
10277			if value != nil {
10278				jtv, ok := value.(string)
10279				if !ok {
10280					return fmt.Errorf("expected OrganizationalUnitArn to be of type string, got %T instead", value)
10281				}
10282				sv.Arn = ptr.String(jtv)
10283			}
10284
10285		case "Id":
10286			if value != nil {
10287				jtv, ok := value.(string)
10288				if !ok {
10289					return fmt.Errorf("expected OrganizationalUnitId to be of type string, got %T instead", value)
10290				}
10291				sv.Id = ptr.String(jtv)
10292			}
10293
10294		case "Name":
10295			if value != nil {
10296				jtv, ok := value.(string)
10297				if !ok {
10298					return fmt.Errorf("expected OrganizationalUnitName to be of type string, got %T instead", value)
10299				}
10300				sv.Name = ptr.String(jtv)
10301			}
10302
10303		default:
10304			_, _ = key, value
10305
10306		}
10307	}
10308	*v = sv
10309	return nil
10310}
10311
10312func awsAwsjson11_deserializeDocumentOrganizationalUnitNotEmptyException(v **types.OrganizationalUnitNotEmptyException, value interface{}) error {
10313	if v == nil {
10314		return fmt.Errorf("unexpected nil of type %T", v)
10315	}
10316	if value == nil {
10317		return nil
10318	}
10319
10320	shape, ok := value.(map[string]interface{})
10321	if !ok {
10322		return fmt.Errorf("unexpected JSON type %v", value)
10323	}
10324
10325	var sv *types.OrganizationalUnitNotEmptyException
10326	if *v == nil {
10327		sv = &types.OrganizationalUnitNotEmptyException{}
10328	} else {
10329		sv = *v
10330	}
10331
10332	for key, value := range shape {
10333		switch key {
10334		case "Message":
10335			if value != nil {
10336				jtv, ok := value.(string)
10337				if !ok {
10338					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
10339				}
10340				sv.Message = ptr.String(jtv)
10341			}
10342
10343		default:
10344			_, _ = key, value
10345
10346		}
10347	}
10348	*v = sv
10349	return nil
10350}
10351
10352func awsAwsjson11_deserializeDocumentOrganizationalUnitNotFoundException(v **types.OrganizationalUnitNotFoundException, value interface{}) error {
10353	if v == nil {
10354		return fmt.Errorf("unexpected nil of type %T", v)
10355	}
10356	if value == nil {
10357		return nil
10358	}
10359
10360	shape, ok := value.(map[string]interface{})
10361	if !ok {
10362		return fmt.Errorf("unexpected JSON type %v", value)
10363	}
10364
10365	var sv *types.OrganizationalUnitNotFoundException
10366	if *v == nil {
10367		sv = &types.OrganizationalUnitNotFoundException{}
10368	} else {
10369		sv = *v
10370	}
10371
10372	for key, value := range shape {
10373		switch key {
10374		case "Message":
10375			if value != nil {
10376				jtv, ok := value.(string)
10377				if !ok {
10378					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
10379				}
10380				sv.Message = ptr.String(jtv)
10381			}
10382
10383		default:
10384			_, _ = key, value
10385
10386		}
10387	}
10388	*v = sv
10389	return nil
10390}
10391
10392func awsAwsjson11_deserializeDocumentOrganizationalUnits(v *[]types.OrganizationalUnit, value interface{}) error {
10393	if v == nil {
10394		return fmt.Errorf("unexpected nil of type %T", v)
10395	}
10396	if value == nil {
10397		return nil
10398	}
10399
10400	shape, ok := value.([]interface{})
10401	if !ok {
10402		return fmt.Errorf("unexpected JSON type %v", value)
10403	}
10404
10405	var cv []types.OrganizationalUnit
10406	if *v == nil {
10407		cv = []types.OrganizationalUnit{}
10408	} else {
10409		cv = *v
10410	}
10411
10412	for _, value := range shape {
10413		var col types.OrganizationalUnit
10414		destAddr := &col
10415		if err := awsAwsjson11_deserializeDocumentOrganizationalUnit(&destAddr, value); err != nil {
10416			return err
10417		}
10418		col = *destAddr
10419		cv = append(cv, col)
10420
10421	}
10422	*v = cv
10423	return nil
10424}
10425
10426func awsAwsjson11_deserializeDocumentOrganizationNotEmptyException(v **types.OrganizationNotEmptyException, value interface{}) error {
10427	if v == nil {
10428		return fmt.Errorf("unexpected nil of type %T", v)
10429	}
10430	if value == nil {
10431		return nil
10432	}
10433
10434	shape, ok := value.(map[string]interface{})
10435	if !ok {
10436		return fmt.Errorf("unexpected JSON type %v", value)
10437	}
10438
10439	var sv *types.OrganizationNotEmptyException
10440	if *v == nil {
10441		sv = &types.OrganizationNotEmptyException{}
10442	} else {
10443		sv = *v
10444	}
10445
10446	for key, value := range shape {
10447		switch key {
10448		case "Message":
10449			if value != nil {
10450				jtv, ok := value.(string)
10451				if !ok {
10452					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
10453				}
10454				sv.Message = ptr.String(jtv)
10455			}
10456
10457		default:
10458			_, _ = key, value
10459
10460		}
10461	}
10462	*v = sv
10463	return nil
10464}
10465
10466func awsAwsjson11_deserializeDocumentParent(v **types.Parent, value interface{}) error {
10467	if v == nil {
10468		return fmt.Errorf("unexpected nil of type %T", v)
10469	}
10470	if value == nil {
10471		return nil
10472	}
10473
10474	shape, ok := value.(map[string]interface{})
10475	if !ok {
10476		return fmt.Errorf("unexpected JSON type %v", value)
10477	}
10478
10479	var sv *types.Parent
10480	if *v == nil {
10481		sv = &types.Parent{}
10482	} else {
10483		sv = *v
10484	}
10485
10486	for key, value := range shape {
10487		switch key {
10488		case "Id":
10489			if value != nil {
10490				jtv, ok := value.(string)
10491				if !ok {
10492					return fmt.Errorf("expected ParentId to be of type string, got %T instead", value)
10493				}
10494				sv.Id = ptr.String(jtv)
10495			}
10496
10497		case "Type":
10498			if value != nil {
10499				jtv, ok := value.(string)
10500				if !ok {
10501					return fmt.Errorf("expected ParentType to be of type string, got %T instead", value)
10502				}
10503				sv.Type = types.ParentType(jtv)
10504			}
10505
10506		default:
10507			_, _ = key, value
10508
10509		}
10510	}
10511	*v = sv
10512	return nil
10513}
10514
10515func awsAwsjson11_deserializeDocumentParentNotFoundException(v **types.ParentNotFoundException, value interface{}) error {
10516	if v == nil {
10517		return fmt.Errorf("unexpected nil of type %T", v)
10518	}
10519	if value == nil {
10520		return nil
10521	}
10522
10523	shape, ok := value.(map[string]interface{})
10524	if !ok {
10525		return fmt.Errorf("unexpected JSON type %v", value)
10526	}
10527
10528	var sv *types.ParentNotFoundException
10529	if *v == nil {
10530		sv = &types.ParentNotFoundException{}
10531	} else {
10532		sv = *v
10533	}
10534
10535	for key, value := range shape {
10536		switch key {
10537		case "Message":
10538			if value != nil {
10539				jtv, ok := value.(string)
10540				if !ok {
10541					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
10542				}
10543				sv.Message = ptr.String(jtv)
10544			}
10545
10546		default:
10547			_, _ = key, value
10548
10549		}
10550	}
10551	*v = sv
10552	return nil
10553}
10554
10555func awsAwsjson11_deserializeDocumentParents(v *[]types.Parent, value interface{}) error {
10556	if v == nil {
10557		return fmt.Errorf("unexpected nil of type %T", v)
10558	}
10559	if value == nil {
10560		return nil
10561	}
10562
10563	shape, ok := value.([]interface{})
10564	if !ok {
10565		return fmt.Errorf("unexpected JSON type %v", value)
10566	}
10567
10568	var cv []types.Parent
10569	if *v == nil {
10570		cv = []types.Parent{}
10571	} else {
10572		cv = *v
10573	}
10574
10575	for _, value := range shape {
10576		var col types.Parent
10577		destAddr := &col
10578		if err := awsAwsjson11_deserializeDocumentParent(&destAddr, value); err != nil {
10579			return err
10580		}
10581		col = *destAddr
10582		cv = append(cv, col)
10583
10584	}
10585	*v = cv
10586	return nil
10587}
10588
10589func awsAwsjson11_deserializeDocumentPolicies(v *[]types.PolicySummary, value interface{}) error {
10590	if v == nil {
10591		return fmt.Errorf("unexpected nil of type %T", v)
10592	}
10593	if value == nil {
10594		return nil
10595	}
10596
10597	shape, ok := value.([]interface{})
10598	if !ok {
10599		return fmt.Errorf("unexpected JSON type %v", value)
10600	}
10601
10602	var cv []types.PolicySummary
10603	if *v == nil {
10604		cv = []types.PolicySummary{}
10605	} else {
10606		cv = *v
10607	}
10608
10609	for _, value := range shape {
10610		var col types.PolicySummary
10611		destAddr := &col
10612		if err := awsAwsjson11_deserializeDocumentPolicySummary(&destAddr, value); err != nil {
10613			return err
10614		}
10615		col = *destAddr
10616		cv = append(cv, col)
10617
10618	}
10619	*v = cv
10620	return nil
10621}
10622
10623func awsAwsjson11_deserializeDocumentPolicy(v **types.Policy, value interface{}) error {
10624	if v == nil {
10625		return fmt.Errorf("unexpected nil of type %T", v)
10626	}
10627	if value == nil {
10628		return nil
10629	}
10630
10631	shape, ok := value.(map[string]interface{})
10632	if !ok {
10633		return fmt.Errorf("unexpected JSON type %v", value)
10634	}
10635
10636	var sv *types.Policy
10637	if *v == nil {
10638		sv = &types.Policy{}
10639	} else {
10640		sv = *v
10641	}
10642
10643	for key, value := range shape {
10644		switch key {
10645		case "Content":
10646			if value != nil {
10647				jtv, ok := value.(string)
10648				if !ok {
10649					return fmt.Errorf("expected PolicyContent to be of type string, got %T instead", value)
10650				}
10651				sv.Content = ptr.String(jtv)
10652			}
10653
10654		case "PolicySummary":
10655			if err := awsAwsjson11_deserializeDocumentPolicySummary(&sv.PolicySummary, value); err != nil {
10656				return err
10657			}
10658
10659		default:
10660			_, _ = key, value
10661
10662		}
10663	}
10664	*v = sv
10665	return nil
10666}
10667
10668func awsAwsjson11_deserializeDocumentPolicyChangesInProgressException(v **types.PolicyChangesInProgressException, value interface{}) error {
10669	if v == nil {
10670		return fmt.Errorf("unexpected nil of type %T", v)
10671	}
10672	if value == nil {
10673		return nil
10674	}
10675
10676	shape, ok := value.(map[string]interface{})
10677	if !ok {
10678		return fmt.Errorf("unexpected JSON type %v", value)
10679	}
10680
10681	var sv *types.PolicyChangesInProgressException
10682	if *v == nil {
10683		sv = &types.PolicyChangesInProgressException{}
10684	} else {
10685		sv = *v
10686	}
10687
10688	for key, value := range shape {
10689		switch key {
10690		case "Message":
10691			if value != nil {
10692				jtv, ok := value.(string)
10693				if !ok {
10694					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
10695				}
10696				sv.Message = ptr.String(jtv)
10697			}
10698
10699		default:
10700			_, _ = key, value
10701
10702		}
10703	}
10704	*v = sv
10705	return nil
10706}
10707
10708func awsAwsjson11_deserializeDocumentPolicyInUseException(v **types.PolicyInUseException, value interface{}) error {
10709	if v == nil {
10710		return fmt.Errorf("unexpected nil of type %T", v)
10711	}
10712	if value == nil {
10713		return nil
10714	}
10715
10716	shape, ok := value.(map[string]interface{})
10717	if !ok {
10718		return fmt.Errorf("unexpected JSON type %v", value)
10719	}
10720
10721	var sv *types.PolicyInUseException
10722	if *v == nil {
10723		sv = &types.PolicyInUseException{}
10724	} else {
10725		sv = *v
10726	}
10727
10728	for key, value := range shape {
10729		switch key {
10730		case "Message":
10731			if value != nil {
10732				jtv, ok := value.(string)
10733				if !ok {
10734					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
10735				}
10736				sv.Message = ptr.String(jtv)
10737			}
10738
10739		default:
10740			_, _ = key, value
10741
10742		}
10743	}
10744	*v = sv
10745	return nil
10746}
10747
10748func awsAwsjson11_deserializeDocumentPolicyNotAttachedException(v **types.PolicyNotAttachedException, value interface{}) error {
10749	if v == nil {
10750		return fmt.Errorf("unexpected nil of type %T", v)
10751	}
10752	if value == nil {
10753		return nil
10754	}
10755
10756	shape, ok := value.(map[string]interface{})
10757	if !ok {
10758		return fmt.Errorf("unexpected JSON type %v", value)
10759	}
10760
10761	var sv *types.PolicyNotAttachedException
10762	if *v == nil {
10763		sv = &types.PolicyNotAttachedException{}
10764	} else {
10765		sv = *v
10766	}
10767
10768	for key, value := range shape {
10769		switch key {
10770		case "Message":
10771			if value != nil {
10772				jtv, ok := value.(string)
10773				if !ok {
10774					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
10775				}
10776				sv.Message = ptr.String(jtv)
10777			}
10778
10779		default:
10780			_, _ = key, value
10781
10782		}
10783	}
10784	*v = sv
10785	return nil
10786}
10787
10788func awsAwsjson11_deserializeDocumentPolicyNotFoundException(v **types.PolicyNotFoundException, value interface{}) error {
10789	if v == nil {
10790		return fmt.Errorf("unexpected nil of type %T", v)
10791	}
10792	if value == nil {
10793		return nil
10794	}
10795
10796	shape, ok := value.(map[string]interface{})
10797	if !ok {
10798		return fmt.Errorf("unexpected JSON type %v", value)
10799	}
10800
10801	var sv *types.PolicyNotFoundException
10802	if *v == nil {
10803		sv = &types.PolicyNotFoundException{}
10804	} else {
10805		sv = *v
10806	}
10807
10808	for key, value := range shape {
10809		switch key {
10810		case "Message":
10811			if value != nil {
10812				jtv, ok := value.(string)
10813				if !ok {
10814					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
10815				}
10816				sv.Message = ptr.String(jtv)
10817			}
10818
10819		default:
10820			_, _ = key, value
10821
10822		}
10823	}
10824	*v = sv
10825	return nil
10826}
10827
10828func awsAwsjson11_deserializeDocumentPolicySummary(v **types.PolicySummary, value interface{}) error {
10829	if v == nil {
10830		return fmt.Errorf("unexpected nil of type %T", v)
10831	}
10832	if value == nil {
10833		return nil
10834	}
10835
10836	shape, ok := value.(map[string]interface{})
10837	if !ok {
10838		return fmt.Errorf("unexpected JSON type %v", value)
10839	}
10840
10841	var sv *types.PolicySummary
10842	if *v == nil {
10843		sv = &types.PolicySummary{}
10844	} else {
10845		sv = *v
10846	}
10847
10848	for key, value := range shape {
10849		switch key {
10850		case "Arn":
10851			if value != nil {
10852				jtv, ok := value.(string)
10853				if !ok {
10854					return fmt.Errorf("expected PolicyArn to be of type string, got %T instead", value)
10855				}
10856				sv.Arn = ptr.String(jtv)
10857			}
10858
10859		case "AwsManaged":
10860			if value != nil {
10861				jtv, ok := value.(bool)
10862				if !ok {
10863					return fmt.Errorf("expected AwsManagedPolicy to be of type *bool, got %T instead", value)
10864				}
10865				sv.AwsManaged = jtv
10866			}
10867
10868		case "Description":
10869			if value != nil {
10870				jtv, ok := value.(string)
10871				if !ok {
10872					return fmt.Errorf("expected PolicyDescription to be of type string, got %T instead", value)
10873				}
10874				sv.Description = ptr.String(jtv)
10875			}
10876
10877		case "Id":
10878			if value != nil {
10879				jtv, ok := value.(string)
10880				if !ok {
10881					return fmt.Errorf("expected PolicyId to be of type string, got %T instead", value)
10882				}
10883				sv.Id = ptr.String(jtv)
10884			}
10885
10886		case "Name":
10887			if value != nil {
10888				jtv, ok := value.(string)
10889				if !ok {
10890					return fmt.Errorf("expected PolicyName to be of type string, got %T instead", value)
10891				}
10892				sv.Name = ptr.String(jtv)
10893			}
10894
10895		case "Type":
10896			if value != nil {
10897				jtv, ok := value.(string)
10898				if !ok {
10899					return fmt.Errorf("expected PolicyType to be of type string, got %T instead", value)
10900				}
10901				sv.Type = types.PolicyType(jtv)
10902			}
10903
10904		default:
10905			_, _ = key, value
10906
10907		}
10908	}
10909	*v = sv
10910	return nil
10911}
10912
10913func awsAwsjson11_deserializeDocumentPolicyTargets(v *[]types.PolicyTargetSummary, value interface{}) error {
10914	if v == nil {
10915		return fmt.Errorf("unexpected nil of type %T", v)
10916	}
10917	if value == nil {
10918		return nil
10919	}
10920
10921	shape, ok := value.([]interface{})
10922	if !ok {
10923		return fmt.Errorf("unexpected JSON type %v", value)
10924	}
10925
10926	var cv []types.PolicyTargetSummary
10927	if *v == nil {
10928		cv = []types.PolicyTargetSummary{}
10929	} else {
10930		cv = *v
10931	}
10932
10933	for _, value := range shape {
10934		var col types.PolicyTargetSummary
10935		destAddr := &col
10936		if err := awsAwsjson11_deserializeDocumentPolicyTargetSummary(&destAddr, value); err != nil {
10937			return err
10938		}
10939		col = *destAddr
10940		cv = append(cv, col)
10941
10942	}
10943	*v = cv
10944	return nil
10945}
10946
10947func awsAwsjson11_deserializeDocumentPolicyTargetSummary(v **types.PolicyTargetSummary, value interface{}) error {
10948	if v == nil {
10949		return fmt.Errorf("unexpected nil of type %T", v)
10950	}
10951	if value == nil {
10952		return nil
10953	}
10954
10955	shape, ok := value.(map[string]interface{})
10956	if !ok {
10957		return fmt.Errorf("unexpected JSON type %v", value)
10958	}
10959
10960	var sv *types.PolicyTargetSummary
10961	if *v == nil {
10962		sv = &types.PolicyTargetSummary{}
10963	} else {
10964		sv = *v
10965	}
10966
10967	for key, value := range shape {
10968		switch key {
10969		case "Arn":
10970			if value != nil {
10971				jtv, ok := value.(string)
10972				if !ok {
10973					return fmt.Errorf("expected GenericArn to be of type string, got %T instead", value)
10974				}
10975				sv.Arn = ptr.String(jtv)
10976			}
10977
10978		case "Name":
10979			if value != nil {
10980				jtv, ok := value.(string)
10981				if !ok {
10982					return fmt.Errorf("expected TargetName to be of type string, got %T instead", value)
10983				}
10984				sv.Name = ptr.String(jtv)
10985			}
10986
10987		case "TargetId":
10988			if value != nil {
10989				jtv, ok := value.(string)
10990				if !ok {
10991					return fmt.Errorf("expected PolicyTargetId to be of type string, got %T instead", value)
10992				}
10993				sv.TargetId = ptr.String(jtv)
10994			}
10995
10996		case "Type":
10997			if value != nil {
10998				jtv, ok := value.(string)
10999				if !ok {
11000					return fmt.Errorf("expected TargetType to be of type string, got %T instead", value)
11001				}
11002				sv.Type = types.TargetType(jtv)
11003			}
11004
11005		default:
11006			_, _ = key, value
11007
11008		}
11009	}
11010	*v = sv
11011	return nil
11012}
11013
11014func awsAwsjson11_deserializeDocumentPolicyTypeAlreadyEnabledException(v **types.PolicyTypeAlreadyEnabledException, value interface{}) error {
11015	if v == nil {
11016		return fmt.Errorf("unexpected nil of type %T", v)
11017	}
11018	if value == nil {
11019		return nil
11020	}
11021
11022	shape, ok := value.(map[string]interface{})
11023	if !ok {
11024		return fmt.Errorf("unexpected JSON type %v", value)
11025	}
11026
11027	var sv *types.PolicyTypeAlreadyEnabledException
11028	if *v == nil {
11029		sv = &types.PolicyTypeAlreadyEnabledException{}
11030	} else {
11031		sv = *v
11032	}
11033
11034	for key, value := range shape {
11035		switch key {
11036		case "Message":
11037			if value != nil {
11038				jtv, ok := value.(string)
11039				if !ok {
11040					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
11041				}
11042				sv.Message = ptr.String(jtv)
11043			}
11044
11045		default:
11046			_, _ = key, value
11047
11048		}
11049	}
11050	*v = sv
11051	return nil
11052}
11053
11054func awsAwsjson11_deserializeDocumentPolicyTypeNotAvailableForOrganizationException(v **types.PolicyTypeNotAvailableForOrganizationException, value interface{}) error {
11055	if v == nil {
11056		return fmt.Errorf("unexpected nil of type %T", v)
11057	}
11058	if value == nil {
11059		return nil
11060	}
11061
11062	shape, ok := value.(map[string]interface{})
11063	if !ok {
11064		return fmt.Errorf("unexpected JSON type %v", value)
11065	}
11066
11067	var sv *types.PolicyTypeNotAvailableForOrganizationException
11068	if *v == nil {
11069		sv = &types.PolicyTypeNotAvailableForOrganizationException{}
11070	} else {
11071		sv = *v
11072	}
11073
11074	for key, value := range shape {
11075		switch key {
11076		case "Message":
11077			if value != nil {
11078				jtv, ok := value.(string)
11079				if !ok {
11080					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
11081				}
11082				sv.Message = ptr.String(jtv)
11083			}
11084
11085		default:
11086			_, _ = key, value
11087
11088		}
11089	}
11090	*v = sv
11091	return nil
11092}
11093
11094func awsAwsjson11_deserializeDocumentPolicyTypeNotEnabledException(v **types.PolicyTypeNotEnabledException, value interface{}) error {
11095	if v == nil {
11096		return fmt.Errorf("unexpected nil of type %T", v)
11097	}
11098	if value == nil {
11099		return nil
11100	}
11101
11102	shape, ok := value.(map[string]interface{})
11103	if !ok {
11104		return fmt.Errorf("unexpected JSON type %v", value)
11105	}
11106
11107	var sv *types.PolicyTypeNotEnabledException
11108	if *v == nil {
11109		sv = &types.PolicyTypeNotEnabledException{}
11110	} else {
11111		sv = *v
11112	}
11113
11114	for key, value := range shape {
11115		switch key {
11116		case "Message":
11117			if value != nil {
11118				jtv, ok := value.(string)
11119				if !ok {
11120					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
11121				}
11122				sv.Message = ptr.String(jtv)
11123			}
11124
11125		default:
11126			_, _ = key, value
11127
11128		}
11129	}
11130	*v = sv
11131	return nil
11132}
11133
11134func awsAwsjson11_deserializeDocumentPolicyTypes(v *[]types.PolicyTypeSummary, value interface{}) error {
11135	if v == nil {
11136		return fmt.Errorf("unexpected nil of type %T", v)
11137	}
11138	if value == nil {
11139		return nil
11140	}
11141
11142	shape, ok := value.([]interface{})
11143	if !ok {
11144		return fmt.Errorf("unexpected JSON type %v", value)
11145	}
11146
11147	var cv []types.PolicyTypeSummary
11148	if *v == nil {
11149		cv = []types.PolicyTypeSummary{}
11150	} else {
11151		cv = *v
11152	}
11153
11154	for _, value := range shape {
11155		var col types.PolicyTypeSummary
11156		destAddr := &col
11157		if err := awsAwsjson11_deserializeDocumentPolicyTypeSummary(&destAddr, value); err != nil {
11158			return err
11159		}
11160		col = *destAddr
11161		cv = append(cv, col)
11162
11163	}
11164	*v = cv
11165	return nil
11166}
11167
11168func awsAwsjson11_deserializeDocumentPolicyTypeSummary(v **types.PolicyTypeSummary, value interface{}) error {
11169	if v == nil {
11170		return fmt.Errorf("unexpected nil of type %T", v)
11171	}
11172	if value == nil {
11173		return nil
11174	}
11175
11176	shape, ok := value.(map[string]interface{})
11177	if !ok {
11178		return fmt.Errorf("unexpected JSON type %v", value)
11179	}
11180
11181	var sv *types.PolicyTypeSummary
11182	if *v == nil {
11183		sv = &types.PolicyTypeSummary{}
11184	} else {
11185		sv = *v
11186	}
11187
11188	for key, value := range shape {
11189		switch key {
11190		case "Status":
11191			if value != nil {
11192				jtv, ok := value.(string)
11193				if !ok {
11194					return fmt.Errorf("expected PolicyTypeStatus to be of type string, got %T instead", value)
11195				}
11196				sv.Status = types.PolicyTypeStatus(jtv)
11197			}
11198
11199		case "Type":
11200			if value != nil {
11201				jtv, ok := value.(string)
11202				if !ok {
11203					return fmt.Errorf("expected PolicyType to be of type string, got %T instead", value)
11204				}
11205				sv.Type = types.PolicyType(jtv)
11206			}
11207
11208		default:
11209			_, _ = key, value
11210
11211		}
11212	}
11213	*v = sv
11214	return nil
11215}
11216
11217func awsAwsjson11_deserializeDocumentRoot(v **types.Root, value interface{}) error {
11218	if v == nil {
11219		return fmt.Errorf("unexpected nil of type %T", v)
11220	}
11221	if value == nil {
11222		return nil
11223	}
11224
11225	shape, ok := value.(map[string]interface{})
11226	if !ok {
11227		return fmt.Errorf("unexpected JSON type %v", value)
11228	}
11229
11230	var sv *types.Root
11231	if *v == nil {
11232		sv = &types.Root{}
11233	} else {
11234		sv = *v
11235	}
11236
11237	for key, value := range shape {
11238		switch key {
11239		case "Arn":
11240			if value != nil {
11241				jtv, ok := value.(string)
11242				if !ok {
11243					return fmt.Errorf("expected RootArn to be of type string, got %T instead", value)
11244				}
11245				sv.Arn = ptr.String(jtv)
11246			}
11247
11248		case "Id":
11249			if value != nil {
11250				jtv, ok := value.(string)
11251				if !ok {
11252					return fmt.Errorf("expected RootId to be of type string, got %T instead", value)
11253				}
11254				sv.Id = ptr.String(jtv)
11255			}
11256
11257		case "Name":
11258			if value != nil {
11259				jtv, ok := value.(string)
11260				if !ok {
11261					return fmt.Errorf("expected RootName to be of type string, got %T instead", value)
11262				}
11263				sv.Name = ptr.String(jtv)
11264			}
11265
11266		case "PolicyTypes":
11267			if err := awsAwsjson11_deserializeDocumentPolicyTypes(&sv.PolicyTypes, value); err != nil {
11268				return err
11269			}
11270
11271		default:
11272			_, _ = key, value
11273
11274		}
11275	}
11276	*v = sv
11277	return nil
11278}
11279
11280func awsAwsjson11_deserializeDocumentRootNotFoundException(v **types.RootNotFoundException, value interface{}) error {
11281	if v == nil {
11282		return fmt.Errorf("unexpected nil of type %T", v)
11283	}
11284	if value == nil {
11285		return nil
11286	}
11287
11288	shape, ok := value.(map[string]interface{})
11289	if !ok {
11290		return fmt.Errorf("unexpected JSON type %v", value)
11291	}
11292
11293	var sv *types.RootNotFoundException
11294	if *v == nil {
11295		sv = &types.RootNotFoundException{}
11296	} else {
11297		sv = *v
11298	}
11299
11300	for key, value := range shape {
11301		switch key {
11302		case "Message":
11303			if value != nil {
11304				jtv, ok := value.(string)
11305				if !ok {
11306					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
11307				}
11308				sv.Message = ptr.String(jtv)
11309			}
11310
11311		default:
11312			_, _ = key, value
11313
11314		}
11315	}
11316	*v = sv
11317	return nil
11318}
11319
11320func awsAwsjson11_deserializeDocumentRoots(v *[]types.Root, value interface{}) error {
11321	if v == nil {
11322		return fmt.Errorf("unexpected nil of type %T", v)
11323	}
11324	if value == nil {
11325		return nil
11326	}
11327
11328	shape, ok := value.([]interface{})
11329	if !ok {
11330		return fmt.Errorf("unexpected JSON type %v", value)
11331	}
11332
11333	var cv []types.Root
11334	if *v == nil {
11335		cv = []types.Root{}
11336	} else {
11337		cv = *v
11338	}
11339
11340	for _, value := range shape {
11341		var col types.Root
11342		destAddr := &col
11343		if err := awsAwsjson11_deserializeDocumentRoot(&destAddr, value); err != nil {
11344			return err
11345		}
11346		col = *destAddr
11347		cv = append(cv, col)
11348
11349	}
11350	*v = cv
11351	return nil
11352}
11353
11354func awsAwsjson11_deserializeDocumentServiceException(v **types.ServiceException, value interface{}) error {
11355	if v == nil {
11356		return fmt.Errorf("unexpected nil of type %T", v)
11357	}
11358	if value == nil {
11359		return nil
11360	}
11361
11362	shape, ok := value.(map[string]interface{})
11363	if !ok {
11364		return fmt.Errorf("unexpected JSON type %v", value)
11365	}
11366
11367	var sv *types.ServiceException
11368	if *v == nil {
11369		sv = &types.ServiceException{}
11370	} else {
11371		sv = *v
11372	}
11373
11374	for key, value := range shape {
11375		switch key {
11376		case "Message":
11377			if value != nil {
11378				jtv, ok := value.(string)
11379				if !ok {
11380					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
11381				}
11382				sv.Message = ptr.String(jtv)
11383			}
11384
11385		default:
11386			_, _ = key, value
11387
11388		}
11389	}
11390	*v = sv
11391	return nil
11392}
11393
11394func awsAwsjson11_deserializeDocumentSourceParentNotFoundException(v **types.SourceParentNotFoundException, value interface{}) error {
11395	if v == nil {
11396		return fmt.Errorf("unexpected nil of type %T", v)
11397	}
11398	if value == nil {
11399		return nil
11400	}
11401
11402	shape, ok := value.(map[string]interface{})
11403	if !ok {
11404		return fmt.Errorf("unexpected JSON type %v", value)
11405	}
11406
11407	var sv *types.SourceParentNotFoundException
11408	if *v == nil {
11409		sv = &types.SourceParentNotFoundException{}
11410	} else {
11411		sv = *v
11412	}
11413
11414	for key, value := range shape {
11415		switch key {
11416		case "Message":
11417			if value != nil {
11418				jtv, ok := value.(string)
11419				if !ok {
11420					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
11421				}
11422				sv.Message = ptr.String(jtv)
11423			}
11424
11425		default:
11426			_, _ = key, value
11427
11428		}
11429	}
11430	*v = sv
11431	return nil
11432}
11433
11434func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error {
11435	if v == nil {
11436		return fmt.Errorf("unexpected nil of type %T", v)
11437	}
11438	if value == nil {
11439		return nil
11440	}
11441
11442	shape, ok := value.(map[string]interface{})
11443	if !ok {
11444		return fmt.Errorf("unexpected JSON type %v", value)
11445	}
11446
11447	var sv *types.Tag
11448	if *v == nil {
11449		sv = &types.Tag{}
11450	} else {
11451		sv = *v
11452	}
11453
11454	for key, value := range shape {
11455		switch key {
11456		case "Key":
11457			if value != nil {
11458				jtv, ok := value.(string)
11459				if !ok {
11460					return fmt.Errorf("expected TagKey to be of type string, got %T instead", value)
11461				}
11462				sv.Key = ptr.String(jtv)
11463			}
11464
11465		case "Value":
11466			if value != nil {
11467				jtv, ok := value.(string)
11468				if !ok {
11469					return fmt.Errorf("expected TagValue to be of type string, got %T instead", value)
11470				}
11471				sv.Value = ptr.String(jtv)
11472			}
11473
11474		default:
11475			_, _ = key, value
11476
11477		}
11478	}
11479	*v = sv
11480	return nil
11481}
11482
11483func awsAwsjson11_deserializeDocumentTags(v *[]types.Tag, value interface{}) error {
11484	if v == nil {
11485		return fmt.Errorf("unexpected nil of type %T", v)
11486	}
11487	if value == nil {
11488		return nil
11489	}
11490
11491	shape, ok := value.([]interface{})
11492	if !ok {
11493		return fmt.Errorf("unexpected JSON type %v", value)
11494	}
11495
11496	var cv []types.Tag
11497	if *v == nil {
11498		cv = []types.Tag{}
11499	} else {
11500		cv = *v
11501	}
11502
11503	for _, value := range shape {
11504		var col types.Tag
11505		destAddr := &col
11506		if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil {
11507			return err
11508		}
11509		col = *destAddr
11510		cv = append(cv, col)
11511
11512	}
11513	*v = cv
11514	return nil
11515}
11516
11517func awsAwsjson11_deserializeDocumentTargetNotFoundException(v **types.TargetNotFoundException, value interface{}) error {
11518	if v == nil {
11519		return fmt.Errorf("unexpected nil of type %T", v)
11520	}
11521	if value == nil {
11522		return nil
11523	}
11524
11525	shape, ok := value.(map[string]interface{})
11526	if !ok {
11527		return fmt.Errorf("unexpected JSON type %v", value)
11528	}
11529
11530	var sv *types.TargetNotFoundException
11531	if *v == nil {
11532		sv = &types.TargetNotFoundException{}
11533	} else {
11534		sv = *v
11535	}
11536
11537	for key, value := range shape {
11538		switch key {
11539		case "Message":
11540			if value != nil {
11541				jtv, ok := value.(string)
11542				if !ok {
11543					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
11544				}
11545				sv.Message = ptr.String(jtv)
11546			}
11547
11548		default:
11549			_, _ = key, value
11550
11551		}
11552	}
11553	*v = sv
11554	return nil
11555}
11556
11557func awsAwsjson11_deserializeDocumentTooManyRequestsException(v **types.TooManyRequestsException, value interface{}) error {
11558	if v == nil {
11559		return fmt.Errorf("unexpected nil of type %T", v)
11560	}
11561	if value == nil {
11562		return nil
11563	}
11564
11565	shape, ok := value.(map[string]interface{})
11566	if !ok {
11567		return fmt.Errorf("unexpected JSON type %v", value)
11568	}
11569
11570	var sv *types.TooManyRequestsException
11571	if *v == nil {
11572		sv = &types.TooManyRequestsException{}
11573	} else {
11574		sv = *v
11575	}
11576
11577	for key, value := range shape {
11578		switch key {
11579		case "Message":
11580			if value != nil {
11581				jtv, ok := value.(string)
11582				if !ok {
11583					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
11584				}
11585				sv.Message = ptr.String(jtv)
11586			}
11587
11588		case "Type":
11589			if value != nil {
11590				jtv, ok := value.(string)
11591				if !ok {
11592					return fmt.Errorf("expected ExceptionType to be of type string, got %T instead", value)
11593				}
11594				sv.Type = ptr.String(jtv)
11595			}
11596
11597		default:
11598			_, _ = key, value
11599
11600		}
11601	}
11602	*v = sv
11603	return nil
11604}
11605
11606func awsAwsjson11_deserializeDocumentUnsupportedAPIEndpointException(v **types.UnsupportedAPIEndpointException, value interface{}) error {
11607	if v == nil {
11608		return fmt.Errorf("unexpected nil of type %T", v)
11609	}
11610	if value == nil {
11611		return nil
11612	}
11613
11614	shape, ok := value.(map[string]interface{})
11615	if !ok {
11616		return fmt.Errorf("unexpected JSON type %v", value)
11617	}
11618
11619	var sv *types.UnsupportedAPIEndpointException
11620	if *v == nil {
11621		sv = &types.UnsupportedAPIEndpointException{}
11622	} else {
11623		sv = *v
11624	}
11625
11626	for key, value := range shape {
11627		switch key {
11628		case "Message":
11629			if value != nil {
11630				jtv, ok := value.(string)
11631				if !ok {
11632					return fmt.Errorf("expected ExceptionMessage to be of type string, got %T instead", value)
11633				}
11634				sv.Message = ptr.String(jtv)
11635			}
11636
11637		default:
11638			_, _ = key, value
11639
11640		}
11641	}
11642	*v = sv
11643	return nil
11644}
11645
11646func awsAwsjson11_deserializeOpDocumentAcceptHandshakeOutput(v **AcceptHandshakeOutput, value interface{}) error {
11647	if v == nil {
11648		return fmt.Errorf("unexpected nil of type %T", v)
11649	}
11650	if value == nil {
11651		return nil
11652	}
11653
11654	shape, ok := value.(map[string]interface{})
11655	if !ok {
11656		return fmt.Errorf("unexpected JSON type %v", value)
11657	}
11658
11659	var sv *AcceptHandshakeOutput
11660	if *v == nil {
11661		sv = &AcceptHandshakeOutput{}
11662	} else {
11663		sv = *v
11664	}
11665
11666	for key, value := range shape {
11667		switch key {
11668		case "Handshake":
11669			if err := awsAwsjson11_deserializeDocumentHandshake(&sv.Handshake, value); err != nil {
11670				return err
11671			}
11672
11673		default:
11674			_, _ = key, value
11675
11676		}
11677	}
11678	*v = sv
11679	return nil
11680}
11681
11682func awsAwsjson11_deserializeOpDocumentCancelHandshakeOutput(v **CancelHandshakeOutput, value interface{}) error {
11683	if v == nil {
11684		return fmt.Errorf("unexpected nil of type %T", v)
11685	}
11686	if value == nil {
11687		return nil
11688	}
11689
11690	shape, ok := value.(map[string]interface{})
11691	if !ok {
11692		return fmt.Errorf("unexpected JSON type %v", value)
11693	}
11694
11695	var sv *CancelHandshakeOutput
11696	if *v == nil {
11697		sv = &CancelHandshakeOutput{}
11698	} else {
11699		sv = *v
11700	}
11701
11702	for key, value := range shape {
11703		switch key {
11704		case "Handshake":
11705			if err := awsAwsjson11_deserializeDocumentHandshake(&sv.Handshake, value); err != nil {
11706				return err
11707			}
11708
11709		default:
11710			_, _ = key, value
11711
11712		}
11713	}
11714	*v = sv
11715	return nil
11716}
11717
11718func awsAwsjson11_deserializeOpDocumentCreateAccountOutput(v **CreateAccountOutput, value interface{}) error {
11719	if v == nil {
11720		return fmt.Errorf("unexpected nil of type %T", v)
11721	}
11722	if value == nil {
11723		return nil
11724	}
11725
11726	shape, ok := value.(map[string]interface{})
11727	if !ok {
11728		return fmt.Errorf("unexpected JSON type %v", value)
11729	}
11730
11731	var sv *CreateAccountOutput
11732	if *v == nil {
11733		sv = &CreateAccountOutput{}
11734	} else {
11735		sv = *v
11736	}
11737
11738	for key, value := range shape {
11739		switch key {
11740		case "CreateAccountStatus":
11741			if err := awsAwsjson11_deserializeDocumentCreateAccountStatus(&sv.CreateAccountStatus, value); err != nil {
11742				return err
11743			}
11744
11745		default:
11746			_, _ = key, value
11747
11748		}
11749	}
11750	*v = sv
11751	return nil
11752}
11753
11754func awsAwsjson11_deserializeOpDocumentCreateGovCloudAccountOutput(v **CreateGovCloudAccountOutput, value interface{}) error {
11755	if v == nil {
11756		return fmt.Errorf("unexpected nil of type %T", v)
11757	}
11758	if value == nil {
11759		return nil
11760	}
11761
11762	shape, ok := value.(map[string]interface{})
11763	if !ok {
11764		return fmt.Errorf("unexpected JSON type %v", value)
11765	}
11766
11767	var sv *CreateGovCloudAccountOutput
11768	if *v == nil {
11769		sv = &CreateGovCloudAccountOutput{}
11770	} else {
11771		sv = *v
11772	}
11773
11774	for key, value := range shape {
11775		switch key {
11776		case "CreateAccountStatus":
11777			if err := awsAwsjson11_deserializeDocumentCreateAccountStatus(&sv.CreateAccountStatus, value); err != nil {
11778				return err
11779			}
11780
11781		default:
11782			_, _ = key, value
11783
11784		}
11785	}
11786	*v = sv
11787	return nil
11788}
11789
11790func awsAwsjson11_deserializeOpDocumentCreateOrganizationalUnitOutput(v **CreateOrganizationalUnitOutput, value interface{}) error {
11791	if v == nil {
11792		return fmt.Errorf("unexpected nil of type %T", v)
11793	}
11794	if value == nil {
11795		return nil
11796	}
11797
11798	shape, ok := value.(map[string]interface{})
11799	if !ok {
11800		return fmt.Errorf("unexpected JSON type %v", value)
11801	}
11802
11803	var sv *CreateOrganizationalUnitOutput
11804	if *v == nil {
11805		sv = &CreateOrganizationalUnitOutput{}
11806	} else {
11807		sv = *v
11808	}
11809
11810	for key, value := range shape {
11811		switch key {
11812		case "OrganizationalUnit":
11813			if err := awsAwsjson11_deserializeDocumentOrganizationalUnit(&sv.OrganizationalUnit, value); err != nil {
11814				return err
11815			}
11816
11817		default:
11818			_, _ = key, value
11819
11820		}
11821	}
11822	*v = sv
11823	return nil
11824}
11825
11826func awsAwsjson11_deserializeOpDocumentCreateOrganizationOutput(v **CreateOrganizationOutput, value interface{}) error {
11827	if v == nil {
11828		return fmt.Errorf("unexpected nil of type %T", v)
11829	}
11830	if value == nil {
11831		return nil
11832	}
11833
11834	shape, ok := value.(map[string]interface{})
11835	if !ok {
11836		return fmt.Errorf("unexpected JSON type %v", value)
11837	}
11838
11839	var sv *CreateOrganizationOutput
11840	if *v == nil {
11841		sv = &CreateOrganizationOutput{}
11842	} else {
11843		sv = *v
11844	}
11845
11846	for key, value := range shape {
11847		switch key {
11848		case "Organization":
11849			if err := awsAwsjson11_deserializeDocumentOrganization(&sv.Organization, value); err != nil {
11850				return err
11851			}
11852
11853		default:
11854			_, _ = key, value
11855
11856		}
11857	}
11858	*v = sv
11859	return nil
11860}
11861
11862func awsAwsjson11_deserializeOpDocumentCreatePolicyOutput(v **CreatePolicyOutput, value interface{}) error {
11863	if v == nil {
11864		return fmt.Errorf("unexpected nil of type %T", v)
11865	}
11866	if value == nil {
11867		return nil
11868	}
11869
11870	shape, ok := value.(map[string]interface{})
11871	if !ok {
11872		return fmt.Errorf("unexpected JSON type %v", value)
11873	}
11874
11875	var sv *CreatePolicyOutput
11876	if *v == nil {
11877		sv = &CreatePolicyOutput{}
11878	} else {
11879		sv = *v
11880	}
11881
11882	for key, value := range shape {
11883		switch key {
11884		case "Policy":
11885			if err := awsAwsjson11_deserializeDocumentPolicy(&sv.Policy, value); err != nil {
11886				return err
11887			}
11888
11889		default:
11890			_, _ = key, value
11891
11892		}
11893	}
11894	*v = sv
11895	return nil
11896}
11897
11898func awsAwsjson11_deserializeOpDocumentDeclineHandshakeOutput(v **DeclineHandshakeOutput, value interface{}) error {
11899	if v == nil {
11900		return fmt.Errorf("unexpected nil of type %T", v)
11901	}
11902	if value == nil {
11903		return nil
11904	}
11905
11906	shape, ok := value.(map[string]interface{})
11907	if !ok {
11908		return fmt.Errorf("unexpected JSON type %v", value)
11909	}
11910
11911	var sv *DeclineHandshakeOutput
11912	if *v == nil {
11913		sv = &DeclineHandshakeOutput{}
11914	} else {
11915		sv = *v
11916	}
11917
11918	for key, value := range shape {
11919		switch key {
11920		case "Handshake":
11921			if err := awsAwsjson11_deserializeDocumentHandshake(&sv.Handshake, value); err != nil {
11922				return err
11923			}
11924
11925		default:
11926			_, _ = key, value
11927
11928		}
11929	}
11930	*v = sv
11931	return nil
11932}
11933
11934func awsAwsjson11_deserializeOpDocumentDescribeAccountOutput(v **DescribeAccountOutput, value interface{}) error {
11935	if v == nil {
11936		return fmt.Errorf("unexpected nil of type %T", v)
11937	}
11938	if value == nil {
11939		return nil
11940	}
11941
11942	shape, ok := value.(map[string]interface{})
11943	if !ok {
11944		return fmt.Errorf("unexpected JSON type %v", value)
11945	}
11946
11947	var sv *DescribeAccountOutput
11948	if *v == nil {
11949		sv = &DescribeAccountOutput{}
11950	} else {
11951		sv = *v
11952	}
11953
11954	for key, value := range shape {
11955		switch key {
11956		case "Account":
11957			if err := awsAwsjson11_deserializeDocumentAccount(&sv.Account, value); err != nil {
11958				return err
11959			}
11960
11961		default:
11962			_, _ = key, value
11963
11964		}
11965	}
11966	*v = sv
11967	return nil
11968}
11969
11970func awsAwsjson11_deserializeOpDocumentDescribeCreateAccountStatusOutput(v **DescribeCreateAccountStatusOutput, value interface{}) error {
11971	if v == nil {
11972		return fmt.Errorf("unexpected nil of type %T", v)
11973	}
11974	if value == nil {
11975		return nil
11976	}
11977
11978	shape, ok := value.(map[string]interface{})
11979	if !ok {
11980		return fmt.Errorf("unexpected JSON type %v", value)
11981	}
11982
11983	var sv *DescribeCreateAccountStatusOutput
11984	if *v == nil {
11985		sv = &DescribeCreateAccountStatusOutput{}
11986	} else {
11987		sv = *v
11988	}
11989
11990	for key, value := range shape {
11991		switch key {
11992		case "CreateAccountStatus":
11993			if err := awsAwsjson11_deserializeDocumentCreateAccountStatus(&sv.CreateAccountStatus, value); err != nil {
11994				return err
11995			}
11996
11997		default:
11998			_, _ = key, value
11999
12000		}
12001	}
12002	*v = sv
12003	return nil
12004}
12005
12006func awsAwsjson11_deserializeOpDocumentDescribeEffectivePolicyOutput(v **DescribeEffectivePolicyOutput, value interface{}) error {
12007	if v == nil {
12008		return fmt.Errorf("unexpected nil of type %T", v)
12009	}
12010	if value == nil {
12011		return nil
12012	}
12013
12014	shape, ok := value.(map[string]interface{})
12015	if !ok {
12016		return fmt.Errorf("unexpected JSON type %v", value)
12017	}
12018
12019	var sv *DescribeEffectivePolicyOutput
12020	if *v == nil {
12021		sv = &DescribeEffectivePolicyOutput{}
12022	} else {
12023		sv = *v
12024	}
12025
12026	for key, value := range shape {
12027		switch key {
12028		case "EffectivePolicy":
12029			if err := awsAwsjson11_deserializeDocumentEffectivePolicy(&sv.EffectivePolicy, value); err != nil {
12030				return err
12031			}
12032
12033		default:
12034			_, _ = key, value
12035
12036		}
12037	}
12038	*v = sv
12039	return nil
12040}
12041
12042func awsAwsjson11_deserializeOpDocumentDescribeHandshakeOutput(v **DescribeHandshakeOutput, value interface{}) error {
12043	if v == nil {
12044		return fmt.Errorf("unexpected nil of type %T", v)
12045	}
12046	if value == nil {
12047		return nil
12048	}
12049
12050	shape, ok := value.(map[string]interface{})
12051	if !ok {
12052		return fmt.Errorf("unexpected JSON type %v", value)
12053	}
12054
12055	var sv *DescribeHandshakeOutput
12056	if *v == nil {
12057		sv = &DescribeHandshakeOutput{}
12058	} else {
12059		sv = *v
12060	}
12061
12062	for key, value := range shape {
12063		switch key {
12064		case "Handshake":
12065			if err := awsAwsjson11_deserializeDocumentHandshake(&sv.Handshake, value); err != nil {
12066				return err
12067			}
12068
12069		default:
12070			_, _ = key, value
12071
12072		}
12073	}
12074	*v = sv
12075	return nil
12076}
12077
12078func awsAwsjson11_deserializeOpDocumentDescribeOrganizationalUnitOutput(v **DescribeOrganizationalUnitOutput, value interface{}) error {
12079	if v == nil {
12080		return fmt.Errorf("unexpected nil of type %T", v)
12081	}
12082	if value == nil {
12083		return nil
12084	}
12085
12086	shape, ok := value.(map[string]interface{})
12087	if !ok {
12088		return fmt.Errorf("unexpected JSON type %v", value)
12089	}
12090
12091	var sv *DescribeOrganizationalUnitOutput
12092	if *v == nil {
12093		sv = &DescribeOrganizationalUnitOutput{}
12094	} else {
12095		sv = *v
12096	}
12097
12098	for key, value := range shape {
12099		switch key {
12100		case "OrganizationalUnit":
12101			if err := awsAwsjson11_deserializeDocumentOrganizationalUnit(&sv.OrganizationalUnit, value); err != nil {
12102				return err
12103			}
12104
12105		default:
12106			_, _ = key, value
12107
12108		}
12109	}
12110	*v = sv
12111	return nil
12112}
12113
12114func awsAwsjson11_deserializeOpDocumentDescribeOrganizationOutput(v **DescribeOrganizationOutput, value interface{}) error {
12115	if v == nil {
12116		return fmt.Errorf("unexpected nil of type %T", v)
12117	}
12118	if value == nil {
12119		return nil
12120	}
12121
12122	shape, ok := value.(map[string]interface{})
12123	if !ok {
12124		return fmt.Errorf("unexpected JSON type %v", value)
12125	}
12126
12127	var sv *DescribeOrganizationOutput
12128	if *v == nil {
12129		sv = &DescribeOrganizationOutput{}
12130	} else {
12131		sv = *v
12132	}
12133
12134	for key, value := range shape {
12135		switch key {
12136		case "Organization":
12137			if err := awsAwsjson11_deserializeDocumentOrganization(&sv.Organization, value); err != nil {
12138				return err
12139			}
12140
12141		default:
12142			_, _ = key, value
12143
12144		}
12145	}
12146	*v = sv
12147	return nil
12148}
12149
12150func awsAwsjson11_deserializeOpDocumentDescribePolicyOutput(v **DescribePolicyOutput, value interface{}) error {
12151	if v == nil {
12152		return fmt.Errorf("unexpected nil of type %T", v)
12153	}
12154	if value == nil {
12155		return nil
12156	}
12157
12158	shape, ok := value.(map[string]interface{})
12159	if !ok {
12160		return fmt.Errorf("unexpected JSON type %v", value)
12161	}
12162
12163	var sv *DescribePolicyOutput
12164	if *v == nil {
12165		sv = &DescribePolicyOutput{}
12166	} else {
12167		sv = *v
12168	}
12169
12170	for key, value := range shape {
12171		switch key {
12172		case "Policy":
12173			if err := awsAwsjson11_deserializeDocumentPolicy(&sv.Policy, value); err != nil {
12174				return err
12175			}
12176
12177		default:
12178			_, _ = key, value
12179
12180		}
12181	}
12182	*v = sv
12183	return nil
12184}
12185
12186func awsAwsjson11_deserializeOpDocumentDisablePolicyTypeOutput(v **DisablePolicyTypeOutput, value interface{}) error {
12187	if v == nil {
12188		return fmt.Errorf("unexpected nil of type %T", v)
12189	}
12190	if value == nil {
12191		return nil
12192	}
12193
12194	shape, ok := value.(map[string]interface{})
12195	if !ok {
12196		return fmt.Errorf("unexpected JSON type %v", value)
12197	}
12198
12199	var sv *DisablePolicyTypeOutput
12200	if *v == nil {
12201		sv = &DisablePolicyTypeOutput{}
12202	} else {
12203		sv = *v
12204	}
12205
12206	for key, value := range shape {
12207		switch key {
12208		case "Root":
12209			if err := awsAwsjson11_deserializeDocumentRoot(&sv.Root, value); err != nil {
12210				return err
12211			}
12212
12213		default:
12214			_, _ = key, value
12215
12216		}
12217	}
12218	*v = sv
12219	return nil
12220}
12221
12222func awsAwsjson11_deserializeOpDocumentEnableAllFeaturesOutput(v **EnableAllFeaturesOutput, value interface{}) error {
12223	if v == nil {
12224		return fmt.Errorf("unexpected nil of type %T", v)
12225	}
12226	if value == nil {
12227		return nil
12228	}
12229
12230	shape, ok := value.(map[string]interface{})
12231	if !ok {
12232		return fmt.Errorf("unexpected JSON type %v", value)
12233	}
12234
12235	var sv *EnableAllFeaturesOutput
12236	if *v == nil {
12237		sv = &EnableAllFeaturesOutput{}
12238	} else {
12239		sv = *v
12240	}
12241
12242	for key, value := range shape {
12243		switch key {
12244		case "Handshake":
12245			if err := awsAwsjson11_deserializeDocumentHandshake(&sv.Handshake, value); err != nil {
12246				return err
12247			}
12248
12249		default:
12250			_, _ = key, value
12251
12252		}
12253	}
12254	*v = sv
12255	return nil
12256}
12257
12258func awsAwsjson11_deserializeOpDocumentEnablePolicyTypeOutput(v **EnablePolicyTypeOutput, value interface{}) error {
12259	if v == nil {
12260		return fmt.Errorf("unexpected nil of type %T", v)
12261	}
12262	if value == nil {
12263		return nil
12264	}
12265
12266	shape, ok := value.(map[string]interface{})
12267	if !ok {
12268		return fmt.Errorf("unexpected JSON type %v", value)
12269	}
12270
12271	var sv *EnablePolicyTypeOutput
12272	if *v == nil {
12273		sv = &EnablePolicyTypeOutput{}
12274	} else {
12275		sv = *v
12276	}
12277
12278	for key, value := range shape {
12279		switch key {
12280		case "Root":
12281			if err := awsAwsjson11_deserializeDocumentRoot(&sv.Root, value); err != nil {
12282				return err
12283			}
12284
12285		default:
12286			_, _ = key, value
12287
12288		}
12289	}
12290	*v = sv
12291	return nil
12292}
12293
12294func awsAwsjson11_deserializeOpDocumentInviteAccountToOrganizationOutput(v **InviteAccountToOrganizationOutput, value interface{}) error {
12295	if v == nil {
12296		return fmt.Errorf("unexpected nil of type %T", v)
12297	}
12298	if value == nil {
12299		return nil
12300	}
12301
12302	shape, ok := value.(map[string]interface{})
12303	if !ok {
12304		return fmt.Errorf("unexpected JSON type %v", value)
12305	}
12306
12307	var sv *InviteAccountToOrganizationOutput
12308	if *v == nil {
12309		sv = &InviteAccountToOrganizationOutput{}
12310	} else {
12311		sv = *v
12312	}
12313
12314	for key, value := range shape {
12315		switch key {
12316		case "Handshake":
12317			if err := awsAwsjson11_deserializeDocumentHandshake(&sv.Handshake, value); err != nil {
12318				return err
12319			}
12320
12321		default:
12322			_, _ = key, value
12323
12324		}
12325	}
12326	*v = sv
12327	return nil
12328}
12329
12330func awsAwsjson11_deserializeOpDocumentListAccountsForParentOutput(v **ListAccountsForParentOutput, value interface{}) error {
12331	if v == nil {
12332		return fmt.Errorf("unexpected nil of type %T", v)
12333	}
12334	if value == nil {
12335		return nil
12336	}
12337
12338	shape, ok := value.(map[string]interface{})
12339	if !ok {
12340		return fmt.Errorf("unexpected JSON type %v", value)
12341	}
12342
12343	var sv *ListAccountsForParentOutput
12344	if *v == nil {
12345		sv = &ListAccountsForParentOutput{}
12346	} else {
12347		sv = *v
12348	}
12349
12350	for key, value := range shape {
12351		switch key {
12352		case "Accounts":
12353			if err := awsAwsjson11_deserializeDocumentAccounts(&sv.Accounts, value); err != nil {
12354				return err
12355			}
12356
12357		case "NextToken":
12358			if value != nil {
12359				jtv, ok := value.(string)
12360				if !ok {
12361					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12362				}
12363				sv.NextToken = ptr.String(jtv)
12364			}
12365
12366		default:
12367			_, _ = key, value
12368
12369		}
12370	}
12371	*v = sv
12372	return nil
12373}
12374
12375func awsAwsjson11_deserializeOpDocumentListAccountsOutput(v **ListAccountsOutput, value interface{}) error {
12376	if v == nil {
12377		return fmt.Errorf("unexpected nil of type %T", v)
12378	}
12379	if value == nil {
12380		return nil
12381	}
12382
12383	shape, ok := value.(map[string]interface{})
12384	if !ok {
12385		return fmt.Errorf("unexpected JSON type %v", value)
12386	}
12387
12388	var sv *ListAccountsOutput
12389	if *v == nil {
12390		sv = &ListAccountsOutput{}
12391	} else {
12392		sv = *v
12393	}
12394
12395	for key, value := range shape {
12396		switch key {
12397		case "Accounts":
12398			if err := awsAwsjson11_deserializeDocumentAccounts(&sv.Accounts, value); err != nil {
12399				return err
12400			}
12401
12402		case "NextToken":
12403			if value != nil {
12404				jtv, ok := value.(string)
12405				if !ok {
12406					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12407				}
12408				sv.NextToken = ptr.String(jtv)
12409			}
12410
12411		default:
12412			_, _ = key, value
12413
12414		}
12415	}
12416	*v = sv
12417	return nil
12418}
12419
12420func awsAwsjson11_deserializeOpDocumentListAWSServiceAccessForOrganizationOutput(v **ListAWSServiceAccessForOrganizationOutput, value interface{}) error {
12421	if v == nil {
12422		return fmt.Errorf("unexpected nil of type %T", v)
12423	}
12424	if value == nil {
12425		return nil
12426	}
12427
12428	shape, ok := value.(map[string]interface{})
12429	if !ok {
12430		return fmt.Errorf("unexpected JSON type %v", value)
12431	}
12432
12433	var sv *ListAWSServiceAccessForOrganizationOutput
12434	if *v == nil {
12435		sv = &ListAWSServiceAccessForOrganizationOutput{}
12436	} else {
12437		sv = *v
12438	}
12439
12440	for key, value := range shape {
12441		switch key {
12442		case "EnabledServicePrincipals":
12443			if err := awsAwsjson11_deserializeDocumentEnabledServicePrincipals(&sv.EnabledServicePrincipals, value); err != nil {
12444				return err
12445			}
12446
12447		case "NextToken":
12448			if value != nil {
12449				jtv, ok := value.(string)
12450				if !ok {
12451					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12452				}
12453				sv.NextToken = ptr.String(jtv)
12454			}
12455
12456		default:
12457			_, _ = key, value
12458
12459		}
12460	}
12461	*v = sv
12462	return nil
12463}
12464
12465func awsAwsjson11_deserializeOpDocumentListChildrenOutput(v **ListChildrenOutput, value interface{}) error {
12466	if v == nil {
12467		return fmt.Errorf("unexpected nil of type %T", v)
12468	}
12469	if value == nil {
12470		return nil
12471	}
12472
12473	shape, ok := value.(map[string]interface{})
12474	if !ok {
12475		return fmt.Errorf("unexpected JSON type %v", value)
12476	}
12477
12478	var sv *ListChildrenOutput
12479	if *v == nil {
12480		sv = &ListChildrenOutput{}
12481	} else {
12482		sv = *v
12483	}
12484
12485	for key, value := range shape {
12486		switch key {
12487		case "Children":
12488			if err := awsAwsjson11_deserializeDocumentChildren(&sv.Children, value); err != nil {
12489				return err
12490			}
12491
12492		case "NextToken":
12493			if value != nil {
12494				jtv, ok := value.(string)
12495				if !ok {
12496					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12497				}
12498				sv.NextToken = ptr.String(jtv)
12499			}
12500
12501		default:
12502			_, _ = key, value
12503
12504		}
12505	}
12506	*v = sv
12507	return nil
12508}
12509
12510func awsAwsjson11_deserializeOpDocumentListCreateAccountStatusOutput(v **ListCreateAccountStatusOutput, value interface{}) error {
12511	if v == nil {
12512		return fmt.Errorf("unexpected nil of type %T", v)
12513	}
12514	if value == nil {
12515		return nil
12516	}
12517
12518	shape, ok := value.(map[string]interface{})
12519	if !ok {
12520		return fmt.Errorf("unexpected JSON type %v", value)
12521	}
12522
12523	var sv *ListCreateAccountStatusOutput
12524	if *v == nil {
12525		sv = &ListCreateAccountStatusOutput{}
12526	} else {
12527		sv = *v
12528	}
12529
12530	for key, value := range shape {
12531		switch key {
12532		case "CreateAccountStatuses":
12533			if err := awsAwsjson11_deserializeDocumentCreateAccountStatuses(&sv.CreateAccountStatuses, value); err != nil {
12534				return err
12535			}
12536
12537		case "NextToken":
12538			if value != nil {
12539				jtv, ok := value.(string)
12540				if !ok {
12541					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12542				}
12543				sv.NextToken = ptr.String(jtv)
12544			}
12545
12546		default:
12547			_, _ = key, value
12548
12549		}
12550	}
12551	*v = sv
12552	return nil
12553}
12554
12555func awsAwsjson11_deserializeOpDocumentListDelegatedAdministratorsOutput(v **ListDelegatedAdministratorsOutput, value interface{}) error {
12556	if v == nil {
12557		return fmt.Errorf("unexpected nil of type %T", v)
12558	}
12559	if value == nil {
12560		return nil
12561	}
12562
12563	shape, ok := value.(map[string]interface{})
12564	if !ok {
12565		return fmt.Errorf("unexpected JSON type %v", value)
12566	}
12567
12568	var sv *ListDelegatedAdministratorsOutput
12569	if *v == nil {
12570		sv = &ListDelegatedAdministratorsOutput{}
12571	} else {
12572		sv = *v
12573	}
12574
12575	for key, value := range shape {
12576		switch key {
12577		case "DelegatedAdministrators":
12578			if err := awsAwsjson11_deserializeDocumentDelegatedAdministrators(&sv.DelegatedAdministrators, value); err != nil {
12579				return err
12580			}
12581
12582		case "NextToken":
12583			if value != nil {
12584				jtv, ok := value.(string)
12585				if !ok {
12586					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12587				}
12588				sv.NextToken = ptr.String(jtv)
12589			}
12590
12591		default:
12592			_, _ = key, value
12593
12594		}
12595	}
12596	*v = sv
12597	return nil
12598}
12599
12600func awsAwsjson11_deserializeOpDocumentListDelegatedServicesForAccountOutput(v **ListDelegatedServicesForAccountOutput, value interface{}) error {
12601	if v == nil {
12602		return fmt.Errorf("unexpected nil of type %T", v)
12603	}
12604	if value == nil {
12605		return nil
12606	}
12607
12608	shape, ok := value.(map[string]interface{})
12609	if !ok {
12610		return fmt.Errorf("unexpected JSON type %v", value)
12611	}
12612
12613	var sv *ListDelegatedServicesForAccountOutput
12614	if *v == nil {
12615		sv = &ListDelegatedServicesForAccountOutput{}
12616	} else {
12617		sv = *v
12618	}
12619
12620	for key, value := range shape {
12621		switch key {
12622		case "DelegatedServices":
12623			if err := awsAwsjson11_deserializeDocumentDelegatedServices(&sv.DelegatedServices, value); err != nil {
12624				return err
12625			}
12626
12627		case "NextToken":
12628			if value != nil {
12629				jtv, ok := value.(string)
12630				if !ok {
12631					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12632				}
12633				sv.NextToken = ptr.String(jtv)
12634			}
12635
12636		default:
12637			_, _ = key, value
12638
12639		}
12640	}
12641	*v = sv
12642	return nil
12643}
12644
12645func awsAwsjson11_deserializeOpDocumentListHandshakesForAccountOutput(v **ListHandshakesForAccountOutput, value interface{}) error {
12646	if v == nil {
12647		return fmt.Errorf("unexpected nil of type %T", v)
12648	}
12649	if value == nil {
12650		return nil
12651	}
12652
12653	shape, ok := value.(map[string]interface{})
12654	if !ok {
12655		return fmt.Errorf("unexpected JSON type %v", value)
12656	}
12657
12658	var sv *ListHandshakesForAccountOutput
12659	if *v == nil {
12660		sv = &ListHandshakesForAccountOutput{}
12661	} else {
12662		sv = *v
12663	}
12664
12665	for key, value := range shape {
12666		switch key {
12667		case "Handshakes":
12668			if err := awsAwsjson11_deserializeDocumentHandshakes(&sv.Handshakes, value); err != nil {
12669				return err
12670			}
12671
12672		case "NextToken":
12673			if value != nil {
12674				jtv, ok := value.(string)
12675				if !ok {
12676					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12677				}
12678				sv.NextToken = ptr.String(jtv)
12679			}
12680
12681		default:
12682			_, _ = key, value
12683
12684		}
12685	}
12686	*v = sv
12687	return nil
12688}
12689
12690func awsAwsjson11_deserializeOpDocumentListHandshakesForOrganizationOutput(v **ListHandshakesForOrganizationOutput, value interface{}) error {
12691	if v == nil {
12692		return fmt.Errorf("unexpected nil of type %T", v)
12693	}
12694	if value == nil {
12695		return nil
12696	}
12697
12698	shape, ok := value.(map[string]interface{})
12699	if !ok {
12700		return fmt.Errorf("unexpected JSON type %v", value)
12701	}
12702
12703	var sv *ListHandshakesForOrganizationOutput
12704	if *v == nil {
12705		sv = &ListHandshakesForOrganizationOutput{}
12706	} else {
12707		sv = *v
12708	}
12709
12710	for key, value := range shape {
12711		switch key {
12712		case "Handshakes":
12713			if err := awsAwsjson11_deserializeDocumentHandshakes(&sv.Handshakes, value); err != nil {
12714				return err
12715			}
12716
12717		case "NextToken":
12718			if value != nil {
12719				jtv, ok := value.(string)
12720				if !ok {
12721					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12722				}
12723				sv.NextToken = ptr.String(jtv)
12724			}
12725
12726		default:
12727			_, _ = key, value
12728
12729		}
12730	}
12731	*v = sv
12732	return nil
12733}
12734
12735func awsAwsjson11_deserializeOpDocumentListOrganizationalUnitsForParentOutput(v **ListOrganizationalUnitsForParentOutput, value interface{}) error {
12736	if v == nil {
12737		return fmt.Errorf("unexpected nil of type %T", v)
12738	}
12739	if value == nil {
12740		return nil
12741	}
12742
12743	shape, ok := value.(map[string]interface{})
12744	if !ok {
12745		return fmt.Errorf("unexpected JSON type %v", value)
12746	}
12747
12748	var sv *ListOrganizationalUnitsForParentOutput
12749	if *v == nil {
12750		sv = &ListOrganizationalUnitsForParentOutput{}
12751	} else {
12752		sv = *v
12753	}
12754
12755	for key, value := range shape {
12756		switch key {
12757		case "NextToken":
12758			if value != nil {
12759				jtv, ok := value.(string)
12760				if !ok {
12761					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12762				}
12763				sv.NextToken = ptr.String(jtv)
12764			}
12765
12766		case "OrganizationalUnits":
12767			if err := awsAwsjson11_deserializeDocumentOrganizationalUnits(&sv.OrganizationalUnits, value); err != nil {
12768				return err
12769			}
12770
12771		default:
12772			_, _ = key, value
12773
12774		}
12775	}
12776	*v = sv
12777	return nil
12778}
12779
12780func awsAwsjson11_deserializeOpDocumentListParentsOutput(v **ListParentsOutput, value interface{}) error {
12781	if v == nil {
12782		return fmt.Errorf("unexpected nil of type %T", v)
12783	}
12784	if value == nil {
12785		return nil
12786	}
12787
12788	shape, ok := value.(map[string]interface{})
12789	if !ok {
12790		return fmt.Errorf("unexpected JSON type %v", value)
12791	}
12792
12793	var sv *ListParentsOutput
12794	if *v == nil {
12795		sv = &ListParentsOutput{}
12796	} else {
12797		sv = *v
12798	}
12799
12800	for key, value := range shape {
12801		switch key {
12802		case "NextToken":
12803			if value != nil {
12804				jtv, ok := value.(string)
12805				if !ok {
12806					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12807				}
12808				sv.NextToken = ptr.String(jtv)
12809			}
12810
12811		case "Parents":
12812			if err := awsAwsjson11_deserializeDocumentParents(&sv.Parents, value); err != nil {
12813				return err
12814			}
12815
12816		default:
12817			_, _ = key, value
12818
12819		}
12820	}
12821	*v = sv
12822	return nil
12823}
12824
12825func awsAwsjson11_deserializeOpDocumentListPoliciesForTargetOutput(v **ListPoliciesForTargetOutput, value interface{}) error {
12826	if v == nil {
12827		return fmt.Errorf("unexpected nil of type %T", v)
12828	}
12829	if value == nil {
12830		return nil
12831	}
12832
12833	shape, ok := value.(map[string]interface{})
12834	if !ok {
12835		return fmt.Errorf("unexpected JSON type %v", value)
12836	}
12837
12838	var sv *ListPoliciesForTargetOutput
12839	if *v == nil {
12840		sv = &ListPoliciesForTargetOutput{}
12841	} else {
12842		sv = *v
12843	}
12844
12845	for key, value := range shape {
12846		switch key {
12847		case "NextToken":
12848			if value != nil {
12849				jtv, ok := value.(string)
12850				if !ok {
12851					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12852				}
12853				sv.NextToken = ptr.String(jtv)
12854			}
12855
12856		case "Policies":
12857			if err := awsAwsjson11_deserializeDocumentPolicies(&sv.Policies, value); err != nil {
12858				return err
12859			}
12860
12861		default:
12862			_, _ = key, value
12863
12864		}
12865	}
12866	*v = sv
12867	return nil
12868}
12869
12870func awsAwsjson11_deserializeOpDocumentListPoliciesOutput(v **ListPoliciesOutput, value interface{}) error {
12871	if v == nil {
12872		return fmt.Errorf("unexpected nil of type %T", v)
12873	}
12874	if value == nil {
12875		return nil
12876	}
12877
12878	shape, ok := value.(map[string]interface{})
12879	if !ok {
12880		return fmt.Errorf("unexpected JSON type %v", value)
12881	}
12882
12883	var sv *ListPoliciesOutput
12884	if *v == nil {
12885		sv = &ListPoliciesOutput{}
12886	} else {
12887		sv = *v
12888	}
12889
12890	for key, value := range shape {
12891		switch key {
12892		case "NextToken":
12893			if value != nil {
12894				jtv, ok := value.(string)
12895				if !ok {
12896					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12897				}
12898				sv.NextToken = ptr.String(jtv)
12899			}
12900
12901		case "Policies":
12902			if err := awsAwsjson11_deserializeDocumentPolicies(&sv.Policies, value); err != nil {
12903				return err
12904			}
12905
12906		default:
12907			_, _ = key, value
12908
12909		}
12910	}
12911	*v = sv
12912	return nil
12913}
12914
12915func awsAwsjson11_deserializeOpDocumentListRootsOutput(v **ListRootsOutput, value interface{}) error {
12916	if v == nil {
12917		return fmt.Errorf("unexpected nil of type %T", v)
12918	}
12919	if value == nil {
12920		return nil
12921	}
12922
12923	shape, ok := value.(map[string]interface{})
12924	if !ok {
12925		return fmt.Errorf("unexpected JSON type %v", value)
12926	}
12927
12928	var sv *ListRootsOutput
12929	if *v == nil {
12930		sv = &ListRootsOutput{}
12931	} else {
12932		sv = *v
12933	}
12934
12935	for key, value := range shape {
12936		switch key {
12937		case "NextToken":
12938			if value != nil {
12939				jtv, ok := value.(string)
12940				if !ok {
12941					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12942				}
12943				sv.NextToken = ptr.String(jtv)
12944			}
12945
12946		case "Roots":
12947			if err := awsAwsjson11_deserializeDocumentRoots(&sv.Roots, value); err != nil {
12948				return err
12949			}
12950
12951		default:
12952			_, _ = key, value
12953
12954		}
12955	}
12956	*v = sv
12957	return nil
12958}
12959
12960func awsAwsjson11_deserializeOpDocumentListTagsForResourceOutput(v **ListTagsForResourceOutput, value interface{}) error {
12961	if v == nil {
12962		return fmt.Errorf("unexpected nil of type %T", v)
12963	}
12964	if value == nil {
12965		return nil
12966	}
12967
12968	shape, ok := value.(map[string]interface{})
12969	if !ok {
12970		return fmt.Errorf("unexpected JSON type %v", value)
12971	}
12972
12973	var sv *ListTagsForResourceOutput
12974	if *v == nil {
12975		sv = &ListTagsForResourceOutput{}
12976	} else {
12977		sv = *v
12978	}
12979
12980	for key, value := range shape {
12981		switch key {
12982		case "NextToken":
12983			if value != nil {
12984				jtv, ok := value.(string)
12985				if !ok {
12986					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
12987				}
12988				sv.NextToken = ptr.String(jtv)
12989			}
12990
12991		case "Tags":
12992			if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
12993				return err
12994			}
12995
12996		default:
12997			_, _ = key, value
12998
12999		}
13000	}
13001	*v = sv
13002	return nil
13003}
13004
13005func awsAwsjson11_deserializeOpDocumentListTargetsForPolicyOutput(v **ListTargetsForPolicyOutput, value interface{}) error {
13006	if v == nil {
13007		return fmt.Errorf("unexpected nil of type %T", v)
13008	}
13009	if value == nil {
13010		return nil
13011	}
13012
13013	shape, ok := value.(map[string]interface{})
13014	if !ok {
13015		return fmt.Errorf("unexpected JSON type %v", value)
13016	}
13017
13018	var sv *ListTargetsForPolicyOutput
13019	if *v == nil {
13020		sv = &ListTargetsForPolicyOutput{}
13021	} else {
13022		sv = *v
13023	}
13024
13025	for key, value := range shape {
13026		switch key {
13027		case "NextToken":
13028			if value != nil {
13029				jtv, ok := value.(string)
13030				if !ok {
13031					return fmt.Errorf("expected NextToken to be of type string, got %T instead", value)
13032				}
13033				sv.NextToken = ptr.String(jtv)
13034			}
13035
13036		case "Targets":
13037			if err := awsAwsjson11_deserializeDocumentPolicyTargets(&sv.Targets, value); err != nil {
13038				return err
13039			}
13040
13041		default:
13042			_, _ = key, value
13043
13044		}
13045	}
13046	*v = sv
13047	return nil
13048}
13049
13050func awsAwsjson11_deserializeOpDocumentUpdateOrganizationalUnitOutput(v **UpdateOrganizationalUnitOutput, value interface{}) error {
13051	if v == nil {
13052		return fmt.Errorf("unexpected nil of type %T", v)
13053	}
13054	if value == nil {
13055		return nil
13056	}
13057
13058	shape, ok := value.(map[string]interface{})
13059	if !ok {
13060		return fmt.Errorf("unexpected JSON type %v", value)
13061	}
13062
13063	var sv *UpdateOrganizationalUnitOutput
13064	if *v == nil {
13065		sv = &UpdateOrganizationalUnitOutput{}
13066	} else {
13067		sv = *v
13068	}
13069
13070	for key, value := range shape {
13071		switch key {
13072		case "OrganizationalUnit":
13073			if err := awsAwsjson11_deserializeDocumentOrganizationalUnit(&sv.OrganizationalUnit, value); err != nil {
13074				return err
13075			}
13076
13077		default:
13078			_, _ = key, value
13079
13080		}
13081	}
13082	*v = sv
13083	return nil
13084}
13085
13086func awsAwsjson11_deserializeOpDocumentUpdatePolicyOutput(v **UpdatePolicyOutput, value interface{}) error {
13087	if v == nil {
13088		return fmt.Errorf("unexpected nil of type %T", v)
13089	}
13090	if value == nil {
13091		return nil
13092	}
13093
13094	shape, ok := value.(map[string]interface{})
13095	if !ok {
13096		return fmt.Errorf("unexpected JSON type %v", value)
13097	}
13098
13099	var sv *UpdatePolicyOutput
13100	if *v == nil {
13101		sv = &UpdatePolicyOutput{}
13102	} else {
13103		sv = *v
13104	}
13105
13106	for key, value := range shape {
13107		switch key {
13108		case "Policy":
13109			if err := awsAwsjson11_deserializeDocumentPolicy(&sv.Policy, value); err != nil {
13110				return err
13111			}
13112
13113		default:
13114			_, _ = key, value
13115
13116		}
13117	}
13118	*v = sv
13119	return nil
13120}
13121