1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package servicecatalog
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/servicecatalog/types"
12	smithy "github.com/aws/smithy-go"
13	smithyio "github.com/aws/smithy-go/io"
14	"github.com/aws/smithy-go/middleware"
15	"github.com/aws/smithy-go/ptr"
16	smithytime "github.com/aws/smithy-go/time"
17	smithyhttp "github.com/aws/smithy-go/transport/http"
18	"io"
19	"strings"
20)
21
22type awsAwsjson11_deserializeOpAcceptPortfolioShare struct {
23}
24
25func (*awsAwsjson11_deserializeOpAcceptPortfolioShare) ID() string {
26	return "OperationDeserializer"
27}
28
29func (m *awsAwsjson11_deserializeOpAcceptPortfolioShare) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
30	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
31) {
32	out, metadata, err = next.HandleDeserialize(ctx, in)
33	if err != nil {
34		return out, metadata, err
35	}
36
37	response, ok := out.RawResponse.(*smithyhttp.Response)
38	if !ok {
39		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
40	}
41
42	if response.StatusCode < 200 || response.StatusCode >= 300 {
43		return out, metadata, awsAwsjson11_deserializeOpErrorAcceptPortfolioShare(response, &metadata)
44	}
45	output := &AcceptPortfolioShareOutput{}
46	out.Result = output
47
48	var buff [1024]byte
49	ringBuffer := smithyio.NewRingBuffer(buff[:])
50
51	body := io.TeeReader(response.Body, ringBuffer)
52	decoder := json.NewDecoder(body)
53	decoder.UseNumber()
54	var shape interface{}
55	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
56		var snapshot bytes.Buffer
57		io.Copy(&snapshot, ringBuffer)
58		err = &smithy.DeserializationError{
59			Err:      fmt.Errorf("failed to decode response body, %w", err),
60			Snapshot: snapshot.Bytes(),
61		}
62		return out, metadata, err
63	}
64
65	err = awsAwsjson11_deserializeOpDocumentAcceptPortfolioShareOutput(&output, shape)
66	if err != nil {
67		var snapshot bytes.Buffer
68		io.Copy(&snapshot, ringBuffer)
69		err = &smithy.DeserializationError{
70			Err:      fmt.Errorf("failed to decode response body, %w", err),
71			Snapshot: snapshot.Bytes(),
72		}
73		return out, metadata, err
74	}
75
76	return out, metadata, err
77}
78
79func awsAwsjson11_deserializeOpErrorAcceptPortfolioShare(response *smithyhttp.Response, metadata *middleware.Metadata) error {
80	var errorBuffer bytes.Buffer
81	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
82		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
83	}
84	errorBody := bytes.NewReader(errorBuffer.Bytes())
85
86	errorCode := "UnknownError"
87	errorMessage := errorCode
88
89	code := response.Header.Get("X-Amzn-ErrorType")
90	if len(code) != 0 {
91		errorCode = restjson.SanitizeErrorCode(code)
92	}
93
94	var buff [1024]byte
95	ringBuffer := smithyio.NewRingBuffer(buff[:])
96
97	body := io.TeeReader(errorBody, ringBuffer)
98	decoder := json.NewDecoder(body)
99	decoder.UseNumber()
100	code, message, err := restjson.GetErrorInfo(decoder)
101	if err != nil {
102		var snapshot bytes.Buffer
103		io.Copy(&snapshot, ringBuffer)
104		err = &smithy.DeserializationError{
105			Err:      fmt.Errorf("failed to decode response body, %w", err),
106			Snapshot: snapshot.Bytes(),
107		}
108		return err
109	}
110
111	errorBody.Seek(0, io.SeekStart)
112	if len(code) != 0 {
113		errorCode = restjson.SanitizeErrorCode(code)
114	}
115	if len(message) != 0 {
116		errorMessage = message
117	}
118
119	switch {
120	case strings.EqualFold("InvalidParametersException", errorCode):
121		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
122
123	case strings.EqualFold("LimitExceededException", errorCode):
124		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
125
126	case strings.EqualFold("ResourceNotFoundException", errorCode):
127		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
128
129	default:
130		genericError := &smithy.GenericAPIError{
131			Code:    errorCode,
132			Message: errorMessage,
133		}
134		return genericError
135
136	}
137}
138
139type awsAwsjson11_deserializeOpAssociateBudgetWithResource struct {
140}
141
142func (*awsAwsjson11_deserializeOpAssociateBudgetWithResource) ID() string {
143	return "OperationDeserializer"
144}
145
146func (m *awsAwsjson11_deserializeOpAssociateBudgetWithResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
147	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
148) {
149	out, metadata, err = next.HandleDeserialize(ctx, in)
150	if err != nil {
151		return out, metadata, err
152	}
153
154	response, ok := out.RawResponse.(*smithyhttp.Response)
155	if !ok {
156		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
157	}
158
159	if response.StatusCode < 200 || response.StatusCode >= 300 {
160		return out, metadata, awsAwsjson11_deserializeOpErrorAssociateBudgetWithResource(response, &metadata)
161	}
162	output := &AssociateBudgetWithResourceOutput{}
163	out.Result = output
164
165	var buff [1024]byte
166	ringBuffer := smithyio.NewRingBuffer(buff[:])
167
168	body := io.TeeReader(response.Body, ringBuffer)
169	decoder := json.NewDecoder(body)
170	decoder.UseNumber()
171	var shape interface{}
172	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
173		var snapshot bytes.Buffer
174		io.Copy(&snapshot, ringBuffer)
175		err = &smithy.DeserializationError{
176			Err:      fmt.Errorf("failed to decode response body, %w", err),
177			Snapshot: snapshot.Bytes(),
178		}
179		return out, metadata, err
180	}
181
182	err = awsAwsjson11_deserializeOpDocumentAssociateBudgetWithResourceOutput(&output, shape)
183	if err != nil {
184		var snapshot bytes.Buffer
185		io.Copy(&snapshot, ringBuffer)
186		err = &smithy.DeserializationError{
187			Err:      fmt.Errorf("failed to decode response body, %w", err),
188			Snapshot: snapshot.Bytes(),
189		}
190		return out, metadata, err
191	}
192
193	return out, metadata, err
194}
195
196func awsAwsjson11_deserializeOpErrorAssociateBudgetWithResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
197	var errorBuffer bytes.Buffer
198	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
199		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
200	}
201	errorBody := bytes.NewReader(errorBuffer.Bytes())
202
203	errorCode := "UnknownError"
204	errorMessage := errorCode
205
206	code := response.Header.Get("X-Amzn-ErrorType")
207	if len(code) != 0 {
208		errorCode = restjson.SanitizeErrorCode(code)
209	}
210
211	var buff [1024]byte
212	ringBuffer := smithyio.NewRingBuffer(buff[:])
213
214	body := io.TeeReader(errorBody, ringBuffer)
215	decoder := json.NewDecoder(body)
216	decoder.UseNumber()
217	code, message, err := restjson.GetErrorInfo(decoder)
218	if err != nil {
219		var snapshot bytes.Buffer
220		io.Copy(&snapshot, ringBuffer)
221		err = &smithy.DeserializationError{
222			Err:      fmt.Errorf("failed to decode response body, %w", err),
223			Snapshot: snapshot.Bytes(),
224		}
225		return err
226	}
227
228	errorBody.Seek(0, io.SeekStart)
229	if len(code) != 0 {
230		errorCode = restjson.SanitizeErrorCode(code)
231	}
232	if len(message) != 0 {
233		errorMessage = message
234	}
235
236	switch {
237	case strings.EqualFold("DuplicateResourceException", errorCode):
238		return awsAwsjson11_deserializeErrorDuplicateResourceException(response, errorBody)
239
240	case strings.EqualFold("InvalidParametersException", errorCode):
241		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
242
243	case strings.EqualFold("LimitExceededException", errorCode):
244		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
245
246	case strings.EqualFold("ResourceNotFoundException", errorCode):
247		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
248
249	default:
250		genericError := &smithy.GenericAPIError{
251			Code:    errorCode,
252			Message: errorMessage,
253		}
254		return genericError
255
256	}
257}
258
259type awsAwsjson11_deserializeOpAssociatePrincipalWithPortfolio struct {
260}
261
262func (*awsAwsjson11_deserializeOpAssociatePrincipalWithPortfolio) ID() string {
263	return "OperationDeserializer"
264}
265
266func (m *awsAwsjson11_deserializeOpAssociatePrincipalWithPortfolio) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
267	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
268) {
269	out, metadata, err = next.HandleDeserialize(ctx, in)
270	if err != nil {
271		return out, metadata, err
272	}
273
274	response, ok := out.RawResponse.(*smithyhttp.Response)
275	if !ok {
276		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
277	}
278
279	if response.StatusCode < 200 || response.StatusCode >= 300 {
280		return out, metadata, awsAwsjson11_deserializeOpErrorAssociatePrincipalWithPortfolio(response, &metadata)
281	}
282	output := &AssociatePrincipalWithPortfolioOutput{}
283	out.Result = output
284
285	var buff [1024]byte
286	ringBuffer := smithyio.NewRingBuffer(buff[:])
287
288	body := io.TeeReader(response.Body, ringBuffer)
289	decoder := json.NewDecoder(body)
290	decoder.UseNumber()
291	var shape interface{}
292	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
293		var snapshot bytes.Buffer
294		io.Copy(&snapshot, ringBuffer)
295		err = &smithy.DeserializationError{
296			Err:      fmt.Errorf("failed to decode response body, %w", err),
297			Snapshot: snapshot.Bytes(),
298		}
299		return out, metadata, err
300	}
301
302	err = awsAwsjson11_deserializeOpDocumentAssociatePrincipalWithPortfolioOutput(&output, shape)
303	if err != nil {
304		var snapshot bytes.Buffer
305		io.Copy(&snapshot, ringBuffer)
306		err = &smithy.DeserializationError{
307			Err:      fmt.Errorf("failed to decode response body, %w", err),
308			Snapshot: snapshot.Bytes(),
309		}
310		return out, metadata, err
311	}
312
313	return out, metadata, err
314}
315
316func awsAwsjson11_deserializeOpErrorAssociatePrincipalWithPortfolio(response *smithyhttp.Response, metadata *middleware.Metadata) error {
317	var errorBuffer bytes.Buffer
318	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
319		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
320	}
321	errorBody := bytes.NewReader(errorBuffer.Bytes())
322
323	errorCode := "UnknownError"
324	errorMessage := errorCode
325
326	code := response.Header.Get("X-Amzn-ErrorType")
327	if len(code) != 0 {
328		errorCode = restjson.SanitizeErrorCode(code)
329	}
330
331	var buff [1024]byte
332	ringBuffer := smithyio.NewRingBuffer(buff[:])
333
334	body := io.TeeReader(errorBody, ringBuffer)
335	decoder := json.NewDecoder(body)
336	decoder.UseNumber()
337	code, message, err := restjson.GetErrorInfo(decoder)
338	if err != nil {
339		var snapshot bytes.Buffer
340		io.Copy(&snapshot, ringBuffer)
341		err = &smithy.DeserializationError{
342			Err:      fmt.Errorf("failed to decode response body, %w", err),
343			Snapshot: snapshot.Bytes(),
344		}
345		return err
346	}
347
348	errorBody.Seek(0, io.SeekStart)
349	if len(code) != 0 {
350		errorCode = restjson.SanitizeErrorCode(code)
351	}
352	if len(message) != 0 {
353		errorMessage = message
354	}
355
356	switch {
357	case strings.EqualFold("InvalidParametersException", errorCode):
358		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
359
360	case strings.EqualFold("LimitExceededException", errorCode):
361		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
362
363	case strings.EqualFold("ResourceNotFoundException", errorCode):
364		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
365
366	default:
367		genericError := &smithy.GenericAPIError{
368			Code:    errorCode,
369			Message: errorMessage,
370		}
371		return genericError
372
373	}
374}
375
376type awsAwsjson11_deserializeOpAssociateProductWithPortfolio struct {
377}
378
379func (*awsAwsjson11_deserializeOpAssociateProductWithPortfolio) ID() string {
380	return "OperationDeserializer"
381}
382
383func (m *awsAwsjson11_deserializeOpAssociateProductWithPortfolio) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
384	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
385) {
386	out, metadata, err = next.HandleDeserialize(ctx, in)
387	if err != nil {
388		return out, metadata, err
389	}
390
391	response, ok := out.RawResponse.(*smithyhttp.Response)
392	if !ok {
393		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
394	}
395
396	if response.StatusCode < 200 || response.StatusCode >= 300 {
397		return out, metadata, awsAwsjson11_deserializeOpErrorAssociateProductWithPortfolio(response, &metadata)
398	}
399	output := &AssociateProductWithPortfolioOutput{}
400	out.Result = output
401
402	var buff [1024]byte
403	ringBuffer := smithyio.NewRingBuffer(buff[:])
404
405	body := io.TeeReader(response.Body, ringBuffer)
406	decoder := json.NewDecoder(body)
407	decoder.UseNumber()
408	var shape interface{}
409	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
410		var snapshot bytes.Buffer
411		io.Copy(&snapshot, ringBuffer)
412		err = &smithy.DeserializationError{
413			Err:      fmt.Errorf("failed to decode response body, %w", err),
414			Snapshot: snapshot.Bytes(),
415		}
416		return out, metadata, err
417	}
418
419	err = awsAwsjson11_deserializeOpDocumentAssociateProductWithPortfolioOutput(&output, shape)
420	if err != nil {
421		var snapshot bytes.Buffer
422		io.Copy(&snapshot, ringBuffer)
423		err = &smithy.DeserializationError{
424			Err:      fmt.Errorf("failed to decode response body, %w", err),
425			Snapshot: snapshot.Bytes(),
426		}
427		return out, metadata, err
428	}
429
430	return out, metadata, err
431}
432
433func awsAwsjson11_deserializeOpErrorAssociateProductWithPortfolio(response *smithyhttp.Response, metadata *middleware.Metadata) error {
434	var errorBuffer bytes.Buffer
435	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
436		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
437	}
438	errorBody := bytes.NewReader(errorBuffer.Bytes())
439
440	errorCode := "UnknownError"
441	errorMessage := errorCode
442
443	code := response.Header.Get("X-Amzn-ErrorType")
444	if len(code) != 0 {
445		errorCode = restjson.SanitizeErrorCode(code)
446	}
447
448	var buff [1024]byte
449	ringBuffer := smithyio.NewRingBuffer(buff[:])
450
451	body := io.TeeReader(errorBody, ringBuffer)
452	decoder := json.NewDecoder(body)
453	decoder.UseNumber()
454	code, message, err := restjson.GetErrorInfo(decoder)
455	if err != nil {
456		var snapshot bytes.Buffer
457		io.Copy(&snapshot, ringBuffer)
458		err = &smithy.DeserializationError{
459			Err:      fmt.Errorf("failed to decode response body, %w", err),
460			Snapshot: snapshot.Bytes(),
461		}
462		return err
463	}
464
465	errorBody.Seek(0, io.SeekStart)
466	if len(code) != 0 {
467		errorCode = restjson.SanitizeErrorCode(code)
468	}
469	if len(message) != 0 {
470		errorMessage = message
471	}
472
473	switch {
474	case strings.EqualFold("InvalidParametersException", errorCode):
475		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
476
477	case strings.EqualFold("LimitExceededException", errorCode):
478		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
479
480	case strings.EqualFold("ResourceNotFoundException", errorCode):
481		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
482
483	default:
484		genericError := &smithy.GenericAPIError{
485			Code:    errorCode,
486			Message: errorMessage,
487		}
488		return genericError
489
490	}
491}
492
493type awsAwsjson11_deserializeOpAssociateServiceActionWithProvisioningArtifact struct {
494}
495
496func (*awsAwsjson11_deserializeOpAssociateServiceActionWithProvisioningArtifact) ID() string {
497	return "OperationDeserializer"
498}
499
500func (m *awsAwsjson11_deserializeOpAssociateServiceActionWithProvisioningArtifact) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
501	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
502) {
503	out, metadata, err = next.HandleDeserialize(ctx, in)
504	if err != nil {
505		return out, metadata, err
506	}
507
508	response, ok := out.RawResponse.(*smithyhttp.Response)
509	if !ok {
510		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
511	}
512
513	if response.StatusCode < 200 || response.StatusCode >= 300 {
514		return out, metadata, awsAwsjson11_deserializeOpErrorAssociateServiceActionWithProvisioningArtifact(response, &metadata)
515	}
516	output := &AssociateServiceActionWithProvisioningArtifactOutput{}
517	out.Result = output
518
519	var buff [1024]byte
520	ringBuffer := smithyio.NewRingBuffer(buff[:])
521
522	body := io.TeeReader(response.Body, ringBuffer)
523	decoder := json.NewDecoder(body)
524	decoder.UseNumber()
525	var shape interface{}
526	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
527		var snapshot bytes.Buffer
528		io.Copy(&snapshot, ringBuffer)
529		err = &smithy.DeserializationError{
530			Err:      fmt.Errorf("failed to decode response body, %w", err),
531			Snapshot: snapshot.Bytes(),
532		}
533		return out, metadata, err
534	}
535
536	err = awsAwsjson11_deserializeOpDocumentAssociateServiceActionWithProvisioningArtifactOutput(&output, shape)
537	if err != nil {
538		var snapshot bytes.Buffer
539		io.Copy(&snapshot, ringBuffer)
540		err = &smithy.DeserializationError{
541			Err:      fmt.Errorf("failed to decode response body, %w", err),
542			Snapshot: snapshot.Bytes(),
543		}
544		return out, metadata, err
545	}
546
547	return out, metadata, err
548}
549
550func awsAwsjson11_deserializeOpErrorAssociateServiceActionWithProvisioningArtifact(response *smithyhttp.Response, metadata *middleware.Metadata) error {
551	var errorBuffer bytes.Buffer
552	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
553		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
554	}
555	errorBody := bytes.NewReader(errorBuffer.Bytes())
556
557	errorCode := "UnknownError"
558	errorMessage := errorCode
559
560	code := response.Header.Get("X-Amzn-ErrorType")
561	if len(code) != 0 {
562		errorCode = restjson.SanitizeErrorCode(code)
563	}
564
565	var buff [1024]byte
566	ringBuffer := smithyio.NewRingBuffer(buff[:])
567
568	body := io.TeeReader(errorBody, ringBuffer)
569	decoder := json.NewDecoder(body)
570	decoder.UseNumber()
571	code, message, err := restjson.GetErrorInfo(decoder)
572	if err != nil {
573		var snapshot bytes.Buffer
574		io.Copy(&snapshot, ringBuffer)
575		err = &smithy.DeserializationError{
576			Err:      fmt.Errorf("failed to decode response body, %w", err),
577			Snapshot: snapshot.Bytes(),
578		}
579		return err
580	}
581
582	errorBody.Seek(0, io.SeekStart)
583	if len(code) != 0 {
584		errorCode = restjson.SanitizeErrorCode(code)
585	}
586	if len(message) != 0 {
587		errorMessage = message
588	}
589
590	switch {
591	case strings.EqualFold("DuplicateResourceException", errorCode):
592		return awsAwsjson11_deserializeErrorDuplicateResourceException(response, errorBody)
593
594	case strings.EqualFold("LimitExceededException", errorCode):
595		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
596
597	case strings.EqualFold("ResourceNotFoundException", errorCode):
598		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
599
600	default:
601		genericError := &smithy.GenericAPIError{
602			Code:    errorCode,
603			Message: errorMessage,
604		}
605		return genericError
606
607	}
608}
609
610type awsAwsjson11_deserializeOpAssociateTagOptionWithResource struct {
611}
612
613func (*awsAwsjson11_deserializeOpAssociateTagOptionWithResource) ID() string {
614	return "OperationDeserializer"
615}
616
617func (m *awsAwsjson11_deserializeOpAssociateTagOptionWithResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
618	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
619) {
620	out, metadata, err = next.HandleDeserialize(ctx, in)
621	if err != nil {
622		return out, metadata, err
623	}
624
625	response, ok := out.RawResponse.(*smithyhttp.Response)
626	if !ok {
627		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
628	}
629
630	if response.StatusCode < 200 || response.StatusCode >= 300 {
631		return out, metadata, awsAwsjson11_deserializeOpErrorAssociateTagOptionWithResource(response, &metadata)
632	}
633	output := &AssociateTagOptionWithResourceOutput{}
634	out.Result = output
635
636	var buff [1024]byte
637	ringBuffer := smithyio.NewRingBuffer(buff[:])
638
639	body := io.TeeReader(response.Body, ringBuffer)
640	decoder := json.NewDecoder(body)
641	decoder.UseNumber()
642	var shape interface{}
643	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
644		var snapshot bytes.Buffer
645		io.Copy(&snapshot, ringBuffer)
646		err = &smithy.DeserializationError{
647			Err:      fmt.Errorf("failed to decode response body, %w", err),
648			Snapshot: snapshot.Bytes(),
649		}
650		return out, metadata, err
651	}
652
653	err = awsAwsjson11_deserializeOpDocumentAssociateTagOptionWithResourceOutput(&output, shape)
654	if err != nil {
655		var snapshot bytes.Buffer
656		io.Copy(&snapshot, ringBuffer)
657		err = &smithy.DeserializationError{
658			Err:      fmt.Errorf("failed to decode response body, %w", err),
659			Snapshot: snapshot.Bytes(),
660		}
661		return out, metadata, err
662	}
663
664	return out, metadata, err
665}
666
667func awsAwsjson11_deserializeOpErrorAssociateTagOptionWithResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
668	var errorBuffer bytes.Buffer
669	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
670		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
671	}
672	errorBody := bytes.NewReader(errorBuffer.Bytes())
673
674	errorCode := "UnknownError"
675	errorMessage := errorCode
676
677	code := response.Header.Get("X-Amzn-ErrorType")
678	if len(code) != 0 {
679		errorCode = restjson.SanitizeErrorCode(code)
680	}
681
682	var buff [1024]byte
683	ringBuffer := smithyio.NewRingBuffer(buff[:])
684
685	body := io.TeeReader(errorBody, ringBuffer)
686	decoder := json.NewDecoder(body)
687	decoder.UseNumber()
688	code, message, err := restjson.GetErrorInfo(decoder)
689	if err != nil {
690		var snapshot bytes.Buffer
691		io.Copy(&snapshot, ringBuffer)
692		err = &smithy.DeserializationError{
693			Err:      fmt.Errorf("failed to decode response body, %w", err),
694			Snapshot: snapshot.Bytes(),
695		}
696		return err
697	}
698
699	errorBody.Seek(0, io.SeekStart)
700	if len(code) != 0 {
701		errorCode = restjson.SanitizeErrorCode(code)
702	}
703	if len(message) != 0 {
704		errorMessage = message
705	}
706
707	switch {
708	case strings.EqualFold("DuplicateResourceException", errorCode):
709		return awsAwsjson11_deserializeErrorDuplicateResourceException(response, errorBody)
710
711	case strings.EqualFold("InvalidParametersException", errorCode):
712		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
713
714	case strings.EqualFold("InvalidStateException", errorCode):
715		return awsAwsjson11_deserializeErrorInvalidStateException(response, errorBody)
716
717	case strings.EqualFold("LimitExceededException", errorCode):
718		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
719
720	case strings.EqualFold("ResourceNotFoundException", errorCode):
721		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
722
723	case strings.EqualFold("TagOptionNotMigratedException", errorCode):
724		return awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response, errorBody)
725
726	default:
727		genericError := &smithy.GenericAPIError{
728			Code:    errorCode,
729			Message: errorMessage,
730		}
731		return genericError
732
733	}
734}
735
736type awsAwsjson11_deserializeOpBatchAssociateServiceActionWithProvisioningArtifact struct {
737}
738
739func (*awsAwsjson11_deserializeOpBatchAssociateServiceActionWithProvisioningArtifact) ID() string {
740	return "OperationDeserializer"
741}
742
743func (m *awsAwsjson11_deserializeOpBatchAssociateServiceActionWithProvisioningArtifact) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
744	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
745) {
746	out, metadata, err = next.HandleDeserialize(ctx, in)
747	if err != nil {
748		return out, metadata, err
749	}
750
751	response, ok := out.RawResponse.(*smithyhttp.Response)
752	if !ok {
753		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
754	}
755
756	if response.StatusCode < 200 || response.StatusCode >= 300 {
757		return out, metadata, awsAwsjson11_deserializeOpErrorBatchAssociateServiceActionWithProvisioningArtifact(response, &metadata)
758	}
759	output := &BatchAssociateServiceActionWithProvisioningArtifactOutput{}
760	out.Result = output
761
762	var buff [1024]byte
763	ringBuffer := smithyio.NewRingBuffer(buff[:])
764
765	body := io.TeeReader(response.Body, ringBuffer)
766	decoder := json.NewDecoder(body)
767	decoder.UseNumber()
768	var shape interface{}
769	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
770		var snapshot bytes.Buffer
771		io.Copy(&snapshot, ringBuffer)
772		err = &smithy.DeserializationError{
773			Err:      fmt.Errorf("failed to decode response body, %w", err),
774			Snapshot: snapshot.Bytes(),
775		}
776		return out, metadata, err
777	}
778
779	err = awsAwsjson11_deserializeOpDocumentBatchAssociateServiceActionWithProvisioningArtifactOutput(&output, shape)
780	if err != nil {
781		var snapshot bytes.Buffer
782		io.Copy(&snapshot, ringBuffer)
783		err = &smithy.DeserializationError{
784			Err:      fmt.Errorf("failed to decode response body, %w", err),
785			Snapshot: snapshot.Bytes(),
786		}
787		return out, metadata, err
788	}
789
790	return out, metadata, err
791}
792
793func awsAwsjson11_deserializeOpErrorBatchAssociateServiceActionWithProvisioningArtifact(response *smithyhttp.Response, metadata *middleware.Metadata) error {
794	var errorBuffer bytes.Buffer
795	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
796		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
797	}
798	errorBody := bytes.NewReader(errorBuffer.Bytes())
799
800	errorCode := "UnknownError"
801	errorMessage := errorCode
802
803	code := response.Header.Get("X-Amzn-ErrorType")
804	if len(code) != 0 {
805		errorCode = restjson.SanitizeErrorCode(code)
806	}
807
808	var buff [1024]byte
809	ringBuffer := smithyio.NewRingBuffer(buff[:])
810
811	body := io.TeeReader(errorBody, ringBuffer)
812	decoder := json.NewDecoder(body)
813	decoder.UseNumber()
814	code, message, err := restjson.GetErrorInfo(decoder)
815	if err != nil {
816		var snapshot bytes.Buffer
817		io.Copy(&snapshot, ringBuffer)
818		err = &smithy.DeserializationError{
819			Err:      fmt.Errorf("failed to decode response body, %w", err),
820			Snapshot: snapshot.Bytes(),
821		}
822		return err
823	}
824
825	errorBody.Seek(0, io.SeekStart)
826	if len(code) != 0 {
827		errorCode = restjson.SanitizeErrorCode(code)
828	}
829	if len(message) != 0 {
830		errorMessage = message
831	}
832
833	switch {
834	case strings.EqualFold("InvalidParametersException", errorCode):
835		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
836
837	default:
838		genericError := &smithy.GenericAPIError{
839			Code:    errorCode,
840			Message: errorMessage,
841		}
842		return genericError
843
844	}
845}
846
847type awsAwsjson11_deserializeOpBatchDisassociateServiceActionFromProvisioningArtifact struct {
848}
849
850func (*awsAwsjson11_deserializeOpBatchDisassociateServiceActionFromProvisioningArtifact) ID() string {
851	return "OperationDeserializer"
852}
853
854func (m *awsAwsjson11_deserializeOpBatchDisassociateServiceActionFromProvisioningArtifact) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
855	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
856) {
857	out, metadata, err = next.HandleDeserialize(ctx, in)
858	if err != nil {
859		return out, metadata, err
860	}
861
862	response, ok := out.RawResponse.(*smithyhttp.Response)
863	if !ok {
864		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
865	}
866
867	if response.StatusCode < 200 || response.StatusCode >= 300 {
868		return out, metadata, awsAwsjson11_deserializeOpErrorBatchDisassociateServiceActionFromProvisioningArtifact(response, &metadata)
869	}
870	output := &BatchDisassociateServiceActionFromProvisioningArtifactOutput{}
871	out.Result = output
872
873	var buff [1024]byte
874	ringBuffer := smithyio.NewRingBuffer(buff[:])
875
876	body := io.TeeReader(response.Body, ringBuffer)
877	decoder := json.NewDecoder(body)
878	decoder.UseNumber()
879	var shape interface{}
880	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
881		var snapshot bytes.Buffer
882		io.Copy(&snapshot, ringBuffer)
883		err = &smithy.DeserializationError{
884			Err:      fmt.Errorf("failed to decode response body, %w", err),
885			Snapshot: snapshot.Bytes(),
886		}
887		return out, metadata, err
888	}
889
890	err = awsAwsjson11_deserializeOpDocumentBatchDisassociateServiceActionFromProvisioningArtifactOutput(&output, shape)
891	if err != nil {
892		var snapshot bytes.Buffer
893		io.Copy(&snapshot, ringBuffer)
894		err = &smithy.DeserializationError{
895			Err:      fmt.Errorf("failed to decode response body, %w", err),
896			Snapshot: snapshot.Bytes(),
897		}
898		return out, metadata, err
899	}
900
901	return out, metadata, err
902}
903
904func awsAwsjson11_deserializeOpErrorBatchDisassociateServiceActionFromProvisioningArtifact(response *smithyhttp.Response, metadata *middleware.Metadata) error {
905	var errorBuffer bytes.Buffer
906	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
907		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
908	}
909	errorBody := bytes.NewReader(errorBuffer.Bytes())
910
911	errorCode := "UnknownError"
912	errorMessage := errorCode
913
914	code := response.Header.Get("X-Amzn-ErrorType")
915	if len(code) != 0 {
916		errorCode = restjson.SanitizeErrorCode(code)
917	}
918
919	var buff [1024]byte
920	ringBuffer := smithyio.NewRingBuffer(buff[:])
921
922	body := io.TeeReader(errorBody, ringBuffer)
923	decoder := json.NewDecoder(body)
924	decoder.UseNumber()
925	code, message, err := restjson.GetErrorInfo(decoder)
926	if err != nil {
927		var snapshot bytes.Buffer
928		io.Copy(&snapshot, ringBuffer)
929		err = &smithy.DeserializationError{
930			Err:      fmt.Errorf("failed to decode response body, %w", err),
931			Snapshot: snapshot.Bytes(),
932		}
933		return err
934	}
935
936	errorBody.Seek(0, io.SeekStart)
937	if len(code) != 0 {
938		errorCode = restjson.SanitizeErrorCode(code)
939	}
940	if len(message) != 0 {
941		errorMessage = message
942	}
943
944	switch {
945	case strings.EqualFold("InvalidParametersException", errorCode):
946		return awsAwsjson11_deserializeErrorInvalidParametersException(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_deserializeOpCopyProduct struct {
959}
960
961func (*awsAwsjson11_deserializeOpCopyProduct) ID() string {
962	return "OperationDeserializer"
963}
964
965func (m *awsAwsjson11_deserializeOpCopyProduct) 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_deserializeOpErrorCopyProduct(response, &metadata)
980	}
981	output := &CopyProductOutput{}
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_deserializeOpDocumentCopyProductOutput(&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_deserializeOpErrorCopyProduct(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("InvalidParametersException", errorCode):
1057		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
1058
1059	case strings.EqualFold("ResourceNotFoundException", errorCode):
1060		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
1061
1062	default:
1063		genericError := &smithy.GenericAPIError{
1064			Code:    errorCode,
1065			Message: errorMessage,
1066		}
1067		return genericError
1068
1069	}
1070}
1071
1072type awsAwsjson11_deserializeOpCreateConstraint struct {
1073}
1074
1075func (*awsAwsjson11_deserializeOpCreateConstraint) ID() string {
1076	return "OperationDeserializer"
1077}
1078
1079func (m *awsAwsjson11_deserializeOpCreateConstraint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1080	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1081) {
1082	out, metadata, err = next.HandleDeserialize(ctx, in)
1083	if err != nil {
1084		return out, metadata, err
1085	}
1086
1087	response, ok := out.RawResponse.(*smithyhttp.Response)
1088	if !ok {
1089		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1090	}
1091
1092	if response.StatusCode < 200 || response.StatusCode >= 300 {
1093		return out, metadata, awsAwsjson11_deserializeOpErrorCreateConstraint(response, &metadata)
1094	}
1095	output := &CreateConstraintOutput{}
1096	out.Result = output
1097
1098	var buff [1024]byte
1099	ringBuffer := smithyio.NewRingBuffer(buff[:])
1100
1101	body := io.TeeReader(response.Body, ringBuffer)
1102	decoder := json.NewDecoder(body)
1103	decoder.UseNumber()
1104	var shape interface{}
1105	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1106		var snapshot bytes.Buffer
1107		io.Copy(&snapshot, ringBuffer)
1108		err = &smithy.DeserializationError{
1109			Err:      fmt.Errorf("failed to decode response body, %w", err),
1110			Snapshot: snapshot.Bytes(),
1111		}
1112		return out, metadata, err
1113	}
1114
1115	err = awsAwsjson11_deserializeOpDocumentCreateConstraintOutput(&output, shape)
1116	if err != nil {
1117		var snapshot bytes.Buffer
1118		io.Copy(&snapshot, ringBuffer)
1119		err = &smithy.DeserializationError{
1120			Err:      fmt.Errorf("failed to decode response body, %w", err),
1121			Snapshot: snapshot.Bytes(),
1122		}
1123		return out, metadata, err
1124	}
1125
1126	return out, metadata, err
1127}
1128
1129func awsAwsjson11_deserializeOpErrorCreateConstraint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1130	var errorBuffer bytes.Buffer
1131	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1132		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1133	}
1134	errorBody := bytes.NewReader(errorBuffer.Bytes())
1135
1136	errorCode := "UnknownError"
1137	errorMessage := errorCode
1138
1139	code := response.Header.Get("X-Amzn-ErrorType")
1140	if len(code) != 0 {
1141		errorCode = restjson.SanitizeErrorCode(code)
1142	}
1143
1144	var buff [1024]byte
1145	ringBuffer := smithyio.NewRingBuffer(buff[:])
1146
1147	body := io.TeeReader(errorBody, ringBuffer)
1148	decoder := json.NewDecoder(body)
1149	decoder.UseNumber()
1150	code, message, err := restjson.GetErrorInfo(decoder)
1151	if err != nil {
1152		var snapshot bytes.Buffer
1153		io.Copy(&snapshot, ringBuffer)
1154		err = &smithy.DeserializationError{
1155			Err:      fmt.Errorf("failed to decode response body, %w", err),
1156			Snapshot: snapshot.Bytes(),
1157		}
1158		return err
1159	}
1160
1161	errorBody.Seek(0, io.SeekStart)
1162	if len(code) != 0 {
1163		errorCode = restjson.SanitizeErrorCode(code)
1164	}
1165	if len(message) != 0 {
1166		errorMessage = message
1167	}
1168
1169	switch {
1170	case strings.EqualFold("DuplicateResourceException", errorCode):
1171		return awsAwsjson11_deserializeErrorDuplicateResourceException(response, errorBody)
1172
1173	case strings.EqualFold("InvalidParametersException", errorCode):
1174		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
1175
1176	case strings.EqualFold("LimitExceededException", errorCode):
1177		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
1178
1179	case strings.EqualFold("ResourceNotFoundException", errorCode):
1180		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
1181
1182	default:
1183		genericError := &smithy.GenericAPIError{
1184			Code:    errorCode,
1185			Message: errorMessage,
1186		}
1187		return genericError
1188
1189	}
1190}
1191
1192type awsAwsjson11_deserializeOpCreatePortfolio struct {
1193}
1194
1195func (*awsAwsjson11_deserializeOpCreatePortfolio) ID() string {
1196	return "OperationDeserializer"
1197}
1198
1199func (m *awsAwsjson11_deserializeOpCreatePortfolio) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1200	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1201) {
1202	out, metadata, err = next.HandleDeserialize(ctx, in)
1203	if err != nil {
1204		return out, metadata, err
1205	}
1206
1207	response, ok := out.RawResponse.(*smithyhttp.Response)
1208	if !ok {
1209		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1210	}
1211
1212	if response.StatusCode < 200 || response.StatusCode >= 300 {
1213		return out, metadata, awsAwsjson11_deserializeOpErrorCreatePortfolio(response, &metadata)
1214	}
1215	output := &CreatePortfolioOutput{}
1216	out.Result = output
1217
1218	var buff [1024]byte
1219	ringBuffer := smithyio.NewRingBuffer(buff[:])
1220
1221	body := io.TeeReader(response.Body, ringBuffer)
1222	decoder := json.NewDecoder(body)
1223	decoder.UseNumber()
1224	var shape interface{}
1225	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1226		var snapshot bytes.Buffer
1227		io.Copy(&snapshot, ringBuffer)
1228		err = &smithy.DeserializationError{
1229			Err:      fmt.Errorf("failed to decode response body, %w", err),
1230			Snapshot: snapshot.Bytes(),
1231		}
1232		return out, metadata, err
1233	}
1234
1235	err = awsAwsjson11_deserializeOpDocumentCreatePortfolioOutput(&output, shape)
1236	if err != nil {
1237		var snapshot bytes.Buffer
1238		io.Copy(&snapshot, ringBuffer)
1239		err = &smithy.DeserializationError{
1240			Err:      fmt.Errorf("failed to decode response body, %w", err),
1241			Snapshot: snapshot.Bytes(),
1242		}
1243		return out, metadata, err
1244	}
1245
1246	return out, metadata, err
1247}
1248
1249func awsAwsjson11_deserializeOpErrorCreatePortfolio(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1250	var errorBuffer bytes.Buffer
1251	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1252		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1253	}
1254	errorBody := bytes.NewReader(errorBuffer.Bytes())
1255
1256	errorCode := "UnknownError"
1257	errorMessage := errorCode
1258
1259	code := response.Header.Get("X-Amzn-ErrorType")
1260	if len(code) != 0 {
1261		errorCode = restjson.SanitizeErrorCode(code)
1262	}
1263
1264	var buff [1024]byte
1265	ringBuffer := smithyio.NewRingBuffer(buff[:])
1266
1267	body := io.TeeReader(errorBody, ringBuffer)
1268	decoder := json.NewDecoder(body)
1269	decoder.UseNumber()
1270	code, message, err := restjson.GetErrorInfo(decoder)
1271	if err != nil {
1272		var snapshot bytes.Buffer
1273		io.Copy(&snapshot, ringBuffer)
1274		err = &smithy.DeserializationError{
1275			Err:      fmt.Errorf("failed to decode response body, %w", err),
1276			Snapshot: snapshot.Bytes(),
1277		}
1278		return err
1279	}
1280
1281	errorBody.Seek(0, io.SeekStart)
1282	if len(code) != 0 {
1283		errorCode = restjson.SanitizeErrorCode(code)
1284	}
1285	if len(message) != 0 {
1286		errorMessage = message
1287	}
1288
1289	switch {
1290	case strings.EqualFold("InvalidParametersException", errorCode):
1291		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
1292
1293	case strings.EqualFold("LimitExceededException", errorCode):
1294		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
1295
1296	case strings.EqualFold("TagOptionNotMigratedException", errorCode):
1297		return awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response, errorBody)
1298
1299	default:
1300		genericError := &smithy.GenericAPIError{
1301			Code:    errorCode,
1302			Message: errorMessage,
1303		}
1304		return genericError
1305
1306	}
1307}
1308
1309type awsAwsjson11_deserializeOpCreatePortfolioShare struct {
1310}
1311
1312func (*awsAwsjson11_deserializeOpCreatePortfolioShare) ID() string {
1313	return "OperationDeserializer"
1314}
1315
1316func (m *awsAwsjson11_deserializeOpCreatePortfolioShare) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1317	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1318) {
1319	out, metadata, err = next.HandleDeserialize(ctx, in)
1320	if err != nil {
1321		return out, metadata, err
1322	}
1323
1324	response, ok := out.RawResponse.(*smithyhttp.Response)
1325	if !ok {
1326		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1327	}
1328
1329	if response.StatusCode < 200 || response.StatusCode >= 300 {
1330		return out, metadata, awsAwsjson11_deserializeOpErrorCreatePortfolioShare(response, &metadata)
1331	}
1332	output := &CreatePortfolioShareOutput{}
1333	out.Result = output
1334
1335	var buff [1024]byte
1336	ringBuffer := smithyio.NewRingBuffer(buff[:])
1337
1338	body := io.TeeReader(response.Body, ringBuffer)
1339	decoder := json.NewDecoder(body)
1340	decoder.UseNumber()
1341	var shape interface{}
1342	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1343		var snapshot bytes.Buffer
1344		io.Copy(&snapshot, ringBuffer)
1345		err = &smithy.DeserializationError{
1346			Err:      fmt.Errorf("failed to decode response body, %w", err),
1347			Snapshot: snapshot.Bytes(),
1348		}
1349		return out, metadata, err
1350	}
1351
1352	err = awsAwsjson11_deserializeOpDocumentCreatePortfolioShareOutput(&output, shape)
1353	if err != nil {
1354		var snapshot bytes.Buffer
1355		io.Copy(&snapshot, ringBuffer)
1356		err = &smithy.DeserializationError{
1357			Err:      fmt.Errorf("failed to decode response body, %w", err),
1358			Snapshot: snapshot.Bytes(),
1359		}
1360		return out, metadata, err
1361	}
1362
1363	return out, metadata, err
1364}
1365
1366func awsAwsjson11_deserializeOpErrorCreatePortfolioShare(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1367	var errorBuffer bytes.Buffer
1368	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1369		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1370	}
1371	errorBody := bytes.NewReader(errorBuffer.Bytes())
1372
1373	errorCode := "UnknownError"
1374	errorMessage := errorCode
1375
1376	code := response.Header.Get("X-Amzn-ErrorType")
1377	if len(code) != 0 {
1378		errorCode = restjson.SanitizeErrorCode(code)
1379	}
1380
1381	var buff [1024]byte
1382	ringBuffer := smithyio.NewRingBuffer(buff[:])
1383
1384	body := io.TeeReader(errorBody, ringBuffer)
1385	decoder := json.NewDecoder(body)
1386	decoder.UseNumber()
1387	code, message, err := restjson.GetErrorInfo(decoder)
1388	if err != nil {
1389		var snapshot bytes.Buffer
1390		io.Copy(&snapshot, ringBuffer)
1391		err = &smithy.DeserializationError{
1392			Err:      fmt.Errorf("failed to decode response body, %w", err),
1393			Snapshot: snapshot.Bytes(),
1394		}
1395		return err
1396	}
1397
1398	errorBody.Seek(0, io.SeekStart)
1399	if len(code) != 0 {
1400		errorCode = restjson.SanitizeErrorCode(code)
1401	}
1402	if len(message) != 0 {
1403		errorMessage = message
1404	}
1405
1406	switch {
1407	case strings.EqualFold("InvalidParametersException", errorCode):
1408		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
1409
1410	case strings.EqualFold("InvalidStateException", errorCode):
1411		return awsAwsjson11_deserializeErrorInvalidStateException(response, errorBody)
1412
1413	case strings.EqualFold("LimitExceededException", errorCode):
1414		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
1415
1416	case strings.EqualFold("OperationNotSupportedException", errorCode):
1417		return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody)
1418
1419	case strings.EqualFold("ResourceNotFoundException", errorCode):
1420		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
1421
1422	default:
1423		genericError := &smithy.GenericAPIError{
1424			Code:    errorCode,
1425			Message: errorMessage,
1426		}
1427		return genericError
1428
1429	}
1430}
1431
1432type awsAwsjson11_deserializeOpCreateProduct struct {
1433}
1434
1435func (*awsAwsjson11_deserializeOpCreateProduct) ID() string {
1436	return "OperationDeserializer"
1437}
1438
1439func (m *awsAwsjson11_deserializeOpCreateProduct) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1440	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1441) {
1442	out, metadata, err = next.HandleDeserialize(ctx, in)
1443	if err != nil {
1444		return out, metadata, err
1445	}
1446
1447	response, ok := out.RawResponse.(*smithyhttp.Response)
1448	if !ok {
1449		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1450	}
1451
1452	if response.StatusCode < 200 || response.StatusCode >= 300 {
1453		return out, metadata, awsAwsjson11_deserializeOpErrorCreateProduct(response, &metadata)
1454	}
1455	output := &CreateProductOutput{}
1456	out.Result = output
1457
1458	var buff [1024]byte
1459	ringBuffer := smithyio.NewRingBuffer(buff[:])
1460
1461	body := io.TeeReader(response.Body, ringBuffer)
1462	decoder := json.NewDecoder(body)
1463	decoder.UseNumber()
1464	var shape interface{}
1465	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1466		var snapshot bytes.Buffer
1467		io.Copy(&snapshot, ringBuffer)
1468		err = &smithy.DeserializationError{
1469			Err:      fmt.Errorf("failed to decode response body, %w", err),
1470			Snapshot: snapshot.Bytes(),
1471		}
1472		return out, metadata, err
1473	}
1474
1475	err = awsAwsjson11_deserializeOpDocumentCreateProductOutput(&output, shape)
1476	if err != nil {
1477		var snapshot bytes.Buffer
1478		io.Copy(&snapshot, ringBuffer)
1479		err = &smithy.DeserializationError{
1480			Err:      fmt.Errorf("failed to decode response body, %w", err),
1481			Snapshot: snapshot.Bytes(),
1482		}
1483		return out, metadata, err
1484	}
1485
1486	return out, metadata, err
1487}
1488
1489func awsAwsjson11_deserializeOpErrorCreateProduct(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1490	var errorBuffer bytes.Buffer
1491	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1492		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1493	}
1494	errorBody := bytes.NewReader(errorBuffer.Bytes())
1495
1496	errorCode := "UnknownError"
1497	errorMessage := errorCode
1498
1499	code := response.Header.Get("X-Amzn-ErrorType")
1500	if len(code) != 0 {
1501		errorCode = restjson.SanitizeErrorCode(code)
1502	}
1503
1504	var buff [1024]byte
1505	ringBuffer := smithyio.NewRingBuffer(buff[:])
1506
1507	body := io.TeeReader(errorBody, ringBuffer)
1508	decoder := json.NewDecoder(body)
1509	decoder.UseNumber()
1510	code, message, err := restjson.GetErrorInfo(decoder)
1511	if err != nil {
1512		var snapshot bytes.Buffer
1513		io.Copy(&snapshot, ringBuffer)
1514		err = &smithy.DeserializationError{
1515			Err:      fmt.Errorf("failed to decode response body, %w", err),
1516			Snapshot: snapshot.Bytes(),
1517		}
1518		return err
1519	}
1520
1521	errorBody.Seek(0, io.SeekStart)
1522	if len(code) != 0 {
1523		errorCode = restjson.SanitizeErrorCode(code)
1524	}
1525	if len(message) != 0 {
1526		errorMessage = message
1527	}
1528
1529	switch {
1530	case strings.EqualFold("InvalidParametersException", errorCode):
1531		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
1532
1533	case strings.EqualFold("LimitExceededException", errorCode):
1534		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
1535
1536	case strings.EqualFold("TagOptionNotMigratedException", errorCode):
1537		return awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response, errorBody)
1538
1539	default:
1540		genericError := &smithy.GenericAPIError{
1541			Code:    errorCode,
1542			Message: errorMessage,
1543		}
1544		return genericError
1545
1546	}
1547}
1548
1549type awsAwsjson11_deserializeOpCreateProvisionedProductPlan struct {
1550}
1551
1552func (*awsAwsjson11_deserializeOpCreateProvisionedProductPlan) ID() string {
1553	return "OperationDeserializer"
1554}
1555
1556func (m *awsAwsjson11_deserializeOpCreateProvisionedProductPlan) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1557	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1558) {
1559	out, metadata, err = next.HandleDeserialize(ctx, in)
1560	if err != nil {
1561		return out, metadata, err
1562	}
1563
1564	response, ok := out.RawResponse.(*smithyhttp.Response)
1565	if !ok {
1566		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1567	}
1568
1569	if response.StatusCode < 200 || response.StatusCode >= 300 {
1570		return out, metadata, awsAwsjson11_deserializeOpErrorCreateProvisionedProductPlan(response, &metadata)
1571	}
1572	output := &CreateProvisionedProductPlanOutput{}
1573	out.Result = output
1574
1575	var buff [1024]byte
1576	ringBuffer := smithyio.NewRingBuffer(buff[:])
1577
1578	body := io.TeeReader(response.Body, ringBuffer)
1579	decoder := json.NewDecoder(body)
1580	decoder.UseNumber()
1581	var shape interface{}
1582	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1583		var snapshot bytes.Buffer
1584		io.Copy(&snapshot, ringBuffer)
1585		err = &smithy.DeserializationError{
1586			Err:      fmt.Errorf("failed to decode response body, %w", err),
1587			Snapshot: snapshot.Bytes(),
1588		}
1589		return out, metadata, err
1590	}
1591
1592	err = awsAwsjson11_deserializeOpDocumentCreateProvisionedProductPlanOutput(&output, shape)
1593	if err != nil {
1594		var snapshot bytes.Buffer
1595		io.Copy(&snapshot, ringBuffer)
1596		err = &smithy.DeserializationError{
1597			Err:      fmt.Errorf("failed to decode response body, %w", err),
1598			Snapshot: snapshot.Bytes(),
1599		}
1600		return out, metadata, err
1601	}
1602
1603	return out, metadata, err
1604}
1605
1606func awsAwsjson11_deserializeOpErrorCreateProvisionedProductPlan(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1607	var errorBuffer bytes.Buffer
1608	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1609		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1610	}
1611	errorBody := bytes.NewReader(errorBuffer.Bytes())
1612
1613	errorCode := "UnknownError"
1614	errorMessage := errorCode
1615
1616	code := response.Header.Get("X-Amzn-ErrorType")
1617	if len(code) != 0 {
1618		errorCode = restjson.SanitizeErrorCode(code)
1619	}
1620
1621	var buff [1024]byte
1622	ringBuffer := smithyio.NewRingBuffer(buff[:])
1623
1624	body := io.TeeReader(errorBody, ringBuffer)
1625	decoder := json.NewDecoder(body)
1626	decoder.UseNumber()
1627	code, message, err := restjson.GetErrorInfo(decoder)
1628	if err != nil {
1629		var snapshot bytes.Buffer
1630		io.Copy(&snapshot, ringBuffer)
1631		err = &smithy.DeserializationError{
1632			Err:      fmt.Errorf("failed to decode response body, %w", err),
1633			Snapshot: snapshot.Bytes(),
1634		}
1635		return err
1636	}
1637
1638	errorBody.Seek(0, io.SeekStart)
1639	if len(code) != 0 {
1640		errorCode = restjson.SanitizeErrorCode(code)
1641	}
1642	if len(message) != 0 {
1643		errorMessage = message
1644	}
1645
1646	switch {
1647	case strings.EqualFold("InvalidParametersException", errorCode):
1648		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
1649
1650	case strings.EqualFold("InvalidStateException", errorCode):
1651		return awsAwsjson11_deserializeErrorInvalidStateException(response, errorBody)
1652
1653	case strings.EqualFold("ResourceNotFoundException", errorCode):
1654		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
1655
1656	default:
1657		genericError := &smithy.GenericAPIError{
1658			Code:    errorCode,
1659			Message: errorMessage,
1660		}
1661		return genericError
1662
1663	}
1664}
1665
1666type awsAwsjson11_deserializeOpCreateProvisioningArtifact struct {
1667}
1668
1669func (*awsAwsjson11_deserializeOpCreateProvisioningArtifact) ID() string {
1670	return "OperationDeserializer"
1671}
1672
1673func (m *awsAwsjson11_deserializeOpCreateProvisioningArtifact) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1674	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1675) {
1676	out, metadata, err = next.HandleDeserialize(ctx, in)
1677	if err != nil {
1678		return out, metadata, err
1679	}
1680
1681	response, ok := out.RawResponse.(*smithyhttp.Response)
1682	if !ok {
1683		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1684	}
1685
1686	if response.StatusCode < 200 || response.StatusCode >= 300 {
1687		return out, metadata, awsAwsjson11_deserializeOpErrorCreateProvisioningArtifact(response, &metadata)
1688	}
1689	output := &CreateProvisioningArtifactOutput{}
1690	out.Result = output
1691
1692	var buff [1024]byte
1693	ringBuffer := smithyio.NewRingBuffer(buff[:])
1694
1695	body := io.TeeReader(response.Body, ringBuffer)
1696	decoder := json.NewDecoder(body)
1697	decoder.UseNumber()
1698	var shape interface{}
1699	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1700		var snapshot bytes.Buffer
1701		io.Copy(&snapshot, ringBuffer)
1702		err = &smithy.DeserializationError{
1703			Err:      fmt.Errorf("failed to decode response body, %w", err),
1704			Snapshot: snapshot.Bytes(),
1705		}
1706		return out, metadata, err
1707	}
1708
1709	err = awsAwsjson11_deserializeOpDocumentCreateProvisioningArtifactOutput(&output, shape)
1710	if err != nil {
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	return out, metadata, err
1721}
1722
1723func awsAwsjson11_deserializeOpErrorCreateProvisioningArtifact(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1724	var errorBuffer bytes.Buffer
1725	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1726		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1727	}
1728	errorBody := bytes.NewReader(errorBuffer.Bytes())
1729
1730	errorCode := "UnknownError"
1731	errorMessage := errorCode
1732
1733	code := response.Header.Get("X-Amzn-ErrorType")
1734	if len(code) != 0 {
1735		errorCode = restjson.SanitizeErrorCode(code)
1736	}
1737
1738	var buff [1024]byte
1739	ringBuffer := smithyio.NewRingBuffer(buff[:])
1740
1741	body := io.TeeReader(errorBody, ringBuffer)
1742	decoder := json.NewDecoder(body)
1743	decoder.UseNumber()
1744	code, message, err := restjson.GetErrorInfo(decoder)
1745	if err != nil {
1746		var snapshot bytes.Buffer
1747		io.Copy(&snapshot, ringBuffer)
1748		err = &smithy.DeserializationError{
1749			Err:      fmt.Errorf("failed to decode response body, %w", err),
1750			Snapshot: snapshot.Bytes(),
1751		}
1752		return err
1753	}
1754
1755	errorBody.Seek(0, io.SeekStart)
1756	if len(code) != 0 {
1757		errorCode = restjson.SanitizeErrorCode(code)
1758	}
1759	if len(message) != 0 {
1760		errorMessage = message
1761	}
1762
1763	switch {
1764	case strings.EqualFold("InvalidParametersException", errorCode):
1765		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
1766
1767	case strings.EqualFold("LimitExceededException", errorCode):
1768		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
1769
1770	case strings.EqualFold("ResourceNotFoundException", errorCode):
1771		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
1772
1773	default:
1774		genericError := &smithy.GenericAPIError{
1775			Code:    errorCode,
1776			Message: errorMessage,
1777		}
1778		return genericError
1779
1780	}
1781}
1782
1783type awsAwsjson11_deserializeOpCreateServiceAction struct {
1784}
1785
1786func (*awsAwsjson11_deserializeOpCreateServiceAction) ID() string {
1787	return "OperationDeserializer"
1788}
1789
1790func (m *awsAwsjson11_deserializeOpCreateServiceAction) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1791	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1792) {
1793	out, metadata, err = next.HandleDeserialize(ctx, in)
1794	if err != nil {
1795		return out, metadata, err
1796	}
1797
1798	response, ok := out.RawResponse.(*smithyhttp.Response)
1799	if !ok {
1800		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1801	}
1802
1803	if response.StatusCode < 200 || response.StatusCode >= 300 {
1804		return out, metadata, awsAwsjson11_deserializeOpErrorCreateServiceAction(response, &metadata)
1805	}
1806	output := &CreateServiceActionOutput{}
1807	out.Result = output
1808
1809	var buff [1024]byte
1810	ringBuffer := smithyio.NewRingBuffer(buff[:])
1811
1812	body := io.TeeReader(response.Body, ringBuffer)
1813	decoder := json.NewDecoder(body)
1814	decoder.UseNumber()
1815	var shape interface{}
1816	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1817		var snapshot bytes.Buffer
1818		io.Copy(&snapshot, ringBuffer)
1819		err = &smithy.DeserializationError{
1820			Err:      fmt.Errorf("failed to decode response body, %w", err),
1821			Snapshot: snapshot.Bytes(),
1822		}
1823		return out, metadata, err
1824	}
1825
1826	err = awsAwsjson11_deserializeOpDocumentCreateServiceActionOutput(&output, shape)
1827	if err != nil {
1828		var snapshot bytes.Buffer
1829		io.Copy(&snapshot, ringBuffer)
1830		err = &smithy.DeserializationError{
1831			Err:      fmt.Errorf("failed to decode response body, %w", err),
1832			Snapshot: snapshot.Bytes(),
1833		}
1834		return out, metadata, err
1835	}
1836
1837	return out, metadata, err
1838}
1839
1840func awsAwsjson11_deserializeOpErrorCreateServiceAction(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1841	var errorBuffer bytes.Buffer
1842	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1843		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1844	}
1845	errorBody := bytes.NewReader(errorBuffer.Bytes())
1846
1847	errorCode := "UnknownError"
1848	errorMessage := errorCode
1849
1850	code := response.Header.Get("X-Amzn-ErrorType")
1851	if len(code) != 0 {
1852		errorCode = restjson.SanitizeErrorCode(code)
1853	}
1854
1855	var buff [1024]byte
1856	ringBuffer := smithyio.NewRingBuffer(buff[:])
1857
1858	body := io.TeeReader(errorBody, ringBuffer)
1859	decoder := json.NewDecoder(body)
1860	decoder.UseNumber()
1861	code, message, err := restjson.GetErrorInfo(decoder)
1862	if err != nil {
1863		var snapshot bytes.Buffer
1864		io.Copy(&snapshot, ringBuffer)
1865		err = &smithy.DeserializationError{
1866			Err:      fmt.Errorf("failed to decode response body, %w", err),
1867			Snapshot: snapshot.Bytes(),
1868		}
1869		return err
1870	}
1871
1872	errorBody.Seek(0, io.SeekStart)
1873	if len(code) != 0 {
1874		errorCode = restjson.SanitizeErrorCode(code)
1875	}
1876	if len(message) != 0 {
1877		errorMessage = message
1878	}
1879
1880	switch {
1881	case strings.EqualFold("InvalidParametersException", errorCode):
1882		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
1883
1884	case strings.EqualFold("LimitExceededException", errorCode):
1885		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
1886
1887	default:
1888		genericError := &smithy.GenericAPIError{
1889			Code:    errorCode,
1890			Message: errorMessage,
1891		}
1892		return genericError
1893
1894	}
1895}
1896
1897type awsAwsjson11_deserializeOpCreateTagOption struct {
1898}
1899
1900func (*awsAwsjson11_deserializeOpCreateTagOption) ID() string {
1901	return "OperationDeserializer"
1902}
1903
1904func (m *awsAwsjson11_deserializeOpCreateTagOption) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
1905	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
1906) {
1907	out, metadata, err = next.HandleDeserialize(ctx, in)
1908	if err != nil {
1909		return out, metadata, err
1910	}
1911
1912	response, ok := out.RawResponse.(*smithyhttp.Response)
1913	if !ok {
1914		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
1915	}
1916
1917	if response.StatusCode < 200 || response.StatusCode >= 300 {
1918		return out, metadata, awsAwsjson11_deserializeOpErrorCreateTagOption(response, &metadata)
1919	}
1920	output := &CreateTagOptionOutput{}
1921	out.Result = output
1922
1923	var buff [1024]byte
1924	ringBuffer := smithyio.NewRingBuffer(buff[:])
1925
1926	body := io.TeeReader(response.Body, ringBuffer)
1927	decoder := json.NewDecoder(body)
1928	decoder.UseNumber()
1929	var shape interface{}
1930	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
1931		var snapshot bytes.Buffer
1932		io.Copy(&snapshot, ringBuffer)
1933		err = &smithy.DeserializationError{
1934			Err:      fmt.Errorf("failed to decode response body, %w", err),
1935			Snapshot: snapshot.Bytes(),
1936		}
1937		return out, metadata, err
1938	}
1939
1940	err = awsAwsjson11_deserializeOpDocumentCreateTagOptionOutput(&output, shape)
1941	if err != nil {
1942		var snapshot bytes.Buffer
1943		io.Copy(&snapshot, ringBuffer)
1944		err = &smithy.DeserializationError{
1945			Err:      fmt.Errorf("failed to decode response body, %w", err),
1946			Snapshot: snapshot.Bytes(),
1947		}
1948		return out, metadata, err
1949	}
1950
1951	return out, metadata, err
1952}
1953
1954func awsAwsjson11_deserializeOpErrorCreateTagOption(response *smithyhttp.Response, metadata *middleware.Metadata) error {
1955	var errorBuffer bytes.Buffer
1956	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
1957		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
1958	}
1959	errorBody := bytes.NewReader(errorBuffer.Bytes())
1960
1961	errorCode := "UnknownError"
1962	errorMessage := errorCode
1963
1964	code := response.Header.Get("X-Amzn-ErrorType")
1965	if len(code) != 0 {
1966		errorCode = restjson.SanitizeErrorCode(code)
1967	}
1968
1969	var buff [1024]byte
1970	ringBuffer := smithyio.NewRingBuffer(buff[:])
1971
1972	body := io.TeeReader(errorBody, ringBuffer)
1973	decoder := json.NewDecoder(body)
1974	decoder.UseNumber()
1975	code, message, err := restjson.GetErrorInfo(decoder)
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 err
1984	}
1985
1986	errorBody.Seek(0, io.SeekStart)
1987	if len(code) != 0 {
1988		errorCode = restjson.SanitizeErrorCode(code)
1989	}
1990	if len(message) != 0 {
1991		errorMessage = message
1992	}
1993
1994	switch {
1995	case strings.EqualFold("DuplicateResourceException", errorCode):
1996		return awsAwsjson11_deserializeErrorDuplicateResourceException(response, errorBody)
1997
1998	case strings.EqualFold("LimitExceededException", errorCode):
1999		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
2000
2001	case strings.EqualFold("TagOptionNotMigratedException", errorCode):
2002		return awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response, errorBody)
2003
2004	default:
2005		genericError := &smithy.GenericAPIError{
2006			Code:    errorCode,
2007			Message: errorMessage,
2008		}
2009		return genericError
2010
2011	}
2012}
2013
2014type awsAwsjson11_deserializeOpDeleteConstraint struct {
2015}
2016
2017func (*awsAwsjson11_deserializeOpDeleteConstraint) ID() string {
2018	return "OperationDeserializer"
2019}
2020
2021func (m *awsAwsjson11_deserializeOpDeleteConstraint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2022	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2023) {
2024	out, metadata, err = next.HandleDeserialize(ctx, in)
2025	if err != nil {
2026		return out, metadata, err
2027	}
2028
2029	response, ok := out.RawResponse.(*smithyhttp.Response)
2030	if !ok {
2031		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2032	}
2033
2034	if response.StatusCode < 200 || response.StatusCode >= 300 {
2035		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteConstraint(response, &metadata)
2036	}
2037	output := &DeleteConstraintOutput{}
2038	out.Result = output
2039
2040	var buff [1024]byte
2041	ringBuffer := smithyio.NewRingBuffer(buff[:])
2042
2043	body := io.TeeReader(response.Body, ringBuffer)
2044	decoder := json.NewDecoder(body)
2045	decoder.UseNumber()
2046	var shape interface{}
2047	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2048		var snapshot bytes.Buffer
2049		io.Copy(&snapshot, ringBuffer)
2050		err = &smithy.DeserializationError{
2051			Err:      fmt.Errorf("failed to decode response body, %w", err),
2052			Snapshot: snapshot.Bytes(),
2053		}
2054		return out, metadata, err
2055	}
2056
2057	err = awsAwsjson11_deserializeOpDocumentDeleteConstraintOutput(&output, shape)
2058	if err != nil {
2059		var snapshot bytes.Buffer
2060		io.Copy(&snapshot, ringBuffer)
2061		err = &smithy.DeserializationError{
2062			Err:      fmt.Errorf("failed to decode response body, %w", err),
2063			Snapshot: snapshot.Bytes(),
2064		}
2065		return out, metadata, err
2066	}
2067
2068	return out, metadata, err
2069}
2070
2071func awsAwsjson11_deserializeOpErrorDeleteConstraint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2072	var errorBuffer bytes.Buffer
2073	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2074		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2075	}
2076	errorBody := bytes.NewReader(errorBuffer.Bytes())
2077
2078	errorCode := "UnknownError"
2079	errorMessage := errorCode
2080
2081	code := response.Header.Get("X-Amzn-ErrorType")
2082	if len(code) != 0 {
2083		errorCode = restjson.SanitizeErrorCode(code)
2084	}
2085
2086	var buff [1024]byte
2087	ringBuffer := smithyio.NewRingBuffer(buff[:])
2088
2089	body := io.TeeReader(errorBody, ringBuffer)
2090	decoder := json.NewDecoder(body)
2091	decoder.UseNumber()
2092	code, message, err := restjson.GetErrorInfo(decoder)
2093	if err != nil {
2094		var snapshot bytes.Buffer
2095		io.Copy(&snapshot, ringBuffer)
2096		err = &smithy.DeserializationError{
2097			Err:      fmt.Errorf("failed to decode response body, %w", err),
2098			Snapshot: snapshot.Bytes(),
2099		}
2100		return err
2101	}
2102
2103	errorBody.Seek(0, io.SeekStart)
2104	if len(code) != 0 {
2105		errorCode = restjson.SanitizeErrorCode(code)
2106	}
2107	if len(message) != 0 {
2108		errorMessage = message
2109	}
2110
2111	switch {
2112	case strings.EqualFold("InvalidParametersException", errorCode):
2113		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
2114
2115	case strings.EqualFold("ResourceNotFoundException", errorCode):
2116		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
2117
2118	default:
2119		genericError := &smithy.GenericAPIError{
2120			Code:    errorCode,
2121			Message: errorMessage,
2122		}
2123		return genericError
2124
2125	}
2126}
2127
2128type awsAwsjson11_deserializeOpDeletePortfolio struct {
2129}
2130
2131func (*awsAwsjson11_deserializeOpDeletePortfolio) ID() string {
2132	return "OperationDeserializer"
2133}
2134
2135func (m *awsAwsjson11_deserializeOpDeletePortfolio) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2136	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2137) {
2138	out, metadata, err = next.HandleDeserialize(ctx, in)
2139	if err != nil {
2140		return out, metadata, err
2141	}
2142
2143	response, ok := out.RawResponse.(*smithyhttp.Response)
2144	if !ok {
2145		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2146	}
2147
2148	if response.StatusCode < 200 || response.StatusCode >= 300 {
2149		return out, metadata, awsAwsjson11_deserializeOpErrorDeletePortfolio(response, &metadata)
2150	}
2151	output := &DeletePortfolioOutput{}
2152	out.Result = output
2153
2154	var buff [1024]byte
2155	ringBuffer := smithyio.NewRingBuffer(buff[:])
2156
2157	body := io.TeeReader(response.Body, ringBuffer)
2158	decoder := json.NewDecoder(body)
2159	decoder.UseNumber()
2160	var shape interface{}
2161	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2162		var snapshot bytes.Buffer
2163		io.Copy(&snapshot, ringBuffer)
2164		err = &smithy.DeserializationError{
2165			Err:      fmt.Errorf("failed to decode response body, %w", err),
2166			Snapshot: snapshot.Bytes(),
2167		}
2168		return out, metadata, err
2169	}
2170
2171	err = awsAwsjson11_deserializeOpDocumentDeletePortfolioOutput(&output, shape)
2172	if err != nil {
2173		var snapshot bytes.Buffer
2174		io.Copy(&snapshot, ringBuffer)
2175		err = &smithy.DeserializationError{
2176			Err:      fmt.Errorf("failed to decode response body, %w", err),
2177			Snapshot: snapshot.Bytes(),
2178		}
2179		return out, metadata, err
2180	}
2181
2182	return out, metadata, err
2183}
2184
2185func awsAwsjson11_deserializeOpErrorDeletePortfolio(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2186	var errorBuffer bytes.Buffer
2187	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2188		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2189	}
2190	errorBody := bytes.NewReader(errorBuffer.Bytes())
2191
2192	errorCode := "UnknownError"
2193	errorMessage := errorCode
2194
2195	code := response.Header.Get("X-Amzn-ErrorType")
2196	if len(code) != 0 {
2197		errorCode = restjson.SanitizeErrorCode(code)
2198	}
2199
2200	var buff [1024]byte
2201	ringBuffer := smithyio.NewRingBuffer(buff[:])
2202
2203	body := io.TeeReader(errorBody, ringBuffer)
2204	decoder := json.NewDecoder(body)
2205	decoder.UseNumber()
2206	code, message, err := restjson.GetErrorInfo(decoder)
2207	if err != nil {
2208		var snapshot bytes.Buffer
2209		io.Copy(&snapshot, ringBuffer)
2210		err = &smithy.DeserializationError{
2211			Err:      fmt.Errorf("failed to decode response body, %w", err),
2212			Snapshot: snapshot.Bytes(),
2213		}
2214		return err
2215	}
2216
2217	errorBody.Seek(0, io.SeekStart)
2218	if len(code) != 0 {
2219		errorCode = restjson.SanitizeErrorCode(code)
2220	}
2221	if len(message) != 0 {
2222		errorMessage = message
2223	}
2224
2225	switch {
2226	case strings.EqualFold("InvalidParametersException", errorCode):
2227		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
2228
2229	case strings.EqualFold("ResourceInUseException", errorCode):
2230		return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody)
2231
2232	case strings.EqualFold("ResourceNotFoundException", errorCode):
2233		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
2234
2235	case strings.EqualFold("TagOptionNotMigratedException", errorCode):
2236		return awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response, errorBody)
2237
2238	default:
2239		genericError := &smithy.GenericAPIError{
2240			Code:    errorCode,
2241			Message: errorMessage,
2242		}
2243		return genericError
2244
2245	}
2246}
2247
2248type awsAwsjson11_deserializeOpDeletePortfolioShare struct {
2249}
2250
2251func (*awsAwsjson11_deserializeOpDeletePortfolioShare) ID() string {
2252	return "OperationDeserializer"
2253}
2254
2255func (m *awsAwsjson11_deserializeOpDeletePortfolioShare) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2256	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2257) {
2258	out, metadata, err = next.HandleDeserialize(ctx, in)
2259	if err != nil {
2260		return out, metadata, err
2261	}
2262
2263	response, ok := out.RawResponse.(*smithyhttp.Response)
2264	if !ok {
2265		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2266	}
2267
2268	if response.StatusCode < 200 || response.StatusCode >= 300 {
2269		return out, metadata, awsAwsjson11_deserializeOpErrorDeletePortfolioShare(response, &metadata)
2270	}
2271	output := &DeletePortfolioShareOutput{}
2272	out.Result = output
2273
2274	var buff [1024]byte
2275	ringBuffer := smithyio.NewRingBuffer(buff[:])
2276
2277	body := io.TeeReader(response.Body, ringBuffer)
2278	decoder := json.NewDecoder(body)
2279	decoder.UseNumber()
2280	var shape interface{}
2281	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2282		var snapshot bytes.Buffer
2283		io.Copy(&snapshot, ringBuffer)
2284		err = &smithy.DeserializationError{
2285			Err:      fmt.Errorf("failed to decode response body, %w", err),
2286			Snapshot: snapshot.Bytes(),
2287		}
2288		return out, metadata, err
2289	}
2290
2291	err = awsAwsjson11_deserializeOpDocumentDeletePortfolioShareOutput(&output, shape)
2292	if err != nil {
2293		var snapshot bytes.Buffer
2294		io.Copy(&snapshot, ringBuffer)
2295		err = &smithy.DeserializationError{
2296			Err:      fmt.Errorf("failed to decode response body, %w", err),
2297			Snapshot: snapshot.Bytes(),
2298		}
2299		return out, metadata, err
2300	}
2301
2302	return out, metadata, err
2303}
2304
2305func awsAwsjson11_deserializeOpErrorDeletePortfolioShare(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2306	var errorBuffer bytes.Buffer
2307	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2308		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2309	}
2310	errorBody := bytes.NewReader(errorBuffer.Bytes())
2311
2312	errorCode := "UnknownError"
2313	errorMessage := errorCode
2314
2315	code := response.Header.Get("X-Amzn-ErrorType")
2316	if len(code) != 0 {
2317		errorCode = restjson.SanitizeErrorCode(code)
2318	}
2319
2320	var buff [1024]byte
2321	ringBuffer := smithyio.NewRingBuffer(buff[:])
2322
2323	body := io.TeeReader(errorBody, ringBuffer)
2324	decoder := json.NewDecoder(body)
2325	decoder.UseNumber()
2326	code, message, err := restjson.GetErrorInfo(decoder)
2327	if err != nil {
2328		var snapshot bytes.Buffer
2329		io.Copy(&snapshot, ringBuffer)
2330		err = &smithy.DeserializationError{
2331			Err:      fmt.Errorf("failed to decode response body, %w", err),
2332			Snapshot: snapshot.Bytes(),
2333		}
2334		return err
2335	}
2336
2337	errorBody.Seek(0, io.SeekStart)
2338	if len(code) != 0 {
2339		errorCode = restjson.SanitizeErrorCode(code)
2340	}
2341	if len(message) != 0 {
2342		errorMessage = message
2343	}
2344
2345	switch {
2346	case strings.EqualFold("InvalidParametersException", errorCode):
2347		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
2348
2349	case strings.EqualFold("InvalidStateException", errorCode):
2350		return awsAwsjson11_deserializeErrorInvalidStateException(response, errorBody)
2351
2352	case strings.EqualFold("OperationNotSupportedException", errorCode):
2353		return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody)
2354
2355	case strings.EqualFold("ResourceNotFoundException", errorCode):
2356		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
2357
2358	default:
2359		genericError := &smithy.GenericAPIError{
2360			Code:    errorCode,
2361			Message: errorMessage,
2362		}
2363		return genericError
2364
2365	}
2366}
2367
2368type awsAwsjson11_deserializeOpDeleteProduct struct {
2369}
2370
2371func (*awsAwsjson11_deserializeOpDeleteProduct) ID() string {
2372	return "OperationDeserializer"
2373}
2374
2375func (m *awsAwsjson11_deserializeOpDeleteProduct) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2376	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2377) {
2378	out, metadata, err = next.HandleDeserialize(ctx, in)
2379	if err != nil {
2380		return out, metadata, err
2381	}
2382
2383	response, ok := out.RawResponse.(*smithyhttp.Response)
2384	if !ok {
2385		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2386	}
2387
2388	if response.StatusCode < 200 || response.StatusCode >= 300 {
2389		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteProduct(response, &metadata)
2390	}
2391	output := &DeleteProductOutput{}
2392	out.Result = output
2393
2394	var buff [1024]byte
2395	ringBuffer := smithyio.NewRingBuffer(buff[:])
2396
2397	body := io.TeeReader(response.Body, ringBuffer)
2398	decoder := json.NewDecoder(body)
2399	decoder.UseNumber()
2400	var shape interface{}
2401	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2402		var snapshot bytes.Buffer
2403		io.Copy(&snapshot, ringBuffer)
2404		err = &smithy.DeserializationError{
2405			Err:      fmt.Errorf("failed to decode response body, %w", err),
2406			Snapshot: snapshot.Bytes(),
2407		}
2408		return out, metadata, err
2409	}
2410
2411	err = awsAwsjson11_deserializeOpDocumentDeleteProductOutput(&output, shape)
2412	if err != nil {
2413		var snapshot bytes.Buffer
2414		io.Copy(&snapshot, ringBuffer)
2415		err = &smithy.DeserializationError{
2416			Err:      fmt.Errorf("failed to decode response body, %w", err),
2417			Snapshot: snapshot.Bytes(),
2418		}
2419		return out, metadata, err
2420	}
2421
2422	return out, metadata, err
2423}
2424
2425func awsAwsjson11_deserializeOpErrorDeleteProduct(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2426	var errorBuffer bytes.Buffer
2427	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2428		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2429	}
2430	errorBody := bytes.NewReader(errorBuffer.Bytes())
2431
2432	errorCode := "UnknownError"
2433	errorMessage := errorCode
2434
2435	code := response.Header.Get("X-Amzn-ErrorType")
2436	if len(code) != 0 {
2437		errorCode = restjson.SanitizeErrorCode(code)
2438	}
2439
2440	var buff [1024]byte
2441	ringBuffer := smithyio.NewRingBuffer(buff[:])
2442
2443	body := io.TeeReader(errorBody, ringBuffer)
2444	decoder := json.NewDecoder(body)
2445	decoder.UseNumber()
2446	code, message, err := restjson.GetErrorInfo(decoder)
2447	if err != nil {
2448		var snapshot bytes.Buffer
2449		io.Copy(&snapshot, ringBuffer)
2450		err = &smithy.DeserializationError{
2451			Err:      fmt.Errorf("failed to decode response body, %w", err),
2452			Snapshot: snapshot.Bytes(),
2453		}
2454		return err
2455	}
2456
2457	errorBody.Seek(0, io.SeekStart)
2458	if len(code) != 0 {
2459		errorCode = restjson.SanitizeErrorCode(code)
2460	}
2461	if len(message) != 0 {
2462		errorMessage = message
2463	}
2464
2465	switch {
2466	case strings.EqualFold("InvalidParametersException", errorCode):
2467		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
2468
2469	case strings.EqualFold("ResourceInUseException", errorCode):
2470		return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody)
2471
2472	case strings.EqualFold("ResourceNotFoundException", errorCode):
2473		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
2474
2475	case strings.EqualFold("TagOptionNotMigratedException", errorCode):
2476		return awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response, errorBody)
2477
2478	default:
2479		genericError := &smithy.GenericAPIError{
2480			Code:    errorCode,
2481			Message: errorMessage,
2482		}
2483		return genericError
2484
2485	}
2486}
2487
2488type awsAwsjson11_deserializeOpDeleteProvisionedProductPlan struct {
2489}
2490
2491func (*awsAwsjson11_deserializeOpDeleteProvisionedProductPlan) ID() string {
2492	return "OperationDeserializer"
2493}
2494
2495func (m *awsAwsjson11_deserializeOpDeleteProvisionedProductPlan) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2496	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2497) {
2498	out, metadata, err = next.HandleDeserialize(ctx, in)
2499	if err != nil {
2500		return out, metadata, err
2501	}
2502
2503	response, ok := out.RawResponse.(*smithyhttp.Response)
2504	if !ok {
2505		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2506	}
2507
2508	if response.StatusCode < 200 || response.StatusCode >= 300 {
2509		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteProvisionedProductPlan(response, &metadata)
2510	}
2511	output := &DeleteProvisionedProductPlanOutput{}
2512	out.Result = output
2513
2514	var buff [1024]byte
2515	ringBuffer := smithyio.NewRingBuffer(buff[:])
2516
2517	body := io.TeeReader(response.Body, ringBuffer)
2518	decoder := json.NewDecoder(body)
2519	decoder.UseNumber()
2520	var shape interface{}
2521	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
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 out, metadata, err
2529	}
2530
2531	err = awsAwsjson11_deserializeOpDocumentDeleteProvisionedProductPlanOutput(&output, shape)
2532	if err != nil {
2533		var snapshot bytes.Buffer
2534		io.Copy(&snapshot, ringBuffer)
2535		err = &smithy.DeserializationError{
2536			Err:      fmt.Errorf("failed to decode response body, %w", err),
2537			Snapshot: snapshot.Bytes(),
2538		}
2539		return out, metadata, err
2540	}
2541
2542	return out, metadata, err
2543}
2544
2545func awsAwsjson11_deserializeOpErrorDeleteProvisionedProductPlan(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2546	var errorBuffer bytes.Buffer
2547	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2548		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2549	}
2550	errorBody := bytes.NewReader(errorBuffer.Bytes())
2551
2552	errorCode := "UnknownError"
2553	errorMessage := errorCode
2554
2555	code := response.Header.Get("X-Amzn-ErrorType")
2556	if len(code) != 0 {
2557		errorCode = restjson.SanitizeErrorCode(code)
2558	}
2559
2560	var buff [1024]byte
2561	ringBuffer := smithyio.NewRingBuffer(buff[:])
2562
2563	body := io.TeeReader(errorBody, ringBuffer)
2564	decoder := json.NewDecoder(body)
2565	decoder.UseNumber()
2566	code, message, err := restjson.GetErrorInfo(decoder)
2567	if err != nil {
2568		var snapshot bytes.Buffer
2569		io.Copy(&snapshot, ringBuffer)
2570		err = &smithy.DeserializationError{
2571			Err:      fmt.Errorf("failed to decode response body, %w", err),
2572			Snapshot: snapshot.Bytes(),
2573		}
2574		return err
2575	}
2576
2577	errorBody.Seek(0, io.SeekStart)
2578	if len(code) != 0 {
2579		errorCode = restjson.SanitizeErrorCode(code)
2580	}
2581	if len(message) != 0 {
2582		errorMessage = message
2583	}
2584
2585	switch {
2586	case strings.EqualFold("InvalidParametersException", errorCode):
2587		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
2588
2589	case strings.EqualFold("ResourceNotFoundException", errorCode):
2590		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
2591
2592	default:
2593		genericError := &smithy.GenericAPIError{
2594			Code:    errorCode,
2595			Message: errorMessage,
2596		}
2597		return genericError
2598
2599	}
2600}
2601
2602type awsAwsjson11_deserializeOpDeleteProvisioningArtifact struct {
2603}
2604
2605func (*awsAwsjson11_deserializeOpDeleteProvisioningArtifact) ID() string {
2606	return "OperationDeserializer"
2607}
2608
2609func (m *awsAwsjson11_deserializeOpDeleteProvisioningArtifact) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2610	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2611) {
2612	out, metadata, err = next.HandleDeserialize(ctx, in)
2613	if err != nil {
2614		return out, metadata, err
2615	}
2616
2617	response, ok := out.RawResponse.(*smithyhttp.Response)
2618	if !ok {
2619		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2620	}
2621
2622	if response.StatusCode < 200 || response.StatusCode >= 300 {
2623		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteProvisioningArtifact(response, &metadata)
2624	}
2625	output := &DeleteProvisioningArtifactOutput{}
2626	out.Result = output
2627
2628	var buff [1024]byte
2629	ringBuffer := smithyio.NewRingBuffer(buff[:])
2630
2631	body := io.TeeReader(response.Body, ringBuffer)
2632	decoder := json.NewDecoder(body)
2633	decoder.UseNumber()
2634	var shape interface{}
2635	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2636		var snapshot bytes.Buffer
2637		io.Copy(&snapshot, ringBuffer)
2638		err = &smithy.DeserializationError{
2639			Err:      fmt.Errorf("failed to decode response body, %w", err),
2640			Snapshot: snapshot.Bytes(),
2641		}
2642		return out, metadata, err
2643	}
2644
2645	err = awsAwsjson11_deserializeOpDocumentDeleteProvisioningArtifactOutput(&output, shape)
2646	if err != nil {
2647		var snapshot bytes.Buffer
2648		io.Copy(&snapshot, ringBuffer)
2649		err = &smithy.DeserializationError{
2650			Err:      fmt.Errorf("failed to decode response body, %w", err),
2651			Snapshot: snapshot.Bytes(),
2652		}
2653		return out, metadata, err
2654	}
2655
2656	return out, metadata, err
2657}
2658
2659func awsAwsjson11_deserializeOpErrorDeleteProvisioningArtifact(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2660	var errorBuffer bytes.Buffer
2661	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2662		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2663	}
2664	errorBody := bytes.NewReader(errorBuffer.Bytes())
2665
2666	errorCode := "UnknownError"
2667	errorMessage := errorCode
2668
2669	code := response.Header.Get("X-Amzn-ErrorType")
2670	if len(code) != 0 {
2671		errorCode = restjson.SanitizeErrorCode(code)
2672	}
2673
2674	var buff [1024]byte
2675	ringBuffer := smithyio.NewRingBuffer(buff[:])
2676
2677	body := io.TeeReader(errorBody, ringBuffer)
2678	decoder := json.NewDecoder(body)
2679	decoder.UseNumber()
2680	code, message, err := restjson.GetErrorInfo(decoder)
2681	if err != nil {
2682		var snapshot bytes.Buffer
2683		io.Copy(&snapshot, ringBuffer)
2684		err = &smithy.DeserializationError{
2685			Err:      fmt.Errorf("failed to decode response body, %w", err),
2686			Snapshot: snapshot.Bytes(),
2687		}
2688		return err
2689	}
2690
2691	errorBody.Seek(0, io.SeekStart)
2692	if len(code) != 0 {
2693		errorCode = restjson.SanitizeErrorCode(code)
2694	}
2695	if len(message) != 0 {
2696		errorMessage = message
2697	}
2698
2699	switch {
2700	case strings.EqualFold("InvalidParametersException", errorCode):
2701		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
2702
2703	case strings.EqualFold("ResourceInUseException", errorCode):
2704		return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody)
2705
2706	case strings.EqualFold("ResourceNotFoundException", errorCode):
2707		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
2708
2709	default:
2710		genericError := &smithy.GenericAPIError{
2711			Code:    errorCode,
2712			Message: errorMessage,
2713		}
2714		return genericError
2715
2716	}
2717}
2718
2719type awsAwsjson11_deserializeOpDeleteServiceAction struct {
2720}
2721
2722func (*awsAwsjson11_deserializeOpDeleteServiceAction) ID() string {
2723	return "OperationDeserializer"
2724}
2725
2726func (m *awsAwsjson11_deserializeOpDeleteServiceAction) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2727	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2728) {
2729	out, metadata, err = next.HandleDeserialize(ctx, in)
2730	if err != nil {
2731		return out, metadata, err
2732	}
2733
2734	response, ok := out.RawResponse.(*smithyhttp.Response)
2735	if !ok {
2736		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2737	}
2738
2739	if response.StatusCode < 200 || response.StatusCode >= 300 {
2740		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteServiceAction(response, &metadata)
2741	}
2742	output := &DeleteServiceActionOutput{}
2743	out.Result = output
2744
2745	var buff [1024]byte
2746	ringBuffer := smithyio.NewRingBuffer(buff[:])
2747
2748	body := io.TeeReader(response.Body, ringBuffer)
2749	decoder := json.NewDecoder(body)
2750	decoder.UseNumber()
2751	var shape interface{}
2752	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2753		var snapshot bytes.Buffer
2754		io.Copy(&snapshot, ringBuffer)
2755		err = &smithy.DeserializationError{
2756			Err:      fmt.Errorf("failed to decode response body, %w", err),
2757			Snapshot: snapshot.Bytes(),
2758		}
2759		return out, metadata, err
2760	}
2761
2762	err = awsAwsjson11_deserializeOpDocumentDeleteServiceActionOutput(&output, shape)
2763	if err != nil {
2764		var snapshot bytes.Buffer
2765		io.Copy(&snapshot, ringBuffer)
2766		err = &smithy.DeserializationError{
2767			Err:      fmt.Errorf("failed to decode response body, %w", err),
2768			Snapshot: snapshot.Bytes(),
2769		}
2770		return out, metadata, err
2771	}
2772
2773	return out, metadata, err
2774}
2775
2776func awsAwsjson11_deserializeOpErrorDeleteServiceAction(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2777	var errorBuffer bytes.Buffer
2778	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2779		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2780	}
2781	errorBody := bytes.NewReader(errorBuffer.Bytes())
2782
2783	errorCode := "UnknownError"
2784	errorMessage := errorCode
2785
2786	code := response.Header.Get("X-Amzn-ErrorType")
2787	if len(code) != 0 {
2788		errorCode = restjson.SanitizeErrorCode(code)
2789	}
2790
2791	var buff [1024]byte
2792	ringBuffer := smithyio.NewRingBuffer(buff[:])
2793
2794	body := io.TeeReader(errorBody, ringBuffer)
2795	decoder := json.NewDecoder(body)
2796	decoder.UseNumber()
2797	code, message, err := restjson.GetErrorInfo(decoder)
2798	if err != nil {
2799		var snapshot bytes.Buffer
2800		io.Copy(&snapshot, ringBuffer)
2801		err = &smithy.DeserializationError{
2802			Err:      fmt.Errorf("failed to decode response body, %w", err),
2803			Snapshot: snapshot.Bytes(),
2804		}
2805		return err
2806	}
2807
2808	errorBody.Seek(0, io.SeekStart)
2809	if len(code) != 0 {
2810		errorCode = restjson.SanitizeErrorCode(code)
2811	}
2812	if len(message) != 0 {
2813		errorMessage = message
2814	}
2815
2816	switch {
2817	case strings.EqualFold("ResourceInUseException", errorCode):
2818		return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody)
2819
2820	case strings.EqualFold("ResourceNotFoundException", errorCode):
2821		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
2822
2823	default:
2824		genericError := &smithy.GenericAPIError{
2825			Code:    errorCode,
2826			Message: errorMessage,
2827		}
2828		return genericError
2829
2830	}
2831}
2832
2833type awsAwsjson11_deserializeOpDeleteTagOption struct {
2834}
2835
2836func (*awsAwsjson11_deserializeOpDeleteTagOption) ID() string {
2837	return "OperationDeserializer"
2838}
2839
2840func (m *awsAwsjson11_deserializeOpDeleteTagOption) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2841	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2842) {
2843	out, metadata, err = next.HandleDeserialize(ctx, in)
2844	if err != nil {
2845		return out, metadata, err
2846	}
2847
2848	response, ok := out.RawResponse.(*smithyhttp.Response)
2849	if !ok {
2850		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2851	}
2852
2853	if response.StatusCode < 200 || response.StatusCode >= 300 {
2854		return out, metadata, awsAwsjson11_deserializeOpErrorDeleteTagOption(response, &metadata)
2855	}
2856	output := &DeleteTagOptionOutput{}
2857	out.Result = output
2858
2859	var buff [1024]byte
2860	ringBuffer := smithyio.NewRingBuffer(buff[:])
2861
2862	body := io.TeeReader(response.Body, ringBuffer)
2863	decoder := json.NewDecoder(body)
2864	decoder.UseNumber()
2865	var shape interface{}
2866	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2867		var snapshot bytes.Buffer
2868		io.Copy(&snapshot, ringBuffer)
2869		err = &smithy.DeserializationError{
2870			Err:      fmt.Errorf("failed to decode response body, %w", err),
2871			Snapshot: snapshot.Bytes(),
2872		}
2873		return out, metadata, err
2874	}
2875
2876	err = awsAwsjson11_deserializeOpDocumentDeleteTagOptionOutput(&output, shape)
2877	if err != nil {
2878		var snapshot bytes.Buffer
2879		io.Copy(&snapshot, ringBuffer)
2880		err = &smithy.DeserializationError{
2881			Err:      fmt.Errorf("failed to decode response body, %w", err),
2882			Snapshot: snapshot.Bytes(),
2883		}
2884		return out, metadata, err
2885	}
2886
2887	return out, metadata, err
2888}
2889
2890func awsAwsjson11_deserializeOpErrorDeleteTagOption(response *smithyhttp.Response, metadata *middleware.Metadata) error {
2891	var errorBuffer bytes.Buffer
2892	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
2893		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
2894	}
2895	errorBody := bytes.NewReader(errorBuffer.Bytes())
2896
2897	errorCode := "UnknownError"
2898	errorMessage := errorCode
2899
2900	code := response.Header.Get("X-Amzn-ErrorType")
2901	if len(code) != 0 {
2902		errorCode = restjson.SanitizeErrorCode(code)
2903	}
2904
2905	var buff [1024]byte
2906	ringBuffer := smithyio.NewRingBuffer(buff[:])
2907
2908	body := io.TeeReader(errorBody, ringBuffer)
2909	decoder := json.NewDecoder(body)
2910	decoder.UseNumber()
2911	code, message, err := restjson.GetErrorInfo(decoder)
2912	if err != nil {
2913		var snapshot bytes.Buffer
2914		io.Copy(&snapshot, ringBuffer)
2915		err = &smithy.DeserializationError{
2916			Err:      fmt.Errorf("failed to decode response body, %w", err),
2917			Snapshot: snapshot.Bytes(),
2918		}
2919		return err
2920	}
2921
2922	errorBody.Seek(0, io.SeekStart)
2923	if len(code) != 0 {
2924		errorCode = restjson.SanitizeErrorCode(code)
2925	}
2926	if len(message) != 0 {
2927		errorMessage = message
2928	}
2929
2930	switch {
2931	case strings.EqualFold("ResourceInUseException", errorCode):
2932		return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody)
2933
2934	case strings.EqualFold("ResourceNotFoundException", errorCode):
2935		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
2936
2937	case strings.EqualFold("TagOptionNotMigratedException", errorCode):
2938		return awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response, errorBody)
2939
2940	default:
2941		genericError := &smithy.GenericAPIError{
2942			Code:    errorCode,
2943			Message: errorMessage,
2944		}
2945		return genericError
2946
2947	}
2948}
2949
2950type awsAwsjson11_deserializeOpDescribeConstraint struct {
2951}
2952
2953func (*awsAwsjson11_deserializeOpDescribeConstraint) ID() string {
2954	return "OperationDeserializer"
2955}
2956
2957func (m *awsAwsjson11_deserializeOpDescribeConstraint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
2958	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
2959) {
2960	out, metadata, err = next.HandleDeserialize(ctx, in)
2961	if err != nil {
2962		return out, metadata, err
2963	}
2964
2965	response, ok := out.RawResponse.(*smithyhttp.Response)
2966	if !ok {
2967		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
2968	}
2969
2970	if response.StatusCode < 200 || response.StatusCode >= 300 {
2971		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeConstraint(response, &metadata)
2972	}
2973	output := &DescribeConstraintOutput{}
2974	out.Result = output
2975
2976	var buff [1024]byte
2977	ringBuffer := smithyio.NewRingBuffer(buff[:])
2978
2979	body := io.TeeReader(response.Body, ringBuffer)
2980	decoder := json.NewDecoder(body)
2981	decoder.UseNumber()
2982	var shape interface{}
2983	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
2984		var snapshot bytes.Buffer
2985		io.Copy(&snapshot, ringBuffer)
2986		err = &smithy.DeserializationError{
2987			Err:      fmt.Errorf("failed to decode response body, %w", err),
2988			Snapshot: snapshot.Bytes(),
2989		}
2990		return out, metadata, err
2991	}
2992
2993	err = awsAwsjson11_deserializeOpDocumentDescribeConstraintOutput(&output, shape)
2994	if err != nil {
2995		var snapshot bytes.Buffer
2996		io.Copy(&snapshot, ringBuffer)
2997		err = &smithy.DeserializationError{
2998			Err:      fmt.Errorf("failed to decode response body, %w", err),
2999			Snapshot: snapshot.Bytes(),
3000		}
3001		return out, metadata, err
3002	}
3003
3004	return out, metadata, err
3005}
3006
3007func awsAwsjson11_deserializeOpErrorDescribeConstraint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3008	var errorBuffer bytes.Buffer
3009	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3010		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3011	}
3012	errorBody := bytes.NewReader(errorBuffer.Bytes())
3013
3014	errorCode := "UnknownError"
3015	errorMessage := errorCode
3016
3017	code := response.Header.Get("X-Amzn-ErrorType")
3018	if len(code) != 0 {
3019		errorCode = restjson.SanitizeErrorCode(code)
3020	}
3021
3022	var buff [1024]byte
3023	ringBuffer := smithyio.NewRingBuffer(buff[:])
3024
3025	body := io.TeeReader(errorBody, ringBuffer)
3026	decoder := json.NewDecoder(body)
3027	decoder.UseNumber()
3028	code, message, err := restjson.GetErrorInfo(decoder)
3029	if err != nil {
3030		var snapshot bytes.Buffer
3031		io.Copy(&snapshot, ringBuffer)
3032		err = &smithy.DeserializationError{
3033			Err:      fmt.Errorf("failed to decode response body, %w", err),
3034			Snapshot: snapshot.Bytes(),
3035		}
3036		return err
3037	}
3038
3039	errorBody.Seek(0, io.SeekStart)
3040	if len(code) != 0 {
3041		errorCode = restjson.SanitizeErrorCode(code)
3042	}
3043	if len(message) != 0 {
3044		errorMessage = message
3045	}
3046
3047	switch {
3048	case strings.EqualFold("ResourceNotFoundException", errorCode):
3049		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
3050
3051	default:
3052		genericError := &smithy.GenericAPIError{
3053			Code:    errorCode,
3054			Message: errorMessage,
3055		}
3056		return genericError
3057
3058	}
3059}
3060
3061type awsAwsjson11_deserializeOpDescribeCopyProductStatus struct {
3062}
3063
3064func (*awsAwsjson11_deserializeOpDescribeCopyProductStatus) ID() string {
3065	return "OperationDeserializer"
3066}
3067
3068func (m *awsAwsjson11_deserializeOpDescribeCopyProductStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3069	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3070) {
3071	out, metadata, err = next.HandleDeserialize(ctx, in)
3072	if err != nil {
3073		return out, metadata, err
3074	}
3075
3076	response, ok := out.RawResponse.(*smithyhttp.Response)
3077	if !ok {
3078		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3079	}
3080
3081	if response.StatusCode < 200 || response.StatusCode >= 300 {
3082		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeCopyProductStatus(response, &metadata)
3083	}
3084	output := &DescribeCopyProductStatusOutput{}
3085	out.Result = output
3086
3087	var buff [1024]byte
3088	ringBuffer := smithyio.NewRingBuffer(buff[:])
3089
3090	body := io.TeeReader(response.Body, ringBuffer)
3091	decoder := json.NewDecoder(body)
3092	decoder.UseNumber()
3093	var shape interface{}
3094	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3095		var snapshot bytes.Buffer
3096		io.Copy(&snapshot, ringBuffer)
3097		err = &smithy.DeserializationError{
3098			Err:      fmt.Errorf("failed to decode response body, %w", err),
3099			Snapshot: snapshot.Bytes(),
3100		}
3101		return out, metadata, err
3102	}
3103
3104	err = awsAwsjson11_deserializeOpDocumentDescribeCopyProductStatusOutput(&output, shape)
3105	if err != nil {
3106		var snapshot bytes.Buffer
3107		io.Copy(&snapshot, ringBuffer)
3108		err = &smithy.DeserializationError{
3109			Err:      fmt.Errorf("failed to decode response body, %w", err),
3110			Snapshot: snapshot.Bytes(),
3111		}
3112		return out, metadata, err
3113	}
3114
3115	return out, metadata, err
3116}
3117
3118func awsAwsjson11_deserializeOpErrorDescribeCopyProductStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3119	var errorBuffer bytes.Buffer
3120	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3121		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3122	}
3123	errorBody := bytes.NewReader(errorBuffer.Bytes())
3124
3125	errorCode := "UnknownError"
3126	errorMessage := errorCode
3127
3128	code := response.Header.Get("X-Amzn-ErrorType")
3129	if len(code) != 0 {
3130		errorCode = restjson.SanitizeErrorCode(code)
3131	}
3132
3133	var buff [1024]byte
3134	ringBuffer := smithyio.NewRingBuffer(buff[:])
3135
3136	body := io.TeeReader(errorBody, ringBuffer)
3137	decoder := json.NewDecoder(body)
3138	decoder.UseNumber()
3139	code, message, err := restjson.GetErrorInfo(decoder)
3140	if err != nil {
3141		var snapshot bytes.Buffer
3142		io.Copy(&snapshot, ringBuffer)
3143		err = &smithy.DeserializationError{
3144			Err:      fmt.Errorf("failed to decode response body, %w", err),
3145			Snapshot: snapshot.Bytes(),
3146		}
3147		return err
3148	}
3149
3150	errorBody.Seek(0, io.SeekStart)
3151	if len(code) != 0 {
3152		errorCode = restjson.SanitizeErrorCode(code)
3153	}
3154	if len(message) != 0 {
3155		errorMessage = message
3156	}
3157
3158	switch {
3159	case strings.EqualFold("ResourceNotFoundException", errorCode):
3160		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
3161
3162	default:
3163		genericError := &smithy.GenericAPIError{
3164			Code:    errorCode,
3165			Message: errorMessage,
3166		}
3167		return genericError
3168
3169	}
3170}
3171
3172type awsAwsjson11_deserializeOpDescribePortfolio struct {
3173}
3174
3175func (*awsAwsjson11_deserializeOpDescribePortfolio) ID() string {
3176	return "OperationDeserializer"
3177}
3178
3179func (m *awsAwsjson11_deserializeOpDescribePortfolio) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3180	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3181) {
3182	out, metadata, err = next.HandleDeserialize(ctx, in)
3183	if err != nil {
3184		return out, metadata, err
3185	}
3186
3187	response, ok := out.RawResponse.(*smithyhttp.Response)
3188	if !ok {
3189		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3190	}
3191
3192	if response.StatusCode < 200 || response.StatusCode >= 300 {
3193		return out, metadata, awsAwsjson11_deserializeOpErrorDescribePortfolio(response, &metadata)
3194	}
3195	output := &DescribePortfolioOutput{}
3196	out.Result = output
3197
3198	var buff [1024]byte
3199	ringBuffer := smithyio.NewRingBuffer(buff[:])
3200
3201	body := io.TeeReader(response.Body, ringBuffer)
3202	decoder := json.NewDecoder(body)
3203	decoder.UseNumber()
3204	var shape interface{}
3205	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3206		var snapshot bytes.Buffer
3207		io.Copy(&snapshot, ringBuffer)
3208		err = &smithy.DeserializationError{
3209			Err:      fmt.Errorf("failed to decode response body, %w", err),
3210			Snapshot: snapshot.Bytes(),
3211		}
3212		return out, metadata, err
3213	}
3214
3215	err = awsAwsjson11_deserializeOpDocumentDescribePortfolioOutput(&output, shape)
3216	if err != nil {
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	return out, metadata, err
3227}
3228
3229func awsAwsjson11_deserializeOpErrorDescribePortfolio(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3230	var errorBuffer bytes.Buffer
3231	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3232		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3233	}
3234	errorBody := bytes.NewReader(errorBuffer.Bytes())
3235
3236	errorCode := "UnknownError"
3237	errorMessage := errorCode
3238
3239	code := response.Header.Get("X-Amzn-ErrorType")
3240	if len(code) != 0 {
3241		errorCode = restjson.SanitizeErrorCode(code)
3242	}
3243
3244	var buff [1024]byte
3245	ringBuffer := smithyio.NewRingBuffer(buff[:])
3246
3247	body := io.TeeReader(errorBody, ringBuffer)
3248	decoder := json.NewDecoder(body)
3249	decoder.UseNumber()
3250	code, message, err := restjson.GetErrorInfo(decoder)
3251	if err != nil {
3252		var snapshot bytes.Buffer
3253		io.Copy(&snapshot, ringBuffer)
3254		err = &smithy.DeserializationError{
3255			Err:      fmt.Errorf("failed to decode response body, %w", err),
3256			Snapshot: snapshot.Bytes(),
3257		}
3258		return err
3259	}
3260
3261	errorBody.Seek(0, io.SeekStart)
3262	if len(code) != 0 {
3263		errorCode = restjson.SanitizeErrorCode(code)
3264	}
3265	if len(message) != 0 {
3266		errorMessage = message
3267	}
3268
3269	switch {
3270	case strings.EqualFold("ResourceNotFoundException", errorCode):
3271		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
3272
3273	default:
3274		genericError := &smithy.GenericAPIError{
3275			Code:    errorCode,
3276			Message: errorMessage,
3277		}
3278		return genericError
3279
3280	}
3281}
3282
3283type awsAwsjson11_deserializeOpDescribePortfolioShares struct {
3284}
3285
3286func (*awsAwsjson11_deserializeOpDescribePortfolioShares) ID() string {
3287	return "OperationDeserializer"
3288}
3289
3290func (m *awsAwsjson11_deserializeOpDescribePortfolioShares) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3291	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3292) {
3293	out, metadata, err = next.HandleDeserialize(ctx, in)
3294	if err != nil {
3295		return out, metadata, err
3296	}
3297
3298	response, ok := out.RawResponse.(*smithyhttp.Response)
3299	if !ok {
3300		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3301	}
3302
3303	if response.StatusCode < 200 || response.StatusCode >= 300 {
3304		return out, metadata, awsAwsjson11_deserializeOpErrorDescribePortfolioShares(response, &metadata)
3305	}
3306	output := &DescribePortfolioSharesOutput{}
3307	out.Result = output
3308
3309	var buff [1024]byte
3310	ringBuffer := smithyio.NewRingBuffer(buff[:])
3311
3312	body := io.TeeReader(response.Body, ringBuffer)
3313	decoder := json.NewDecoder(body)
3314	decoder.UseNumber()
3315	var shape interface{}
3316	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3317		var snapshot bytes.Buffer
3318		io.Copy(&snapshot, ringBuffer)
3319		err = &smithy.DeserializationError{
3320			Err:      fmt.Errorf("failed to decode response body, %w", err),
3321			Snapshot: snapshot.Bytes(),
3322		}
3323		return out, metadata, err
3324	}
3325
3326	err = awsAwsjson11_deserializeOpDocumentDescribePortfolioSharesOutput(&output, shape)
3327	if err != nil {
3328		var snapshot bytes.Buffer
3329		io.Copy(&snapshot, ringBuffer)
3330		err = &smithy.DeserializationError{
3331			Err:      fmt.Errorf("failed to decode response body, %w", err),
3332			Snapshot: snapshot.Bytes(),
3333		}
3334		return out, metadata, err
3335	}
3336
3337	return out, metadata, err
3338}
3339
3340func awsAwsjson11_deserializeOpErrorDescribePortfolioShares(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3341	var errorBuffer bytes.Buffer
3342	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3343		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3344	}
3345	errorBody := bytes.NewReader(errorBuffer.Bytes())
3346
3347	errorCode := "UnknownError"
3348	errorMessage := errorCode
3349
3350	code := response.Header.Get("X-Amzn-ErrorType")
3351	if len(code) != 0 {
3352		errorCode = restjson.SanitizeErrorCode(code)
3353	}
3354
3355	var buff [1024]byte
3356	ringBuffer := smithyio.NewRingBuffer(buff[:])
3357
3358	body := io.TeeReader(errorBody, ringBuffer)
3359	decoder := json.NewDecoder(body)
3360	decoder.UseNumber()
3361	code, message, err := restjson.GetErrorInfo(decoder)
3362	if err != nil {
3363		var snapshot bytes.Buffer
3364		io.Copy(&snapshot, ringBuffer)
3365		err = &smithy.DeserializationError{
3366			Err:      fmt.Errorf("failed to decode response body, %w", err),
3367			Snapshot: snapshot.Bytes(),
3368		}
3369		return err
3370	}
3371
3372	errorBody.Seek(0, io.SeekStart)
3373	if len(code) != 0 {
3374		errorCode = restjson.SanitizeErrorCode(code)
3375	}
3376	if len(message) != 0 {
3377		errorMessage = message
3378	}
3379
3380	switch {
3381	case strings.EqualFold("InvalidParametersException", errorCode):
3382		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
3383
3384	case strings.EqualFold("ResourceNotFoundException", errorCode):
3385		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
3386
3387	default:
3388		genericError := &smithy.GenericAPIError{
3389			Code:    errorCode,
3390			Message: errorMessage,
3391		}
3392		return genericError
3393
3394	}
3395}
3396
3397type awsAwsjson11_deserializeOpDescribePortfolioShareStatus struct {
3398}
3399
3400func (*awsAwsjson11_deserializeOpDescribePortfolioShareStatus) ID() string {
3401	return "OperationDeserializer"
3402}
3403
3404func (m *awsAwsjson11_deserializeOpDescribePortfolioShareStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3405	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3406) {
3407	out, metadata, err = next.HandleDeserialize(ctx, in)
3408	if err != nil {
3409		return out, metadata, err
3410	}
3411
3412	response, ok := out.RawResponse.(*smithyhttp.Response)
3413	if !ok {
3414		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3415	}
3416
3417	if response.StatusCode < 200 || response.StatusCode >= 300 {
3418		return out, metadata, awsAwsjson11_deserializeOpErrorDescribePortfolioShareStatus(response, &metadata)
3419	}
3420	output := &DescribePortfolioShareStatusOutput{}
3421	out.Result = output
3422
3423	var buff [1024]byte
3424	ringBuffer := smithyio.NewRingBuffer(buff[:])
3425
3426	body := io.TeeReader(response.Body, ringBuffer)
3427	decoder := json.NewDecoder(body)
3428	decoder.UseNumber()
3429	var shape interface{}
3430	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3431		var snapshot bytes.Buffer
3432		io.Copy(&snapshot, ringBuffer)
3433		err = &smithy.DeserializationError{
3434			Err:      fmt.Errorf("failed to decode response body, %w", err),
3435			Snapshot: snapshot.Bytes(),
3436		}
3437		return out, metadata, err
3438	}
3439
3440	err = awsAwsjson11_deserializeOpDocumentDescribePortfolioShareStatusOutput(&output, shape)
3441	if err != nil {
3442		var snapshot bytes.Buffer
3443		io.Copy(&snapshot, ringBuffer)
3444		err = &smithy.DeserializationError{
3445			Err:      fmt.Errorf("failed to decode response body, %w", err),
3446			Snapshot: snapshot.Bytes(),
3447		}
3448		return out, metadata, err
3449	}
3450
3451	return out, metadata, err
3452}
3453
3454func awsAwsjson11_deserializeOpErrorDescribePortfolioShareStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3455	var errorBuffer bytes.Buffer
3456	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3457		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3458	}
3459	errorBody := bytes.NewReader(errorBuffer.Bytes())
3460
3461	errorCode := "UnknownError"
3462	errorMessage := errorCode
3463
3464	code := response.Header.Get("X-Amzn-ErrorType")
3465	if len(code) != 0 {
3466		errorCode = restjson.SanitizeErrorCode(code)
3467	}
3468
3469	var buff [1024]byte
3470	ringBuffer := smithyio.NewRingBuffer(buff[:])
3471
3472	body := io.TeeReader(errorBody, ringBuffer)
3473	decoder := json.NewDecoder(body)
3474	decoder.UseNumber()
3475	code, message, err := restjson.GetErrorInfo(decoder)
3476	if err != nil {
3477		var snapshot bytes.Buffer
3478		io.Copy(&snapshot, ringBuffer)
3479		err = &smithy.DeserializationError{
3480			Err:      fmt.Errorf("failed to decode response body, %w", err),
3481			Snapshot: snapshot.Bytes(),
3482		}
3483		return err
3484	}
3485
3486	errorBody.Seek(0, io.SeekStart)
3487	if len(code) != 0 {
3488		errorCode = restjson.SanitizeErrorCode(code)
3489	}
3490	if len(message) != 0 {
3491		errorMessage = message
3492	}
3493
3494	switch {
3495	case strings.EqualFold("InvalidParametersException", errorCode):
3496		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
3497
3498	case strings.EqualFold("OperationNotSupportedException", errorCode):
3499		return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody)
3500
3501	case strings.EqualFold("ResourceNotFoundException", errorCode):
3502		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
3503
3504	default:
3505		genericError := &smithy.GenericAPIError{
3506			Code:    errorCode,
3507			Message: errorMessage,
3508		}
3509		return genericError
3510
3511	}
3512}
3513
3514type awsAwsjson11_deserializeOpDescribeProduct struct {
3515}
3516
3517func (*awsAwsjson11_deserializeOpDescribeProduct) ID() string {
3518	return "OperationDeserializer"
3519}
3520
3521func (m *awsAwsjson11_deserializeOpDescribeProduct) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3522	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3523) {
3524	out, metadata, err = next.HandleDeserialize(ctx, in)
3525	if err != nil {
3526		return out, metadata, err
3527	}
3528
3529	response, ok := out.RawResponse.(*smithyhttp.Response)
3530	if !ok {
3531		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3532	}
3533
3534	if response.StatusCode < 200 || response.StatusCode >= 300 {
3535		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeProduct(response, &metadata)
3536	}
3537	output := &DescribeProductOutput{}
3538	out.Result = output
3539
3540	var buff [1024]byte
3541	ringBuffer := smithyio.NewRingBuffer(buff[:])
3542
3543	body := io.TeeReader(response.Body, ringBuffer)
3544	decoder := json.NewDecoder(body)
3545	decoder.UseNumber()
3546	var shape interface{}
3547	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3548		var snapshot bytes.Buffer
3549		io.Copy(&snapshot, ringBuffer)
3550		err = &smithy.DeserializationError{
3551			Err:      fmt.Errorf("failed to decode response body, %w", err),
3552			Snapshot: snapshot.Bytes(),
3553		}
3554		return out, metadata, err
3555	}
3556
3557	err = awsAwsjson11_deserializeOpDocumentDescribeProductOutput(&output, shape)
3558	if err != nil {
3559		var snapshot bytes.Buffer
3560		io.Copy(&snapshot, ringBuffer)
3561		err = &smithy.DeserializationError{
3562			Err:      fmt.Errorf("failed to decode response body, %w", err),
3563			Snapshot: snapshot.Bytes(),
3564		}
3565		return out, metadata, err
3566	}
3567
3568	return out, metadata, err
3569}
3570
3571func awsAwsjson11_deserializeOpErrorDescribeProduct(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3572	var errorBuffer bytes.Buffer
3573	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3574		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3575	}
3576	errorBody := bytes.NewReader(errorBuffer.Bytes())
3577
3578	errorCode := "UnknownError"
3579	errorMessage := errorCode
3580
3581	code := response.Header.Get("X-Amzn-ErrorType")
3582	if len(code) != 0 {
3583		errorCode = restjson.SanitizeErrorCode(code)
3584	}
3585
3586	var buff [1024]byte
3587	ringBuffer := smithyio.NewRingBuffer(buff[:])
3588
3589	body := io.TeeReader(errorBody, ringBuffer)
3590	decoder := json.NewDecoder(body)
3591	decoder.UseNumber()
3592	code, message, err := restjson.GetErrorInfo(decoder)
3593	if err != nil {
3594		var snapshot bytes.Buffer
3595		io.Copy(&snapshot, ringBuffer)
3596		err = &smithy.DeserializationError{
3597			Err:      fmt.Errorf("failed to decode response body, %w", err),
3598			Snapshot: snapshot.Bytes(),
3599		}
3600		return err
3601	}
3602
3603	errorBody.Seek(0, io.SeekStart)
3604	if len(code) != 0 {
3605		errorCode = restjson.SanitizeErrorCode(code)
3606	}
3607	if len(message) != 0 {
3608		errorMessage = message
3609	}
3610
3611	switch {
3612	case strings.EqualFold("InvalidParametersException", errorCode):
3613		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
3614
3615	case strings.EqualFold("ResourceNotFoundException", errorCode):
3616		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
3617
3618	default:
3619		genericError := &smithy.GenericAPIError{
3620			Code:    errorCode,
3621			Message: errorMessage,
3622		}
3623		return genericError
3624
3625	}
3626}
3627
3628type awsAwsjson11_deserializeOpDescribeProductAsAdmin struct {
3629}
3630
3631func (*awsAwsjson11_deserializeOpDescribeProductAsAdmin) ID() string {
3632	return "OperationDeserializer"
3633}
3634
3635func (m *awsAwsjson11_deserializeOpDescribeProductAsAdmin) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3636	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3637) {
3638	out, metadata, err = next.HandleDeserialize(ctx, in)
3639	if err != nil {
3640		return out, metadata, err
3641	}
3642
3643	response, ok := out.RawResponse.(*smithyhttp.Response)
3644	if !ok {
3645		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3646	}
3647
3648	if response.StatusCode < 200 || response.StatusCode >= 300 {
3649		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeProductAsAdmin(response, &metadata)
3650	}
3651	output := &DescribeProductAsAdminOutput{}
3652	out.Result = output
3653
3654	var buff [1024]byte
3655	ringBuffer := smithyio.NewRingBuffer(buff[:])
3656
3657	body := io.TeeReader(response.Body, ringBuffer)
3658	decoder := json.NewDecoder(body)
3659	decoder.UseNumber()
3660	var shape interface{}
3661	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3662		var snapshot bytes.Buffer
3663		io.Copy(&snapshot, ringBuffer)
3664		err = &smithy.DeserializationError{
3665			Err:      fmt.Errorf("failed to decode response body, %w", err),
3666			Snapshot: snapshot.Bytes(),
3667		}
3668		return out, metadata, err
3669	}
3670
3671	err = awsAwsjson11_deserializeOpDocumentDescribeProductAsAdminOutput(&output, shape)
3672	if err != nil {
3673		var snapshot bytes.Buffer
3674		io.Copy(&snapshot, ringBuffer)
3675		err = &smithy.DeserializationError{
3676			Err:      fmt.Errorf("failed to decode response body, %w", err),
3677			Snapshot: snapshot.Bytes(),
3678		}
3679		return out, metadata, err
3680	}
3681
3682	return out, metadata, err
3683}
3684
3685func awsAwsjson11_deserializeOpErrorDescribeProductAsAdmin(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3686	var errorBuffer bytes.Buffer
3687	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3688		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3689	}
3690	errorBody := bytes.NewReader(errorBuffer.Bytes())
3691
3692	errorCode := "UnknownError"
3693	errorMessage := errorCode
3694
3695	code := response.Header.Get("X-Amzn-ErrorType")
3696	if len(code) != 0 {
3697		errorCode = restjson.SanitizeErrorCode(code)
3698	}
3699
3700	var buff [1024]byte
3701	ringBuffer := smithyio.NewRingBuffer(buff[:])
3702
3703	body := io.TeeReader(errorBody, ringBuffer)
3704	decoder := json.NewDecoder(body)
3705	decoder.UseNumber()
3706	code, message, err := restjson.GetErrorInfo(decoder)
3707	if err != nil {
3708		var snapshot bytes.Buffer
3709		io.Copy(&snapshot, ringBuffer)
3710		err = &smithy.DeserializationError{
3711			Err:      fmt.Errorf("failed to decode response body, %w", err),
3712			Snapshot: snapshot.Bytes(),
3713		}
3714		return err
3715	}
3716
3717	errorBody.Seek(0, io.SeekStart)
3718	if len(code) != 0 {
3719		errorCode = restjson.SanitizeErrorCode(code)
3720	}
3721	if len(message) != 0 {
3722		errorMessage = message
3723	}
3724
3725	switch {
3726	case strings.EqualFold("InvalidParametersException", errorCode):
3727		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
3728
3729	case strings.EqualFold("ResourceNotFoundException", errorCode):
3730		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
3731
3732	default:
3733		genericError := &smithy.GenericAPIError{
3734			Code:    errorCode,
3735			Message: errorMessage,
3736		}
3737		return genericError
3738
3739	}
3740}
3741
3742type awsAwsjson11_deserializeOpDescribeProductView struct {
3743}
3744
3745func (*awsAwsjson11_deserializeOpDescribeProductView) ID() string {
3746	return "OperationDeserializer"
3747}
3748
3749func (m *awsAwsjson11_deserializeOpDescribeProductView) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3750	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3751) {
3752	out, metadata, err = next.HandleDeserialize(ctx, in)
3753	if err != nil {
3754		return out, metadata, err
3755	}
3756
3757	response, ok := out.RawResponse.(*smithyhttp.Response)
3758	if !ok {
3759		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3760	}
3761
3762	if response.StatusCode < 200 || response.StatusCode >= 300 {
3763		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeProductView(response, &metadata)
3764	}
3765	output := &DescribeProductViewOutput{}
3766	out.Result = output
3767
3768	var buff [1024]byte
3769	ringBuffer := smithyio.NewRingBuffer(buff[:])
3770
3771	body := io.TeeReader(response.Body, ringBuffer)
3772	decoder := json.NewDecoder(body)
3773	decoder.UseNumber()
3774	var shape interface{}
3775	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3776		var snapshot bytes.Buffer
3777		io.Copy(&snapshot, ringBuffer)
3778		err = &smithy.DeserializationError{
3779			Err:      fmt.Errorf("failed to decode response body, %w", err),
3780			Snapshot: snapshot.Bytes(),
3781		}
3782		return out, metadata, err
3783	}
3784
3785	err = awsAwsjson11_deserializeOpDocumentDescribeProductViewOutput(&output, shape)
3786	if err != nil {
3787		var snapshot bytes.Buffer
3788		io.Copy(&snapshot, ringBuffer)
3789		err = &smithy.DeserializationError{
3790			Err:      fmt.Errorf("failed to decode response body, %w", err),
3791			Snapshot: snapshot.Bytes(),
3792		}
3793		return out, metadata, err
3794	}
3795
3796	return out, metadata, err
3797}
3798
3799func awsAwsjson11_deserializeOpErrorDescribeProductView(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3800	var errorBuffer bytes.Buffer
3801	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3802		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3803	}
3804	errorBody := bytes.NewReader(errorBuffer.Bytes())
3805
3806	errorCode := "UnknownError"
3807	errorMessage := errorCode
3808
3809	code := response.Header.Get("X-Amzn-ErrorType")
3810	if len(code) != 0 {
3811		errorCode = restjson.SanitizeErrorCode(code)
3812	}
3813
3814	var buff [1024]byte
3815	ringBuffer := smithyio.NewRingBuffer(buff[:])
3816
3817	body := io.TeeReader(errorBody, ringBuffer)
3818	decoder := json.NewDecoder(body)
3819	decoder.UseNumber()
3820	code, message, err := restjson.GetErrorInfo(decoder)
3821	if err != nil {
3822		var snapshot bytes.Buffer
3823		io.Copy(&snapshot, ringBuffer)
3824		err = &smithy.DeserializationError{
3825			Err:      fmt.Errorf("failed to decode response body, %w", err),
3826			Snapshot: snapshot.Bytes(),
3827		}
3828		return err
3829	}
3830
3831	errorBody.Seek(0, io.SeekStart)
3832	if len(code) != 0 {
3833		errorCode = restjson.SanitizeErrorCode(code)
3834	}
3835	if len(message) != 0 {
3836		errorMessage = message
3837	}
3838
3839	switch {
3840	case strings.EqualFold("InvalidParametersException", errorCode):
3841		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
3842
3843	case strings.EqualFold("ResourceNotFoundException", errorCode):
3844		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
3845
3846	default:
3847		genericError := &smithy.GenericAPIError{
3848			Code:    errorCode,
3849			Message: errorMessage,
3850		}
3851		return genericError
3852
3853	}
3854}
3855
3856type awsAwsjson11_deserializeOpDescribeProvisionedProduct struct {
3857}
3858
3859func (*awsAwsjson11_deserializeOpDescribeProvisionedProduct) ID() string {
3860	return "OperationDeserializer"
3861}
3862
3863func (m *awsAwsjson11_deserializeOpDescribeProvisionedProduct) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3864	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3865) {
3866	out, metadata, err = next.HandleDeserialize(ctx, in)
3867	if err != nil {
3868		return out, metadata, err
3869	}
3870
3871	response, ok := out.RawResponse.(*smithyhttp.Response)
3872	if !ok {
3873		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3874	}
3875
3876	if response.StatusCode < 200 || response.StatusCode >= 300 {
3877		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeProvisionedProduct(response, &metadata)
3878	}
3879	output := &DescribeProvisionedProductOutput{}
3880	out.Result = output
3881
3882	var buff [1024]byte
3883	ringBuffer := smithyio.NewRingBuffer(buff[:])
3884
3885	body := io.TeeReader(response.Body, ringBuffer)
3886	decoder := json.NewDecoder(body)
3887	decoder.UseNumber()
3888	var shape interface{}
3889	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
3890		var snapshot bytes.Buffer
3891		io.Copy(&snapshot, ringBuffer)
3892		err = &smithy.DeserializationError{
3893			Err:      fmt.Errorf("failed to decode response body, %w", err),
3894			Snapshot: snapshot.Bytes(),
3895		}
3896		return out, metadata, err
3897	}
3898
3899	err = awsAwsjson11_deserializeOpDocumentDescribeProvisionedProductOutput(&output, shape)
3900	if err != nil {
3901		var snapshot bytes.Buffer
3902		io.Copy(&snapshot, ringBuffer)
3903		err = &smithy.DeserializationError{
3904			Err:      fmt.Errorf("failed to decode response body, %w", err),
3905			Snapshot: snapshot.Bytes(),
3906		}
3907		return out, metadata, err
3908	}
3909
3910	return out, metadata, err
3911}
3912
3913func awsAwsjson11_deserializeOpErrorDescribeProvisionedProduct(response *smithyhttp.Response, metadata *middleware.Metadata) error {
3914	var errorBuffer bytes.Buffer
3915	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
3916		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
3917	}
3918	errorBody := bytes.NewReader(errorBuffer.Bytes())
3919
3920	errorCode := "UnknownError"
3921	errorMessage := errorCode
3922
3923	code := response.Header.Get("X-Amzn-ErrorType")
3924	if len(code) != 0 {
3925		errorCode = restjson.SanitizeErrorCode(code)
3926	}
3927
3928	var buff [1024]byte
3929	ringBuffer := smithyio.NewRingBuffer(buff[:])
3930
3931	body := io.TeeReader(errorBody, ringBuffer)
3932	decoder := json.NewDecoder(body)
3933	decoder.UseNumber()
3934	code, message, err := restjson.GetErrorInfo(decoder)
3935	if err != nil {
3936		var snapshot bytes.Buffer
3937		io.Copy(&snapshot, ringBuffer)
3938		err = &smithy.DeserializationError{
3939			Err:      fmt.Errorf("failed to decode response body, %w", err),
3940			Snapshot: snapshot.Bytes(),
3941		}
3942		return err
3943	}
3944
3945	errorBody.Seek(0, io.SeekStart)
3946	if len(code) != 0 {
3947		errorCode = restjson.SanitizeErrorCode(code)
3948	}
3949	if len(message) != 0 {
3950		errorMessage = message
3951	}
3952
3953	switch {
3954	case strings.EqualFold("InvalidParametersException", errorCode):
3955		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
3956
3957	case strings.EqualFold("ResourceNotFoundException", errorCode):
3958		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
3959
3960	default:
3961		genericError := &smithy.GenericAPIError{
3962			Code:    errorCode,
3963			Message: errorMessage,
3964		}
3965		return genericError
3966
3967	}
3968}
3969
3970type awsAwsjson11_deserializeOpDescribeProvisionedProductPlan struct {
3971}
3972
3973func (*awsAwsjson11_deserializeOpDescribeProvisionedProductPlan) ID() string {
3974	return "OperationDeserializer"
3975}
3976
3977func (m *awsAwsjson11_deserializeOpDescribeProvisionedProductPlan) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
3978	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
3979) {
3980	out, metadata, err = next.HandleDeserialize(ctx, in)
3981	if err != nil {
3982		return out, metadata, err
3983	}
3984
3985	response, ok := out.RawResponse.(*smithyhttp.Response)
3986	if !ok {
3987		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
3988	}
3989
3990	if response.StatusCode < 200 || response.StatusCode >= 300 {
3991		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeProvisionedProductPlan(response, &metadata)
3992	}
3993	output := &DescribeProvisionedProductPlanOutput{}
3994	out.Result = output
3995
3996	var buff [1024]byte
3997	ringBuffer := smithyio.NewRingBuffer(buff[:])
3998
3999	body := io.TeeReader(response.Body, ringBuffer)
4000	decoder := json.NewDecoder(body)
4001	decoder.UseNumber()
4002	var shape interface{}
4003	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
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	err = awsAwsjson11_deserializeOpDocumentDescribeProvisionedProductPlanOutput(&output, shape)
4014	if err != nil {
4015		var snapshot bytes.Buffer
4016		io.Copy(&snapshot, ringBuffer)
4017		err = &smithy.DeserializationError{
4018			Err:      fmt.Errorf("failed to decode response body, %w", err),
4019			Snapshot: snapshot.Bytes(),
4020		}
4021		return out, metadata, err
4022	}
4023
4024	return out, metadata, err
4025}
4026
4027func awsAwsjson11_deserializeOpErrorDescribeProvisionedProductPlan(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4028	var errorBuffer bytes.Buffer
4029	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4030		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4031	}
4032	errorBody := bytes.NewReader(errorBuffer.Bytes())
4033
4034	errorCode := "UnknownError"
4035	errorMessage := errorCode
4036
4037	code := response.Header.Get("X-Amzn-ErrorType")
4038	if len(code) != 0 {
4039		errorCode = restjson.SanitizeErrorCode(code)
4040	}
4041
4042	var buff [1024]byte
4043	ringBuffer := smithyio.NewRingBuffer(buff[:])
4044
4045	body := io.TeeReader(errorBody, ringBuffer)
4046	decoder := json.NewDecoder(body)
4047	decoder.UseNumber()
4048	code, message, err := restjson.GetErrorInfo(decoder)
4049	if err != nil {
4050		var snapshot bytes.Buffer
4051		io.Copy(&snapshot, ringBuffer)
4052		err = &smithy.DeserializationError{
4053			Err:      fmt.Errorf("failed to decode response body, %w", err),
4054			Snapshot: snapshot.Bytes(),
4055		}
4056		return err
4057	}
4058
4059	errorBody.Seek(0, io.SeekStart)
4060	if len(code) != 0 {
4061		errorCode = restjson.SanitizeErrorCode(code)
4062	}
4063	if len(message) != 0 {
4064		errorMessage = message
4065	}
4066
4067	switch {
4068	case strings.EqualFold("InvalidParametersException", errorCode):
4069		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
4070
4071	case strings.EqualFold("ResourceNotFoundException", errorCode):
4072		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
4073
4074	default:
4075		genericError := &smithy.GenericAPIError{
4076			Code:    errorCode,
4077			Message: errorMessage,
4078		}
4079		return genericError
4080
4081	}
4082}
4083
4084type awsAwsjson11_deserializeOpDescribeProvisioningArtifact struct {
4085}
4086
4087func (*awsAwsjson11_deserializeOpDescribeProvisioningArtifact) ID() string {
4088	return "OperationDeserializer"
4089}
4090
4091func (m *awsAwsjson11_deserializeOpDescribeProvisioningArtifact) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4092	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4093) {
4094	out, metadata, err = next.HandleDeserialize(ctx, in)
4095	if err != nil {
4096		return out, metadata, err
4097	}
4098
4099	response, ok := out.RawResponse.(*smithyhttp.Response)
4100	if !ok {
4101		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4102	}
4103
4104	if response.StatusCode < 200 || response.StatusCode >= 300 {
4105		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeProvisioningArtifact(response, &metadata)
4106	}
4107	output := &DescribeProvisioningArtifactOutput{}
4108	out.Result = output
4109
4110	var buff [1024]byte
4111	ringBuffer := smithyio.NewRingBuffer(buff[:])
4112
4113	body := io.TeeReader(response.Body, ringBuffer)
4114	decoder := json.NewDecoder(body)
4115	decoder.UseNumber()
4116	var shape interface{}
4117	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4118		var snapshot bytes.Buffer
4119		io.Copy(&snapshot, ringBuffer)
4120		err = &smithy.DeserializationError{
4121			Err:      fmt.Errorf("failed to decode response body, %w", err),
4122			Snapshot: snapshot.Bytes(),
4123		}
4124		return out, metadata, err
4125	}
4126
4127	err = awsAwsjson11_deserializeOpDocumentDescribeProvisioningArtifactOutput(&output, shape)
4128	if err != nil {
4129		var snapshot bytes.Buffer
4130		io.Copy(&snapshot, ringBuffer)
4131		err = &smithy.DeserializationError{
4132			Err:      fmt.Errorf("failed to decode response body, %w", err),
4133			Snapshot: snapshot.Bytes(),
4134		}
4135		return out, metadata, err
4136	}
4137
4138	return out, metadata, err
4139}
4140
4141func awsAwsjson11_deserializeOpErrorDescribeProvisioningArtifact(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4142	var errorBuffer bytes.Buffer
4143	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4144		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4145	}
4146	errorBody := bytes.NewReader(errorBuffer.Bytes())
4147
4148	errorCode := "UnknownError"
4149	errorMessage := errorCode
4150
4151	code := response.Header.Get("X-Amzn-ErrorType")
4152	if len(code) != 0 {
4153		errorCode = restjson.SanitizeErrorCode(code)
4154	}
4155
4156	var buff [1024]byte
4157	ringBuffer := smithyio.NewRingBuffer(buff[:])
4158
4159	body := io.TeeReader(errorBody, ringBuffer)
4160	decoder := json.NewDecoder(body)
4161	decoder.UseNumber()
4162	code, message, err := restjson.GetErrorInfo(decoder)
4163	if err != nil {
4164		var snapshot bytes.Buffer
4165		io.Copy(&snapshot, ringBuffer)
4166		err = &smithy.DeserializationError{
4167			Err:      fmt.Errorf("failed to decode response body, %w", err),
4168			Snapshot: snapshot.Bytes(),
4169		}
4170		return err
4171	}
4172
4173	errorBody.Seek(0, io.SeekStart)
4174	if len(code) != 0 {
4175		errorCode = restjson.SanitizeErrorCode(code)
4176	}
4177	if len(message) != 0 {
4178		errorMessage = message
4179	}
4180
4181	switch {
4182	case strings.EqualFold("InvalidParametersException", errorCode):
4183		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
4184
4185	case strings.EqualFold("ResourceNotFoundException", errorCode):
4186		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
4187
4188	default:
4189		genericError := &smithy.GenericAPIError{
4190			Code:    errorCode,
4191			Message: errorMessage,
4192		}
4193		return genericError
4194
4195	}
4196}
4197
4198type awsAwsjson11_deserializeOpDescribeProvisioningParameters struct {
4199}
4200
4201func (*awsAwsjson11_deserializeOpDescribeProvisioningParameters) ID() string {
4202	return "OperationDeserializer"
4203}
4204
4205func (m *awsAwsjson11_deserializeOpDescribeProvisioningParameters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4206	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4207) {
4208	out, metadata, err = next.HandleDeserialize(ctx, in)
4209	if err != nil {
4210		return out, metadata, err
4211	}
4212
4213	response, ok := out.RawResponse.(*smithyhttp.Response)
4214	if !ok {
4215		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4216	}
4217
4218	if response.StatusCode < 200 || response.StatusCode >= 300 {
4219		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeProvisioningParameters(response, &metadata)
4220	}
4221	output := &DescribeProvisioningParametersOutput{}
4222	out.Result = output
4223
4224	var buff [1024]byte
4225	ringBuffer := smithyio.NewRingBuffer(buff[:])
4226
4227	body := io.TeeReader(response.Body, ringBuffer)
4228	decoder := json.NewDecoder(body)
4229	decoder.UseNumber()
4230	var shape interface{}
4231	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4232		var snapshot bytes.Buffer
4233		io.Copy(&snapshot, ringBuffer)
4234		err = &smithy.DeserializationError{
4235			Err:      fmt.Errorf("failed to decode response body, %w", err),
4236			Snapshot: snapshot.Bytes(),
4237		}
4238		return out, metadata, err
4239	}
4240
4241	err = awsAwsjson11_deserializeOpDocumentDescribeProvisioningParametersOutput(&output, shape)
4242	if err != nil {
4243		var snapshot bytes.Buffer
4244		io.Copy(&snapshot, ringBuffer)
4245		err = &smithy.DeserializationError{
4246			Err:      fmt.Errorf("failed to decode response body, %w", err),
4247			Snapshot: snapshot.Bytes(),
4248		}
4249		return out, metadata, err
4250	}
4251
4252	return out, metadata, err
4253}
4254
4255func awsAwsjson11_deserializeOpErrorDescribeProvisioningParameters(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4256	var errorBuffer bytes.Buffer
4257	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4258		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4259	}
4260	errorBody := bytes.NewReader(errorBuffer.Bytes())
4261
4262	errorCode := "UnknownError"
4263	errorMessage := errorCode
4264
4265	code := response.Header.Get("X-Amzn-ErrorType")
4266	if len(code) != 0 {
4267		errorCode = restjson.SanitizeErrorCode(code)
4268	}
4269
4270	var buff [1024]byte
4271	ringBuffer := smithyio.NewRingBuffer(buff[:])
4272
4273	body := io.TeeReader(errorBody, ringBuffer)
4274	decoder := json.NewDecoder(body)
4275	decoder.UseNumber()
4276	code, message, err := restjson.GetErrorInfo(decoder)
4277	if err != nil {
4278		var snapshot bytes.Buffer
4279		io.Copy(&snapshot, ringBuffer)
4280		err = &smithy.DeserializationError{
4281			Err:      fmt.Errorf("failed to decode response body, %w", err),
4282			Snapshot: snapshot.Bytes(),
4283		}
4284		return err
4285	}
4286
4287	errorBody.Seek(0, io.SeekStart)
4288	if len(code) != 0 {
4289		errorCode = restjson.SanitizeErrorCode(code)
4290	}
4291	if len(message) != 0 {
4292		errorMessage = message
4293	}
4294
4295	switch {
4296	case strings.EqualFold("InvalidParametersException", errorCode):
4297		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
4298
4299	case strings.EqualFold("ResourceNotFoundException", errorCode):
4300		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
4301
4302	default:
4303		genericError := &smithy.GenericAPIError{
4304			Code:    errorCode,
4305			Message: errorMessage,
4306		}
4307		return genericError
4308
4309	}
4310}
4311
4312type awsAwsjson11_deserializeOpDescribeRecord struct {
4313}
4314
4315func (*awsAwsjson11_deserializeOpDescribeRecord) ID() string {
4316	return "OperationDeserializer"
4317}
4318
4319func (m *awsAwsjson11_deserializeOpDescribeRecord) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4320	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4321) {
4322	out, metadata, err = next.HandleDeserialize(ctx, in)
4323	if err != nil {
4324		return out, metadata, err
4325	}
4326
4327	response, ok := out.RawResponse.(*smithyhttp.Response)
4328	if !ok {
4329		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4330	}
4331
4332	if response.StatusCode < 200 || response.StatusCode >= 300 {
4333		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeRecord(response, &metadata)
4334	}
4335	output := &DescribeRecordOutput{}
4336	out.Result = output
4337
4338	var buff [1024]byte
4339	ringBuffer := smithyio.NewRingBuffer(buff[:])
4340
4341	body := io.TeeReader(response.Body, ringBuffer)
4342	decoder := json.NewDecoder(body)
4343	decoder.UseNumber()
4344	var shape interface{}
4345	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4346		var snapshot bytes.Buffer
4347		io.Copy(&snapshot, ringBuffer)
4348		err = &smithy.DeserializationError{
4349			Err:      fmt.Errorf("failed to decode response body, %w", err),
4350			Snapshot: snapshot.Bytes(),
4351		}
4352		return out, metadata, err
4353	}
4354
4355	err = awsAwsjson11_deserializeOpDocumentDescribeRecordOutput(&output, shape)
4356	if err != nil {
4357		var snapshot bytes.Buffer
4358		io.Copy(&snapshot, ringBuffer)
4359		err = &smithy.DeserializationError{
4360			Err:      fmt.Errorf("failed to decode response body, %w", err),
4361			Snapshot: snapshot.Bytes(),
4362		}
4363		return out, metadata, err
4364	}
4365
4366	return out, metadata, err
4367}
4368
4369func awsAwsjson11_deserializeOpErrorDescribeRecord(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4370	var errorBuffer bytes.Buffer
4371	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4372		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4373	}
4374	errorBody := bytes.NewReader(errorBuffer.Bytes())
4375
4376	errorCode := "UnknownError"
4377	errorMessage := errorCode
4378
4379	code := response.Header.Get("X-Amzn-ErrorType")
4380	if len(code) != 0 {
4381		errorCode = restjson.SanitizeErrorCode(code)
4382	}
4383
4384	var buff [1024]byte
4385	ringBuffer := smithyio.NewRingBuffer(buff[:])
4386
4387	body := io.TeeReader(errorBody, ringBuffer)
4388	decoder := json.NewDecoder(body)
4389	decoder.UseNumber()
4390	code, message, err := restjson.GetErrorInfo(decoder)
4391	if err != nil {
4392		var snapshot bytes.Buffer
4393		io.Copy(&snapshot, ringBuffer)
4394		err = &smithy.DeserializationError{
4395			Err:      fmt.Errorf("failed to decode response body, %w", err),
4396			Snapshot: snapshot.Bytes(),
4397		}
4398		return err
4399	}
4400
4401	errorBody.Seek(0, io.SeekStart)
4402	if len(code) != 0 {
4403		errorCode = restjson.SanitizeErrorCode(code)
4404	}
4405	if len(message) != 0 {
4406		errorMessage = message
4407	}
4408
4409	switch {
4410	case strings.EqualFold("ResourceNotFoundException", errorCode):
4411		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
4412
4413	default:
4414		genericError := &smithy.GenericAPIError{
4415			Code:    errorCode,
4416			Message: errorMessage,
4417		}
4418		return genericError
4419
4420	}
4421}
4422
4423type awsAwsjson11_deserializeOpDescribeServiceAction struct {
4424}
4425
4426func (*awsAwsjson11_deserializeOpDescribeServiceAction) ID() string {
4427	return "OperationDeserializer"
4428}
4429
4430func (m *awsAwsjson11_deserializeOpDescribeServiceAction) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4431	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4432) {
4433	out, metadata, err = next.HandleDeserialize(ctx, in)
4434	if err != nil {
4435		return out, metadata, err
4436	}
4437
4438	response, ok := out.RawResponse.(*smithyhttp.Response)
4439	if !ok {
4440		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4441	}
4442
4443	if response.StatusCode < 200 || response.StatusCode >= 300 {
4444		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeServiceAction(response, &metadata)
4445	}
4446	output := &DescribeServiceActionOutput{}
4447	out.Result = output
4448
4449	var buff [1024]byte
4450	ringBuffer := smithyio.NewRingBuffer(buff[:])
4451
4452	body := io.TeeReader(response.Body, ringBuffer)
4453	decoder := json.NewDecoder(body)
4454	decoder.UseNumber()
4455	var shape interface{}
4456	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4457		var snapshot bytes.Buffer
4458		io.Copy(&snapshot, ringBuffer)
4459		err = &smithy.DeserializationError{
4460			Err:      fmt.Errorf("failed to decode response body, %w", err),
4461			Snapshot: snapshot.Bytes(),
4462		}
4463		return out, metadata, err
4464	}
4465
4466	err = awsAwsjson11_deserializeOpDocumentDescribeServiceActionOutput(&output, shape)
4467	if err != nil {
4468		var snapshot bytes.Buffer
4469		io.Copy(&snapshot, ringBuffer)
4470		err = &smithy.DeserializationError{
4471			Err:      fmt.Errorf("failed to decode response body, %w", err),
4472			Snapshot: snapshot.Bytes(),
4473		}
4474		return out, metadata, err
4475	}
4476
4477	return out, metadata, err
4478}
4479
4480func awsAwsjson11_deserializeOpErrorDescribeServiceAction(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4481	var errorBuffer bytes.Buffer
4482	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4483		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4484	}
4485	errorBody := bytes.NewReader(errorBuffer.Bytes())
4486
4487	errorCode := "UnknownError"
4488	errorMessage := errorCode
4489
4490	code := response.Header.Get("X-Amzn-ErrorType")
4491	if len(code) != 0 {
4492		errorCode = restjson.SanitizeErrorCode(code)
4493	}
4494
4495	var buff [1024]byte
4496	ringBuffer := smithyio.NewRingBuffer(buff[:])
4497
4498	body := io.TeeReader(errorBody, ringBuffer)
4499	decoder := json.NewDecoder(body)
4500	decoder.UseNumber()
4501	code, message, err := restjson.GetErrorInfo(decoder)
4502	if err != nil {
4503		var snapshot bytes.Buffer
4504		io.Copy(&snapshot, ringBuffer)
4505		err = &smithy.DeserializationError{
4506			Err:      fmt.Errorf("failed to decode response body, %w", err),
4507			Snapshot: snapshot.Bytes(),
4508		}
4509		return err
4510	}
4511
4512	errorBody.Seek(0, io.SeekStart)
4513	if len(code) != 0 {
4514		errorCode = restjson.SanitizeErrorCode(code)
4515	}
4516	if len(message) != 0 {
4517		errorMessage = message
4518	}
4519
4520	switch {
4521	case strings.EqualFold("ResourceNotFoundException", errorCode):
4522		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
4523
4524	default:
4525		genericError := &smithy.GenericAPIError{
4526			Code:    errorCode,
4527			Message: errorMessage,
4528		}
4529		return genericError
4530
4531	}
4532}
4533
4534type awsAwsjson11_deserializeOpDescribeServiceActionExecutionParameters struct {
4535}
4536
4537func (*awsAwsjson11_deserializeOpDescribeServiceActionExecutionParameters) ID() string {
4538	return "OperationDeserializer"
4539}
4540
4541func (m *awsAwsjson11_deserializeOpDescribeServiceActionExecutionParameters) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4542	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4543) {
4544	out, metadata, err = next.HandleDeserialize(ctx, in)
4545	if err != nil {
4546		return out, metadata, err
4547	}
4548
4549	response, ok := out.RawResponse.(*smithyhttp.Response)
4550	if !ok {
4551		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4552	}
4553
4554	if response.StatusCode < 200 || response.StatusCode >= 300 {
4555		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeServiceActionExecutionParameters(response, &metadata)
4556	}
4557	output := &DescribeServiceActionExecutionParametersOutput{}
4558	out.Result = output
4559
4560	var buff [1024]byte
4561	ringBuffer := smithyio.NewRingBuffer(buff[:])
4562
4563	body := io.TeeReader(response.Body, ringBuffer)
4564	decoder := json.NewDecoder(body)
4565	decoder.UseNumber()
4566	var shape interface{}
4567	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4568		var snapshot bytes.Buffer
4569		io.Copy(&snapshot, ringBuffer)
4570		err = &smithy.DeserializationError{
4571			Err:      fmt.Errorf("failed to decode response body, %w", err),
4572			Snapshot: snapshot.Bytes(),
4573		}
4574		return out, metadata, err
4575	}
4576
4577	err = awsAwsjson11_deserializeOpDocumentDescribeServiceActionExecutionParametersOutput(&output, shape)
4578	if err != nil {
4579		var snapshot bytes.Buffer
4580		io.Copy(&snapshot, ringBuffer)
4581		err = &smithy.DeserializationError{
4582			Err:      fmt.Errorf("failed to decode response body, %w", err),
4583			Snapshot: snapshot.Bytes(),
4584		}
4585		return out, metadata, err
4586	}
4587
4588	return out, metadata, err
4589}
4590
4591func awsAwsjson11_deserializeOpErrorDescribeServiceActionExecutionParameters(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4592	var errorBuffer bytes.Buffer
4593	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4594		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4595	}
4596	errorBody := bytes.NewReader(errorBuffer.Bytes())
4597
4598	errorCode := "UnknownError"
4599	errorMessage := errorCode
4600
4601	code := response.Header.Get("X-Amzn-ErrorType")
4602	if len(code) != 0 {
4603		errorCode = restjson.SanitizeErrorCode(code)
4604	}
4605
4606	var buff [1024]byte
4607	ringBuffer := smithyio.NewRingBuffer(buff[:])
4608
4609	body := io.TeeReader(errorBody, ringBuffer)
4610	decoder := json.NewDecoder(body)
4611	decoder.UseNumber()
4612	code, message, err := restjson.GetErrorInfo(decoder)
4613	if err != nil {
4614		var snapshot bytes.Buffer
4615		io.Copy(&snapshot, ringBuffer)
4616		err = &smithy.DeserializationError{
4617			Err:      fmt.Errorf("failed to decode response body, %w", err),
4618			Snapshot: snapshot.Bytes(),
4619		}
4620		return err
4621	}
4622
4623	errorBody.Seek(0, io.SeekStart)
4624	if len(code) != 0 {
4625		errorCode = restjson.SanitizeErrorCode(code)
4626	}
4627	if len(message) != 0 {
4628		errorMessage = message
4629	}
4630
4631	switch {
4632	case strings.EqualFold("InvalidParametersException", errorCode):
4633		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
4634
4635	case strings.EqualFold("ResourceNotFoundException", errorCode):
4636		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
4637
4638	default:
4639		genericError := &smithy.GenericAPIError{
4640			Code:    errorCode,
4641			Message: errorMessage,
4642		}
4643		return genericError
4644
4645	}
4646}
4647
4648type awsAwsjson11_deserializeOpDescribeTagOption struct {
4649}
4650
4651func (*awsAwsjson11_deserializeOpDescribeTagOption) ID() string {
4652	return "OperationDeserializer"
4653}
4654
4655func (m *awsAwsjson11_deserializeOpDescribeTagOption) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4656	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4657) {
4658	out, metadata, err = next.HandleDeserialize(ctx, in)
4659	if err != nil {
4660		return out, metadata, err
4661	}
4662
4663	response, ok := out.RawResponse.(*smithyhttp.Response)
4664	if !ok {
4665		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4666	}
4667
4668	if response.StatusCode < 200 || response.StatusCode >= 300 {
4669		return out, metadata, awsAwsjson11_deserializeOpErrorDescribeTagOption(response, &metadata)
4670	}
4671	output := &DescribeTagOptionOutput{}
4672	out.Result = output
4673
4674	var buff [1024]byte
4675	ringBuffer := smithyio.NewRingBuffer(buff[:])
4676
4677	body := io.TeeReader(response.Body, ringBuffer)
4678	decoder := json.NewDecoder(body)
4679	decoder.UseNumber()
4680	var shape interface{}
4681	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4682		var snapshot bytes.Buffer
4683		io.Copy(&snapshot, ringBuffer)
4684		err = &smithy.DeserializationError{
4685			Err:      fmt.Errorf("failed to decode response body, %w", err),
4686			Snapshot: snapshot.Bytes(),
4687		}
4688		return out, metadata, err
4689	}
4690
4691	err = awsAwsjson11_deserializeOpDocumentDescribeTagOptionOutput(&output, shape)
4692	if err != nil {
4693		var snapshot bytes.Buffer
4694		io.Copy(&snapshot, ringBuffer)
4695		err = &smithy.DeserializationError{
4696			Err:      fmt.Errorf("failed to decode response body, %w", err),
4697			Snapshot: snapshot.Bytes(),
4698		}
4699		return out, metadata, err
4700	}
4701
4702	return out, metadata, err
4703}
4704
4705func awsAwsjson11_deserializeOpErrorDescribeTagOption(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4706	var errorBuffer bytes.Buffer
4707	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4708		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4709	}
4710	errorBody := bytes.NewReader(errorBuffer.Bytes())
4711
4712	errorCode := "UnknownError"
4713	errorMessage := errorCode
4714
4715	code := response.Header.Get("X-Amzn-ErrorType")
4716	if len(code) != 0 {
4717		errorCode = restjson.SanitizeErrorCode(code)
4718	}
4719
4720	var buff [1024]byte
4721	ringBuffer := smithyio.NewRingBuffer(buff[:])
4722
4723	body := io.TeeReader(errorBody, ringBuffer)
4724	decoder := json.NewDecoder(body)
4725	decoder.UseNumber()
4726	code, message, err := restjson.GetErrorInfo(decoder)
4727	if err != nil {
4728		var snapshot bytes.Buffer
4729		io.Copy(&snapshot, ringBuffer)
4730		err = &smithy.DeserializationError{
4731			Err:      fmt.Errorf("failed to decode response body, %w", err),
4732			Snapshot: snapshot.Bytes(),
4733		}
4734		return err
4735	}
4736
4737	errorBody.Seek(0, io.SeekStart)
4738	if len(code) != 0 {
4739		errorCode = restjson.SanitizeErrorCode(code)
4740	}
4741	if len(message) != 0 {
4742		errorMessage = message
4743	}
4744
4745	switch {
4746	case strings.EqualFold("ResourceNotFoundException", errorCode):
4747		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
4748
4749	case strings.EqualFold("TagOptionNotMigratedException", errorCode):
4750		return awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response, errorBody)
4751
4752	default:
4753		genericError := &smithy.GenericAPIError{
4754			Code:    errorCode,
4755			Message: errorMessage,
4756		}
4757		return genericError
4758
4759	}
4760}
4761
4762type awsAwsjson11_deserializeOpDisableAWSOrganizationsAccess struct {
4763}
4764
4765func (*awsAwsjson11_deserializeOpDisableAWSOrganizationsAccess) ID() string {
4766	return "OperationDeserializer"
4767}
4768
4769func (m *awsAwsjson11_deserializeOpDisableAWSOrganizationsAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4770	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4771) {
4772	out, metadata, err = next.HandleDeserialize(ctx, in)
4773	if err != nil {
4774		return out, metadata, err
4775	}
4776
4777	response, ok := out.RawResponse.(*smithyhttp.Response)
4778	if !ok {
4779		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4780	}
4781
4782	if response.StatusCode < 200 || response.StatusCode >= 300 {
4783		return out, metadata, awsAwsjson11_deserializeOpErrorDisableAWSOrganizationsAccess(response, &metadata)
4784	}
4785	output := &DisableAWSOrganizationsAccessOutput{}
4786	out.Result = output
4787
4788	var buff [1024]byte
4789	ringBuffer := smithyio.NewRingBuffer(buff[:])
4790
4791	body := io.TeeReader(response.Body, ringBuffer)
4792	decoder := json.NewDecoder(body)
4793	decoder.UseNumber()
4794	var shape interface{}
4795	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4796		var snapshot bytes.Buffer
4797		io.Copy(&snapshot, ringBuffer)
4798		err = &smithy.DeserializationError{
4799			Err:      fmt.Errorf("failed to decode response body, %w", err),
4800			Snapshot: snapshot.Bytes(),
4801		}
4802		return out, metadata, err
4803	}
4804
4805	err = awsAwsjson11_deserializeOpDocumentDisableAWSOrganizationsAccessOutput(&output, shape)
4806	if err != nil {
4807		var snapshot bytes.Buffer
4808		io.Copy(&snapshot, ringBuffer)
4809		err = &smithy.DeserializationError{
4810			Err:      fmt.Errorf("failed to decode response body, %w", err),
4811			Snapshot: snapshot.Bytes(),
4812		}
4813		return out, metadata, err
4814	}
4815
4816	return out, metadata, err
4817}
4818
4819func awsAwsjson11_deserializeOpErrorDisableAWSOrganizationsAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4820	var errorBuffer bytes.Buffer
4821	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4822		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4823	}
4824	errorBody := bytes.NewReader(errorBuffer.Bytes())
4825
4826	errorCode := "UnknownError"
4827	errorMessage := errorCode
4828
4829	code := response.Header.Get("X-Amzn-ErrorType")
4830	if len(code) != 0 {
4831		errorCode = restjson.SanitizeErrorCode(code)
4832	}
4833
4834	var buff [1024]byte
4835	ringBuffer := smithyio.NewRingBuffer(buff[:])
4836
4837	body := io.TeeReader(errorBody, ringBuffer)
4838	decoder := json.NewDecoder(body)
4839	decoder.UseNumber()
4840	code, message, err := restjson.GetErrorInfo(decoder)
4841	if err != nil {
4842		var snapshot bytes.Buffer
4843		io.Copy(&snapshot, ringBuffer)
4844		err = &smithy.DeserializationError{
4845			Err:      fmt.Errorf("failed to decode response body, %w", err),
4846			Snapshot: snapshot.Bytes(),
4847		}
4848		return err
4849	}
4850
4851	errorBody.Seek(0, io.SeekStart)
4852	if len(code) != 0 {
4853		errorCode = restjson.SanitizeErrorCode(code)
4854	}
4855	if len(message) != 0 {
4856		errorMessage = message
4857	}
4858
4859	switch {
4860	case strings.EqualFold("InvalidStateException", errorCode):
4861		return awsAwsjson11_deserializeErrorInvalidStateException(response, errorBody)
4862
4863	case strings.EqualFold("OperationNotSupportedException", errorCode):
4864		return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody)
4865
4866	case strings.EqualFold("ResourceNotFoundException", errorCode):
4867		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
4868
4869	default:
4870		genericError := &smithy.GenericAPIError{
4871			Code:    errorCode,
4872			Message: errorMessage,
4873		}
4874		return genericError
4875
4876	}
4877}
4878
4879type awsAwsjson11_deserializeOpDisassociateBudgetFromResource struct {
4880}
4881
4882func (*awsAwsjson11_deserializeOpDisassociateBudgetFromResource) ID() string {
4883	return "OperationDeserializer"
4884}
4885
4886func (m *awsAwsjson11_deserializeOpDisassociateBudgetFromResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4887	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4888) {
4889	out, metadata, err = next.HandleDeserialize(ctx, in)
4890	if err != nil {
4891		return out, metadata, err
4892	}
4893
4894	response, ok := out.RawResponse.(*smithyhttp.Response)
4895	if !ok {
4896		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
4897	}
4898
4899	if response.StatusCode < 200 || response.StatusCode >= 300 {
4900		return out, metadata, awsAwsjson11_deserializeOpErrorDisassociateBudgetFromResource(response, &metadata)
4901	}
4902	output := &DisassociateBudgetFromResourceOutput{}
4903	out.Result = output
4904
4905	var buff [1024]byte
4906	ringBuffer := smithyio.NewRingBuffer(buff[:])
4907
4908	body := io.TeeReader(response.Body, ringBuffer)
4909	decoder := json.NewDecoder(body)
4910	decoder.UseNumber()
4911	var shape interface{}
4912	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
4913		var snapshot bytes.Buffer
4914		io.Copy(&snapshot, ringBuffer)
4915		err = &smithy.DeserializationError{
4916			Err:      fmt.Errorf("failed to decode response body, %w", err),
4917			Snapshot: snapshot.Bytes(),
4918		}
4919		return out, metadata, err
4920	}
4921
4922	err = awsAwsjson11_deserializeOpDocumentDisassociateBudgetFromResourceOutput(&output, shape)
4923	if err != nil {
4924		var snapshot bytes.Buffer
4925		io.Copy(&snapshot, ringBuffer)
4926		err = &smithy.DeserializationError{
4927			Err:      fmt.Errorf("failed to decode response body, %w", err),
4928			Snapshot: snapshot.Bytes(),
4929		}
4930		return out, metadata, err
4931	}
4932
4933	return out, metadata, err
4934}
4935
4936func awsAwsjson11_deserializeOpErrorDisassociateBudgetFromResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
4937	var errorBuffer bytes.Buffer
4938	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
4939		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
4940	}
4941	errorBody := bytes.NewReader(errorBuffer.Bytes())
4942
4943	errorCode := "UnknownError"
4944	errorMessage := errorCode
4945
4946	code := response.Header.Get("X-Amzn-ErrorType")
4947	if len(code) != 0 {
4948		errorCode = restjson.SanitizeErrorCode(code)
4949	}
4950
4951	var buff [1024]byte
4952	ringBuffer := smithyio.NewRingBuffer(buff[:])
4953
4954	body := io.TeeReader(errorBody, ringBuffer)
4955	decoder := json.NewDecoder(body)
4956	decoder.UseNumber()
4957	code, message, err := restjson.GetErrorInfo(decoder)
4958	if err != nil {
4959		var snapshot bytes.Buffer
4960		io.Copy(&snapshot, ringBuffer)
4961		err = &smithy.DeserializationError{
4962			Err:      fmt.Errorf("failed to decode response body, %w", err),
4963			Snapshot: snapshot.Bytes(),
4964		}
4965		return err
4966	}
4967
4968	errorBody.Seek(0, io.SeekStart)
4969	if len(code) != 0 {
4970		errorCode = restjson.SanitizeErrorCode(code)
4971	}
4972	if len(message) != 0 {
4973		errorMessage = message
4974	}
4975
4976	switch {
4977	case strings.EqualFold("ResourceNotFoundException", errorCode):
4978		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
4979
4980	default:
4981		genericError := &smithy.GenericAPIError{
4982			Code:    errorCode,
4983			Message: errorMessage,
4984		}
4985		return genericError
4986
4987	}
4988}
4989
4990type awsAwsjson11_deserializeOpDisassociatePrincipalFromPortfolio struct {
4991}
4992
4993func (*awsAwsjson11_deserializeOpDisassociatePrincipalFromPortfolio) ID() string {
4994	return "OperationDeserializer"
4995}
4996
4997func (m *awsAwsjson11_deserializeOpDisassociatePrincipalFromPortfolio) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
4998	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
4999) {
5000	out, metadata, err = next.HandleDeserialize(ctx, in)
5001	if err != nil {
5002		return out, metadata, err
5003	}
5004
5005	response, ok := out.RawResponse.(*smithyhttp.Response)
5006	if !ok {
5007		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5008	}
5009
5010	if response.StatusCode < 200 || response.StatusCode >= 300 {
5011		return out, metadata, awsAwsjson11_deserializeOpErrorDisassociatePrincipalFromPortfolio(response, &metadata)
5012	}
5013	output := &DisassociatePrincipalFromPortfolioOutput{}
5014	out.Result = output
5015
5016	var buff [1024]byte
5017	ringBuffer := smithyio.NewRingBuffer(buff[:])
5018
5019	body := io.TeeReader(response.Body, ringBuffer)
5020	decoder := json.NewDecoder(body)
5021	decoder.UseNumber()
5022	var shape interface{}
5023	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5024		var snapshot bytes.Buffer
5025		io.Copy(&snapshot, ringBuffer)
5026		err = &smithy.DeserializationError{
5027			Err:      fmt.Errorf("failed to decode response body, %w", err),
5028			Snapshot: snapshot.Bytes(),
5029		}
5030		return out, metadata, err
5031	}
5032
5033	err = awsAwsjson11_deserializeOpDocumentDisassociatePrincipalFromPortfolioOutput(&output, shape)
5034	if err != nil {
5035		var snapshot bytes.Buffer
5036		io.Copy(&snapshot, ringBuffer)
5037		err = &smithy.DeserializationError{
5038			Err:      fmt.Errorf("failed to decode response body, %w", err),
5039			Snapshot: snapshot.Bytes(),
5040		}
5041		return out, metadata, err
5042	}
5043
5044	return out, metadata, err
5045}
5046
5047func awsAwsjson11_deserializeOpErrorDisassociatePrincipalFromPortfolio(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5048	var errorBuffer bytes.Buffer
5049	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5050		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5051	}
5052	errorBody := bytes.NewReader(errorBuffer.Bytes())
5053
5054	errorCode := "UnknownError"
5055	errorMessage := errorCode
5056
5057	code := response.Header.Get("X-Amzn-ErrorType")
5058	if len(code) != 0 {
5059		errorCode = restjson.SanitizeErrorCode(code)
5060	}
5061
5062	var buff [1024]byte
5063	ringBuffer := smithyio.NewRingBuffer(buff[:])
5064
5065	body := io.TeeReader(errorBody, ringBuffer)
5066	decoder := json.NewDecoder(body)
5067	decoder.UseNumber()
5068	code, message, err := restjson.GetErrorInfo(decoder)
5069	if err != nil {
5070		var snapshot bytes.Buffer
5071		io.Copy(&snapshot, ringBuffer)
5072		err = &smithy.DeserializationError{
5073			Err:      fmt.Errorf("failed to decode response body, %w", err),
5074			Snapshot: snapshot.Bytes(),
5075		}
5076		return err
5077	}
5078
5079	errorBody.Seek(0, io.SeekStart)
5080	if len(code) != 0 {
5081		errorCode = restjson.SanitizeErrorCode(code)
5082	}
5083	if len(message) != 0 {
5084		errorMessage = message
5085	}
5086
5087	switch {
5088	case strings.EqualFold("InvalidParametersException", errorCode):
5089		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
5090
5091	case strings.EqualFold("ResourceNotFoundException", errorCode):
5092		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
5093
5094	default:
5095		genericError := &smithy.GenericAPIError{
5096			Code:    errorCode,
5097			Message: errorMessage,
5098		}
5099		return genericError
5100
5101	}
5102}
5103
5104type awsAwsjson11_deserializeOpDisassociateProductFromPortfolio struct {
5105}
5106
5107func (*awsAwsjson11_deserializeOpDisassociateProductFromPortfolio) ID() string {
5108	return "OperationDeserializer"
5109}
5110
5111func (m *awsAwsjson11_deserializeOpDisassociateProductFromPortfolio) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5112	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5113) {
5114	out, metadata, err = next.HandleDeserialize(ctx, in)
5115	if err != nil {
5116		return out, metadata, err
5117	}
5118
5119	response, ok := out.RawResponse.(*smithyhttp.Response)
5120	if !ok {
5121		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5122	}
5123
5124	if response.StatusCode < 200 || response.StatusCode >= 300 {
5125		return out, metadata, awsAwsjson11_deserializeOpErrorDisassociateProductFromPortfolio(response, &metadata)
5126	}
5127	output := &DisassociateProductFromPortfolioOutput{}
5128	out.Result = output
5129
5130	var buff [1024]byte
5131	ringBuffer := smithyio.NewRingBuffer(buff[:])
5132
5133	body := io.TeeReader(response.Body, ringBuffer)
5134	decoder := json.NewDecoder(body)
5135	decoder.UseNumber()
5136	var shape interface{}
5137	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5138		var snapshot bytes.Buffer
5139		io.Copy(&snapshot, ringBuffer)
5140		err = &smithy.DeserializationError{
5141			Err:      fmt.Errorf("failed to decode response body, %w", err),
5142			Snapshot: snapshot.Bytes(),
5143		}
5144		return out, metadata, err
5145	}
5146
5147	err = awsAwsjson11_deserializeOpDocumentDisassociateProductFromPortfolioOutput(&output, shape)
5148	if err != nil {
5149		var snapshot bytes.Buffer
5150		io.Copy(&snapshot, ringBuffer)
5151		err = &smithy.DeserializationError{
5152			Err:      fmt.Errorf("failed to decode response body, %w", err),
5153			Snapshot: snapshot.Bytes(),
5154		}
5155		return out, metadata, err
5156	}
5157
5158	return out, metadata, err
5159}
5160
5161func awsAwsjson11_deserializeOpErrorDisassociateProductFromPortfolio(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5162	var errorBuffer bytes.Buffer
5163	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5164		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5165	}
5166	errorBody := bytes.NewReader(errorBuffer.Bytes())
5167
5168	errorCode := "UnknownError"
5169	errorMessage := errorCode
5170
5171	code := response.Header.Get("X-Amzn-ErrorType")
5172	if len(code) != 0 {
5173		errorCode = restjson.SanitizeErrorCode(code)
5174	}
5175
5176	var buff [1024]byte
5177	ringBuffer := smithyio.NewRingBuffer(buff[:])
5178
5179	body := io.TeeReader(errorBody, ringBuffer)
5180	decoder := json.NewDecoder(body)
5181	decoder.UseNumber()
5182	code, message, err := restjson.GetErrorInfo(decoder)
5183	if err != nil {
5184		var snapshot bytes.Buffer
5185		io.Copy(&snapshot, ringBuffer)
5186		err = &smithy.DeserializationError{
5187			Err:      fmt.Errorf("failed to decode response body, %w", err),
5188			Snapshot: snapshot.Bytes(),
5189		}
5190		return err
5191	}
5192
5193	errorBody.Seek(0, io.SeekStart)
5194	if len(code) != 0 {
5195		errorCode = restjson.SanitizeErrorCode(code)
5196	}
5197	if len(message) != 0 {
5198		errorMessage = message
5199	}
5200
5201	switch {
5202	case strings.EqualFold("InvalidParametersException", errorCode):
5203		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
5204
5205	case strings.EqualFold("ResourceInUseException", errorCode):
5206		return awsAwsjson11_deserializeErrorResourceInUseException(response, errorBody)
5207
5208	case strings.EqualFold("ResourceNotFoundException", errorCode):
5209		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
5210
5211	default:
5212		genericError := &smithy.GenericAPIError{
5213			Code:    errorCode,
5214			Message: errorMessage,
5215		}
5216		return genericError
5217
5218	}
5219}
5220
5221type awsAwsjson11_deserializeOpDisassociateServiceActionFromProvisioningArtifact struct {
5222}
5223
5224func (*awsAwsjson11_deserializeOpDisassociateServiceActionFromProvisioningArtifact) ID() string {
5225	return "OperationDeserializer"
5226}
5227
5228func (m *awsAwsjson11_deserializeOpDisassociateServiceActionFromProvisioningArtifact) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5229	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5230) {
5231	out, metadata, err = next.HandleDeserialize(ctx, in)
5232	if err != nil {
5233		return out, metadata, err
5234	}
5235
5236	response, ok := out.RawResponse.(*smithyhttp.Response)
5237	if !ok {
5238		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5239	}
5240
5241	if response.StatusCode < 200 || response.StatusCode >= 300 {
5242		return out, metadata, awsAwsjson11_deserializeOpErrorDisassociateServiceActionFromProvisioningArtifact(response, &metadata)
5243	}
5244	output := &DisassociateServiceActionFromProvisioningArtifactOutput{}
5245	out.Result = output
5246
5247	var buff [1024]byte
5248	ringBuffer := smithyio.NewRingBuffer(buff[:])
5249
5250	body := io.TeeReader(response.Body, ringBuffer)
5251	decoder := json.NewDecoder(body)
5252	decoder.UseNumber()
5253	var shape interface{}
5254	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5255		var snapshot bytes.Buffer
5256		io.Copy(&snapshot, ringBuffer)
5257		err = &smithy.DeserializationError{
5258			Err:      fmt.Errorf("failed to decode response body, %w", err),
5259			Snapshot: snapshot.Bytes(),
5260		}
5261		return out, metadata, err
5262	}
5263
5264	err = awsAwsjson11_deserializeOpDocumentDisassociateServiceActionFromProvisioningArtifactOutput(&output, shape)
5265	if err != nil {
5266		var snapshot bytes.Buffer
5267		io.Copy(&snapshot, ringBuffer)
5268		err = &smithy.DeserializationError{
5269			Err:      fmt.Errorf("failed to decode response body, %w", err),
5270			Snapshot: snapshot.Bytes(),
5271		}
5272		return out, metadata, err
5273	}
5274
5275	return out, metadata, err
5276}
5277
5278func awsAwsjson11_deserializeOpErrorDisassociateServiceActionFromProvisioningArtifact(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5279	var errorBuffer bytes.Buffer
5280	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5281		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5282	}
5283	errorBody := bytes.NewReader(errorBuffer.Bytes())
5284
5285	errorCode := "UnknownError"
5286	errorMessage := errorCode
5287
5288	code := response.Header.Get("X-Amzn-ErrorType")
5289	if len(code) != 0 {
5290		errorCode = restjson.SanitizeErrorCode(code)
5291	}
5292
5293	var buff [1024]byte
5294	ringBuffer := smithyio.NewRingBuffer(buff[:])
5295
5296	body := io.TeeReader(errorBody, ringBuffer)
5297	decoder := json.NewDecoder(body)
5298	decoder.UseNumber()
5299	code, message, err := restjson.GetErrorInfo(decoder)
5300	if err != nil {
5301		var snapshot bytes.Buffer
5302		io.Copy(&snapshot, ringBuffer)
5303		err = &smithy.DeserializationError{
5304			Err:      fmt.Errorf("failed to decode response body, %w", err),
5305			Snapshot: snapshot.Bytes(),
5306		}
5307		return err
5308	}
5309
5310	errorBody.Seek(0, io.SeekStart)
5311	if len(code) != 0 {
5312		errorCode = restjson.SanitizeErrorCode(code)
5313	}
5314	if len(message) != 0 {
5315		errorMessage = message
5316	}
5317
5318	switch {
5319	case strings.EqualFold("ResourceNotFoundException", errorCode):
5320		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
5321
5322	default:
5323		genericError := &smithy.GenericAPIError{
5324			Code:    errorCode,
5325			Message: errorMessage,
5326		}
5327		return genericError
5328
5329	}
5330}
5331
5332type awsAwsjson11_deserializeOpDisassociateTagOptionFromResource struct {
5333}
5334
5335func (*awsAwsjson11_deserializeOpDisassociateTagOptionFromResource) ID() string {
5336	return "OperationDeserializer"
5337}
5338
5339func (m *awsAwsjson11_deserializeOpDisassociateTagOptionFromResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5340	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5341) {
5342	out, metadata, err = next.HandleDeserialize(ctx, in)
5343	if err != nil {
5344		return out, metadata, err
5345	}
5346
5347	response, ok := out.RawResponse.(*smithyhttp.Response)
5348	if !ok {
5349		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5350	}
5351
5352	if response.StatusCode < 200 || response.StatusCode >= 300 {
5353		return out, metadata, awsAwsjson11_deserializeOpErrorDisassociateTagOptionFromResource(response, &metadata)
5354	}
5355	output := &DisassociateTagOptionFromResourceOutput{}
5356	out.Result = output
5357
5358	var buff [1024]byte
5359	ringBuffer := smithyio.NewRingBuffer(buff[:])
5360
5361	body := io.TeeReader(response.Body, ringBuffer)
5362	decoder := json.NewDecoder(body)
5363	decoder.UseNumber()
5364	var shape interface{}
5365	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5366		var snapshot bytes.Buffer
5367		io.Copy(&snapshot, ringBuffer)
5368		err = &smithy.DeserializationError{
5369			Err:      fmt.Errorf("failed to decode response body, %w", err),
5370			Snapshot: snapshot.Bytes(),
5371		}
5372		return out, metadata, err
5373	}
5374
5375	err = awsAwsjson11_deserializeOpDocumentDisassociateTagOptionFromResourceOutput(&output, shape)
5376	if err != nil {
5377		var snapshot bytes.Buffer
5378		io.Copy(&snapshot, ringBuffer)
5379		err = &smithy.DeserializationError{
5380			Err:      fmt.Errorf("failed to decode response body, %w", err),
5381			Snapshot: snapshot.Bytes(),
5382		}
5383		return out, metadata, err
5384	}
5385
5386	return out, metadata, err
5387}
5388
5389func awsAwsjson11_deserializeOpErrorDisassociateTagOptionFromResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5390	var errorBuffer bytes.Buffer
5391	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5392		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5393	}
5394	errorBody := bytes.NewReader(errorBuffer.Bytes())
5395
5396	errorCode := "UnknownError"
5397	errorMessage := errorCode
5398
5399	code := response.Header.Get("X-Amzn-ErrorType")
5400	if len(code) != 0 {
5401		errorCode = restjson.SanitizeErrorCode(code)
5402	}
5403
5404	var buff [1024]byte
5405	ringBuffer := smithyio.NewRingBuffer(buff[:])
5406
5407	body := io.TeeReader(errorBody, ringBuffer)
5408	decoder := json.NewDecoder(body)
5409	decoder.UseNumber()
5410	code, message, err := restjson.GetErrorInfo(decoder)
5411	if err != nil {
5412		var snapshot bytes.Buffer
5413		io.Copy(&snapshot, ringBuffer)
5414		err = &smithy.DeserializationError{
5415			Err:      fmt.Errorf("failed to decode response body, %w", err),
5416			Snapshot: snapshot.Bytes(),
5417		}
5418		return err
5419	}
5420
5421	errorBody.Seek(0, io.SeekStart)
5422	if len(code) != 0 {
5423		errorCode = restjson.SanitizeErrorCode(code)
5424	}
5425	if len(message) != 0 {
5426		errorMessage = message
5427	}
5428
5429	switch {
5430	case strings.EqualFold("ResourceNotFoundException", errorCode):
5431		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
5432
5433	case strings.EqualFold("TagOptionNotMigratedException", errorCode):
5434		return awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response, errorBody)
5435
5436	default:
5437		genericError := &smithy.GenericAPIError{
5438			Code:    errorCode,
5439			Message: errorMessage,
5440		}
5441		return genericError
5442
5443	}
5444}
5445
5446type awsAwsjson11_deserializeOpEnableAWSOrganizationsAccess struct {
5447}
5448
5449func (*awsAwsjson11_deserializeOpEnableAWSOrganizationsAccess) ID() string {
5450	return "OperationDeserializer"
5451}
5452
5453func (m *awsAwsjson11_deserializeOpEnableAWSOrganizationsAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5454	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5455) {
5456	out, metadata, err = next.HandleDeserialize(ctx, in)
5457	if err != nil {
5458		return out, metadata, err
5459	}
5460
5461	response, ok := out.RawResponse.(*smithyhttp.Response)
5462	if !ok {
5463		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5464	}
5465
5466	if response.StatusCode < 200 || response.StatusCode >= 300 {
5467		return out, metadata, awsAwsjson11_deserializeOpErrorEnableAWSOrganizationsAccess(response, &metadata)
5468	}
5469	output := &EnableAWSOrganizationsAccessOutput{}
5470	out.Result = output
5471
5472	var buff [1024]byte
5473	ringBuffer := smithyio.NewRingBuffer(buff[:])
5474
5475	body := io.TeeReader(response.Body, ringBuffer)
5476	decoder := json.NewDecoder(body)
5477	decoder.UseNumber()
5478	var shape interface{}
5479	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5480		var snapshot bytes.Buffer
5481		io.Copy(&snapshot, ringBuffer)
5482		err = &smithy.DeserializationError{
5483			Err:      fmt.Errorf("failed to decode response body, %w", err),
5484			Snapshot: snapshot.Bytes(),
5485		}
5486		return out, metadata, err
5487	}
5488
5489	err = awsAwsjson11_deserializeOpDocumentEnableAWSOrganizationsAccessOutput(&output, shape)
5490	if err != nil {
5491		var snapshot bytes.Buffer
5492		io.Copy(&snapshot, ringBuffer)
5493		err = &smithy.DeserializationError{
5494			Err:      fmt.Errorf("failed to decode response body, %w", err),
5495			Snapshot: snapshot.Bytes(),
5496		}
5497		return out, metadata, err
5498	}
5499
5500	return out, metadata, err
5501}
5502
5503func awsAwsjson11_deserializeOpErrorEnableAWSOrganizationsAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5504	var errorBuffer bytes.Buffer
5505	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5506		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5507	}
5508	errorBody := bytes.NewReader(errorBuffer.Bytes())
5509
5510	errorCode := "UnknownError"
5511	errorMessage := errorCode
5512
5513	code := response.Header.Get("X-Amzn-ErrorType")
5514	if len(code) != 0 {
5515		errorCode = restjson.SanitizeErrorCode(code)
5516	}
5517
5518	var buff [1024]byte
5519	ringBuffer := smithyio.NewRingBuffer(buff[:])
5520
5521	body := io.TeeReader(errorBody, ringBuffer)
5522	decoder := json.NewDecoder(body)
5523	decoder.UseNumber()
5524	code, message, err := restjson.GetErrorInfo(decoder)
5525	if err != nil {
5526		var snapshot bytes.Buffer
5527		io.Copy(&snapshot, ringBuffer)
5528		err = &smithy.DeserializationError{
5529			Err:      fmt.Errorf("failed to decode response body, %w", err),
5530			Snapshot: snapshot.Bytes(),
5531		}
5532		return err
5533	}
5534
5535	errorBody.Seek(0, io.SeekStart)
5536	if len(code) != 0 {
5537		errorCode = restjson.SanitizeErrorCode(code)
5538	}
5539	if len(message) != 0 {
5540		errorMessage = message
5541	}
5542
5543	switch {
5544	case strings.EqualFold("InvalidStateException", errorCode):
5545		return awsAwsjson11_deserializeErrorInvalidStateException(response, errorBody)
5546
5547	case strings.EqualFold("OperationNotSupportedException", errorCode):
5548		return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody)
5549
5550	case strings.EqualFold("ResourceNotFoundException", errorCode):
5551		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
5552
5553	default:
5554		genericError := &smithy.GenericAPIError{
5555			Code:    errorCode,
5556			Message: errorMessage,
5557		}
5558		return genericError
5559
5560	}
5561}
5562
5563type awsAwsjson11_deserializeOpExecuteProvisionedProductPlan struct {
5564}
5565
5566func (*awsAwsjson11_deserializeOpExecuteProvisionedProductPlan) ID() string {
5567	return "OperationDeserializer"
5568}
5569
5570func (m *awsAwsjson11_deserializeOpExecuteProvisionedProductPlan) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5571	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5572) {
5573	out, metadata, err = next.HandleDeserialize(ctx, in)
5574	if err != nil {
5575		return out, metadata, err
5576	}
5577
5578	response, ok := out.RawResponse.(*smithyhttp.Response)
5579	if !ok {
5580		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5581	}
5582
5583	if response.StatusCode < 200 || response.StatusCode >= 300 {
5584		return out, metadata, awsAwsjson11_deserializeOpErrorExecuteProvisionedProductPlan(response, &metadata)
5585	}
5586	output := &ExecuteProvisionedProductPlanOutput{}
5587	out.Result = output
5588
5589	var buff [1024]byte
5590	ringBuffer := smithyio.NewRingBuffer(buff[:])
5591
5592	body := io.TeeReader(response.Body, ringBuffer)
5593	decoder := json.NewDecoder(body)
5594	decoder.UseNumber()
5595	var shape interface{}
5596	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5597		var snapshot bytes.Buffer
5598		io.Copy(&snapshot, ringBuffer)
5599		err = &smithy.DeserializationError{
5600			Err:      fmt.Errorf("failed to decode response body, %w", err),
5601			Snapshot: snapshot.Bytes(),
5602		}
5603		return out, metadata, err
5604	}
5605
5606	err = awsAwsjson11_deserializeOpDocumentExecuteProvisionedProductPlanOutput(&output, shape)
5607	if err != nil {
5608		var snapshot bytes.Buffer
5609		io.Copy(&snapshot, ringBuffer)
5610		err = &smithy.DeserializationError{
5611			Err:      fmt.Errorf("failed to decode response body, %w", err),
5612			Snapshot: snapshot.Bytes(),
5613		}
5614		return out, metadata, err
5615	}
5616
5617	return out, metadata, err
5618}
5619
5620func awsAwsjson11_deserializeOpErrorExecuteProvisionedProductPlan(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5621	var errorBuffer bytes.Buffer
5622	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5623		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5624	}
5625	errorBody := bytes.NewReader(errorBuffer.Bytes())
5626
5627	errorCode := "UnknownError"
5628	errorMessage := errorCode
5629
5630	code := response.Header.Get("X-Amzn-ErrorType")
5631	if len(code) != 0 {
5632		errorCode = restjson.SanitizeErrorCode(code)
5633	}
5634
5635	var buff [1024]byte
5636	ringBuffer := smithyio.NewRingBuffer(buff[:])
5637
5638	body := io.TeeReader(errorBody, ringBuffer)
5639	decoder := json.NewDecoder(body)
5640	decoder.UseNumber()
5641	code, message, err := restjson.GetErrorInfo(decoder)
5642	if err != nil {
5643		var snapshot bytes.Buffer
5644		io.Copy(&snapshot, ringBuffer)
5645		err = &smithy.DeserializationError{
5646			Err:      fmt.Errorf("failed to decode response body, %w", err),
5647			Snapshot: snapshot.Bytes(),
5648		}
5649		return err
5650	}
5651
5652	errorBody.Seek(0, io.SeekStart)
5653	if len(code) != 0 {
5654		errorCode = restjson.SanitizeErrorCode(code)
5655	}
5656	if len(message) != 0 {
5657		errorMessage = message
5658	}
5659
5660	switch {
5661	case strings.EqualFold("InvalidParametersException", errorCode):
5662		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
5663
5664	case strings.EqualFold("InvalidStateException", errorCode):
5665		return awsAwsjson11_deserializeErrorInvalidStateException(response, errorBody)
5666
5667	case strings.EqualFold("ResourceNotFoundException", errorCode):
5668		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
5669
5670	default:
5671		genericError := &smithy.GenericAPIError{
5672			Code:    errorCode,
5673			Message: errorMessage,
5674		}
5675		return genericError
5676
5677	}
5678}
5679
5680type awsAwsjson11_deserializeOpExecuteProvisionedProductServiceAction struct {
5681}
5682
5683func (*awsAwsjson11_deserializeOpExecuteProvisionedProductServiceAction) ID() string {
5684	return "OperationDeserializer"
5685}
5686
5687func (m *awsAwsjson11_deserializeOpExecuteProvisionedProductServiceAction) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5688	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5689) {
5690	out, metadata, err = next.HandleDeserialize(ctx, in)
5691	if err != nil {
5692		return out, metadata, err
5693	}
5694
5695	response, ok := out.RawResponse.(*smithyhttp.Response)
5696	if !ok {
5697		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5698	}
5699
5700	if response.StatusCode < 200 || response.StatusCode >= 300 {
5701		return out, metadata, awsAwsjson11_deserializeOpErrorExecuteProvisionedProductServiceAction(response, &metadata)
5702	}
5703	output := &ExecuteProvisionedProductServiceActionOutput{}
5704	out.Result = output
5705
5706	var buff [1024]byte
5707	ringBuffer := smithyio.NewRingBuffer(buff[:])
5708
5709	body := io.TeeReader(response.Body, ringBuffer)
5710	decoder := json.NewDecoder(body)
5711	decoder.UseNumber()
5712	var shape interface{}
5713	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5714		var snapshot bytes.Buffer
5715		io.Copy(&snapshot, ringBuffer)
5716		err = &smithy.DeserializationError{
5717			Err:      fmt.Errorf("failed to decode response body, %w", err),
5718			Snapshot: snapshot.Bytes(),
5719		}
5720		return out, metadata, err
5721	}
5722
5723	err = awsAwsjson11_deserializeOpDocumentExecuteProvisionedProductServiceActionOutput(&output, shape)
5724	if err != nil {
5725		var snapshot bytes.Buffer
5726		io.Copy(&snapshot, ringBuffer)
5727		err = &smithy.DeserializationError{
5728			Err:      fmt.Errorf("failed to decode response body, %w", err),
5729			Snapshot: snapshot.Bytes(),
5730		}
5731		return out, metadata, err
5732	}
5733
5734	return out, metadata, err
5735}
5736
5737func awsAwsjson11_deserializeOpErrorExecuteProvisionedProductServiceAction(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5738	var errorBuffer bytes.Buffer
5739	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5740		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5741	}
5742	errorBody := bytes.NewReader(errorBuffer.Bytes())
5743
5744	errorCode := "UnknownError"
5745	errorMessage := errorCode
5746
5747	code := response.Header.Get("X-Amzn-ErrorType")
5748	if len(code) != 0 {
5749		errorCode = restjson.SanitizeErrorCode(code)
5750	}
5751
5752	var buff [1024]byte
5753	ringBuffer := smithyio.NewRingBuffer(buff[:])
5754
5755	body := io.TeeReader(errorBody, ringBuffer)
5756	decoder := json.NewDecoder(body)
5757	decoder.UseNumber()
5758	code, message, err := restjson.GetErrorInfo(decoder)
5759	if err != nil {
5760		var snapshot bytes.Buffer
5761		io.Copy(&snapshot, ringBuffer)
5762		err = &smithy.DeserializationError{
5763			Err:      fmt.Errorf("failed to decode response body, %w", err),
5764			Snapshot: snapshot.Bytes(),
5765		}
5766		return err
5767	}
5768
5769	errorBody.Seek(0, io.SeekStart)
5770	if len(code) != 0 {
5771		errorCode = restjson.SanitizeErrorCode(code)
5772	}
5773	if len(message) != 0 {
5774		errorMessage = message
5775	}
5776
5777	switch {
5778	case strings.EqualFold("InvalidParametersException", errorCode):
5779		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
5780
5781	case strings.EqualFold("InvalidStateException", errorCode):
5782		return awsAwsjson11_deserializeErrorInvalidStateException(response, errorBody)
5783
5784	case strings.EqualFold("ResourceNotFoundException", errorCode):
5785		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
5786
5787	default:
5788		genericError := &smithy.GenericAPIError{
5789			Code:    errorCode,
5790			Message: errorMessage,
5791		}
5792		return genericError
5793
5794	}
5795}
5796
5797type awsAwsjson11_deserializeOpGetAWSOrganizationsAccessStatus struct {
5798}
5799
5800func (*awsAwsjson11_deserializeOpGetAWSOrganizationsAccessStatus) ID() string {
5801	return "OperationDeserializer"
5802}
5803
5804func (m *awsAwsjson11_deserializeOpGetAWSOrganizationsAccessStatus) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5805	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5806) {
5807	out, metadata, err = next.HandleDeserialize(ctx, in)
5808	if err != nil {
5809		return out, metadata, err
5810	}
5811
5812	response, ok := out.RawResponse.(*smithyhttp.Response)
5813	if !ok {
5814		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5815	}
5816
5817	if response.StatusCode < 200 || response.StatusCode >= 300 {
5818		return out, metadata, awsAwsjson11_deserializeOpErrorGetAWSOrganizationsAccessStatus(response, &metadata)
5819	}
5820	output := &GetAWSOrganizationsAccessStatusOutput{}
5821	out.Result = output
5822
5823	var buff [1024]byte
5824	ringBuffer := smithyio.NewRingBuffer(buff[:])
5825
5826	body := io.TeeReader(response.Body, ringBuffer)
5827	decoder := json.NewDecoder(body)
5828	decoder.UseNumber()
5829	var shape interface{}
5830	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5831		var snapshot bytes.Buffer
5832		io.Copy(&snapshot, ringBuffer)
5833		err = &smithy.DeserializationError{
5834			Err:      fmt.Errorf("failed to decode response body, %w", err),
5835			Snapshot: snapshot.Bytes(),
5836		}
5837		return out, metadata, err
5838	}
5839
5840	err = awsAwsjson11_deserializeOpDocumentGetAWSOrganizationsAccessStatusOutput(&output, shape)
5841	if err != nil {
5842		var snapshot bytes.Buffer
5843		io.Copy(&snapshot, ringBuffer)
5844		err = &smithy.DeserializationError{
5845			Err:      fmt.Errorf("failed to decode response body, %w", err),
5846			Snapshot: snapshot.Bytes(),
5847		}
5848		return out, metadata, err
5849	}
5850
5851	return out, metadata, err
5852}
5853
5854func awsAwsjson11_deserializeOpErrorGetAWSOrganizationsAccessStatus(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5855	var errorBuffer bytes.Buffer
5856	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5857		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5858	}
5859	errorBody := bytes.NewReader(errorBuffer.Bytes())
5860
5861	errorCode := "UnknownError"
5862	errorMessage := errorCode
5863
5864	code := response.Header.Get("X-Amzn-ErrorType")
5865	if len(code) != 0 {
5866		errorCode = restjson.SanitizeErrorCode(code)
5867	}
5868
5869	var buff [1024]byte
5870	ringBuffer := smithyio.NewRingBuffer(buff[:])
5871
5872	body := io.TeeReader(errorBody, ringBuffer)
5873	decoder := json.NewDecoder(body)
5874	decoder.UseNumber()
5875	code, message, err := restjson.GetErrorInfo(decoder)
5876	if err != nil {
5877		var snapshot bytes.Buffer
5878		io.Copy(&snapshot, ringBuffer)
5879		err = &smithy.DeserializationError{
5880			Err:      fmt.Errorf("failed to decode response body, %w", err),
5881			Snapshot: snapshot.Bytes(),
5882		}
5883		return err
5884	}
5885
5886	errorBody.Seek(0, io.SeekStart)
5887	if len(code) != 0 {
5888		errorCode = restjson.SanitizeErrorCode(code)
5889	}
5890	if len(message) != 0 {
5891		errorMessage = message
5892	}
5893
5894	switch {
5895	case strings.EqualFold("OperationNotSupportedException", errorCode):
5896		return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody)
5897
5898	case strings.EqualFold("ResourceNotFoundException", errorCode):
5899		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
5900
5901	default:
5902		genericError := &smithy.GenericAPIError{
5903			Code:    errorCode,
5904			Message: errorMessage,
5905		}
5906		return genericError
5907
5908	}
5909}
5910
5911type awsAwsjson11_deserializeOpGetProvisionedProductOutputs struct {
5912}
5913
5914func (*awsAwsjson11_deserializeOpGetProvisionedProductOutputs) ID() string {
5915	return "OperationDeserializer"
5916}
5917
5918func (m *awsAwsjson11_deserializeOpGetProvisionedProductOutputs) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
5919	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
5920) {
5921	out, metadata, err = next.HandleDeserialize(ctx, in)
5922	if err != nil {
5923		return out, metadata, err
5924	}
5925
5926	response, ok := out.RawResponse.(*smithyhttp.Response)
5927	if !ok {
5928		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
5929	}
5930
5931	if response.StatusCode < 200 || response.StatusCode >= 300 {
5932		return out, metadata, awsAwsjson11_deserializeOpErrorGetProvisionedProductOutputs(response, &metadata)
5933	}
5934	output := &GetProvisionedProductOutputsOutput{}
5935	out.Result = output
5936
5937	var buff [1024]byte
5938	ringBuffer := smithyio.NewRingBuffer(buff[:])
5939
5940	body := io.TeeReader(response.Body, ringBuffer)
5941	decoder := json.NewDecoder(body)
5942	decoder.UseNumber()
5943	var shape interface{}
5944	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
5945		var snapshot bytes.Buffer
5946		io.Copy(&snapshot, ringBuffer)
5947		err = &smithy.DeserializationError{
5948			Err:      fmt.Errorf("failed to decode response body, %w", err),
5949			Snapshot: snapshot.Bytes(),
5950		}
5951		return out, metadata, err
5952	}
5953
5954	err = awsAwsjson11_deserializeOpDocumentGetProvisionedProductOutputsOutput(&output, shape)
5955	if err != nil {
5956		var snapshot bytes.Buffer
5957		io.Copy(&snapshot, ringBuffer)
5958		err = &smithy.DeserializationError{
5959			Err:      fmt.Errorf("failed to decode response body, %w", err),
5960			Snapshot: snapshot.Bytes(),
5961		}
5962		return out, metadata, err
5963	}
5964
5965	return out, metadata, err
5966}
5967
5968func awsAwsjson11_deserializeOpErrorGetProvisionedProductOutputs(response *smithyhttp.Response, metadata *middleware.Metadata) error {
5969	var errorBuffer bytes.Buffer
5970	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
5971		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
5972	}
5973	errorBody := bytes.NewReader(errorBuffer.Bytes())
5974
5975	errorCode := "UnknownError"
5976	errorMessage := errorCode
5977
5978	code := response.Header.Get("X-Amzn-ErrorType")
5979	if len(code) != 0 {
5980		errorCode = restjson.SanitizeErrorCode(code)
5981	}
5982
5983	var buff [1024]byte
5984	ringBuffer := smithyio.NewRingBuffer(buff[:])
5985
5986	body := io.TeeReader(errorBody, ringBuffer)
5987	decoder := json.NewDecoder(body)
5988	decoder.UseNumber()
5989	code, message, err := restjson.GetErrorInfo(decoder)
5990	if err != nil {
5991		var snapshot bytes.Buffer
5992		io.Copy(&snapshot, ringBuffer)
5993		err = &smithy.DeserializationError{
5994			Err:      fmt.Errorf("failed to decode response body, %w", err),
5995			Snapshot: snapshot.Bytes(),
5996		}
5997		return err
5998	}
5999
6000	errorBody.Seek(0, io.SeekStart)
6001	if len(code) != 0 {
6002		errorCode = restjson.SanitizeErrorCode(code)
6003	}
6004	if len(message) != 0 {
6005		errorMessage = message
6006	}
6007
6008	switch {
6009	case strings.EqualFold("InvalidParametersException", errorCode):
6010		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
6011
6012	case strings.EqualFold("ResourceNotFoundException", errorCode):
6013		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
6014
6015	default:
6016		genericError := &smithy.GenericAPIError{
6017			Code:    errorCode,
6018			Message: errorMessage,
6019		}
6020		return genericError
6021
6022	}
6023}
6024
6025type awsAwsjson11_deserializeOpImportAsProvisionedProduct struct {
6026}
6027
6028func (*awsAwsjson11_deserializeOpImportAsProvisionedProduct) ID() string {
6029	return "OperationDeserializer"
6030}
6031
6032func (m *awsAwsjson11_deserializeOpImportAsProvisionedProduct) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6033	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6034) {
6035	out, metadata, err = next.HandleDeserialize(ctx, in)
6036	if err != nil {
6037		return out, metadata, err
6038	}
6039
6040	response, ok := out.RawResponse.(*smithyhttp.Response)
6041	if !ok {
6042		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6043	}
6044
6045	if response.StatusCode < 200 || response.StatusCode >= 300 {
6046		return out, metadata, awsAwsjson11_deserializeOpErrorImportAsProvisionedProduct(response, &metadata)
6047	}
6048	output := &ImportAsProvisionedProductOutput{}
6049	out.Result = output
6050
6051	var buff [1024]byte
6052	ringBuffer := smithyio.NewRingBuffer(buff[:])
6053
6054	body := io.TeeReader(response.Body, ringBuffer)
6055	decoder := json.NewDecoder(body)
6056	decoder.UseNumber()
6057	var shape interface{}
6058	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6059		var snapshot bytes.Buffer
6060		io.Copy(&snapshot, ringBuffer)
6061		err = &smithy.DeserializationError{
6062			Err:      fmt.Errorf("failed to decode response body, %w", err),
6063			Snapshot: snapshot.Bytes(),
6064		}
6065		return out, metadata, err
6066	}
6067
6068	err = awsAwsjson11_deserializeOpDocumentImportAsProvisionedProductOutput(&output, shape)
6069	if err != nil {
6070		var snapshot bytes.Buffer
6071		io.Copy(&snapshot, ringBuffer)
6072		err = &smithy.DeserializationError{
6073			Err:      fmt.Errorf("failed to decode response body, %w", err),
6074			Snapshot: snapshot.Bytes(),
6075		}
6076		return out, metadata, err
6077	}
6078
6079	return out, metadata, err
6080}
6081
6082func awsAwsjson11_deserializeOpErrorImportAsProvisionedProduct(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6083	var errorBuffer bytes.Buffer
6084	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6085		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6086	}
6087	errorBody := bytes.NewReader(errorBuffer.Bytes())
6088
6089	errorCode := "UnknownError"
6090	errorMessage := errorCode
6091
6092	code := response.Header.Get("X-Amzn-ErrorType")
6093	if len(code) != 0 {
6094		errorCode = restjson.SanitizeErrorCode(code)
6095	}
6096
6097	var buff [1024]byte
6098	ringBuffer := smithyio.NewRingBuffer(buff[:])
6099
6100	body := io.TeeReader(errorBody, ringBuffer)
6101	decoder := json.NewDecoder(body)
6102	decoder.UseNumber()
6103	code, message, err := restjson.GetErrorInfo(decoder)
6104	if err != nil {
6105		var snapshot bytes.Buffer
6106		io.Copy(&snapshot, ringBuffer)
6107		err = &smithy.DeserializationError{
6108			Err:      fmt.Errorf("failed to decode response body, %w", err),
6109			Snapshot: snapshot.Bytes(),
6110		}
6111		return err
6112	}
6113
6114	errorBody.Seek(0, io.SeekStart)
6115	if len(code) != 0 {
6116		errorCode = restjson.SanitizeErrorCode(code)
6117	}
6118	if len(message) != 0 {
6119		errorMessage = message
6120	}
6121
6122	switch {
6123	case strings.EqualFold("DuplicateResourceException", errorCode):
6124		return awsAwsjson11_deserializeErrorDuplicateResourceException(response, errorBody)
6125
6126	case strings.EqualFold("InvalidParametersException", errorCode):
6127		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
6128
6129	case strings.EqualFold("InvalidStateException", errorCode):
6130		return awsAwsjson11_deserializeErrorInvalidStateException(response, errorBody)
6131
6132	case strings.EqualFold("ResourceNotFoundException", errorCode):
6133		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
6134
6135	default:
6136		genericError := &smithy.GenericAPIError{
6137			Code:    errorCode,
6138			Message: errorMessage,
6139		}
6140		return genericError
6141
6142	}
6143}
6144
6145type awsAwsjson11_deserializeOpListAcceptedPortfolioShares struct {
6146}
6147
6148func (*awsAwsjson11_deserializeOpListAcceptedPortfolioShares) ID() string {
6149	return "OperationDeserializer"
6150}
6151
6152func (m *awsAwsjson11_deserializeOpListAcceptedPortfolioShares) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6153	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6154) {
6155	out, metadata, err = next.HandleDeserialize(ctx, in)
6156	if err != nil {
6157		return out, metadata, err
6158	}
6159
6160	response, ok := out.RawResponse.(*smithyhttp.Response)
6161	if !ok {
6162		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6163	}
6164
6165	if response.StatusCode < 200 || response.StatusCode >= 300 {
6166		return out, metadata, awsAwsjson11_deserializeOpErrorListAcceptedPortfolioShares(response, &metadata)
6167	}
6168	output := &ListAcceptedPortfolioSharesOutput{}
6169	out.Result = output
6170
6171	var buff [1024]byte
6172	ringBuffer := smithyio.NewRingBuffer(buff[:])
6173
6174	body := io.TeeReader(response.Body, ringBuffer)
6175	decoder := json.NewDecoder(body)
6176	decoder.UseNumber()
6177	var shape interface{}
6178	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6179		var snapshot bytes.Buffer
6180		io.Copy(&snapshot, ringBuffer)
6181		err = &smithy.DeserializationError{
6182			Err:      fmt.Errorf("failed to decode response body, %w", err),
6183			Snapshot: snapshot.Bytes(),
6184		}
6185		return out, metadata, err
6186	}
6187
6188	err = awsAwsjson11_deserializeOpDocumentListAcceptedPortfolioSharesOutput(&output, shape)
6189	if err != nil {
6190		var snapshot bytes.Buffer
6191		io.Copy(&snapshot, ringBuffer)
6192		err = &smithy.DeserializationError{
6193			Err:      fmt.Errorf("failed to decode response body, %w", err),
6194			Snapshot: snapshot.Bytes(),
6195		}
6196		return out, metadata, err
6197	}
6198
6199	return out, metadata, err
6200}
6201
6202func awsAwsjson11_deserializeOpErrorListAcceptedPortfolioShares(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6203	var errorBuffer bytes.Buffer
6204	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6205		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6206	}
6207	errorBody := bytes.NewReader(errorBuffer.Bytes())
6208
6209	errorCode := "UnknownError"
6210	errorMessage := errorCode
6211
6212	code := response.Header.Get("X-Amzn-ErrorType")
6213	if len(code) != 0 {
6214		errorCode = restjson.SanitizeErrorCode(code)
6215	}
6216
6217	var buff [1024]byte
6218	ringBuffer := smithyio.NewRingBuffer(buff[:])
6219
6220	body := io.TeeReader(errorBody, ringBuffer)
6221	decoder := json.NewDecoder(body)
6222	decoder.UseNumber()
6223	code, message, err := restjson.GetErrorInfo(decoder)
6224	if err != nil {
6225		var snapshot bytes.Buffer
6226		io.Copy(&snapshot, ringBuffer)
6227		err = &smithy.DeserializationError{
6228			Err:      fmt.Errorf("failed to decode response body, %w", err),
6229			Snapshot: snapshot.Bytes(),
6230		}
6231		return err
6232	}
6233
6234	errorBody.Seek(0, io.SeekStart)
6235	if len(code) != 0 {
6236		errorCode = restjson.SanitizeErrorCode(code)
6237	}
6238	if len(message) != 0 {
6239		errorMessage = message
6240	}
6241
6242	switch {
6243	case strings.EqualFold("InvalidParametersException", errorCode):
6244		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
6245
6246	case strings.EqualFold("OperationNotSupportedException", errorCode):
6247		return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody)
6248
6249	default:
6250		genericError := &smithy.GenericAPIError{
6251			Code:    errorCode,
6252			Message: errorMessage,
6253		}
6254		return genericError
6255
6256	}
6257}
6258
6259type awsAwsjson11_deserializeOpListBudgetsForResource struct {
6260}
6261
6262func (*awsAwsjson11_deserializeOpListBudgetsForResource) ID() string {
6263	return "OperationDeserializer"
6264}
6265
6266func (m *awsAwsjson11_deserializeOpListBudgetsForResource) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6267	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6268) {
6269	out, metadata, err = next.HandleDeserialize(ctx, in)
6270	if err != nil {
6271		return out, metadata, err
6272	}
6273
6274	response, ok := out.RawResponse.(*smithyhttp.Response)
6275	if !ok {
6276		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6277	}
6278
6279	if response.StatusCode < 200 || response.StatusCode >= 300 {
6280		return out, metadata, awsAwsjson11_deserializeOpErrorListBudgetsForResource(response, &metadata)
6281	}
6282	output := &ListBudgetsForResourceOutput{}
6283	out.Result = output
6284
6285	var buff [1024]byte
6286	ringBuffer := smithyio.NewRingBuffer(buff[:])
6287
6288	body := io.TeeReader(response.Body, ringBuffer)
6289	decoder := json.NewDecoder(body)
6290	decoder.UseNumber()
6291	var shape interface{}
6292	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6293		var snapshot bytes.Buffer
6294		io.Copy(&snapshot, ringBuffer)
6295		err = &smithy.DeserializationError{
6296			Err:      fmt.Errorf("failed to decode response body, %w", err),
6297			Snapshot: snapshot.Bytes(),
6298		}
6299		return out, metadata, err
6300	}
6301
6302	err = awsAwsjson11_deserializeOpDocumentListBudgetsForResourceOutput(&output, shape)
6303	if err != nil {
6304		var snapshot bytes.Buffer
6305		io.Copy(&snapshot, ringBuffer)
6306		err = &smithy.DeserializationError{
6307			Err:      fmt.Errorf("failed to decode response body, %w", err),
6308			Snapshot: snapshot.Bytes(),
6309		}
6310		return out, metadata, err
6311	}
6312
6313	return out, metadata, err
6314}
6315
6316func awsAwsjson11_deserializeOpErrorListBudgetsForResource(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6317	var errorBuffer bytes.Buffer
6318	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6319		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6320	}
6321	errorBody := bytes.NewReader(errorBuffer.Bytes())
6322
6323	errorCode := "UnknownError"
6324	errorMessage := errorCode
6325
6326	code := response.Header.Get("X-Amzn-ErrorType")
6327	if len(code) != 0 {
6328		errorCode = restjson.SanitizeErrorCode(code)
6329	}
6330
6331	var buff [1024]byte
6332	ringBuffer := smithyio.NewRingBuffer(buff[:])
6333
6334	body := io.TeeReader(errorBody, ringBuffer)
6335	decoder := json.NewDecoder(body)
6336	decoder.UseNumber()
6337	code, message, err := restjson.GetErrorInfo(decoder)
6338	if err != nil {
6339		var snapshot bytes.Buffer
6340		io.Copy(&snapshot, ringBuffer)
6341		err = &smithy.DeserializationError{
6342			Err:      fmt.Errorf("failed to decode response body, %w", err),
6343			Snapshot: snapshot.Bytes(),
6344		}
6345		return err
6346	}
6347
6348	errorBody.Seek(0, io.SeekStart)
6349	if len(code) != 0 {
6350		errorCode = restjson.SanitizeErrorCode(code)
6351	}
6352	if len(message) != 0 {
6353		errorMessage = message
6354	}
6355
6356	switch {
6357	case strings.EqualFold("InvalidParametersException", errorCode):
6358		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
6359
6360	case strings.EqualFold("ResourceNotFoundException", errorCode):
6361		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
6362
6363	default:
6364		genericError := &smithy.GenericAPIError{
6365			Code:    errorCode,
6366			Message: errorMessage,
6367		}
6368		return genericError
6369
6370	}
6371}
6372
6373type awsAwsjson11_deserializeOpListConstraintsForPortfolio struct {
6374}
6375
6376func (*awsAwsjson11_deserializeOpListConstraintsForPortfolio) ID() string {
6377	return "OperationDeserializer"
6378}
6379
6380func (m *awsAwsjson11_deserializeOpListConstraintsForPortfolio) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6381	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6382) {
6383	out, metadata, err = next.HandleDeserialize(ctx, in)
6384	if err != nil {
6385		return out, metadata, err
6386	}
6387
6388	response, ok := out.RawResponse.(*smithyhttp.Response)
6389	if !ok {
6390		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6391	}
6392
6393	if response.StatusCode < 200 || response.StatusCode >= 300 {
6394		return out, metadata, awsAwsjson11_deserializeOpErrorListConstraintsForPortfolio(response, &metadata)
6395	}
6396	output := &ListConstraintsForPortfolioOutput{}
6397	out.Result = output
6398
6399	var buff [1024]byte
6400	ringBuffer := smithyio.NewRingBuffer(buff[:])
6401
6402	body := io.TeeReader(response.Body, ringBuffer)
6403	decoder := json.NewDecoder(body)
6404	decoder.UseNumber()
6405	var shape interface{}
6406	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6407		var snapshot bytes.Buffer
6408		io.Copy(&snapshot, ringBuffer)
6409		err = &smithy.DeserializationError{
6410			Err:      fmt.Errorf("failed to decode response body, %w", err),
6411			Snapshot: snapshot.Bytes(),
6412		}
6413		return out, metadata, err
6414	}
6415
6416	err = awsAwsjson11_deserializeOpDocumentListConstraintsForPortfolioOutput(&output, shape)
6417	if err != nil {
6418		var snapshot bytes.Buffer
6419		io.Copy(&snapshot, ringBuffer)
6420		err = &smithy.DeserializationError{
6421			Err:      fmt.Errorf("failed to decode response body, %w", err),
6422			Snapshot: snapshot.Bytes(),
6423		}
6424		return out, metadata, err
6425	}
6426
6427	return out, metadata, err
6428}
6429
6430func awsAwsjson11_deserializeOpErrorListConstraintsForPortfolio(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6431	var errorBuffer bytes.Buffer
6432	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6433		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6434	}
6435	errorBody := bytes.NewReader(errorBuffer.Bytes())
6436
6437	errorCode := "UnknownError"
6438	errorMessage := errorCode
6439
6440	code := response.Header.Get("X-Amzn-ErrorType")
6441	if len(code) != 0 {
6442		errorCode = restjson.SanitizeErrorCode(code)
6443	}
6444
6445	var buff [1024]byte
6446	ringBuffer := smithyio.NewRingBuffer(buff[:])
6447
6448	body := io.TeeReader(errorBody, ringBuffer)
6449	decoder := json.NewDecoder(body)
6450	decoder.UseNumber()
6451	code, message, err := restjson.GetErrorInfo(decoder)
6452	if err != nil {
6453		var snapshot bytes.Buffer
6454		io.Copy(&snapshot, ringBuffer)
6455		err = &smithy.DeserializationError{
6456			Err:      fmt.Errorf("failed to decode response body, %w", err),
6457			Snapshot: snapshot.Bytes(),
6458		}
6459		return err
6460	}
6461
6462	errorBody.Seek(0, io.SeekStart)
6463	if len(code) != 0 {
6464		errorCode = restjson.SanitizeErrorCode(code)
6465	}
6466	if len(message) != 0 {
6467		errorMessage = message
6468	}
6469
6470	switch {
6471	case strings.EqualFold("InvalidParametersException", errorCode):
6472		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
6473
6474	case strings.EqualFold("ResourceNotFoundException", errorCode):
6475		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
6476
6477	default:
6478		genericError := &smithy.GenericAPIError{
6479			Code:    errorCode,
6480			Message: errorMessage,
6481		}
6482		return genericError
6483
6484	}
6485}
6486
6487type awsAwsjson11_deserializeOpListLaunchPaths struct {
6488}
6489
6490func (*awsAwsjson11_deserializeOpListLaunchPaths) ID() string {
6491	return "OperationDeserializer"
6492}
6493
6494func (m *awsAwsjson11_deserializeOpListLaunchPaths) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6495	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6496) {
6497	out, metadata, err = next.HandleDeserialize(ctx, in)
6498	if err != nil {
6499		return out, metadata, err
6500	}
6501
6502	response, ok := out.RawResponse.(*smithyhttp.Response)
6503	if !ok {
6504		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6505	}
6506
6507	if response.StatusCode < 200 || response.StatusCode >= 300 {
6508		return out, metadata, awsAwsjson11_deserializeOpErrorListLaunchPaths(response, &metadata)
6509	}
6510	output := &ListLaunchPathsOutput{}
6511	out.Result = output
6512
6513	var buff [1024]byte
6514	ringBuffer := smithyio.NewRingBuffer(buff[:])
6515
6516	body := io.TeeReader(response.Body, ringBuffer)
6517	decoder := json.NewDecoder(body)
6518	decoder.UseNumber()
6519	var shape interface{}
6520	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6521		var snapshot bytes.Buffer
6522		io.Copy(&snapshot, ringBuffer)
6523		err = &smithy.DeserializationError{
6524			Err:      fmt.Errorf("failed to decode response body, %w", err),
6525			Snapshot: snapshot.Bytes(),
6526		}
6527		return out, metadata, err
6528	}
6529
6530	err = awsAwsjson11_deserializeOpDocumentListLaunchPathsOutput(&output, shape)
6531	if err != nil {
6532		var snapshot bytes.Buffer
6533		io.Copy(&snapshot, ringBuffer)
6534		err = &smithy.DeserializationError{
6535			Err:      fmt.Errorf("failed to decode response body, %w", err),
6536			Snapshot: snapshot.Bytes(),
6537		}
6538		return out, metadata, err
6539	}
6540
6541	return out, metadata, err
6542}
6543
6544func awsAwsjson11_deserializeOpErrorListLaunchPaths(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6545	var errorBuffer bytes.Buffer
6546	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6547		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6548	}
6549	errorBody := bytes.NewReader(errorBuffer.Bytes())
6550
6551	errorCode := "UnknownError"
6552	errorMessage := errorCode
6553
6554	code := response.Header.Get("X-Amzn-ErrorType")
6555	if len(code) != 0 {
6556		errorCode = restjson.SanitizeErrorCode(code)
6557	}
6558
6559	var buff [1024]byte
6560	ringBuffer := smithyio.NewRingBuffer(buff[:])
6561
6562	body := io.TeeReader(errorBody, ringBuffer)
6563	decoder := json.NewDecoder(body)
6564	decoder.UseNumber()
6565	code, message, err := restjson.GetErrorInfo(decoder)
6566	if err != nil {
6567		var snapshot bytes.Buffer
6568		io.Copy(&snapshot, ringBuffer)
6569		err = &smithy.DeserializationError{
6570			Err:      fmt.Errorf("failed to decode response body, %w", err),
6571			Snapshot: snapshot.Bytes(),
6572		}
6573		return err
6574	}
6575
6576	errorBody.Seek(0, io.SeekStart)
6577	if len(code) != 0 {
6578		errorCode = restjson.SanitizeErrorCode(code)
6579	}
6580	if len(message) != 0 {
6581		errorMessage = message
6582	}
6583
6584	switch {
6585	case strings.EqualFold("InvalidParametersException", errorCode):
6586		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
6587
6588	case strings.EqualFold("ResourceNotFoundException", errorCode):
6589		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
6590
6591	default:
6592		genericError := &smithy.GenericAPIError{
6593			Code:    errorCode,
6594			Message: errorMessage,
6595		}
6596		return genericError
6597
6598	}
6599}
6600
6601type awsAwsjson11_deserializeOpListOrganizationPortfolioAccess struct {
6602}
6603
6604func (*awsAwsjson11_deserializeOpListOrganizationPortfolioAccess) ID() string {
6605	return "OperationDeserializer"
6606}
6607
6608func (m *awsAwsjson11_deserializeOpListOrganizationPortfolioAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6609	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6610) {
6611	out, metadata, err = next.HandleDeserialize(ctx, in)
6612	if err != nil {
6613		return out, metadata, err
6614	}
6615
6616	response, ok := out.RawResponse.(*smithyhttp.Response)
6617	if !ok {
6618		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6619	}
6620
6621	if response.StatusCode < 200 || response.StatusCode >= 300 {
6622		return out, metadata, awsAwsjson11_deserializeOpErrorListOrganizationPortfolioAccess(response, &metadata)
6623	}
6624	output := &ListOrganizationPortfolioAccessOutput{}
6625	out.Result = output
6626
6627	var buff [1024]byte
6628	ringBuffer := smithyio.NewRingBuffer(buff[:])
6629
6630	body := io.TeeReader(response.Body, ringBuffer)
6631	decoder := json.NewDecoder(body)
6632	decoder.UseNumber()
6633	var shape interface{}
6634	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6635		var snapshot bytes.Buffer
6636		io.Copy(&snapshot, ringBuffer)
6637		err = &smithy.DeserializationError{
6638			Err:      fmt.Errorf("failed to decode response body, %w", err),
6639			Snapshot: snapshot.Bytes(),
6640		}
6641		return out, metadata, err
6642	}
6643
6644	err = awsAwsjson11_deserializeOpDocumentListOrganizationPortfolioAccessOutput(&output, shape)
6645	if err != nil {
6646		var snapshot bytes.Buffer
6647		io.Copy(&snapshot, ringBuffer)
6648		err = &smithy.DeserializationError{
6649			Err:      fmt.Errorf("failed to decode response body, %w", err),
6650			Snapshot: snapshot.Bytes(),
6651		}
6652		return out, metadata, err
6653	}
6654
6655	return out, metadata, err
6656}
6657
6658func awsAwsjson11_deserializeOpErrorListOrganizationPortfolioAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6659	var errorBuffer bytes.Buffer
6660	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6661		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6662	}
6663	errorBody := bytes.NewReader(errorBuffer.Bytes())
6664
6665	errorCode := "UnknownError"
6666	errorMessage := errorCode
6667
6668	code := response.Header.Get("X-Amzn-ErrorType")
6669	if len(code) != 0 {
6670		errorCode = restjson.SanitizeErrorCode(code)
6671	}
6672
6673	var buff [1024]byte
6674	ringBuffer := smithyio.NewRingBuffer(buff[:])
6675
6676	body := io.TeeReader(errorBody, ringBuffer)
6677	decoder := json.NewDecoder(body)
6678	decoder.UseNumber()
6679	code, message, err := restjson.GetErrorInfo(decoder)
6680	if err != nil {
6681		var snapshot bytes.Buffer
6682		io.Copy(&snapshot, ringBuffer)
6683		err = &smithy.DeserializationError{
6684			Err:      fmt.Errorf("failed to decode response body, %w", err),
6685			Snapshot: snapshot.Bytes(),
6686		}
6687		return err
6688	}
6689
6690	errorBody.Seek(0, io.SeekStart)
6691	if len(code) != 0 {
6692		errorCode = restjson.SanitizeErrorCode(code)
6693	}
6694	if len(message) != 0 {
6695		errorMessage = message
6696	}
6697
6698	switch {
6699	case strings.EqualFold("InvalidParametersException", errorCode):
6700		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
6701
6702	case strings.EqualFold("OperationNotSupportedException", errorCode):
6703		return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody)
6704
6705	case strings.EqualFold("ResourceNotFoundException", errorCode):
6706		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
6707
6708	default:
6709		genericError := &smithy.GenericAPIError{
6710			Code:    errorCode,
6711			Message: errorMessage,
6712		}
6713		return genericError
6714
6715	}
6716}
6717
6718type awsAwsjson11_deserializeOpListPortfolioAccess struct {
6719}
6720
6721func (*awsAwsjson11_deserializeOpListPortfolioAccess) ID() string {
6722	return "OperationDeserializer"
6723}
6724
6725func (m *awsAwsjson11_deserializeOpListPortfolioAccess) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6726	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6727) {
6728	out, metadata, err = next.HandleDeserialize(ctx, in)
6729	if err != nil {
6730		return out, metadata, err
6731	}
6732
6733	response, ok := out.RawResponse.(*smithyhttp.Response)
6734	if !ok {
6735		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6736	}
6737
6738	if response.StatusCode < 200 || response.StatusCode >= 300 {
6739		return out, metadata, awsAwsjson11_deserializeOpErrorListPortfolioAccess(response, &metadata)
6740	}
6741	output := &ListPortfolioAccessOutput{}
6742	out.Result = output
6743
6744	var buff [1024]byte
6745	ringBuffer := smithyio.NewRingBuffer(buff[:])
6746
6747	body := io.TeeReader(response.Body, ringBuffer)
6748	decoder := json.NewDecoder(body)
6749	decoder.UseNumber()
6750	var shape interface{}
6751	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
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 out, metadata, err
6759	}
6760
6761	err = awsAwsjson11_deserializeOpDocumentListPortfolioAccessOutput(&output, shape)
6762	if err != nil {
6763		var snapshot bytes.Buffer
6764		io.Copy(&snapshot, ringBuffer)
6765		err = &smithy.DeserializationError{
6766			Err:      fmt.Errorf("failed to decode response body, %w", err),
6767			Snapshot: snapshot.Bytes(),
6768		}
6769		return out, metadata, err
6770	}
6771
6772	return out, metadata, err
6773}
6774
6775func awsAwsjson11_deserializeOpErrorListPortfolioAccess(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6776	var errorBuffer bytes.Buffer
6777	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6778		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6779	}
6780	errorBody := bytes.NewReader(errorBuffer.Bytes())
6781
6782	errorCode := "UnknownError"
6783	errorMessage := errorCode
6784
6785	code := response.Header.Get("X-Amzn-ErrorType")
6786	if len(code) != 0 {
6787		errorCode = restjson.SanitizeErrorCode(code)
6788	}
6789
6790	var buff [1024]byte
6791	ringBuffer := smithyio.NewRingBuffer(buff[:])
6792
6793	body := io.TeeReader(errorBody, ringBuffer)
6794	decoder := json.NewDecoder(body)
6795	decoder.UseNumber()
6796	code, message, err := restjson.GetErrorInfo(decoder)
6797	if err != nil {
6798		var snapshot bytes.Buffer
6799		io.Copy(&snapshot, ringBuffer)
6800		err = &smithy.DeserializationError{
6801			Err:      fmt.Errorf("failed to decode response body, %w", err),
6802			Snapshot: snapshot.Bytes(),
6803		}
6804		return err
6805	}
6806
6807	errorBody.Seek(0, io.SeekStart)
6808	if len(code) != 0 {
6809		errorCode = restjson.SanitizeErrorCode(code)
6810	}
6811	if len(message) != 0 {
6812		errorMessage = message
6813	}
6814
6815	switch {
6816	case strings.EqualFold("InvalidParametersException", errorCode):
6817		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
6818
6819	case strings.EqualFold("ResourceNotFoundException", errorCode):
6820		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
6821
6822	default:
6823		genericError := &smithy.GenericAPIError{
6824			Code:    errorCode,
6825			Message: errorMessage,
6826		}
6827		return genericError
6828
6829	}
6830}
6831
6832type awsAwsjson11_deserializeOpListPortfolios struct {
6833}
6834
6835func (*awsAwsjson11_deserializeOpListPortfolios) ID() string {
6836	return "OperationDeserializer"
6837}
6838
6839func (m *awsAwsjson11_deserializeOpListPortfolios) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6840	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6841) {
6842	out, metadata, err = next.HandleDeserialize(ctx, in)
6843	if err != nil {
6844		return out, metadata, err
6845	}
6846
6847	response, ok := out.RawResponse.(*smithyhttp.Response)
6848	if !ok {
6849		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6850	}
6851
6852	if response.StatusCode < 200 || response.StatusCode >= 300 {
6853		return out, metadata, awsAwsjson11_deserializeOpErrorListPortfolios(response, &metadata)
6854	}
6855	output := &ListPortfoliosOutput{}
6856	out.Result = output
6857
6858	var buff [1024]byte
6859	ringBuffer := smithyio.NewRingBuffer(buff[:])
6860
6861	body := io.TeeReader(response.Body, ringBuffer)
6862	decoder := json.NewDecoder(body)
6863	decoder.UseNumber()
6864	var shape interface{}
6865	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6866		var snapshot bytes.Buffer
6867		io.Copy(&snapshot, ringBuffer)
6868		err = &smithy.DeserializationError{
6869			Err:      fmt.Errorf("failed to decode response body, %w", err),
6870			Snapshot: snapshot.Bytes(),
6871		}
6872		return out, metadata, err
6873	}
6874
6875	err = awsAwsjson11_deserializeOpDocumentListPortfoliosOutput(&output, shape)
6876	if err != nil {
6877		var snapshot bytes.Buffer
6878		io.Copy(&snapshot, ringBuffer)
6879		err = &smithy.DeserializationError{
6880			Err:      fmt.Errorf("failed to decode response body, %w", err),
6881			Snapshot: snapshot.Bytes(),
6882		}
6883		return out, metadata, err
6884	}
6885
6886	return out, metadata, err
6887}
6888
6889func awsAwsjson11_deserializeOpErrorListPortfolios(response *smithyhttp.Response, metadata *middleware.Metadata) error {
6890	var errorBuffer bytes.Buffer
6891	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
6892		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
6893	}
6894	errorBody := bytes.NewReader(errorBuffer.Bytes())
6895
6896	errorCode := "UnknownError"
6897	errorMessage := errorCode
6898
6899	code := response.Header.Get("X-Amzn-ErrorType")
6900	if len(code) != 0 {
6901		errorCode = restjson.SanitizeErrorCode(code)
6902	}
6903
6904	var buff [1024]byte
6905	ringBuffer := smithyio.NewRingBuffer(buff[:])
6906
6907	body := io.TeeReader(errorBody, ringBuffer)
6908	decoder := json.NewDecoder(body)
6909	decoder.UseNumber()
6910	code, message, err := restjson.GetErrorInfo(decoder)
6911	if err != nil {
6912		var snapshot bytes.Buffer
6913		io.Copy(&snapshot, ringBuffer)
6914		err = &smithy.DeserializationError{
6915			Err:      fmt.Errorf("failed to decode response body, %w", err),
6916			Snapshot: snapshot.Bytes(),
6917		}
6918		return err
6919	}
6920
6921	errorBody.Seek(0, io.SeekStart)
6922	if len(code) != 0 {
6923		errorCode = restjson.SanitizeErrorCode(code)
6924	}
6925	if len(message) != 0 {
6926		errorMessage = message
6927	}
6928
6929	switch {
6930	case strings.EqualFold("InvalidParametersException", errorCode):
6931		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
6932
6933	default:
6934		genericError := &smithy.GenericAPIError{
6935			Code:    errorCode,
6936			Message: errorMessage,
6937		}
6938		return genericError
6939
6940	}
6941}
6942
6943type awsAwsjson11_deserializeOpListPortfoliosForProduct struct {
6944}
6945
6946func (*awsAwsjson11_deserializeOpListPortfoliosForProduct) ID() string {
6947	return "OperationDeserializer"
6948}
6949
6950func (m *awsAwsjson11_deserializeOpListPortfoliosForProduct) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
6951	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
6952) {
6953	out, metadata, err = next.HandleDeserialize(ctx, in)
6954	if err != nil {
6955		return out, metadata, err
6956	}
6957
6958	response, ok := out.RawResponse.(*smithyhttp.Response)
6959	if !ok {
6960		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
6961	}
6962
6963	if response.StatusCode < 200 || response.StatusCode >= 300 {
6964		return out, metadata, awsAwsjson11_deserializeOpErrorListPortfoliosForProduct(response, &metadata)
6965	}
6966	output := &ListPortfoliosForProductOutput{}
6967	out.Result = output
6968
6969	var buff [1024]byte
6970	ringBuffer := smithyio.NewRingBuffer(buff[:])
6971
6972	body := io.TeeReader(response.Body, ringBuffer)
6973	decoder := json.NewDecoder(body)
6974	decoder.UseNumber()
6975	var shape interface{}
6976	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
6977		var snapshot bytes.Buffer
6978		io.Copy(&snapshot, ringBuffer)
6979		err = &smithy.DeserializationError{
6980			Err:      fmt.Errorf("failed to decode response body, %w", err),
6981			Snapshot: snapshot.Bytes(),
6982		}
6983		return out, metadata, err
6984	}
6985
6986	err = awsAwsjson11_deserializeOpDocumentListPortfoliosForProductOutput(&output, shape)
6987	if err != nil {
6988		var snapshot bytes.Buffer
6989		io.Copy(&snapshot, ringBuffer)
6990		err = &smithy.DeserializationError{
6991			Err:      fmt.Errorf("failed to decode response body, %w", err),
6992			Snapshot: snapshot.Bytes(),
6993		}
6994		return out, metadata, err
6995	}
6996
6997	return out, metadata, err
6998}
6999
7000func awsAwsjson11_deserializeOpErrorListPortfoliosForProduct(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7001	var errorBuffer bytes.Buffer
7002	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7003		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7004	}
7005	errorBody := bytes.NewReader(errorBuffer.Bytes())
7006
7007	errorCode := "UnknownError"
7008	errorMessage := errorCode
7009
7010	code := response.Header.Get("X-Amzn-ErrorType")
7011	if len(code) != 0 {
7012		errorCode = restjson.SanitizeErrorCode(code)
7013	}
7014
7015	var buff [1024]byte
7016	ringBuffer := smithyio.NewRingBuffer(buff[:])
7017
7018	body := io.TeeReader(errorBody, ringBuffer)
7019	decoder := json.NewDecoder(body)
7020	decoder.UseNumber()
7021	code, message, err := restjson.GetErrorInfo(decoder)
7022	if err != nil {
7023		var snapshot bytes.Buffer
7024		io.Copy(&snapshot, ringBuffer)
7025		err = &smithy.DeserializationError{
7026			Err:      fmt.Errorf("failed to decode response body, %w", err),
7027			Snapshot: snapshot.Bytes(),
7028		}
7029		return err
7030	}
7031
7032	errorBody.Seek(0, io.SeekStart)
7033	if len(code) != 0 {
7034		errorCode = restjson.SanitizeErrorCode(code)
7035	}
7036	if len(message) != 0 {
7037		errorMessage = message
7038	}
7039
7040	switch {
7041	case strings.EqualFold("InvalidParametersException", errorCode):
7042		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
7043
7044	case strings.EqualFold("ResourceNotFoundException", errorCode):
7045		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
7046
7047	default:
7048		genericError := &smithy.GenericAPIError{
7049			Code:    errorCode,
7050			Message: errorMessage,
7051		}
7052		return genericError
7053
7054	}
7055}
7056
7057type awsAwsjson11_deserializeOpListPrincipalsForPortfolio struct {
7058}
7059
7060func (*awsAwsjson11_deserializeOpListPrincipalsForPortfolio) ID() string {
7061	return "OperationDeserializer"
7062}
7063
7064func (m *awsAwsjson11_deserializeOpListPrincipalsForPortfolio) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7065	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7066) {
7067	out, metadata, err = next.HandleDeserialize(ctx, in)
7068	if err != nil {
7069		return out, metadata, err
7070	}
7071
7072	response, ok := out.RawResponse.(*smithyhttp.Response)
7073	if !ok {
7074		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7075	}
7076
7077	if response.StatusCode < 200 || response.StatusCode >= 300 {
7078		return out, metadata, awsAwsjson11_deserializeOpErrorListPrincipalsForPortfolio(response, &metadata)
7079	}
7080	output := &ListPrincipalsForPortfolioOutput{}
7081	out.Result = output
7082
7083	var buff [1024]byte
7084	ringBuffer := smithyio.NewRingBuffer(buff[:])
7085
7086	body := io.TeeReader(response.Body, ringBuffer)
7087	decoder := json.NewDecoder(body)
7088	decoder.UseNumber()
7089	var shape interface{}
7090	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7091		var snapshot bytes.Buffer
7092		io.Copy(&snapshot, ringBuffer)
7093		err = &smithy.DeserializationError{
7094			Err:      fmt.Errorf("failed to decode response body, %w", err),
7095			Snapshot: snapshot.Bytes(),
7096		}
7097		return out, metadata, err
7098	}
7099
7100	err = awsAwsjson11_deserializeOpDocumentListPrincipalsForPortfolioOutput(&output, shape)
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 out, metadata, err
7109	}
7110
7111	return out, metadata, err
7112}
7113
7114func awsAwsjson11_deserializeOpErrorListPrincipalsForPortfolio(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7115	var errorBuffer bytes.Buffer
7116	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7117		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7118	}
7119	errorBody := bytes.NewReader(errorBuffer.Bytes())
7120
7121	errorCode := "UnknownError"
7122	errorMessage := errorCode
7123
7124	code := response.Header.Get("X-Amzn-ErrorType")
7125	if len(code) != 0 {
7126		errorCode = restjson.SanitizeErrorCode(code)
7127	}
7128
7129	var buff [1024]byte
7130	ringBuffer := smithyio.NewRingBuffer(buff[:])
7131
7132	body := io.TeeReader(errorBody, ringBuffer)
7133	decoder := json.NewDecoder(body)
7134	decoder.UseNumber()
7135	code, message, err := restjson.GetErrorInfo(decoder)
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	if len(code) != 0 {
7148		errorCode = restjson.SanitizeErrorCode(code)
7149	}
7150	if len(message) != 0 {
7151		errorMessage = message
7152	}
7153
7154	switch {
7155	case strings.EqualFold("InvalidParametersException", errorCode):
7156		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
7157
7158	case strings.EqualFold("ResourceNotFoundException", errorCode):
7159		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
7160
7161	default:
7162		genericError := &smithy.GenericAPIError{
7163			Code:    errorCode,
7164			Message: errorMessage,
7165		}
7166		return genericError
7167
7168	}
7169}
7170
7171type awsAwsjson11_deserializeOpListProvisionedProductPlans struct {
7172}
7173
7174func (*awsAwsjson11_deserializeOpListProvisionedProductPlans) ID() string {
7175	return "OperationDeserializer"
7176}
7177
7178func (m *awsAwsjson11_deserializeOpListProvisionedProductPlans) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7179	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7180) {
7181	out, metadata, err = next.HandleDeserialize(ctx, in)
7182	if err != nil {
7183		return out, metadata, err
7184	}
7185
7186	response, ok := out.RawResponse.(*smithyhttp.Response)
7187	if !ok {
7188		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7189	}
7190
7191	if response.StatusCode < 200 || response.StatusCode >= 300 {
7192		return out, metadata, awsAwsjson11_deserializeOpErrorListProvisionedProductPlans(response, &metadata)
7193	}
7194	output := &ListProvisionedProductPlansOutput{}
7195	out.Result = output
7196
7197	var buff [1024]byte
7198	ringBuffer := smithyio.NewRingBuffer(buff[:])
7199
7200	body := io.TeeReader(response.Body, ringBuffer)
7201	decoder := json.NewDecoder(body)
7202	decoder.UseNumber()
7203	var shape interface{}
7204	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7205		var snapshot bytes.Buffer
7206		io.Copy(&snapshot, ringBuffer)
7207		err = &smithy.DeserializationError{
7208			Err:      fmt.Errorf("failed to decode response body, %w", err),
7209			Snapshot: snapshot.Bytes(),
7210		}
7211		return out, metadata, err
7212	}
7213
7214	err = awsAwsjson11_deserializeOpDocumentListProvisionedProductPlansOutput(&output, shape)
7215	if err != nil {
7216		var snapshot bytes.Buffer
7217		io.Copy(&snapshot, ringBuffer)
7218		err = &smithy.DeserializationError{
7219			Err:      fmt.Errorf("failed to decode response body, %w", err),
7220			Snapshot: snapshot.Bytes(),
7221		}
7222		return out, metadata, err
7223	}
7224
7225	return out, metadata, err
7226}
7227
7228func awsAwsjson11_deserializeOpErrorListProvisionedProductPlans(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7229	var errorBuffer bytes.Buffer
7230	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7231		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7232	}
7233	errorBody := bytes.NewReader(errorBuffer.Bytes())
7234
7235	errorCode := "UnknownError"
7236	errorMessage := errorCode
7237
7238	code := response.Header.Get("X-Amzn-ErrorType")
7239	if len(code) != 0 {
7240		errorCode = restjson.SanitizeErrorCode(code)
7241	}
7242
7243	var buff [1024]byte
7244	ringBuffer := smithyio.NewRingBuffer(buff[:])
7245
7246	body := io.TeeReader(errorBody, ringBuffer)
7247	decoder := json.NewDecoder(body)
7248	decoder.UseNumber()
7249	code, message, err := restjson.GetErrorInfo(decoder)
7250	if err != nil {
7251		var snapshot bytes.Buffer
7252		io.Copy(&snapshot, ringBuffer)
7253		err = &smithy.DeserializationError{
7254			Err:      fmt.Errorf("failed to decode response body, %w", err),
7255			Snapshot: snapshot.Bytes(),
7256		}
7257		return err
7258	}
7259
7260	errorBody.Seek(0, io.SeekStart)
7261	if len(code) != 0 {
7262		errorCode = restjson.SanitizeErrorCode(code)
7263	}
7264	if len(message) != 0 {
7265		errorMessage = message
7266	}
7267
7268	switch {
7269	case strings.EqualFold("InvalidParametersException", errorCode):
7270		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
7271
7272	case strings.EqualFold("ResourceNotFoundException", errorCode):
7273		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
7274
7275	default:
7276		genericError := &smithy.GenericAPIError{
7277			Code:    errorCode,
7278			Message: errorMessage,
7279		}
7280		return genericError
7281
7282	}
7283}
7284
7285type awsAwsjson11_deserializeOpListProvisioningArtifacts struct {
7286}
7287
7288func (*awsAwsjson11_deserializeOpListProvisioningArtifacts) ID() string {
7289	return "OperationDeserializer"
7290}
7291
7292func (m *awsAwsjson11_deserializeOpListProvisioningArtifacts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7293	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7294) {
7295	out, metadata, err = next.HandleDeserialize(ctx, in)
7296	if err != nil {
7297		return out, metadata, err
7298	}
7299
7300	response, ok := out.RawResponse.(*smithyhttp.Response)
7301	if !ok {
7302		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7303	}
7304
7305	if response.StatusCode < 200 || response.StatusCode >= 300 {
7306		return out, metadata, awsAwsjson11_deserializeOpErrorListProvisioningArtifacts(response, &metadata)
7307	}
7308	output := &ListProvisioningArtifactsOutput{}
7309	out.Result = output
7310
7311	var buff [1024]byte
7312	ringBuffer := smithyio.NewRingBuffer(buff[:])
7313
7314	body := io.TeeReader(response.Body, ringBuffer)
7315	decoder := json.NewDecoder(body)
7316	decoder.UseNumber()
7317	var shape interface{}
7318	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7319		var snapshot bytes.Buffer
7320		io.Copy(&snapshot, ringBuffer)
7321		err = &smithy.DeserializationError{
7322			Err:      fmt.Errorf("failed to decode response body, %w", err),
7323			Snapshot: snapshot.Bytes(),
7324		}
7325		return out, metadata, err
7326	}
7327
7328	err = awsAwsjson11_deserializeOpDocumentListProvisioningArtifactsOutput(&output, shape)
7329	if err != nil {
7330		var snapshot bytes.Buffer
7331		io.Copy(&snapshot, ringBuffer)
7332		err = &smithy.DeserializationError{
7333			Err:      fmt.Errorf("failed to decode response body, %w", err),
7334			Snapshot: snapshot.Bytes(),
7335		}
7336		return out, metadata, err
7337	}
7338
7339	return out, metadata, err
7340}
7341
7342func awsAwsjson11_deserializeOpErrorListProvisioningArtifacts(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7343	var errorBuffer bytes.Buffer
7344	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7345		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7346	}
7347	errorBody := bytes.NewReader(errorBuffer.Bytes())
7348
7349	errorCode := "UnknownError"
7350	errorMessage := errorCode
7351
7352	code := response.Header.Get("X-Amzn-ErrorType")
7353	if len(code) != 0 {
7354		errorCode = restjson.SanitizeErrorCode(code)
7355	}
7356
7357	var buff [1024]byte
7358	ringBuffer := smithyio.NewRingBuffer(buff[:])
7359
7360	body := io.TeeReader(errorBody, ringBuffer)
7361	decoder := json.NewDecoder(body)
7362	decoder.UseNumber()
7363	code, message, err := restjson.GetErrorInfo(decoder)
7364	if err != nil {
7365		var snapshot bytes.Buffer
7366		io.Copy(&snapshot, ringBuffer)
7367		err = &smithy.DeserializationError{
7368			Err:      fmt.Errorf("failed to decode response body, %w", err),
7369			Snapshot: snapshot.Bytes(),
7370		}
7371		return err
7372	}
7373
7374	errorBody.Seek(0, io.SeekStart)
7375	if len(code) != 0 {
7376		errorCode = restjson.SanitizeErrorCode(code)
7377	}
7378	if len(message) != 0 {
7379		errorMessage = message
7380	}
7381
7382	switch {
7383	case strings.EqualFold("InvalidParametersException", errorCode):
7384		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
7385
7386	case strings.EqualFold("ResourceNotFoundException", errorCode):
7387		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
7388
7389	default:
7390		genericError := &smithy.GenericAPIError{
7391			Code:    errorCode,
7392			Message: errorMessage,
7393		}
7394		return genericError
7395
7396	}
7397}
7398
7399type awsAwsjson11_deserializeOpListProvisioningArtifactsForServiceAction struct {
7400}
7401
7402func (*awsAwsjson11_deserializeOpListProvisioningArtifactsForServiceAction) ID() string {
7403	return "OperationDeserializer"
7404}
7405
7406func (m *awsAwsjson11_deserializeOpListProvisioningArtifactsForServiceAction) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7407	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7408) {
7409	out, metadata, err = next.HandleDeserialize(ctx, in)
7410	if err != nil {
7411		return out, metadata, err
7412	}
7413
7414	response, ok := out.RawResponse.(*smithyhttp.Response)
7415	if !ok {
7416		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7417	}
7418
7419	if response.StatusCode < 200 || response.StatusCode >= 300 {
7420		return out, metadata, awsAwsjson11_deserializeOpErrorListProvisioningArtifactsForServiceAction(response, &metadata)
7421	}
7422	output := &ListProvisioningArtifactsForServiceActionOutput{}
7423	out.Result = output
7424
7425	var buff [1024]byte
7426	ringBuffer := smithyio.NewRingBuffer(buff[:])
7427
7428	body := io.TeeReader(response.Body, ringBuffer)
7429	decoder := json.NewDecoder(body)
7430	decoder.UseNumber()
7431	var shape interface{}
7432	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7433		var snapshot bytes.Buffer
7434		io.Copy(&snapshot, ringBuffer)
7435		err = &smithy.DeserializationError{
7436			Err:      fmt.Errorf("failed to decode response body, %w", err),
7437			Snapshot: snapshot.Bytes(),
7438		}
7439		return out, metadata, err
7440	}
7441
7442	err = awsAwsjson11_deserializeOpDocumentListProvisioningArtifactsForServiceActionOutput(&output, shape)
7443	if err != nil {
7444		var snapshot bytes.Buffer
7445		io.Copy(&snapshot, ringBuffer)
7446		err = &smithy.DeserializationError{
7447			Err:      fmt.Errorf("failed to decode response body, %w", err),
7448			Snapshot: snapshot.Bytes(),
7449		}
7450		return out, metadata, err
7451	}
7452
7453	return out, metadata, err
7454}
7455
7456func awsAwsjson11_deserializeOpErrorListProvisioningArtifactsForServiceAction(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7457	var errorBuffer bytes.Buffer
7458	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7459		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7460	}
7461	errorBody := bytes.NewReader(errorBuffer.Bytes())
7462
7463	errorCode := "UnknownError"
7464	errorMessage := errorCode
7465
7466	code := response.Header.Get("X-Amzn-ErrorType")
7467	if len(code) != 0 {
7468		errorCode = restjson.SanitizeErrorCode(code)
7469	}
7470
7471	var buff [1024]byte
7472	ringBuffer := smithyio.NewRingBuffer(buff[:])
7473
7474	body := io.TeeReader(errorBody, ringBuffer)
7475	decoder := json.NewDecoder(body)
7476	decoder.UseNumber()
7477	code, message, err := restjson.GetErrorInfo(decoder)
7478	if err != nil {
7479		var snapshot bytes.Buffer
7480		io.Copy(&snapshot, ringBuffer)
7481		err = &smithy.DeserializationError{
7482			Err:      fmt.Errorf("failed to decode response body, %w", err),
7483			Snapshot: snapshot.Bytes(),
7484		}
7485		return err
7486	}
7487
7488	errorBody.Seek(0, io.SeekStart)
7489	if len(code) != 0 {
7490		errorCode = restjson.SanitizeErrorCode(code)
7491	}
7492	if len(message) != 0 {
7493		errorMessage = message
7494	}
7495
7496	switch {
7497	case strings.EqualFold("InvalidParametersException", errorCode):
7498		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
7499
7500	case strings.EqualFold("ResourceNotFoundException", errorCode):
7501		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
7502
7503	default:
7504		genericError := &smithy.GenericAPIError{
7505			Code:    errorCode,
7506			Message: errorMessage,
7507		}
7508		return genericError
7509
7510	}
7511}
7512
7513type awsAwsjson11_deserializeOpListRecordHistory struct {
7514}
7515
7516func (*awsAwsjson11_deserializeOpListRecordHistory) ID() string {
7517	return "OperationDeserializer"
7518}
7519
7520func (m *awsAwsjson11_deserializeOpListRecordHistory) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7521	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7522) {
7523	out, metadata, err = next.HandleDeserialize(ctx, in)
7524	if err != nil {
7525		return out, metadata, err
7526	}
7527
7528	response, ok := out.RawResponse.(*smithyhttp.Response)
7529	if !ok {
7530		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7531	}
7532
7533	if response.StatusCode < 200 || response.StatusCode >= 300 {
7534		return out, metadata, awsAwsjson11_deserializeOpErrorListRecordHistory(response, &metadata)
7535	}
7536	output := &ListRecordHistoryOutput{}
7537	out.Result = output
7538
7539	var buff [1024]byte
7540	ringBuffer := smithyio.NewRingBuffer(buff[:])
7541
7542	body := io.TeeReader(response.Body, ringBuffer)
7543	decoder := json.NewDecoder(body)
7544	decoder.UseNumber()
7545	var shape interface{}
7546	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7547		var snapshot bytes.Buffer
7548		io.Copy(&snapshot, ringBuffer)
7549		err = &smithy.DeserializationError{
7550			Err:      fmt.Errorf("failed to decode response body, %w", err),
7551			Snapshot: snapshot.Bytes(),
7552		}
7553		return out, metadata, err
7554	}
7555
7556	err = awsAwsjson11_deserializeOpDocumentListRecordHistoryOutput(&output, shape)
7557	if err != nil {
7558		var snapshot bytes.Buffer
7559		io.Copy(&snapshot, ringBuffer)
7560		err = &smithy.DeserializationError{
7561			Err:      fmt.Errorf("failed to decode response body, %w", err),
7562			Snapshot: snapshot.Bytes(),
7563		}
7564		return out, metadata, err
7565	}
7566
7567	return out, metadata, err
7568}
7569
7570func awsAwsjson11_deserializeOpErrorListRecordHistory(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7571	var errorBuffer bytes.Buffer
7572	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7573		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7574	}
7575	errorBody := bytes.NewReader(errorBuffer.Bytes())
7576
7577	errorCode := "UnknownError"
7578	errorMessage := errorCode
7579
7580	code := response.Header.Get("X-Amzn-ErrorType")
7581	if len(code) != 0 {
7582		errorCode = restjson.SanitizeErrorCode(code)
7583	}
7584
7585	var buff [1024]byte
7586	ringBuffer := smithyio.NewRingBuffer(buff[:])
7587
7588	body := io.TeeReader(errorBody, ringBuffer)
7589	decoder := json.NewDecoder(body)
7590	decoder.UseNumber()
7591	code, message, err := restjson.GetErrorInfo(decoder)
7592	if err != nil {
7593		var snapshot bytes.Buffer
7594		io.Copy(&snapshot, ringBuffer)
7595		err = &smithy.DeserializationError{
7596			Err:      fmt.Errorf("failed to decode response body, %w", err),
7597			Snapshot: snapshot.Bytes(),
7598		}
7599		return err
7600	}
7601
7602	errorBody.Seek(0, io.SeekStart)
7603	if len(code) != 0 {
7604		errorCode = restjson.SanitizeErrorCode(code)
7605	}
7606	if len(message) != 0 {
7607		errorMessage = message
7608	}
7609
7610	switch {
7611	case strings.EqualFold("InvalidParametersException", errorCode):
7612		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
7613
7614	default:
7615		genericError := &smithy.GenericAPIError{
7616			Code:    errorCode,
7617			Message: errorMessage,
7618		}
7619		return genericError
7620
7621	}
7622}
7623
7624type awsAwsjson11_deserializeOpListResourcesForTagOption struct {
7625}
7626
7627func (*awsAwsjson11_deserializeOpListResourcesForTagOption) ID() string {
7628	return "OperationDeserializer"
7629}
7630
7631func (m *awsAwsjson11_deserializeOpListResourcesForTagOption) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7632	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7633) {
7634	out, metadata, err = next.HandleDeserialize(ctx, in)
7635	if err != nil {
7636		return out, metadata, err
7637	}
7638
7639	response, ok := out.RawResponse.(*smithyhttp.Response)
7640	if !ok {
7641		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7642	}
7643
7644	if response.StatusCode < 200 || response.StatusCode >= 300 {
7645		return out, metadata, awsAwsjson11_deserializeOpErrorListResourcesForTagOption(response, &metadata)
7646	}
7647	output := &ListResourcesForTagOptionOutput{}
7648	out.Result = output
7649
7650	var buff [1024]byte
7651	ringBuffer := smithyio.NewRingBuffer(buff[:])
7652
7653	body := io.TeeReader(response.Body, ringBuffer)
7654	decoder := json.NewDecoder(body)
7655	decoder.UseNumber()
7656	var shape interface{}
7657	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7658		var snapshot bytes.Buffer
7659		io.Copy(&snapshot, ringBuffer)
7660		err = &smithy.DeserializationError{
7661			Err:      fmt.Errorf("failed to decode response body, %w", err),
7662			Snapshot: snapshot.Bytes(),
7663		}
7664		return out, metadata, err
7665	}
7666
7667	err = awsAwsjson11_deserializeOpDocumentListResourcesForTagOptionOutput(&output, shape)
7668	if err != nil {
7669		var snapshot bytes.Buffer
7670		io.Copy(&snapshot, ringBuffer)
7671		err = &smithy.DeserializationError{
7672			Err:      fmt.Errorf("failed to decode response body, %w", err),
7673			Snapshot: snapshot.Bytes(),
7674		}
7675		return out, metadata, err
7676	}
7677
7678	return out, metadata, err
7679}
7680
7681func awsAwsjson11_deserializeOpErrorListResourcesForTagOption(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7682	var errorBuffer bytes.Buffer
7683	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7684		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7685	}
7686	errorBody := bytes.NewReader(errorBuffer.Bytes())
7687
7688	errorCode := "UnknownError"
7689	errorMessage := errorCode
7690
7691	code := response.Header.Get("X-Amzn-ErrorType")
7692	if len(code) != 0 {
7693		errorCode = restjson.SanitizeErrorCode(code)
7694	}
7695
7696	var buff [1024]byte
7697	ringBuffer := smithyio.NewRingBuffer(buff[:])
7698
7699	body := io.TeeReader(errorBody, ringBuffer)
7700	decoder := json.NewDecoder(body)
7701	decoder.UseNumber()
7702	code, message, err := restjson.GetErrorInfo(decoder)
7703	if err != nil {
7704		var snapshot bytes.Buffer
7705		io.Copy(&snapshot, ringBuffer)
7706		err = &smithy.DeserializationError{
7707			Err:      fmt.Errorf("failed to decode response body, %w", err),
7708			Snapshot: snapshot.Bytes(),
7709		}
7710		return err
7711	}
7712
7713	errorBody.Seek(0, io.SeekStart)
7714	if len(code) != 0 {
7715		errorCode = restjson.SanitizeErrorCode(code)
7716	}
7717	if len(message) != 0 {
7718		errorMessage = message
7719	}
7720
7721	switch {
7722	case strings.EqualFold("InvalidParametersException", errorCode):
7723		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
7724
7725	case strings.EqualFold("ResourceNotFoundException", errorCode):
7726		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
7727
7728	case strings.EqualFold("TagOptionNotMigratedException", errorCode):
7729		return awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response, errorBody)
7730
7731	default:
7732		genericError := &smithy.GenericAPIError{
7733			Code:    errorCode,
7734			Message: errorMessage,
7735		}
7736		return genericError
7737
7738	}
7739}
7740
7741type awsAwsjson11_deserializeOpListServiceActions struct {
7742}
7743
7744func (*awsAwsjson11_deserializeOpListServiceActions) ID() string {
7745	return "OperationDeserializer"
7746}
7747
7748func (m *awsAwsjson11_deserializeOpListServiceActions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7749	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7750) {
7751	out, metadata, err = next.HandleDeserialize(ctx, in)
7752	if err != nil {
7753		return out, metadata, err
7754	}
7755
7756	response, ok := out.RawResponse.(*smithyhttp.Response)
7757	if !ok {
7758		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7759	}
7760
7761	if response.StatusCode < 200 || response.StatusCode >= 300 {
7762		return out, metadata, awsAwsjson11_deserializeOpErrorListServiceActions(response, &metadata)
7763	}
7764	output := &ListServiceActionsOutput{}
7765	out.Result = output
7766
7767	var buff [1024]byte
7768	ringBuffer := smithyio.NewRingBuffer(buff[:])
7769
7770	body := io.TeeReader(response.Body, ringBuffer)
7771	decoder := json.NewDecoder(body)
7772	decoder.UseNumber()
7773	var shape interface{}
7774	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7775		var snapshot bytes.Buffer
7776		io.Copy(&snapshot, ringBuffer)
7777		err = &smithy.DeserializationError{
7778			Err:      fmt.Errorf("failed to decode response body, %w", err),
7779			Snapshot: snapshot.Bytes(),
7780		}
7781		return out, metadata, err
7782	}
7783
7784	err = awsAwsjson11_deserializeOpDocumentListServiceActionsOutput(&output, shape)
7785	if err != nil {
7786		var snapshot bytes.Buffer
7787		io.Copy(&snapshot, ringBuffer)
7788		err = &smithy.DeserializationError{
7789			Err:      fmt.Errorf("failed to decode response body, %w", err),
7790			Snapshot: snapshot.Bytes(),
7791		}
7792		return out, metadata, err
7793	}
7794
7795	return out, metadata, err
7796}
7797
7798func awsAwsjson11_deserializeOpErrorListServiceActions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7799	var errorBuffer bytes.Buffer
7800	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7801		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7802	}
7803	errorBody := bytes.NewReader(errorBuffer.Bytes())
7804
7805	errorCode := "UnknownError"
7806	errorMessage := errorCode
7807
7808	code := response.Header.Get("X-Amzn-ErrorType")
7809	if len(code) != 0 {
7810		errorCode = restjson.SanitizeErrorCode(code)
7811	}
7812
7813	var buff [1024]byte
7814	ringBuffer := smithyio.NewRingBuffer(buff[:])
7815
7816	body := io.TeeReader(errorBody, ringBuffer)
7817	decoder := json.NewDecoder(body)
7818	decoder.UseNumber()
7819	code, message, err := restjson.GetErrorInfo(decoder)
7820	if err != nil {
7821		var snapshot bytes.Buffer
7822		io.Copy(&snapshot, ringBuffer)
7823		err = &smithy.DeserializationError{
7824			Err:      fmt.Errorf("failed to decode response body, %w", err),
7825			Snapshot: snapshot.Bytes(),
7826		}
7827		return err
7828	}
7829
7830	errorBody.Seek(0, io.SeekStart)
7831	if len(code) != 0 {
7832		errorCode = restjson.SanitizeErrorCode(code)
7833	}
7834	if len(message) != 0 {
7835		errorMessage = message
7836	}
7837
7838	switch {
7839	case strings.EqualFold("InvalidParametersException", errorCode):
7840		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
7841
7842	default:
7843		genericError := &smithy.GenericAPIError{
7844			Code:    errorCode,
7845			Message: errorMessage,
7846		}
7847		return genericError
7848
7849	}
7850}
7851
7852type awsAwsjson11_deserializeOpListServiceActionsForProvisioningArtifact struct {
7853}
7854
7855func (*awsAwsjson11_deserializeOpListServiceActionsForProvisioningArtifact) ID() string {
7856	return "OperationDeserializer"
7857}
7858
7859func (m *awsAwsjson11_deserializeOpListServiceActionsForProvisioningArtifact) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7860	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7861) {
7862	out, metadata, err = next.HandleDeserialize(ctx, in)
7863	if err != nil {
7864		return out, metadata, err
7865	}
7866
7867	response, ok := out.RawResponse.(*smithyhttp.Response)
7868	if !ok {
7869		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7870	}
7871
7872	if response.StatusCode < 200 || response.StatusCode >= 300 {
7873		return out, metadata, awsAwsjson11_deserializeOpErrorListServiceActionsForProvisioningArtifact(response, &metadata)
7874	}
7875	output := &ListServiceActionsForProvisioningArtifactOutput{}
7876	out.Result = output
7877
7878	var buff [1024]byte
7879	ringBuffer := smithyio.NewRingBuffer(buff[:])
7880
7881	body := io.TeeReader(response.Body, ringBuffer)
7882	decoder := json.NewDecoder(body)
7883	decoder.UseNumber()
7884	var shape interface{}
7885	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
7886		var snapshot bytes.Buffer
7887		io.Copy(&snapshot, ringBuffer)
7888		err = &smithy.DeserializationError{
7889			Err:      fmt.Errorf("failed to decode response body, %w", err),
7890			Snapshot: snapshot.Bytes(),
7891		}
7892		return out, metadata, err
7893	}
7894
7895	err = awsAwsjson11_deserializeOpDocumentListServiceActionsForProvisioningArtifactOutput(&output, shape)
7896	if err != nil {
7897		var snapshot bytes.Buffer
7898		io.Copy(&snapshot, ringBuffer)
7899		err = &smithy.DeserializationError{
7900			Err:      fmt.Errorf("failed to decode response body, %w", err),
7901			Snapshot: snapshot.Bytes(),
7902		}
7903		return out, metadata, err
7904	}
7905
7906	return out, metadata, err
7907}
7908
7909func awsAwsjson11_deserializeOpErrorListServiceActionsForProvisioningArtifact(response *smithyhttp.Response, metadata *middleware.Metadata) error {
7910	var errorBuffer bytes.Buffer
7911	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
7912		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
7913	}
7914	errorBody := bytes.NewReader(errorBuffer.Bytes())
7915
7916	errorCode := "UnknownError"
7917	errorMessage := errorCode
7918
7919	code := response.Header.Get("X-Amzn-ErrorType")
7920	if len(code) != 0 {
7921		errorCode = restjson.SanitizeErrorCode(code)
7922	}
7923
7924	var buff [1024]byte
7925	ringBuffer := smithyio.NewRingBuffer(buff[:])
7926
7927	body := io.TeeReader(errorBody, ringBuffer)
7928	decoder := json.NewDecoder(body)
7929	decoder.UseNumber()
7930	code, message, err := restjson.GetErrorInfo(decoder)
7931	if err != nil {
7932		var snapshot bytes.Buffer
7933		io.Copy(&snapshot, ringBuffer)
7934		err = &smithy.DeserializationError{
7935			Err:      fmt.Errorf("failed to decode response body, %w", err),
7936			Snapshot: snapshot.Bytes(),
7937		}
7938		return err
7939	}
7940
7941	errorBody.Seek(0, io.SeekStart)
7942	if len(code) != 0 {
7943		errorCode = restjson.SanitizeErrorCode(code)
7944	}
7945	if len(message) != 0 {
7946		errorMessage = message
7947	}
7948
7949	switch {
7950	case strings.EqualFold("InvalidParametersException", errorCode):
7951		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
7952
7953	case strings.EqualFold("ResourceNotFoundException", errorCode):
7954		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
7955
7956	default:
7957		genericError := &smithy.GenericAPIError{
7958			Code:    errorCode,
7959			Message: errorMessage,
7960		}
7961		return genericError
7962
7963	}
7964}
7965
7966type awsAwsjson11_deserializeOpListStackInstancesForProvisionedProduct struct {
7967}
7968
7969func (*awsAwsjson11_deserializeOpListStackInstancesForProvisionedProduct) ID() string {
7970	return "OperationDeserializer"
7971}
7972
7973func (m *awsAwsjson11_deserializeOpListStackInstancesForProvisionedProduct) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
7974	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
7975) {
7976	out, metadata, err = next.HandleDeserialize(ctx, in)
7977	if err != nil {
7978		return out, metadata, err
7979	}
7980
7981	response, ok := out.RawResponse.(*smithyhttp.Response)
7982	if !ok {
7983		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
7984	}
7985
7986	if response.StatusCode < 200 || response.StatusCode >= 300 {
7987		return out, metadata, awsAwsjson11_deserializeOpErrorListStackInstancesForProvisionedProduct(response, &metadata)
7988	}
7989	output := &ListStackInstancesForProvisionedProductOutput{}
7990	out.Result = output
7991
7992	var buff [1024]byte
7993	ringBuffer := smithyio.NewRingBuffer(buff[:])
7994
7995	body := io.TeeReader(response.Body, ringBuffer)
7996	decoder := json.NewDecoder(body)
7997	decoder.UseNumber()
7998	var shape interface{}
7999	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8000		var snapshot bytes.Buffer
8001		io.Copy(&snapshot, ringBuffer)
8002		err = &smithy.DeserializationError{
8003			Err:      fmt.Errorf("failed to decode response body, %w", err),
8004			Snapshot: snapshot.Bytes(),
8005		}
8006		return out, metadata, err
8007	}
8008
8009	err = awsAwsjson11_deserializeOpDocumentListStackInstancesForProvisionedProductOutput(&output, shape)
8010	if err != nil {
8011		var snapshot bytes.Buffer
8012		io.Copy(&snapshot, ringBuffer)
8013		err = &smithy.DeserializationError{
8014			Err:      fmt.Errorf("failed to decode response body, %w", err),
8015			Snapshot: snapshot.Bytes(),
8016		}
8017		return out, metadata, err
8018	}
8019
8020	return out, metadata, err
8021}
8022
8023func awsAwsjson11_deserializeOpErrorListStackInstancesForProvisionedProduct(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8024	var errorBuffer bytes.Buffer
8025	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8026		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8027	}
8028	errorBody := bytes.NewReader(errorBuffer.Bytes())
8029
8030	errorCode := "UnknownError"
8031	errorMessage := errorCode
8032
8033	code := response.Header.Get("X-Amzn-ErrorType")
8034	if len(code) != 0 {
8035		errorCode = restjson.SanitizeErrorCode(code)
8036	}
8037
8038	var buff [1024]byte
8039	ringBuffer := smithyio.NewRingBuffer(buff[:])
8040
8041	body := io.TeeReader(errorBody, ringBuffer)
8042	decoder := json.NewDecoder(body)
8043	decoder.UseNumber()
8044	code, message, err := restjson.GetErrorInfo(decoder)
8045	if err != nil {
8046		var snapshot bytes.Buffer
8047		io.Copy(&snapshot, ringBuffer)
8048		err = &smithy.DeserializationError{
8049			Err:      fmt.Errorf("failed to decode response body, %w", err),
8050			Snapshot: snapshot.Bytes(),
8051		}
8052		return err
8053	}
8054
8055	errorBody.Seek(0, io.SeekStart)
8056	if len(code) != 0 {
8057		errorCode = restjson.SanitizeErrorCode(code)
8058	}
8059	if len(message) != 0 {
8060		errorMessage = message
8061	}
8062
8063	switch {
8064	case strings.EqualFold("InvalidParametersException", errorCode):
8065		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
8066
8067	case strings.EqualFold("ResourceNotFoundException", errorCode):
8068		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
8069
8070	default:
8071		genericError := &smithy.GenericAPIError{
8072			Code:    errorCode,
8073			Message: errorMessage,
8074		}
8075		return genericError
8076
8077	}
8078}
8079
8080type awsAwsjson11_deserializeOpListTagOptions struct {
8081}
8082
8083func (*awsAwsjson11_deserializeOpListTagOptions) ID() string {
8084	return "OperationDeserializer"
8085}
8086
8087func (m *awsAwsjson11_deserializeOpListTagOptions) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8088	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8089) {
8090	out, metadata, err = next.HandleDeserialize(ctx, in)
8091	if err != nil {
8092		return out, metadata, err
8093	}
8094
8095	response, ok := out.RawResponse.(*smithyhttp.Response)
8096	if !ok {
8097		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8098	}
8099
8100	if response.StatusCode < 200 || response.StatusCode >= 300 {
8101		return out, metadata, awsAwsjson11_deserializeOpErrorListTagOptions(response, &metadata)
8102	}
8103	output := &ListTagOptionsOutput{}
8104	out.Result = output
8105
8106	var buff [1024]byte
8107	ringBuffer := smithyio.NewRingBuffer(buff[:])
8108
8109	body := io.TeeReader(response.Body, ringBuffer)
8110	decoder := json.NewDecoder(body)
8111	decoder.UseNumber()
8112	var shape interface{}
8113	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8114		var snapshot bytes.Buffer
8115		io.Copy(&snapshot, ringBuffer)
8116		err = &smithy.DeserializationError{
8117			Err:      fmt.Errorf("failed to decode response body, %w", err),
8118			Snapshot: snapshot.Bytes(),
8119		}
8120		return out, metadata, err
8121	}
8122
8123	err = awsAwsjson11_deserializeOpDocumentListTagOptionsOutput(&output, shape)
8124	if err != nil {
8125		var snapshot bytes.Buffer
8126		io.Copy(&snapshot, ringBuffer)
8127		err = &smithy.DeserializationError{
8128			Err:      fmt.Errorf("failed to decode response body, %w", err),
8129			Snapshot: snapshot.Bytes(),
8130		}
8131		return out, metadata, err
8132	}
8133
8134	return out, metadata, err
8135}
8136
8137func awsAwsjson11_deserializeOpErrorListTagOptions(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8138	var errorBuffer bytes.Buffer
8139	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8140		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8141	}
8142	errorBody := bytes.NewReader(errorBuffer.Bytes())
8143
8144	errorCode := "UnknownError"
8145	errorMessage := errorCode
8146
8147	code := response.Header.Get("X-Amzn-ErrorType")
8148	if len(code) != 0 {
8149		errorCode = restjson.SanitizeErrorCode(code)
8150	}
8151
8152	var buff [1024]byte
8153	ringBuffer := smithyio.NewRingBuffer(buff[:])
8154
8155	body := io.TeeReader(errorBody, ringBuffer)
8156	decoder := json.NewDecoder(body)
8157	decoder.UseNumber()
8158	code, message, err := restjson.GetErrorInfo(decoder)
8159	if err != nil {
8160		var snapshot bytes.Buffer
8161		io.Copy(&snapshot, ringBuffer)
8162		err = &smithy.DeserializationError{
8163			Err:      fmt.Errorf("failed to decode response body, %w", err),
8164			Snapshot: snapshot.Bytes(),
8165		}
8166		return err
8167	}
8168
8169	errorBody.Seek(0, io.SeekStart)
8170	if len(code) != 0 {
8171		errorCode = restjson.SanitizeErrorCode(code)
8172	}
8173	if len(message) != 0 {
8174		errorMessage = message
8175	}
8176
8177	switch {
8178	case strings.EqualFold("InvalidParametersException", errorCode):
8179		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
8180
8181	case strings.EqualFold("TagOptionNotMigratedException", errorCode):
8182		return awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response, errorBody)
8183
8184	default:
8185		genericError := &smithy.GenericAPIError{
8186			Code:    errorCode,
8187			Message: errorMessage,
8188		}
8189		return genericError
8190
8191	}
8192}
8193
8194type awsAwsjson11_deserializeOpProvisionProduct struct {
8195}
8196
8197func (*awsAwsjson11_deserializeOpProvisionProduct) ID() string {
8198	return "OperationDeserializer"
8199}
8200
8201func (m *awsAwsjson11_deserializeOpProvisionProduct) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8202	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8203) {
8204	out, metadata, err = next.HandleDeserialize(ctx, in)
8205	if err != nil {
8206		return out, metadata, err
8207	}
8208
8209	response, ok := out.RawResponse.(*smithyhttp.Response)
8210	if !ok {
8211		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8212	}
8213
8214	if response.StatusCode < 200 || response.StatusCode >= 300 {
8215		return out, metadata, awsAwsjson11_deserializeOpErrorProvisionProduct(response, &metadata)
8216	}
8217	output := &ProvisionProductOutput{}
8218	out.Result = output
8219
8220	var buff [1024]byte
8221	ringBuffer := smithyio.NewRingBuffer(buff[:])
8222
8223	body := io.TeeReader(response.Body, ringBuffer)
8224	decoder := json.NewDecoder(body)
8225	decoder.UseNumber()
8226	var shape interface{}
8227	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8228		var snapshot bytes.Buffer
8229		io.Copy(&snapshot, ringBuffer)
8230		err = &smithy.DeserializationError{
8231			Err:      fmt.Errorf("failed to decode response body, %w", err),
8232			Snapshot: snapshot.Bytes(),
8233		}
8234		return out, metadata, err
8235	}
8236
8237	err = awsAwsjson11_deserializeOpDocumentProvisionProductOutput(&output, shape)
8238	if err != nil {
8239		var snapshot bytes.Buffer
8240		io.Copy(&snapshot, ringBuffer)
8241		err = &smithy.DeserializationError{
8242			Err:      fmt.Errorf("failed to decode response body, %w", err),
8243			Snapshot: snapshot.Bytes(),
8244		}
8245		return out, metadata, err
8246	}
8247
8248	return out, metadata, err
8249}
8250
8251func awsAwsjson11_deserializeOpErrorProvisionProduct(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8252	var errorBuffer bytes.Buffer
8253	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8254		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8255	}
8256	errorBody := bytes.NewReader(errorBuffer.Bytes())
8257
8258	errorCode := "UnknownError"
8259	errorMessage := errorCode
8260
8261	code := response.Header.Get("X-Amzn-ErrorType")
8262	if len(code) != 0 {
8263		errorCode = restjson.SanitizeErrorCode(code)
8264	}
8265
8266	var buff [1024]byte
8267	ringBuffer := smithyio.NewRingBuffer(buff[:])
8268
8269	body := io.TeeReader(errorBody, ringBuffer)
8270	decoder := json.NewDecoder(body)
8271	decoder.UseNumber()
8272	code, message, err := restjson.GetErrorInfo(decoder)
8273	if err != nil {
8274		var snapshot bytes.Buffer
8275		io.Copy(&snapshot, ringBuffer)
8276		err = &smithy.DeserializationError{
8277			Err:      fmt.Errorf("failed to decode response body, %w", err),
8278			Snapshot: snapshot.Bytes(),
8279		}
8280		return err
8281	}
8282
8283	errorBody.Seek(0, io.SeekStart)
8284	if len(code) != 0 {
8285		errorCode = restjson.SanitizeErrorCode(code)
8286	}
8287	if len(message) != 0 {
8288		errorMessage = message
8289	}
8290
8291	switch {
8292	case strings.EqualFold("DuplicateResourceException", errorCode):
8293		return awsAwsjson11_deserializeErrorDuplicateResourceException(response, errorBody)
8294
8295	case strings.EqualFold("InvalidParametersException", errorCode):
8296		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
8297
8298	case strings.EqualFold("ResourceNotFoundException", errorCode):
8299		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
8300
8301	default:
8302		genericError := &smithy.GenericAPIError{
8303			Code:    errorCode,
8304			Message: errorMessage,
8305		}
8306		return genericError
8307
8308	}
8309}
8310
8311type awsAwsjson11_deserializeOpRejectPortfolioShare struct {
8312}
8313
8314func (*awsAwsjson11_deserializeOpRejectPortfolioShare) ID() string {
8315	return "OperationDeserializer"
8316}
8317
8318func (m *awsAwsjson11_deserializeOpRejectPortfolioShare) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8319	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8320) {
8321	out, metadata, err = next.HandleDeserialize(ctx, in)
8322	if err != nil {
8323		return out, metadata, err
8324	}
8325
8326	response, ok := out.RawResponse.(*smithyhttp.Response)
8327	if !ok {
8328		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8329	}
8330
8331	if response.StatusCode < 200 || response.StatusCode >= 300 {
8332		return out, metadata, awsAwsjson11_deserializeOpErrorRejectPortfolioShare(response, &metadata)
8333	}
8334	output := &RejectPortfolioShareOutput{}
8335	out.Result = output
8336
8337	var buff [1024]byte
8338	ringBuffer := smithyio.NewRingBuffer(buff[:])
8339
8340	body := io.TeeReader(response.Body, ringBuffer)
8341	decoder := json.NewDecoder(body)
8342	decoder.UseNumber()
8343	var shape interface{}
8344	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8345		var snapshot bytes.Buffer
8346		io.Copy(&snapshot, ringBuffer)
8347		err = &smithy.DeserializationError{
8348			Err:      fmt.Errorf("failed to decode response body, %w", err),
8349			Snapshot: snapshot.Bytes(),
8350		}
8351		return out, metadata, err
8352	}
8353
8354	err = awsAwsjson11_deserializeOpDocumentRejectPortfolioShareOutput(&output, shape)
8355	if err != nil {
8356		var snapshot bytes.Buffer
8357		io.Copy(&snapshot, ringBuffer)
8358		err = &smithy.DeserializationError{
8359			Err:      fmt.Errorf("failed to decode response body, %w", err),
8360			Snapshot: snapshot.Bytes(),
8361		}
8362		return out, metadata, err
8363	}
8364
8365	return out, metadata, err
8366}
8367
8368func awsAwsjson11_deserializeOpErrorRejectPortfolioShare(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8369	var errorBuffer bytes.Buffer
8370	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8371		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8372	}
8373	errorBody := bytes.NewReader(errorBuffer.Bytes())
8374
8375	errorCode := "UnknownError"
8376	errorMessage := errorCode
8377
8378	code := response.Header.Get("X-Amzn-ErrorType")
8379	if len(code) != 0 {
8380		errorCode = restjson.SanitizeErrorCode(code)
8381	}
8382
8383	var buff [1024]byte
8384	ringBuffer := smithyio.NewRingBuffer(buff[:])
8385
8386	body := io.TeeReader(errorBody, ringBuffer)
8387	decoder := json.NewDecoder(body)
8388	decoder.UseNumber()
8389	code, message, err := restjson.GetErrorInfo(decoder)
8390	if err != nil {
8391		var snapshot bytes.Buffer
8392		io.Copy(&snapshot, ringBuffer)
8393		err = &smithy.DeserializationError{
8394			Err:      fmt.Errorf("failed to decode response body, %w", err),
8395			Snapshot: snapshot.Bytes(),
8396		}
8397		return err
8398	}
8399
8400	errorBody.Seek(0, io.SeekStart)
8401	if len(code) != 0 {
8402		errorCode = restjson.SanitizeErrorCode(code)
8403	}
8404	if len(message) != 0 {
8405		errorMessage = message
8406	}
8407
8408	switch {
8409	case strings.EqualFold("ResourceNotFoundException", errorCode):
8410		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
8411
8412	default:
8413		genericError := &smithy.GenericAPIError{
8414			Code:    errorCode,
8415			Message: errorMessage,
8416		}
8417		return genericError
8418
8419	}
8420}
8421
8422type awsAwsjson11_deserializeOpScanProvisionedProducts struct {
8423}
8424
8425func (*awsAwsjson11_deserializeOpScanProvisionedProducts) ID() string {
8426	return "OperationDeserializer"
8427}
8428
8429func (m *awsAwsjson11_deserializeOpScanProvisionedProducts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8430	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8431) {
8432	out, metadata, err = next.HandleDeserialize(ctx, in)
8433	if err != nil {
8434		return out, metadata, err
8435	}
8436
8437	response, ok := out.RawResponse.(*smithyhttp.Response)
8438	if !ok {
8439		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8440	}
8441
8442	if response.StatusCode < 200 || response.StatusCode >= 300 {
8443		return out, metadata, awsAwsjson11_deserializeOpErrorScanProvisionedProducts(response, &metadata)
8444	}
8445	output := &ScanProvisionedProductsOutput{}
8446	out.Result = output
8447
8448	var buff [1024]byte
8449	ringBuffer := smithyio.NewRingBuffer(buff[:])
8450
8451	body := io.TeeReader(response.Body, ringBuffer)
8452	decoder := json.NewDecoder(body)
8453	decoder.UseNumber()
8454	var shape interface{}
8455	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8456		var snapshot bytes.Buffer
8457		io.Copy(&snapshot, ringBuffer)
8458		err = &smithy.DeserializationError{
8459			Err:      fmt.Errorf("failed to decode response body, %w", err),
8460			Snapshot: snapshot.Bytes(),
8461		}
8462		return out, metadata, err
8463	}
8464
8465	err = awsAwsjson11_deserializeOpDocumentScanProvisionedProductsOutput(&output, shape)
8466	if err != nil {
8467		var snapshot bytes.Buffer
8468		io.Copy(&snapshot, ringBuffer)
8469		err = &smithy.DeserializationError{
8470			Err:      fmt.Errorf("failed to decode response body, %w", err),
8471			Snapshot: snapshot.Bytes(),
8472		}
8473		return out, metadata, err
8474	}
8475
8476	return out, metadata, err
8477}
8478
8479func awsAwsjson11_deserializeOpErrorScanProvisionedProducts(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8480	var errorBuffer bytes.Buffer
8481	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8482		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8483	}
8484	errorBody := bytes.NewReader(errorBuffer.Bytes())
8485
8486	errorCode := "UnknownError"
8487	errorMessage := errorCode
8488
8489	code := response.Header.Get("X-Amzn-ErrorType")
8490	if len(code) != 0 {
8491		errorCode = restjson.SanitizeErrorCode(code)
8492	}
8493
8494	var buff [1024]byte
8495	ringBuffer := smithyio.NewRingBuffer(buff[:])
8496
8497	body := io.TeeReader(errorBody, ringBuffer)
8498	decoder := json.NewDecoder(body)
8499	decoder.UseNumber()
8500	code, message, err := restjson.GetErrorInfo(decoder)
8501	if err != nil {
8502		var snapshot bytes.Buffer
8503		io.Copy(&snapshot, ringBuffer)
8504		err = &smithy.DeserializationError{
8505			Err:      fmt.Errorf("failed to decode response body, %w", err),
8506			Snapshot: snapshot.Bytes(),
8507		}
8508		return err
8509	}
8510
8511	errorBody.Seek(0, io.SeekStart)
8512	if len(code) != 0 {
8513		errorCode = restjson.SanitizeErrorCode(code)
8514	}
8515	if len(message) != 0 {
8516		errorMessage = message
8517	}
8518
8519	switch {
8520	case strings.EqualFold("InvalidParametersException", errorCode):
8521		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
8522
8523	default:
8524		genericError := &smithy.GenericAPIError{
8525			Code:    errorCode,
8526			Message: errorMessage,
8527		}
8528		return genericError
8529
8530	}
8531}
8532
8533type awsAwsjson11_deserializeOpSearchProducts struct {
8534}
8535
8536func (*awsAwsjson11_deserializeOpSearchProducts) ID() string {
8537	return "OperationDeserializer"
8538}
8539
8540func (m *awsAwsjson11_deserializeOpSearchProducts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8541	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8542) {
8543	out, metadata, err = next.HandleDeserialize(ctx, in)
8544	if err != nil {
8545		return out, metadata, err
8546	}
8547
8548	response, ok := out.RawResponse.(*smithyhttp.Response)
8549	if !ok {
8550		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8551	}
8552
8553	if response.StatusCode < 200 || response.StatusCode >= 300 {
8554		return out, metadata, awsAwsjson11_deserializeOpErrorSearchProducts(response, &metadata)
8555	}
8556	output := &SearchProductsOutput{}
8557	out.Result = output
8558
8559	var buff [1024]byte
8560	ringBuffer := smithyio.NewRingBuffer(buff[:])
8561
8562	body := io.TeeReader(response.Body, ringBuffer)
8563	decoder := json.NewDecoder(body)
8564	decoder.UseNumber()
8565	var shape interface{}
8566	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8567		var snapshot bytes.Buffer
8568		io.Copy(&snapshot, ringBuffer)
8569		err = &smithy.DeserializationError{
8570			Err:      fmt.Errorf("failed to decode response body, %w", err),
8571			Snapshot: snapshot.Bytes(),
8572		}
8573		return out, metadata, err
8574	}
8575
8576	err = awsAwsjson11_deserializeOpDocumentSearchProductsOutput(&output, shape)
8577	if err != nil {
8578		var snapshot bytes.Buffer
8579		io.Copy(&snapshot, ringBuffer)
8580		err = &smithy.DeserializationError{
8581			Err:      fmt.Errorf("failed to decode response body, %w", err),
8582			Snapshot: snapshot.Bytes(),
8583		}
8584		return out, metadata, err
8585	}
8586
8587	return out, metadata, err
8588}
8589
8590func awsAwsjson11_deserializeOpErrorSearchProducts(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8591	var errorBuffer bytes.Buffer
8592	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8593		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8594	}
8595	errorBody := bytes.NewReader(errorBuffer.Bytes())
8596
8597	errorCode := "UnknownError"
8598	errorMessage := errorCode
8599
8600	code := response.Header.Get("X-Amzn-ErrorType")
8601	if len(code) != 0 {
8602		errorCode = restjson.SanitizeErrorCode(code)
8603	}
8604
8605	var buff [1024]byte
8606	ringBuffer := smithyio.NewRingBuffer(buff[:])
8607
8608	body := io.TeeReader(errorBody, ringBuffer)
8609	decoder := json.NewDecoder(body)
8610	decoder.UseNumber()
8611	code, message, err := restjson.GetErrorInfo(decoder)
8612	if err != nil {
8613		var snapshot bytes.Buffer
8614		io.Copy(&snapshot, ringBuffer)
8615		err = &smithy.DeserializationError{
8616			Err:      fmt.Errorf("failed to decode response body, %w", err),
8617			Snapshot: snapshot.Bytes(),
8618		}
8619		return err
8620	}
8621
8622	errorBody.Seek(0, io.SeekStart)
8623	if len(code) != 0 {
8624		errorCode = restjson.SanitizeErrorCode(code)
8625	}
8626	if len(message) != 0 {
8627		errorMessage = message
8628	}
8629
8630	switch {
8631	case strings.EqualFold("InvalidParametersException", errorCode):
8632		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
8633
8634	default:
8635		genericError := &smithy.GenericAPIError{
8636			Code:    errorCode,
8637			Message: errorMessage,
8638		}
8639		return genericError
8640
8641	}
8642}
8643
8644type awsAwsjson11_deserializeOpSearchProductsAsAdmin struct {
8645}
8646
8647func (*awsAwsjson11_deserializeOpSearchProductsAsAdmin) ID() string {
8648	return "OperationDeserializer"
8649}
8650
8651func (m *awsAwsjson11_deserializeOpSearchProductsAsAdmin) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8652	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8653) {
8654	out, metadata, err = next.HandleDeserialize(ctx, in)
8655	if err != nil {
8656		return out, metadata, err
8657	}
8658
8659	response, ok := out.RawResponse.(*smithyhttp.Response)
8660	if !ok {
8661		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8662	}
8663
8664	if response.StatusCode < 200 || response.StatusCode >= 300 {
8665		return out, metadata, awsAwsjson11_deserializeOpErrorSearchProductsAsAdmin(response, &metadata)
8666	}
8667	output := &SearchProductsAsAdminOutput{}
8668	out.Result = output
8669
8670	var buff [1024]byte
8671	ringBuffer := smithyio.NewRingBuffer(buff[:])
8672
8673	body := io.TeeReader(response.Body, ringBuffer)
8674	decoder := json.NewDecoder(body)
8675	decoder.UseNumber()
8676	var shape interface{}
8677	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8678		var snapshot bytes.Buffer
8679		io.Copy(&snapshot, ringBuffer)
8680		err = &smithy.DeserializationError{
8681			Err:      fmt.Errorf("failed to decode response body, %w", err),
8682			Snapshot: snapshot.Bytes(),
8683		}
8684		return out, metadata, err
8685	}
8686
8687	err = awsAwsjson11_deserializeOpDocumentSearchProductsAsAdminOutput(&output, shape)
8688	if err != nil {
8689		var snapshot bytes.Buffer
8690		io.Copy(&snapshot, ringBuffer)
8691		err = &smithy.DeserializationError{
8692			Err:      fmt.Errorf("failed to decode response body, %w", err),
8693			Snapshot: snapshot.Bytes(),
8694		}
8695		return out, metadata, err
8696	}
8697
8698	return out, metadata, err
8699}
8700
8701func awsAwsjson11_deserializeOpErrorSearchProductsAsAdmin(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8702	var errorBuffer bytes.Buffer
8703	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8704		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8705	}
8706	errorBody := bytes.NewReader(errorBuffer.Bytes())
8707
8708	errorCode := "UnknownError"
8709	errorMessage := errorCode
8710
8711	code := response.Header.Get("X-Amzn-ErrorType")
8712	if len(code) != 0 {
8713		errorCode = restjson.SanitizeErrorCode(code)
8714	}
8715
8716	var buff [1024]byte
8717	ringBuffer := smithyio.NewRingBuffer(buff[:])
8718
8719	body := io.TeeReader(errorBody, ringBuffer)
8720	decoder := json.NewDecoder(body)
8721	decoder.UseNumber()
8722	code, message, err := restjson.GetErrorInfo(decoder)
8723	if err != nil {
8724		var snapshot bytes.Buffer
8725		io.Copy(&snapshot, ringBuffer)
8726		err = &smithy.DeserializationError{
8727			Err:      fmt.Errorf("failed to decode response body, %w", err),
8728			Snapshot: snapshot.Bytes(),
8729		}
8730		return err
8731	}
8732
8733	errorBody.Seek(0, io.SeekStart)
8734	if len(code) != 0 {
8735		errorCode = restjson.SanitizeErrorCode(code)
8736	}
8737	if len(message) != 0 {
8738		errorMessage = message
8739	}
8740
8741	switch {
8742	case strings.EqualFold("InvalidParametersException", errorCode):
8743		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
8744
8745	case strings.EqualFold("ResourceNotFoundException", errorCode):
8746		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
8747
8748	default:
8749		genericError := &smithy.GenericAPIError{
8750			Code:    errorCode,
8751			Message: errorMessage,
8752		}
8753		return genericError
8754
8755	}
8756}
8757
8758type awsAwsjson11_deserializeOpSearchProvisionedProducts struct {
8759}
8760
8761func (*awsAwsjson11_deserializeOpSearchProvisionedProducts) ID() string {
8762	return "OperationDeserializer"
8763}
8764
8765func (m *awsAwsjson11_deserializeOpSearchProvisionedProducts) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8766	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8767) {
8768	out, metadata, err = next.HandleDeserialize(ctx, in)
8769	if err != nil {
8770		return out, metadata, err
8771	}
8772
8773	response, ok := out.RawResponse.(*smithyhttp.Response)
8774	if !ok {
8775		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8776	}
8777
8778	if response.StatusCode < 200 || response.StatusCode >= 300 {
8779		return out, metadata, awsAwsjson11_deserializeOpErrorSearchProvisionedProducts(response, &metadata)
8780	}
8781	output := &SearchProvisionedProductsOutput{}
8782	out.Result = output
8783
8784	var buff [1024]byte
8785	ringBuffer := smithyio.NewRingBuffer(buff[:])
8786
8787	body := io.TeeReader(response.Body, ringBuffer)
8788	decoder := json.NewDecoder(body)
8789	decoder.UseNumber()
8790	var shape interface{}
8791	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8792		var snapshot bytes.Buffer
8793		io.Copy(&snapshot, ringBuffer)
8794		err = &smithy.DeserializationError{
8795			Err:      fmt.Errorf("failed to decode response body, %w", err),
8796			Snapshot: snapshot.Bytes(),
8797		}
8798		return out, metadata, err
8799	}
8800
8801	err = awsAwsjson11_deserializeOpDocumentSearchProvisionedProductsOutput(&output, shape)
8802	if err != nil {
8803		var snapshot bytes.Buffer
8804		io.Copy(&snapshot, ringBuffer)
8805		err = &smithy.DeserializationError{
8806			Err:      fmt.Errorf("failed to decode response body, %w", err),
8807			Snapshot: snapshot.Bytes(),
8808		}
8809		return out, metadata, err
8810	}
8811
8812	return out, metadata, err
8813}
8814
8815func awsAwsjson11_deserializeOpErrorSearchProvisionedProducts(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8816	var errorBuffer bytes.Buffer
8817	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8818		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8819	}
8820	errorBody := bytes.NewReader(errorBuffer.Bytes())
8821
8822	errorCode := "UnknownError"
8823	errorMessage := errorCode
8824
8825	code := response.Header.Get("X-Amzn-ErrorType")
8826	if len(code) != 0 {
8827		errorCode = restjson.SanitizeErrorCode(code)
8828	}
8829
8830	var buff [1024]byte
8831	ringBuffer := smithyio.NewRingBuffer(buff[:])
8832
8833	body := io.TeeReader(errorBody, ringBuffer)
8834	decoder := json.NewDecoder(body)
8835	decoder.UseNumber()
8836	code, message, err := restjson.GetErrorInfo(decoder)
8837	if err != nil {
8838		var snapshot bytes.Buffer
8839		io.Copy(&snapshot, ringBuffer)
8840		err = &smithy.DeserializationError{
8841			Err:      fmt.Errorf("failed to decode response body, %w", err),
8842			Snapshot: snapshot.Bytes(),
8843		}
8844		return err
8845	}
8846
8847	errorBody.Seek(0, io.SeekStart)
8848	if len(code) != 0 {
8849		errorCode = restjson.SanitizeErrorCode(code)
8850	}
8851	if len(message) != 0 {
8852		errorMessage = message
8853	}
8854
8855	switch {
8856	case strings.EqualFold("InvalidParametersException", errorCode):
8857		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
8858
8859	default:
8860		genericError := &smithy.GenericAPIError{
8861			Code:    errorCode,
8862			Message: errorMessage,
8863		}
8864		return genericError
8865
8866	}
8867}
8868
8869type awsAwsjson11_deserializeOpTerminateProvisionedProduct struct {
8870}
8871
8872func (*awsAwsjson11_deserializeOpTerminateProvisionedProduct) ID() string {
8873	return "OperationDeserializer"
8874}
8875
8876func (m *awsAwsjson11_deserializeOpTerminateProvisionedProduct) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8877	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8878) {
8879	out, metadata, err = next.HandleDeserialize(ctx, in)
8880	if err != nil {
8881		return out, metadata, err
8882	}
8883
8884	response, ok := out.RawResponse.(*smithyhttp.Response)
8885	if !ok {
8886		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8887	}
8888
8889	if response.StatusCode < 200 || response.StatusCode >= 300 {
8890		return out, metadata, awsAwsjson11_deserializeOpErrorTerminateProvisionedProduct(response, &metadata)
8891	}
8892	output := &TerminateProvisionedProductOutput{}
8893	out.Result = output
8894
8895	var buff [1024]byte
8896	ringBuffer := smithyio.NewRingBuffer(buff[:])
8897
8898	body := io.TeeReader(response.Body, ringBuffer)
8899	decoder := json.NewDecoder(body)
8900	decoder.UseNumber()
8901	var shape interface{}
8902	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
8903		var snapshot bytes.Buffer
8904		io.Copy(&snapshot, ringBuffer)
8905		err = &smithy.DeserializationError{
8906			Err:      fmt.Errorf("failed to decode response body, %w", err),
8907			Snapshot: snapshot.Bytes(),
8908		}
8909		return out, metadata, err
8910	}
8911
8912	err = awsAwsjson11_deserializeOpDocumentTerminateProvisionedProductOutput(&output, shape)
8913	if err != nil {
8914		var snapshot bytes.Buffer
8915		io.Copy(&snapshot, ringBuffer)
8916		err = &smithy.DeserializationError{
8917			Err:      fmt.Errorf("failed to decode response body, %w", err),
8918			Snapshot: snapshot.Bytes(),
8919		}
8920		return out, metadata, err
8921	}
8922
8923	return out, metadata, err
8924}
8925
8926func awsAwsjson11_deserializeOpErrorTerminateProvisionedProduct(response *smithyhttp.Response, metadata *middleware.Metadata) error {
8927	var errorBuffer bytes.Buffer
8928	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
8929		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
8930	}
8931	errorBody := bytes.NewReader(errorBuffer.Bytes())
8932
8933	errorCode := "UnknownError"
8934	errorMessage := errorCode
8935
8936	code := response.Header.Get("X-Amzn-ErrorType")
8937	if len(code) != 0 {
8938		errorCode = restjson.SanitizeErrorCode(code)
8939	}
8940
8941	var buff [1024]byte
8942	ringBuffer := smithyio.NewRingBuffer(buff[:])
8943
8944	body := io.TeeReader(errorBody, ringBuffer)
8945	decoder := json.NewDecoder(body)
8946	decoder.UseNumber()
8947	code, message, err := restjson.GetErrorInfo(decoder)
8948	if err != nil {
8949		var snapshot bytes.Buffer
8950		io.Copy(&snapshot, ringBuffer)
8951		err = &smithy.DeserializationError{
8952			Err:      fmt.Errorf("failed to decode response body, %w", err),
8953			Snapshot: snapshot.Bytes(),
8954		}
8955		return err
8956	}
8957
8958	errorBody.Seek(0, io.SeekStart)
8959	if len(code) != 0 {
8960		errorCode = restjson.SanitizeErrorCode(code)
8961	}
8962	if len(message) != 0 {
8963		errorMessage = message
8964	}
8965
8966	switch {
8967	case strings.EqualFold("ResourceNotFoundException", errorCode):
8968		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
8969
8970	default:
8971		genericError := &smithy.GenericAPIError{
8972			Code:    errorCode,
8973			Message: errorMessage,
8974		}
8975		return genericError
8976
8977	}
8978}
8979
8980type awsAwsjson11_deserializeOpUpdateConstraint struct {
8981}
8982
8983func (*awsAwsjson11_deserializeOpUpdateConstraint) ID() string {
8984	return "OperationDeserializer"
8985}
8986
8987func (m *awsAwsjson11_deserializeOpUpdateConstraint) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
8988	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
8989) {
8990	out, metadata, err = next.HandleDeserialize(ctx, in)
8991	if err != nil {
8992		return out, metadata, err
8993	}
8994
8995	response, ok := out.RawResponse.(*smithyhttp.Response)
8996	if !ok {
8997		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
8998	}
8999
9000	if response.StatusCode < 200 || response.StatusCode >= 300 {
9001		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateConstraint(response, &metadata)
9002	}
9003	output := &UpdateConstraintOutput{}
9004	out.Result = output
9005
9006	var buff [1024]byte
9007	ringBuffer := smithyio.NewRingBuffer(buff[:])
9008
9009	body := io.TeeReader(response.Body, ringBuffer)
9010	decoder := json.NewDecoder(body)
9011	decoder.UseNumber()
9012	var shape interface{}
9013	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9014		var snapshot bytes.Buffer
9015		io.Copy(&snapshot, ringBuffer)
9016		err = &smithy.DeserializationError{
9017			Err:      fmt.Errorf("failed to decode response body, %w", err),
9018			Snapshot: snapshot.Bytes(),
9019		}
9020		return out, metadata, err
9021	}
9022
9023	err = awsAwsjson11_deserializeOpDocumentUpdateConstraintOutput(&output, shape)
9024	if err != nil {
9025		var snapshot bytes.Buffer
9026		io.Copy(&snapshot, ringBuffer)
9027		err = &smithy.DeserializationError{
9028			Err:      fmt.Errorf("failed to decode response body, %w", err),
9029			Snapshot: snapshot.Bytes(),
9030		}
9031		return out, metadata, err
9032	}
9033
9034	return out, metadata, err
9035}
9036
9037func awsAwsjson11_deserializeOpErrorUpdateConstraint(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9038	var errorBuffer bytes.Buffer
9039	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9040		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9041	}
9042	errorBody := bytes.NewReader(errorBuffer.Bytes())
9043
9044	errorCode := "UnknownError"
9045	errorMessage := errorCode
9046
9047	code := response.Header.Get("X-Amzn-ErrorType")
9048	if len(code) != 0 {
9049		errorCode = restjson.SanitizeErrorCode(code)
9050	}
9051
9052	var buff [1024]byte
9053	ringBuffer := smithyio.NewRingBuffer(buff[:])
9054
9055	body := io.TeeReader(errorBody, ringBuffer)
9056	decoder := json.NewDecoder(body)
9057	decoder.UseNumber()
9058	code, message, err := restjson.GetErrorInfo(decoder)
9059	if err != nil {
9060		var snapshot bytes.Buffer
9061		io.Copy(&snapshot, ringBuffer)
9062		err = &smithy.DeserializationError{
9063			Err:      fmt.Errorf("failed to decode response body, %w", err),
9064			Snapshot: snapshot.Bytes(),
9065		}
9066		return err
9067	}
9068
9069	errorBody.Seek(0, io.SeekStart)
9070	if len(code) != 0 {
9071		errorCode = restjson.SanitizeErrorCode(code)
9072	}
9073	if len(message) != 0 {
9074		errorMessage = message
9075	}
9076
9077	switch {
9078	case strings.EqualFold("InvalidParametersException", errorCode):
9079		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
9080
9081	case strings.EqualFold("ResourceNotFoundException", errorCode):
9082		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
9083
9084	default:
9085		genericError := &smithy.GenericAPIError{
9086			Code:    errorCode,
9087			Message: errorMessage,
9088		}
9089		return genericError
9090
9091	}
9092}
9093
9094type awsAwsjson11_deserializeOpUpdatePortfolio struct {
9095}
9096
9097func (*awsAwsjson11_deserializeOpUpdatePortfolio) ID() string {
9098	return "OperationDeserializer"
9099}
9100
9101func (m *awsAwsjson11_deserializeOpUpdatePortfolio) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9102	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9103) {
9104	out, metadata, err = next.HandleDeserialize(ctx, in)
9105	if err != nil {
9106		return out, metadata, err
9107	}
9108
9109	response, ok := out.RawResponse.(*smithyhttp.Response)
9110	if !ok {
9111		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9112	}
9113
9114	if response.StatusCode < 200 || response.StatusCode >= 300 {
9115		return out, metadata, awsAwsjson11_deserializeOpErrorUpdatePortfolio(response, &metadata)
9116	}
9117	output := &UpdatePortfolioOutput{}
9118	out.Result = output
9119
9120	var buff [1024]byte
9121	ringBuffer := smithyio.NewRingBuffer(buff[:])
9122
9123	body := io.TeeReader(response.Body, ringBuffer)
9124	decoder := json.NewDecoder(body)
9125	decoder.UseNumber()
9126	var shape interface{}
9127	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9128		var snapshot bytes.Buffer
9129		io.Copy(&snapshot, ringBuffer)
9130		err = &smithy.DeserializationError{
9131			Err:      fmt.Errorf("failed to decode response body, %w", err),
9132			Snapshot: snapshot.Bytes(),
9133		}
9134		return out, metadata, err
9135	}
9136
9137	err = awsAwsjson11_deserializeOpDocumentUpdatePortfolioOutput(&output, shape)
9138	if err != nil {
9139		var snapshot bytes.Buffer
9140		io.Copy(&snapshot, ringBuffer)
9141		err = &smithy.DeserializationError{
9142			Err:      fmt.Errorf("failed to decode response body, %w", err),
9143			Snapshot: snapshot.Bytes(),
9144		}
9145		return out, metadata, err
9146	}
9147
9148	return out, metadata, err
9149}
9150
9151func awsAwsjson11_deserializeOpErrorUpdatePortfolio(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9152	var errorBuffer bytes.Buffer
9153	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9154		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9155	}
9156	errorBody := bytes.NewReader(errorBuffer.Bytes())
9157
9158	errorCode := "UnknownError"
9159	errorMessage := errorCode
9160
9161	code := response.Header.Get("X-Amzn-ErrorType")
9162	if len(code) != 0 {
9163		errorCode = restjson.SanitizeErrorCode(code)
9164	}
9165
9166	var buff [1024]byte
9167	ringBuffer := smithyio.NewRingBuffer(buff[:])
9168
9169	body := io.TeeReader(errorBody, ringBuffer)
9170	decoder := json.NewDecoder(body)
9171	decoder.UseNumber()
9172	code, message, err := restjson.GetErrorInfo(decoder)
9173	if err != nil {
9174		var snapshot bytes.Buffer
9175		io.Copy(&snapshot, ringBuffer)
9176		err = &smithy.DeserializationError{
9177			Err:      fmt.Errorf("failed to decode response body, %w", err),
9178			Snapshot: snapshot.Bytes(),
9179		}
9180		return err
9181	}
9182
9183	errorBody.Seek(0, io.SeekStart)
9184	if len(code) != 0 {
9185		errorCode = restjson.SanitizeErrorCode(code)
9186	}
9187	if len(message) != 0 {
9188		errorMessage = message
9189	}
9190
9191	switch {
9192	case strings.EqualFold("InvalidParametersException", errorCode):
9193		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
9194
9195	case strings.EqualFold("LimitExceededException", errorCode):
9196		return awsAwsjson11_deserializeErrorLimitExceededException(response, errorBody)
9197
9198	case strings.EqualFold("ResourceNotFoundException", errorCode):
9199		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
9200
9201	case strings.EqualFold("TagOptionNotMigratedException", errorCode):
9202		return awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response, errorBody)
9203
9204	default:
9205		genericError := &smithy.GenericAPIError{
9206			Code:    errorCode,
9207			Message: errorMessage,
9208		}
9209		return genericError
9210
9211	}
9212}
9213
9214type awsAwsjson11_deserializeOpUpdatePortfolioShare struct {
9215}
9216
9217func (*awsAwsjson11_deserializeOpUpdatePortfolioShare) ID() string {
9218	return "OperationDeserializer"
9219}
9220
9221func (m *awsAwsjson11_deserializeOpUpdatePortfolioShare) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9222	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9223) {
9224	out, metadata, err = next.HandleDeserialize(ctx, in)
9225	if err != nil {
9226		return out, metadata, err
9227	}
9228
9229	response, ok := out.RawResponse.(*smithyhttp.Response)
9230	if !ok {
9231		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9232	}
9233
9234	if response.StatusCode < 200 || response.StatusCode >= 300 {
9235		return out, metadata, awsAwsjson11_deserializeOpErrorUpdatePortfolioShare(response, &metadata)
9236	}
9237	output := &UpdatePortfolioShareOutput{}
9238	out.Result = output
9239
9240	var buff [1024]byte
9241	ringBuffer := smithyio.NewRingBuffer(buff[:])
9242
9243	body := io.TeeReader(response.Body, ringBuffer)
9244	decoder := json.NewDecoder(body)
9245	decoder.UseNumber()
9246	var shape interface{}
9247	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9248		var snapshot bytes.Buffer
9249		io.Copy(&snapshot, ringBuffer)
9250		err = &smithy.DeserializationError{
9251			Err:      fmt.Errorf("failed to decode response body, %w", err),
9252			Snapshot: snapshot.Bytes(),
9253		}
9254		return out, metadata, err
9255	}
9256
9257	err = awsAwsjson11_deserializeOpDocumentUpdatePortfolioShareOutput(&output, shape)
9258	if err != nil {
9259		var snapshot bytes.Buffer
9260		io.Copy(&snapshot, ringBuffer)
9261		err = &smithy.DeserializationError{
9262			Err:      fmt.Errorf("failed to decode response body, %w", err),
9263			Snapshot: snapshot.Bytes(),
9264		}
9265		return out, metadata, err
9266	}
9267
9268	return out, metadata, err
9269}
9270
9271func awsAwsjson11_deserializeOpErrorUpdatePortfolioShare(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9272	var errorBuffer bytes.Buffer
9273	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9274		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9275	}
9276	errorBody := bytes.NewReader(errorBuffer.Bytes())
9277
9278	errorCode := "UnknownError"
9279	errorMessage := errorCode
9280
9281	code := response.Header.Get("X-Amzn-ErrorType")
9282	if len(code) != 0 {
9283		errorCode = restjson.SanitizeErrorCode(code)
9284	}
9285
9286	var buff [1024]byte
9287	ringBuffer := smithyio.NewRingBuffer(buff[:])
9288
9289	body := io.TeeReader(errorBody, ringBuffer)
9290	decoder := json.NewDecoder(body)
9291	decoder.UseNumber()
9292	code, message, err := restjson.GetErrorInfo(decoder)
9293	if err != nil {
9294		var snapshot bytes.Buffer
9295		io.Copy(&snapshot, ringBuffer)
9296		err = &smithy.DeserializationError{
9297			Err:      fmt.Errorf("failed to decode response body, %w", err),
9298			Snapshot: snapshot.Bytes(),
9299		}
9300		return err
9301	}
9302
9303	errorBody.Seek(0, io.SeekStart)
9304	if len(code) != 0 {
9305		errorCode = restjson.SanitizeErrorCode(code)
9306	}
9307	if len(message) != 0 {
9308		errorMessage = message
9309	}
9310
9311	switch {
9312	case strings.EqualFold("InvalidParametersException", errorCode):
9313		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
9314
9315	case strings.EqualFold("InvalidStateException", errorCode):
9316		return awsAwsjson11_deserializeErrorInvalidStateException(response, errorBody)
9317
9318	case strings.EqualFold("OperationNotSupportedException", errorCode):
9319		return awsAwsjson11_deserializeErrorOperationNotSupportedException(response, errorBody)
9320
9321	case strings.EqualFold("ResourceNotFoundException", errorCode):
9322		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
9323
9324	default:
9325		genericError := &smithy.GenericAPIError{
9326			Code:    errorCode,
9327			Message: errorMessage,
9328		}
9329		return genericError
9330
9331	}
9332}
9333
9334type awsAwsjson11_deserializeOpUpdateProduct struct {
9335}
9336
9337func (*awsAwsjson11_deserializeOpUpdateProduct) ID() string {
9338	return "OperationDeserializer"
9339}
9340
9341func (m *awsAwsjson11_deserializeOpUpdateProduct) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9342	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9343) {
9344	out, metadata, err = next.HandleDeserialize(ctx, in)
9345	if err != nil {
9346		return out, metadata, err
9347	}
9348
9349	response, ok := out.RawResponse.(*smithyhttp.Response)
9350	if !ok {
9351		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9352	}
9353
9354	if response.StatusCode < 200 || response.StatusCode >= 300 {
9355		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateProduct(response, &metadata)
9356	}
9357	output := &UpdateProductOutput{}
9358	out.Result = output
9359
9360	var buff [1024]byte
9361	ringBuffer := smithyio.NewRingBuffer(buff[:])
9362
9363	body := io.TeeReader(response.Body, ringBuffer)
9364	decoder := json.NewDecoder(body)
9365	decoder.UseNumber()
9366	var shape interface{}
9367	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9368		var snapshot bytes.Buffer
9369		io.Copy(&snapshot, ringBuffer)
9370		err = &smithy.DeserializationError{
9371			Err:      fmt.Errorf("failed to decode response body, %w", err),
9372			Snapshot: snapshot.Bytes(),
9373		}
9374		return out, metadata, err
9375	}
9376
9377	err = awsAwsjson11_deserializeOpDocumentUpdateProductOutput(&output, shape)
9378	if err != nil {
9379		var snapshot bytes.Buffer
9380		io.Copy(&snapshot, ringBuffer)
9381		err = &smithy.DeserializationError{
9382			Err:      fmt.Errorf("failed to decode response body, %w", err),
9383			Snapshot: snapshot.Bytes(),
9384		}
9385		return out, metadata, err
9386	}
9387
9388	return out, metadata, err
9389}
9390
9391func awsAwsjson11_deserializeOpErrorUpdateProduct(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9392	var errorBuffer bytes.Buffer
9393	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9394		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9395	}
9396	errorBody := bytes.NewReader(errorBuffer.Bytes())
9397
9398	errorCode := "UnknownError"
9399	errorMessage := errorCode
9400
9401	code := response.Header.Get("X-Amzn-ErrorType")
9402	if len(code) != 0 {
9403		errorCode = restjson.SanitizeErrorCode(code)
9404	}
9405
9406	var buff [1024]byte
9407	ringBuffer := smithyio.NewRingBuffer(buff[:])
9408
9409	body := io.TeeReader(errorBody, ringBuffer)
9410	decoder := json.NewDecoder(body)
9411	decoder.UseNumber()
9412	code, message, err := restjson.GetErrorInfo(decoder)
9413	if err != nil {
9414		var snapshot bytes.Buffer
9415		io.Copy(&snapshot, ringBuffer)
9416		err = &smithy.DeserializationError{
9417			Err:      fmt.Errorf("failed to decode response body, %w", err),
9418			Snapshot: snapshot.Bytes(),
9419		}
9420		return err
9421	}
9422
9423	errorBody.Seek(0, io.SeekStart)
9424	if len(code) != 0 {
9425		errorCode = restjson.SanitizeErrorCode(code)
9426	}
9427	if len(message) != 0 {
9428		errorMessage = message
9429	}
9430
9431	switch {
9432	case strings.EqualFold("InvalidParametersException", errorCode):
9433		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
9434
9435	case strings.EqualFold("ResourceNotFoundException", errorCode):
9436		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
9437
9438	case strings.EqualFold("TagOptionNotMigratedException", errorCode):
9439		return awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response, errorBody)
9440
9441	default:
9442		genericError := &smithy.GenericAPIError{
9443			Code:    errorCode,
9444			Message: errorMessage,
9445		}
9446		return genericError
9447
9448	}
9449}
9450
9451type awsAwsjson11_deserializeOpUpdateProvisionedProduct struct {
9452}
9453
9454func (*awsAwsjson11_deserializeOpUpdateProvisionedProduct) ID() string {
9455	return "OperationDeserializer"
9456}
9457
9458func (m *awsAwsjson11_deserializeOpUpdateProvisionedProduct) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9459	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9460) {
9461	out, metadata, err = next.HandleDeserialize(ctx, in)
9462	if err != nil {
9463		return out, metadata, err
9464	}
9465
9466	response, ok := out.RawResponse.(*smithyhttp.Response)
9467	if !ok {
9468		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9469	}
9470
9471	if response.StatusCode < 200 || response.StatusCode >= 300 {
9472		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateProvisionedProduct(response, &metadata)
9473	}
9474	output := &UpdateProvisionedProductOutput{}
9475	out.Result = output
9476
9477	var buff [1024]byte
9478	ringBuffer := smithyio.NewRingBuffer(buff[:])
9479
9480	body := io.TeeReader(response.Body, ringBuffer)
9481	decoder := json.NewDecoder(body)
9482	decoder.UseNumber()
9483	var shape interface{}
9484	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9485		var snapshot bytes.Buffer
9486		io.Copy(&snapshot, ringBuffer)
9487		err = &smithy.DeserializationError{
9488			Err:      fmt.Errorf("failed to decode response body, %w", err),
9489			Snapshot: snapshot.Bytes(),
9490		}
9491		return out, metadata, err
9492	}
9493
9494	err = awsAwsjson11_deserializeOpDocumentUpdateProvisionedProductOutput(&output, shape)
9495	if err != nil {
9496		var snapshot bytes.Buffer
9497		io.Copy(&snapshot, ringBuffer)
9498		err = &smithy.DeserializationError{
9499			Err:      fmt.Errorf("failed to decode response body, %w", err),
9500			Snapshot: snapshot.Bytes(),
9501		}
9502		return out, metadata, err
9503	}
9504
9505	return out, metadata, err
9506}
9507
9508func awsAwsjson11_deserializeOpErrorUpdateProvisionedProduct(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9509	var errorBuffer bytes.Buffer
9510	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9511		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9512	}
9513	errorBody := bytes.NewReader(errorBuffer.Bytes())
9514
9515	errorCode := "UnknownError"
9516	errorMessage := errorCode
9517
9518	code := response.Header.Get("X-Amzn-ErrorType")
9519	if len(code) != 0 {
9520		errorCode = restjson.SanitizeErrorCode(code)
9521	}
9522
9523	var buff [1024]byte
9524	ringBuffer := smithyio.NewRingBuffer(buff[:])
9525
9526	body := io.TeeReader(errorBody, ringBuffer)
9527	decoder := json.NewDecoder(body)
9528	decoder.UseNumber()
9529	code, message, err := restjson.GetErrorInfo(decoder)
9530	if err != nil {
9531		var snapshot bytes.Buffer
9532		io.Copy(&snapshot, ringBuffer)
9533		err = &smithy.DeserializationError{
9534			Err:      fmt.Errorf("failed to decode response body, %w", err),
9535			Snapshot: snapshot.Bytes(),
9536		}
9537		return err
9538	}
9539
9540	errorBody.Seek(0, io.SeekStart)
9541	if len(code) != 0 {
9542		errorCode = restjson.SanitizeErrorCode(code)
9543	}
9544	if len(message) != 0 {
9545		errorMessage = message
9546	}
9547
9548	switch {
9549	case strings.EqualFold("InvalidParametersException", errorCode):
9550		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
9551
9552	case strings.EqualFold("ResourceNotFoundException", errorCode):
9553		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
9554
9555	default:
9556		genericError := &smithy.GenericAPIError{
9557			Code:    errorCode,
9558			Message: errorMessage,
9559		}
9560		return genericError
9561
9562	}
9563}
9564
9565type awsAwsjson11_deserializeOpUpdateProvisionedProductProperties struct {
9566}
9567
9568func (*awsAwsjson11_deserializeOpUpdateProvisionedProductProperties) ID() string {
9569	return "OperationDeserializer"
9570}
9571
9572func (m *awsAwsjson11_deserializeOpUpdateProvisionedProductProperties) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9573	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9574) {
9575	out, metadata, err = next.HandleDeserialize(ctx, in)
9576	if err != nil {
9577		return out, metadata, err
9578	}
9579
9580	response, ok := out.RawResponse.(*smithyhttp.Response)
9581	if !ok {
9582		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9583	}
9584
9585	if response.StatusCode < 200 || response.StatusCode >= 300 {
9586		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateProvisionedProductProperties(response, &metadata)
9587	}
9588	output := &UpdateProvisionedProductPropertiesOutput{}
9589	out.Result = output
9590
9591	var buff [1024]byte
9592	ringBuffer := smithyio.NewRingBuffer(buff[:])
9593
9594	body := io.TeeReader(response.Body, ringBuffer)
9595	decoder := json.NewDecoder(body)
9596	decoder.UseNumber()
9597	var shape interface{}
9598	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9599		var snapshot bytes.Buffer
9600		io.Copy(&snapshot, ringBuffer)
9601		err = &smithy.DeserializationError{
9602			Err:      fmt.Errorf("failed to decode response body, %w", err),
9603			Snapshot: snapshot.Bytes(),
9604		}
9605		return out, metadata, err
9606	}
9607
9608	err = awsAwsjson11_deserializeOpDocumentUpdateProvisionedProductPropertiesOutput(&output, shape)
9609	if err != nil {
9610		var snapshot bytes.Buffer
9611		io.Copy(&snapshot, ringBuffer)
9612		err = &smithy.DeserializationError{
9613			Err:      fmt.Errorf("failed to decode response body, %w", err),
9614			Snapshot: snapshot.Bytes(),
9615		}
9616		return out, metadata, err
9617	}
9618
9619	return out, metadata, err
9620}
9621
9622func awsAwsjson11_deserializeOpErrorUpdateProvisionedProductProperties(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9623	var errorBuffer bytes.Buffer
9624	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9625		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9626	}
9627	errorBody := bytes.NewReader(errorBuffer.Bytes())
9628
9629	errorCode := "UnknownError"
9630	errorMessage := errorCode
9631
9632	code := response.Header.Get("X-Amzn-ErrorType")
9633	if len(code) != 0 {
9634		errorCode = restjson.SanitizeErrorCode(code)
9635	}
9636
9637	var buff [1024]byte
9638	ringBuffer := smithyio.NewRingBuffer(buff[:])
9639
9640	body := io.TeeReader(errorBody, ringBuffer)
9641	decoder := json.NewDecoder(body)
9642	decoder.UseNumber()
9643	code, message, err := restjson.GetErrorInfo(decoder)
9644	if err != nil {
9645		var snapshot bytes.Buffer
9646		io.Copy(&snapshot, ringBuffer)
9647		err = &smithy.DeserializationError{
9648			Err:      fmt.Errorf("failed to decode response body, %w", err),
9649			Snapshot: snapshot.Bytes(),
9650		}
9651		return err
9652	}
9653
9654	errorBody.Seek(0, io.SeekStart)
9655	if len(code) != 0 {
9656		errorCode = restjson.SanitizeErrorCode(code)
9657	}
9658	if len(message) != 0 {
9659		errorMessage = message
9660	}
9661
9662	switch {
9663	case strings.EqualFold("InvalidParametersException", errorCode):
9664		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
9665
9666	case strings.EqualFold("InvalidStateException", errorCode):
9667		return awsAwsjson11_deserializeErrorInvalidStateException(response, errorBody)
9668
9669	case strings.EqualFold("ResourceNotFoundException", errorCode):
9670		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
9671
9672	default:
9673		genericError := &smithy.GenericAPIError{
9674			Code:    errorCode,
9675			Message: errorMessage,
9676		}
9677		return genericError
9678
9679	}
9680}
9681
9682type awsAwsjson11_deserializeOpUpdateProvisioningArtifact struct {
9683}
9684
9685func (*awsAwsjson11_deserializeOpUpdateProvisioningArtifact) ID() string {
9686	return "OperationDeserializer"
9687}
9688
9689func (m *awsAwsjson11_deserializeOpUpdateProvisioningArtifact) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9690	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9691) {
9692	out, metadata, err = next.HandleDeserialize(ctx, in)
9693	if err != nil {
9694		return out, metadata, err
9695	}
9696
9697	response, ok := out.RawResponse.(*smithyhttp.Response)
9698	if !ok {
9699		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9700	}
9701
9702	if response.StatusCode < 200 || response.StatusCode >= 300 {
9703		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateProvisioningArtifact(response, &metadata)
9704	}
9705	output := &UpdateProvisioningArtifactOutput{}
9706	out.Result = output
9707
9708	var buff [1024]byte
9709	ringBuffer := smithyio.NewRingBuffer(buff[:])
9710
9711	body := io.TeeReader(response.Body, ringBuffer)
9712	decoder := json.NewDecoder(body)
9713	decoder.UseNumber()
9714	var shape interface{}
9715	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9716		var snapshot bytes.Buffer
9717		io.Copy(&snapshot, ringBuffer)
9718		err = &smithy.DeserializationError{
9719			Err:      fmt.Errorf("failed to decode response body, %w", err),
9720			Snapshot: snapshot.Bytes(),
9721		}
9722		return out, metadata, err
9723	}
9724
9725	err = awsAwsjson11_deserializeOpDocumentUpdateProvisioningArtifactOutput(&output, shape)
9726	if err != nil {
9727		var snapshot bytes.Buffer
9728		io.Copy(&snapshot, ringBuffer)
9729		err = &smithy.DeserializationError{
9730			Err:      fmt.Errorf("failed to decode response body, %w", err),
9731			Snapshot: snapshot.Bytes(),
9732		}
9733		return out, metadata, err
9734	}
9735
9736	return out, metadata, err
9737}
9738
9739func awsAwsjson11_deserializeOpErrorUpdateProvisioningArtifact(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9740	var errorBuffer bytes.Buffer
9741	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9742		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9743	}
9744	errorBody := bytes.NewReader(errorBuffer.Bytes())
9745
9746	errorCode := "UnknownError"
9747	errorMessage := errorCode
9748
9749	code := response.Header.Get("X-Amzn-ErrorType")
9750	if len(code) != 0 {
9751		errorCode = restjson.SanitizeErrorCode(code)
9752	}
9753
9754	var buff [1024]byte
9755	ringBuffer := smithyio.NewRingBuffer(buff[:])
9756
9757	body := io.TeeReader(errorBody, ringBuffer)
9758	decoder := json.NewDecoder(body)
9759	decoder.UseNumber()
9760	code, message, err := restjson.GetErrorInfo(decoder)
9761	if err != nil {
9762		var snapshot bytes.Buffer
9763		io.Copy(&snapshot, ringBuffer)
9764		err = &smithy.DeserializationError{
9765			Err:      fmt.Errorf("failed to decode response body, %w", err),
9766			Snapshot: snapshot.Bytes(),
9767		}
9768		return err
9769	}
9770
9771	errorBody.Seek(0, io.SeekStart)
9772	if len(code) != 0 {
9773		errorCode = restjson.SanitizeErrorCode(code)
9774	}
9775	if len(message) != 0 {
9776		errorMessage = message
9777	}
9778
9779	switch {
9780	case strings.EqualFold("InvalidParametersException", errorCode):
9781		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
9782
9783	case strings.EqualFold("ResourceNotFoundException", errorCode):
9784		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
9785
9786	default:
9787		genericError := &smithy.GenericAPIError{
9788			Code:    errorCode,
9789			Message: errorMessage,
9790		}
9791		return genericError
9792
9793	}
9794}
9795
9796type awsAwsjson11_deserializeOpUpdateServiceAction struct {
9797}
9798
9799func (*awsAwsjson11_deserializeOpUpdateServiceAction) ID() string {
9800	return "OperationDeserializer"
9801}
9802
9803func (m *awsAwsjson11_deserializeOpUpdateServiceAction) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9804	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9805) {
9806	out, metadata, err = next.HandleDeserialize(ctx, in)
9807	if err != nil {
9808		return out, metadata, err
9809	}
9810
9811	response, ok := out.RawResponse.(*smithyhttp.Response)
9812	if !ok {
9813		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9814	}
9815
9816	if response.StatusCode < 200 || response.StatusCode >= 300 {
9817		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateServiceAction(response, &metadata)
9818	}
9819	output := &UpdateServiceActionOutput{}
9820	out.Result = output
9821
9822	var buff [1024]byte
9823	ringBuffer := smithyio.NewRingBuffer(buff[:])
9824
9825	body := io.TeeReader(response.Body, ringBuffer)
9826	decoder := json.NewDecoder(body)
9827	decoder.UseNumber()
9828	var shape interface{}
9829	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9830		var snapshot bytes.Buffer
9831		io.Copy(&snapshot, ringBuffer)
9832		err = &smithy.DeserializationError{
9833			Err:      fmt.Errorf("failed to decode response body, %w", err),
9834			Snapshot: snapshot.Bytes(),
9835		}
9836		return out, metadata, err
9837	}
9838
9839	err = awsAwsjson11_deserializeOpDocumentUpdateServiceActionOutput(&output, shape)
9840	if err != nil {
9841		var snapshot bytes.Buffer
9842		io.Copy(&snapshot, ringBuffer)
9843		err = &smithy.DeserializationError{
9844			Err:      fmt.Errorf("failed to decode response body, %w", err),
9845			Snapshot: snapshot.Bytes(),
9846		}
9847		return out, metadata, err
9848	}
9849
9850	return out, metadata, err
9851}
9852
9853func awsAwsjson11_deserializeOpErrorUpdateServiceAction(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9854	var errorBuffer bytes.Buffer
9855	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9856		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9857	}
9858	errorBody := bytes.NewReader(errorBuffer.Bytes())
9859
9860	errorCode := "UnknownError"
9861	errorMessage := errorCode
9862
9863	code := response.Header.Get("X-Amzn-ErrorType")
9864	if len(code) != 0 {
9865		errorCode = restjson.SanitizeErrorCode(code)
9866	}
9867
9868	var buff [1024]byte
9869	ringBuffer := smithyio.NewRingBuffer(buff[:])
9870
9871	body := io.TeeReader(errorBody, ringBuffer)
9872	decoder := json.NewDecoder(body)
9873	decoder.UseNumber()
9874	code, message, err := restjson.GetErrorInfo(decoder)
9875	if err != nil {
9876		var snapshot bytes.Buffer
9877		io.Copy(&snapshot, ringBuffer)
9878		err = &smithy.DeserializationError{
9879			Err:      fmt.Errorf("failed to decode response body, %w", err),
9880			Snapshot: snapshot.Bytes(),
9881		}
9882		return err
9883	}
9884
9885	errorBody.Seek(0, io.SeekStart)
9886	if len(code) != 0 {
9887		errorCode = restjson.SanitizeErrorCode(code)
9888	}
9889	if len(message) != 0 {
9890		errorMessage = message
9891	}
9892
9893	switch {
9894	case strings.EqualFold("InvalidParametersException", errorCode):
9895		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
9896
9897	case strings.EqualFold("ResourceNotFoundException", errorCode):
9898		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
9899
9900	default:
9901		genericError := &smithy.GenericAPIError{
9902			Code:    errorCode,
9903			Message: errorMessage,
9904		}
9905		return genericError
9906
9907	}
9908}
9909
9910type awsAwsjson11_deserializeOpUpdateTagOption struct {
9911}
9912
9913func (*awsAwsjson11_deserializeOpUpdateTagOption) ID() string {
9914	return "OperationDeserializer"
9915}
9916
9917func (m *awsAwsjson11_deserializeOpUpdateTagOption) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) (
9918	out middleware.DeserializeOutput, metadata middleware.Metadata, err error,
9919) {
9920	out, metadata, err = next.HandleDeserialize(ctx, in)
9921	if err != nil {
9922		return out, metadata, err
9923	}
9924
9925	response, ok := out.RawResponse.(*smithyhttp.Response)
9926	if !ok {
9927		return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)}
9928	}
9929
9930	if response.StatusCode < 200 || response.StatusCode >= 300 {
9931		return out, metadata, awsAwsjson11_deserializeOpErrorUpdateTagOption(response, &metadata)
9932	}
9933	output := &UpdateTagOptionOutput{}
9934	out.Result = output
9935
9936	var buff [1024]byte
9937	ringBuffer := smithyio.NewRingBuffer(buff[:])
9938
9939	body := io.TeeReader(response.Body, ringBuffer)
9940	decoder := json.NewDecoder(body)
9941	decoder.UseNumber()
9942	var shape interface{}
9943	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
9944		var snapshot bytes.Buffer
9945		io.Copy(&snapshot, ringBuffer)
9946		err = &smithy.DeserializationError{
9947			Err:      fmt.Errorf("failed to decode response body, %w", err),
9948			Snapshot: snapshot.Bytes(),
9949		}
9950		return out, metadata, err
9951	}
9952
9953	err = awsAwsjson11_deserializeOpDocumentUpdateTagOptionOutput(&output, shape)
9954	if err != nil {
9955		var snapshot bytes.Buffer
9956		io.Copy(&snapshot, ringBuffer)
9957		err = &smithy.DeserializationError{
9958			Err:      fmt.Errorf("failed to decode response body, %w", err),
9959			Snapshot: snapshot.Bytes(),
9960		}
9961		return out, metadata, err
9962	}
9963
9964	return out, metadata, err
9965}
9966
9967func awsAwsjson11_deserializeOpErrorUpdateTagOption(response *smithyhttp.Response, metadata *middleware.Metadata) error {
9968	var errorBuffer bytes.Buffer
9969	if _, err := io.Copy(&errorBuffer, response.Body); err != nil {
9970		return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)}
9971	}
9972	errorBody := bytes.NewReader(errorBuffer.Bytes())
9973
9974	errorCode := "UnknownError"
9975	errorMessage := errorCode
9976
9977	code := response.Header.Get("X-Amzn-ErrorType")
9978	if len(code) != 0 {
9979		errorCode = restjson.SanitizeErrorCode(code)
9980	}
9981
9982	var buff [1024]byte
9983	ringBuffer := smithyio.NewRingBuffer(buff[:])
9984
9985	body := io.TeeReader(errorBody, ringBuffer)
9986	decoder := json.NewDecoder(body)
9987	decoder.UseNumber()
9988	code, message, err := restjson.GetErrorInfo(decoder)
9989	if err != nil {
9990		var snapshot bytes.Buffer
9991		io.Copy(&snapshot, ringBuffer)
9992		err = &smithy.DeserializationError{
9993			Err:      fmt.Errorf("failed to decode response body, %w", err),
9994			Snapshot: snapshot.Bytes(),
9995		}
9996		return err
9997	}
9998
9999	errorBody.Seek(0, io.SeekStart)
10000	if len(code) != 0 {
10001		errorCode = restjson.SanitizeErrorCode(code)
10002	}
10003	if len(message) != 0 {
10004		errorMessage = message
10005	}
10006
10007	switch {
10008	case strings.EqualFold("DuplicateResourceException", errorCode):
10009		return awsAwsjson11_deserializeErrorDuplicateResourceException(response, errorBody)
10010
10011	case strings.EqualFold("InvalidParametersException", errorCode):
10012		return awsAwsjson11_deserializeErrorInvalidParametersException(response, errorBody)
10013
10014	case strings.EqualFold("ResourceNotFoundException", errorCode):
10015		return awsAwsjson11_deserializeErrorResourceNotFoundException(response, errorBody)
10016
10017	case strings.EqualFold("TagOptionNotMigratedException", errorCode):
10018		return awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response, errorBody)
10019
10020	default:
10021		genericError := &smithy.GenericAPIError{
10022			Code:    errorCode,
10023			Message: errorMessage,
10024		}
10025		return genericError
10026
10027	}
10028}
10029
10030func awsAwsjson11_deserializeErrorDuplicateResourceException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
10031	var buff [1024]byte
10032	ringBuffer := smithyio.NewRingBuffer(buff[:])
10033
10034	body := io.TeeReader(errorBody, ringBuffer)
10035	decoder := json.NewDecoder(body)
10036	decoder.UseNumber()
10037	var shape interface{}
10038	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10039		var snapshot bytes.Buffer
10040		io.Copy(&snapshot, ringBuffer)
10041		err = &smithy.DeserializationError{
10042			Err:      fmt.Errorf("failed to decode response body, %w", err),
10043			Snapshot: snapshot.Bytes(),
10044		}
10045		return err
10046	}
10047
10048	output := &types.DuplicateResourceException{}
10049	err := awsAwsjson11_deserializeDocumentDuplicateResourceException(&output, shape)
10050
10051	if err != nil {
10052		var snapshot bytes.Buffer
10053		io.Copy(&snapshot, ringBuffer)
10054		err = &smithy.DeserializationError{
10055			Err:      fmt.Errorf("failed to decode response body, %w", err),
10056			Snapshot: snapshot.Bytes(),
10057		}
10058		return err
10059	}
10060
10061	errorBody.Seek(0, io.SeekStart)
10062	return output
10063}
10064
10065func awsAwsjson11_deserializeErrorInvalidParametersException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
10066	var buff [1024]byte
10067	ringBuffer := smithyio.NewRingBuffer(buff[:])
10068
10069	body := io.TeeReader(errorBody, ringBuffer)
10070	decoder := json.NewDecoder(body)
10071	decoder.UseNumber()
10072	var shape interface{}
10073	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10074		var snapshot bytes.Buffer
10075		io.Copy(&snapshot, ringBuffer)
10076		err = &smithy.DeserializationError{
10077			Err:      fmt.Errorf("failed to decode response body, %w", err),
10078			Snapshot: snapshot.Bytes(),
10079		}
10080		return err
10081	}
10082
10083	output := &types.InvalidParametersException{}
10084	err := awsAwsjson11_deserializeDocumentInvalidParametersException(&output, shape)
10085
10086	if err != nil {
10087		var snapshot bytes.Buffer
10088		io.Copy(&snapshot, ringBuffer)
10089		err = &smithy.DeserializationError{
10090			Err:      fmt.Errorf("failed to decode response body, %w", err),
10091			Snapshot: snapshot.Bytes(),
10092		}
10093		return err
10094	}
10095
10096	errorBody.Seek(0, io.SeekStart)
10097	return output
10098}
10099
10100func awsAwsjson11_deserializeErrorInvalidStateException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
10101	var buff [1024]byte
10102	ringBuffer := smithyio.NewRingBuffer(buff[:])
10103
10104	body := io.TeeReader(errorBody, ringBuffer)
10105	decoder := json.NewDecoder(body)
10106	decoder.UseNumber()
10107	var shape interface{}
10108	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10109		var snapshot bytes.Buffer
10110		io.Copy(&snapshot, ringBuffer)
10111		err = &smithy.DeserializationError{
10112			Err:      fmt.Errorf("failed to decode response body, %w", err),
10113			Snapshot: snapshot.Bytes(),
10114		}
10115		return err
10116	}
10117
10118	output := &types.InvalidStateException{}
10119	err := awsAwsjson11_deserializeDocumentInvalidStateException(&output, shape)
10120
10121	if err != nil {
10122		var snapshot bytes.Buffer
10123		io.Copy(&snapshot, ringBuffer)
10124		err = &smithy.DeserializationError{
10125			Err:      fmt.Errorf("failed to decode response body, %w", err),
10126			Snapshot: snapshot.Bytes(),
10127		}
10128		return err
10129	}
10130
10131	errorBody.Seek(0, io.SeekStart)
10132	return output
10133}
10134
10135func awsAwsjson11_deserializeErrorLimitExceededException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
10136	var buff [1024]byte
10137	ringBuffer := smithyio.NewRingBuffer(buff[:])
10138
10139	body := io.TeeReader(errorBody, ringBuffer)
10140	decoder := json.NewDecoder(body)
10141	decoder.UseNumber()
10142	var shape interface{}
10143	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10144		var snapshot bytes.Buffer
10145		io.Copy(&snapshot, ringBuffer)
10146		err = &smithy.DeserializationError{
10147			Err:      fmt.Errorf("failed to decode response body, %w", err),
10148			Snapshot: snapshot.Bytes(),
10149		}
10150		return err
10151	}
10152
10153	output := &types.LimitExceededException{}
10154	err := awsAwsjson11_deserializeDocumentLimitExceededException(&output, shape)
10155
10156	if err != nil {
10157		var snapshot bytes.Buffer
10158		io.Copy(&snapshot, ringBuffer)
10159		err = &smithy.DeserializationError{
10160			Err:      fmt.Errorf("failed to decode response body, %w", err),
10161			Snapshot: snapshot.Bytes(),
10162		}
10163		return err
10164	}
10165
10166	errorBody.Seek(0, io.SeekStart)
10167	return output
10168}
10169
10170func awsAwsjson11_deserializeErrorOperationNotSupportedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
10171	var buff [1024]byte
10172	ringBuffer := smithyio.NewRingBuffer(buff[:])
10173
10174	body := io.TeeReader(errorBody, ringBuffer)
10175	decoder := json.NewDecoder(body)
10176	decoder.UseNumber()
10177	var shape interface{}
10178	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10179		var snapshot bytes.Buffer
10180		io.Copy(&snapshot, ringBuffer)
10181		err = &smithy.DeserializationError{
10182			Err:      fmt.Errorf("failed to decode response body, %w", err),
10183			Snapshot: snapshot.Bytes(),
10184		}
10185		return err
10186	}
10187
10188	output := &types.OperationNotSupportedException{}
10189	err := awsAwsjson11_deserializeDocumentOperationNotSupportedException(&output, shape)
10190
10191	if err != nil {
10192		var snapshot bytes.Buffer
10193		io.Copy(&snapshot, ringBuffer)
10194		err = &smithy.DeserializationError{
10195			Err:      fmt.Errorf("failed to decode response body, %w", err),
10196			Snapshot: snapshot.Bytes(),
10197		}
10198		return err
10199	}
10200
10201	errorBody.Seek(0, io.SeekStart)
10202	return output
10203}
10204
10205func awsAwsjson11_deserializeErrorResourceInUseException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
10206	var buff [1024]byte
10207	ringBuffer := smithyio.NewRingBuffer(buff[:])
10208
10209	body := io.TeeReader(errorBody, ringBuffer)
10210	decoder := json.NewDecoder(body)
10211	decoder.UseNumber()
10212	var shape interface{}
10213	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10214		var snapshot bytes.Buffer
10215		io.Copy(&snapshot, ringBuffer)
10216		err = &smithy.DeserializationError{
10217			Err:      fmt.Errorf("failed to decode response body, %w", err),
10218			Snapshot: snapshot.Bytes(),
10219		}
10220		return err
10221	}
10222
10223	output := &types.ResourceInUseException{}
10224	err := awsAwsjson11_deserializeDocumentResourceInUseException(&output, shape)
10225
10226	if err != nil {
10227		var snapshot bytes.Buffer
10228		io.Copy(&snapshot, ringBuffer)
10229		err = &smithy.DeserializationError{
10230			Err:      fmt.Errorf("failed to decode response body, %w", err),
10231			Snapshot: snapshot.Bytes(),
10232		}
10233		return err
10234	}
10235
10236	errorBody.Seek(0, io.SeekStart)
10237	return output
10238}
10239
10240func awsAwsjson11_deserializeErrorResourceNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
10241	var buff [1024]byte
10242	ringBuffer := smithyio.NewRingBuffer(buff[:])
10243
10244	body := io.TeeReader(errorBody, ringBuffer)
10245	decoder := json.NewDecoder(body)
10246	decoder.UseNumber()
10247	var shape interface{}
10248	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10249		var snapshot bytes.Buffer
10250		io.Copy(&snapshot, ringBuffer)
10251		err = &smithy.DeserializationError{
10252			Err:      fmt.Errorf("failed to decode response body, %w", err),
10253			Snapshot: snapshot.Bytes(),
10254		}
10255		return err
10256	}
10257
10258	output := &types.ResourceNotFoundException{}
10259	err := awsAwsjson11_deserializeDocumentResourceNotFoundException(&output, shape)
10260
10261	if err != nil {
10262		var snapshot bytes.Buffer
10263		io.Copy(&snapshot, ringBuffer)
10264		err = &smithy.DeserializationError{
10265			Err:      fmt.Errorf("failed to decode response body, %w", err),
10266			Snapshot: snapshot.Bytes(),
10267		}
10268		return err
10269	}
10270
10271	errorBody.Seek(0, io.SeekStart)
10272	return output
10273}
10274
10275func awsAwsjson11_deserializeErrorTagOptionNotMigratedException(response *smithyhttp.Response, errorBody *bytes.Reader) error {
10276	var buff [1024]byte
10277	ringBuffer := smithyio.NewRingBuffer(buff[:])
10278
10279	body := io.TeeReader(errorBody, ringBuffer)
10280	decoder := json.NewDecoder(body)
10281	decoder.UseNumber()
10282	var shape interface{}
10283	if err := decoder.Decode(&shape); err != nil && err != io.EOF {
10284		var snapshot bytes.Buffer
10285		io.Copy(&snapshot, ringBuffer)
10286		err = &smithy.DeserializationError{
10287			Err:      fmt.Errorf("failed to decode response body, %w", err),
10288			Snapshot: snapshot.Bytes(),
10289		}
10290		return err
10291	}
10292
10293	output := &types.TagOptionNotMigratedException{}
10294	err := awsAwsjson11_deserializeDocumentTagOptionNotMigratedException(&output, shape)
10295
10296	if err != nil {
10297		var snapshot bytes.Buffer
10298		io.Copy(&snapshot, ringBuffer)
10299		err = &smithy.DeserializationError{
10300			Err:      fmt.Errorf("failed to decode response body, %w", err),
10301			Snapshot: snapshot.Bytes(),
10302		}
10303		return err
10304	}
10305
10306	errorBody.Seek(0, io.SeekStart)
10307	return output
10308}
10309
10310func awsAwsjson11_deserializeDocumentAccountIds(v *[]string, value interface{}) error {
10311	if v == nil {
10312		return fmt.Errorf("unexpected nil of type %T", v)
10313	}
10314	if value == nil {
10315		return nil
10316	}
10317
10318	shape, ok := value.([]interface{})
10319	if !ok {
10320		return fmt.Errorf("unexpected JSON type %v", value)
10321	}
10322
10323	var cv []string
10324	if *v == nil {
10325		cv = []string{}
10326	} else {
10327		cv = *v
10328	}
10329
10330	for _, value := range shape {
10331		var col string
10332		if value != nil {
10333			jtv, ok := value.(string)
10334			if !ok {
10335				return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
10336			}
10337			col = jtv
10338		}
10339		cv = append(cv, col)
10340
10341	}
10342	*v = cv
10343	return nil
10344}
10345
10346func awsAwsjson11_deserializeDocumentAllowedValues(v *[]string, value interface{}) error {
10347	if v == nil {
10348		return fmt.Errorf("unexpected nil of type %T", v)
10349	}
10350	if value == nil {
10351		return nil
10352	}
10353
10354	shape, ok := value.([]interface{})
10355	if !ok {
10356		return fmt.Errorf("unexpected JSON type %v", value)
10357	}
10358
10359	var cv []string
10360	if *v == nil {
10361		cv = []string{}
10362	} else {
10363		cv = *v
10364	}
10365
10366	for _, value := range shape {
10367		var col string
10368		if value != nil {
10369			jtv, ok := value.(string)
10370			if !ok {
10371				return fmt.Errorf("expected AllowedValue to be of type string, got %T instead", value)
10372			}
10373			col = jtv
10374		}
10375		cv = append(cv, col)
10376
10377	}
10378	*v = cv
10379	return nil
10380}
10381
10382func awsAwsjson11_deserializeDocumentBudgetDetail(v **types.BudgetDetail, value interface{}) error {
10383	if v == nil {
10384		return fmt.Errorf("unexpected nil of type %T", v)
10385	}
10386	if value == nil {
10387		return nil
10388	}
10389
10390	shape, ok := value.(map[string]interface{})
10391	if !ok {
10392		return fmt.Errorf("unexpected JSON type %v", value)
10393	}
10394
10395	var sv *types.BudgetDetail
10396	if *v == nil {
10397		sv = &types.BudgetDetail{}
10398	} else {
10399		sv = *v
10400	}
10401
10402	for key, value := range shape {
10403		switch key {
10404		case "BudgetName":
10405			if value != nil {
10406				jtv, ok := value.(string)
10407				if !ok {
10408					return fmt.Errorf("expected BudgetName to be of type string, got %T instead", value)
10409				}
10410				sv.BudgetName = ptr.String(jtv)
10411			}
10412
10413		default:
10414			_, _ = key, value
10415
10416		}
10417	}
10418	*v = sv
10419	return nil
10420}
10421
10422func awsAwsjson11_deserializeDocumentBudgets(v *[]types.BudgetDetail, value interface{}) error {
10423	if v == nil {
10424		return fmt.Errorf("unexpected nil of type %T", v)
10425	}
10426	if value == nil {
10427		return nil
10428	}
10429
10430	shape, ok := value.([]interface{})
10431	if !ok {
10432		return fmt.Errorf("unexpected JSON type %v", value)
10433	}
10434
10435	var cv []types.BudgetDetail
10436	if *v == nil {
10437		cv = []types.BudgetDetail{}
10438	} else {
10439		cv = *v
10440	}
10441
10442	for _, value := range shape {
10443		var col types.BudgetDetail
10444		destAddr := &col
10445		if err := awsAwsjson11_deserializeDocumentBudgetDetail(&destAddr, value); err != nil {
10446			return err
10447		}
10448		col = *destAddr
10449		cv = append(cv, col)
10450
10451	}
10452	*v = cv
10453	return nil
10454}
10455
10456func awsAwsjson11_deserializeDocumentCloudWatchDashboard(v **types.CloudWatchDashboard, value interface{}) error {
10457	if v == nil {
10458		return fmt.Errorf("unexpected nil of type %T", v)
10459	}
10460	if value == nil {
10461		return nil
10462	}
10463
10464	shape, ok := value.(map[string]interface{})
10465	if !ok {
10466		return fmt.Errorf("unexpected JSON type %v", value)
10467	}
10468
10469	var sv *types.CloudWatchDashboard
10470	if *v == nil {
10471		sv = &types.CloudWatchDashboard{}
10472	} else {
10473		sv = *v
10474	}
10475
10476	for key, value := range shape {
10477		switch key {
10478		case "Name":
10479			if value != nil {
10480				jtv, ok := value.(string)
10481				if !ok {
10482					return fmt.Errorf("expected CloudWatchDashboardName to be of type string, got %T instead", value)
10483				}
10484				sv.Name = ptr.String(jtv)
10485			}
10486
10487		default:
10488			_, _ = key, value
10489
10490		}
10491	}
10492	*v = sv
10493	return nil
10494}
10495
10496func awsAwsjson11_deserializeDocumentCloudWatchDashboards(v *[]types.CloudWatchDashboard, value interface{}) error {
10497	if v == nil {
10498		return fmt.Errorf("unexpected nil of type %T", v)
10499	}
10500	if value == nil {
10501		return nil
10502	}
10503
10504	shape, ok := value.([]interface{})
10505	if !ok {
10506		return fmt.Errorf("unexpected JSON type %v", value)
10507	}
10508
10509	var cv []types.CloudWatchDashboard
10510	if *v == nil {
10511		cv = []types.CloudWatchDashboard{}
10512	} else {
10513		cv = *v
10514	}
10515
10516	for _, value := range shape {
10517		var col types.CloudWatchDashboard
10518		destAddr := &col
10519		if err := awsAwsjson11_deserializeDocumentCloudWatchDashboard(&destAddr, value); err != nil {
10520			return err
10521		}
10522		col = *destAddr
10523		cv = append(cv, col)
10524
10525	}
10526	*v = cv
10527	return nil
10528}
10529
10530func awsAwsjson11_deserializeDocumentConstraintDetail(v **types.ConstraintDetail, value interface{}) error {
10531	if v == nil {
10532		return fmt.Errorf("unexpected nil of type %T", v)
10533	}
10534	if value == nil {
10535		return nil
10536	}
10537
10538	shape, ok := value.(map[string]interface{})
10539	if !ok {
10540		return fmt.Errorf("unexpected JSON type %v", value)
10541	}
10542
10543	var sv *types.ConstraintDetail
10544	if *v == nil {
10545		sv = &types.ConstraintDetail{}
10546	} else {
10547		sv = *v
10548	}
10549
10550	for key, value := range shape {
10551		switch key {
10552		case "ConstraintId":
10553			if value != nil {
10554				jtv, ok := value.(string)
10555				if !ok {
10556					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
10557				}
10558				sv.ConstraintId = ptr.String(jtv)
10559			}
10560
10561		case "Description":
10562			if value != nil {
10563				jtv, ok := value.(string)
10564				if !ok {
10565					return fmt.Errorf("expected ConstraintDescription to be of type string, got %T instead", value)
10566				}
10567				sv.Description = ptr.String(jtv)
10568			}
10569
10570		case "Owner":
10571			if value != nil {
10572				jtv, ok := value.(string)
10573				if !ok {
10574					return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
10575				}
10576				sv.Owner = ptr.String(jtv)
10577			}
10578
10579		case "PortfolioId":
10580			if value != nil {
10581				jtv, ok := value.(string)
10582				if !ok {
10583					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
10584				}
10585				sv.PortfolioId = ptr.String(jtv)
10586			}
10587
10588		case "ProductId":
10589			if value != nil {
10590				jtv, ok := value.(string)
10591				if !ok {
10592					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
10593				}
10594				sv.ProductId = ptr.String(jtv)
10595			}
10596
10597		case "Type":
10598			if value != nil {
10599				jtv, ok := value.(string)
10600				if !ok {
10601					return fmt.Errorf("expected ConstraintType to be of type string, got %T instead", value)
10602				}
10603				sv.Type = ptr.String(jtv)
10604			}
10605
10606		default:
10607			_, _ = key, value
10608
10609		}
10610	}
10611	*v = sv
10612	return nil
10613}
10614
10615func awsAwsjson11_deserializeDocumentConstraintDetails(v *[]types.ConstraintDetail, value interface{}) error {
10616	if v == nil {
10617		return fmt.Errorf("unexpected nil of type %T", v)
10618	}
10619	if value == nil {
10620		return nil
10621	}
10622
10623	shape, ok := value.([]interface{})
10624	if !ok {
10625		return fmt.Errorf("unexpected JSON type %v", value)
10626	}
10627
10628	var cv []types.ConstraintDetail
10629	if *v == nil {
10630		cv = []types.ConstraintDetail{}
10631	} else {
10632		cv = *v
10633	}
10634
10635	for _, value := range shape {
10636		var col types.ConstraintDetail
10637		destAddr := &col
10638		if err := awsAwsjson11_deserializeDocumentConstraintDetail(&destAddr, value); err != nil {
10639			return err
10640		}
10641		col = *destAddr
10642		cv = append(cv, col)
10643
10644	}
10645	*v = cv
10646	return nil
10647}
10648
10649func awsAwsjson11_deserializeDocumentConstraintSummaries(v *[]types.ConstraintSummary, value interface{}) error {
10650	if v == nil {
10651		return fmt.Errorf("unexpected nil of type %T", v)
10652	}
10653	if value == nil {
10654		return nil
10655	}
10656
10657	shape, ok := value.([]interface{})
10658	if !ok {
10659		return fmt.Errorf("unexpected JSON type %v", value)
10660	}
10661
10662	var cv []types.ConstraintSummary
10663	if *v == nil {
10664		cv = []types.ConstraintSummary{}
10665	} else {
10666		cv = *v
10667	}
10668
10669	for _, value := range shape {
10670		var col types.ConstraintSummary
10671		destAddr := &col
10672		if err := awsAwsjson11_deserializeDocumentConstraintSummary(&destAddr, value); err != nil {
10673			return err
10674		}
10675		col = *destAddr
10676		cv = append(cv, col)
10677
10678	}
10679	*v = cv
10680	return nil
10681}
10682
10683func awsAwsjson11_deserializeDocumentConstraintSummary(v **types.ConstraintSummary, value interface{}) error {
10684	if v == nil {
10685		return fmt.Errorf("unexpected nil of type %T", v)
10686	}
10687	if value == nil {
10688		return nil
10689	}
10690
10691	shape, ok := value.(map[string]interface{})
10692	if !ok {
10693		return fmt.Errorf("unexpected JSON type %v", value)
10694	}
10695
10696	var sv *types.ConstraintSummary
10697	if *v == nil {
10698		sv = &types.ConstraintSummary{}
10699	} else {
10700		sv = *v
10701	}
10702
10703	for key, value := range shape {
10704		switch key {
10705		case "Description":
10706			if value != nil {
10707				jtv, ok := value.(string)
10708				if !ok {
10709					return fmt.Errorf("expected ConstraintDescription to be of type string, got %T instead", value)
10710				}
10711				sv.Description = ptr.String(jtv)
10712			}
10713
10714		case "Type":
10715			if value != nil {
10716				jtv, ok := value.(string)
10717				if !ok {
10718					return fmt.Errorf("expected ConstraintType to be of type string, got %T instead", value)
10719				}
10720				sv.Type = ptr.String(jtv)
10721			}
10722
10723		default:
10724			_, _ = key, value
10725
10726		}
10727	}
10728	*v = sv
10729	return nil
10730}
10731
10732func awsAwsjson11_deserializeDocumentDuplicateResourceException(v **types.DuplicateResourceException, value interface{}) error {
10733	if v == nil {
10734		return fmt.Errorf("unexpected nil of type %T", v)
10735	}
10736	if value == nil {
10737		return nil
10738	}
10739
10740	shape, ok := value.(map[string]interface{})
10741	if !ok {
10742		return fmt.Errorf("unexpected JSON type %v", value)
10743	}
10744
10745	var sv *types.DuplicateResourceException
10746	if *v == nil {
10747		sv = &types.DuplicateResourceException{}
10748	} else {
10749		sv = *v
10750	}
10751
10752	for key, value := range shape {
10753		switch key {
10754		case "Message":
10755			if value != nil {
10756				jtv, ok := value.(string)
10757				if !ok {
10758					return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
10759				}
10760				sv.Message = ptr.String(jtv)
10761			}
10762
10763		default:
10764			_, _ = key, value
10765
10766		}
10767	}
10768	*v = sv
10769	return nil
10770}
10771
10772func awsAwsjson11_deserializeDocumentExecutionParameter(v **types.ExecutionParameter, value interface{}) error {
10773	if v == nil {
10774		return fmt.Errorf("unexpected nil of type %T", v)
10775	}
10776	if value == nil {
10777		return nil
10778	}
10779
10780	shape, ok := value.(map[string]interface{})
10781	if !ok {
10782		return fmt.Errorf("unexpected JSON type %v", value)
10783	}
10784
10785	var sv *types.ExecutionParameter
10786	if *v == nil {
10787		sv = &types.ExecutionParameter{}
10788	} else {
10789		sv = *v
10790	}
10791
10792	for key, value := range shape {
10793		switch key {
10794		case "DefaultValues":
10795			if err := awsAwsjson11_deserializeDocumentExecutionParameterValueList(&sv.DefaultValues, value); err != nil {
10796				return err
10797			}
10798
10799		case "Name":
10800			if value != nil {
10801				jtv, ok := value.(string)
10802				if !ok {
10803					return fmt.Errorf("expected ExecutionParameterKey to be of type string, got %T instead", value)
10804				}
10805				sv.Name = ptr.String(jtv)
10806			}
10807
10808		case "Type":
10809			if value != nil {
10810				jtv, ok := value.(string)
10811				if !ok {
10812					return fmt.Errorf("expected ExecutionParameterType to be of type string, got %T instead", value)
10813				}
10814				sv.Type = ptr.String(jtv)
10815			}
10816
10817		default:
10818			_, _ = key, value
10819
10820		}
10821	}
10822	*v = sv
10823	return nil
10824}
10825
10826func awsAwsjson11_deserializeDocumentExecutionParameters(v *[]types.ExecutionParameter, value interface{}) error {
10827	if v == nil {
10828		return fmt.Errorf("unexpected nil of type %T", v)
10829	}
10830	if value == nil {
10831		return nil
10832	}
10833
10834	shape, ok := value.([]interface{})
10835	if !ok {
10836		return fmt.Errorf("unexpected JSON type %v", value)
10837	}
10838
10839	var cv []types.ExecutionParameter
10840	if *v == nil {
10841		cv = []types.ExecutionParameter{}
10842	} else {
10843		cv = *v
10844	}
10845
10846	for _, value := range shape {
10847		var col types.ExecutionParameter
10848		destAddr := &col
10849		if err := awsAwsjson11_deserializeDocumentExecutionParameter(&destAddr, value); err != nil {
10850			return err
10851		}
10852		col = *destAddr
10853		cv = append(cv, col)
10854
10855	}
10856	*v = cv
10857	return nil
10858}
10859
10860func awsAwsjson11_deserializeDocumentExecutionParameterValueList(v *[]string, value interface{}) error {
10861	if v == nil {
10862		return fmt.Errorf("unexpected nil of type %T", v)
10863	}
10864	if value == nil {
10865		return nil
10866	}
10867
10868	shape, ok := value.([]interface{})
10869	if !ok {
10870		return fmt.Errorf("unexpected JSON type %v", value)
10871	}
10872
10873	var cv []string
10874	if *v == nil {
10875		cv = []string{}
10876	} else {
10877		cv = *v
10878	}
10879
10880	for _, value := range shape {
10881		var col string
10882		if value != nil {
10883			jtv, ok := value.(string)
10884			if !ok {
10885				return fmt.Errorf("expected ExecutionParameterValue to be of type string, got %T instead", value)
10886			}
10887			col = jtv
10888		}
10889		cv = append(cv, col)
10890
10891	}
10892	*v = cv
10893	return nil
10894}
10895
10896func awsAwsjson11_deserializeDocumentFailedServiceActionAssociation(v **types.FailedServiceActionAssociation, value interface{}) error {
10897	if v == nil {
10898		return fmt.Errorf("unexpected nil of type %T", v)
10899	}
10900	if value == nil {
10901		return nil
10902	}
10903
10904	shape, ok := value.(map[string]interface{})
10905	if !ok {
10906		return fmt.Errorf("unexpected JSON type %v", value)
10907	}
10908
10909	var sv *types.FailedServiceActionAssociation
10910	if *v == nil {
10911		sv = &types.FailedServiceActionAssociation{}
10912	} else {
10913		sv = *v
10914	}
10915
10916	for key, value := range shape {
10917		switch key {
10918		case "ErrorCode":
10919			if value != nil {
10920				jtv, ok := value.(string)
10921				if !ok {
10922					return fmt.Errorf("expected ServiceActionAssociationErrorCode to be of type string, got %T instead", value)
10923				}
10924				sv.ErrorCode = types.ServiceActionAssociationErrorCode(jtv)
10925			}
10926
10927		case "ErrorMessage":
10928			if value != nil {
10929				jtv, ok := value.(string)
10930				if !ok {
10931					return fmt.Errorf("expected ServiceActionAssociationErrorMessage to be of type string, got %T instead", value)
10932				}
10933				sv.ErrorMessage = ptr.String(jtv)
10934			}
10935
10936		case "ProductId":
10937			if value != nil {
10938				jtv, ok := value.(string)
10939				if !ok {
10940					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
10941				}
10942				sv.ProductId = ptr.String(jtv)
10943			}
10944
10945		case "ProvisioningArtifactId":
10946			if value != nil {
10947				jtv, ok := value.(string)
10948				if !ok {
10949					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
10950				}
10951				sv.ProvisioningArtifactId = ptr.String(jtv)
10952			}
10953
10954		case "ServiceActionId":
10955			if value != nil {
10956				jtv, ok := value.(string)
10957				if !ok {
10958					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
10959				}
10960				sv.ServiceActionId = ptr.String(jtv)
10961			}
10962
10963		default:
10964			_, _ = key, value
10965
10966		}
10967	}
10968	*v = sv
10969	return nil
10970}
10971
10972func awsAwsjson11_deserializeDocumentFailedServiceActionAssociations(v *[]types.FailedServiceActionAssociation, value interface{}) error {
10973	if v == nil {
10974		return fmt.Errorf("unexpected nil of type %T", v)
10975	}
10976	if value == nil {
10977		return nil
10978	}
10979
10980	shape, ok := value.([]interface{})
10981	if !ok {
10982		return fmt.Errorf("unexpected JSON type %v", value)
10983	}
10984
10985	var cv []types.FailedServiceActionAssociation
10986	if *v == nil {
10987		cv = []types.FailedServiceActionAssociation{}
10988	} else {
10989		cv = *v
10990	}
10991
10992	for _, value := range shape {
10993		var col types.FailedServiceActionAssociation
10994		destAddr := &col
10995		if err := awsAwsjson11_deserializeDocumentFailedServiceActionAssociation(&destAddr, value); err != nil {
10996			return err
10997		}
10998		col = *destAddr
10999		cv = append(cv, col)
11000
11001	}
11002	*v = cv
11003	return nil
11004}
11005
11006func awsAwsjson11_deserializeDocumentInvalidParametersException(v **types.InvalidParametersException, value interface{}) error {
11007	if v == nil {
11008		return fmt.Errorf("unexpected nil of type %T", v)
11009	}
11010	if value == nil {
11011		return nil
11012	}
11013
11014	shape, ok := value.(map[string]interface{})
11015	if !ok {
11016		return fmt.Errorf("unexpected JSON type %v", value)
11017	}
11018
11019	var sv *types.InvalidParametersException
11020	if *v == nil {
11021		sv = &types.InvalidParametersException{}
11022	} else {
11023		sv = *v
11024	}
11025
11026	for key, value := range shape {
11027		switch key {
11028		case "Message":
11029			if value != nil {
11030				jtv, ok := value.(string)
11031				if !ok {
11032					return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
11033				}
11034				sv.Message = ptr.String(jtv)
11035			}
11036
11037		default:
11038			_, _ = key, value
11039
11040		}
11041	}
11042	*v = sv
11043	return nil
11044}
11045
11046func awsAwsjson11_deserializeDocumentInvalidStateException(v **types.InvalidStateException, value interface{}) error {
11047	if v == nil {
11048		return fmt.Errorf("unexpected nil of type %T", v)
11049	}
11050	if value == nil {
11051		return nil
11052	}
11053
11054	shape, ok := value.(map[string]interface{})
11055	if !ok {
11056		return fmt.Errorf("unexpected JSON type %v", value)
11057	}
11058
11059	var sv *types.InvalidStateException
11060	if *v == nil {
11061		sv = &types.InvalidStateException{}
11062	} else {
11063		sv = *v
11064	}
11065
11066	for key, value := range shape {
11067		switch key {
11068		case "Message":
11069			if value != nil {
11070				jtv, ok := value.(string)
11071				if !ok {
11072					return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
11073				}
11074				sv.Message = ptr.String(jtv)
11075			}
11076
11077		default:
11078			_, _ = key, value
11079
11080		}
11081	}
11082	*v = sv
11083	return nil
11084}
11085
11086func awsAwsjson11_deserializeDocumentLaunchPath(v **types.LaunchPath, value interface{}) error {
11087	if v == nil {
11088		return fmt.Errorf("unexpected nil of type %T", v)
11089	}
11090	if value == nil {
11091		return nil
11092	}
11093
11094	shape, ok := value.(map[string]interface{})
11095	if !ok {
11096		return fmt.Errorf("unexpected JSON type %v", value)
11097	}
11098
11099	var sv *types.LaunchPath
11100	if *v == nil {
11101		sv = &types.LaunchPath{}
11102	} else {
11103		sv = *v
11104	}
11105
11106	for key, value := range shape {
11107		switch key {
11108		case "Id":
11109			if value != nil {
11110				jtv, ok := value.(string)
11111				if !ok {
11112					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
11113				}
11114				sv.Id = ptr.String(jtv)
11115			}
11116
11117		case "Name":
11118			if value != nil {
11119				jtv, ok := value.(string)
11120				if !ok {
11121					return fmt.Errorf("expected PortfolioName to be of type string, got %T instead", value)
11122				}
11123				sv.Name = ptr.String(jtv)
11124			}
11125
11126		default:
11127			_, _ = key, value
11128
11129		}
11130	}
11131	*v = sv
11132	return nil
11133}
11134
11135func awsAwsjson11_deserializeDocumentLaunchPaths(v *[]types.LaunchPath, value interface{}) error {
11136	if v == nil {
11137		return fmt.Errorf("unexpected nil of type %T", v)
11138	}
11139	if value == nil {
11140		return nil
11141	}
11142
11143	shape, ok := value.([]interface{})
11144	if !ok {
11145		return fmt.Errorf("unexpected JSON type %v", value)
11146	}
11147
11148	var cv []types.LaunchPath
11149	if *v == nil {
11150		cv = []types.LaunchPath{}
11151	} else {
11152		cv = *v
11153	}
11154
11155	for _, value := range shape {
11156		var col types.LaunchPath
11157		destAddr := &col
11158		if err := awsAwsjson11_deserializeDocumentLaunchPath(&destAddr, value); err != nil {
11159			return err
11160		}
11161		col = *destAddr
11162		cv = append(cv, col)
11163
11164	}
11165	*v = cv
11166	return nil
11167}
11168
11169func awsAwsjson11_deserializeDocumentLaunchPathSummaries(v *[]types.LaunchPathSummary, value interface{}) error {
11170	if v == nil {
11171		return fmt.Errorf("unexpected nil of type %T", v)
11172	}
11173	if value == nil {
11174		return nil
11175	}
11176
11177	shape, ok := value.([]interface{})
11178	if !ok {
11179		return fmt.Errorf("unexpected JSON type %v", value)
11180	}
11181
11182	var cv []types.LaunchPathSummary
11183	if *v == nil {
11184		cv = []types.LaunchPathSummary{}
11185	} else {
11186		cv = *v
11187	}
11188
11189	for _, value := range shape {
11190		var col types.LaunchPathSummary
11191		destAddr := &col
11192		if err := awsAwsjson11_deserializeDocumentLaunchPathSummary(&destAddr, value); err != nil {
11193			return err
11194		}
11195		col = *destAddr
11196		cv = append(cv, col)
11197
11198	}
11199	*v = cv
11200	return nil
11201}
11202
11203func awsAwsjson11_deserializeDocumentLaunchPathSummary(v **types.LaunchPathSummary, value interface{}) error {
11204	if v == nil {
11205		return fmt.Errorf("unexpected nil of type %T", v)
11206	}
11207	if value == nil {
11208		return nil
11209	}
11210
11211	shape, ok := value.(map[string]interface{})
11212	if !ok {
11213		return fmt.Errorf("unexpected JSON type %v", value)
11214	}
11215
11216	var sv *types.LaunchPathSummary
11217	if *v == nil {
11218		sv = &types.LaunchPathSummary{}
11219	} else {
11220		sv = *v
11221	}
11222
11223	for key, value := range shape {
11224		switch key {
11225		case "ConstraintSummaries":
11226			if err := awsAwsjson11_deserializeDocumentConstraintSummaries(&sv.ConstraintSummaries, value); err != nil {
11227				return err
11228			}
11229
11230		case "Id":
11231			if value != nil {
11232				jtv, ok := value.(string)
11233				if !ok {
11234					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
11235				}
11236				sv.Id = ptr.String(jtv)
11237			}
11238
11239		case "Name":
11240			if value != nil {
11241				jtv, ok := value.(string)
11242				if !ok {
11243					return fmt.Errorf("expected PortfolioName to be of type string, got %T instead", value)
11244				}
11245				sv.Name = ptr.String(jtv)
11246			}
11247
11248		case "Tags":
11249			if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
11250				return err
11251			}
11252
11253		default:
11254			_, _ = key, value
11255
11256		}
11257	}
11258	*v = sv
11259	return nil
11260}
11261
11262func awsAwsjson11_deserializeDocumentLimitExceededException(v **types.LimitExceededException, value interface{}) error {
11263	if v == nil {
11264		return fmt.Errorf("unexpected nil of type %T", v)
11265	}
11266	if value == nil {
11267		return nil
11268	}
11269
11270	shape, ok := value.(map[string]interface{})
11271	if !ok {
11272		return fmt.Errorf("unexpected JSON type %v", value)
11273	}
11274
11275	var sv *types.LimitExceededException
11276	if *v == nil {
11277		sv = &types.LimitExceededException{}
11278	} else {
11279		sv = *v
11280	}
11281
11282	for key, value := range shape {
11283		switch key {
11284		case "Message":
11285			if value != nil {
11286				jtv, ok := value.(string)
11287				if !ok {
11288					return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
11289				}
11290				sv.Message = ptr.String(jtv)
11291			}
11292
11293		default:
11294			_, _ = key, value
11295
11296		}
11297	}
11298	*v = sv
11299	return nil
11300}
11301
11302func awsAwsjson11_deserializeDocumentNamespaces(v *[]string, value interface{}) error {
11303	if v == nil {
11304		return fmt.Errorf("unexpected nil of type %T", v)
11305	}
11306	if value == nil {
11307		return nil
11308	}
11309
11310	shape, ok := value.([]interface{})
11311	if !ok {
11312		return fmt.Errorf("unexpected JSON type %v", value)
11313	}
11314
11315	var cv []string
11316	if *v == nil {
11317		cv = []string{}
11318	} else {
11319		cv = *v
11320	}
11321
11322	for _, value := range shape {
11323		var col string
11324		if value != nil {
11325			jtv, ok := value.(string)
11326			if !ok {
11327				return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
11328			}
11329			col = jtv
11330		}
11331		cv = append(cv, col)
11332
11333	}
11334	*v = cv
11335	return nil
11336}
11337
11338func awsAwsjson11_deserializeDocumentNotificationArns(v *[]string, value interface{}) error {
11339	if v == nil {
11340		return fmt.Errorf("unexpected nil of type %T", v)
11341	}
11342	if value == nil {
11343		return nil
11344	}
11345
11346	shape, ok := value.([]interface{})
11347	if !ok {
11348		return fmt.Errorf("unexpected JSON type %v", value)
11349	}
11350
11351	var cv []string
11352	if *v == nil {
11353		cv = []string{}
11354	} else {
11355		cv = *v
11356	}
11357
11358	for _, value := range shape {
11359		var col string
11360		if value != nil {
11361			jtv, ok := value.(string)
11362			if !ok {
11363				return fmt.Errorf("expected NotificationArn to be of type string, got %T instead", value)
11364			}
11365			col = jtv
11366		}
11367		cv = append(cv, col)
11368
11369	}
11370	*v = cv
11371	return nil
11372}
11373
11374func awsAwsjson11_deserializeDocumentOperationNotSupportedException(v **types.OperationNotSupportedException, value interface{}) error {
11375	if v == nil {
11376		return fmt.Errorf("unexpected nil of type %T", v)
11377	}
11378	if value == nil {
11379		return nil
11380	}
11381
11382	shape, ok := value.(map[string]interface{})
11383	if !ok {
11384		return fmt.Errorf("unexpected JSON type %v", value)
11385	}
11386
11387	var sv *types.OperationNotSupportedException
11388	if *v == nil {
11389		sv = &types.OperationNotSupportedException{}
11390	} else {
11391		sv = *v
11392	}
11393
11394	for key, value := range shape {
11395		switch key {
11396		case "Message":
11397			if value != nil {
11398				jtv, ok := value.(string)
11399				if !ok {
11400					return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
11401				}
11402				sv.Message = ptr.String(jtv)
11403			}
11404
11405		default:
11406			_, _ = key, value
11407
11408		}
11409	}
11410	*v = sv
11411	return nil
11412}
11413
11414func awsAwsjson11_deserializeDocumentOrganizationNode(v **types.OrganizationNode, value interface{}) error {
11415	if v == nil {
11416		return fmt.Errorf("unexpected nil of type %T", v)
11417	}
11418	if value == nil {
11419		return nil
11420	}
11421
11422	shape, ok := value.(map[string]interface{})
11423	if !ok {
11424		return fmt.Errorf("unexpected JSON type %v", value)
11425	}
11426
11427	var sv *types.OrganizationNode
11428	if *v == nil {
11429		sv = &types.OrganizationNode{}
11430	} else {
11431		sv = *v
11432	}
11433
11434	for key, value := range shape {
11435		switch key {
11436		case "Type":
11437			if value != nil {
11438				jtv, ok := value.(string)
11439				if !ok {
11440					return fmt.Errorf("expected OrganizationNodeType to be of type string, got %T instead", value)
11441				}
11442				sv.Type = types.OrganizationNodeType(jtv)
11443			}
11444
11445		case "Value":
11446			if value != nil {
11447				jtv, ok := value.(string)
11448				if !ok {
11449					return fmt.Errorf("expected OrganizationNodeValue to be of type string, got %T instead", value)
11450				}
11451				sv.Value = ptr.String(jtv)
11452			}
11453
11454		default:
11455			_, _ = key, value
11456
11457		}
11458	}
11459	*v = sv
11460	return nil
11461}
11462
11463func awsAwsjson11_deserializeDocumentOrganizationNodes(v *[]types.OrganizationNode, value interface{}) error {
11464	if v == nil {
11465		return fmt.Errorf("unexpected nil of type %T", v)
11466	}
11467	if value == nil {
11468		return nil
11469	}
11470
11471	shape, ok := value.([]interface{})
11472	if !ok {
11473		return fmt.Errorf("unexpected JSON type %v", value)
11474	}
11475
11476	var cv []types.OrganizationNode
11477	if *v == nil {
11478		cv = []types.OrganizationNode{}
11479	} else {
11480		cv = *v
11481	}
11482
11483	for _, value := range shape {
11484		var col types.OrganizationNode
11485		destAddr := &col
11486		if err := awsAwsjson11_deserializeDocumentOrganizationNode(&destAddr, value); err != nil {
11487			return err
11488		}
11489		col = *destAddr
11490		cv = append(cv, col)
11491
11492	}
11493	*v = cv
11494	return nil
11495}
11496
11497func awsAwsjson11_deserializeDocumentParameterConstraints(v **types.ParameterConstraints, value interface{}) error {
11498	if v == nil {
11499		return fmt.Errorf("unexpected nil of type %T", v)
11500	}
11501	if value == nil {
11502		return nil
11503	}
11504
11505	shape, ok := value.(map[string]interface{})
11506	if !ok {
11507		return fmt.Errorf("unexpected JSON type %v", value)
11508	}
11509
11510	var sv *types.ParameterConstraints
11511	if *v == nil {
11512		sv = &types.ParameterConstraints{}
11513	} else {
11514		sv = *v
11515	}
11516
11517	for key, value := range shape {
11518		switch key {
11519		case "AllowedValues":
11520			if err := awsAwsjson11_deserializeDocumentAllowedValues(&sv.AllowedValues, value); err != nil {
11521				return err
11522			}
11523
11524		default:
11525			_, _ = key, value
11526
11527		}
11528	}
11529	*v = sv
11530	return nil
11531}
11532
11533func awsAwsjson11_deserializeDocumentPortfolioDetail(v **types.PortfolioDetail, value interface{}) error {
11534	if v == nil {
11535		return fmt.Errorf("unexpected nil of type %T", v)
11536	}
11537	if value == nil {
11538		return nil
11539	}
11540
11541	shape, ok := value.(map[string]interface{})
11542	if !ok {
11543		return fmt.Errorf("unexpected JSON type %v", value)
11544	}
11545
11546	var sv *types.PortfolioDetail
11547	if *v == nil {
11548		sv = &types.PortfolioDetail{}
11549	} else {
11550		sv = *v
11551	}
11552
11553	for key, value := range shape {
11554		switch key {
11555		case "ARN":
11556			if value != nil {
11557				jtv, ok := value.(string)
11558				if !ok {
11559					return fmt.Errorf("expected ResourceARN to be of type string, got %T instead", value)
11560				}
11561				sv.ARN = ptr.String(jtv)
11562			}
11563
11564		case "CreatedTime":
11565			if value != nil {
11566				jtv, ok := value.(json.Number)
11567				if !ok {
11568					return fmt.Errorf("expected CreationTime to be json.Number, got %T instead", value)
11569				}
11570				f64, err := jtv.Float64()
11571				if err != nil {
11572					return err
11573				}
11574				sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
11575			}
11576
11577		case "Description":
11578			if value != nil {
11579				jtv, ok := value.(string)
11580				if !ok {
11581					return fmt.Errorf("expected PortfolioDescription to be of type string, got %T instead", value)
11582				}
11583				sv.Description = ptr.String(jtv)
11584			}
11585
11586		case "DisplayName":
11587			if value != nil {
11588				jtv, ok := value.(string)
11589				if !ok {
11590					return fmt.Errorf("expected PortfolioDisplayName to be of type string, got %T instead", value)
11591				}
11592				sv.DisplayName = ptr.String(jtv)
11593			}
11594
11595		case "Id":
11596			if value != nil {
11597				jtv, ok := value.(string)
11598				if !ok {
11599					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
11600				}
11601				sv.Id = ptr.String(jtv)
11602			}
11603
11604		case "ProviderName":
11605			if value != nil {
11606				jtv, ok := value.(string)
11607				if !ok {
11608					return fmt.Errorf("expected ProviderName to be of type string, got %T instead", value)
11609				}
11610				sv.ProviderName = ptr.String(jtv)
11611			}
11612
11613		default:
11614			_, _ = key, value
11615
11616		}
11617	}
11618	*v = sv
11619	return nil
11620}
11621
11622func awsAwsjson11_deserializeDocumentPortfolioDetails(v *[]types.PortfolioDetail, value interface{}) error {
11623	if v == nil {
11624		return fmt.Errorf("unexpected nil of type %T", v)
11625	}
11626	if value == nil {
11627		return nil
11628	}
11629
11630	shape, ok := value.([]interface{})
11631	if !ok {
11632		return fmt.Errorf("unexpected JSON type %v", value)
11633	}
11634
11635	var cv []types.PortfolioDetail
11636	if *v == nil {
11637		cv = []types.PortfolioDetail{}
11638	} else {
11639		cv = *v
11640	}
11641
11642	for _, value := range shape {
11643		var col types.PortfolioDetail
11644		destAddr := &col
11645		if err := awsAwsjson11_deserializeDocumentPortfolioDetail(&destAddr, value); err != nil {
11646			return err
11647		}
11648		col = *destAddr
11649		cv = append(cv, col)
11650
11651	}
11652	*v = cv
11653	return nil
11654}
11655
11656func awsAwsjson11_deserializeDocumentPortfolioShareDetail(v **types.PortfolioShareDetail, value interface{}) error {
11657	if v == nil {
11658		return fmt.Errorf("unexpected nil of type %T", v)
11659	}
11660	if value == nil {
11661		return nil
11662	}
11663
11664	shape, ok := value.(map[string]interface{})
11665	if !ok {
11666		return fmt.Errorf("unexpected JSON type %v", value)
11667	}
11668
11669	var sv *types.PortfolioShareDetail
11670	if *v == nil {
11671		sv = &types.PortfolioShareDetail{}
11672	} else {
11673		sv = *v
11674	}
11675
11676	for key, value := range shape {
11677		switch key {
11678		case "Accepted":
11679			if value != nil {
11680				jtv, ok := value.(bool)
11681				if !ok {
11682					return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
11683				}
11684				sv.Accepted = jtv
11685			}
11686
11687		case "PrincipalId":
11688			if value != nil {
11689				jtv, ok := value.(string)
11690				if !ok {
11691					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
11692				}
11693				sv.PrincipalId = ptr.String(jtv)
11694			}
11695
11696		case "ShareTagOptions":
11697			if value != nil {
11698				jtv, ok := value.(bool)
11699				if !ok {
11700					return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value)
11701				}
11702				sv.ShareTagOptions = jtv
11703			}
11704
11705		case "Type":
11706			if value != nil {
11707				jtv, ok := value.(string)
11708				if !ok {
11709					return fmt.Errorf("expected DescribePortfolioShareType to be of type string, got %T instead", value)
11710				}
11711				sv.Type = types.DescribePortfolioShareType(jtv)
11712			}
11713
11714		default:
11715			_, _ = key, value
11716
11717		}
11718	}
11719	*v = sv
11720	return nil
11721}
11722
11723func awsAwsjson11_deserializeDocumentPortfolioShareDetails(v *[]types.PortfolioShareDetail, value interface{}) error {
11724	if v == nil {
11725		return fmt.Errorf("unexpected nil of type %T", v)
11726	}
11727	if value == nil {
11728		return nil
11729	}
11730
11731	shape, ok := value.([]interface{})
11732	if !ok {
11733		return fmt.Errorf("unexpected JSON type %v", value)
11734	}
11735
11736	var cv []types.PortfolioShareDetail
11737	if *v == nil {
11738		cv = []types.PortfolioShareDetail{}
11739	} else {
11740		cv = *v
11741	}
11742
11743	for _, value := range shape {
11744		var col types.PortfolioShareDetail
11745		destAddr := &col
11746		if err := awsAwsjson11_deserializeDocumentPortfolioShareDetail(&destAddr, value); err != nil {
11747			return err
11748		}
11749		col = *destAddr
11750		cv = append(cv, col)
11751
11752	}
11753	*v = cv
11754	return nil
11755}
11756
11757func awsAwsjson11_deserializeDocumentPrincipal(v **types.Principal, value interface{}) error {
11758	if v == nil {
11759		return fmt.Errorf("unexpected nil of type %T", v)
11760	}
11761	if value == nil {
11762		return nil
11763	}
11764
11765	shape, ok := value.(map[string]interface{})
11766	if !ok {
11767		return fmt.Errorf("unexpected JSON type %v", value)
11768	}
11769
11770	var sv *types.Principal
11771	if *v == nil {
11772		sv = &types.Principal{}
11773	} else {
11774		sv = *v
11775	}
11776
11777	for key, value := range shape {
11778		switch key {
11779		case "PrincipalARN":
11780			if value != nil {
11781				jtv, ok := value.(string)
11782				if !ok {
11783					return fmt.Errorf("expected PrincipalARN to be of type string, got %T instead", value)
11784				}
11785				sv.PrincipalARN = ptr.String(jtv)
11786			}
11787
11788		case "PrincipalType":
11789			if value != nil {
11790				jtv, ok := value.(string)
11791				if !ok {
11792					return fmt.Errorf("expected PrincipalType to be of type string, got %T instead", value)
11793				}
11794				sv.PrincipalType = types.PrincipalType(jtv)
11795			}
11796
11797		default:
11798			_, _ = key, value
11799
11800		}
11801	}
11802	*v = sv
11803	return nil
11804}
11805
11806func awsAwsjson11_deserializeDocumentPrincipals(v *[]types.Principal, value interface{}) error {
11807	if v == nil {
11808		return fmt.Errorf("unexpected nil of type %T", v)
11809	}
11810	if value == nil {
11811		return nil
11812	}
11813
11814	shape, ok := value.([]interface{})
11815	if !ok {
11816		return fmt.Errorf("unexpected JSON type %v", value)
11817	}
11818
11819	var cv []types.Principal
11820	if *v == nil {
11821		cv = []types.Principal{}
11822	} else {
11823		cv = *v
11824	}
11825
11826	for _, value := range shape {
11827		var col types.Principal
11828		destAddr := &col
11829		if err := awsAwsjson11_deserializeDocumentPrincipal(&destAddr, value); err != nil {
11830			return err
11831		}
11832		col = *destAddr
11833		cv = append(cv, col)
11834
11835	}
11836	*v = cv
11837	return nil
11838}
11839
11840func awsAwsjson11_deserializeDocumentProductViewAggregations(v *map[string][]types.ProductViewAggregationValue, value interface{}) error {
11841	if v == nil {
11842		return fmt.Errorf("unexpected nil of type %T", v)
11843	}
11844	if value == nil {
11845		return nil
11846	}
11847
11848	shape, ok := value.(map[string]interface{})
11849	if !ok {
11850		return fmt.Errorf("unexpected JSON type %v", value)
11851	}
11852
11853	var mv map[string][]types.ProductViewAggregationValue
11854	if *v == nil {
11855		mv = map[string][]types.ProductViewAggregationValue{}
11856	} else {
11857		mv = *v
11858	}
11859
11860	for key, value := range shape {
11861		var parsedVal []types.ProductViewAggregationValue
11862		mapVar := parsedVal
11863		if err := awsAwsjson11_deserializeDocumentProductViewAggregationValues(&mapVar, value); err != nil {
11864			return err
11865		}
11866		parsedVal = mapVar
11867		mv[key] = parsedVal
11868
11869	}
11870	*v = mv
11871	return nil
11872}
11873
11874func awsAwsjson11_deserializeDocumentProductViewAggregationValue(v **types.ProductViewAggregationValue, value interface{}) error {
11875	if v == nil {
11876		return fmt.Errorf("unexpected nil of type %T", v)
11877	}
11878	if value == nil {
11879		return nil
11880	}
11881
11882	shape, ok := value.(map[string]interface{})
11883	if !ok {
11884		return fmt.Errorf("unexpected JSON type %v", value)
11885	}
11886
11887	var sv *types.ProductViewAggregationValue
11888	if *v == nil {
11889		sv = &types.ProductViewAggregationValue{}
11890	} else {
11891		sv = *v
11892	}
11893
11894	for key, value := range shape {
11895		switch key {
11896		case "ApproximateCount":
11897			if value != nil {
11898				jtv, ok := value.(json.Number)
11899				if !ok {
11900					return fmt.Errorf("expected ApproximateCount to be json.Number, got %T instead", value)
11901				}
11902				i64, err := jtv.Int64()
11903				if err != nil {
11904					return err
11905				}
11906				sv.ApproximateCount = int32(i64)
11907			}
11908
11909		case "Value":
11910			if value != nil {
11911				jtv, ok := value.(string)
11912				if !ok {
11913					return fmt.Errorf("expected AttributeValue to be of type string, got %T instead", value)
11914				}
11915				sv.Value = ptr.String(jtv)
11916			}
11917
11918		default:
11919			_, _ = key, value
11920
11921		}
11922	}
11923	*v = sv
11924	return nil
11925}
11926
11927func awsAwsjson11_deserializeDocumentProductViewAggregationValues(v *[]types.ProductViewAggregationValue, value interface{}) error {
11928	if v == nil {
11929		return fmt.Errorf("unexpected nil of type %T", v)
11930	}
11931	if value == nil {
11932		return nil
11933	}
11934
11935	shape, ok := value.([]interface{})
11936	if !ok {
11937		return fmt.Errorf("unexpected JSON type %v", value)
11938	}
11939
11940	var cv []types.ProductViewAggregationValue
11941	if *v == nil {
11942		cv = []types.ProductViewAggregationValue{}
11943	} else {
11944		cv = *v
11945	}
11946
11947	for _, value := range shape {
11948		var col types.ProductViewAggregationValue
11949		destAddr := &col
11950		if err := awsAwsjson11_deserializeDocumentProductViewAggregationValue(&destAddr, value); err != nil {
11951			return err
11952		}
11953		col = *destAddr
11954		cv = append(cv, col)
11955
11956	}
11957	*v = cv
11958	return nil
11959}
11960
11961func awsAwsjson11_deserializeDocumentProductViewDetail(v **types.ProductViewDetail, value interface{}) error {
11962	if v == nil {
11963		return fmt.Errorf("unexpected nil of type %T", v)
11964	}
11965	if value == nil {
11966		return nil
11967	}
11968
11969	shape, ok := value.(map[string]interface{})
11970	if !ok {
11971		return fmt.Errorf("unexpected JSON type %v", value)
11972	}
11973
11974	var sv *types.ProductViewDetail
11975	if *v == nil {
11976		sv = &types.ProductViewDetail{}
11977	} else {
11978		sv = *v
11979	}
11980
11981	for key, value := range shape {
11982		switch key {
11983		case "CreatedTime":
11984			if value != nil {
11985				jtv, ok := value.(json.Number)
11986				if !ok {
11987					return fmt.Errorf("expected CreatedTime to be json.Number, got %T instead", value)
11988				}
11989				f64, err := jtv.Float64()
11990				if err != nil {
11991					return err
11992				}
11993				sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
11994			}
11995
11996		case "ProductARN":
11997			if value != nil {
11998				jtv, ok := value.(string)
11999				if !ok {
12000					return fmt.Errorf("expected ResourceARN to be of type string, got %T instead", value)
12001				}
12002				sv.ProductARN = ptr.String(jtv)
12003			}
12004
12005		case "ProductViewSummary":
12006			if err := awsAwsjson11_deserializeDocumentProductViewSummary(&sv.ProductViewSummary, value); err != nil {
12007				return err
12008			}
12009
12010		case "Status":
12011			if value != nil {
12012				jtv, ok := value.(string)
12013				if !ok {
12014					return fmt.Errorf("expected Status to be of type string, got %T instead", value)
12015				}
12016				sv.Status = types.Status(jtv)
12017			}
12018
12019		default:
12020			_, _ = key, value
12021
12022		}
12023	}
12024	*v = sv
12025	return nil
12026}
12027
12028func awsAwsjson11_deserializeDocumentProductViewDetails(v *[]types.ProductViewDetail, value interface{}) error {
12029	if v == nil {
12030		return fmt.Errorf("unexpected nil of type %T", v)
12031	}
12032	if value == nil {
12033		return nil
12034	}
12035
12036	shape, ok := value.([]interface{})
12037	if !ok {
12038		return fmt.Errorf("unexpected JSON type %v", value)
12039	}
12040
12041	var cv []types.ProductViewDetail
12042	if *v == nil {
12043		cv = []types.ProductViewDetail{}
12044	} else {
12045		cv = *v
12046	}
12047
12048	for _, value := range shape {
12049		var col types.ProductViewDetail
12050		destAddr := &col
12051		if err := awsAwsjson11_deserializeDocumentProductViewDetail(&destAddr, value); err != nil {
12052			return err
12053		}
12054		col = *destAddr
12055		cv = append(cv, col)
12056
12057	}
12058	*v = cv
12059	return nil
12060}
12061
12062func awsAwsjson11_deserializeDocumentProductViewSummaries(v *[]types.ProductViewSummary, value interface{}) error {
12063	if v == nil {
12064		return fmt.Errorf("unexpected nil of type %T", v)
12065	}
12066	if value == nil {
12067		return nil
12068	}
12069
12070	shape, ok := value.([]interface{})
12071	if !ok {
12072		return fmt.Errorf("unexpected JSON type %v", value)
12073	}
12074
12075	var cv []types.ProductViewSummary
12076	if *v == nil {
12077		cv = []types.ProductViewSummary{}
12078	} else {
12079		cv = *v
12080	}
12081
12082	for _, value := range shape {
12083		var col types.ProductViewSummary
12084		destAddr := &col
12085		if err := awsAwsjson11_deserializeDocumentProductViewSummary(&destAddr, value); err != nil {
12086			return err
12087		}
12088		col = *destAddr
12089		cv = append(cv, col)
12090
12091	}
12092	*v = cv
12093	return nil
12094}
12095
12096func awsAwsjson11_deserializeDocumentProductViewSummary(v **types.ProductViewSummary, value interface{}) error {
12097	if v == nil {
12098		return fmt.Errorf("unexpected nil of type %T", v)
12099	}
12100	if value == nil {
12101		return nil
12102	}
12103
12104	shape, ok := value.(map[string]interface{})
12105	if !ok {
12106		return fmt.Errorf("unexpected JSON type %v", value)
12107	}
12108
12109	var sv *types.ProductViewSummary
12110	if *v == nil {
12111		sv = &types.ProductViewSummary{}
12112	} else {
12113		sv = *v
12114	}
12115
12116	for key, value := range shape {
12117		switch key {
12118		case "Distributor":
12119			if value != nil {
12120				jtv, ok := value.(string)
12121				if !ok {
12122					return fmt.Errorf("expected ProductViewDistributor to be of type string, got %T instead", value)
12123				}
12124				sv.Distributor = ptr.String(jtv)
12125			}
12126
12127		case "HasDefaultPath":
12128			if value != nil {
12129				jtv, ok := value.(bool)
12130				if !ok {
12131					return fmt.Errorf("expected HasDefaultPath to be of type *bool, got %T instead", value)
12132				}
12133				sv.HasDefaultPath = jtv
12134			}
12135
12136		case "Id":
12137			if value != nil {
12138				jtv, ok := value.(string)
12139				if !ok {
12140					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
12141				}
12142				sv.Id = ptr.String(jtv)
12143			}
12144
12145		case "Name":
12146			if value != nil {
12147				jtv, ok := value.(string)
12148				if !ok {
12149					return fmt.Errorf("expected ProductViewName to be of type string, got %T instead", value)
12150				}
12151				sv.Name = ptr.String(jtv)
12152			}
12153
12154		case "Owner":
12155			if value != nil {
12156				jtv, ok := value.(string)
12157				if !ok {
12158					return fmt.Errorf("expected ProductViewOwner to be of type string, got %T instead", value)
12159				}
12160				sv.Owner = ptr.String(jtv)
12161			}
12162
12163		case "ProductId":
12164			if value != nil {
12165				jtv, ok := value.(string)
12166				if !ok {
12167					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
12168				}
12169				sv.ProductId = ptr.String(jtv)
12170			}
12171
12172		case "ShortDescription":
12173			if value != nil {
12174				jtv, ok := value.(string)
12175				if !ok {
12176					return fmt.Errorf("expected ProductViewShortDescription to be of type string, got %T instead", value)
12177				}
12178				sv.ShortDescription = ptr.String(jtv)
12179			}
12180
12181		case "SupportDescription":
12182			if value != nil {
12183				jtv, ok := value.(string)
12184				if !ok {
12185					return fmt.Errorf("expected SupportDescription to be of type string, got %T instead", value)
12186				}
12187				sv.SupportDescription = ptr.String(jtv)
12188			}
12189
12190		case "SupportEmail":
12191			if value != nil {
12192				jtv, ok := value.(string)
12193				if !ok {
12194					return fmt.Errorf("expected SupportEmail to be of type string, got %T instead", value)
12195				}
12196				sv.SupportEmail = ptr.String(jtv)
12197			}
12198
12199		case "SupportUrl":
12200			if value != nil {
12201				jtv, ok := value.(string)
12202				if !ok {
12203					return fmt.Errorf("expected SupportUrl to be of type string, got %T instead", value)
12204				}
12205				sv.SupportUrl = ptr.String(jtv)
12206			}
12207
12208		case "Type":
12209			if value != nil {
12210				jtv, ok := value.(string)
12211				if !ok {
12212					return fmt.Errorf("expected ProductType to be of type string, got %T instead", value)
12213				}
12214				sv.Type = types.ProductType(jtv)
12215			}
12216
12217		default:
12218			_, _ = key, value
12219
12220		}
12221	}
12222	*v = sv
12223	return nil
12224}
12225
12226func awsAwsjson11_deserializeDocumentProvisionedProductAttribute(v **types.ProvisionedProductAttribute, value interface{}) error {
12227	if v == nil {
12228		return fmt.Errorf("unexpected nil of type %T", v)
12229	}
12230	if value == nil {
12231		return nil
12232	}
12233
12234	shape, ok := value.(map[string]interface{})
12235	if !ok {
12236		return fmt.Errorf("unexpected JSON type %v", value)
12237	}
12238
12239	var sv *types.ProvisionedProductAttribute
12240	if *v == nil {
12241		sv = &types.ProvisionedProductAttribute{}
12242	} else {
12243		sv = *v
12244	}
12245
12246	for key, value := range shape {
12247		switch key {
12248		case "Arn":
12249			if value != nil {
12250				jtv, ok := value.(string)
12251				if !ok {
12252					return fmt.Errorf("expected ProvisionedProductNameOrArn to be of type string, got %T instead", value)
12253				}
12254				sv.Arn = ptr.String(jtv)
12255			}
12256
12257		case "CreatedTime":
12258			if value != nil {
12259				jtv, ok := value.(json.Number)
12260				if !ok {
12261					return fmt.Errorf("expected CreatedTime to be json.Number, got %T instead", value)
12262				}
12263				f64, err := jtv.Float64()
12264				if err != nil {
12265					return err
12266				}
12267				sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
12268			}
12269
12270		case "Id":
12271			if value != nil {
12272				jtv, ok := value.(string)
12273				if !ok {
12274					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
12275				}
12276				sv.Id = ptr.String(jtv)
12277			}
12278
12279		case "IdempotencyToken":
12280			if value != nil {
12281				jtv, ok := value.(string)
12282				if !ok {
12283					return fmt.Errorf("expected IdempotencyToken to be of type string, got %T instead", value)
12284				}
12285				sv.IdempotencyToken = ptr.String(jtv)
12286			}
12287
12288		case "LastProvisioningRecordId":
12289			if value != nil {
12290				jtv, ok := value.(string)
12291				if !ok {
12292					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
12293				}
12294				sv.LastProvisioningRecordId = ptr.String(jtv)
12295			}
12296
12297		case "LastRecordId":
12298			if value != nil {
12299				jtv, ok := value.(string)
12300				if !ok {
12301					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
12302				}
12303				sv.LastRecordId = ptr.String(jtv)
12304			}
12305
12306		case "LastSuccessfulProvisioningRecordId":
12307			if value != nil {
12308				jtv, ok := value.(string)
12309				if !ok {
12310					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
12311				}
12312				sv.LastSuccessfulProvisioningRecordId = ptr.String(jtv)
12313			}
12314
12315		case "Name":
12316			if value != nil {
12317				jtv, ok := value.(string)
12318				if !ok {
12319					return fmt.Errorf("expected ProvisionedProductNameOrArn to be of type string, got %T instead", value)
12320				}
12321				sv.Name = ptr.String(jtv)
12322			}
12323
12324		case "PhysicalId":
12325			if value != nil {
12326				jtv, ok := value.(string)
12327				if !ok {
12328					return fmt.Errorf("expected PhysicalId to be of type string, got %T instead", value)
12329				}
12330				sv.PhysicalId = ptr.String(jtv)
12331			}
12332
12333		case "ProductId":
12334			if value != nil {
12335				jtv, ok := value.(string)
12336				if !ok {
12337					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
12338				}
12339				sv.ProductId = ptr.String(jtv)
12340			}
12341
12342		case "ProductName":
12343			if value != nil {
12344				jtv, ok := value.(string)
12345				if !ok {
12346					return fmt.Errorf("expected ProductViewName to be of type string, got %T instead", value)
12347				}
12348				sv.ProductName = ptr.String(jtv)
12349			}
12350
12351		case "ProvisioningArtifactId":
12352			if value != nil {
12353				jtv, ok := value.(string)
12354				if !ok {
12355					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
12356				}
12357				sv.ProvisioningArtifactId = ptr.String(jtv)
12358			}
12359
12360		case "ProvisioningArtifactName":
12361			if value != nil {
12362				jtv, ok := value.(string)
12363				if !ok {
12364					return fmt.Errorf("expected ProvisioningArtifactName to be of type string, got %T instead", value)
12365				}
12366				sv.ProvisioningArtifactName = ptr.String(jtv)
12367			}
12368
12369		case "Status":
12370			if value != nil {
12371				jtv, ok := value.(string)
12372				if !ok {
12373					return fmt.Errorf("expected ProvisionedProductStatus to be of type string, got %T instead", value)
12374				}
12375				sv.Status = types.ProvisionedProductStatus(jtv)
12376			}
12377
12378		case "StatusMessage":
12379			if value != nil {
12380				jtv, ok := value.(string)
12381				if !ok {
12382					return fmt.Errorf("expected ProvisionedProductStatusMessage to be of type string, got %T instead", value)
12383				}
12384				sv.StatusMessage = ptr.String(jtv)
12385			}
12386
12387		case "Tags":
12388			if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
12389				return err
12390			}
12391
12392		case "Type":
12393			if value != nil {
12394				jtv, ok := value.(string)
12395				if !ok {
12396					return fmt.Errorf("expected ProvisionedProductType to be of type string, got %T instead", value)
12397				}
12398				sv.Type = ptr.String(jtv)
12399			}
12400
12401		case "UserArn":
12402			if value != nil {
12403				jtv, ok := value.(string)
12404				if !ok {
12405					return fmt.Errorf("expected UserArn to be of type string, got %T instead", value)
12406				}
12407				sv.UserArn = ptr.String(jtv)
12408			}
12409
12410		case "UserArnSession":
12411			if value != nil {
12412				jtv, ok := value.(string)
12413				if !ok {
12414					return fmt.Errorf("expected UserArnSession to be of type string, got %T instead", value)
12415				}
12416				sv.UserArnSession = ptr.String(jtv)
12417			}
12418
12419		default:
12420			_, _ = key, value
12421
12422		}
12423	}
12424	*v = sv
12425	return nil
12426}
12427
12428func awsAwsjson11_deserializeDocumentProvisionedProductAttributes(v *[]types.ProvisionedProductAttribute, value interface{}) error {
12429	if v == nil {
12430		return fmt.Errorf("unexpected nil of type %T", v)
12431	}
12432	if value == nil {
12433		return nil
12434	}
12435
12436	shape, ok := value.([]interface{})
12437	if !ok {
12438		return fmt.Errorf("unexpected JSON type %v", value)
12439	}
12440
12441	var cv []types.ProvisionedProductAttribute
12442	if *v == nil {
12443		cv = []types.ProvisionedProductAttribute{}
12444	} else {
12445		cv = *v
12446	}
12447
12448	for _, value := range shape {
12449		var col types.ProvisionedProductAttribute
12450		destAddr := &col
12451		if err := awsAwsjson11_deserializeDocumentProvisionedProductAttribute(&destAddr, value); err != nil {
12452			return err
12453		}
12454		col = *destAddr
12455		cv = append(cv, col)
12456
12457	}
12458	*v = cv
12459	return nil
12460}
12461
12462func awsAwsjson11_deserializeDocumentProvisionedProductDetail(v **types.ProvisionedProductDetail, value interface{}) error {
12463	if v == nil {
12464		return fmt.Errorf("unexpected nil of type %T", v)
12465	}
12466	if value == nil {
12467		return nil
12468	}
12469
12470	shape, ok := value.(map[string]interface{})
12471	if !ok {
12472		return fmt.Errorf("unexpected JSON type %v", value)
12473	}
12474
12475	var sv *types.ProvisionedProductDetail
12476	if *v == nil {
12477		sv = &types.ProvisionedProductDetail{}
12478	} else {
12479		sv = *v
12480	}
12481
12482	for key, value := range shape {
12483		switch key {
12484		case "Arn":
12485			if value != nil {
12486				jtv, ok := value.(string)
12487				if !ok {
12488					return fmt.Errorf("expected ProvisionedProductNameOrArn to be of type string, got %T instead", value)
12489				}
12490				sv.Arn = ptr.String(jtv)
12491			}
12492
12493		case "CreatedTime":
12494			if value != nil {
12495				jtv, ok := value.(json.Number)
12496				if !ok {
12497					return fmt.Errorf("expected CreatedTime to be json.Number, got %T instead", value)
12498				}
12499				f64, err := jtv.Float64()
12500				if err != nil {
12501					return err
12502				}
12503				sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
12504			}
12505
12506		case "Id":
12507			if value != nil {
12508				jtv, ok := value.(string)
12509				if !ok {
12510					return fmt.Errorf("expected ProvisionedProductId to be of type string, got %T instead", value)
12511				}
12512				sv.Id = ptr.String(jtv)
12513			}
12514
12515		case "IdempotencyToken":
12516			if value != nil {
12517				jtv, ok := value.(string)
12518				if !ok {
12519					return fmt.Errorf("expected IdempotencyToken to be of type string, got %T instead", value)
12520				}
12521				sv.IdempotencyToken = ptr.String(jtv)
12522			}
12523
12524		case "LastProvisioningRecordId":
12525			if value != nil {
12526				jtv, ok := value.(string)
12527				if !ok {
12528					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
12529				}
12530				sv.LastProvisioningRecordId = ptr.String(jtv)
12531			}
12532
12533		case "LastRecordId":
12534			if value != nil {
12535				jtv, ok := value.(string)
12536				if !ok {
12537					return fmt.Errorf("expected LastRequestId to be of type string, got %T instead", value)
12538				}
12539				sv.LastRecordId = ptr.String(jtv)
12540			}
12541
12542		case "LastSuccessfulProvisioningRecordId":
12543			if value != nil {
12544				jtv, ok := value.(string)
12545				if !ok {
12546					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
12547				}
12548				sv.LastSuccessfulProvisioningRecordId = ptr.String(jtv)
12549			}
12550
12551		case "LaunchRoleArn":
12552			if value != nil {
12553				jtv, ok := value.(string)
12554				if !ok {
12555					return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value)
12556				}
12557				sv.LaunchRoleArn = ptr.String(jtv)
12558			}
12559
12560		case "Name":
12561			if value != nil {
12562				jtv, ok := value.(string)
12563				if !ok {
12564					return fmt.Errorf("expected ProvisionedProductNameOrArn to be of type string, got %T instead", value)
12565				}
12566				sv.Name = ptr.String(jtv)
12567			}
12568
12569		case "ProductId":
12570			if value != nil {
12571				jtv, ok := value.(string)
12572				if !ok {
12573					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
12574				}
12575				sv.ProductId = ptr.String(jtv)
12576			}
12577
12578		case "ProvisioningArtifactId":
12579			if value != nil {
12580				jtv, ok := value.(string)
12581				if !ok {
12582					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
12583				}
12584				sv.ProvisioningArtifactId = ptr.String(jtv)
12585			}
12586
12587		case "Status":
12588			if value != nil {
12589				jtv, ok := value.(string)
12590				if !ok {
12591					return fmt.Errorf("expected ProvisionedProductStatus to be of type string, got %T instead", value)
12592				}
12593				sv.Status = types.ProvisionedProductStatus(jtv)
12594			}
12595
12596		case "StatusMessage":
12597			if value != nil {
12598				jtv, ok := value.(string)
12599				if !ok {
12600					return fmt.Errorf("expected ProvisionedProductStatusMessage to be of type string, got %T instead", value)
12601				}
12602				sv.StatusMessage = ptr.String(jtv)
12603			}
12604
12605		case "Type":
12606			if value != nil {
12607				jtv, ok := value.(string)
12608				if !ok {
12609					return fmt.Errorf("expected ProvisionedProductType to be of type string, got %T instead", value)
12610				}
12611				sv.Type = ptr.String(jtv)
12612			}
12613
12614		default:
12615			_, _ = key, value
12616
12617		}
12618	}
12619	*v = sv
12620	return nil
12621}
12622
12623func awsAwsjson11_deserializeDocumentProvisionedProductDetails(v *[]types.ProvisionedProductDetail, value interface{}) error {
12624	if v == nil {
12625		return fmt.Errorf("unexpected nil of type %T", v)
12626	}
12627	if value == nil {
12628		return nil
12629	}
12630
12631	shape, ok := value.([]interface{})
12632	if !ok {
12633		return fmt.Errorf("unexpected JSON type %v", value)
12634	}
12635
12636	var cv []types.ProvisionedProductDetail
12637	if *v == nil {
12638		cv = []types.ProvisionedProductDetail{}
12639	} else {
12640		cv = *v
12641	}
12642
12643	for _, value := range shape {
12644		var col types.ProvisionedProductDetail
12645		destAddr := &col
12646		if err := awsAwsjson11_deserializeDocumentProvisionedProductDetail(&destAddr, value); err != nil {
12647			return err
12648		}
12649		col = *destAddr
12650		cv = append(cv, col)
12651
12652	}
12653	*v = cv
12654	return nil
12655}
12656
12657func awsAwsjson11_deserializeDocumentProvisionedProductPlanDetails(v **types.ProvisionedProductPlanDetails, value interface{}) error {
12658	if v == nil {
12659		return fmt.Errorf("unexpected nil of type %T", v)
12660	}
12661	if value == nil {
12662		return nil
12663	}
12664
12665	shape, ok := value.(map[string]interface{})
12666	if !ok {
12667		return fmt.Errorf("unexpected JSON type %v", value)
12668	}
12669
12670	var sv *types.ProvisionedProductPlanDetails
12671	if *v == nil {
12672		sv = &types.ProvisionedProductPlanDetails{}
12673	} else {
12674		sv = *v
12675	}
12676
12677	for key, value := range shape {
12678		switch key {
12679		case "CreatedTime":
12680			if value != nil {
12681				jtv, ok := value.(json.Number)
12682				if !ok {
12683					return fmt.Errorf("expected CreatedTime to be json.Number, got %T instead", value)
12684				}
12685				f64, err := jtv.Float64()
12686				if err != nil {
12687					return err
12688				}
12689				sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
12690			}
12691
12692		case "NotificationArns":
12693			if err := awsAwsjson11_deserializeDocumentNotificationArns(&sv.NotificationArns, value); err != nil {
12694				return err
12695			}
12696
12697		case "PathId":
12698			if value != nil {
12699				jtv, ok := value.(string)
12700				if !ok {
12701					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
12702				}
12703				sv.PathId = ptr.String(jtv)
12704			}
12705
12706		case "PlanId":
12707			if value != nil {
12708				jtv, ok := value.(string)
12709				if !ok {
12710					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
12711				}
12712				sv.PlanId = ptr.String(jtv)
12713			}
12714
12715		case "PlanName":
12716			if value != nil {
12717				jtv, ok := value.(string)
12718				if !ok {
12719					return fmt.Errorf("expected ProvisionedProductPlanName to be of type string, got %T instead", value)
12720				}
12721				sv.PlanName = ptr.String(jtv)
12722			}
12723
12724		case "PlanType":
12725			if value != nil {
12726				jtv, ok := value.(string)
12727				if !ok {
12728					return fmt.Errorf("expected ProvisionedProductPlanType to be of type string, got %T instead", value)
12729				}
12730				sv.PlanType = types.ProvisionedProductPlanType(jtv)
12731			}
12732
12733		case "ProductId":
12734			if value != nil {
12735				jtv, ok := value.(string)
12736				if !ok {
12737					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
12738				}
12739				sv.ProductId = ptr.String(jtv)
12740			}
12741
12742		case "ProvisioningArtifactId":
12743			if value != nil {
12744				jtv, ok := value.(string)
12745				if !ok {
12746					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
12747				}
12748				sv.ProvisioningArtifactId = ptr.String(jtv)
12749			}
12750
12751		case "ProvisioningParameters":
12752			if err := awsAwsjson11_deserializeDocumentUpdateProvisioningParameters(&sv.ProvisioningParameters, value); err != nil {
12753				return err
12754			}
12755
12756		case "ProvisionProductId":
12757			if value != nil {
12758				jtv, ok := value.(string)
12759				if !ok {
12760					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
12761				}
12762				sv.ProvisionProductId = ptr.String(jtv)
12763			}
12764
12765		case "ProvisionProductName":
12766			if value != nil {
12767				jtv, ok := value.(string)
12768				if !ok {
12769					return fmt.Errorf("expected ProvisionedProductName to be of type string, got %T instead", value)
12770				}
12771				sv.ProvisionProductName = ptr.String(jtv)
12772			}
12773
12774		case "Status":
12775			if value != nil {
12776				jtv, ok := value.(string)
12777				if !ok {
12778					return fmt.Errorf("expected ProvisionedProductPlanStatus to be of type string, got %T instead", value)
12779				}
12780				sv.Status = types.ProvisionedProductPlanStatus(jtv)
12781			}
12782
12783		case "StatusMessage":
12784			if value != nil {
12785				jtv, ok := value.(string)
12786				if !ok {
12787					return fmt.Errorf("expected StatusMessage to be of type string, got %T instead", value)
12788				}
12789				sv.StatusMessage = ptr.String(jtv)
12790			}
12791
12792		case "Tags":
12793			if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
12794				return err
12795			}
12796
12797		case "UpdatedTime":
12798			if value != nil {
12799				jtv, ok := value.(json.Number)
12800				if !ok {
12801					return fmt.Errorf("expected UpdatedTime to be json.Number, got %T instead", value)
12802				}
12803				f64, err := jtv.Float64()
12804				if err != nil {
12805					return err
12806				}
12807				sv.UpdatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
12808			}
12809
12810		default:
12811			_, _ = key, value
12812
12813		}
12814	}
12815	*v = sv
12816	return nil
12817}
12818
12819func awsAwsjson11_deserializeDocumentProvisionedProductPlans(v *[]types.ProvisionedProductPlanSummary, value interface{}) error {
12820	if v == nil {
12821		return fmt.Errorf("unexpected nil of type %T", v)
12822	}
12823	if value == nil {
12824		return nil
12825	}
12826
12827	shape, ok := value.([]interface{})
12828	if !ok {
12829		return fmt.Errorf("unexpected JSON type %v", value)
12830	}
12831
12832	var cv []types.ProvisionedProductPlanSummary
12833	if *v == nil {
12834		cv = []types.ProvisionedProductPlanSummary{}
12835	} else {
12836		cv = *v
12837	}
12838
12839	for _, value := range shape {
12840		var col types.ProvisionedProductPlanSummary
12841		destAddr := &col
12842		if err := awsAwsjson11_deserializeDocumentProvisionedProductPlanSummary(&destAddr, value); err != nil {
12843			return err
12844		}
12845		col = *destAddr
12846		cv = append(cv, col)
12847
12848	}
12849	*v = cv
12850	return nil
12851}
12852
12853func awsAwsjson11_deserializeDocumentProvisionedProductPlanSummary(v **types.ProvisionedProductPlanSummary, value interface{}) error {
12854	if v == nil {
12855		return fmt.Errorf("unexpected nil of type %T", v)
12856	}
12857	if value == nil {
12858		return nil
12859	}
12860
12861	shape, ok := value.(map[string]interface{})
12862	if !ok {
12863		return fmt.Errorf("unexpected JSON type %v", value)
12864	}
12865
12866	var sv *types.ProvisionedProductPlanSummary
12867	if *v == nil {
12868		sv = &types.ProvisionedProductPlanSummary{}
12869	} else {
12870		sv = *v
12871	}
12872
12873	for key, value := range shape {
12874		switch key {
12875		case "PlanId":
12876			if value != nil {
12877				jtv, ok := value.(string)
12878				if !ok {
12879					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
12880				}
12881				sv.PlanId = ptr.String(jtv)
12882			}
12883
12884		case "PlanName":
12885			if value != nil {
12886				jtv, ok := value.(string)
12887				if !ok {
12888					return fmt.Errorf("expected ProvisionedProductPlanName to be of type string, got %T instead", value)
12889				}
12890				sv.PlanName = ptr.String(jtv)
12891			}
12892
12893		case "PlanType":
12894			if value != nil {
12895				jtv, ok := value.(string)
12896				if !ok {
12897					return fmt.Errorf("expected ProvisionedProductPlanType to be of type string, got %T instead", value)
12898				}
12899				sv.PlanType = types.ProvisionedProductPlanType(jtv)
12900			}
12901
12902		case "ProvisioningArtifactId":
12903			if value != nil {
12904				jtv, ok := value.(string)
12905				if !ok {
12906					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
12907				}
12908				sv.ProvisioningArtifactId = ptr.String(jtv)
12909			}
12910
12911		case "ProvisionProductId":
12912			if value != nil {
12913				jtv, ok := value.(string)
12914				if !ok {
12915					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
12916				}
12917				sv.ProvisionProductId = ptr.String(jtv)
12918			}
12919
12920		case "ProvisionProductName":
12921			if value != nil {
12922				jtv, ok := value.(string)
12923				if !ok {
12924					return fmt.Errorf("expected ProvisionedProductName to be of type string, got %T instead", value)
12925				}
12926				sv.ProvisionProductName = ptr.String(jtv)
12927			}
12928
12929		default:
12930			_, _ = key, value
12931
12932		}
12933	}
12934	*v = sv
12935	return nil
12936}
12937
12938func awsAwsjson11_deserializeDocumentProvisionedProductProperties(v *map[string]string, value interface{}) error {
12939	if v == nil {
12940		return fmt.Errorf("unexpected nil of type %T", v)
12941	}
12942	if value == nil {
12943		return nil
12944	}
12945
12946	shape, ok := value.(map[string]interface{})
12947	if !ok {
12948		return fmt.Errorf("unexpected JSON type %v", value)
12949	}
12950
12951	var mv map[string]string
12952	if *v == nil {
12953		mv = map[string]string{}
12954	} else {
12955		mv = *v
12956	}
12957
12958	for key, value := range shape {
12959		var parsedVal string
12960		if value != nil {
12961			jtv, ok := value.(string)
12962			if !ok {
12963				return fmt.Errorf("expected PropertyValue to be of type string, got %T instead", value)
12964			}
12965			parsedVal = jtv
12966		}
12967		mv[key] = parsedVal
12968
12969	}
12970	*v = mv
12971	return nil
12972}
12973
12974func awsAwsjson11_deserializeDocumentProvisioningArtifact(v **types.ProvisioningArtifact, value interface{}) error {
12975	if v == nil {
12976		return fmt.Errorf("unexpected nil of type %T", v)
12977	}
12978	if value == nil {
12979		return nil
12980	}
12981
12982	shape, ok := value.(map[string]interface{})
12983	if !ok {
12984		return fmt.Errorf("unexpected JSON type %v", value)
12985	}
12986
12987	var sv *types.ProvisioningArtifact
12988	if *v == nil {
12989		sv = &types.ProvisioningArtifact{}
12990	} else {
12991		sv = *v
12992	}
12993
12994	for key, value := range shape {
12995		switch key {
12996		case "CreatedTime":
12997			if value != nil {
12998				jtv, ok := value.(json.Number)
12999				if !ok {
13000					return fmt.Errorf("expected ProvisioningArtifactCreatedTime to be json.Number, got %T instead", value)
13001				}
13002				f64, err := jtv.Float64()
13003				if err != nil {
13004					return err
13005				}
13006				sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
13007			}
13008
13009		case "Description":
13010			if value != nil {
13011				jtv, ok := value.(string)
13012				if !ok {
13013					return fmt.Errorf("expected ProvisioningArtifactDescription to be of type string, got %T instead", value)
13014				}
13015				sv.Description = ptr.String(jtv)
13016			}
13017
13018		case "Guidance":
13019			if value != nil {
13020				jtv, ok := value.(string)
13021				if !ok {
13022					return fmt.Errorf("expected ProvisioningArtifactGuidance to be of type string, got %T instead", value)
13023				}
13024				sv.Guidance = types.ProvisioningArtifactGuidance(jtv)
13025			}
13026
13027		case "Id":
13028			if value != nil {
13029				jtv, ok := value.(string)
13030				if !ok {
13031					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
13032				}
13033				sv.Id = ptr.String(jtv)
13034			}
13035
13036		case "Name":
13037			if value != nil {
13038				jtv, ok := value.(string)
13039				if !ok {
13040					return fmt.Errorf("expected ProvisioningArtifactName to be of type string, got %T instead", value)
13041				}
13042				sv.Name = ptr.String(jtv)
13043			}
13044
13045		default:
13046			_, _ = key, value
13047
13048		}
13049	}
13050	*v = sv
13051	return nil
13052}
13053
13054func awsAwsjson11_deserializeDocumentProvisioningArtifactDetail(v **types.ProvisioningArtifactDetail, value interface{}) error {
13055	if v == nil {
13056		return fmt.Errorf("unexpected nil of type %T", v)
13057	}
13058	if value == nil {
13059		return nil
13060	}
13061
13062	shape, ok := value.(map[string]interface{})
13063	if !ok {
13064		return fmt.Errorf("unexpected JSON type %v", value)
13065	}
13066
13067	var sv *types.ProvisioningArtifactDetail
13068	if *v == nil {
13069		sv = &types.ProvisioningArtifactDetail{}
13070	} else {
13071		sv = *v
13072	}
13073
13074	for key, value := range shape {
13075		switch key {
13076		case "Active":
13077			if value != nil {
13078				jtv, ok := value.(bool)
13079				if !ok {
13080					return fmt.Errorf("expected ProvisioningArtifactActive to be of type *bool, got %T instead", value)
13081				}
13082				sv.Active = ptr.Bool(jtv)
13083			}
13084
13085		case "CreatedTime":
13086			if value != nil {
13087				jtv, ok := value.(json.Number)
13088				if !ok {
13089					return fmt.Errorf("expected CreationTime to be json.Number, got %T instead", value)
13090				}
13091				f64, err := jtv.Float64()
13092				if err != nil {
13093					return err
13094				}
13095				sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
13096			}
13097
13098		case "Description":
13099			if value != nil {
13100				jtv, ok := value.(string)
13101				if !ok {
13102					return fmt.Errorf("expected ProvisioningArtifactName to be of type string, got %T instead", value)
13103				}
13104				sv.Description = ptr.String(jtv)
13105			}
13106
13107		case "Guidance":
13108			if value != nil {
13109				jtv, ok := value.(string)
13110				if !ok {
13111					return fmt.Errorf("expected ProvisioningArtifactGuidance to be of type string, got %T instead", value)
13112				}
13113				sv.Guidance = types.ProvisioningArtifactGuidance(jtv)
13114			}
13115
13116		case "Id":
13117			if value != nil {
13118				jtv, ok := value.(string)
13119				if !ok {
13120					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
13121				}
13122				sv.Id = ptr.String(jtv)
13123			}
13124
13125		case "Name":
13126			if value != nil {
13127				jtv, ok := value.(string)
13128				if !ok {
13129					return fmt.Errorf("expected ProvisioningArtifactName to be of type string, got %T instead", value)
13130				}
13131				sv.Name = ptr.String(jtv)
13132			}
13133
13134		case "Type":
13135			if value != nil {
13136				jtv, ok := value.(string)
13137				if !ok {
13138					return fmt.Errorf("expected ProvisioningArtifactType to be of type string, got %T instead", value)
13139				}
13140				sv.Type = types.ProvisioningArtifactType(jtv)
13141			}
13142
13143		default:
13144			_, _ = key, value
13145
13146		}
13147	}
13148	*v = sv
13149	return nil
13150}
13151
13152func awsAwsjson11_deserializeDocumentProvisioningArtifactDetails(v *[]types.ProvisioningArtifactDetail, value interface{}) error {
13153	if v == nil {
13154		return fmt.Errorf("unexpected nil of type %T", v)
13155	}
13156	if value == nil {
13157		return nil
13158	}
13159
13160	shape, ok := value.([]interface{})
13161	if !ok {
13162		return fmt.Errorf("unexpected JSON type %v", value)
13163	}
13164
13165	var cv []types.ProvisioningArtifactDetail
13166	if *v == nil {
13167		cv = []types.ProvisioningArtifactDetail{}
13168	} else {
13169		cv = *v
13170	}
13171
13172	for _, value := range shape {
13173		var col types.ProvisioningArtifactDetail
13174		destAddr := &col
13175		if err := awsAwsjson11_deserializeDocumentProvisioningArtifactDetail(&destAddr, value); err != nil {
13176			return err
13177		}
13178		col = *destAddr
13179		cv = append(cv, col)
13180
13181	}
13182	*v = cv
13183	return nil
13184}
13185
13186func awsAwsjson11_deserializeDocumentProvisioningArtifactInfo(v *map[string]string, value interface{}) error {
13187	if v == nil {
13188		return fmt.Errorf("unexpected nil of type %T", v)
13189	}
13190	if value == nil {
13191		return nil
13192	}
13193
13194	shape, ok := value.(map[string]interface{})
13195	if !ok {
13196		return fmt.Errorf("unexpected JSON type %v", value)
13197	}
13198
13199	var mv map[string]string
13200	if *v == nil {
13201		mv = map[string]string{}
13202	} else {
13203		mv = *v
13204	}
13205
13206	for key, value := range shape {
13207		var parsedVal string
13208		if value != nil {
13209			jtv, ok := value.(string)
13210			if !ok {
13211				return fmt.Errorf("expected ProvisioningArtifactInfoValue to be of type string, got %T instead", value)
13212			}
13213			parsedVal = jtv
13214		}
13215		mv[key] = parsedVal
13216
13217	}
13218	*v = mv
13219	return nil
13220}
13221
13222func awsAwsjson11_deserializeDocumentProvisioningArtifactOutput(v **types.ProvisioningArtifactOutput, value interface{}) error {
13223	if v == nil {
13224		return fmt.Errorf("unexpected nil of type %T", v)
13225	}
13226	if value == nil {
13227		return nil
13228	}
13229
13230	shape, ok := value.(map[string]interface{})
13231	if !ok {
13232		return fmt.Errorf("unexpected JSON type %v", value)
13233	}
13234
13235	var sv *types.ProvisioningArtifactOutput
13236	if *v == nil {
13237		sv = &types.ProvisioningArtifactOutput{}
13238	} else {
13239		sv = *v
13240	}
13241
13242	for key, value := range shape {
13243		switch key {
13244		case "Description":
13245			if value != nil {
13246				jtv, ok := value.(string)
13247				if !ok {
13248					return fmt.Errorf("expected OutputDescription to be of type string, got %T instead", value)
13249				}
13250				sv.Description = ptr.String(jtv)
13251			}
13252
13253		case "Key":
13254			if value != nil {
13255				jtv, ok := value.(string)
13256				if !ok {
13257					return fmt.Errorf("expected ProvisioningArtifactOutputKey to be of type string, got %T instead", value)
13258				}
13259				sv.Key = ptr.String(jtv)
13260			}
13261
13262		default:
13263			_, _ = key, value
13264
13265		}
13266	}
13267	*v = sv
13268	return nil
13269}
13270
13271func awsAwsjson11_deserializeDocumentProvisioningArtifactOutputs(v *[]types.ProvisioningArtifactOutput, value interface{}) error {
13272	if v == nil {
13273		return fmt.Errorf("unexpected nil of type %T", v)
13274	}
13275	if value == nil {
13276		return nil
13277	}
13278
13279	shape, ok := value.([]interface{})
13280	if !ok {
13281		return fmt.Errorf("unexpected JSON type %v", value)
13282	}
13283
13284	var cv []types.ProvisioningArtifactOutput
13285	if *v == nil {
13286		cv = []types.ProvisioningArtifactOutput{}
13287	} else {
13288		cv = *v
13289	}
13290
13291	for _, value := range shape {
13292		var col types.ProvisioningArtifactOutput
13293		destAddr := &col
13294		if err := awsAwsjson11_deserializeDocumentProvisioningArtifactOutput(&destAddr, value); err != nil {
13295			return err
13296		}
13297		col = *destAddr
13298		cv = append(cv, col)
13299
13300	}
13301	*v = cv
13302	return nil
13303}
13304
13305func awsAwsjson11_deserializeDocumentProvisioningArtifactParameter(v **types.ProvisioningArtifactParameter, value interface{}) error {
13306	if v == nil {
13307		return fmt.Errorf("unexpected nil of type %T", v)
13308	}
13309	if value == nil {
13310		return nil
13311	}
13312
13313	shape, ok := value.(map[string]interface{})
13314	if !ok {
13315		return fmt.Errorf("unexpected JSON type %v", value)
13316	}
13317
13318	var sv *types.ProvisioningArtifactParameter
13319	if *v == nil {
13320		sv = &types.ProvisioningArtifactParameter{}
13321	} else {
13322		sv = *v
13323	}
13324
13325	for key, value := range shape {
13326		switch key {
13327		case "DefaultValue":
13328			if value != nil {
13329				jtv, ok := value.(string)
13330				if !ok {
13331					return fmt.Errorf("expected DefaultValue to be of type string, got %T instead", value)
13332				}
13333				sv.DefaultValue = ptr.String(jtv)
13334			}
13335
13336		case "Description":
13337			if value != nil {
13338				jtv, ok := value.(string)
13339				if !ok {
13340					return fmt.Errorf("expected Description to be of type string, got %T instead", value)
13341				}
13342				sv.Description = ptr.String(jtv)
13343			}
13344
13345		case "IsNoEcho":
13346			if value != nil {
13347				jtv, ok := value.(bool)
13348				if !ok {
13349					return fmt.Errorf("expected NoEcho to be of type *bool, got %T instead", value)
13350				}
13351				sv.IsNoEcho = jtv
13352			}
13353
13354		case "ParameterConstraints":
13355			if err := awsAwsjson11_deserializeDocumentParameterConstraints(&sv.ParameterConstraints, value); err != nil {
13356				return err
13357			}
13358
13359		case "ParameterKey":
13360			if value != nil {
13361				jtv, ok := value.(string)
13362				if !ok {
13363					return fmt.Errorf("expected ParameterKey to be of type string, got %T instead", value)
13364				}
13365				sv.ParameterKey = ptr.String(jtv)
13366			}
13367
13368		case "ParameterType":
13369			if value != nil {
13370				jtv, ok := value.(string)
13371				if !ok {
13372					return fmt.Errorf("expected ParameterType to be of type string, got %T instead", value)
13373				}
13374				sv.ParameterType = ptr.String(jtv)
13375			}
13376
13377		default:
13378			_, _ = key, value
13379
13380		}
13381	}
13382	*v = sv
13383	return nil
13384}
13385
13386func awsAwsjson11_deserializeDocumentProvisioningArtifactParameters(v *[]types.ProvisioningArtifactParameter, value interface{}) error {
13387	if v == nil {
13388		return fmt.Errorf("unexpected nil of type %T", v)
13389	}
13390	if value == nil {
13391		return nil
13392	}
13393
13394	shape, ok := value.([]interface{})
13395	if !ok {
13396		return fmt.Errorf("unexpected JSON type %v", value)
13397	}
13398
13399	var cv []types.ProvisioningArtifactParameter
13400	if *v == nil {
13401		cv = []types.ProvisioningArtifactParameter{}
13402	} else {
13403		cv = *v
13404	}
13405
13406	for _, value := range shape {
13407		var col types.ProvisioningArtifactParameter
13408		destAddr := &col
13409		if err := awsAwsjson11_deserializeDocumentProvisioningArtifactParameter(&destAddr, value); err != nil {
13410			return err
13411		}
13412		col = *destAddr
13413		cv = append(cv, col)
13414
13415	}
13416	*v = cv
13417	return nil
13418}
13419
13420func awsAwsjson11_deserializeDocumentProvisioningArtifactPreferences(v **types.ProvisioningArtifactPreferences, value interface{}) error {
13421	if v == nil {
13422		return fmt.Errorf("unexpected nil of type %T", v)
13423	}
13424	if value == nil {
13425		return nil
13426	}
13427
13428	shape, ok := value.(map[string]interface{})
13429	if !ok {
13430		return fmt.Errorf("unexpected JSON type %v", value)
13431	}
13432
13433	var sv *types.ProvisioningArtifactPreferences
13434	if *v == nil {
13435		sv = &types.ProvisioningArtifactPreferences{}
13436	} else {
13437		sv = *v
13438	}
13439
13440	for key, value := range shape {
13441		switch key {
13442		case "StackSetAccounts":
13443			if err := awsAwsjson11_deserializeDocumentStackSetAccounts(&sv.StackSetAccounts, value); err != nil {
13444				return err
13445			}
13446
13447		case "StackSetRegions":
13448			if err := awsAwsjson11_deserializeDocumentStackSetRegions(&sv.StackSetRegions, value); err != nil {
13449				return err
13450			}
13451
13452		default:
13453			_, _ = key, value
13454
13455		}
13456	}
13457	*v = sv
13458	return nil
13459}
13460
13461func awsAwsjson11_deserializeDocumentProvisioningArtifacts(v *[]types.ProvisioningArtifact, value interface{}) error {
13462	if v == nil {
13463		return fmt.Errorf("unexpected nil of type %T", v)
13464	}
13465	if value == nil {
13466		return nil
13467	}
13468
13469	shape, ok := value.([]interface{})
13470	if !ok {
13471		return fmt.Errorf("unexpected JSON type %v", value)
13472	}
13473
13474	var cv []types.ProvisioningArtifact
13475	if *v == nil {
13476		cv = []types.ProvisioningArtifact{}
13477	} else {
13478		cv = *v
13479	}
13480
13481	for _, value := range shape {
13482		var col types.ProvisioningArtifact
13483		destAddr := &col
13484		if err := awsAwsjson11_deserializeDocumentProvisioningArtifact(&destAddr, value); err != nil {
13485			return err
13486		}
13487		col = *destAddr
13488		cv = append(cv, col)
13489
13490	}
13491	*v = cv
13492	return nil
13493}
13494
13495func awsAwsjson11_deserializeDocumentProvisioningArtifactSummaries(v *[]types.ProvisioningArtifactSummary, value interface{}) error {
13496	if v == nil {
13497		return fmt.Errorf("unexpected nil of type %T", v)
13498	}
13499	if value == nil {
13500		return nil
13501	}
13502
13503	shape, ok := value.([]interface{})
13504	if !ok {
13505		return fmt.Errorf("unexpected JSON type %v", value)
13506	}
13507
13508	var cv []types.ProvisioningArtifactSummary
13509	if *v == nil {
13510		cv = []types.ProvisioningArtifactSummary{}
13511	} else {
13512		cv = *v
13513	}
13514
13515	for _, value := range shape {
13516		var col types.ProvisioningArtifactSummary
13517		destAddr := &col
13518		if err := awsAwsjson11_deserializeDocumentProvisioningArtifactSummary(&destAddr, value); err != nil {
13519			return err
13520		}
13521		col = *destAddr
13522		cv = append(cv, col)
13523
13524	}
13525	*v = cv
13526	return nil
13527}
13528
13529func awsAwsjson11_deserializeDocumentProvisioningArtifactSummary(v **types.ProvisioningArtifactSummary, value interface{}) error {
13530	if v == nil {
13531		return fmt.Errorf("unexpected nil of type %T", v)
13532	}
13533	if value == nil {
13534		return nil
13535	}
13536
13537	shape, ok := value.(map[string]interface{})
13538	if !ok {
13539		return fmt.Errorf("unexpected JSON type %v", value)
13540	}
13541
13542	var sv *types.ProvisioningArtifactSummary
13543	if *v == nil {
13544		sv = &types.ProvisioningArtifactSummary{}
13545	} else {
13546		sv = *v
13547	}
13548
13549	for key, value := range shape {
13550		switch key {
13551		case "CreatedTime":
13552			if value != nil {
13553				jtv, ok := value.(json.Number)
13554				if !ok {
13555					return fmt.Errorf("expected ProvisioningArtifactCreatedTime to be json.Number, got %T instead", value)
13556				}
13557				f64, err := jtv.Float64()
13558				if err != nil {
13559					return err
13560				}
13561				sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
13562			}
13563
13564		case "Description":
13565			if value != nil {
13566				jtv, ok := value.(string)
13567				if !ok {
13568					return fmt.Errorf("expected ProvisioningArtifactDescription to be of type string, got %T instead", value)
13569				}
13570				sv.Description = ptr.String(jtv)
13571			}
13572
13573		case "Id":
13574			if value != nil {
13575				jtv, ok := value.(string)
13576				if !ok {
13577					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
13578				}
13579				sv.Id = ptr.String(jtv)
13580			}
13581
13582		case "Name":
13583			if value != nil {
13584				jtv, ok := value.(string)
13585				if !ok {
13586					return fmt.Errorf("expected ProvisioningArtifactName to be of type string, got %T instead", value)
13587				}
13588				sv.Name = ptr.String(jtv)
13589			}
13590
13591		case "ProvisioningArtifactMetadata":
13592			if err := awsAwsjson11_deserializeDocumentProvisioningArtifactInfo(&sv.ProvisioningArtifactMetadata, value); err != nil {
13593				return err
13594			}
13595
13596		default:
13597			_, _ = key, value
13598
13599		}
13600	}
13601	*v = sv
13602	return nil
13603}
13604
13605func awsAwsjson11_deserializeDocumentProvisioningArtifactView(v **types.ProvisioningArtifactView, value interface{}) error {
13606	if v == nil {
13607		return fmt.Errorf("unexpected nil of type %T", v)
13608	}
13609	if value == nil {
13610		return nil
13611	}
13612
13613	shape, ok := value.(map[string]interface{})
13614	if !ok {
13615		return fmt.Errorf("unexpected JSON type %v", value)
13616	}
13617
13618	var sv *types.ProvisioningArtifactView
13619	if *v == nil {
13620		sv = &types.ProvisioningArtifactView{}
13621	} else {
13622		sv = *v
13623	}
13624
13625	for key, value := range shape {
13626		switch key {
13627		case "ProductViewSummary":
13628			if err := awsAwsjson11_deserializeDocumentProductViewSummary(&sv.ProductViewSummary, value); err != nil {
13629				return err
13630			}
13631
13632		case "ProvisioningArtifact":
13633			if err := awsAwsjson11_deserializeDocumentProvisioningArtifact(&sv.ProvisioningArtifact, value); err != nil {
13634				return err
13635			}
13636
13637		default:
13638			_, _ = key, value
13639
13640		}
13641	}
13642	*v = sv
13643	return nil
13644}
13645
13646func awsAwsjson11_deserializeDocumentProvisioningArtifactViews(v *[]types.ProvisioningArtifactView, value interface{}) error {
13647	if v == nil {
13648		return fmt.Errorf("unexpected nil of type %T", v)
13649	}
13650	if value == nil {
13651		return nil
13652	}
13653
13654	shape, ok := value.([]interface{})
13655	if !ok {
13656		return fmt.Errorf("unexpected JSON type %v", value)
13657	}
13658
13659	var cv []types.ProvisioningArtifactView
13660	if *v == nil {
13661		cv = []types.ProvisioningArtifactView{}
13662	} else {
13663		cv = *v
13664	}
13665
13666	for _, value := range shape {
13667		var col types.ProvisioningArtifactView
13668		destAddr := &col
13669		if err := awsAwsjson11_deserializeDocumentProvisioningArtifactView(&destAddr, value); err != nil {
13670			return err
13671		}
13672		col = *destAddr
13673		cv = append(cv, col)
13674
13675	}
13676	*v = cv
13677	return nil
13678}
13679
13680func awsAwsjson11_deserializeDocumentRecordDetail(v **types.RecordDetail, value interface{}) error {
13681	if v == nil {
13682		return fmt.Errorf("unexpected nil of type %T", v)
13683	}
13684	if value == nil {
13685		return nil
13686	}
13687
13688	shape, ok := value.(map[string]interface{})
13689	if !ok {
13690		return fmt.Errorf("unexpected JSON type %v", value)
13691	}
13692
13693	var sv *types.RecordDetail
13694	if *v == nil {
13695		sv = &types.RecordDetail{}
13696	} else {
13697		sv = *v
13698	}
13699
13700	for key, value := range shape {
13701		switch key {
13702		case "CreatedTime":
13703			if value != nil {
13704				jtv, ok := value.(json.Number)
13705				if !ok {
13706					return fmt.Errorf("expected CreatedTime to be json.Number, got %T instead", value)
13707				}
13708				f64, err := jtv.Float64()
13709				if err != nil {
13710					return err
13711				}
13712				sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
13713			}
13714
13715		case "LaunchRoleArn":
13716			if value != nil {
13717				jtv, ok := value.(string)
13718				if !ok {
13719					return fmt.Errorf("expected RoleArn to be of type string, got %T instead", value)
13720				}
13721				sv.LaunchRoleArn = ptr.String(jtv)
13722			}
13723
13724		case "PathId":
13725			if value != nil {
13726				jtv, ok := value.(string)
13727				if !ok {
13728					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
13729				}
13730				sv.PathId = ptr.String(jtv)
13731			}
13732
13733		case "ProductId":
13734			if value != nil {
13735				jtv, ok := value.(string)
13736				if !ok {
13737					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
13738				}
13739				sv.ProductId = ptr.String(jtv)
13740			}
13741
13742		case "ProvisionedProductId":
13743			if value != nil {
13744				jtv, ok := value.(string)
13745				if !ok {
13746					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
13747				}
13748				sv.ProvisionedProductId = ptr.String(jtv)
13749			}
13750
13751		case "ProvisionedProductName":
13752			if value != nil {
13753				jtv, ok := value.(string)
13754				if !ok {
13755					return fmt.Errorf("expected ProvisionedProductName to be of type string, got %T instead", value)
13756				}
13757				sv.ProvisionedProductName = ptr.String(jtv)
13758			}
13759
13760		case "ProvisionedProductType":
13761			if value != nil {
13762				jtv, ok := value.(string)
13763				if !ok {
13764					return fmt.Errorf("expected ProvisionedProductType to be of type string, got %T instead", value)
13765				}
13766				sv.ProvisionedProductType = ptr.String(jtv)
13767			}
13768
13769		case "ProvisioningArtifactId":
13770			if value != nil {
13771				jtv, ok := value.(string)
13772				if !ok {
13773					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
13774				}
13775				sv.ProvisioningArtifactId = ptr.String(jtv)
13776			}
13777
13778		case "RecordErrors":
13779			if err := awsAwsjson11_deserializeDocumentRecordErrors(&sv.RecordErrors, value); err != nil {
13780				return err
13781			}
13782
13783		case "RecordId":
13784			if value != nil {
13785				jtv, ok := value.(string)
13786				if !ok {
13787					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
13788				}
13789				sv.RecordId = ptr.String(jtv)
13790			}
13791
13792		case "RecordTags":
13793			if err := awsAwsjson11_deserializeDocumentRecordTags(&sv.RecordTags, value); err != nil {
13794				return err
13795			}
13796
13797		case "RecordType":
13798			if value != nil {
13799				jtv, ok := value.(string)
13800				if !ok {
13801					return fmt.Errorf("expected RecordType to be of type string, got %T instead", value)
13802				}
13803				sv.RecordType = ptr.String(jtv)
13804			}
13805
13806		case "Status":
13807			if value != nil {
13808				jtv, ok := value.(string)
13809				if !ok {
13810					return fmt.Errorf("expected RecordStatus to be of type string, got %T instead", value)
13811				}
13812				sv.Status = types.RecordStatus(jtv)
13813			}
13814
13815		case "UpdatedTime":
13816			if value != nil {
13817				jtv, ok := value.(json.Number)
13818				if !ok {
13819					return fmt.Errorf("expected UpdatedTime to be json.Number, got %T instead", value)
13820				}
13821				f64, err := jtv.Float64()
13822				if err != nil {
13823					return err
13824				}
13825				sv.UpdatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
13826			}
13827
13828		default:
13829			_, _ = key, value
13830
13831		}
13832	}
13833	*v = sv
13834	return nil
13835}
13836
13837func awsAwsjson11_deserializeDocumentRecordDetails(v *[]types.RecordDetail, value interface{}) error {
13838	if v == nil {
13839		return fmt.Errorf("unexpected nil of type %T", v)
13840	}
13841	if value == nil {
13842		return nil
13843	}
13844
13845	shape, ok := value.([]interface{})
13846	if !ok {
13847		return fmt.Errorf("unexpected JSON type %v", value)
13848	}
13849
13850	var cv []types.RecordDetail
13851	if *v == nil {
13852		cv = []types.RecordDetail{}
13853	} else {
13854		cv = *v
13855	}
13856
13857	for _, value := range shape {
13858		var col types.RecordDetail
13859		destAddr := &col
13860		if err := awsAwsjson11_deserializeDocumentRecordDetail(&destAddr, value); err != nil {
13861			return err
13862		}
13863		col = *destAddr
13864		cv = append(cv, col)
13865
13866	}
13867	*v = cv
13868	return nil
13869}
13870
13871func awsAwsjson11_deserializeDocumentRecordError(v **types.RecordError, value interface{}) error {
13872	if v == nil {
13873		return fmt.Errorf("unexpected nil of type %T", v)
13874	}
13875	if value == nil {
13876		return nil
13877	}
13878
13879	shape, ok := value.(map[string]interface{})
13880	if !ok {
13881		return fmt.Errorf("unexpected JSON type %v", value)
13882	}
13883
13884	var sv *types.RecordError
13885	if *v == nil {
13886		sv = &types.RecordError{}
13887	} else {
13888		sv = *v
13889	}
13890
13891	for key, value := range shape {
13892		switch key {
13893		case "Code":
13894			if value != nil {
13895				jtv, ok := value.(string)
13896				if !ok {
13897					return fmt.Errorf("expected ErrorCode to be of type string, got %T instead", value)
13898				}
13899				sv.Code = ptr.String(jtv)
13900			}
13901
13902		case "Description":
13903			if value != nil {
13904				jtv, ok := value.(string)
13905				if !ok {
13906					return fmt.Errorf("expected ErrorDescription to be of type string, got %T instead", value)
13907				}
13908				sv.Description = ptr.String(jtv)
13909			}
13910
13911		default:
13912			_, _ = key, value
13913
13914		}
13915	}
13916	*v = sv
13917	return nil
13918}
13919
13920func awsAwsjson11_deserializeDocumentRecordErrors(v *[]types.RecordError, value interface{}) error {
13921	if v == nil {
13922		return fmt.Errorf("unexpected nil of type %T", v)
13923	}
13924	if value == nil {
13925		return nil
13926	}
13927
13928	shape, ok := value.([]interface{})
13929	if !ok {
13930		return fmt.Errorf("unexpected JSON type %v", value)
13931	}
13932
13933	var cv []types.RecordError
13934	if *v == nil {
13935		cv = []types.RecordError{}
13936	} else {
13937		cv = *v
13938	}
13939
13940	for _, value := range shape {
13941		var col types.RecordError
13942		destAddr := &col
13943		if err := awsAwsjson11_deserializeDocumentRecordError(&destAddr, value); err != nil {
13944			return err
13945		}
13946		col = *destAddr
13947		cv = append(cv, col)
13948
13949	}
13950	*v = cv
13951	return nil
13952}
13953
13954func awsAwsjson11_deserializeDocumentRecordOutput(v **types.RecordOutput, value interface{}) error {
13955	if v == nil {
13956		return fmt.Errorf("unexpected nil of type %T", v)
13957	}
13958	if value == nil {
13959		return nil
13960	}
13961
13962	shape, ok := value.(map[string]interface{})
13963	if !ok {
13964		return fmt.Errorf("unexpected JSON type %v", value)
13965	}
13966
13967	var sv *types.RecordOutput
13968	if *v == nil {
13969		sv = &types.RecordOutput{}
13970	} else {
13971		sv = *v
13972	}
13973
13974	for key, value := range shape {
13975		switch key {
13976		case "Description":
13977			if value != nil {
13978				jtv, ok := value.(string)
13979				if !ok {
13980					return fmt.Errorf("expected Description to be of type string, got %T instead", value)
13981				}
13982				sv.Description = ptr.String(jtv)
13983			}
13984
13985		case "OutputKey":
13986			if value != nil {
13987				jtv, ok := value.(string)
13988				if !ok {
13989					return fmt.Errorf("expected OutputKey to be of type string, got %T instead", value)
13990				}
13991				sv.OutputKey = ptr.String(jtv)
13992			}
13993
13994		case "OutputValue":
13995			if value != nil {
13996				jtv, ok := value.(string)
13997				if !ok {
13998					return fmt.Errorf("expected OutputValue to be of type string, got %T instead", value)
13999				}
14000				sv.OutputValue = ptr.String(jtv)
14001			}
14002
14003		default:
14004			_, _ = key, value
14005
14006		}
14007	}
14008	*v = sv
14009	return nil
14010}
14011
14012func awsAwsjson11_deserializeDocumentRecordOutputs(v *[]types.RecordOutput, value interface{}) error {
14013	if v == nil {
14014		return fmt.Errorf("unexpected nil of type %T", v)
14015	}
14016	if value == nil {
14017		return nil
14018	}
14019
14020	shape, ok := value.([]interface{})
14021	if !ok {
14022		return fmt.Errorf("unexpected JSON type %v", value)
14023	}
14024
14025	var cv []types.RecordOutput
14026	if *v == nil {
14027		cv = []types.RecordOutput{}
14028	} else {
14029		cv = *v
14030	}
14031
14032	for _, value := range shape {
14033		var col types.RecordOutput
14034		destAddr := &col
14035		if err := awsAwsjson11_deserializeDocumentRecordOutput(&destAddr, value); err != nil {
14036			return err
14037		}
14038		col = *destAddr
14039		cv = append(cv, col)
14040
14041	}
14042	*v = cv
14043	return nil
14044}
14045
14046func awsAwsjson11_deserializeDocumentRecordTag(v **types.RecordTag, value interface{}) error {
14047	if v == nil {
14048		return fmt.Errorf("unexpected nil of type %T", v)
14049	}
14050	if value == nil {
14051		return nil
14052	}
14053
14054	shape, ok := value.(map[string]interface{})
14055	if !ok {
14056		return fmt.Errorf("unexpected JSON type %v", value)
14057	}
14058
14059	var sv *types.RecordTag
14060	if *v == nil {
14061		sv = &types.RecordTag{}
14062	} else {
14063		sv = *v
14064	}
14065
14066	for key, value := range shape {
14067		switch key {
14068		case "Key":
14069			if value != nil {
14070				jtv, ok := value.(string)
14071				if !ok {
14072					return fmt.Errorf("expected RecordTagKey to be of type string, got %T instead", value)
14073				}
14074				sv.Key = ptr.String(jtv)
14075			}
14076
14077		case "Value":
14078			if value != nil {
14079				jtv, ok := value.(string)
14080				if !ok {
14081					return fmt.Errorf("expected RecordTagValue to be of type string, got %T instead", value)
14082				}
14083				sv.Value = ptr.String(jtv)
14084			}
14085
14086		default:
14087			_, _ = key, value
14088
14089		}
14090	}
14091	*v = sv
14092	return nil
14093}
14094
14095func awsAwsjson11_deserializeDocumentRecordTags(v *[]types.RecordTag, value interface{}) error {
14096	if v == nil {
14097		return fmt.Errorf("unexpected nil of type %T", v)
14098	}
14099	if value == nil {
14100		return nil
14101	}
14102
14103	shape, ok := value.([]interface{})
14104	if !ok {
14105		return fmt.Errorf("unexpected JSON type %v", value)
14106	}
14107
14108	var cv []types.RecordTag
14109	if *v == nil {
14110		cv = []types.RecordTag{}
14111	} else {
14112		cv = *v
14113	}
14114
14115	for _, value := range shape {
14116		var col types.RecordTag
14117		destAddr := &col
14118		if err := awsAwsjson11_deserializeDocumentRecordTag(&destAddr, value); err != nil {
14119			return err
14120		}
14121		col = *destAddr
14122		cv = append(cv, col)
14123
14124	}
14125	*v = cv
14126	return nil
14127}
14128
14129func awsAwsjson11_deserializeDocumentResourceChange(v **types.ResourceChange, value interface{}) error {
14130	if v == nil {
14131		return fmt.Errorf("unexpected nil of type %T", v)
14132	}
14133	if value == nil {
14134		return nil
14135	}
14136
14137	shape, ok := value.(map[string]interface{})
14138	if !ok {
14139		return fmt.Errorf("unexpected JSON type %v", value)
14140	}
14141
14142	var sv *types.ResourceChange
14143	if *v == nil {
14144		sv = &types.ResourceChange{}
14145	} else {
14146		sv = *v
14147	}
14148
14149	for key, value := range shape {
14150		switch key {
14151		case "Action":
14152			if value != nil {
14153				jtv, ok := value.(string)
14154				if !ok {
14155					return fmt.Errorf("expected ChangeAction to be of type string, got %T instead", value)
14156				}
14157				sv.Action = types.ChangeAction(jtv)
14158			}
14159
14160		case "Details":
14161			if err := awsAwsjson11_deserializeDocumentResourceChangeDetails(&sv.Details, value); err != nil {
14162				return err
14163			}
14164
14165		case "LogicalResourceId":
14166			if value != nil {
14167				jtv, ok := value.(string)
14168				if !ok {
14169					return fmt.Errorf("expected LogicalResourceId to be of type string, got %T instead", value)
14170				}
14171				sv.LogicalResourceId = ptr.String(jtv)
14172			}
14173
14174		case "PhysicalResourceId":
14175			if value != nil {
14176				jtv, ok := value.(string)
14177				if !ok {
14178					return fmt.Errorf("expected PhysicalResourceId to be of type string, got %T instead", value)
14179				}
14180				sv.PhysicalResourceId = ptr.String(jtv)
14181			}
14182
14183		case "Replacement":
14184			if value != nil {
14185				jtv, ok := value.(string)
14186				if !ok {
14187					return fmt.Errorf("expected Replacement to be of type string, got %T instead", value)
14188				}
14189				sv.Replacement = types.Replacement(jtv)
14190			}
14191
14192		case "ResourceType":
14193			if value != nil {
14194				jtv, ok := value.(string)
14195				if !ok {
14196					return fmt.Errorf("expected PlanResourceType to be of type string, got %T instead", value)
14197				}
14198				sv.ResourceType = ptr.String(jtv)
14199			}
14200
14201		case "Scope":
14202			if err := awsAwsjson11_deserializeDocumentScope(&sv.Scope, value); err != nil {
14203				return err
14204			}
14205
14206		default:
14207			_, _ = key, value
14208
14209		}
14210	}
14211	*v = sv
14212	return nil
14213}
14214
14215func awsAwsjson11_deserializeDocumentResourceChangeDetail(v **types.ResourceChangeDetail, value interface{}) error {
14216	if v == nil {
14217		return fmt.Errorf("unexpected nil of type %T", v)
14218	}
14219	if value == nil {
14220		return nil
14221	}
14222
14223	shape, ok := value.(map[string]interface{})
14224	if !ok {
14225		return fmt.Errorf("unexpected JSON type %v", value)
14226	}
14227
14228	var sv *types.ResourceChangeDetail
14229	if *v == nil {
14230		sv = &types.ResourceChangeDetail{}
14231	} else {
14232		sv = *v
14233	}
14234
14235	for key, value := range shape {
14236		switch key {
14237		case "CausingEntity":
14238			if value != nil {
14239				jtv, ok := value.(string)
14240				if !ok {
14241					return fmt.Errorf("expected CausingEntity to be of type string, got %T instead", value)
14242				}
14243				sv.CausingEntity = ptr.String(jtv)
14244			}
14245
14246		case "Evaluation":
14247			if value != nil {
14248				jtv, ok := value.(string)
14249				if !ok {
14250					return fmt.Errorf("expected EvaluationType to be of type string, got %T instead", value)
14251				}
14252				sv.Evaluation = types.EvaluationType(jtv)
14253			}
14254
14255		case "Target":
14256			if err := awsAwsjson11_deserializeDocumentResourceTargetDefinition(&sv.Target, value); err != nil {
14257				return err
14258			}
14259
14260		default:
14261			_, _ = key, value
14262
14263		}
14264	}
14265	*v = sv
14266	return nil
14267}
14268
14269func awsAwsjson11_deserializeDocumentResourceChangeDetails(v *[]types.ResourceChangeDetail, value interface{}) error {
14270	if v == nil {
14271		return fmt.Errorf("unexpected nil of type %T", v)
14272	}
14273	if value == nil {
14274		return nil
14275	}
14276
14277	shape, ok := value.([]interface{})
14278	if !ok {
14279		return fmt.Errorf("unexpected JSON type %v", value)
14280	}
14281
14282	var cv []types.ResourceChangeDetail
14283	if *v == nil {
14284		cv = []types.ResourceChangeDetail{}
14285	} else {
14286		cv = *v
14287	}
14288
14289	for _, value := range shape {
14290		var col types.ResourceChangeDetail
14291		destAddr := &col
14292		if err := awsAwsjson11_deserializeDocumentResourceChangeDetail(&destAddr, value); err != nil {
14293			return err
14294		}
14295		col = *destAddr
14296		cv = append(cv, col)
14297
14298	}
14299	*v = cv
14300	return nil
14301}
14302
14303func awsAwsjson11_deserializeDocumentResourceChanges(v *[]types.ResourceChange, value interface{}) error {
14304	if v == nil {
14305		return fmt.Errorf("unexpected nil of type %T", v)
14306	}
14307	if value == nil {
14308		return nil
14309	}
14310
14311	shape, ok := value.([]interface{})
14312	if !ok {
14313		return fmt.Errorf("unexpected JSON type %v", value)
14314	}
14315
14316	var cv []types.ResourceChange
14317	if *v == nil {
14318		cv = []types.ResourceChange{}
14319	} else {
14320		cv = *v
14321	}
14322
14323	for _, value := range shape {
14324		var col types.ResourceChange
14325		destAddr := &col
14326		if err := awsAwsjson11_deserializeDocumentResourceChange(&destAddr, value); err != nil {
14327			return err
14328		}
14329		col = *destAddr
14330		cv = append(cv, col)
14331
14332	}
14333	*v = cv
14334	return nil
14335}
14336
14337func awsAwsjson11_deserializeDocumentResourceDetail(v **types.ResourceDetail, value interface{}) error {
14338	if v == nil {
14339		return fmt.Errorf("unexpected nil of type %T", v)
14340	}
14341	if value == nil {
14342		return nil
14343	}
14344
14345	shape, ok := value.(map[string]interface{})
14346	if !ok {
14347		return fmt.Errorf("unexpected JSON type %v", value)
14348	}
14349
14350	var sv *types.ResourceDetail
14351	if *v == nil {
14352		sv = &types.ResourceDetail{}
14353	} else {
14354		sv = *v
14355	}
14356
14357	for key, value := range shape {
14358		switch key {
14359		case "ARN":
14360			if value != nil {
14361				jtv, ok := value.(string)
14362				if !ok {
14363					return fmt.Errorf("expected ResourceDetailARN to be of type string, got %T instead", value)
14364				}
14365				sv.ARN = ptr.String(jtv)
14366			}
14367
14368		case "CreatedTime":
14369			if value != nil {
14370				jtv, ok := value.(json.Number)
14371				if !ok {
14372					return fmt.Errorf("expected ResourceDetailCreatedTime to be json.Number, got %T instead", value)
14373				}
14374				f64, err := jtv.Float64()
14375				if err != nil {
14376					return err
14377				}
14378				sv.CreatedTime = ptr.Time(smithytime.ParseEpochSeconds(f64))
14379			}
14380
14381		case "Description":
14382			if value != nil {
14383				jtv, ok := value.(string)
14384				if !ok {
14385					return fmt.Errorf("expected ResourceDetailDescription to be of type string, got %T instead", value)
14386				}
14387				sv.Description = ptr.String(jtv)
14388			}
14389
14390		case "Id":
14391			if value != nil {
14392				jtv, ok := value.(string)
14393				if !ok {
14394					return fmt.Errorf("expected ResourceDetailId to be of type string, got %T instead", value)
14395				}
14396				sv.Id = ptr.String(jtv)
14397			}
14398
14399		case "Name":
14400			if value != nil {
14401				jtv, ok := value.(string)
14402				if !ok {
14403					return fmt.Errorf("expected ResourceDetailName to be of type string, got %T instead", value)
14404				}
14405				sv.Name = ptr.String(jtv)
14406			}
14407
14408		default:
14409			_, _ = key, value
14410
14411		}
14412	}
14413	*v = sv
14414	return nil
14415}
14416
14417func awsAwsjson11_deserializeDocumentResourceDetails(v *[]types.ResourceDetail, value interface{}) error {
14418	if v == nil {
14419		return fmt.Errorf("unexpected nil of type %T", v)
14420	}
14421	if value == nil {
14422		return nil
14423	}
14424
14425	shape, ok := value.([]interface{})
14426	if !ok {
14427		return fmt.Errorf("unexpected JSON type %v", value)
14428	}
14429
14430	var cv []types.ResourceDetail
14431	if *v == nil {
14432		cv = []types.ResourceDetail{}
14433	} else {
14434		cv = *v
14435	}
14436
14437	for _, value := range shape {
14438		var col types.ResourceDetail
14439		destAddr := &col
14440		if err := awsAwsjson11_deserializeDocumentResourceDetail(&destAddr, value); err != nil {
14441			return err
14442		}
14443		col = *destAddr
14444		cv = append(cv, col)
14445
14446	}
14447	*v = cv
14448	return nil
14449}
14450
14451func awsAwsjson11_deserializeDocumentResourceInUseException(v **types.ResourceInUseException, value interface{}) error {
14452	if v == nil {
14453		return fmt.Errorf("unexpected nil of type %T", v)
14454	}
14455	if value == nil {
14456		return nil
14457	}
14458
14459	shape, ok := value.(map[string]interface{})
14460	if !ok {
14461		return fmt.Errorf("unexpected JSON type %v", value)
14462	}
14463
14464	var sv *types.ResourceInUseException
14465	if *v == nil {
14466		sv = &types.ResourceInUseException{}
14467	} else {
14468		sv = *v
14469	}
14470
14471	for key, value := range shape {
14472		switch key {
14473		case "Message":
14474			if value != nil {
14475				jtv, ok := value.(string)
14476				if !ok {
14477					return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
14478				}
14479				sv.Message = ptr.String(jtv)
14480			}
14481
14482		default:
14483			_, _ = key, value
14484
14485		}
14486	}
14487	*v = sv
14488	return nil
14489}
14490
14491func awsAwsjson11_deserializeDocumentResourceNotFoundException(v **types.ResourceNotFoundException, value interface{}) error {
14492	if v == nil {
14493		return fmt.Errorf("unexpected nil of type %T", v)
14494	}
14495	if value == nil {
14496		return nil
14497	}
14498
14499	shape, ok := value.(map[string]interface{})
14500	if !ok {
14501		return fmt.Errorf("unexpected JSON type %v", value)
14502	}
14503
14504	var sv *types.ResourceNotFoundException
14505	if *v == nil {
14506		sv = &types.ResourceNotFoundException{}
14507	} else {
14508		sv = *v
14509	}
14510
14511	for key, value := range shape {
14512		switch key {
14513		case "Message":
14514			if value != nil {
14515				jtv, ok := value.(string)
14516				if !ok {
14517					return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
14518				}
14519				sv.Message = ptr.String(jtv)
14520			}
14521
14522		default:
14523			_, _ = key, value
14524
14525		}
14526	}
14527	*v = sv
14528	return nil
14529}
14530
14531func awsAwsjson11_deserializeDocumentResourceTargetDefinition(v **types.ResourceTargetDefinition, value interface{}) error {
14532	if v == nil {
14533		return fmt.Errorf("unexpected nil of type %T", v)
14534	}
14535	if value == nil {
14536		return nil
14537	}
14538
14539	shape, ok := value.(map[string]interface{})
14540	if !ok {
14541		return fmt.Errorf("unexpected JSON type %v", value)
14542	}
14543
14544	var sv *types.ResourceTargetDefinition
14545	if *v == nil {
14546		sv = &types.ResourceTargetDefinition{}
14547	} else {
14548		sv = *v
14549	}
14550
14551	for key, value := range shape {
14552		switch key {
14553		case "Attribute":
14554			if value != nil {
14555				jtv, ok := value.(string)
14556				if !ok {
14557					return fmt.Errorf("expected ResourceAttribute to be of type string, got %T instead", value)
14558				}
14559				sv.Attribute = types.ResourceAttribute(jtv)
14560			}
14561
14562		case "Name":
14563			if value != nil {
14564				jtv, ok := value.(string)
14565				if !ok {
14566					return fmt.Errorf("expected PropertyName to be of type string, got %T instead", value)
14567				}
14568				sv.Name = ptr.String(jtv)
14569			}
14570
14571		case "RequiresRecreation":
14572			if value != nil {
14573				jtv, ok := value.(string)
14574				if !ok {
14575					return fmt.Errorf("expected RequiresRecreation to be of type string, got %T instead", value)
14576				}
14577				sv.RequiresRecreation = types.RequiresRecreation(jtv)
14578			}
14579
14580		default:
14581			_, _ = key, value
14582
14583		}
14584	}
14585	*v = sv
14586	return nil
14587}
14588
14589func awsAwsjson11_deserializeDocumentScope(v *[]types.ResourceAttribute, value interface{}) error {
14590	if v == nil {
14591		return fmt.Errorf("unexpected nil of type %T", v)
14592	}
14593	if value == nil {
14594		return nil
14595	}
14596
14597	shape, ok := value.([]interface{})
14598	if !ok {
14599		return fmt.Errorf("unexpected JSON type %v", value)
14600	}
14601
14602	var cv []types.ResourceAttribute
14603	if *v == nil {
14604		cv = []types.ResourceAttribute{}
14605	} else {
14606		cv = *v
14607	}
14608
14609	for _, value := range shape {
14610		var col types.ResourceAttribute
14611		if value != nil {
14612			jtv, ok := value.(string)
14613			if !ok {
14614				return fmt.Errorf("expected ResourceAttribute to be of type string, got %T instead", value)
14615			}
14616			col = types.ResourceAttribute(jtv)
14617		}
14618		cv = append(cv, col)
14619
14620	}
14621	*v = cv
14622	return nil
14623}
14624
14625func awsAwsjson11_deserializeDocumentServiceActionDefinitionMap(v *map[string]string, value interface{}) error {
14626	if v == nil {
14627		return fmt.Errorf("unexpected nil of type %T", v)
14628	}
14629	if value == nil {
14630		return nil
14631	}
14632
14633	shape, ok := value.(map[string]interface{})
14634	if !ok {
14635		return fmt.Errorf("unexpected JSON type %v", value)
14636	}
14637
14638	var mv map[string]string
14639	if *v == nil {
14640		mv = map[string]string{}
14641	} else {
14642		mv = *v
14643	}
14644
14645	for key, value := range shape {
14646		var parsedVal string
14647		if value != nil {
14648			jtv, ok := value.(string)
14649			if !ok {
14650				return fmt.Errorf("expected ServiceActionDefinitionValue to be of type string, got %T instead", value)
14651			}
14652			parsedVal = jtv
14653		}
14654		mv[key] = parsedVal
14655
14656	}
14657	*v = mv
14658	return nil
14659}
14660
14661func awsAwsjson11_deserializeDocumentServiceActionDetail(v **types.ServiceActionDetail, value interface{}) error {
14662	if v == nil {
14663		return fmt.Errorf("unexpected nil of type %T", v)
14664	}
14665	if value == nil {
14666		return nil
14667	}
14668
14669	shape, ok := value.(map[string]interface{})
14670	if !ok {
14671		return fmt.Errorf("unexpected JSON type %v", value)
14672	}
14673
14674	var sv *types.ServiceActionDetail
14675	if *v == nil {
14676		sv = &types.ServiceActionDetail{}
14677	} else {
14678		sv = *v
14679	}
14680
14681	for key, value := range shape {
14682		switch key {
14683		case "Definition":
14684			if err := awsAwsjson11_deserializeDocumentServiceActionDefinitionMap(&sv.Definition, value); err != nil {
14685				return err
14686			}
14687
14688		case "ServiceActionSummary":
14689			if err := awsAwsjson11_deserializeDocumentServiceActionSummary(&sv.ServiceActionSummary, value); err != nil {
14690				return err
14691			}
14692
14693		default:
14694			_, _ = key, value
14695
14696		}
14697	}
14698	*v = sv
14699	return nil
14700}
14701
14702func awsAwsjson11_deserializeDocumentServiceActionSummaries(v *[]types.ServiceActionSummary, value interface{}) error {
14703	if v == nil {
14704		return fmt.Errorf("unexpected nil of type %T", v)
14705	}
14706	if value == nil {
14707		return nil
14708	}
14709
14710	shape, ok := value.([]interface{})
14711	if !ok {
14712		return fmt.Errorf("unexpected JSON type %v", value)
14713	}
14714
14715	var cv []types.ServiceActionSummary
14716	if *v == nil {
14717		cv = []types.ServiceActionSummary{}
14718	} else {
14719		cv = *v
14720	}
14721
14722	for _, value := range shape {
14723		var col types.ServiceActionSummary
14724		destAddr := &col
14725		if err := awsAwsjson11_deserializeDocumentServiceActionSummary(&destAddr, value); err != nil {
14726			return err
14727		}
14728		col = *destAddr
14729		cv = append(cv, col)
14730
14731	}
14732	*v = cv
14733	return nil
14734}
14735
14736func awsAwsjson11_deserializeDocumentServiceActionSummary(v **types.ServiceActionSummary, value interface{}) error {
14737	if v == nil {
14738		return fmt.Errorf("unexpected nil of type %T", v)
14739	}
14740	if value == nil {
14741		return nil
14742	}
14743
14744	shape, ok := value.(map[string]interface{})
14745	if !ok {
14746		return fmt.Errorf("unexpected JSON type %v", value)
14747	}
14748
14749	var sv *types.ServiceActionSummary
14750	if *v == nil {
14751		sv = &types.ServiceActionSummary{}
14752	} else {
14753		sv = *v
14754	}
14755
14756	for key, value := range shape {
14757		switch key {
14758		case "DefinitionType":
14759			if value != nil {
14760				jtv, ok := value.(string)
14761				if !ok {
14762					return fmt.Errorf("expected ServiceActionDefinitionType to be of type string, got %T instead", value)
14763				}
14764				sv.DefinitionType = types.ServiceActionDefinitionType(jtv)
14765			}
14766
14767		case "Description":
14768			if value != nil {
14769				jtv, ok := value.(string)
14770				if !ok {
14771					return fmt.Errorf("expected ServiceActionDescription to be of type string, got %T instead", value)
14772				}
14773				sv.Description = ptr.String(jtv)
14774			}
14775
14776		case "Id":
14777			if value != nil {
14778				jtv, ok := value.(string)
14779				if !ok {
14780					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
14781				}
14782				sv.Id = ptr.String(jtv)
14783			}
14784
14785		case "Name":
14786			if value != nil {
14787				jtv, ok := value.(string)
14788				if !ok {
14789					return fmt.Errorf("expected ServiceActionName to be of type string, got %T instead", value)
14790				}
14791				sv.Name = ptr.String(jtv)
14792			}
14793
14794		default:
14795			_, _ = key, value
14796
14797		}
14798	}
14799	*v = sv
14800	return nil
14801}
14802
14803func awsAwsjson11_deserializeDocumentShareDetails(v **types.ShareDetails, value interface{}) error {
14804	if v == nil {
14805		return fmt.Errorf("unexpected nil of type %T", v)
14806	}
14807	if value == nil {
14808		return nil
14809	}
14810
14811	shape, ok := value.(map[string]interface{})
14812	if !ok {
14813		return fmt.Errorf("unexpected JSON type %v", value)
14814	}
14815
14816	var sv *types.ShareDetails
14817	if *v == nil {
14818		sv = &types.ShareDetails{}
14819	} else {
14820		sv = *v
14821	}
14822
14823	for key, value := range shape {
14824		switch key {
14825		case "ShareErrors":
14826			if err := awsAwsjson11_deserializeDocumentShareErrors(&sv.ShareErrors, value); err != nil {
14827				return err
14828			}
14829
14830		case "SuccessfulShares":
14831			if err := awsAwsjson11_deserializeDocumentSuccessfulShares(&sv.SuccessfulShares, value); err != nil {
14832				return err
14833			}
14834
14835		default:
14836			_, _ = key, value
14837
14838		}
14839	}
14840	*v = sv
14841	return nil
14842}
14843
14844func awsAwsjson11_deserializeDocumentShareError(v **types.ShareError, value interface{}) error {
14845	if v == nil {
14846		return fmt.Errorf("unexpected nil of type %T", v)
14847	}
14848	if value == nil {
14849		return nil
14850	}
14851
14852	shape, ok := value.(map[string]interface{})
14853	if !ok {
14854		return fmt.Errorf("unexpected JSON type %v", value)
14855	}
14856
14857	var sv *types.ShareError
14858	if *v == nil {
14859		sv = &types.ShareError{}
14860	} else {
14861		sv = *v
14862	}
14863
14864	for key, value := range shape {
14865		switch key {
14866		case "Accounts":
14867			if err := awsAwsjson11_deserializeDocumentNamespaces(&sv.Accounts, value); err != nil {
14868				return err
14869			}
14870
14871		case "Error":
14872			if value != nil {
14873				jtv, ok := value.(string)
14874				if !ok {
14875					return fmt.Errorf("expected Error to be of type string, got %T instead", value)
14876				}
14877				sv.Error = ptr.String(jtv)
14878			}
14879
14880		case "Message":
14881			if value != nil {
14882				jtv, ok := value.(string)
14883				if !ok {
14884					return fmt.Errorf("expected Message to be of type string, got %T instead", value)
14885				}
14886				sv.Message = ptr.String(jtv)
14887			}
14888
14889		default:
14890			_, _ = key, value
14891
14892		}
14893	}
14894	*v = sv
14895	return nil
14896}
14897
14898func awsAwsjson11_deserializeDocumentShareErrors(v *[]types.ShareError, value interface{}) error {
14899	if v == nil {
14900		return fmt.Errorf("unexpected nil of type %T", v)
14901	}
14902	if value == nil {
14903		return nil
14904	}
14905
14906	shape, ok := value.([]interface{})
14907	if !ok {
14908		return fmt.Errorf("unexpected JSON type %v", value)
14909	}
14910
14911	var cv []types.ShareError
14912	if *v == nil {
14913		cv = []types.ShareError{}
14914	} else {
14915		cv = *v
14916	}
14917
14918	for _, value := range shape {
14919		var col types.ShareError
14920		destAddr := &col
14921		if err := awsAwsjson11_deserializeDocumentShareError(&destAddr, value); err != nil {
14922			return err
14923		}
14924		col = *destAddr
14925		cv = append(cv, col)
14926
14927	}
14928	*v = cv
14929	return nil
14930}
14931
14932func awsAwsjson11_deserializeDocumentStackInstance(v **types.StackInstance, value interface{}) error {
14933	if v == nil {
14934		return fmt.Errorf("unexpected nil of type %T", v)
14935	}
14936	if value == nil {
14937		return nil
14938	}
14939
14940	shape, ok := value.(map[string]interface{})
14941	if !ok {
14942		return fmt.Errorf("unexpected JSON type %v", value)
14943	}
14944
14945	var sv *types.StackInstance
14946	if *v == nil {
14947		sv = &types.StackInstance{}
14948	} else {
14949		sv = *v
14950	}
14951
14952	for key, value := range shape {
14953		switch key {
14954		case "Account":
14955			if value != nil {
14956				jtv, ok := value.(string)
14957				if !ok {
14958					return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
14959				}
14960				sv.Account = ptr.String(jtv)
14961			}
14962
14963		case "Region":
14964			if value != nil {
14965				jtv, ok := value.(string)
14966				if !ok {
14967					return fmt.Errorf("expected Region to be of type string, got %T instead", value)
14968				}
14969				sv.Region = ptr.String(jtv)
14970			}
14971
14972		case "StackInstanceStatus":
14973			if value != nil {
14974				jtv, ok := value.(string)
14975				if !ok {
14976					return fmt.Errorf("expected StackInstanceStatus to be of type string, got %T instead", value)
14977				}
14978				sv.StackInstanceStatus = types.StackInstanceStatus(jtv)
14979			}
14980
14981		default:
14982			_, _ = key, value
14983
14984		}
14985	}
14986	*v = sv
14987	return nil
14988}
14989
14990func awsAwsjson11_deserializeDocumentStackInstances(v *[]types.StackInstance, value interface{}) error {
14991	if v == nil {
14992		return fmt.Errorf("unexpected nil of type %T", v)
14993	}
14994	if value == nil {
14995		return nil
14996	}
14997
14998	shape, ok := value.([]interface{})
14999	if !ok {
15000		return fmt.Errorf("unexpected JSON type %v", value)
15001	}
15002
15003	var cv []types.StackInstance
15004	if *v == nil {
15005		cv = []types.StackInstance{}
15006	} else {
15007		cv = *v
15008	}
15009
15010	for _, value := range shape {
15011		var col types.StackInstance
15012		destAddr := &col
15013		if err := awsAwsjson11_deserializeDocumentStackInstance(&destAddr, value); err != nil {
15014			return err
15015		}
15016		col = *destAddr
15017		cv = append(cv, col)
15018
15019	}
15020	*v = cv
15021	return nil
15022}
15023
15024func awsAwsjson11_deserializeDocumentStackSetAccounts(v *[]string, value interface{}) error {
15025	if v == nil {
15026		return fmt.Errorf("unexpected nil of type %T", v)
15027	}
15028	if value == nil {
15029		return nil
15030	}
15031
15032	shape, ok := value.([]interface{})
15033	if !ok {
15034		return fmt.Errorf("unexpected JSON type %v", value)
15035	}
15036
15037	var cv []string
15038	if *v == nil {
15039		cv = []string{}
15040	} else {
15041		cv = *v
15042	}
15043
15044	for _, value := range shape {
15045		var col string
15046		if value != nil {
15047			jtv, ok := value.(string)
15048			if !ok {
15049				return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
15050			}
15051			col = jtv
15052		}
15053		cv = append(cv, col)
15054
15055	}
15056	*v = cv
15057	return nil
15058}
15059
15060func awsAwsjson11_deserializeDocumentStackSetRegions(v *[]string, value interface{}) error {
15061	if v == nil {
15062		return fmt.Errorf("unexpected nil of type %T", v)
15063	}
15064	if value == nil {
15065		return nil
15066	}
15067
15068	shape, ok := value.([]interface{})
15069	if !ok {
15070		return fmt.Errorf("unexpected JSON type %v", value)
15071	}
15072
15073	var cv []string
15074	if *v == nil {
15075		cv = []string{}
15076	} else {
15077		cv = *v
15078	}
15079
15080	for _, value := range shape {
15081		var col string
15082		if value != nil {
15083			jtv, ok := value.(string)
15084			if !ok {
15085				return fmt.Errorf("expected Region to be of type string, got %T instead", value)
15086			}
15087			col = jtv
15088		}
15089		cv = append(cv, col)
15090
15091	}
15092	*v = cv
15093	return nil
15094}
15095
15096func awsAwsjson11_deserializeDocumentSuccessfulShares(v *[]string, value interface{}) error {
15097	if v == nil {
15098		return fmt.Errorf("unexpected nil of type %T", v)
15099	}
15100	if value == nil {
15101		return nil
15102	}
15103
15104	shape, ok := value.([]interface{})
15105	if !ok {
15106		return fmt.Errorf("unexpected JSON type %v", value)
15107	}
15108
15109	var cv []string
15110	if *v == nil {
15111		cv = []string{}
15112	} else {
15113		cv = *v
15114	}
15115
15116	for _, value := range shape {
15117		var col string
15118		if value != nil {
15119			jtv, ok := value.(string)
15120			if !ok {
15121				return fmt.Errorf("expected AccountId to be of type string, got %T instead", value)
15122			}
15123			col = jtv
15124		}
15125		cv = append(cv, col)
15126
15127	}
15128	*v = cv
15129	return nil
15130}
15131
15132func awsAwsjson11_deserializeDocumentTag(v **types.Tag, value interface{}) error {
15133	if v == nil {
15134		return fmt.Errorf("unexpected nil of type %T", v)
15135	}
15136	if value == nil {
15137		return nil
15138	}
15139
15140	shape, ok := value.(map[string]interface{})
15141	if !ok {
15142		return fmt.Errorf("unexpected JSON type %v", value)
15143	}
15144
15145	var sv *types.Tag
15146	if *v == nil {
15147		sv = &types.Tag{}
15148	} else {
15149		sv = *v
15150	}
15151
15152	for key, value := range shape {
15153		switch key {
15154		case "Key":
15155			if value != nil {
15156				jtv, ok := value.(string)
15157				if !ok {
15158					return fmt.Errorf("expected TagKey to be of type string, got %T instead", value)
15159				}
15160				sv.Key = ptr.String(jtv)
15161			}
15162
15163		case "Value":
15164			if value != nil {
15165				jtv, ok := value.(string)
15166				if !ok {
15167					return fmt.Errorf("expected TagValue to be of type string, got %T instead", value)
15168				}
15169				sv.Value = ptr.String(jtv)
15170			}
15171
15172		default:
15173			_, _ = key, value
15174
15175		}
15176	}
15177	*v = sv
15178	return nil
15179}
15180
15181func awsAwsjson11_deserializeDocumentTagOptionDetail(v **types.TagOptionDetail, value interface{}) error {
15182	if v == nil {
15183		return fmt.Errorf("unexpected nil of type %T", v)
15184	}
15185	if value == nil {
15186		return nil
15187	}
15188
15189	shape, ok := value.(map[string]interface{})
15190	if !ok {
15191		return fmt.Errorf("unexpected JSON type %v", value)
15192	}
15193
15194	var sv *types.TagOptionDetail
15195	if *v == nil {
15196		sv = &types.TagOptionDetail{}
15197	} else {
15198		sv = *v
15199	}
15200
15201	for key, value := range shape {
15202		switch key {
15203		case "Active":
15204			if value != nil {
15205				jtv, ok := value.(bool)
15206				if !ok {
15207					return fmt.Errorf("expected TagOptionActive to be of type *bool, got %T instead", value)
15208				}
15209				sv.Active = ptr.Bool(jtv)
15210			}
15211
15212		case "Id":
15213			if value != nil {
15214				jtv, ok := value.(string)
15215				if !ok {
15216					return fmt.Errorf("expected TagOptionId to be of type string, got %T instead", value)
15217				}
15218				sv.Id = ptr.String(jtv)
15219			}
15220
15221		case "Key":
15222			if value != nil {
15223				jtv, ok := value.(string)
15224				if !ok {
15225					return fmt.Errorf("expected TagOptionKey to be of type string, got %T instead", value)
15226				}
15227				sv.Key = ptr.String(jtv)
15228			}
15229
15230		case "Owner":
15231			if value != nil {
15232				jtv, ok := value.(string)
15233				if !ok {
15234					return fmt.Errorf("expected Owner to be of type string, got %T instead", value)
15235				}
15236				sv.Owner = ptr.String(jtv)
15237			}
15238
15239		case "Value":
15240			if value != nil {
15241				jtv, ok := value.(string)
15242				if !ok {
15243					return fmt.Errorf("expected TagOptionValue to be of type string, got %T instead", value)
15244				}
15245				sv.Value = ptr.String(jtv)
15246			}
15247
15248		default:
15249			_, _ = key, value
15250
15251		}
15252	}
15253	*v = sv
15254	return nil
15255}
15256
15257func awsAwsjson11_deserializeDocumentTagOptionDetails(v *[]types.TagOptionDetail, value interface{}) error {
15258	if v == nil {
15259		return fmt.Errorf("unexpected nil of type %T", v)
15260	}
15261	if value == nil {
15262		return nil
15263	}
15264
15265	shape, ok := value.([]interface{})
15266	if !ok {
15267		return fmt.Errorf("unexpected JSON type %v", value)
15268	}
15269
15270	var cv []types.TagOptionDetail
15271	if *v == nil {
15272		cv = []types.TagOptionDetail{}
15273	} else {
15274		cv = *v
15275	}
15276
15277	for _, value := range shape {
15278		var col types.TagOptionDetail
15279		destAddr := &col
15280		if err := awsAwsjson11_deserializeDocumentTagOptionDetail(&destAddr, value); err != nil {
15281			return err
15282		}
15283		col = *destAddr
15284		cv = append(cv, col)
15285
15286	}
15287	*v = cv
15288	return nil
15289}
15290
15291func awsAwsjson11_deserializeDocumentTagOptionNotMigratedException(v **types.TagOptionNotMigratedException, value interface{}) error {
15292	if v == nil {
15293		return fmt.Errorf("unexpected nil of type %T", v)
15294	}
15295	if value == nil {
15296		return nil
15297	}
15298
15299	shape, ok := value.(map[string]interface{})
15300	if !ok {
15301		return fmt.Errorf("unexpected JSON type %v", value)
15302	}
15303
15304	var sv *types.TagOptionNotMigratedException
15305	if *v == nil {
15306		sv = &types.TagOptionNotMigratedException{}
15307	} else {
15308		sv = *v
15309	}
15310
15311	for key, value := range shape {
15312		switch key {
15313		case "Message":
15314			if value != nil {
15315				jtv, ok := value.(string)
15316				if !ok {
15317					return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value)
15318				}
15319				sv.Message = ptr.String(jtv)
15320			}
15321
15322		default:
15323			_, _ = key, value
15324
15325		}
15326	}
15327	*v = sv
15328	return nil
15329}
15330
15331func awsAwsjson11_deserializeDocumentTagOptionSummaries(v *[]types.TagOptionSummary, value interface{}) error {
15332	if v == nil {
15333		return fmt.Errorf("unexpected nil of type %T", v)
15334	}
15335	if value == nil {
15336		return nil
15337	}
15338
15339	shape, ok := value.([]interface{})
15340	if !ok {
15341		return fmt.Errorf("unexpected JSON type %v", value)
15342	}
15343
15344	var cv []types.TagOptionSummary
15345	if *v == nil {
15346		cv = []types.TagOptionSummary{}
15347	} else {
15348		cv = *v
15349	}
15350
15351	for _, value := range shape {
15352		var col types.TagOptionSummary
15353		destAddr := &col
15354		if err := awsAwsjson11_deserializeDocumentTagOptionSummary(&destAddr, value); err != nil {
15355			return err
15356		}
15357		col = *destAddr
15358		cv = append(cv, col)
15359
15360	}
15361	*v = cv
15362	return nil
15363}
15364
15365func awsAwsjson11_deserializeDocumentTagOptionSummary(v **types.TagOptionSummary, value interface{}) error {
15366	if v == nil {
15367		return fmt.Errorf("unexpected nil of type %T", v)
15368	}
15369	if value == nil {
15370		return nil
15371	}
15372
15373	shape, ok := value.(map[string]interface{})
15374	if !ok {
15375		return fmt.Errorf("unexpected JSON type %v", value)
15376	}
15377
15378	var sv *types.TagOptionSummary
15379	if *v == nil {
15380		sv = &types.TagOptionSummary{}
15381	} else {
15382		sv = *v
15383	}
15384
15385	for key, value := range shape {
15386		switch key {
15387		case "Key":
15388			if value != nil {
15389				jtv, ok := value.(string)
15390				if !ok {
15391					return fmt.Errorf("expected TagOptionKey to be of type string, got %T instead", value)
15392				}
15393				sv.Key = ptr.String(jtv)
15394			}
15395
15396		case "Values":
15397			if err := awsAwsjson11_deserializeDocumentTagOptionValues(&sv.Values, value); err != nil {
15398				return err
15399			}
15400
15401		default:
15402			_, _ = key, value
15403
15404		}
15405	}
15406	*v = sv
15407	return nil
15408}
15409
15410func awsAwsjson11_deserializeDocumentTagOptionValues(v *[]string, value interface{}) error {
15411	if v == nil {
15412		return fmt.Errorf("unexpected nil of type %T", v)
15413	}
15414	if value == nil {
15415		return nil
15416	}
15417
15418	shape, ok := value.([]interface{})
15419	if !ok {
15420		return fmt.Errorf("unexpected JSON type %v", value)
15421	}
15422
15423	var cv []string
15424	if *v == nil {
15425		cv = []string{}
15426	} else {
15427		cv = *v
15428	}
15429
15430	for _, value := range shape {
15431		var col string
15432		if value != nil {
15433			jtv, ok := value.(string)
15434			if !ok {
15435				return fmt.Errorf("expected TagOptionValue to be of type string, got %T instead", value)
15436			}
15437			col = jtv
15438		}
15439		cv = append(cv, col)
15440
15441	}
15442	*v = cv
15443	return nil
15444}
15445
15446func awsAwsjson11_deserializeDocumentTags(v *[]types.Tag, value interface{}) error {
15447	if v == nil {
15448		return fmt.Errorf("unexpected nil of type %T", v)
15449	}
15450	if value == nil {
15451		return nil
15452	}
15453
15454	shape, ok := value.([]interface{})
15455	if !ok {
15456		return fmt.Errorf("unexpected JSON type %v", value)
15457	}
15458
15459	var cv []types.Tag
15460	if *v == nil {
15461		cv = []types.Tag{}
15462	} else {
15463		cv = *v
15464	}
15465
15466	for _, value := range shape {
15467		var col types.Tag
15468		destAddr := &col
15469		if err := awsAwsjson11_deserializeDocumentTag(&destAddr, value); err != nil {
15470			return err
15471		}
15472		col = *destAddr
15473		cv = append(cv, col)
15474
15475	}
15476	*v = cv
15477	return nil
15478}
15479
15480func awsAwsjson11_deserializeDocumentUpdateProvisioningParameter(v **types.UpdateProvisioningParameter, value interface{}) error {
15481	if v == nil {
15482		return fmt.Errorf("unexpected nil of type %T", v)
15483	}
15484	if value == nil {
15485		return nil
15486	}
15487
15488	shape, ok := value.(map[string]interface{})
15489	if !ok {
15490		return fmt.Errorf("unexpected JSON type %v", value)
15491	}
15492
15493	var sv *types.UpdateProvisioningParameter
15494	if *v == nil {
15495		sv = &types.UpdateProvisioningParameter{}
15496	} else {
15497		sv = *v
15498	}
15499
15500	for key, value := range shape {
15501		switch key {
15502		case "Key":
15503			if value != nil {
15504				jtv, ok := value.(string)
15505				if !ok {
15506					return fmt.Errorf("expected ParameterKey to be of type string, got %T instead", value)
15507				}
15508				sv.Key = ptr.String(jtv)
15509			}
15510
15511		case "UsePreviousValue":
15512			if value != nil {
15513				jtv, ok := value.(bool)
15514				if !ok {
15515					return fmt.Errorf("expected UsePreviousValue to be of type *bool, got %T instead", value)
15516				}
15517				sv.UsePreviousValue = jtv
15518			}
15519
15520		case "Value":
15521			if value != nil {
15522				jtv, ok := value.(string)
15523				if !ok {
15524					return fmt.Errorf("expected ParameterValue to be of type string, got %T instead", value)
15525				}
15526				sv.Value = ptr.String(jtv)
15527			}
15528
15529		default:
15530			_, _ = key, value
15531
15532		}
15533	}
15534	*v = sv
15535	return nil
15536}
15537
15538func awsAwsjson11_deserializeDocumentUpdateProvisioningParameters(v *[]types.UpdateProvisioningParameter, value interface{}) error {
15539	if v == nil {
15540		return fmt.Errorf("unexpected nil of type %T", v)
15541	}
15542	if value == nil {
15543		return nil
15544	}
15545
15546	shape, ok := value.([]interface{})
15547	if !ok {
15548		return fmt.Errorf("unexpected JSON type %v", value)
15549	}
15550
15551	var cv []types.UpdateProvisioningParameter
15552	if *v == nil {
15553		cv = []types.UpdateProvisioningParameter{}
15554	} else {
15555		cv = *v
15556	}
15557
15558	for _, value := range shape {
15559		var col types.UpdateProvisioningParameter
15560		destAddr := &col
15561		if err := awsAwsjson11_deserializeDocumentUpdateProvisioningParameter(&destAddr, value); err != nil {
15562			return err
15563		}
15564		col = *destAddr
15565		cv = append(cv, col)
15566
15567	}
15568	*v = cv
15569	return nil
15570}
15571
15572func awsAwsjson11_deserializeDocumentUsageInstruction(v **types.UsageInstruction, value interface{}) error {
15573	if v == nil {
15574		return fmt.Errorf("unexpected nil of type %T", v)
15575	}
15576	if value == nil {
15577		return nil
15578	}
15579
15580	shape, ok := value.(map[string]interface{})
15581	if !ok {
15582		return fmt.Errorf("unexpected JSON type %v", value)
15583	}
15584
15585	var sv *types.UsageInstruction
15586	if *v == nil {
15587		sv = &types.UsageInstruction{}
15588	} else {
15589		sv = *v
15590	}
15591
15592	for key, value := range shape {
15593		switch key {
15594		case "Type":
15595			if value != nil {
15596				jtv, ok := value.(string)
15597				if !ok {
15598					return fmt.Errorf("expected InstructionType to be of type string, got %T instead", value)
15599				}
15600				sv.Type = ptr.String(jtv)
15601			}
15602
15603		case "Value":
15604			if value != nil {
15605				jtv, ok := value.(string)
15606				if !ok {
15607					return fmt.Errorf("expected InstructionValue to be of type string, got %T instead", value)
15608				}
15609				sv.Value = ptr.String(jtv)
15610			}
15611
15612		default:
15613			_, _ = key, value
15614
15615		}
15616	}
15617	*v = sv
15618	return nil
15619}
15620
15621func awsAwsjson11_deserializeDocumentUsageInstructions(v *[]types.UsageInstruction, value interface{}) error {
15622	if v == nil {
15623		return fmt.Errorf("unexpected nil of type %T", v)
15624	}
15625	if value == nil {
15626		return nil
15627	}
15628
15629	shape, ok := value.([]interface{})
15630	if !ok {
15631		return fmt.Errorf("unexpected JSON type %v", value)
15632	}
15633
15634	var cv []types.UsageInstruction
15635	if *v == nil {
15636		cv = []types.UsageInstruction{}
15637	} else {
15638		cv = *v
15639	}
15640
15641	for _, value := range shape {
15642		var col types.UsageInstruction
15643		destAddr := &col
15644		if err := awsAwsjson11_deserializeDocumentUsageInstruction(&destAddr, value); err != nil {
15645			return err
15646		}
15647		col = *destAddr
15648		cv = append(cv, col)
15649
15650	}
15651	*v = cv
15652	return nil
15653}
15654
15655func awsAwsjson11_deserializeOpDocumentAcceptPortfolioShareOutput(v **AcceptPortfolioShareOutput, value interface{}) error {
15656	if v == nil {
15657		return fmt.Errorf("unexpected nil of type %T", v)
15658	}
15659	if value == nil {
15660		return nil
15661	}
15662
15663	shape, ok := value.(map[string]interface{})
15664	if !ok {
15665		return fmt.Errorf("unexpected JSON type %v", value)
15666	}
15667
15668	var sv *AcceptPortfolioShareOutput
15669	if *v == nil {
15670		sv = &AcceptPortfolioShareOutput{}
15671	} else {
15672		sv = *v
15673	}
15674
15675	for key, value := range shape {
15676		switch key {
15677		default:
15678			_, _ = key, value
15679
15680		}
15681	}
15682	*v = sv
15683	return nil
15684}
15685
15686func awsAwsjson11_deserializeOpDocumentAssociateBudgetWithResourceOutput(v **AssociateBudgetWithResourceOutput, value interface{}) error {
15687	if v == nil {
15688		return fmt.Errorf("unexpected nil of type %T", v)
15689	}
15690	if value == nil {
15691		return nil
15692	}
15693
15694	shape, ok := value.(map[string]interface{})
15695	if !ok {
15696		return fmt.Errorf("unexpected JSON type %v", value)
15697	}
15698
15699	var sv *AssociateBudgetWithResourceOutput
15700	if *v == nil {
15701		sv = &AssociateBudgetWithResourceOutput{}
15702	} else {
15703		sv = *v
15704	}
15705
15706	for key, value := range shape {
15707		switch key {
15708		default:
15709			_, _ = key, value
15710
15711		}
15712	}
15713	*v = sv
15714	return nil
15715}
15716
15717func awsAwsjson11_deserializeOpDocumentAssociatePrincipalWithPortfolioOutput(v **AssociatePrincipalWithPortfolioOutput, value interface{}) error {
15718	if v == nil {
15719		return fmt.Errorf("unexpected nil of type %T", v)
15720	}
15721	if value == nil {
15722		return nil
15723	}
15724
15725	shape, ok := value.(map[string]interface{})
15726	if !ok {
15727		return fmt.Errorf("unexpected JSON type %v", value)
15728	}
15729
15730	var sv *AssociatePrincipalWithPortfolioOutput
15731	if *v == nil {
15732		sv = &AssociatePrincipalWithPortfolioOutput{}
15733	} else {
15734		sv = *v
15735	}
15736
15737	for key, value := range shape {
15738		switch key {
15739		default:
15740			_, _ = key, value
15741
15742		}
15743	}
15744	*v = sv
15745	return nil
15746}
15747
15748func awsAwsjson11_deserializeOpDocumentAssociateProductWithPortfolioOutput(v **AssociateProductWithPortfolioOutput, value interface{}) error {
15749	if v == nil {
15750		return fmt.Errorf("unexpected nil of type %T", v)
15751	}
15752	if value == nil {
15753		return nil
15754	}
15755
15756	shape, ok := value.(map[string]interface{})
15757	if !ok {
15758		return fmt.Errorf("unexpected JSON type %v", value)
15759	}
15760
15761	var sv *AssociateProductWithPortfolioOutput
15762	if *v == nil {
15763		sv = &AssociateProductWithPortfolioOutput{}
15764	} else {
15765		sv = *v
15766	}
15767
15768	for key, value := range shape {
15769		switch key {
15770		default:
15771			_, _ = key, value
15772
15773		}
15774	}
15775	*v = sv
15776	return nil
15777}
15778
15779func awsAwsjson11_deserializeOpDocumentAssociateServiceActionWithProvisioningArtifactOutput(v **AssociateServiceActionWithProvisioningArtifactOutput, value interface{}) error {
15780	if v == nil {
15781		return fmt.Errorf("unexpected nil of type %T", v)
15782	}
15783	if value == nil {
15784		return nil
15785	}
15786
15787	shape, ok := value.(map[string]interface{})
15788	if !ok {
15789		return fmt.Errorf("unexpected JSON type %v", value)
15790	}
15791
15792	var sv *AssociateServiceActionWithProvisioningArtifactOutput
15793	if *v == nil {
15794		sv = &AssociateServiceActionWithProvisioningArtifactOutput{}
15795	} else {
15796		sv = *v
15797	}
15798
15799	for key, value := range shape {
15800		switch key {
15801		default:
15802			_, _ = key, value
15803
15804		}
15805	}
15806	*v = sv
15807	return nil
15808}
15809
15810func awsAwsjson11_deserializeOpDocumentAssociateTagOptionWithResourceOutput(v **AssociateTagOptionWithResourceOutput, value interface{}) error {
15811	if v == nil {
15812		return fmt.Errorf("unexpected nil of type %T", v)
15813	}
15814	if value == nil {
15815		return nil
15816	}
15817
15818	shape, ok := value.(map[string]interface{})
15819	if !ok {
15820		return fmt.Errorf("unexpected JSON type %v", value)
15821	}
15822
15823	var sv *AssociateTagOptionWithResourceOutput
15824	if *v == nil {
15825		sv = &AssociateTagOptionWithResourceOutput{}
15826	} else {
15827		sv = *v
15828	}
15829
15830	for key, value := range shape {
15831		switch key {
15832		default:
15833			_, _ = key, value
15834
15835		}
15836	}
15837	*v = sv
15838	return nil
15839}
15840
15841func awsAwsjson11_deserializeOpDocumentBatchAssociateServiceActionWithProvisioningArtifactOutput(v **BatchAssociateServiceActionWithProvisioningArtifactOutput, value interface{}) error {
15842	if v == nil {
15843		return fmt.Errorf("unexpected nil of type %T", v)
15844	}
15845	if value == nil {
15846		return nil
15847	}
15848
15849	shape, ok := value.(map[string]interface{})
15850	if !ok {
15851		return fmt.Errorf("unexpected JSON type %v", value)
15852	}
15853
15854	var sv *BatchAssociateServiceActionWithProvisioningArtifactOutput
15855	if *v == nil {
15856		sv = &BatchAssociateServiceActionWithProvisioningArtifactOutput{}
15857	} else {
15858		sv = *v
15859	}
15860
15861	for key, value := range shape {
15862		switch key {
15863		case "FailedServiceActionAssociations":
15864			if err := awsAwsjson11_deserializeDocumentFailedServiceActionAssociations(&sv.FailedServiceActionAssociations, value); err != nil {
15865				return err
15866			}
15867
15868		default:
15869			_, _ = key, value
15870
15871		}
15872	}
15873	*v = sv
15874	return nil
15875}
15876
15877func awsAwsjson11_deserializeOpDocumentBatchDisassociateServiceActionFromProvisioningArtifactOutput(v **BatchDisassociateServiceActionFromProvisioningArtifactOutput, value interface{}) error {
15878	if v == nil {
15879		return fmt.Errorf("unexpected nil of type %T", v)
15880	}
15881	if value == nil {
15882		return nil
15883	}
15884
15885	shape, ok := value.(map[string]interface{})
15886	if !ok {
15887		return fmt.Errorf("unexpected JSON type %v", value)
15888	}
15889
15890	var sv *BatchDisassociateServiceActionFromProvisioningArtifactOutput
15891	if *v == nil {
15892		sv = &BatchDisassociateServiceActionFromProvisioningArtifactOutput{}
15893	} else {
15894		sv = *v
15895	}
15896
15897	for key, value := range shape {
15898		switch key {
15899		case "FailedServiceActionAssociations":
15900			if err := awsAwsjson11_deserializeDocumentFailedServiceActionAssociations(&sv.FailedServiceActionAssociations, value); err != nil {
15901				return err
15902			}
15903
15904		default:
15905			_, _ = key, value
15906
15907		}
15908	}
15909	*v = sv
15910	return nil
15911}
15912
15913func awsAwsjson11_deserializeOpDocumentCopyProductOutput(v **CopyProductOutput, value interface{}) error {
15914	if v == nil {
15915		return fmt.Errorf("unexpected nil of type %T", v)
15916	}
15917	if value == nil {
15918		return nil
15919	}
15920
15921	shape, ok := value.(map[string]interface{})
15922	if !ok {
15923		return fmt.Errorf("unexpected JSON type %v", value)
15924	}
15925
15926	var sv *CopyProductOutput
15927	if *v == nil {
15928		sv = &CopyProductOutput{}
15929	} else {
15930		sv = *v
15931	}
15932
15933	for key, value := range shape {
15934		switch key {
15935		case "CopyProductToken":
15936			if value != nil {
15937				jtv, ok := value.(string)
15938				if !ok {
15939					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
15940				}
15941				sv.CopyProductToken = ptr.String(jtv)
15942			}
15943
15944		default:
15945			_, _ = key, value
15946
15947		}
15948	}
15949	*v = sv
15950	return nil
15951}
15952
15953func awsAwsjson11_deserializeOpDocumentCreateConstraintOutput(v **CreateConstraintOutput, value interface{}) error {
15954	if v == nil {
15955		return fmt.Errorf("unexpected nil of type %T", v)
15956	}
15957	if value == nil {
15958		return nil
15959	}
15960
15961	shape, ok := value.(map[string]interface{})
15962	if !ok {
15963		return fmt.Errorf("unexpected JSON type %v", value)
15964	}
15965
15966	var sv *CreateConstraintOutput
15967	if *v == nil {
15968		sv = &CreateConstraintOutput{}
15969	} else {
15970		sv = *v
15971	}
15972
15973	for key, value := range shape {
15974		switch key {
15975		case "ConstraintDetail":
15976			if err := awsAwsjson11_deserializeDocumentConstraintDetail(&sv.ConstraintDetail, value); err != nil {
15977				return err
15978			}
15979
15980		case "ConstraintParameters":
15981			if value != nil {
15982				jtv, ok := value.(string)
15983				if !ok {
15984					return fmt.Errorf("expected ConstraintParameters to be of type string, got %T instead", value)
15985				}
15986				sv.ConstraintParameters = ptr.String(jtv)
15987			}
15988
15989		case "Status":
15990			if value != nil {
15991				jtv, ok := value.(string)
15992				if !ok {
15993					return fmt.Errorf("expected Status to be of type string, got %T instead", value)
15994				}
15995				sv.Status = types.Status(jtv)
15996			}
15997
15998		default:
15999			_, _ = key, value
16000
16001		}
16002	}
16003	*v = sv
16004	return nil
16005}
16006
16007func awsAwsjson11_deserializeOpDocumentCreatePortfolioOutput(v **CreatePortfolioOutput, value interface{}) error {
16008	if v == nil {
16009		return fmt.Errorf("unexpected nil of type %T", v)
16010	}
16011	if value == nil {
16012		return nil
16013	}
16014
16015	shape, ok := value.(map[string]interface{})
16016	if !ok {
16017		return fmt.Errorf("unexpected JSON type %v", value)
16018	}
16019
16020	var sv *CreatePortfolioOutput
16021	if *v == nil {
16022		sv = &CreatePortfolioOutput{}
16023	} else {
16024		sv = *v
16025	}
16026
16027	for key, value := range shape {
16028		switch key {
16029		case "PortfolioDetail":
16030			if err := awsAwsjson11_deserializeDocumentPortfolioDetail(&sv.PortfolioDetail, value); err != nil {
16031				return err
16032			}
16033
16034		case "Tags":
16035			if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
16036				return err
16037			}
16038
16039		default:
16040			_, _ = key, value
16041
16042		}
16043	}
16044	*v = sv
16045	return nil
16046}
16047
16048func awsAwsjson11_deserializeOpDocumentCreatePortfolioShareOutput(v **CreatePortfolioShareOutput, value interface{}) error {
16049	if v == nil {
16050		return fmt.Errorf("unexpected nil of type %T", v)
16051	}
16052	if value == nil {
16053		return nil
16054	}
16055
16056	shape, ok := value.(map[string]interface{})
16057	if !ok {
16058		return fmt.Errorf("unexpected JSON type %v", value)
16059	}
16060
16061	var sv *CreatePortfolioShareOutput
16062	if *v == nil {
16063		sv = &CreatePortfolioShareOutput{}
16064	} else {
16065		sv = *v
16066	}
16067
16068	for key, value := range shape {
16069		switch key {
16070		case "PortfolioShareToken":
16071			if value != nil {
16072				jtv, ok := value.(string)
16073				if !ok {
16074					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
16075				}
16076				sv.PortfolioShareToken = ptr.String(jtv)
16077			}
16078
16079		default:
16080			_, _ = key, value
16081
16082		}
16083	}
16084	*v = sv
16085	return nil
16086}
16087
16088func awsAwsjson11_deserializeOpDocumentCreateProductOutput(v **CreateProductOutput, value interface{}) error {
16089	if v == nil {
16090		return fmt.Errorf("unexpected nil of type %T", v)
16091	}
16092	if value == nil {
16093		return nil
16094	}
16095
16096	shape, ok := value.(map[string]interface{})
16097	if !ok {
16098		return fmt.Errorf("unexpected JSON type %v", value)
16099	}
16100
16101	var sv *CreateProductOutput
16102	if *v == nil {
16103		sv = &CreateProductOutput{}
16104	} else {
16105		sv = *v
16106	}
16107
16108	for key, value := range shape {
16109		switch key {
16110		case "ProductViewDetail":
16111			if err := awsAwsjson11_deserializeDocumentProductViewDetail(&sv.ProductViewDetail, value); err != nil {
16112				return err
16113			}
16114
16115		case "ProvisioningArtifactDetail":
16116			if err := awsAwsjson11_deserializeDocumentProvisioningArtifactDetail(&sv.ProvisioningArtifactDetail, value); err != nil {
16117				return err
16118			}
16119
16120		case "Tags":
16121			if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
16122				return err
16123			}
16124
16125		default:
16126			_, _ = key, value
16127
16128		}
16129	}
16130	*v = sv
16131	return nil
16132}
16133
16134func awsAwsjson11_deserializeOpDocumentCreateProvisionedProductPlanOutput(v **CreateProvisionedProductPlanOutput, value interface{}) error {
16135	if v == nil {
16136		return fmt.Errorf("unexpected nil of type %T", v)
16137	}
16138	if value == nil {
16139		return nil
16140	}
16141
16142	shape, ok := value.(map[string]interface{})
16143	if !ok {
16144		return fmt.Errorf("unexpected JSON type %v", value)
16145	}
16146
16147	var sv *CreateProvisionedProductPlanOutput
16148	if *v == nil {
16149		sv = &CreateProvisionedProductPlanOutput{}
16150	} else {
16151		sv = *v
16152	}
16153
16154	for key, value := range shape {
16155		switch key {
16156		case "PlanId":
16157			if value != nil {
16158				jtv, ok := value.(string)
16159				if !ok {
16160					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
16161				}
16162				sv.PlanId = ptr.String(jtv)
16163			}
16164
16165		case "PlanName":
16166			if value != nil {
16167				jtv, ok := value.(string)
16168				if !ok {
16169					return fmt.Errorf("expected ProvisionedProductPlanName to be of type string, got %T instead", value)
16170				}
16171				sv.PlanName = ptr.String(jtv)
16172			}
16173
16174		case "ProvisionedProductName":
16175			if value != nil {
16176				jtv, ok := value.(string)
16177				if !ok {
16178					return fmt.Errorf("expected ProvisionedProductName to be of type string, got %T instead", value)
16179				}
16180				sv.ProvisionedProductName = ptr.String(jtv)
16181			}
16182
16183		case "ProvisioningArtifactId":
16184			if value != nil {
16185				jtv, ok := value.(string)
16186				if !ok {
16187					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
16188				}
16189				sv.ProvisioningArtifactId = ptr.String(jtv)
16190			}
16191
16192		case "ProvisionProductId":
16193			if value != nil {
16194				jtv, ok := value.(string)
16195				if !ok {
16196					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
16197				}
16198				sv.ProvisionProductId = ptr.String(jtv)
16199			}
16200
16201		default:
16202			_, _ = key, value
16203
16204		}
16205	}
16206	*v = sv
16207	return nil
16208}
16209
16210func awsAwsjson11_deserializeOpDocumentCreateProvisioningArtifactOutput(v **CreateProvisioningArtifactOutput, value interface{}) error {
16211	if v == nil {
16212		return fmt.Errorf("unexpected nil of type %T", v)
16213	}
16214	if value == nil {
16215		return nil
16216	}
16217
16218	shape, ok := value.(map[string]interface{})
16219	if !ok {
16220		return fmt.Errorf("unexpected JSON type %v", value)
16221	}
16222
16223	var sv *CreateProvisioningArtifactOutput
16224	if *v == nil {
16225		sv = &CreateProvisioningArtifactOutput{}
16226	} else {
16227		sv = *v
16228	}
16229
16230	for key, value := range shape {
16231		switch key {
16232		case "Info":
16233			if err := awsAwsjson11_deserializeDocumentProvisioningArtifactInfo(&sv.Info, value); err != nil {
16234				return err
16235			}
16236
16237		case "ProvisioningArtifactDetail":
16238			if err := awsAwsjson11_deserializeDocumentProvisioningArtifactDetail(&sv.ProvisioningArtifactDetail, value); err != nil {
16239				return err
16240			}
16241
16242		case "Status":
16243			if value != nil {
16244				jtv, ok := value.(string)
16245				if !ok {
16246					return fmt.Errorf("expected Status to be of type string, got %T instead", value)
16247				}
16248				sv.Status = types.Status(jtv)
16249			}
16250
16251		default:
16252			_, _ = key, value
16253
16254		}
16255	}
16256	*v = sv
16257	return nil
16258}
16259
16260func awsAwsjson11_deserializeOpDocumentCreateServiceActionOutput(v **CreateServiceActionOutput, value interface{}) error {
16261	if v == nil {
16262		return fmt.Errorf("unexpected nil of type %T", v)
16263	}
16264	if value == nil {
16265		return nil
16266	}
16267
16268	shape, ok := value.(map[string]interface{})
16269	if !ok {
16270		return fmt.Errorf("unexpected JSON type %v", value)
16271	}
16272
16273	var sv *CreateServiceActionOutput
16274	if *v == nil {
16275		sv = &CreateServiceActionOutput{}
16276	} else {
16277		sv = *v
16278	}
16279
16280	for key, value := range shape {
16281		switch key {
16282		case "ServiceActionDetail":
16283			if err := awsAwsjson11_deserializeDocumentServiceActionDetail(&sv.ServiceActionDetail, value); err != nil {
16284				return err
16285			}
16286
16287		default:
16288			_, _ = key, value
16289
16290		}
16291	}
16292	*v = sv
16293	return nil
16294}
16295
16296func awsAwsjson11_deserializeOpDocumentCreateTagOptionOutput(v **CreateTagOptionOutput, value interface{}) error {
16297	if v == nil {
16298		return fmt.Errorf("unexpected nil of type %T", v)
16299	}
16300	if value == nil {
16301		return nil
16302	}
16303
16304	shape, ok := value.(map[string]interface{})
16305	if !ok {
16306		return fmt.Errorf("unexpected JSON type %v", value)
16307	}
16308
16309	var sv *CreateTagOptionOutput
16310	if *v == nil {
16311		sv = &CreateTagOptionOutput{}
16312	} else {
16313		sv = *v
16314	}
16315
16316	for key, value := range shape {
16317		switch key {
16318		case "TagOptionDetail":
16319			if err := awsAwsjson11_deserializeDocumentTagOptionDetail(&sv.TagOptionDetail, value); err != nil {
16320				return err
16321			}
16322
16323		default:
16324			_, _ = key, value
16325
16326		}
16327	}
16328	*v = sv
16329	return nil
16330}
16331
16332func awsAwsjson11_deserializeOpDocumentDeleteConstraintOutput(v **DeleteConstraintOutput, value interface{}) error {
16333	if v == nil {
16334		return fmt.Errorf("unexpected nil of type %T", v)
16335	}
16336	if value == nil {
16337		return nil
16338	}
16339
16340	shape, ok := value.(map[string]interface{})
16341	if !ok {
16342		return fmt.Errorf("unexpected JSON type %v", value)
16343	}
16344
16345	var sv *DeleteConstraintOutput
16346	if *v == nil {
16347		sv = &DeleteConstraintOutput{}
16348	} else {
16349		sv = *v
16350	}
16351
16352	for key, value := range shape {
16353		switch key {
16354		default:
16355			_, _ = key, value
16356
16357		}
16358	}
16359	*v = sv
16360	return nil
16361}
16362
16363func awsAwsjson11_deserializeOpDocumentDeletePortfolioOutput(v **DeletePortfolioOutput, value interface{}) error {
16364	if v == nil {
16365		return fmt.Errorf("unexpected nil of type %T", v)
16366	}
16367	if value == nil {
16368		return nil
16369	}
16370
16371	shape, ok := value.(map[string]interface{})
16372	if !ok {
16373		return fmt.Errorf("unexpected JSON type %v", value)
16374	}
16375
16376	var sv *DeletePortfolioOutput
16377	if *v == nil {
16378		sv = &DeletePortfolioOutput{}
16379	} else {
16380		sv = *v
16381	}
16382
16383	for key, value := range shape {
16384		switch key {
16385		default:
16386			_, _ = key, value
16387
16388		}
16389	}
16390	*v = sv
16391	return nil
16392}
16393
16394func awsAwsjson11_deserializeOpDocumentDeletePortfolioShareOutput(v **DeletePortfolioShareOutput, value interface{}) error {
16395	if v == nil {
16396		return fmt.Errorf("unexpected nil of type %T", v)
16397	}
16398	if value == nil {
16399		return nil
16400	}
16401
16402	shape, ok := value.(map[string]interface{})
16403	if !ok {
16404		return fmt.Errorf("unexpected JSON type %v", value)
16405	}
16406
16407	var sv *DeletePortfolioShareOutput
16408	if *v == nil {
16409		sv = &DeletePortfolioShareOutput{}
16410	} else {
16411		sv = *v
16412	}
16413
16414	for key, value := range shape {
16415		switch key {
16416		case "PortfolioShareToken":
16417			if value != nil {
16418				jtv, ok := value.(string)
16419				if !ok {
16420					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
16421				}
16422				sv.PortfolioShareToken = ptr.String(jtv)
16423			}
16424
16425		default:
16426			_, _ = key, value
16427
16428		}
16429	}
16430	*v = sv
16431	return nil
16432}
16433
16434func awsAwsjson11_deserializeOpDocumentDeleteProductOutput(v **DeleteProductOutput, value interface{}) error {
16435	if v == nil {
16436		return fmt.Errorf("unexpected nil of type %T", v)
16437	}
16438	if value == nil {
16439		return nil
16440	}
16441
16442	shape, ok := value.(map[string]interface{})
16443	if !ok {
16444		return fmt.Errorf("unexpected JSON type %v", value)
16445	}
16446
16447	var sv *DeleteProductOutput
16448	if *v == nil {
16449		sv = &DeleteProductOutput{}
16450	} else {
16451		sv = *v
16452	}
16453
16454	for key, value := range shape {
16455		switch key {
16456		default:
16457			_, _ = key, value
16458
16459		}
16460	}
16461	*v = sv
16462	return nil
16463}
16464
16465func awsAwsjson11_deserializeOpDocumentDeleteProvisionedProductPlanOutput(v **DeleteProvisionedProductPlanOutput, value interface{}) error {
16466	if v == nil {
16467		return fmt.Errorf("unexpected nil of type %T", v)
16468	}
16469	if value == nil {
16470		return nil
16471	}
16472
16473	shape, ok := value.(map[string]interface{})
16474	if !ok {
16475		return fmt.Errorf("unexpected JSON type %v", value)
16476	}
16477
16478	var sv *DeleteProvisionedProductPlanOutput
16479	if *v == nil {
16480		sv = &DeleteProvisionedProductPlanOutput{}
16481	} else {
16482		sv = *v
16483	}
16484
16485	for key, value := range shape {
16486		switch key {
16487		default:
16488			_, _ = key, value
16489
16490		}
16491	}
16492	*v = sv
16493	return nil
16494}
16495
16496func awsAwsjson11_deserializeOpDocumentDeleteProvisioningArtifactOutput(v **DeleteProvisioningArtifactOutput, value interface{}) error {
16497	if v == nil {
16498		return fmt.Errorf("unexpected nil of type %T", v)
16499	}
16500	if value == nil {
16501		return nil
16502	}
16503
16504	shape, ok := value.(map[string]interface{})
16505	if !ok {
16506		return fmt.Errorf("unexpected JSON type %v", value)
16507	}
16508
16509	var sv *DeleteProvisioningArtifactOutput
16510	if *v == nil {
16511		sv = &DeleteProvisioningArtifactOutput{}
16512	} else {
16513		sv = *v
16514	}
16515
16516	for key, value := range shape {
16517		switch key {
16518		default:
16519			_, _ = key, value
16520
16521		}
16522	}
16523	*v = sv
16524	return nil
16525}
16526
16527func awsAwsjson11_deserializeOpDocumentDeleteServiceActionOutput(v **DeleteServiceActionOutput, value interface{}) error {
16528	if v == nil {
16529		return fmt.Errorf("unexpected nil of type %T", v)
16530	}
16531	if value == nil {
16532		return nil
16533	}
16534
16535	shape, ok := value.(map[string]interface{})
16536	if !ok {
16537		return fmt.Errorf("unexpected JSON type %v", value)
16538	}
16539
16540	var sv *DeleteServiceActionOutput
16541	if *v == nil {
16542		sv = &DeleteServiceActionOutput{}
16543	} else {
16544		sv = *v
16545	}
16546
16547	for key, value := range shape {
16548		switch key {
16549		default:
16550			_, _ = key, value
16551
16552		}
16553	}
16554	*v = sv
16555	return nil
16556}
16557
16558func awsAwsjson11_deserializeOpDocumentDeleteTagOptionOutput(v **DeleteTagOptionOutput, value interface{}) error {
16559	if v == nil {
16560		return fmt.Errorf("unexpected nil of type %T", v)
16561	}
16562	if value == nil {
16563		return nil
16564	}
16565
16566	shape, ok := value.(map[string]interface{})
16567	if !ok {
16568		return fmt.Errorf("unexpected JSON type %v", value)
16569	}
16570
16571	var sv *DeleteTagOptionOutput
16572	if *v == nil {
16573		sv = &DeleteTagOptionOutput{}
16574	} else {
16575		sv = *v
16576	}
16577
16578	for key, value := range shape {
16579		switch key {
16580		default:
16581			_, _ = key, value
16582
16583		}
16584	}
16585	*v = sv
16586	return nil
16587}
16588
16589func awsAwsjson11_deserializeOpDocumentDescribeConstraintOutput(v **DescribeConstraintOutput, value interface{}) error {
16590	if v == nil {
16591		return fmt.Errorf("unexpected nil of type %T", v)
16592	}
16593	if value == nil {
16594		return nil
16595	}
16596
16597	shape, ok := value.(map[string]interface{})
16598	if !ok {
16599		return fmt.Errorf("unexpected JSON type %v", value)
16600	}
16601
16602	var sv *DescribeConstraintOutput
16603	if *v == nil {
16604		sv = &DescribeConstraintOutput{}
16605	} else {
16606		sv = *v
16607	}
16608
16609	for key, value := range shape {
16610		switch key {
16611		case "ConstraintDetail":
16612			if err := awsAwsjson11_deserializeDocumentConstraintDetail(&sv.ConstraintDetail, value); err != nil {
16613				return err
16614			}
16615
16616		case "ConstraintParameters":
16617			if value != nil {
16618				jtv, ok := value.(string)
16619				if !ok {
16620					return fmt.Errorf("expected ConstraintParameters to be of type string, got %T instead", value)
16621				}
16622				sv.ConstraintParameters = ptr.String(jtv)
16623			}
16624
16625		case "Status":
16626			if value != nil {
16627				jtv, ok := value.(string)
16628				if !ok {
16629					return fmt.Errorf("expected Status to be of type string, got %T instead", value)
16630				}
16631				sv.Status = types.Status(jtv)
16632			}
16633
16634		default:
16635			_, _ = key, value
16636
16637		}
16638	}
16639	*v = sv
16640	return nil
16641}
16642
16643func awsAwsjson11_deserializeOpDocumentDescribeCopyProductStatusOutput(v **DescribeCopyProductStatusOutput, value interface{}) error {
16644	if v == nil {
16645		return fmt.Errorf("unexpected nil of type %T", v)
16646	}
16647	if value == nil {
16648		return nil
16649	}
16650
16651	shape, ok := value.(map[string]interface{})
16652	if !ok {
16653		return fmt.Errorf("unexpected JSON type %v", value)
16654	}
16655
16656	var sv *DescribeCopyProductStatusOutput
16657	if *v == nil {
16658		sv = &DescribeCopyProductStatusOutput{}
16659	} else {
16660		sv = *v
16661	}
16662
16663	for key, value := range shape {
16664		switch key {
16665		case "CopyProductStatus":
16666			if value != nil {
16667				jtv, ok := value.(string)
16668				if !ok {
16669					return fmt.Errorf("expected CopyProductStatus to be of type string, got %T instead", value)
16670				}
16671				sv.CopyProductStatus = types.CopyProductStatus(jtv)
16672			}
16673
16674		case "StatusDetail":
16675			if value != nil {
16676				jtv, ok := value.(string)
16677				if !ok {
16678					return fmt.Errorf("expected StatusDetail to be of type string, got %T instead", value)
16679				}
16680				sv.StatusDetail = ptr.String(jtv)
16681			}
16682
16683		case "TargetProductId":
16684			if value != nil {
16685				jtv, ok := value.(string)
16686				if !ok {
16687					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
16688				}
16689				sv.TargetProductId = ptr.String(jtv)
16690			}
16691
16692		default:
16693			_, _ = key, value
16694
16695		}
16696	}
16697	*v = sv
16698	return nil
16699}
16700
16701func awsAwsjson11_deserializeOpDocumentDescribePortfolioOutput(v **DescribePortfolioOutput, value interface{}) error {
16702	if v == nil {
16703		return fmt.Errorf("unexpected nil of type %T", v)
16704	}
16705	if value == nil {
16706		return nil
16707	}
16708
16709	shape, ok := value.(map[string]interface{})
16710	if !ok {
16711		return fmt.Errorf("unexpected JSON type %v", value)
16712	}
16713
16714	var sv *DescribePortfolioOutput
16715	if *v == nil {
16716		sv = &DescribePortfolioOutput{}
16717	} else {
16718		sv = *v
16719	}
16720
16721	for key, value := range shape {
16722		switch key {
16723		case "Budgets":
16724			if err := awsAwsjson11_deserializeDocumentBudgets(&sv.Budgets, value); err != nil {
16725				return err
16726			}
16727
16728		case "PortfolioDetail":
16729			if err := awsAwsjson11_deserializeDocumentPortfolioDetail(&sv.PortfolioDetail, value); err != nil {
16730				return err
16731			}
16732
16733		case "TagOptions":
16734			if err := awsAwsjson11_deserializeDocumentTagOptionDetails(&sv.TagOptions, value); err != nil {
16735				return err
16736			}
16737
16738		case "Tags":
16739			if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
16740				return err
16741			}
16742
16743		default:
16744			_, _ = key, value
16745
16746		}
16747	}
16748	*v = sv
16749	return nil
16750}
16751
16752func awsAwsjson11_deserializeOpDocumentDescribePortfolioSharesOutput(v **DescribePortfolioSharesOutput, value interface{}) error {
16753	if v == nil {
16754		return fmt.Errorf("unexpected nil of type %T", v)
16755	}
16756	if value == nil {
16757		return nil
16758	}
16759
16760	shape, ok := value.(map[string]interface{})
16761	if !ok {
16762		return fmt.Errorf("unexpected JSON type %v", value)
16763	}
16764
16765	var sv *DescribePortfolioSharesOutput
16766	if *v == nil {
16767		sv = &DescribePortfolioSharesOutput{}
16768	} else {
16769		sv = *v
16770	}
16771
16772	for key, value := range shape {
16773		switch key {
16774		case "NextPageToken":
16775			if value != nil {
16776				jtv, ok := value.(string)
16777				if !ok {
16778					return fmt.Errorf("expected PageToken to be of type string, got %T instead", value)
16779				}
16780				sv.NextPageToken = ptr.String(jtv)
16781			}
16782
16783		case "PortfolioShareDetails":
16784			if err := awsAwsjson11_deserializeDocumentPortfolioShareDetails(&sv.PortfolioShareDetails, value); err != nil {
16785				return err
16786			}
16787
16788		default:
16789			_, _ = key, value
16790
16791		}
16792	}
16793	*v = sv
16794	return nil
16795}
16796
16797func awsAwsjson11_deserializeOpDocumentDescribePortfolioShareStatusOutput(v **DescribePortfolioShareStatusOutput, value interface{}) error {
16798	if v == nil {
16799		return fmt.Errorf("unexpected nil of type %T", v)
16800	}
16801	if value == nil {
16802		return nil
16803	}
16804
16805	shape, ok := value.(map[string]interface{})
16806	if !ok {
16807		return fmt.Errorf("unexpected JSON type %v", value)
16808	}
16809
16810	var sv *DescribePortfolioShareStatusOutput
16811	if *v == nil {
16812		sv = &DescribePortfolioShareStatusOutput{}
16813	} else {
16814		sv = *v
16815	}
16816
16817	for key, value := range shape {
16818		switch key {
16819		case "OrganizationNodeValue":
16820			if value != nil {
16821				jtv, ok := value.(string)
16822				if !ok {
16823					return fmt.Errorf("expected OrganizationNodeValue to be of type string, got %T instead", value)
16824				}
16825				sv.OrganizationNodeValue = ptr.String(jtv)
16826			}
16827
16828		case "PortfolioId":
16829			if value != nil {
16830				jtv, ok := value.(string)
16831				if !ok {
16832					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
16833				}
16834				sv.PortfolioId = ptr.String(jtv)
16835			}
16836
16837		case "PortfolioShareToken":
16838			if value != nil {
16839				jtv, ok := value.(string)
16840				if !ok {
16841					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
16842				}
16843				sv.PortfolioShareToken = ptr.String(jtv)
16844			}
16845
16846		case "ShareDetails":
16847			if err := awsAwsjson11_deserializeDocumentShareDetails(&sv.ShareDetails, value); err != nil {
16848				return err
16849			}
16850
16851		case "Status":
16852			if value != nil {
16853				jtv, ok := value.(string)
16854				if !ok {
16855					return fmt.Errorf("expected ShareStatus to be of type string, got %T instead", value)
16856				}
16857				sv.Status = types.ShareStatus(jtv)
16858			}
16859
16860		default:
16861			_, _ = key, value
16862
16863		}
16864	}
16865	*v = sv
16866	return nil
16867}
16868
16869func awsAwsjson11_deserializeOpDocumentDescribeProductAsAdminOutput(v **DescribeProductAsAdminOutput, value interface{}) error {
16870	if v == nil {
16871		return fmt.Errorf("unexpected nil of type %T", v)
16872	}
16873	if value == nil {
16874		return nil
16875	}
16876
16877	shape, ok := value.(map[string]interface{})
16878	if !ok {
16879		return fmt.Errorf("unexpected JSON type %v", value)
16880	}
16881
16882	var sv *DescribeProductAsAdminOutput
16883	if *v == nil {
16884		sv = &DescribeProductAsAdminOutput{}
16885	} else {
16886		sv = *v
16887	}
16888
16889	for key, value := range shape {
16890		switch key {
16891		case "Budgets":
16892			if err := awsAwsjson11_deserializeDocumentBudgets(&sv.Budgets, value); err != nil {
16893				return err
16894			}
16895
16896		case "ProductViewDetail":
16897			if err := awsAwsjson11_deserializeDocumentProductViewDetail(&sv.ProductViewDetail, value); err != nil {
16898				return err
16899			}
16900
16901		case "ProvisioningArtifactSummaries":
16902			if err := awsAwsjson11_deserializeDocumentProvisioningArtifactSummaries(&sv.ProvisioningArtifactSummaries, value); err != nil {
16903				return err
16904			}
16905
16906		case "TagOptions":
16907			if err := awsAwsjson11_deserializeDocumentTagOptionDetails(&sv.TagOptions, value); err != nil {
16908				return err
16909			}
16910
16911		case "Tags":
16912			if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
16913				return err
16914			}
16915
16916		default:
16917			_, _ = key, value
16918
16919		}
16920	}
16921	*v = sv
16922	return nil
16923}
16924
16925func awsAwsjson11_deserializeOpDocumentDescribeProductOutput(v **DescribeProductOutput, value interface{}) error {
16926	if v == nil {
16927		return fmt.Errorf("unexpected nil of type %T", v)
16928	}
16929	if value == nil {
16930		return nil
16931	}
16932
16933	shape, ok := value.(map[string]interface{})
16934	if !ok {
16935		return fmt.Errorf("unexpected JSON type %v", value)
16936	}
16937
16938	var sv *DescribeProductOutput
16939	if *v == nil {
16940		sv = &DescribeProductOutput{}
16941	} else {
16942		sv = *v
16943	}
16944
16945	for key, value := range shape {
16946		switch key {
16947		case "Budgets":
16948			if err := awsAwsjson11_deserializeDocumentBudgets(&sv.Budgets, value); err != nil {
16949				return err
16950			}
16951
16952		case "LaunchPaths":
16953			if err := awsAwsjson11_deserializeDocumentLaunchPaths(&sv.LaunchPaths, value); err != nil {
16954				return err
16955			}
16956
16957		case "ProductViewSummary":
16958			if err := awsAwsjson11_deserializeDocumentProductViewSummary(&sv.ProductViewSummary, value); err != nil {
16959				return err
16960			}
16961
16962		case "ProvisioningArtifacts":
16963			if err := awsAwsjson11_deserializeDocumentProvisioningArtifacts(&sv.ProvisioningArtifacts, value); err != nil {
16964				return err
16965			}
16966
16967		default:
16968			_, _ = key, value
16969
16970		}
16971	}
16972	*v = sv
16973	return nil
16974}
16975
16976func awsAwsjson11_deserializeOpDocumentDescribeProductViewOutput(v **DescribeProductViewOutput, value interface{}) error {
16977	if v == nil {
16978		return fmt.Errorf("unexpected nil of type %T", v)
16979	}
16980	if value == nil {
16981		return nil
16982	}
16983
16984	shape, ok := value.(map[string]interface{})
16985	if !ok {
16986		return fmt.Errorf("unexpected JSON type %v", value)
16987	}
16988
16989	var sv *DescribeProductViewOutput
16990	if *v == nil {
16991		sv = &DescribeProductViewOutput{}
16992	} else {
16993		sv = *v
16994	}
16995
16996	for key, value := range shape {
16997		switch key {
16998		case "ProductViewSummary":
16999			if err := awsAwsjson11_deserializeDocumentProductViewSummary(&sv.ProductViewSummary, value); err != nil {
17000				return err
17001			}
17002
17003		case "ProvisioningArtifacts":
17004			if err := awsAwsjson11_deserializeDocumentProvisioningArtifacts(&sv.ProvisioningArtifacts, value); err != nil {
17005				return err
17006			}
17007
17008		default:
17009			_, _ = key, value
17010
17011		}
17012	}
17013	*v = sv
17014	return nil
17015}
17016
17017func awsAwsjson11_deserializeOpDocumentDescribeProvisionedProductOutput(v **DescribeProvisionedProductOutput, value interface{}) error {
17018	if v == nil {
17019		return fmt.Errorf("unexpected nil of type %T", v)
17020	}
17021	if value == nil {
17022		return nil
17023	}
17024
17025	shape, ok := value.(map[string]interface{})
17026	if !ok {
17027		return fmt.Errorf("unexpected JSON type %v", value)
17028	}
17029
17030	var sv *DescribeProvisionedProductOutput
17031	if *v == nil {
17032		sv = &DescribeProvisionedProductOutput{}
17033	} else {
17034		sv = *v
17035	}
17036
17037	for key, value := range shape {
17038		switch key {
17039		case "CloudWatchDashboards":
17040			if err := awsAwsjson11_deserializeDocumentCloudWatchDashboards(&sv.CloudWatchDashboards, value); err != nil {
17041				return err
17042			}
17043
17044		case "ProvisionedProductDetail":
17045			if err := awsAwsjson11_deserializeDocumentProvisionedProductDetail(&sv.ProvisionedProductDetail, value); err != nil {
17046				return err
17047			}
17048
17049		default:
17050			_, _ = key, value
17051
17052		}
17053	}
17054	*v = sv
17055	return nil
17056}
17057
17058func awsAwsjson11_deserializeOpDocumentDescribeProvisionedProductPlanOutput(v **DescribeProvisionedProductPlanOutput, value interface{}) error {
17059	if v == nil {
17060		return fmt.Errorf("unexpected nil of type %T", v)
17061	}
17062	if value == nil {
17063		return nil
17064	}
17065
17066	shape, ok := value.(map[string]interface{})
17067	if !ok {
17068		return fmt.Errorf("unexpected JSON type %v", value)
17069	}
17070
17071	var sv *DescribeProvisionedProductPlanOutput
17072	if *v == nil {
17073		sv = &DescribeProvisionedProductPlanOutput{}
17074	} else {
17075		sv = *v
17076	}
17077
17078	for key, value := range shape {
17079		switch key {
17080		case "NextPageToken":
17081			if value != nil {
17082				jtv, ok := value.(string)
17083				if !ok {
17084					return fmt.Errorf("expected PageToken to be of type string, got %T instead", value)
17085				}
17086				sv.NextPageToken = ptr.String(jtv)
17087			}
17088
17089		case "ProvisionedProductPlanDetails":
17090			if err := awsAwsjson11_deserializeDocumentProvisionedProductPlanDetails(&sv.ProvisionedProductPlanDetails, value); err != nil {
17091				return err
17092			}
17093
17094		case "ResourceChanges":
17095			if err := awsAwsjson11_deserializeDocumentResourceChanges(&sv.ResourceChanges, value); err != nil {
17096				return err
17097			}
17098
17099		default:
17100			_, _ = key, value
17101
17102		}
17103	}
17104	*v = sv
17105	return nil
17106}
17107
17108func awsAwsjson11_deserializeOpDocumentDescribeProvisioningArtifactOutput(v **DescribeProvisioningArtifactOutput, value interface{}) error {
17109	if v == nil {
17110		return fmt.Errorf("unexpected nil of type %T", v)
17111	}
17112	if value == nil {
17113		return nil
17114	}
17115
17116	shape, ok := value.(map[string]interface{})
17117	if !ok {
17118		return fmt.Errorf("unexpected JSON type %v", value)
17119	}
17120
17121	var sv *DescribeProvisioningArtifactOutput
17122	if *v == nil {
17123		sv = &DescribeProvisioningArtifactOutput{}
17124	} else {
17125		sv = *v
17126	}
17127
17128	for key, value := range shape {
17129		switch key {
17130		case "Info":
17131			if err := awsAwsjson11_deserializeDocumentProvisioningArtifactInfo(&sv.Info, value); err != nil {
17132				return err
17133			}
17134
17135		case "ProvisioningArtifactDetail":
17136			if err := awsAwsjson11_deserializeDocumentProvisioningArtifactDetail(&sv.ProvisioningArtifactDetail, value); err != nil {
17137				return err
17138			}
17139
17140		case "Status":
17141			if value != nil {
17142				jtv, ok := value.(string)
17143				if !ok {
17144					return fmt.Errorf("expected Status to be of type string, got %T instead", value)
17145				}
17146				sv.Status = types.Status(jtv)
17147			}
17148
17149		default:
17150			_, _ = key, value
17151
17152		}
17153	}
17154	*v = sv
17155	return nil
17156}
17157
17158func awsAwsjson11_deserializeOpDocumentDescribeProvisioningParametersOutput(v **DescribeProvisioningParametersOutput, value interface{}) error {
17159	if v == nil {
17160		return fmt.Errorf("unexpected nil of type %T", v)
17161	}
17162	if value == nil {
17163		return nil
17164	}
17165
17166	shape, ok := value.(map[string]interface{})
17167	if !ok {
17168		return fmt.Errorf("unexpected JSON type %v", value)
17169	}
17170
17171	var sv *DescribeProvisioningParametersOutput
17172	if *v == nil {
17173		sv = &DescribeProvisioningParametersOutput{}
17174	} else {
17175		sv = *v
17176	}
17177
17178	for key, value := range shape {
17179		switch key {
17180		case "ConstraintSummaries":
17181			if err := awsAwsjson11_deserializeDocumentConstraintSummaries(&sv.ConstraintSummaries, value); err != nil {
17182				return err
17183			}
17184
17185		case "ProvisioningArtifactOutputs":
17186			if err := awsAwsjson11_deserializeDocumentProvisioningArtifactOutputs(&sv.ProvisioningArtifactOutputs, value); err != nil {
17187				return err
17188			}
17189
17190		case "ProvisioningArtifactParameters":
17191			if err := awsAwsjson11_deserializeDocumentProvisioningArtifactParameters(&sv.ProvisioningArtifactParameters, value); err != nil {
17192				return err
17193			}
17194
17195		case "ProvisioningArtifactPreferences":
17196			if err := awsAwsjson11_deserializeDocumentProvisioningArtifactPreferences(&sv.ProvisioningArtifactPreferences, value); err != nil {
17197				return err
17198			}
17199
17200		case "TagOptions":
17201			if err := awsAwsjson11_deserializeDocumentTagOptionSummaries(&sv.TagOptions, value); err != nil {
17202				return err
17203			}
17204
17205		case "UsageInstructions":
17206			if err := awsAwsjson11_deserializeDocumentUsageInstructions(&sv.UsageInstructions, value); err != nil {
17207				return err
17208			}
17209
17210		default:
17211			_, _ = key, value
17212
17213		}
17214	}
17215	*v = sv
17216	return nil
17217}
17218
17219func awsAwsjson11_deserializeOpDocumentDescribeRecordOutput(v **DescribeRecordOutput, value interface{}) error {
17220	if v == nil {
17221		return fmt.Errorf("unexpected nil of type %T", v)
17222	}
17223	if value == nil {
17224		return nil
17225	}
17226
17227	shape, ok := value.(map[string]interface{})
17228	if !ok {
17229		return fmt.Errorf("unexpected JSON type %v", value)
17230	}
17231
17232	var sv *DescribeRecordOutput
17233	if *v == nil {
17234		sv = &DescribeRecordOutput{}
17235	} else {
17236		sv = *v
17237	}
17238
17239	for key, value := range shape {
17240		switch key {
17241		case "NextPageToken":
17242			if value != nil {
17243				jtv, ok := value.(string)
17244				if !ok {
17245					return fmt.Errorf("expected PageToken to be of type string, got %T instead", value)
17246				}
17247				sv.NextPageToken = ptr.String(jtv)
17248			}
17249
17250		case "RecordDetail":
17251			if err := awsAwsjson11_deserializeDocumentRecordDetail(&sv.RecordDetail, value); err != nil {
17252				return err
17253			}
17254
17255		case "RecordOutputs":
17256			if err := awsAwsjson11_deserializeDocumentRecordOutputs(&sv.RecordOutputs, value); err != nil {
17257				return err
17258			}
17259
17260		default:
17261			_, _ = key, value
17262
17263		}
17264	}
17265	*v = sv
17266	return nil
17267}
17268
17269func awsAwsjson11_deserializeOpDocumentDescribeServiceActionExecutionParametersOutput(v **DescribeServiceActionExecutionParametersOutput, value interface{}) error {
17270	if v == nil {
17271		return fmt.Errorf("unexpected nil of type %T", v)
17272	}
17273	if value == nil {
17274		return nil
17275	}
17276
17277	shape, ok := value.(map[string]interface{})
17278	if !ok {
17279		return fmt.Errorf("unexpected JSON type %v", value)
17280	}
17281
17282	var sv *DescribeServiceActionExecutionParametersOutput
17283	if *v == nil {
17284		sv = &DescribeServiceActionExecutionParametersOutput{}
17285	} else {
17286		sv = *v
17287	}
17288
17289	for key, value := range shape {
17290		switch key {
17291		case "ServiceActionParameters":
17292			if err := awsAwsjson11_deserializeDocumentExecutionParameters(&sv.ServiceActionParameters, value); err != nil {
17293				return err
17294			}
17295
17296		default:
17297			_, _ = key, value
17298
17299		}
17300	}
17301	*v = sv
17302	return nil
17303}
17304
17305func awsAwsjson11_deserializeOpDocumentDescribeServiceActionOutput(v **DescribeServiceActionOutput, value interface{}) error {
17306	if v == nil {
17307		return fmt.Errorf("unexpected nil of type %T", v)
17308	}
17309	if value == nil {
17310		return nil
17311	}
17312
17313	shape, ok := value.(map[string]interface{})
17314	if !ok {
17315		return fmt.Errorf("unexpected JSON type %v", value)
17316	}
17317
17318	var sv *DescribeServiceActionOutput
17319	if *v == nil {
17320		sv = &DescribeServiceActionOutput{}
17321	} else {
17322		sv = *v
17323	}
17324
17325	for key, value := range shape {
17326		switch key {
17327		case "ServiceActionDetail":
17328			if err := awsAwsjson11_deserializeDocumentServiceActionDetail(&sv.ServiceActionDetail, value); err != nil {
17329				return err
17330			}
17331
17332		default:
17333			_, _ = key, value
17334
17335		}
17336	}
17337	*v = sv
17338	return nil
17339}
17340
17341func awsAwsjson11_deserializeOpDocumentDescribeTagOptionOutput(v **DescribeTagOptionOutput, value interface{}) error {
17342	if v == nil {
17343		return fmt.Errorf("unexpected nil of type %T", v)
17344	}
17345	if value == nil {
17346		return nil
17347	}
17348
17349	shape, ok := value.(map[string]interface{})
17350	if !ok {
17351		return fmt.Errorf("unexpected JSON type %v", value)
17352	}
17353
17354	var sv *DescribeTagOptionOutput
17355	if *v == nil {
17356		sv = &DescribeTagOptionOutput{}
17357	} else {
17358		sv = *v
17359	}
17360
17361	for key, value := range shape {
17362		switch key {
17363		case "TagOptionDetail":
17364			if err := awsAwsjson11_deserializeDocumentTagOptionDetail(&sv.TagOptionDetail, value); err != nil {
17365				return err
17366			}
17367
17368		default:
17369			_, _ = key, value
17370
17371		}
17372	}
17373	*v = sv
17374	return nil
17375}
17376
17377func awsAwsjson11_deserializeOpDocumentDisableAWSOrganizationsAccessOutput(v **DisableAWSOrganizationsAccessOutput, value interface{}) error {
17378	if v == nil {
17379		return fmt.Errorf("unexpected nil of type %T", v)
17380	}
17381	if value == nil {
17382		return nil
17383	}
17384
17385	shape, ok := value.(map[string]interface{})
17386	if !ok {
17387		return fmt.Errorf("unexpected JSON type %v", value)
17388	}
17389
17390	var sv *DisableAWSOrganizationsAccessOutput
17391	if *v == nil {
17392		sv = &DisableAWSOrganizationsAccessOutput{}
17393	} else {
17394		sv = *v
17395	}
17396
17397	for key, value := range shape {
17398		switch key {
17399		default:
17400			_, _ = key, value
17401
17402		}
17403	}
17404	*v = sv
17405	return nil
17406}
17407
17408func awsAwsjson11_deserializeOpDocumentDisassociateBudgetFromResourceOutput(v **DisassociateBudgetFromResourceOutput, value interface{}) error {
17409	if v == nil {
17410		return fmt.Errorf("unexpected nil of type %T", v)
17411	}
17412	if value == nil {
17413		return nil
17414	}
17415
17416	shape, ok := value.(map[string]interface{})
17417	if !ok {
17418		return fmt.Errorf("unexpected JSON type %v", value)
17419	}
17420
17421	var sv *DisassociateBudgetFromResourceOutput
17422	if *v == nil {
17423		sv = &DisassociateBudgetFromResourceOutput{}
17424	} else {
17425		sv = *v
17426	}
17427
17428	for key, value := range shape {
17429		switch key {
17430		default:
17431			_, _ = key, value
17432
17433		}
17434	}
17435	*v = sv
17436	return nil
17437}
17438
17439func awsAwsjson11_deserializeOpDocumentDisassociatePrincipalFromPortfolioOutput(v **DisassociatePrincipalFromPortfolioOutput, value interface{}) error {
17440	if v == nil {
17441		return fmt.Errorf("unexpected nil of type %T", v)
17442	}
17443	if value == nil {
17444		return nil
17445	}
17446
17447	shape, ok := value.(map[string]interface{})
17448	if !ok {
17449		return fmt.Errorf("unexpected JSON type %v", value)
17450	}
17451
17452	var sv *DisassociatePrincipalFromPortfolioOutput
17453	if *v == nil {
17454		sv = &DisassociatePrincipalFromPortfolioOutput{}
17455	} else {
17456		sv = *v
17457	}
17458
17459	for key, value := range shape {
17460		switch key {
17461		default:
17462			_, _ = key, value
17463
17464		}
17465	}
17466	*v = sv
17467	return nil
17468}
17469
17470func awsAwsjson11_deserializeOpDocumentDisassociateProductFromPortfolioOutput(v **DisassociateProductFromPortfolioOutput, value interface{}) error {
17471	if v == nil {
17472		return fmt.Errorf("unexpected nil of type %T", v)
17473	}
17474	if value == nil {
17475		return nil
17476	}
17477
17478	shape, ok := value.(map[string]interface{})
17479	if !ok {
17480		return fmt.Errorf("unexpected JSON type %v", value)
17481	}
17482
17483	var sv *DisassociateProductFromPortfolioOutput
17484	if *v == nil {
17485		sv = &DisassociateProductFromPortfolioOutput{}
17486	} else {
17487		sv = *v
17488	}
17489
17490	for key, value := range shape {
17491		switch key {
17492		default:
17493			_, _ = key, value
17494
17495		}
17496	}
17497	*v = sv
17498	return nil
17499}
17500
17501func awsAwsjson11_deserializeOpDocumentDisassociateServiceActionFromProvisioningArtifactOutput(v **DisassociateServiceActionFromProvisioningArtifactOutput, value interface{}) error {
17502	if v == nil {
17503		return fmt.Errorf("unexpected nil of type %T", v)
17504	}
17505	if value == nil {
17506		return nil
17507	}
17508
17509	shape, ok := value.(map[string]interface{})
17510	if !ok {
17511		return fmt.Errorf("unexpected JSON type %v", value)
17512	}
17513
17514	var sv *DisassociateServiceActionFromProvisioningArtifactOutput
17515	if *v == nil {
17516		sv = &DisassociateServiceActionFromProvisioningArtifactOutput{}
17517	} else {
17518		sv = *v
17519	}
17520
17521	for key, value := range shape {
17522		switch key {
17523		default:
17524			_, _ = key, value
17525
17526		}
17527	}
17528	*v = sv
17529	return nil
17530}
17531
17532func awsAwsjson11_deserializeOpDocumentDisassociateTagOptionFromResourceOutput(v **DisassociateTagOptionFromResourceOutput, value interface{}) error {
17533	if v == nil {
17534		return fmt.Errorf("unexpected nil of type %T", v)
17535	}
17536	if value == nil {
17537		return nil
17538	}
17539
17540	shape, ok := value.(map[string]interface{})
17541	if !ok {
17542		return fmt.Errorf("unexpected JSON type %v", value)
17543	}
17544
17545	var sv *DisassociateTagOptionFromResourceOutput
17546	if *v == nil {
17547		sv = &DisassociateTagOptionFromResourceOutput{}
17548	} else {
17549		sv = *v
17550	}
17551
17552	for key, value := range shape {
17553		switch key {
17554		default:
17555			_, _ = key, value
17556
17557		}
17558	}
17559	*v = sv
17560	return nil
17561}
17562
17563func awsAwsjson11_deserializeOpDocumentEnableAWSOrganizationsAccessOutput(v **EnableAWSOrganizationsAccessOutput, value interface{}) error {
17564	if v == nil {
17565		return fmt.Errorf("unexpected nil of type %T", v)
17566	}
17567	if value == nil {
17568		return nil
17569	}
17570
17571	shape, ok := value.(map[string]interface{})
17572	if !ok {
17573		return fmt.Errorf("unexpected JSON type %v", value)
17574	}
17575
17576	var sv *EnableAWSOrganizationsAccessOutput
17577	if *v == nil {
17578		sv = &EnableAWSOrganizationsAccessOutput{}
17579	} else {
17580		sv = *v
17581	}
17582
17583	for key, value := range shape {
17584		switch key {
17585		default:
17586			_, _ = key, value
17587
17588		}
17589	}
17590	*v = sv
17591	return nil
17592}
17593
17594func awsAwsjson11_deserializeOpDocumentExecuteProvisionedProductPlanOutput(v **ExecuteProvisionedProductPlanOutput, value interface{}) error {
17595	if v == nil {
17596		return fmt.Errorf("unexpected nil of type %T", v)
17597	}
17598	if value == nil {
17599		return nil
17600	}
17601
17602	shape, ok := value.(map[string]interface{})
17603	if !ok {
17604		return fmt.Errorf("unexpected JSON type %v", value)
17605	}
17606
17607	var sv *ExecuteProvisionedProductPlanOutput
17608	if *v == nil {
17609		sv = &ExecuteProvisionedProductPlanOutput{}
17610	} else {
17611		sv = *v
17612	}
17613
17614	for key, value := range shape {
17615		switch key {
17616		case "RecordDetail":
17617			if err := awsAwsjson11_deserializeDocumentRecordDetail(&sv.RecordDetail, value); err != nil {
17618				return err
17619			}
17620
17621		default:
17622			_, _ = key, value
17623
17624		}
17625	}
17626	*v = sv
17627	return nil
17628}
17629
17630func awsAwsjson11_deserializeOpDocumentExecuteProvisionedProductServiceActionOutput(v **ExecuteProvisionedProductServiceActionOutput, value interface{}) error {
17631	if v == nil {
17632		return fmt.Errorf("unexpected nil of type %T", v)
17633	}
17634	if value == nil {
17635		return nil
17636	}
17637
17638	shape, ok := value.(map[string]interface{})
17639	if !ok {
17640		return fmt.Errorf("unexpected JSON type %v", value)
17641	}
17642
17643	var sv *ExecuteProvisionedProductServiceActionOutput
17644	if *v == nil {
17645		sv = &ExecuteProvisionedProductServiceActionOutput{}
17646	} else {
17647		sv = *v
17648	}
17649
17650	for key, value := range shape {
17651		switch key {
17652		case "RecordDetail":
17653			if err := awsAwsjson11_deserializeDocumentRecordDetail(&sv.RecordDetail, value); err != nil {
17654				return err
17655			}
17656
17657		default:
17658			_, _ = key, value
17659
17660		}
17661	}
17662	*v = sv
17663	return nil
17664}
17665
17666func awsAwsjson11_deserializeOpDocumentGetAWSOrganizationsAccessStatusOutput(v **GetAWSOrganizationsAccessStatusOutput, value interface{}) error {
17667	if v == nil {
17668		return fmt.Errorf("unexpected nil of type %T", v)
17669	}
17670	if value == nil {
17671		return nil
17672	}
17673
17674	shape, ok := value.(map[string]interface{})
17675	if !ok {
17676		return fmt.Errorf("unexpected JSON type %v", value)
17677	}
17678
17679	var sv *GetAWSOrganizationsAccessStatusOutput
17680	if *v == nil {
17681		sv = &GetAWSOrganizationsAccessStatusOutput{}
17682	} else {
17683		sv = *v
17684	}
17685
17686	for key, value := range shape {
17687		switch key {
17688		case "AccessStatus":
17689			if value != nil {
17690				jtv, ok := value.(string)
17691				if !ok {
17692					return fmt.Errorf("expected AccessStatus to be of type string, got %T instead", value)
17693				}
17694				sv.AccessStatus = types.AccessStatus(jtv)
17695			}
17696
17697		default:
17698			_, _ = key, value
17699
17700		}
17701	}
17702	*v = sv
17703	return nil
17704}
17705
17706func awsAwsjson11_deserializeOpDocumentGetProvisionedProductOutputsOutput(v **GetProvisionedProductOutputsOutput, value interface{}) error {
17707	if v == nil {
17708		return fmt.Errorf("unexpected nil of type %T", v)
17709	}
17710	if value == nil {
17711		return nil
17712	}
17713
17714	shape, ok := value.(map[string]interface{})
17715	if !ok {
17716		return fmt.Errorf("unexpected JSON type %v", value)
17717	}
17718
17719	var sv *GetProvisionedProductOutputsOutput
17720	if *v == nil {
17721		sv = &GetProvisionedProductOutputsOutput{}
17722	} else {
17723		sv = *v
17724	}
17725
17726	for key, value := range shape {
17727		switch key {
17728		case "NextPageToken":
17729			if value != nil {
17730				jtv, ok := value.(string)
17731				if !ok {
17732					return fmt.Errorf("expected PageToken to be of type string, got %T instead", value)
17733				}
17734				sv.NextPageToken = ptr.String(jtv)
17735			}
17736
17737		case "Outputs":
17738			if err := awsAwsjson11_deserializeDocumentRecordOutputs(&sv.Outputs, value); err != nil {
17739				return err
17740			}
17741
17742		default:
17743			_, _ = key, value
17744
17745		}
17746	}
17747	*v = sv
17748	return nil
17749}
17750
17751func awsAwsjson11_deserializeOpDocumentImportAsProvisionedProductOutput(v **ImportAsProvisionedProductOutput, value interface{}) error {
17752	if v == nil {
17753		return fmt.Errorf("unexpected nil of type %T", v)
17754	}
17755	if value == nil {
17756		return nil
17757	}
17758
17759	shape, ok := value.(map[string]interface{})
17760	if !ok {
17761		return fmt.Errorf("unexpected JSON type %v", value)
17762	}
17763
17764	var sv *ImportAsProvisionedProductOutput
17765	if *v == nil {
17766		sv = &ImportAsProvisionedProductOutput{}
17767	} else {
17768		sv = *v
17769	}
17770
17771	for key, value := range shape {
17772		switch key {
17773		case "RecordDetail":
17774			if err := awsAwsjson11_deserializeDocumentRecordDetail(&sv.RecordDetail, value); err != nil {
17775				return err
17776			}
17777
17778		default:
17779			_, _ = key, value
17780
17781		}
17782	}
17783	*v = sv
17784	return nil
17785}
17786
17787func awsAwsjson11_deserializeOpDocumentListAcceptedPortfolioSharesOutput(v **ListAcceptedPortfolioSharesOutput, value interface{}) error {
17788	if v == nil {
17789		return fmt.Errorf("unexpected nil of type %T", v)
17790	}
17791	if value == nil {
17792		return nil
17793	}
17794
17795	shape, ok := value.(map[string]interface{})
17796	if !ok {
17797		return fmt.Errorf("unexpected JSON type %v", value)
17798	}
17799
17800	var sv *ListAcceptedPortfolioSharesOutput
17801	if *v == nil {
17802		sv = &ListAcceptedPortfolioSharesOutput{}
17803	} else {
17804		sv = *v
17805	}
17806
17807	for key, value := range shape {
17808		switch key {
17809		case "NextPageToken":
17810			if value != nil {
17811				jtv, ok := value.(string)
17812				if !ok {
17813					return fmt.Errorf("expected PageToken to be of type string, got %T instead", value)
17814				}
17815				sv.NextPageToken = ptr.String(jtv)
17816			}
17817
17818		case "PortfolioDetails":
17819			if err := awsAwsjson11_deserializeDocumentPortfolioDetails(&sv.PortfolioDetails, value); err != nil {
17820				return err
17821			}
17822
17823		default:
17824			_, _ = key, value
17825
17826		}
17827	}
17828	*v = sv
17829	return nil
17830}
17831
17832func awsAwsjson11_deserializeOpDocumentListBudgetsForResourceOutput(v **ListBudgetsForResourceOutput, value interface{}) error {
17833	if v == nil {
17834		return fmt.Errorf("unexpected nil of type %T", v)
17835	}
17836	if value == nil {
17837		return nil
17838	}
17839
17840	shape, ok := value.(map[string]interface{})
17841	if !ok {
17842		return fmt.Errorf("unexpected JSON type %v", value)
17843	}
17844
17845	var sv *ListBudgetsForResourceOutput
17846	if *v == nil {
17847		sv = &ListBudgetsForResourceOutput{}
17848	} else {
17849		sv = *v
17850	}
17851
17852	for key, value := range shape {
17853		switch key {
17854		case "Budgets":
17855			if err := awsAwsjson11_deserializeDocumentBudgets(&sv.Budgets, value); err != nil {
17856				return err
17857			}
17858
17859		case "NextPageToken":
17860			if value != nil {
17861				jtv, ok := value.(string)
17862				if !ok {
17863					return fmt.Errorf("expected PageToken to be of type string, got %T instead", value)
17864				}
17865				sv.NextPageToken = ptr.String(jtv)
17866			}
17867
17868		default:
17869			_, _ = key, value
17870
17871		}
17872	}
17873	*v = sv
17874	return nil
17875}
17876
17877func awsAwsjson11_deserializeOpDocumentListConstraintsForPortfolioOutput(v **ListConstraintsForPortfolioOutput, value interface{}) error {
17878	if v == nil {
17879		return fmt.Errorf("unexpected nil of type %T", v)
17880	}
17881	if value == nil {
17882		return nil
17883	}
17884
17885	shape, ok := value.(map[string]interface{})
17886	if !ok {
17887		return fmt.Errorf("unexpected JSON type %v", value)
17888	}
17889
17890	var sv *ListConstraintsForPortfolioOutput
17891	if *v == nil {
17892		sv = &ListConstraintsForPortfolioOutput{}
17893	} else {
17894		sv = *v
17895	}
17896
17897	for key, value := range shape {
17898		switch key {
17899		case "ConstraintDetails":
17900			if err := awsAwsjson11_deserializeDocumentConstraintDetails(&sv.ConstraintDetails, value); err != nil {
17901				return err
17902			}
17903
17904		case "NextPageToken":
17905			if value != nil {
17906				jtv, ok := value.(string)
17907				if !ok {
17908					return fmt.Errorf("expected PageToken to be of type string, got %T instead", value)
17909				}
17910				sv.NextPageToken = ptr.String(jtv)
17911			}
17912
17913		default:
17914			_, _ = key, value
17915
17916		}
17917	}
17918	*v = sv
17919	return nil
17920}
17921
17922func awsAwsjson11_deserializeOpDocumentListLaunchPathsOutput(v **ListLaunchPathsOutput, value interface{}) error {
17923	if v == nil {
17924		return fmt.Errorf("unexpected nil of type %T", v)
17925	}
17926	if value == nil {
17927		return nil
17928	}
17929
17930	shape, ok := value.(map[string]interface{})
17931	if !ok {
17932		return fmt.Errorf("unexpected JSON type %v", value)
17933	}
17934
17935	var sv *ListLaunchPathsOutput
17936	if *v == nil {
17937		sv = &ListLaunchPathsOutput{}
17938	} else {
17939		sv = *v
17940	}
17941
17942	for key, value := range shape {
17943		switch key {
17944		case "LaunchPathSummaries":
17945			if err := awsAwsjson11_deserializeDocumentLaunchPathSummaries(&sv.LaunchPathSummaries, value); err != nil {
17946				return err
17947			}
17948
17949		case "NextPageToken":
17950			if value != nil {
17951				jtv, ok := value.(string)
17952				if !ok {
17953					return fmt.Errorf("expected PageToken to be of type string, got %T instead", value)
17954				}
17955				sv.NextPageToken = ptr.String(jtv)
17956			}
17957
17958		default:
17959			_, _ = key, value
17960
17961		}
17962	}
17963	*v = sv
17964	return nil
17965}
17966
17967func awsAwsjson11_deserializeOpDocumentListOrganizationPortfolioAccessOutput(v **ListOrganizationPortfolioAccessOutput, value interface{}) error {
17968	if v == nil {
17969		return fmt.Errorf("unexpected nil of type %T", v)
17970	}
17971	if value == nil {
17972		return nil
17973	}
17974
17975	shape, ok := value.(map[string]interface{})
17976	if !ok {
17977		return fmt.Errorf("unexpected JSON type %v", value)
17978	}
17979
17980	var sv *ListOrganizationPortfolioAccessOutput
17981	if *v == nil {
17982		sv = &ListOrganizationPortfolioAccessOutput{}
17983	} else {
17984		sv = *v
17985	}
17986
17987	for key, value := range shape {
17988		switch key {
17989		case "NextPageToken":
17990			if value != nil {
17991				jtv, ok := value.(string)
17992				if !ok {
17993					return fmt.Errorf("expected PageToken to be of type string, got %T instead", value)
17994				}
17995				sv.NextPageToken = ptr.String(jtv)
17996			}
17997
17998		case "OrganizationNodes":
17999			if err := awsAwsjson11_deserializeDocumentOrganizationNodes(&sv.OrganizationNodes, value); err != nil {
18000				return err
18001			}
18002
18003		default:
18004			_, _ = key, value
18005
18006		}
18007	}
18008	*v = sv
18009	return nil
18010}
18011
18012func awsAwsjson11_deserializeOpDocumentListPortfolioAccessOutput(v **ListPortfolioAccessOutput, value interface{}) error {
18013	if v == nil {
18014		return fmt.Errorf("unexpected nil of type %T", v)
18015	}
18016	if value == nil {
18017		return nil
18018	}
18019
18020	shape, ok := value.(map[string]interface{})
18021	if !ok {
18022		return fmt.Errorf("unexpected JSON type %v", value)
18023	}
18024
18025	var sv *ListPortfolioAccessOutput
18026	if *v == nil {
18027		sv = &ListPortfolioAccessOutput{}
18028	} else {
18029		sv = *v
18030	}
18031
18032	for key, value := range shape {
18033		switch key {
18034		case "AccountIds":
18035			if err := awsAwsjson11_deserializeDocumentAccountIds(&sv.AccountIds, value); err != nil {
18036				return err
18037			}
18038
18039		case "NextPageToken":
18040			if value != nil {
18041				jtv, ok := value.(string)
18042				if !ok {
18043					return fmt.Errorf("expected PageToken to be of type string, got %T instead", value)
18044				}
18045				sv.NextPageToken = ptr.String(jtv)
18046			}
18047
18048		default:
18049			_, _ = key, value
18050
18051		}
18052	}
18053	*v = sv
18054	return nil
18055}
18056
18057func awsAwsjson11_deserializeOpDocumentListPortfoliosForProductOutput(v **ListPortfoliosForProductOutput, value interface{}) error {
18058	if v == nil {
18059		return fmt.Errorf("unexpected nil of type %T", v)
18060	}
18061	if value == nil {
18062		return nil
18063	}
18064
18065	shape, ok := value.(map[string]interface{})
18066	if !ok {
18067		return fmt.Errorf("unexpected JSON type %v", value)
18068	}
18069
18070	var sv *ListPortfoliosForProductOutput
18071	if *v == nil {
18072		sv = &ListPortfoliosForProductOutput{}
18073	} else {
18074		sv = *v
18075	}
18076
18077	for key, value := range shape {
18078		switch key {
18079		case "NextPageToken":
18080			if value != nil {
18081				jtv, ok := value.(string)
18082				if !ok {
18083					return fmt.Errorf("expected PageToken to be of type string, got %T instead", value)
18084				}
18085				sv.NextPageToken = ptr.String(jtv)
18086			}
18087
18088		case "PortfolioDetails":
18089			if err := awsAwsjson11_deserializeDocumentPortfolioDetails(&sv.PortfolioDetails, value); err != nil {
18090				return err
18091			}
18092
18093		default:
18094			_, _ = key, value
18095
18096		}
18097	}
18098	*v = sv
18099	return nil
18100}
18101
18102func awsAwsjson11_deserializeOpDocumentListPortfoliosOutput(v **ListPortfoliosOutput, value interface{}) error {
18103	if v == nil {
18104		return fmt.Errorf("unexpected nil of type %T", v)
18105	}
18106	if value == nil {
18107		return nil
18108	}
18109
18110	shape, ok := value.(map[string]interface{})
18111	if !ok {
18112		return fmt.Errorf("unexpected JSON type %v", value)
18113	}
18114
18115	var sv *ListPortfoliosOutput
18116	if *v == nil {
18117		sv = &ListPortfoliosOutput{}
18118	} else {
18119		sv = *v
18120	}
18121
18122	for key, value := range shape {
18123		switch key {
18124		case "NextPageToken":
18125			if value != nil {
18126				jtv, ok := value.(string)
18127				if !ok {
18128					return fmt.Errorf("expected PageToken to be of type string, got %T instead", value)
18129				}
18130				sv.NextPageToken = ptr.String(jtv)
18131			}
18132
18133		case "PortfolioDetails":
18134			if err := awsAwsjson11_deserializeDocumentPortfolioDetails(&sv.PortfolioDetails, value); err != nil {
18135				return err
18136			}
18137
18138		default:
18139			_, _ = key, value
18140
18141		}
18142	}
18143	*v = sv
18144	return nil
18145}
18146
18147func awsAwsjson11_deserializeOpDocumentListPrincipalsForPortfolioOutput(v **ListPrincipalsForPortfolioOutput, value interface{}) error {
18148	if v == nil {
18149		return fmt.Errorf("unexpected nil of type %T", v)
18150	}
18151	if value == nil {
18152		return nil
18153	}
18154
18155	shape, ok := value.(map[string]interface{})
18156	if !ok {
18157		return fmt.Errorf("unexpected JSON type %v", value)
18158	}
18159
18160	var sv *ListPrincipalsForPortfolioOutput
18161	if *v == nil {
18162		sv = &ListPrincipalsForPortfolioOutput{}
18163	} else {
18164		sv = *v
18165	}
18166
18167	for key, value := range shape {
18168		switch key {
18169		case "NextPageToken":
18170			if value != nil {
18171				jtv, ok := value.(string)
18172				if !ok {
18173					return fmt.Errorf("expected PageToken to be of type string, got %T instead", value)
18174				}
18175				sv.NextPageToken = ptr.String(jtv)
18176			}
18177
18178		case "Principals":
18179			if err := awsAwsjson11_deserializeDocumentPrincipals(&sv.Principals, value); err != nil {
18180				return err
18181			}
18182
18183		default:
18184			_, _ = key, value
18185
18186		}
18187	}
18188	*v = sv
18189	return nil
18190}
18191
18192func awsAwsjson11_deserializeOpDocumentListProvisionedProductPlansOutput(v **ListProvisionedProductPlansOutput, value interface{}) error {
18193	if v == nil {
18194		return fmt.Errorf("unexpected nil of type %T", v)
18195	}
18196	if value == nil {
18197		return nil
18198	}
18199
18200	shape, ok := value.(map[string]interface{})
18201	if !ok {
18202		return fmt.Errorf("unexpected JSON type %v", value)
18203	}
18204
18205	var sv *ListProvisionedProductPlansOutput
18206	if *v == nil {
18207		sv = &ListProvisionedProductPlansOutput{}
18208	} else {
18209		sv = *v
18210	}
18211
18212	for key, value := range shape {
18213		switch key {
18214		case "NextPageToken":
18215			if value != nil {
18216				jtv, ok := value.(string)
18217				if !ok {
18218					return fmt.Errorf("expected PageToken to be of type string, got %T instead", value)
18219				}
18220				sv.NextPageToken = ptr.String(jtv)
18221			}
18222
18223		case "ProvisionedProductPlans":
18224			if err := awsAwsjson11_deserializeDocumentProvisionedProductPlans(&sv.ProvisionedProductPlans, value); err != nil {
18225				return err
18226			}
18227
18228		default:
18229			_, _ = key, value
18230
18231		}
18232	}
18233	*v = sv
18234	return nil
18235}
18236
18237func awsAwsjson11_deserializeOpDocumentListProvisioningArtifactsForServiceActionOutput(v **ListProvisioningArtifactsForServiceActionOutput, value interface{}) error {
18238	if v == nil {
18239		return fmt.Errorf("unexpected nil of type %T", v)
18240	}
18241	if value == nil {
18242		return nil
18243	}
18244
18245	shape, ok := value.(map[string]interface{})
18246	if !ok {
18247		return fmt.Errorf("unexpected JSON type %v", value)
18248	}
18249
18250	var sv *ListProvisioningArtifactsForServiceActionOutput
18251	if *v == nil {
18252		sv = &ListProvisioningArtifactsForServiceActionOutput{}
18253	} else {
18254		sv = *v
18255	}
18256
18257	for key, value := range shape {
18258		switch key {
18259		case "NextPageToken":
18260			if value != nil {
18261				jtv, ok := value.(string)
18262				if !ok {
18263					return fmt.Errorf("expected PageToken to be of type string, got %T instead", value)
18264				}
18265				sv.NextPageToken = ptr.String(jtv)
18266			}
18267
18268		case "ProvisioningArtifactViews":
18269			if err := awsAwsjson11_deserializeDocumentProvisioningArtifactViews(&sv.ProvisioningArtifactViews, value); err != nil {
18270				return err
18271			}
18272
18273		default:
18274			_, _ = key, value
18275
18276		}
18277	}
18278	*v = sv
18279	return nil
18280}
18281
18282func awsAwsjson11_deserializeOpDocumentListProvisioningArtifactsOutput(v **ListProvisioningArtifactsOutput, value interface{}) error {
18283	if v == nil {
18284		return fmt.Errorf("unexpected nil of type %T", v)
18285	}
18286	if value == nil {
18287		return nil
18288	}
18289
18290	shape, ok := value.(map[string]interface{})
18291	if !ok {
18292		return fmt.Errorf("unexpected JSON type %v", value)
18293	}
18294
18295	var sv *ListProvisioningArtifactsOutput
18296	if *v == nil {
18297		sv = &ListProvisioningArtifactsOutput{}
18298	} else {
18299		sv = *v
18300	}
18301
18302	for key, value := range shape {
18303		switch key {
18304		case "NextPageToken":
18305			if value != nil {
18306				jtv, ok := value.(string)
18307				if !ok {
18308					return fmt.Errorf("expected PageToken to be of type string, got %T instead", value)
18309				}
18310				sv.NextPageToken = ptr.String(jtv)
18311			}
18312
18313		case "ProvisioningArtifactDetails":
18314			if err := awsAwsjson11_deserializeDocumentProvisioningArtifactDetails(&sv.ProvisioningArtifactDetails, value); err != nil {
18315				return err
18316			}
18317
18318		default:
18319			_, _ = key, value
18320
18321		}
18322	}
18323	*v = sv
18324	return nil
18325}
18326
18327func awsAwsjson11_deserializeOpDocumentListRecordHistoryOutput(v **ListRecordHistoryOutput, value interface{}) error {
18328	if v == nil {
18329		return fmt.Errorf("unexpected nil of type %T", v)
18330	}
18331	if value == nil {
18332		return nil
18333	}
18334
18335	shape, ok := value.(map[string]interface{})
18336	if !ok {
18337		return fmt.Errorf("unexpected JSON type %v", value)
18338	}
18339
18340	var sv *ListRecordHistoryOutput
18341	if *v == nil {
18342		sv = &ListRecordHistoryOutput{}
18343	} else {
18344		sv = *v
18345	}
18346
18347	for key, value := range shape {
18348		switch key {
18349		case "NextPageToken":
18350			if value != nil {
18351				jtv, ok := value.(string)
18352				if !ok {
18353					return fmt.Errorf("expected PageToken to be of type string, got %T instead", value)
18354				}
18355				sv.NextPageToken = ptr.String(jtv)
18356			}
18357
18358		case "RecordDetails":
18359			if err := awsAwsjson11_deserializeDocumentRecordDetails(&sv.RecordDetails, value); err != nil {
18360				return err
18361			}
18362
18363		default:
18364			_, _ = key, value
18365
18366		}
18367	}
18368	*v = sv
18369	return nil
18370}
18371
18372func awsAwsjson11_deserializeOpDocumentListResourcesForTagOptionOutput(v **ListResourcesForTagOptionOutput, value interface{}) error {
18373	if v == nil {
18374		return fmt.Errorf("unexpected nil of type %T", v)
18375	}
18376	if value == nil {
18377		return nil
18378	}
18379
18380	shape, ok := value.(map[string]interface{})
18381	if !ok {
18382		return fmt.Errorf("unexpected JSON type %v", value)
18383	}
18384
18385	var sv *ListResourcesForTagOptionOutput
18386	if *v == nil {
18387		sv = &ListResourcesForTagOptionOutput{}
18388	} else {
18389		sv = *v
18390	}
18391
18392	for key, value := range shape {
18393		switch key {
18394		case "PageToken":
18395			if value != nil {
18396				jtv, ok := value.(string)
18397				if !ok {
18398					return fmt.Errorf("expected PageToken to be of type string, got %T instead", value)
18399				}
18400				sv.PageToken = ptr.String(jtv)
18401			}
18402
18403		case "ResourceDetails":
18404			if err := awsAwsjson11_deserializeDocumentResourceDetails(&sv.ResourceDetails, value); err != nil {
18405				return err
18406			}
18407
18408		default:
18409			_, _ = key, value
18410
18411		}
18412	}
18413	*v = sv
18414	return nil
18415}
18416
18417func awsAwsjson11_deserializeOpDocumentListServiceActionsForProvisioningArtifactOutput(v **ListServiceActionsForProvisioningArtifactOutput, value interface{}) error {
18418	if v == nil {
18419		return fmt.Errorf("unexpected nil of type %T", v)
18420	}
18421	if value == nil {
18422		return nil
18423	}
18424
18425	shape, ok := value.(map[string]interface{})
18426	if !ok {
18427		return fmt.Errorf("unexpected JSON type %v", value)
18428	}
18429
18430	var sv *ListServiceActionsForProvisioningArtifactOutput
18431	if *v == nil {
18432		sv = &ListServiceActionsForProvisioningArtifactOutput{}
18433	} else {
18434		sv = *v
18435	}
18436
18437	for key, value := range shape {
18438		switch key {
18439		case "NextPageToken":
18440			if value != nil {
18441				jtv, ok := value.(string)
18442				if !ok {
18443					return fmt.Errorf("expected PageToken to be of type string, got %T instead", value)
18444				}
18445				sv.NextPageToken = ptr.String(jtv)
18446			}
18447
18448		case "ServiceActionSummaries":
18449			if err := awsAwsjson11_deserializeDocumentServiceActionSummaries(&sv.ServiceActionSummaries, value); err != nil {
18450				return err
18451			}
18452
18453		default:
18454			_, _ = key, value
18455
18456		}
18457	}
18458	*v = sv
18459	return nil
18460}
18461
18462func awsAwsjson11_deserializeOpDocumentListServiceActionsOutput(v **ListServiceActionsOutput, value interface{}) error {
18463	if v == nil {
18464		return fmt.Errorf("unexpected nil of type %T", v)
18465	}
18466	if value == nil {
18467		return nil
18468	}
18469
18470	shape, ok := value.(map[string]interface{})
18471	if !ok {
18472		return fmt.Errorf("unexpected JSON type %v", value)
18473	}
18474
18475	var sv *ListServiceActionsOutput
18476	if *v == nil {
18477		sv = &ListServiceActionsOutput{}
18478	} else {
18479		sv = *v
18480	}
18481
18482	for key, value := range shape {
18483		switch key {
18484		case "NextPageToken":
18485			if value != nil {
18486				jtv, ok := value.(string)
18487				if !ok {
18488					return fmt.Errorf("expected PageToken to be of type string, got %T instead", value)
18489				}
18490				sv.NextPageToken = ptr.String(jtv)
18491			}
18492
18493		case "ServiceActionSummaries":
18494			if err := awsAwsjson11_deserializeDocumentServiceActionSummaries(&sv.ServiceActionSummaries, value); err != nil {
18495				return err
18496			}
18497
18498		default:
18499			_, _ = key, value
18500
18501		}
18502	}
18503	*v = sv
18504	return nil
18505}
18506
18507func awsAwsjson11_deserializeOpDocumentListStackInstancesForProvisionedProductOutput(v **ListStackInstancesForProvisionedProductOutput, value interface{}) error {
18508	if v == nil {
18509		return fmt.Errorf("unexpected nil of type %T", v)
18510	}
18511	if value == nil {
18512		return nil
18513	}
18514
18515	shape, ok := value.(map[string]interface{})
18516	if !ok {
18517		return fmt.Errorf("unexpected JSON type %v", value)
18518	}
18519
18520	var sv *ListStackInstancesForProvisionedProductOutput
18521	if *v == nil {
18522		sv = &ListStackInstancesForProvisionedProductOutput{}
18523	} else {
18524		sv = *v
18525	}
18526
18527	for key, value := range shape {
18528		switch key {
18529		case "NextPageToken":
18530			if value != nil {
18531				jtv, ok := value.(string)
18532				if !ok {
18533					return fmt.Errorf("expected PageToken to be of type string, got %T instead", value)
18534				}
18535				sv.NextPageToken = ptr.String(jtv)
18536			}
18537
18538		case "StackInstances":
18539			if err := awsAwsjson11_deserializeDocumentStackInstances(&sv.StackInstances, value); err != nil {
18540				return err
18541			}
18542
18543		default:
18544			_, _ = key, value
18545
18546		}
18547	}
18548	*v = sv
18549	return nil
18550}
18551
18552func awsAwsjson11_deserializeOpDocumentListTagOptionsOutput(v **ListTagOptionsOutput, value interface{}) error {
18553	if v == nil {
18554		return fmt.Errorf("unexpected nil of type %T", v)
18555	}
18556	if value == nil {
18557		return nil
18558	}
18559
18560	shape, ok := value.(map[string]interface{})
18561	if !ok {
18562		return fmt.Errorf("unexpected JSON type %v", value)
18563	}
18564
18565	var sv *ListTagOptionsOutput
18566	if *v == nil {
18567		sv = &ListTagOptionsOutput{}
18568	} else {
18569		sv = *v
18570	}
18571
18572	for key, value := range shape {
18573		switch key {
18574		case "PageToken":
18575			if value != nil {
18576				jtv, ok := value.(string)
18577				if !ok {
18578					return fmt.Errorf("expected PageToken to be of type string, got %T instead", value)
18579				}
18580				sv.PageToken = ptr.String(jtv)
18581			}
18582
18583		case "TagOptionDetails":
18584			if err := awsAwsjson11_deserializeDocumentTagOptionDetails(&sv.TagOptionDetails, value); err != nil {
18585				return err
18586			}
18587
18588		default:
18589			_, _ = key, value
18590
18591		}
18592	}
18593	*v = sv
18594	return nil
18595}
18596
18597func awsAwsjson11_deserializeOpDocumentProvisionProductOutput(v **ProvisionProductOutput, value interface{}) error {
18598	if v == nil {
18599		return fmt.Errorf("unexpected nil of type %T", v)
18600	}
18601	if value == nil {
18602		return nil
18603	}
18604
18605	shape, ok := value.(map[string]interface{})
18606	if !ok {
18607		return fmt.Errorf("unexpected JSON type %v", value)
18608	}
18609
18610	var sv *ProvisionProductOutput
18611	if *v == nil {
18612		sv = &ProvisionProductOutput{}
18613	} else {
18614		sv = *v
18615	}
18616
18617	for key, value := range shape {
18618		switch key {
18619		case "RecordDetail":
18620			if err := awsAwsjson11_deserializeDocumentRecordDetail(&sv.RecordDetail, value); err != nil {
18621				return err
18622			}
18623
18624		default:
18625			_, _ = key, value
18626
18627		}
18628	}
18629	*v = sv
18630	return nil
18631}
18632
18633func awsAwsjson11_deserializeOpDocumentRejectPortfolioShareOutput(v **RejectPortfolioShareOutput, value interface{}) error {
18634	if v == nil {
18635		return fmt.Errorf("unexpected nil of type %T", v)
18636	}
18637	if value == nil {
18638		return nil
18639	}
18640
18641	shape, ok := value.(map[string]interface{})
18642	if !ok {
18643		return fmt.Errorf("unexpected JSON type %v", value)
18644	}
18645
18646	var sv *RejectPortfolioShareOutput
18647	if *v == nil {
18648		sv = &RejectPortfolioShareOutput{}
18649	} else {
18650		sv = *v
18651	}
18652
18653	for key, value := range shape {
18654		switch key {
18655		default:
18656			_, _ = key, value
18657
18658		}
18659	}
18660	*v = sv
18661	return nil
18662}
18663
18664func awsAwsjson11_deserializeOpDocumentScanProvisionedProductsOutput(v **ScanProvisionedProductsOutput, value interface{}) error {
18665	if v == nil {
18666		return fmt.Errorf("unexpected nil of type %T", v)
18667	}
18668	if value == nil {
18669		return nil
18670	}
18671
18672	shape, ok := value.(map[string]interface{})
18673	if !ok {
18674		return fmt.Errorf("unexpected JSON type %v", value)
18675	}
18676
18677	var sv *ScanProvisionedProductsOutput
18678	if *v == nil {
18679		sv = &ScanProvisionedProductsOutput{}
18680	} else {
18681		sv = *v
18682	}
18683
18684	for key, value := range shape {
18685		switch key {
18686		case "NextPageToken":
18687			if value != nil {
18688				jtv, ok := value.(string)
18689				if !ok {
18690					return fmt.Errorf("expected PageToken to be of type string, got %T instead", value)
18691				}
18692				sv.NextPageToken = ptr.String(jtv)
18693			}
18694
18695		case "ProvisionedProducts":
18696			if err := awsAwsjson11_deserializeDocumentProvisionedProductDetails(&sv.ProvisionedProducts, value); err != nil {
18697				return err
18698			}
18699
18700		default:
18701			_, _ = key, value
18702
18703		}
18704	}
18705	*v = sv
18706	return nil
18707}
18708
18709func awsAwsjson11_deserializeOpDocumentSearchProductsAsAdminOutput(v **SearchProductsAsAdminOutput, value interface{}) error {
18710	if v == nil {
18711		return fmt.Errorf("unexpected nil of type %T", v)
18712	}
18713	if value == nil {
18714		return nil
18715	}
18716
18717	shape, ok := value.(map[string]interface{})
18718	if !ok {
18719		return fmt.Errorf("unexpected JSON type %v", value)
18720	}
18721
18722	var sv *SearchProductsAsAdminOutput
18723	if *v == nil {
18724		sv = &SearchProductsAsAdminOutput{}
18725	} else {
18726		sv = *v
18727	}
18728
18729	for key, value := range shape {
18730		switch key {
18731		case "NextPageToken":
18732			if value != nil {
18733				jtv, ok := value.(string)
18734				if !ok {
18735					return fmt.Errorf("expected PageToken to be of type string, got %T instead", value)
18736				}
18737				sv.NextPageToken = ptr.String(jtv)
18738			}
18739
18740		case "ProductViewDetails":
18741			if err := awsAwsjson11_deserializeDocumentProductViewDetails(&sv.ProductViewDetails, value); err != nil {
18742				return err
18743			}
18744
18745		default:
18746			_, _ = key, value
18747
18748		}
18749	}
18750	*v = sv
18751	return nil
18752}
18753
18754func awsAwsjson11_deserializeOpDocumentSearchProductsOutput(v **SearchProductsOutput, value interface{}) error {
18755	if v == nil {
18756		return fmt.Errorf("unexpected nil of type %T", v)
18757	}
18758	if value == nil {
18759		return nil
18760	}
18761
18762	shape, ok := value.(map[string]interface{})
18763	if !ok {
18764		return fmt.Errorf("unexpected JSON type %v", value)
18765	}
18766
18767	var sv *SearchProductsOutput
18768	if *v == nil {
18769		sv = &SearchProductsOutput{}
18770	} else {
18771		sv = *v
18772	}
18773
18774	for key, value := range shape {
18775		switch key {
18776		case "NextPageToken":
18777			if value != nil {
18778				jtv, ok := value.(string)
18779				if !ok {
18780					return fmt.Errorf("expected PageToken to be of type string, got %T instead", value)
18781				}
18782				sv.NextPageToken = ptr.String(jtv)
18783			}
18784
18785		case "ProductViewAggregations":
18786			if err := awsAwsjson11_deserializeDocumentProductViewAggregations(&sv.ProductViewAggregations, value); err != nil {
18787				return err
18788			}
18789
18790		case "ProductViewSummaries":
18791			if err := awsAwsjson11_deserializeDocumentProductViewSummaries(&sv.ProductViewSummaries, value); err != nil {
18792				return err
18793			}
18794
18795		default:
18796			_, _ = key, value
18797
18798		}
18799	}
18800	*v = sv
18801	return nil
18802}
18803
18804func awsAwsjson11_deserializeOpDocumentSearchProvisionedProductsOutput(v **SearchProvisionedProductsOutput, value interface{}) error {
18805	if v == nil {
18806		return fmt.Errorf("unexpected nil of type %T", v)
18807	}
18808	if value == nil {
18809		return nil
18810	}
18811
18812	shape, ok := value.(map[string]interface{})
18813	if !ok {
18814		return fmt.Errorf("unexpected JSON type %v", value)
18815	}
18816
18817	var sv *SearchProvisionedProductsOutput
18818	if *v == nil {
18819		sv = &SearchProvisionedProductsOutput{}
18820	} else {
18821		sv = *v
18822	}
18823
18824	for key, value := range shape {
18825		switch key {
18826		case "NextPageToken":
18827			if value != nil {
18828				jtv, ok := value.(string)
18829				if !ok {
18830					return fmt.Errorf("expected PageToken to be of type string, got %T instead", value)
18831				}
18832				sv.NextPageToken = ptr.String(jtv)
18833			}
18834
18835		case "ProvisionedProducts":
18836			if err := awsAwsjson11_deserializeDocumentProvisionedProductAttributes(&sv.ProvisionedProducts, value); err != nil {
18837				return err
18838			}
18839
18840		case "TotalResultsCount":
18841			if value != nil {
18842				jtv, ok := value.(json.Number)
18843				if !ok {
18844					return fmt.Errorf("expected TotalResultsCount to be json.Number, got %T instead", value)
18845				}
18846				i64, err := jtv.Int64()
18847				if err != nil {
18848					return err
18849				}
18850				sv.TotalResultsCount = int32(i64)
18851			}
18852
18853		default:
18854			_, _ = key, value
18855
18856		}
18857	}
18858	*v = sv
18859	return nil
18860}
18861
18862func awsAwsjson11_deserializeOpDocumentTerminateProvisionedProductOutput(v **TerminateProvisionedProductOutput, value interface{}) error {
18863	if v == nil {
18864		return fmt.Errorf("unexpected nil of type %T", v)
18865	}
18866	if value == nil {
18867		return nil
18868	}
18869
18870	shape, ok := value.(map[string]interface{})
18871	if !ok {
18872		return fmt.Errorf("unexpected JSON type %v", value)
18873	}
18874
18875	var sv *TerminateProvisionedProductOutput
18876	if *v == nil {
18877		sv = &TerminateProvisionedProductOutput{}
18878	} else {
18879		sv = *v
18880	}
18881
18882	for key, value := range shape {
18883		switch key {
18884		case "RecordDetail":
18885			if err := awsAwsjson11_deserializeDocumentRecordDetail(&sv.RecordDetail, value); err != nil {
18886				return err
18887			}
18888
18889		default:
18890			_, _ = key, value
18891
18892		}
18893	}
18894	*v = sv
18895	return nil
18896}
18897
18898func awsAwsjson11_deserializeOpDocumentUpdateConstraintOutput(v **UpdateConstraintOutput, value interface{}) error {
18899	if v == nil {
18900		return fmt.Errorf("unexpected nil of type %T", v)
18901	}
18902	if value == nil {
18903		return nil
18904	}
18905
18906	shape, ok := value.(map[string]interface{})
18907	if !ok {
18908		return fmt.Errorf("unexpected JSON type %v", value)
18909	}
18910
18911	var sv *UpdateConstraintOutput
18912	if *v == nil {
18913		sv = &UpdateConstraintOutput{}
18914	} else {
18915		sv = *v
18916	}
18917
18918	for key, value := range shape {
18919		switch key {
18920		case "ConstraintDetail":
18921			if err := awsAwsjson11_deserializeDocumentConstraintDetail(&sv.ConstraintDetail, value); err != nil {
18922				return err
18923			}
18924
18925		case "ConstraintParameters":
18926			if value != nil {
18927				jtv, ok := value.(string)
18928				if !ok {
18929					return fmt.Errorf("expected ConstraintParameters to be of type string, got %T instead", value)
18930				}
18931				sv.ConstraintParameters = ptr.String(jtv)
18932			}
18933
18934		case "Status":
18935			if value != nil {
18936				jtv, ok := value.(string)
18937				if !ok {
18938					return fmt.Errorf("expected Status to be of type string, got %T instead", value)
18939				}
18940				sv.Status = types.Status(jtv)
18941			}
18942
18943		default:
18944			_, _ = key, value
18945
18946		}
18947	}
18948	*v = sv
18949	return nil
18950}
18951
18952func awsAwsjson11_deserializeOpDocumentUpdatePortfolioOutput(v **UpdatePortfolioOutput, value interface{}) error {
18953	if v == nil {
18954		return fmt.Errorf("unexpected nil of type %T", v)
18955	}
18956	if value == nil {
18957		return nil
18958	}
18959
18960	shape, ok := value.(map[string]interface{})
18961	if !ok {
18962		return fmt.Errorf("unexpected JSON type %v", value)
18963	}
18964
18965	var sv *UpdatePortfolioOutput
18966	if *v == nil {
18967		sv = &UpdatePortfolioOutput{}
18968	} else {
18969		sv = *v
18970	}
18971
18972	for key, value := range shape {
18973		switch key {
18974		case "PortfolioDetail":
18975			if err := awsAwsjson11_deserializeDocumentPortfolioDetail(&sv.PortfolioDetail, value); err != nil {
18976				return err
18977			}
18978
18979		case "Tags":
18980			if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
18981				return err
18982			}
18983
18984		default:
18985			_, _ = key, value
18986
18987		}
18988	}
18989	*v = sv
18990	return nil
18991}
18992
18993func awsAwsjson11_deserializeOpDocumentUpdatePortfolioShareOutput(v **UpdatePortfolioShareOutput, value interface{}) error {
18994	if v == nil {
18995		return fmt.Errorf("unexpected nil of type %T", v)
18996	}
18997	if value == nil {
18998		return nil
18999	}
19000
19001	shape, ok := value.(map[string]interface{})
19002	if !ok {
19003		return fmt.Errorf("unexpected JSON type %v", value)
19004	}
19005
19006	var sv *UpdatePortfolioShareOutput
19007	if *v == nil {
19008		sv = &UpdatePortfolioShareOutput{}
19009	} else {
19010		sv = *v
19011	}
19012
19013	for key, value := range shape {
19014		switch key {
19015		case "PortfolioShareToken":
19016			if value != nil {
19017				jtv, ok := value.(string)
19018				if !ok {
19019					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
19020				}
19021				sv.PortfolioShareToken = ptr.String(jtv)
19022			}
19023
19024		case "Status":
19025			if value != nil {
19026				jtv, ok := value.(string)
19027				if !ok {
19028					return fmt.Errorf("expected ShareStatus to be of type string, got %T instead", value)
19029				}
19030				sv.Status = types.ShareStatus(jtv)
19031			}
19032
19033		default:
19034			_, _ = key, value
19035
19036		}
19037	}
19038	*v = sv
19039	return nil
19040}
19041
19042func awsAwsjson11_deserializeOpDocumentUpdateProductOutput(v **UpdateProductOutput, value interface{}) error {
19043	if v == nil {
19044		return fmt.Errorf("unexpected nil of type %T", v)
19045	}
19046	if value == nil {
19047		return nil
19048	}
19049
19050	shape, ok := value.(map[string]interface{})
19051	if !ok {
19052		return fmt.Errorf("unexpected JSON type %v", value)
19053	}
19054
19055	var sv *UpdateProductOutput
19056	if *v == nil {
19057		sv = &UpdateProductOutput{}
19058	} else {
19059		sv = *v
19060	}
19061
19062	for key, value := range shape {
19063		switch key {
19064		case "ProductViewDetail":
19065			if err := awsAwsjson11_deserializeDocumentProductViewDetail(&sv.ProductViewDetail, value); err != nil {
19066				return err
19067			}
19068
19069		case "Tags":
19070			if err := awsAwsjson11_deserializeDocumentTags(&sv.Tags, value); err != nil {
19071				return err
19072			}
19073
19074		default:
19075			_, _ = key, value
19076
19077		}
19078	}
19079	*v = sv
19080	return nil
19081}
19082
19083func awsAwsjson11_deserializeOpDocumentUpdateProvisionedProductOutput(v **UpdateProvisionedProductOutput, value interface{}) error {
19084	if v == nil {
19085		return fmt.Errorf("unexpected nil of type %T", v)
19086	}
19087	if value == nil {
19088		return nil
19089	}
19090
19091	shape, ok := value.(map[string]interface{})
19092	if !ok {
19093		return fmt.Errorf("unexpected JSON type %v", value)
19094	}
19095
19096	var sv *UpdateProvisionedProductOutput
19097	if *v == nil {
19098		sv = &UpdateProvisionedProductOutput{}
19099	} else {
19100		sv = *v
19101	}
19102
19103	for key, value := range shape {
19104		switch key {
19105		case "RecordDetail":
19106			if err := awsAwsjson11_deserializeDocumentRecordDetail(&sv.RecordDetail, value); err != nil {
19107				return err
19108			}
19109
19110		default:
19111			_, _ = key, value
19112
19113		}
19114	}
19115	*v = sv
19116	return nil
19117}
19118
19119func awsAwsjson11_deserializeOpDocumentUpdateProvisionedProductPropertiesOutput(v **UpdateProvisionedProductPropertiesOutput, value interface{}) error {
19120	if v == nil {
19121		return fmt.Errorf("unexpected nil of type %T", v)
19122	}
19123	if value == nil {
19124		return nil
19125	}
19126
19127	shape, ok := value.(map[string]interface{})
19128	if !ok {
19129		return fmt.Errorf("unexpected JSON type %v", value)
19130	}
19131
19132	var sv *UpdateProvisionedProductPropertiesOutput
19133	if *v == nil {
19134		sv = &UpdateProvisionedProductPropertiesOutput{}
19135	} else {
19136		sv = *v
19137	}
19138
19139	for key, value := range shape {
19140		switch key {
19141		case "ProvisionedProductId":
19142			if value != nil {
19143				jtv, ok := value.(string)
19144				if !ok {
19145					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
19146				}
19147				sv.ProvisionedProductId = ptr.String(jtv)
19148			}
19149
19150		case "ProvisionedProductProperties":
19151			if err := awsAwsjson11_deserializeDocumentProvisionedProductProperties(&sv.ProvisionedProductProperties, value); err != nil {
19152				return err
19153			}
19154
19155		case "RecordId":
19156			if value != nil {
19157				jtv, ok := value.(string)
19158				if !ok {
19159					return fmt.Errorf("expected Id to be of type string, got %T instead", value)
19160				}
19161				sv.RecordId = ptr.String(jtv)
19162			}
19163
19164		case "Status":
19165			if value != nil {
19166				jtv, ok := value.(string)
19167				if !ok {
19168					return fmt.Errorf("expected RecordStatus to be of type string, got %T instead", value)
19169				}
19170				sv.Status = types.RecordStatus(jtv)
19171			}
19172
19173		default:
19174			_, _ = key, value
19175
19176		}
19177	}
19178	*v = sv
19179	return nil
19180}
19181
19182func awsAwsjson11_deserializeOpDocumentUpdateProvisioningArtifactOutput(v **UpdateProvisioningArtifactOutput, value interface{}) error {
19183	if v == nil {
19184		return fmt.Errorf("unexpected nil of type %T", v)
19185	}
19186	if value == nil {
19187		return nil
19188	}
19189
19190	shape, ok := value.(map[string]interface{})
19191	if !ok {
19192		return fmt.Errorf("unexpected JSON type %v", value)
19193	}
19194
19195	var sv *UpdateProvisioningArtifactOutput
19196	if *v == nil {
19197		sv = &UpdateProvisioningArtifactOutput{}
19198	} else {
19199		sv = *v
19200	}
19201
19202	for key, value := range shape {
19203		switch key {
19204		case "Info":
19205			if err := awsAwsjson11_deserializeDocumentProvisioningArtifactInfo(&sv.Info, value); err != nil {
19206				return err
19207			}
19208
19209		case "ProvisioningArtifactDetail":
19210			if err := awsAwsjson11_deserializeDocumentProvisioningArtifactDetail(&sv.ProvisioningArtifactDetail, value); err != nil {
19211				return err
19212			}
19213
19214		case "Status":
19215			if value != nil {
19216				jtv, ok := value.(string)
19217				if !ok {
19218					return fmt.Errorf("expected Status to be of type string, got %T instead", value)
19219				}
19220				sv.Status = types.Status(jtv)
19221			}
19222
19223		default:
19224			_, _ = key, value
19225
19226		}
19227	}
19228	*v = sv
19229	return nil
19230}
19231
19232func awsAwsjson11_deserializeOpDocumentUpdateServiceActionOutput(v **UpdateServiceActionOutput, value interface{}) error {
19233	if v == nil {
19234		return fmt.Errorf("unexpected nil of type %T", v)
19235	}
19236	if value == nil {
19237		return nil
19238	}
19239
19240	shape, ok := value.(map[string]interface{})
19241	if !ok {
19242		return fmt.Errorf("unexpected JSON type %v", value)
19243	}
19244
19245	var sv *UpdateServiceActionOutput
19246	if *v == nil {
19247		sv = &UpdateServiceActionOutput{}
19248	} else {
19249		sv = *v
19250	}
19251
19252	for key, value := range shape {
19253		switch key {
19254		case "ServiceActionDetail":
19255			if err := awsAwsjson11_deserializeDocumentServiceActionDetail(&sv.ServiceActionDetail, value); err != nil {
19256				return err
19257			}
19258
19259		default:
19260			_, _ = key, value
19261
19262		}
19263	}
19264	*v = sv
19265	return nil
19266}
19267
19268func awsAwsjson11_deserializeOpDocumentUpdateTagOptionOutput(v **UpdateTagOptionOutput, value interface{}) error {
19269	if v == nil {
19270		return fmt.Errorf("unexpected nil of type %T", v)
19271	}
19272	if value == nil {
19273		return nil
19274	}
19275
19276	shape, ok := value.(map[string]interface{})
19277	if !ok {
19278		return fmt.Errorf("unexpected JSON type %v", value)
19279	}
19280
19281	var sv *UpdateTagOptionOutput
19282	if *v == nil {
19283		sv = &UpdateTagOptionOutput{}
19284	} else {
19285		sv = *v
19286	}
19287
19288	for key, value := range shape {
19289		switch key {
19290		case "TagOptionDetail":
19291			if err := awsAwsjson11_deserializeDocumentTagOptionDetail(&sv.TagOptionDetail, value); err != nil {
19292				return err
19293			}
19294
19295		default:
19296			_, _ = key, value
19297
19298		}
19299	}
19300	*v = sv
19301	return nil
19302}
19303